Faire un "git export" (comme "svn export")?

je me demande s'il existe une bonne solution" git export "qui crée une copie d'un arbre sans le répertoire de dépôt .git . Il y a au moins trois méthodes que je connais:

  1. git clone suivi de la suppression du répertoire .git .
  2. git checkout-index fait allusion à cette fonctionnalité mais commence par "il suffit de lire l'arbre désiré dans l'index..."dont je ne suis pas tout à fait sûr comment faire.
  3. git-export est un script tiers qui fait essentiellement un git clone dans un emplacement temporaire suivi de rsync --exclude='.git' dans la destination finale.

aucune de ces solutions ne me semble vraiment satisfaisante. La plus proche de svn export pourrait être l'option 1, car toutes deux requièrent que le répertoire cible soit vide en premier. Mais l'option 2 semble encore mieux, en supposant que je peux comprendre ce que cela signifie pour lire un arbre dans l'index.

2185
demandé sur Peter O. 2008-10-02 06:21:33

30 réponses

probablement le moyen le plus simple pour y arriver est avec git archive . Si vous avez vraiment besoin juste de l'arbre étendu, vous pouvez faire quelque chose comme ça.

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

la plupart du temps que je dois "exporter" quelque chose de git, je veux une archive compressée dans tous les cas donc je fais quelque chose comme ça.

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

ZIP archive:

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

git help archive pour plus les détails, c'est tout à fait flexible.


soyez conscient que même si l'archive ne contiendra pas le .git directory, il contiendra cependant d'autres fichiers git spécifiques comme.gitignore,.gitattributes, etc. Si vous ne voulez pas dans l'archive, assurez-vous d'utiliser l'export-ignore l'attribut dans un .gitattributes file et commit ceci avant de faire votre archive. lire la suite...


Remarque: Si vous êtes intéressé par l'exportation de l'index, la commande est

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

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

2216
répondu CB Bailey 2018-05-29 10:10:20

j'ai trouvé ce que signifie l'option 2. À partir d'un dépôt, vous pouvez faire:

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

la barre oblique à la fin du chemin est importante, sinon il en résultera que les fichiers seront dans /destination avec un préfixe de 'chemin'.

puisque dans une situation normale l'index contient le contenu du dépôt, il n'y a rien de spécial à faire pour"lire l'arbre désiré dans l'index". C'est déjà là.

le -a flag est nécessaire pour vérifier tous les fichiers dans l'index (Je ne suis pas sûr de ce que cela signifie d'omettre ce flag dans cette situation, car il ne fait pas ce que je veux). Les forces du drapeau -f écrasent tous les fichiers existants dans la sortie, ce que cette commande ne fait pas normalement.

c'est le genre de" git export " que je cherchais.

304
répondu Greg Hewgill 2012-05-23 15:55:15

git archive fonctionne également avec un dépôt à distance.

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

pour exporter un chemin particulier à l'intérieur du repo ajouter 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
242
répondu Aleksandr Somov 2014-06-23 19:01:01

enter image description here

une réponse spéciale si le dépôt est hébergé sur GitHub.

il suffit d'utiliser svn export .

autant que je sache, Github n'autorise pas archive --remote . Bien que GitHub soit compatible svn et ils ont tous les repos git svn accessible de sorte que vous pouvez juste utiliser svn export comme vous le feriez normalement avec quelques ajustements à votre url GitHub.

par exemple, pour exporter un dépôt entier, notez que trunk dans L'URL remplace master (ou n'importe quel autre la branche principale du projet est définie à ):

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 bibliothèque JavaScript jQuery

la branche HEAD ou maître de la branche seront disponibles à l'aide de trunk :

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

non HEAD branches seront accessibles dans la rubrique /branches/ :

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

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

svn ls https://github.com/jquery/jquery/tags/2.1.3
50
répondu Anthony Hatzopoulos 2017-01-18 15:13:04

De la Git Manuel :

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

la capacité de préfixe le rend fondamentalement trivial d'utiliser git-checkout-index comme une fonction" export as tree". Il suffit de lire l'arbre désiré dans l'index, et faire:

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

