Faites une «exportation git» (comme «exportation svn»)?

Je me demandais s'il existe une bonne solution "git export" qui crée une copie d'une arborescence sans le .gitrépertoire du référentiel. Il y a au moins trois méthodes que je connais:

1. git clonesuivi de la suppression du .gitrépertoire du référentiel.
2. git checkout-index fait allusion à cette fonctionnalité mais commence par "Il suffit de lire l'arborescence souhaitée dans l'index ..." que je ne sais pas trop comment faire.
3. git-exportest un script tiers qui fait essentiellement un git clonedans un emplacement temporaire suivi de rsync --exclude='.git'la destination finale.

Aucune de ces solutions ne me semble vraiment satisfaisante. L' svn exportoption la plus proche pourrait être l'option 1, car les deux nécessitent que le répertoire cible soit vide en premier. Mais l'option 2 semble encore meilleure, en supposant que je puisse comprendre ce que signifie lire un arbre dans l'index.

Le moyen le plus simple d'y parvenir est probablement de git archive. Si vous avez vraiment besoin de l'arborescence développée, vous pouvez faire quelque chose comme ça.

git archive master | tar -x -C /somewhere/else

La plupart du temps, j'ai besoin d'exporter quelque chose de git, je veux en tout cas une archive compressée, donc je fais quelque chose comme ça.

git archive master | bzip2 >source-tree.tar.bz2

Archive ZIP:

git archive --format zip --output /full/path/to/zipfile.zip master 

git help archive pour plus de détails, c'est assez flexible.

Sachez que même si l'archive ne contiendra pas le répertoire .git, elle contiendra cependant d'autres fichiers spécifiques à git cachés comme .gitignore, .gitattributes, etc. Si vous ne les voulez pas dans l'archive, assurez-vous de utilisez l'attribut export-ignore dans un fichier .gitattributes et validez-le avant de faire votre archive. Lire la suite...

Remarque: si vous souhaitez exporter l'index, la commande est

git checkout-index -a -f --prefix=/destination/path/

(Voir la réponse de Greg pour plus de détails)

J'ai découvert ce que signifie l'option 2. À partir d'un référentiel, vous pouvez faire:

git checkout-index -a -f --prefix=/destination/path/

La barre oblique à la fin du chemin est importante, sinon elle entraînera que les fichiers se trouvent dans / destination avec un préfixe «chemin».

Comme dans une situation normale, l'index contient le contenu du référentiel, il n'y a rien de spécial à faire pour "lire l'arborescence souhaitée dans l'index". C'est déjà là.

Le -adrapeau est requis pour extraire tous les fichiers de l'index (je ne sais pas ce que cela signifie d'omettre ce drapeau dans cette situation, car il ne fait pas ce que je veux). L' -findicateur force l'écrasement de tous les fichiers existants dans la sortie, ce que cette commande ne fait normalement pas.

Cela semble être le genre de "git export" que je recherchais.

git archive fonctionne également avec le référentiel distant.

git archive --format=tar \
--remote=ssh://remote_server/remote_repository master | tar -xf -

Pour exporter un chemin particulier à l'intérieur du référentiel, ajoutez autant de chemins que vous le souhaitez comme dernier argument à git, par exemple:

git archive --format=tar \
--remote=ssh://remote_server/remote_repository master path1/ path2/ | tar -xv

Une réponse à un cas particulier si le référentiel est hébergé sur GitHub.

Utilisez simplement svn export.

Autant que je sache, Github ne le permet pas archive --remote. Bien que GitHub soit compatible svn et que tous les dépôts git soient svnaccessibles, vous pouvez simplement les utiliser svn exportcomme vous le feriez normalement avec quelques ajustements à votre URL GitHub.

Par exemple, pour exporter un référentiel entier, notez comment trunkdans l'URL remplace master(ou quel que soit le branchement HEAD du projet ):

svn export https://github.com/username/repo-name/trunk/

Et vous pouvez exporter un seul fichier ou même un certain chemin ou dossier:

svn export https://github.com/username/repo-name/trunk/src/lib/folder

Exemple avec la bibliothèque JavaScript jQuery

La HEADbranche ou maître branche sera disponible à l' aide trunk:

svn ls https://github.com/jquery/jquery/trunk

