source keys code archives git export git-archive svn-export

code - git archives int keys



¿Hacer un "git exportar"(como "svn export")? (30)

Me he estado preguntando si hay una buena solución de "exportación git" que cree una copia de un árbol sin el directorio del repositorio .git . Hay al menos tres métodos que conozco:

  1. git clone seguido de la eliminación del directorio del repositorio .git .
  2. git checkout-index alude a esta funcionalidad pero comienza con "Simplemente lea el árbol deseado en el índice ...", que no estoy completamente seguro de cómo hacerlo.
  3. git-export es un script de terceros que esencialmente hace un git clone en una ubicación temporal seguida de rsync --exclude=''.git'' en el destino final.

Ninguna de estas soluciones realmente me parece satisfactoria. La más cercana a svn export podría ser la opción 1, porque ambas requieren que el directorio de destino esté vacío primero. Pero la opción 2 parece aún mejor, asumiendo que puedo averiguar qué significa leer un árbol en el índice.

Bash-implementación de git-export.

He segmentado los procesos de creación y eliminación de archivos .empty en su propia función, con el propósito de reutilizarlos en la implementación de ''git-archive'' (se publicará más adelante).

También agregué el archivo ''.gitattributes'' al proceso para eliminar los archivos no deseados de la carpeta de exportación de destino. Incluyó verbosidad al proceso al tiempo que hace que la función ''git-export'' sea más eficiente.

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; }

Salida:

$ git-export /tmp/rel-1.0.0

Agregando archivos ''.empty'' a las carpetas vacías: ... hecho.

Checking-Out Index componente (s): ... hecho.

Restableciendo HEAD e Índice: ... hecho.

Purga de componentes específicos de Git: ...

''/tmp/rel-1.0.0/{.buildpath}'' archivos ... listo. ''

''/tmp/rel-1.0.0/{.project}'' archivos ... listo. ''

''/tmp/rel-1.0.0/{.gitignore}'' archivos ... listo. ''

''/tmp/rel-1.0.0/{.git}'' archivos ... listo. ''

''/tmp/rel-1.0.0/{.gitattributes}'' archivos ... hecho. ''

''/tmp/rel-1.0.0/{*.mno}'' archivos ... listo. ''

''/tmp/rel-1.0.0/{*~}'' archivos ... listo. ''

''/tmp/rel-1.0.0/{.*~}'' archivos ... listo. ''

''/tmp/rel-1.0.0/{*.swp}'' archivos ... listo. ''

''/tmp/rel-1.0.0/{*.swo}'' archivos ... listo. ''

''/tmp/rel-1.0.0/{.DS_Store}'' archivos ... listo. ''

''/tmp/rel-1.0.0/{.settings}'' archivos ... listo. ''

''/tmp/rel-1.0.0/{.empty}'' archivos ... listo. ''

hecho.

Archivando el (los) componente (s) desprotegido (s): ... hecho.

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

Ahora he incorporado la funcionalidad ''git archive'' en un proceso único que hace uso de la función ''create_empty'' y otras características.

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; }

Del manual de Git :

Usando git-checkout-index para "exportar un árbol completo"

La capacidad del prefijo básicamente hace que sea trivial utilizar git-checkout-index como una función de "exportar como árbol". Solo lea el árbol deseado en el índice, y haga:

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

Descubrí lo que significa la opción 2. Desde un repositorio, puedes hacer:

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

La barra diagonal al final de la ruta es importante, de lo contrario, los archivos estarán en / destino con un prefijo de "ruta".

Como en una situación normal el índice contiene el contenido del repositorio, no hay nada especial que hacer para "leer el árbol deseado en el índice". Ya está ahí.

La -a se requiere para revisar todos los archivos en el índice (no estoy seguro de lo que significa omitir esta bandera en esta situación, ya que no hace lo que quiero). El indicador -f obliga a sobrescribir cualquier archivo existente en la salida, lo que este comando normalmente no hace.

Este parece ser el tipo de "exportación de git" que estaba buscando.

El equivalente de

svn export . otherpath

dentro de un repositorio existente es

git archive branchname | (cd otherpath; tar x)

El equivalente de

svn export url otherpath

es

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

Esto copiará los archivos en un rango de confirmaciones (C a G) a un archivo tar. Nota: esto solo conseguirá los archivos comprometidos. No todo el repositorio. Ligeramente modificado desde Here