38
répondu jperras 2008-10-02 02:27:07

j'ai écrit un emballage simple autour de git-checkout-index que vous pouvez utiliser comme ceci:

git export ~/the/destination/dir

si le répertoire de destination existe déjà, vous devrez ajouter -f ou --force .

L'Installation de

est simple; il suffit de laisser tomber le script quelque part dans votre PATH , et assurez-vous qu'il est exécutable.

le dépôt github pour git-export

37
répondu Daniel Schierbeck 2008-10-16 17:17:00

il semble que ce soit moins un problème avec Git que SVN. Git ne met qu'un .git folder dans la racine du dépôt, alors que SVN puts a.svn dossier dans chaque sous-répertoire. Ainsi, "svn export" évite la magie de ligne de commande récursive, alors qu'avec Git recursion n'est pas nécessaire.

35
répondu kostmo 2009-05-12 04:20:24

l'équivalent de

svn export . otherpath

à l'intérieur d'un repo 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)
26
répondu aredridel 2012-02-23 15:41:55

j'utilise git-submodules intensivement. Celui-ci travaille pour moi:

rsync -a ./FROM/ ./TO --exclude='.*'
21
répondu slatvick 2011-09-13 06:26:03

si vous n'excluez pas les fichiers avec .gitattributes export-ignore alors essayez git checkout

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

- f

Lors de la vérification des chemins à partir de l'index, ne manquez pas entrées; au lieu de cela, les entrées non fusionnées sont ignorées.

et

- q

Évitez les bavardages

De plus, vous pouvez obtenir n'importe quelle branche ou étiquette ou à partir d'une révision de Commit 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 avec le même nom sans avertissement

mise à jour: Pour éviter le problème décapité ou pour laisser intact le dépôt de travail lors de l'utilisation checkout pour l'exportation avec des étiquettes, branches ou SHA1, vous devez ajouter -- ./ à la fin

La double dash -- indique à git que tout ce qui est après les tirets sont des chemins d'accès ou des fichiers, et aussi dans ce cas dit git checkout de ne pas modifier le HEAD

exemples:

cette commande ne récupérera que le répertoire libs et aussi le fichier readme.txt à partir de celui-là même commit

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

ce sera créer(écraser) my_file_2_behind_HEAD.txt deux s'engage derrière la tête HEAD^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 de l'exportation d'une autre branche

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

notez que ./ est relatif à la racine du dépôt

20
répondu user5286776117878 2018-01-10 15:45:19

cela copiera tout le contenu, moins le .dot fichiers. Je m'en sers pour exporter des projets git clonés dans le repo git de mon application web sans le .git choses.

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

Plain old bash fonctionne tout simplement génial :)

16
répondu Harmon 2010-12-10 17:17:49

j'ai souvent consulté cette page lorsque je cherche un moyen d'exporter un dépôt git. Ma réponse à cette question porte sur trois propriétés que svn export possède par conception par rapport à git, puisque svn utilise une approche de dépôt centralisé:

  • il minimise le trafic vers un dépôt à distance en n'exportant pas toutes les révisions
  • il n'inclut pas les méta-informations dans le répertoire d'exportation
  • exporter une certaine branche en utilisant svn est réalisé en spécifiant le chemin approprié

    git clone --depth 1 --branch master git://git.somewhere destination_path
    rm -rf destination_path/.git
    
"151930920 Lors de la construction d'une certaine libération, il est utile de cloner une branche stable comme par exemple --branch stable ou --branch release/0.9 .

16
répondu Lars Schillingmann 2012-01-22 17:31:47

aussi simple que clone puis supprimer le .dossier git:

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

11
répondu teleme.io 2013-09-27 19:35:10

je veux juste souligner que, dans le cas que vous êtes

  1. exporter un sous-dossier du dépôt (c'est ainsi que J'utilisais SVN export feature)
  2. sont D'accord pour copier tout de ce dossier à la destination de déploiement
  3. et puisque vous avez déjà une copie du dépôt entier en place.