Les non- HEAD succursales seront accessibles sous /branches/:

svn ls https://github.com/jquery/jquery/branches/2.1-stable

Tous les tags sous /tags/de la même manière:

svn ls https://github.com/jquery/jquery/tags/2.1.3

Depuis le manuel Git :

Utiliser git-checkout-index pour "exporter un arbre entier"

La capacité de préfixe rend fondamentalement trivial l'utilisation de git-checkout-index comme une fonction "exportation sous forme d'arbre". Il suffit de lire l'arbre souhaité dans l'index et de faire:

$ git checkout-index --prefix=git-export-dir/ -a

J'ai écrit un simple wrapper git-checkout-indexque vous pouvez utiliser comme ceci:

git export ~/the/destination/dir

Si le répertoire de destination existe déjà, vous devrez ajouter -fou --force.

L'installation est simple; déposez simplement le script quelque part dans votre PATH, et assurez-vous qu'il est exécutable.

Le référentiel github pour git-export

Il semble que ce soit moins un problème avec Git qu'avec SVN. Git place uniquement un dossier .git dans la racine du référentiel, tandis que SVN place un dossier .svn dans chaque sous-répertoire. Donc, "svn export" évite la magie récursive en ligne de commande, alors qu'avec Git la récursivité n'est pas nécessaire.

L'équivalent de

svn export . otherpath

à l'intérieur d'un référentiel existant est

git archive branchname | (cd otherpath; tar x)

L'équivalent de

svn export url otherpath

est

git archive --remote=url branchname | (cd otherpath; tar x)

Si vous n'excluez pas de fichiers avec, .gitattributes export-ignoreessayezgit checkout

mkdir /path/to/checkout/
git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout -f -q

-f
Lors de l'extraction de chemins à partir de l'index, n'échouez pas lors des entrées non fusionnées; au lieu de cela, les entrées non fusionnées sont ignorées.

et

-q
Évitez verbeux

De plus, vous pouvez obtenir n'importe quelle branche ou étiquette ou à partir d'une révision de validation spécifique comme dans SVN en ajoutant simplement SHA1 (SHA1 dans Git est l'équivalent du numéro de révision dans SVN)

mkdir /path/to/checkout/
git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout 2ef2e1f2de5f3d4f5e87df7d8 -f -q -- ./

Le /path/to/checkout/doit être vide, Git ne supprimera aucun fichier, mais écrasera les fichiers du même nom sans aucun avertissement

MISE À JOUR: Pour éviter le problème décapité ou pour laisser intact le référentiel de travail lors de l'utilisation de la caisse pour l'exportation avec des balises, des branches ou SHA1, vous devez ajouter -- ./à la fin

Le double tiret --indique à git que tout ce qui se trouve après les tirets sont des chemins ou des fichiers, et dans ce cas, indique également git checkoutde ne pas modifier leHEAD

Exemples:

Cette commande obtiendra uniquement le répertoire libs et également le readme.txtfichier de ce commit

git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout fef2e1f2de5f3d4f5e87df7d8 -f -q -- ./libs ./docs/readme.txt

Cela va créer (écraser) my_file_2_behind_HEAD.txtdeux commits derrière la têteHEAD^2

git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout HEAD^2 -f -q -- ./my_file_2_behind_HEAD.txt

Pour obtenir l'exportation d'une autre branche

git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout myotherbranch -f -q -- ./

Notez que ./c'est relatif à la racine du référentiel

J'utilise largement les sous-modules git. Celui-ci fonctionne pour moi:

rsync -a ./FROM/ ./TO --exclude='.*'

J'ai souvent visité cette page lorsque je cherche un moyen d'exporter un référentiel git. Ma réponse à cette question considère trois propriétés que svn export a par conception par rapport à git, car svn suit une approche de référentiel centralisé:

• Il minimise le trafic vers un emplacement de référentiel distant en n'exportant pas toutes les révisions
• Il n'inclut pas de méta-informations dans le répertoire d'exportation

• L'exportation d'une certaine branche à l'aide de svn s'effectue en spécifiant le chemin approprié

  git clone --depth 1 --branch master git://git.somewhere destination_path
  rm -rf destination_path/.git
  

Lors de la construction d'une certaine version, il est utile de cloner une branche stable comme par exemple --branch stableou --branch release/0.9.

Cela copiera tout le contenu, moins les fichiers .dot. Je l'utilise pour exporter des projets git clonés dans le dépôt git de mon application Web sans les trucs .git.

cp -R ./path-to-git-repo / chemin / vers / destination /

Plain old bash fonctionne tout simplement :)