Ejemplo de historia de compromiso

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

Here

-r -> prestar atención en sub-árboles

--no-commit-id -> git diff-tree genera una línea con el ID de confirmación cuando corresponda. Este indicador suprimió la salida de ID de confirmación.

--name-only -> Mostrar solo nombres de archivos modificados.

--diff-filter = ACMRT -> Selecciona solo estos archivos. Vea aquí para la lista completa de archivos

C..G -> Archivos en este rango de confirmaciones

C ~ -> Incluir archivos de Commit C. No solo archivos desde Commit C.

| xargs tar -rf myTarFile -> salidas a tar

Esto copiará todos los contenidos, menos los archivos .dot. Uso esto para exportar proyectos clonados de git al repositorio de git de mi aplicación web sin las cosas .git.

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

Bash viejo simple funciona simplemente genial :)

He escrito un envoltorio simple alrededor de git-checkout-index que puedes usar así:

git export ~/the/destination/dir

Si el directorio de destino ya existe, deberá agregar -f o --force .

La instalación es simple; simplemente suelte el script en algún lugar de su PATH , y asegúrese de que sea ejecutable.

El repositorio github para git-export

He visitado esta página con frecuencia cuando busco una manera de exportar un repositorio de git. Mi respuesta a esta pregunta considera tres propiedades que svn export tiene por diseño en comparación con git, ya que svn sigue un enfoque de repositorio centralizado:

  • Minimiza el tráfico a una ubicación de repositorio remoto al no exportar todas las revisiones
  • No incluye metainformación en el directorio de exportación.

  • La exportación de una rama determinada usando svn se realiza especificando la ruta apropiada

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

Cuando se --branch stable una determinada versión, es útil clonar una rama estable como, por ejemplo, --branch stable o --branch release/0.9 .

Mi preferencia sería tener un destino dist en su Makefile (u otro sistema de compilación) que exporte un archivo distribuible de su código (.tar.bz2, .zip, .jar, o lo que sea apropiado). Si está utilizando las herramientas automáticas GNU o los sistemas MakeMaker de Perl, creo que esto existe automáticamente para usted. Si no, le recomiendo que lo agregue.

ETA (2012-09-06): Wow, duras críticas. Todavía creo que es mejor construir sus distribuciones con sus herramientas de construcción en lugar de su herramienta de control de código fuente. Creo en la construcción de artefactos con herramientas de construcción. En mi trabajo actual, nuestro producto principal está construido con un objetivo de hormigas. Estamos en medio de sistemas de control de código fuente de conmutación, y la presencia de este objetivo ant significa un problema menos en la migración.

Necesitaba esto para un script de implementación y no podía usar ninguno de los enfoques mencionados anteriormente. En su lugar descubrí una solución diferente:

#!/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

Para los usuarios de GitHub, el método git archive --remote no funcionará directamente, ya que docs . Debes pedirle a GitHub la URL, luego descargarla. curl hace que sea fácil:

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

Esto le dará el código exportado en un directorio local. Ejemplo:

$ 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

Editar
Si desea que el código se coloque en un directorio específico existente (en lugar de uno aleatorio de github):

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

Parece que esto es un problema menor con Git que con SVN. Git solo coloca una carpeta .git en la raíz del repositorio, mientras que SVN coloca una carpeta .svn en cada subdirectorio. Por lo tanto, "svn export" evita la magia recursiva de la línea de comandos, mientras que con Git no es necesaria la recursión.

Probablemente la forma más sencilla de lograr esto es con git archive . Si realmente necesitas solo el árbol expandido, puedes hacer algo como esto.

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

La mayoría de las veces que necesito ''exportar'' algo desde git, quiero un archivo comprimido en cualquier caso, así que hago algo como esto.

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

Archivo ZIP:

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

git help archive para más detalles, es bastante flexible.

Tenga en cuenta que aunque el archivo no contendrá el directorio .git, sin embargo, contendrá otros archivos ocultos específicos de git como .gitignore, .gitattributes, etc. Si no los quiere en el archivo, asegúrese de use el atributo export-ignore en un archivo .gitattributes y confirme esto antes de hacer su archivo. Lee mas...

Nota: Si está interesado en exportar el índice, el comando es

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

(Vea la respuesta de Greg para más detalles)

Puede archivar un repositorio remoto en cualquier confirmación como archivo zip.

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

