Haz un & # 8220; git export & # 8221; (como & # 8220; svn export & # 8221;)?

StackOverflow https://stackoverflow.com/questions/160608

Pregunta

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

  1. git clone seguido de eliminar el 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 eso esencialmente hace que un git clone en una ubicación temporal seguido 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.

¿Fue útil?

Solució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 usar el atributo exportar-ignorar en un archivo .gitattributes y confirme esto antes de hacer su archivo. Leer más ...

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

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

(Consulte la respuesta de Greg para obtener más detalles)

Otros consejos

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".

Dado que 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á allí.

El indicador -a es necesario para revisar todos los archivos en el índice (no estoy seguro de lo que significa omitir este indicador en esta situación, ya que no hace lo que quiero ). El indicador -f obliga a sobrescribir los archivos existentes en la salida, lo que este comando no suele hacer.

Este parece ser el tipo de " git export " Yo estaba buscando.

git archive también funciona con un repositorio remoto. 

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

Para exportar una ruta en particular 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

ingrese la descripción de la imagen aquí

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

Solo usa svn export .

Por lo que sé, Github no permite archive --remote . Aunque GitHub es svn compatible y tienen todos los repositorios git svn < Puede acceder a / code> para que pueda 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 trunk en la URL reemplaza a master (o cualquiera que sea el la rama HEAD del proyecto está establecida en ): 

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 master estará disponible utilizando trunk : 

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

Se podrá acceder al HEAD sucursales bajo / branches / : 

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

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

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

De la Manual de Git :

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

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

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

He escrito un envoltorio simple alrededor de git-checkout-index que puedes usar de esta forma: 

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 su PATH y asegúrese de que sea ejecutable.

El repositorio github para git-export

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. Así que " svn exportar " evita la magia de línea de comandos recursiva, mientras que con Git no es necesaria la recursión.

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)

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 verificar las rutas del índice, no se debe fallar al no fusionar   entradas; en su lugar, las entradas no combinadas se ignoran.

y

  

-q
  Evitar verbosa

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 ninguna advertencia

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

El guión doble - 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 el HEAD

Ejemplos:

Este comando obtendrá solo el directorio libs y también el archivo readme.txt de ese cometer 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 rama 

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

Uso git-submodules extensivamente. Este funciona para mí: 

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

He visitado esta página con frecuencia cuando busco una manera de exportar un repositorio 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 adecuada 

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

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

Esto copiará todos los contenidos, menos los archivos .dot. Lo utilizo 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 old bash funciona genial :)

Tan simple como clonar, elimine la carpeta .git:

git clone url_of_your_repo path_to_export & amp; & amp; rm -rf ruta_de_exportación / .git

Sí, este es un comando limpio y ordenado para archivar su código sin ninguna inclusión de git en el archivo y es bueno para pasar sin preocuparse por cualquier historial de git commit. 

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

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 dado que ya tiene una copia de todo el repositorio en su lugar.

Luego, puedes usar cp foo [destino] en lugar del mencionado git-archive master foo | -x -C [destino] .

Para los usuarios de GitHub, el método git archive --remote no funcionará directamente, como la URL de exportación es efímera . Debes pedirle a GitHub la URL, luego descargarla. curl lo hace 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 del aleatorio de github): 

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

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

Implementación Bash 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: ... listo.

     

Componente (s) del índice de verificación de salida: ... hecho.

     

Restablecimiento de 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 ... listo. '

     

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

     

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

     

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

     

'/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 ... hecho. '

     

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

     

hecho.

     

Archivando los componentes desprotegidos: ... 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 solo proceso que utiliza 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;
  }

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

Nota:

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

Suposiciones:

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

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

Mi preferencia sería tener un objetivo 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 para usted automáticamente. Si no, le recomiendo que lo agregue.

ETA (2012-09-06): Wow, votos negativos. Todavía creo que es mejor construir sus distribuciones con sus herramientas de compilació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 cambiar los sistemas de control de código fuente, y la presencia de este objetivo ant significa una molestia menos en la migración.

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. Modificado ligeramente de Aquí

Ejemplo de historial de confirmación

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

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

git-diff-tree Página del manual

-r - > recesse 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.

- sólo el nombre - > Mostrar solo nombres de archivos modificados.

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

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

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

| xargs tar -rf myTarFile - > salidas a tar

Necesitaba esto para un script de implementación y no pude usar ninguno de los enfoques mencionados anteriormente. En su lugar, me di cuenta de una solución diferente: 

#!/bin/sh
[ $# -eq 2 ] || echo "USAGE <*> 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

Haciéndolo de la manera más 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 previamente como se dice aquí , hasta que se solucione, 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' -

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 muchos de los que aquí lo describen).

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).
  • --depth is (was?) supuestamente defectuoso, pero para el caso de una exportación, los problemas mencionados no deberían importar.

Creo que la publicación de @Aredridel fue la más cercana, pero hay un poco más de eso, así que añadiré 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

entonces svn exportará todos los archivos que están bajo control de revisión (también podrían haber sido agregados recientemente o modificados), y si tiene otra " basura " en ese directorio (y no estoy contando las subcarpetas .svn aquí, pero las cosas visibles como los archivos .o ), no se exportarán no ; 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 no ; y otra cosa buena es que las marcas de tiempo de los archivos exportados son las mismas que las originales. O, como lo indica svn help export :

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

Para darse cuenta de que git no conservará las marcas de tiempo, compare la salida de estos comandos (en una subcarpeta de un git repo 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, notamos que git archive hace que todas las marcas de tiempo del archivo archivado sean iguales. git help archive dice:

  

git archive se comporta de manera diferente cuando se le asigna un ID de árbol en comparación con cuando se le asigna un ID de confirmación o ID de etiqueta. En el primer caso el   la hora actual se utiliza como la hora de modificación de cada archivo en el archivo. En este último caso, el tiempo de confirmación registrado.   en el objeto de referencia referenciado se utiliza en su lugar.

... pero aparentemente ambos casos configuran la hora de modificación de " cada archivo " ;; por lo tanto, no conserva las marcas de tiempo reales de esos archivos!

Entonces, para preservar también las marcas de tiempo, aquí hay una secuencia de comandos bash , que en realidad es una línea de una sola línea, aunque algo complicada, 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 " actual " directorio (arriba, / media / disk / git_svn / subdir ) - y el destino al que está exportando se coloca de forma un tanto inconveniente, pero está en la variable de entorno DEST . Tenga en cuenta que con este script; debe crear el directorio DEST manualmente, antes de ejecutar el script anterior.

Después de ejecutar el script, deberías 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,
¡Salud!

De lejos, la forma más fácil que he visto para hacerlo (y también funciona en Windows) es git bundle :

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

Consulte esta respuesta para obtener más detalles: ¿Cómo puedo copiar mi repositorio git de mi máquina Windows a una máquina Linux a través de una unidad USB?

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, vaya 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 git y le gustaría descargar una versión limpia en / var / www / . En este caso, agregue este comando en un script .git / hooks / post-receive ( hooks / post-receive en un repositorio simple, que es más adecuado en esta situación)

una exportación de git a un archivo zip al agregar un prefijo (por ejemplo, el nombre del directorio): 

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

Si también necesita submódulos, debería hacer el truco: https: / /github.com/meitar/git-archive-all.sh/wiki

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
}
Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top