Aussi simple que cloner, supprimez le dossier .git:

git clone url_of_your_repo path_to_export && rm -rf path_to_export/.git

Pour les utilisateurs de GitHub, la git archive --remoteméthode ne fonctionnera pas directement, car l'URL d'exportation est éphémère . Vous devez demander l'URL à GitHub, puis télécharger cette URL. curlrend cela facile:

curl -L https://api.github.com/repos/VENDOR/PROJECT/tarball | tar xzf -

Cela vous donnera le code exporté dans un répertoire local. Exemple:

$ curl -L https://api.github.com/repos/jpic/bashworks/tarball | tar xzf -
$ ls jpic-bashworks-34f4441/
break  conf  docs  hack  LICENSE  mlog  module  mpd  mtests  os  README.rst  remote  todo  vcs  vps  wepcrack

Modifier
Si vous voulez que le code soit placé dans un répertoire spécifique existant (plutôt que dans le répertoire aléatoire de github):

curl -L https://api.github.com/repos/VENDOR/PROJECT/tarball | \
tar xzC /path/you/want --strip 1

Oui, c'est une commande propre et soigné pour archiver votre code sans inclusion git dans l'archive et il est bon de passer autour sans se soucier de toute git commit histoire.

git archive --format zip --output /full/path/to/zipfile.zip master 

Je veux juste souligner que dans le cas où vous êtes