Sí, this es un comando limpio y ordenado para archivar su código sin ninguna inclusión de git en el archivo y es bueno pasarlo sin preocuparse por ningún historial de confirmación de git.

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

Si no está excluyendo archivos con .gitattributes export-ignore , intente git checkout

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

-F
Al retirar las rutas del índice, no falle en las entradas no combinadas; en cambio, las entradas no combinadas se ignoran.

y

-q
Evitar verboso

Además, puede obtener cualquier rama o etiqueta o de una revisión de compromiso específica como en SVN simplemente agregando el SHA1 (SHA1 en Git es el equivalente al número de revisión en SVN)

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

El /path/to/checkout/ debe estar vacío, Git no eliminará ningún archivo, pero sobrescribirá los archivos con el mismo nombre sin ningún aviso.

ACTUALIZACIÓN: para evitar el problema decapitado o para dejar intacto el repositorio de trabajo cuando se utiliza la extracción para exportar con etiquetas, sucursales o SHA1, debe agregar -- ./ al final

El doble guión -- le dice a git que todo después de los guiones son rutas o archivos, y también en este caso le dice a git checkout que no cambie la HEAD

Ejemplos:

Este comando obtendrá solo el directorio libs y también el archivo readme.txt que se realiza exactamente

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

Esto creará (sobrescribirá) my_file_2_behind_HEAD.txt dos confirmaciones detrás de la cabeza 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

Para obtener la exportación de otra sucursal.

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

Observe que ./ es relativo a la raíz del repositorio

Si quieres algo que funcione con submódulos, esto podría valer la pena.

Nota:

  • MASTER_DIR = un checkout con sus submódulos desprotegidos también
  • DEST_DIR = donde terminará esta exportación
  • Si tienes rsync, creo que podrías hacer lo mismo con menos dolor de balón.

Suposiciones

  • Debe ejecutar esto desde el directorio principal de MASTER_DIR (es decir, desde el CD de MASTER_DIR ..)
  • Se supone que DEST_DIR ha sido creado. Esto es bastante fácil de modificar para incluir la creación de un DEST_DIR si quisiera

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

Solo quiero señalar que en el caso de que usted sea

  1. exportar una subcarpeta del repositorio (así es como solía usar la función de exportación SVN)
  2. están de acuerdo con copiar todo desde esa carpeta al destino de implementación
  3. y como ya tiene una copia de todo el repositorio en su lugar.

Luego, puede usar cp foo [destination] lugar del mencionado git-archive master foo | -x -C [destination] git-archive master foo | -x -C [destination] .

Tan simple como clonar, entonces elimine la carpeta .git:

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

Yo uso git-submódulos extensivamente. Esta funciona para mí:

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

git archive también funciona con repositorio remoto.

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

Para exportar una ruta específica dentro del repositorio, agregue tantas rutas como desee como último argumento para git, por ejemplo:

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

Según entiendo la pregunta, se trata más de descargar solo cierto estado del servidor, sin historial y sin datos de otras ramas, en lugar de extraer un estado de un repositorio local (como lo hacen muchas respuestas aquí).

Eso se puede hacer así:

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

  • --single-branch Está disponible desde Git 1.7.10 (abril de 2012).
  • --depthse reportedly era (era?) defectuoso, pero para el caso de una exportación, los problemas mencionados no deberían importar.

Tengo la siguiente función de utilidad en mi archivo .bashrc: crea un archivo de la rama actual en un repositorio 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 }

Una respuesta de caso especial si el repositorio está alojado en GitHub.

Sólo tiene que utilizar svn export .

Por lo que sé, Github no permite archive --remote . Aunque GitHub es svn compatible y tienen todos los repositorios git svn accesibles, por lo que puede usar svn export como lo haría normalmente con algunos ajustes en su URL de GitHub.

Por ejemplo, para exportar un repositorio completo, observe cómo el enlace trunk en la URL reemplaza al master (o a la rama HEAD del proyecto ):

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

Y puede exportar un solo archivo o incluso una determinada ruta o carpeta:

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

Ejemplo con jQuery JavaScript Library

La rama HEAD o la rama maestra estarán disponibles mediante trunk :

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

Las sucursales que no sean HEAD serán accesibles bajo /branches/ :

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

Todas las etiquetas en /tags/ de la misma manera:

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

Creo que la @Aredridel de @Aredridel fue la más cercana, pero hay un poco más de eso, por lo que agregaré esto aquí; la cosa es, en svn, si estás en una subcarpeta de un repositorio, y lo haces:

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

