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:
-
git clone
suivi de la suppression du répertoire.git
. -
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. -
git-export
est un script tiers qui fait essentiellement ungit clone
dans un emplacement temporaire suivi dersync --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.
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)
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.
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
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
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
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
.
est simple; il suffit de laisser tomber le script quelque part dans votre PATH
, et assurez-vous qu'il est exécutable.
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.
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)
j'utilise git-submodules intensivement. Celui-ci travaille pour moi:
rsync -a ./FROM/ ./TO --exclude='.*'
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
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 :)
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
--branch stable
ou --branch release/0.9
.
aussi simple que clone puis supprimer le .dossier git:
git clone url_of_your_repo path_to_export && rm -rf path_to_export/.git
je veux juste souligner que, dans le cas que vous êtes
- exporter un sous-dossier du dépôt (c'est ainsi que J'utilisais SVN export feature)
- sont D'accord pour copier tout de ce dossier à la destination de déploiement
- 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]
.
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
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
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;
}
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
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
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.
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
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' -
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
:
- 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!
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?
si vous avez aussi besoin de sous-modules, cela devrait faire l'affaire: https://github.com/meitar/git-archive-all.sh/wiki
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.
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
}
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 ).
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)