1. exporter un sous-dossier du référentiel (c'est comme ça que j'utilisais la fonction d'exportation SVN)
2. êtes d'accord pour tout copier de ce dossier vers la destination de déploiement
3. et puisque vous avez déjà une copie de l'ensemble du référentiel en place.

Ensuite, vous pouvez simplement utiliser à la cp foo [destination]place de ce qui est mentionné git-archive master foo | -x -C [destination].

Vous pouvez archiver un dépôt à distance à tout commit en tant que fichier zip.

git archive --format=zip --output=archive.zip --remote=USERNAME@HOSTNAME:PROJECTNAME.git HASHOFGITCOMMIT

Bash-implémentation de git-export.

J'ai segmenté les processus de création et de suppression de fichiers .empty sur leur propre fonction, dans le but de les réutiliser dans l'implémentation de 'git-archive' (sera publié plus tard).

J'ai également ajouté le fichier «.gitattributes» au processus afin de supprimer les fichiers indésirables du dossier d'exportation cible. Inclus la verbosité du processus tout en rendant la fonction 'git-export' plus efficace.

EMPTY_FILE = ". Empty";

function create_empty () {
## Processing path (target-dir):
    TRG_PATH="${1}";
## Component(s):
    EXCLUDE_DIR=".git";
echo -en "\nAdding '${EMPTY_FILE}' files to empty folder(s): ...";
    find ${TRG_PATH} -not -path "*/${EXCLUDE_DIR}/*" -type d -empty -exec touch {}/${EMPTY_FILE} \;
#echo "done.";
## Purging SRC/TRG_DIRs variable(s):
    unset TRG_PATH EMPTY_FILE EXCLUDE_DIR;
    return 0;
  }

declare -a GIT_EXCLUDE;
function load_exclude () {
    SRC_PATH="${1}";
    ITEMS=0; while read LINE; do
#      echo -e "Line [${ITEMS}]: '${LINE%%\ *}'";
      GIT_EXCLUDE[((ITEMS++))]=${LINE%%\ *};
    done < ${SRC_PATH}/.gitattributes;
    GIT_EXCLUDE[${ITEMS}]="${EMPTY_FILE}";
## Purging variable(s):
    unset SRC_PATH ITEMS;
    return 0;
  }

function purge_empty () {
## Processing path (Source/Target-dir):
    SRC_PATH="${1}";
    TRG_PATH="${2}";
echo -e "\nPurging Git-Specific component(s): ... ";
    find ${SRC_PATH} -type f -name ${EMPTY_FILE} -exec /bin/rm '{}' \;
    for xRULE in ${GIT_EXCLUDE[@]}; do
echo -en "    '${TRG_PATH}/{${xRULE}}' files ... ";
      find ${TRG_PATH} -type f -name "${xRULE}" -exec /bin/rm -rf '{}' \;
echo "done.'";
    done;
echo -e "done.\n"
## Purging SRC/TRG_PATHs variable(s):
    unset SRC_PATH; unset TRG_PATH;
    return 0;
  }

function git-export () {
    TRG_DIR="${1}"; SRC_DIR="${2}";
    if [ -z "${SRC_DIR}" ]; then SRC_DIR="${PWD}"; fi
    load_exclude "${SRC_DIR}";
## Dynamically added '.empty' files to the Git-Structure:
    create_empty "${SRC_DIR}";
    GIT_COMMIT="Including '${EMPTY_FILE}' files into Git-Index container."; #echo -e "\n${GIT_COMMIT}";
    git add .; git commit --quiet --all --verbose --message "${GIT_COMMIT}";
    if [ "${?}" -eq 0 ]; then echo " done."; fi
    /bin/rm -rf ${TRG_DIR} && mkdir -p "${TRG_DIR}";
echo -en "\nChecking-Out Index component(s): ... ";
    git checkout-index --prefix=${TRG_DIR}/ -q -f -a
## Reset: --mixed = reset HEAD and index:
    if [ "${?}" -eq 0 ]; then
echo "done."; echo -en "Resetting HEAD and Index: ... ";
        git reset --soft HEAD^;
        if [ "${?}" -eq 0 ]; then
echo "done.";
## Purging Git-specific components and '.empty' files from Target-Dir:
            purge_empty "${SRC_DIR}" "${TRG_DIR}"
          else echo "failed.";
        fi
## Archiving exported-content:
echo -en "Archiving Checked-Out component(s): ... ";
        if [ -f "${TRG_DIR}.tgz" ]; then /bin/rm ${TRG_DIR}.tgz; fi
        cd ${TRG_DIR} && tar -czf ${TRG_DIR}.tgz ./; cd ${SRC_DIR}
echo "done.";
## Listing *.tgz file attributes:
## Warning: Un-TAR this file to a specific directory:
        ls -al ${TRG_DIR}.tgz
      else echo "failed.";
    fi
## Purgin all references to Un-Staged File(s):
   git reset HEAD;
## Purging SRC/TRG_DIRs variable(s):
    unset SRC_DIR; unset TRG_DIR;
    echo "";
    return 0;
  }

Production:

$ git-export /tmp/rel-1.0.0

Ajout de fichiers «.empty» à des dossiers vides: ... terminé.

Extraction des composants de l'index: ... terminé.

Réinitialisation de HEAD et Index: ... terminé.

Purge des composants spécifiques à Git: ...

'/tmp/rel-1.0.0/{.buildpath}' fichiers ... terminé. '

'/tmp/rel-1.0.0/{.project}' fichiers ... terminé. '

'/tmp/rel-1.0.0/{.gitignore}' fichiers ... terminé. '

'/tmp/rel-1.0.0/{.git}' fichiers ... terminé. '

'/tmp/rel-1.0.0/{.gitattributes}' fichiers ... terminé. '

'/tmp/rel-1.0.0/{*.mno}' fichiers ... terminé. '

'/tmp/rel-1.0.0/{*~}' fichiers ... terminé. '

'/tmp/rel-1.0.0/{.*~}' fichiers ... terminé. '

'/tmp/rel-1.0.0/{*.swp}' fichiers ... terminé. '

'/tmp/rel-1.0.0/{*.swo}' fichiers ... terminé. '

'/tmp/rel-1.0.0/{.DS_Store}' fichiers ... terminé. '

'/tmp/rel-1.0.0/{.settings}' fichiers ... terminé. '

'/tmp/rel-1.0.0/{.empty}' fichiers ... terminé. '

terminé.

Archivage des composants extraits: ... terminé.

-rw-r - r-- 1 roue d'administration 25445901 3 nov 12:57 /tmp/rel-1.0.0.tgz

J'ai maintenant intégré la fonctionnalité 'git archive' dans un processus unique qui utilise la fonction 'create_empty' et d'autres fonctionnalités.

function git-archive () {
    PREFIX="${1}"; ## sudo mkdir -p ${PREFIX}
    REPO_PATH="`echo "${2}"|awk -F: '{print $1}'`";
    RELEASE="`echo "${2}"|awk -F: '{print $2}'`";
    USER_PATH="${PWD}";
echo "$PREFIX $REPO_PATH $RELEASE $USER_PATH";
## Dynamically added '.empty' files to the Git-Structure:
    cd "${REPO_PATH}"; populate_empty .; echo -en "\n";
#    git archive --prefix=git-1.4.0/ -o git-1.4.0.tar.gz v1.4.0
# e.g.: git-archive /var/www/htdocs /repos/domain.name/website:rel-1.0.0 --explode
    OUTPUT_FILE="${USER_PATH}/${RELEASE}.tar.gz";
    git archive --verbose --prefix=${PREFIX}/ -o ${OUTPUT_FILE} ${RELEASE}
    cd "${USER_PATH}";
    if [[ "${3}" =~ [--explode] ]]; then
      if [ -d "./${RELEASE}" ]; then /bin/rm -rf "./${RELEASE}"; fi
      mkdir -p ./${RELEASE}; tar -xzf "${OUTPUT_FILE}" -C ./${RELEASE}
    fi
## Purging SRC/TRG_DIRs variable(s):
    unset PREFIX REPO_PATH RELEASE USER_PATH OUTPUT_FILE;
    return 0;
  }

Si vous voulez quelque chose qui fonctionne avec des sous-modules, cela pourrait valoir le coup.

Remarque:

• MASTER_DIR = un paiement avec vos sous-modules récupérés également
• DEST_DIR = où se terminera cette exportation
• Si vous avez rsync, je pense que vous pourriez faire la même chose avec encore moins de maux de balle.

Hypothèses:

• Vous devez l'exécuter à partir du répertoire parent de MASTER_DIR (c'est-à-dire à partir de MASTER_DIR cd ..)
• DEST_DIR est supposé avoir été créé. C'est assez facile à modifier pour inclure la création d'un DEST_DIR si vous voulez