alors vous pouvez simplement utiliser cp foo [destination] au lieu de la mention git-archive master foo | -x -C [destination] .

10
répondu dkinzer 2010-10-29 13:51:08

pour les utilisateurs de GitHub, la méthode git archive --remote ne fonctionnera pas directement, comme L'URL d'exportation est éphémère . Vous devez demander à GitHub L'URL, puis télécharger cette URL. curl qui 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 mettre le code un répertoire spécifique, existant (plutôt que le répertoire aléatoire de github):

curl -L https://api.github.com/repos/VENDOR/PROJECT/tarball | \
tar xzC /path/you/want --strip 1
10
répondu bishop 2014-08-05 13:24:42

vous pouvez archiver un repo distant à n'importe quelle propagation en fichier zip.

git archive --format=zip --output=archive.zip --remote=USERNAME@HOSTNAME:PROJECTNAME.git HASHOFGITCOMMIT
9
répondu orkoden 2012-10-09 13:49:55

Oui, ce est propre et soigné commande pour archiver votre code sans git inclusion dans l'archive et il est bon de passer sans s'inquiéter du git commit l'histoire.

git archive --format zip --output /full/path/to/zipfile.zip master 
9
répondu zeeawan 2017-05-23 12:26:34

Bash-la mise en œuvre de git-export.

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

j'ai aussi ajouté le".gitattributes' fichier pour le processus afin de supprimer l'onu voulu des fichiers à partir de la cible du dossier d'exportation. Verbosité incluse au processus tout en rendant la fonction "git-export" plus efficace.

EMPTY_FILE=".vide";

function create_empty () {
## Processing path (target-dir):
    TRG_PATH="";
## 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="";
    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="";
    TRG_PATH="";
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=""; SRC_DIR="";
    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;
  }

sortie:

$ git-export /tmp/rel-1.0.0

Adding'.vide " fichiers de dossier vide(s): ... faire.

composant(s) de L'indice de contrôle: ... faire.

tête de réinitialisation et Index:... faire.

Purge Git-composant Spécifique(s): ...

'/tmp/rel-1.0.0/{.buildpath}' fichiers ... faire.

'/tmp/rel-1.0.0/{.projet}' fichiers ... faire.

'/tmp/rel-1.0.0/{.gitignore}' fichiers ... faire.

'/tmp/rel-1.0.0/{.git}' fichiers ... faire.

'/tmp/rel-1.0.0/{.gitattributes}' fichiers ... faire.

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

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

'/tmp/rel-1.0.0/{.*~}' fichier. .. faire.

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

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

'/tmp/rel-1.0.0/{.DS_Store} ' files ... faire.

'/tmp/rel-1.0.0/{.paramètres}' fichiers ... faire.

'/tmp/rel-1.0.0/{.vide}' fichiers ... faire.

fait.

l'Archivage des extraits composant(s)... faire.

-rw-r--r-- 1 admin wheel 25445901 3 Nov 12:57 /tmp/rel-1.0.0.tgz

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