luego svnexportará todos los archivos que están bajo control de revisión (también podrían haber sido agregados recientemente o estado Modificado) y si tiene otra "basura" en ese directorio (y no estoy contando las .svnsubcarpetas aquí, sino cosas visibles como .oarchivos) , no será exportado; solo se exportarán los archivos registrados por el repositorio SVN. Para mí, una cosa buena es que esta exportación también incluye archivos con cambios locales que aún no se han confirmado; y otra cosa buena es que las marcas de tiempo de los archivos exportados son las mismas que las originales. O, como lo svn help exportpone:

  1. Exporta un árbol de directorios limpio de la copia de trabajo especificada por PATH1, en la revisión REV si se proporciona, de lo contrario, en TRABAJO, en PATH2. ... Si no se especifica REV, se conservarán todos los cambios locales. Los archivos que no están bajo el control de versiones no serán copiados.

Para darse cuenta de que gitno se conservarán las marcas de tiempo, compare la salida de estos comandos (en una subcarpeta de un gitrepositorio de su elección):

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

... y:

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

... y yo, en cualquier caso, ¡un aviso que git archivehace que todas las marcas de tiempo del archivo archivado sean iguales! git help archivedice:

git archive se comporta de manera diferente cuando se le asigna una ID de árbol y cuando se le asigna una ID de confirmación o una ID de etiqueta. En el primer caso, la hora actual se usa como la hora de modificación de cada archivo en el archivo. En este último caso, se utiliza el tiempo de confirmación registrado en el objeto de confirmación al que se hace referencia.

... pero aparentemente ambos casos establecen el "tiempo de modificación de cada archivo"; por lo tanto no se conservan las marcas de tiempo reales de esos archivos!

Por lo tanto, para preservar también las marcas de tiempo, aquí hay un bashscript, que en realidad es un "de una sola línea", aunque algo complicado, así que a continuación se publica en varias líneas:

/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 / )

Tenga en cuenta que se supone que está exportando el contenido en el directorio "actual" (arriba, /media/disk/git_svn/subdir), y que el destino al que está exportando está colocado de forma un poco inconveniente, pero está en DESTla variable de entorno. Tenga en cuenta que con este script; debe crear el DESTdirectorio manualmente usted mismo, antes de ejecutar el script anterior.

Después de ejecutar el script, debería poder comparar:

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

... y espero ver las mismas marcas de tiempo (para aquellos archivos que estaban bajo el control de versiones).

Espero que esto ayude a alguien,
¡Aclamaciones!

Haciéndolo de manera fácil, esta es una función para .bash_profile, directamente descomprime el archivo en la ubicación actual, primero configura tu [url: ruta] habitual. NOTA: Con esta función evita la operación de clonación, se obtiene directamente del repositorio remoto.

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 ​​para .gitconfig, se requiere la misma configuración (TAKE CARE ejecuta el comando dentro de los proyectos .git, SIEMPRE salta al directorio base anteriormente como se dijo aquí , hasta que esto se arregle, personalmente prefiero la función

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'' -

La opción 1 no suena demasiado eficiente. ¿Qué pasa si no hay espacio en el cliente para hacer una clonación y luego eliminar la .gitcarpeta?

Hoy me encontré tratando de hacer esto, donde el cliente es una Raspberry Pi sin casi espacio. Además, también quiero excluir algunas carpetas pesadas del repositorio.

La opción 2 y otras respuestas aquí no ayudan en este escenario. Ninguno de los dos git archive(porque es necesario confirmar un .gitattributesarchivo y no quiero guardar esta exclusión en el repositorio).

Aquí comparto mi solución, similar a la opción 3, pero sin la necesidad de git clone:

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

Cambiar la rsynclínea por una línea equivalente para comprimir también funcionará como una git archiveopción de exclusión (como se solicita here ).

Tengo otra solución que funciona bien si tiene una copia local del repositorio en la máquina donde desea crear la exportación. En este caso, muévase a este directorio de repositorio e ingrese este comando:

GIT_WORK_TREE=outputdirectory git checkout -f

Esto es particularmente útil si administra un sitio web con un repositorio de git y desea verificar una versión limpia en /var/www/. En este caso, agregue este comando en un .git/hooks/post-receivescript ( hooks/post-receiveen un repositorio simple , que es más adecuado en esta situación)