cd MASTER_DIR && tar -zcvf ../DEST_DIR/export.tar.gz --exclude = '. git *'. && cd ../DEST_DIR/ && tar xvfz export.tar.gz && rm export.tar.gz

Ma préférence serait en fait d'avoir une cible dist dans votre Makefile (ou autre système de build) qui exporte une archive distribuable de votre code (.tar.bz2, .zip, .jar, ou tout ce qui est approprié). S'il vous arrive d'utiliser des outils automatiques GNU ou les systèmes MakeMaker de Perl, je pense que cela existe automatiquement pour vous. Sinon, je recommande fortement de l'ajouter.

ETA (2012-09-06): Wow, des downvotes sévères. Je pense toujours qu'il vaut mieux construire vos distributions avec vos outils de build plutôt qu'avec votre outil de contrôle de code source. Je crois en la construction d'artefacts avec des outils de construction. Dans mon travail actuel, notre produit principal est construit avec une cible de fourmi. Nous sommes en train de changer de système de contrôle de code source, et la présence de cette cible de fourmi signifie un tracas de migration en moins.

Cela copiera les fichiers dans une plage de validations (C à G) dans un fichier tar. Remarque: cela ne fera que valider les fichiers. Pas l'intégralité du référentiel. Légèrement modifié d' ici

Exemple d'historique de validation

A -> B -> C -> D -> E -> F -> G -> H -> I

git diff-tree -r --no-commit-id --name-only --diff-filter=ACMRT C~..G | xargs tar -rf myTarFile.tar

Page de manuel de git-diff-tree

-r -> recurse dans les sous-arbres

--no-commit-id -> git diff-tree affiche une ligne avec l'ID de validation le cas échéant. Cet indicateur a supprimé la sortie de l'ID de validation.

--name-only -> Afficher uniquement les noms des fichiers modifiés.

--diff-filter = ACMRT -> Sélectionnez uniquement ces fichiers. Voir ici pour la liste complète des fichiers

C..G -> Fichiers dans cette gamme de commits

C ~ -> Inclure les fichiers de Commit C. Pas seulement les fichiers depuis Commit C.