function git-archive () {
    PREFIX=""; ## sudo mkdir -p ${PREFIX}
    REPO_PATH="`echo ""|awk -F: '{print }'`";
    RELEASE="`echo ""|awk -F: '{print }'`";
    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 [[ "" =~ [--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;
  }
8
répondu tocororo 2011-11-04 04:34:30

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

Note:

  • MASTER_DIR = une caisse avec votre submodules vérifié aussi
  • DEST_DIR = où cette exportation finira
  • si vous avez rsync, je pense que vous pourriez faire la même chose avec encore moins de douleur à la balle.

suppositions:

  • Vous devez exécuter ceci à partir du répertoire parent de MASTER_DIR ( I. e from 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 à l'exportation.tar.gz

8
répondu Rob Jensen 2012-02-28 01:42:28

cela copiera les fichiers dans une plage de propagations (C à G) vers un fichier tar. Remarque: cette obtiendrez uniquement les fichiers obligé. Pas l'ensemble du référentiel. Légèrement modifié de ici

Exemple Commettre L'Histoire

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

git-diff-arborescence de la Page de Manuel de

- r --> de manière récursive, les sous-arbres

--no-commit-id --> git diff-tree affiche une ligne avec l'ID de commit s'il y a lieu. Ce drapeau supprimait la sortie de l'ID de propagation.

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

--diff-filtre=ACMRT --> Sélectionner uniquement ces fichiers. voir ici pour la liste complète des fichiers

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

C ~ -- > Include fichiers de Commit C. pas seulement depuis Commit C.

/ xargs tar-rf myTarFile -- > sorties to tar

6
répondu Fuyu Persimmon 2017-05-23 12:18:27

Ma préférence serait en fait d'avoir une cible dist dans votre Makefile (ou autre système de compilation) qui exporte une archive distribuable de votre code (.goudron.bz2,.zip. ,un bocal, ou tout ce qui est approprié). Si vous utilisez GNU autotools ou les systèmes MakeMaker de Perl, je pense que cela existe automatiquement pour vous. Si pas, je vous recommande fortement de l'ajouter.

ETA (2012-09-06): Wow, hard downvotes. Je crois toujours qu'il vaut mieux construire vos distributions avec vos outils de construction plutôt que votre outil de contrôle du 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 ant. Nous sommes en train de changer les systèmes de contrôle du code source, et la présence de cette cible ant signifie un tracas de moins dans la migration.

5
répondu skiphoppy 2012-09-06 13:54:17

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 "151900920" REPOSITORY DESTINATION" && exit 1
REPOSITORY=
DESTINATION=
TMPNAME="/tmp/$(basename $REPOSITORY).$$"
git clone $REPOSITORY $TMPNAME
rm -rf $TMPNAME/.git
mkdir -p $DESTINATION
cp -r $TMPNAME/* $DESTINATION
rm -rf $TMPNAME
4
répondu troelskn 2009-07-17 10:07:43
"151920920 de Faire, le moyen le plus facile, c'est une fonction .bash_profile, il décompose directement l'archive sur l'emplacement courant, configure d'abord votre [url:path] habituel. NOTE: avec cette fonction, vous évitez l'opération clone, il obtient directement à partir de la prise en charge à distance.

gitss() {
    URL=[url:path]

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

d'Alias .gitconfig, même configuration requise (faites attention en exécutant la commande à l'intérieur .git projets, il saute toujours à la base dir précédemment comme dit ici , jusqu'à ce que ceci est fixé je préfère personnellement la fonction

ss = !env GIT_TMPFILE="`/bin/tempfile`" sh -c 'git archive --format=zip --remote=[url:path]/  \ > $GIT_TMPFILE && unzip $GIT_TMPFILE && rm $GIT_TMPFILE' -
4
répondu RkG 2010-03-19 16:32:28

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

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

puis svn exportera tous les fichiers qui sont sous contrôle de révision (ils pourraient aussi avoir ajouté récemment; ou modifié le statut) - et si vous avez d'autres "junk" dans ce répertoire (et je ne compte pas les sous-dossiers .svn ici, mais les fichiers visibles comme .o ), il sera exporté et non ; seuls les fichiers enregistrés par SVN repo seront exportés. Pour moi, une bonne chose est que cette exportation inclut aussi des fichiers avec des modifications locales qui ont pas encore été commis; et une autre bonne chose est que les horodateurs des fichiers exportés sont les mêmes que les originaux. Ou, comme le dit svn help export :

  1. Exporte un arbre de répertoire propre de la copie de travail spécifiée par PATH1, lors de la révision REV si elle est donnée, sinon au travail, dans PATH2. ... Si REV n'est pas spécifié, tous les les changements seront préservés. Les fichiers qui ne sont pas sous contrôle de version de ne pas être copié.

pour se rendre compte que git ne préservera pas les horodateurs, comparez la sortie de ces commandes (dans un sous-dossier d'un git repo 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 moi, en tout cas, je remarque que git archive fait que tous les horodateurs du fichier archivé sont les mêmes! git help archive dit:

git archive se comporte différemment lorsqu'on lui donne une arborescence ID par rapport à lorsqu'on lui donne une propagation ID ou une balise ID. Dans le premier cas, l' l'heure courante est utilisée comme Heure de modification de chaque fichier dans l'archive. Dans ce dernier cas, l'heure de validation que enregistré en référence commettre l'objet est utilisé à la place.

... mais apparemment les deux cas ont défini le "temps de modification de chaque fichier"; de ce fait pas préserver les horodateurs réels de ces fichiers!

donc, afin de préserver également les horodateurs, voici un script bash , qui est en fait un "one-liner", bien que quelque peu compliqué - donc ci-dessous il est affiché en 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 Qu'il est supposé que vous exportez le contenu dans" current "directory (ci - dessus, /media/disk/git_svn/subdir ) - et la destination dans laquelle vous exportez est quelque peu mal placée, mais elle est dans DEST variable d'environnement. Notez qu'avec ce script, vous devez créer vous-même le répertoire DEST avant d'exécuter le script ci-dessus.

après le script est lancé, vous devriez être en mesure de comparer:

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

... et avec un peu de chance voir les mêmes horodateurs (pour les fichiers qui étaient sous le contrôle de la version).

Espérons que cela aide quelqu'un,

Acclamations!

3
répondu sdaau 2017-05-23 12:18:27

de loin la façon la plus facile que j'ai vu pour le faire (et travaille sur windows aussi bien) 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 dépôt git depuis ma machine windows vers une machine linux via une clé usb?

3
répondu B T 2017-05-23 12:34:53

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

2
répondu Brandon 2012-08-23 15:05:20

si je comprends bien la question, il s'agit davantage de télécharger un certain état à partir du serveur, sans historique, et sans données d'autres branches, plutôt que d'extraire un État à partir d'un dépôt local (comme le font de nombreux anwsers ici).

Qui peut être fait 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).
  • --depth est (était?) aurait défectueux, mais pour le cas d'une exportation, les questions mentionnées ci-dessus ne devrait pas d'importance.
2
répondu Ondra Žižka 2018-03-12 14:59:27

j'ai la fonction utilitaire suivante dans mon .bashrc fichier: il crée une archive de la branche courante dans un dépôt git.

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

l'option 1 ne semble pas trop efficace. Qu'en est-il s'il n'y a pas d'espace dans le client pour faire un clone et puis supprimer le dossier .git ?

Aujourd'hui, je me suis trouvé à essayer de le faire, où le client est un Pi à la framboise avec presque plus d'espace. En outre, je veux également exclure certains dossiers lourds du dépôt.

Option 2 et autres réponses ici n'aident pas dans ce scénario. Ni git archive (car besoin de commettre un .gitattributes fichier, et je ne veux pas enregistrer cette exclusion dans le référentiel).

ici je partage ma solution, similaire à l'option 3, mais sans le besoin de git clone :

tmp=`mktemp`
git ls-tree --name-only -r HEAD > $tmp
rsync -avz --files-from=$tmp --exclude='fonts/*' . raspberry:

changer la ligne rsync pour une ligne équivalente de compresse fonctionnera aussi comme un git archive mais avec une sorte d'option d'exclusion (comme est demandé ici ).

1
répondu alexis 2015-06-12 19:35:11

j'ai une autre solution qui fonctionne très bien si vous avez une copie locale du dépôt sur l'ordinateur où vous souhaitez créer l'exportation. Dans ce cas, déplacez-vous dans ce répertoire de dépôt et entrez cette commande:

GIT_WORK_TREE=outputdirectory git checkout -f

Ceci est particulièrement utile si vous gérez un site web avec un dépôt git et voudrais commander une version propre de /var/www/ . Dans ce cas, ajoutez cette commande dans un script .git/hooks/post-receive ( hooks/post-receive sur un dépôt nu, ce qui est plus approprié dans cette situation)

1
répondu Tom 2018-02-23 10:30:17