| xargs tar -rf myTarFile -> sorties vers tar

Si je comprends bien la question, il s'agit davantage de télécharger uniquement un certain état du serveur, sans historique et sans données d'autres branches, plutôt que d'extraire un état d'un référentiel local (comme le font de nombreuses réponses ici).

Cela peut se faire comme ceci:

git clone -b someBranch --depth 1 --single-branch git://somewhere.com/repo.git \
&& rm -rf repo/.git/

• --single-branch est disponible depuis Git 1.7.10 (avril 2012).
• --depthest (était?) censément défectueux, mais dans le cas d'une exportation, les problèmes mentionnés ne devraient pas avoir d'importance.

J'en avais besoin pour un script de déploiement et je ne pouvais utiliser aucune des approches mentionnées ci-dessus. Au lieu de cela, j'ai trouvé une solution différente:

#!/bin/sh
[ $# -eq 2 ] || echo "USAGE $0 REPOSITORY DESTINATION" && exit 1
REPOSITORY=$1
DESTINATION=$2
TMPNAME="/tmp/$(basename $REPOSITORY).$$"
git clone $REPOSITORY $TMPNAME
rm -rf $TMPNAME/.git
mkdir -p $DESTINATION
cp -r $TMPNAME/* $DESTINATION
rm -rf $TMPNAME

En le faisant facilement, c'est une fonction pour .bash_profile, il décompresse directement l'archive sur l'emplacement actuel, configurez d'abord votre [url: chemin] habituel. REMARQUE: Avec cette fonction, vous évitez l'opération de clonage, elle provient directement du référentiel distant.

gitss() {
    URL=[url:path]

    TMPFILE="`/bin/tempfile`"
    if [ "$1" = "" ]; then
        echo -e "Use: gitss repo [tree/commit]\n"
        return
    fi
    if [ "$2" = "" ]; then
        TREEISH="HEAD"
    else
        TREEISH="$2"
    fi
    echo "Getting $1/$TREEISH..."
    git archive --format=zip --remote=$URL/$1 $TREEISH > $TMPFILE && unzip $TMPFILE && echo -e "\nDone\n"
    rm $TMPFILE
}

Alias ​​pour .gitconfig, même configuration requise (PRENEZ SOIN d'exécuter la commande à l'intérieur des projets .git, il saute TOUJOURS au répertoire de base précédemment comme indiqué ici , jusqu'à ce que ce soit corrigé, je préfère personnellement la fonction

ss = !env GIT_TMPFILE="`/bin/tempfile`" sh -c 'git archive --format=zip --remote=[url:path]/$1 $2 \ > $GIT_TMPFILE && unzip $GIT_TMPFILE && rm $GIT_TMPFILE' -

De loin, la façon la plus simple que j'ai vue de le faire (et fonctionne également sur Windows) est git bundle:

git bundle create /some/bundle/path.bundle --all

Voir cette réponse pour plus de détails: Comment puis-je copier mon référentiel git de ma machine Windows vers une machine Linux via un lecteur USB?

J'ai une autre solution qui fonctionne bien si vous avez une copie locale du référentiel sur la machine où vous souhaitez créer l'exportation. Dans ce cas, accédez à ce répertoire de référentiel et entrez cette commande:

GIT_WORK_TREE=outputdirectory git checkout -f

Cela est particulièrement utile si vous gérez un site Web avec un référentiel git et souhaitez extraire une version propre dans /var/www/. Dans ce cas, ajoutez cette commande dans un .git/hooks/post-receivescript ( hooks/post-receivesur un référentiel nu, ce qui est plus approprié dans cette situation)

Je pense que le message de @Aredridel était le plus proche, mais il y a un peu plus - je vais donc ajouter ceci ici; la chose est, dans svn, si vous êtes dans un sous-dossier d'un repo, et vous faites:

/media/disk/repo_svn/subdir$ svn export . /media/disk2/repo_svn_B/subdir

puis svnexportera tous les fichiers qui sont sous contrôle de révision (ils pourraient également avoir été récemment ajoutés; ou état modifié) - et si vous avez d'autres "ordures" dans ce répertoire (et je ne compte pas les .svnsous-dossiers ici, mais des choses visibles comme des .ofichiers) , il ne sera pas exporté; seuls les fichiers enregistrés par le dépôt SVN seront exportés. Pour moi, une bonne chose est que cette exportation inclut également des fichiers avec des modifications locales qui n'ont pas encore été validées; et une autre bonne chose est que les horodatages des fichiers exportés sont les mêmes que ceux d'origine. Ou, comme le svn help exportdit:

2. Exporte une arborescence de répertoires propre de la copie de travail spécifiée par PATH1, à la révision REV si elle est donnée, sinon à WORKING, dans PATH2. ... Si REV n'est pas spécifié, toutes les modifications locales seront conservées. Les fichiers qui ne sont pas sous contrôle de version ne seront pas copiés.

Pour réaliser que gitcela ne préservera pas les horodatages, comparez la sortie de ces commandes (dans un sous-dossier d'un gitdépôt de votre choix):

/media/disk/git_svn/subdir$ ls -la .

... et:

/media/disk/git_svn/subdir$ git archive --format=tar --prefix=junk/ HEAD | (tar -t -v --full-time -f -)

... et je remarque en tout cas que git archivetous les horodatages du fichier archivé sont identiques! git help archivedit:

git archive se comporte différemment quand on lui donne un ID d'arbre par rapport à quand on lui donne un ID de commit ou un ID de tag. Dans le premier cas, l'heure actuelle est utilisée comme heure de modification de chaque fichier de l'archive. Dans ce dernier cas, le temps de validation enregistré dans l'objet de validation référencé est utilisé à la place.

... mais apparemment les deux cas fixent le "temps de modification de chaque fichier"; donc pas préservant les horodatages réels de ces fichiers!

Donc, afin de préserver également les horodatages, voici un bashscript, qui est en fait un "one-liner", quoique quelque peu compliqué - donc ci-dessous il est affiché sur plusieurs lignes:

/media/disk/git_svn/subdir$ git archive --format=tar master | (tar tf -) | (\
  DEST="/media/diskC/tmp/subdirB"; \
  CWD="$PWD"; \
  while read line; do \
    DN=$(dirname "$line"); BN=$(basename "$line"); \
    SRD="$CWD"; TGD="$DEST"; \
    if [ "$DN" != "." ]; then \
      SRD="$SRD/$DN" ; TGD="$TGD/$DN" ; \
      if [ ! -d "$TGD" ] ; then \
        CMD="mkdir \"$TGD\"; touch -r \"$SRD\" \"$TGD\""; \
        echo "$CMD"; \
        eval "$CMD"; \
      fi; \
    fi; \
    CMD="cp -a \"$SRD/$BN\" \"$TGD/\""; \
    echo "$CMD"; \
    eval "$CMD"; \
    done \
)

Notez que l'on suppose que vous exportez le contenu dans le répertoire "actuel" (ci-dessus, /media/disk/git_svn/subdir) - et que la destination dans laquelle vous exportez est quelque peu gênante, mais elle est dans DESTla variable d'environnement. Notez qu'avec ce script; vous devez créer leDEST répertoire manuellement vous-même, avant d'exécuter le script ci-dessus.

Une fois le script exécuté, vous devriez pouvoir comparer:

ls -la /media/disk/git_svn/subdir
ls -la /media/diskC/tmp/subdirB   # DEST

... et j'espère voir les mêmes horodatages (pour les fichiers qui étaient sous contrôle de version).

J'espère que cela aide quelqu'un,
Cheers!

une exportation git vers une archive zip tout en ajoutant un préfixe (par exemple le nom du répertoire):

git archive master --prefix=directoryWithinZip/  --format=zip -o out.zip

Si vous avez également besoin de sous-modules, cela devrait faire l'affaire: https://github.com/meitar/git-archive-all.sh/wiki

j'ai la fonction utilitaire suivante dans mon fichier .bashrc: il crée une archive de la branche actuelle dans un référentiel git.

function garchive()
{
  if [[ "x$1" == "x-h" || "x$1" == "x" ]]; then
    cat <<EOF
Usage: garchive <archive-name>
create zip archive of the current branch into <archive-name>
EOF
  else
    local oname=$1
    set -x
    local bname=$(git branch | grep -F "*" | sed -e 's#^*##')
    git archive --format zip --output ${oname} ${bname}
    set +x
  fi
}