Hacer una " exportación de git "(como"exportación svn")?

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

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

La barra al final de la ruta de acceso es importante, de lo contrario resultará en que los archivos estén en /destination con el prefijo 'path'.

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á ahí.

El indicador -a es necesario para revisar todos los archivos en el índice (no estoy seguro de qué significa omitir esta bandera en esta situación, ya que no hace lo que quiero). La bandera -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.

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 particular dentro del repositorio agregue tantas rutas como desee como último argumento a git, por ejemplo:

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

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

Simplemente use svn export.

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

Por ejemplo, para exportar un repositorio completo, observe cómo trunk en la URL reemplaza a master (o lo que sea la rama HEAD del proyecto se establece 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 la rama master estará disponible usando trunk:

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

El no-HEAD las ramas serán accesibles en /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

Del Manual de Git :

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

La capacidad de prefijo básicamente hace que sea trivial usar git-checkout-index como una función "exportar como árbol". Simplemente 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 así:

git export ~/the/destination/dir

Si el directorio de destino ya existe, necesitará 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

Parece que esto es menos problemático con Git que con SVN. Git solo pone a .carpeta git en la raíz del repositorio, mientras que SVN pone un .svn en cada subdirectorio. Por lo tanto, "svn export" evita la magia recursiva de la línea de comandos, mientras que con Git recursion no es necesaria.

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)

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

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

Si no está excluyendo archivos con .gitattributes export-ignore entonces intenta git checkout

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

- f
Al revisar rutas desde el índice, no falle al no fusionarse entradas; en su lugar, las entradas no fusionadas se ignoran.

Y

-q
Evitar verbos

Además, puede obtener cualquier Rama o Etiqueta o de una Revisión de confirmación 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 borrará ningún archivo, sino que sobrescribirá archivos con el mismo nombre sin previo aviso

ACTUALIZACIÓN: Para evitar el problema decapitado o para dejar intacto el repositorio de trabajo al usar checkout para exportar con etiquetas, ramas o SHA1, debe agregar -- ./ al final

El doble guion -- 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 de esa confirmación exacta

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

Esto copiará todo el contenido, menos el.archivos dot. Uso esto para exportar proyectos clonados por git al repositorio git de mi aplicación web sin el.git cosas.

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

La vieja bash funciona genial:)

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 meta información en el directorio de exportación

• Exportar una cierta rama usando svn se logra mediante especificar la ruta apropiada

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

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

Tan simple como clonar a continuación, eliminar el .carpeta git:

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

Sólo quiero señalar que en el caso de que usted

1. exportando una subcarpeta del repositorio (así es como solía usar la función de exportación SVN)
2. está bien 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.

Entonces puedes usar cp foo [destination] en lugar del mencionado git-archive master foo | -x -C [destination].

Para los usuarios de GitHub, el método git archive --remote no funcionará directamente, ya que la URL de exportación es efímera. Debes pedirle a GitHub la URL y 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 quieres poner el código 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

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 pasarlo sin preocuparse por ningún historial de confirmaciones de git.

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

Bash-implementación de git-export.

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

También he añadido la '.gitattributes ' archivo al proceso con el fin de eliminar los archivos no deseados de la carpeta de exportación de destino. Incluye detalle en el proceso mientras hace que la función 'git-export' sea más eficiente.

EMPTY_FILE=".vacío";

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 git-export / tmp / rel-1.0.0

Añadiendo ".empty ' files to empty folder(s): ... Terminado.

Componente (s) del índice de salida:... Terminado.

Restablecer la CABEZA y el índice: ... Terminado.

Purgar componentes específicos de Git: ...

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

' / tmp / rel-1.0.0 / {.archivos del proyecto}... Terminado.'

' / tmp / rel-1.0.0 / {.archivos de gitignore... Terminado.'

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

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

'/tmp/rel-1.0.0/{*.archivos mno... Terminado.'

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

' / tmp / rel-1.0.0 / {.*~}' file ... Terminado.'

'/tmp/rel-1.0.0/{*.archivos swp ... Terminado.'

'/tmp/rel-1.0.0/{*.archivos swo ... Terminado.'

' / tmp / rel-1.0.0 / {.DS_Store}" file ... Terminado.'

' / tmp / rel-1.0.0 / {.archivos de configuración}... Terminado.'

' / tmp / rel-1.0.0 / {.archivos vacíos ... Terminado.'

Hecho.

Archivando componentes retirados: ... Terminado.

-rw-r wheel r 1 1 rueda de administración 25445901 3 Nov 12:57 /tmp/rel-1.0.0.tgz

Ahora he incorporado la funcionalidad 'git archive' en un solo proceso 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;
  }

Si quieres algo que funcione con submódulos, vale la pena intentarlo.

Nota:

• MASTER_DIR = un checkout con tus submódulos checked out también
• DEST_DIR = donde terminará esta exportación
• Si usted tiene rsync, creo que sería capaz de hacer lo mismo con aún menos dolor de pelota.

Supuestos:

• Necesita ejecutar esto desde el directorio padre de MASTER_DIR ( es decir, desde MASTER_DIR cd.. )
• Se asume DEST_DIR haber sido creado. Esto es bastante fácil de modificar para incluir la creación de un DEST_DIR si quieres

Cd MASTER_DIR && tar-zcvf ../DEST_DIR / export.alquitrán.gz --exclude='.git*' . && CD ../ DEST_DIR / & & tar xvfz export.alquitrán.exportación de gz y rm.alquitrán.gz

Esto copiará los archivos en un rango de confirmaciones (C a G) a un archivo tar. Nota: esto solo hará que los archivos se comprometan. No todo el repositorio. Ligeramente modificado de Aquí

Ejemplo Historial de confirmaciones

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-tree Página de manual

- r > > recurse en sub-árboles

No no-commit-id git> git diff-tree muestra una línea con el ID de confirmación cuando corresponde. Esta bandera suprimido el resultado del ID de confirmación.

Name name-only Show> Mostrar solo los nombres de los archivos modificados.

Di diff-filter=ACMRT Select> Seleccione solo estos archivos. Vea aquí la lista completa de archivos

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

C~ Include> Incluir archivos de la confirmación C. No solo archivos desde la confirmación C.

/ xargs tar-rf myTarFile outputs > salidas a tar

Mi preferencia sería tener un destino dist en tu Makefile (u otro sistema de compilación) que exporte un archivo distribuible de tu código (. tar. bz2, .Postal, .tarro, o lo que sea apropiado). Si está usando GNU autotools o los sistemas MakeMaker de Perl, creo que esto existe automáticamente. Si no, recomiendo agregarlo.

ETA (2012-09-06): Wow, duros 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 hormiga. 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.

Necesitaba esto para un script de implementación y no pude 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

Hacerlo de la manera fácil, esta es una función para .bash_profile, descomprime directamente el archivo en la ubicación actual, configure primero su [url:path] habitual. NOTA: Con esta función se evita la operación de clonación, se obtiene directamente desde el 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 for .gitconfig, se requiere la misma configuración (TENGA CUIDADO de ejecutar el comando dentro .git proyectos, siempre salta a la base dir previamente como se dice aquí, hasta que esto se arregla yo personalmente prefiero el 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' -

Creo que El post de @ Aredridel fue el más cercano, pero hay un poco más de eso, así 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 svn exportará todos los archivos que están bajo control de revisión (también podrían haber sido añadidos recientemente; o estado Modificado) - y si tiene otros "basura" en ese directorio (y no estoy contando .svn subcarpetas aquí, pero cosas visibles como .o archivos), no será exportado; solo se exportarán aquellos archivos registrados por el repositorio SVN. Para mí, una cosa buena es que esta exportación también incluye archivos con cambios locales que no han sido confirmados todavía; y otra cosa buena es que las marcas de tiempo de los archivos exportados son las mismas que las originales. O, como svn help export lo pone:

1. Exporta un árbol de directorios limpio desde la copia de trabajo especificada por PATH1, en la revisión REV si se da, de lo contrario en el TRABAJO, en PATH2. ... If REV no se especifica, todo local los cambios se conservarán. Los archivos que no estén bajo control de versiones no ser copiado.

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

El archivo Git se comporta diferentemente cuando se le da un ID de árbol versus cuando se le da un ID de confirmación o ID de etiqueta. En el primer caso, 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 commit referenciado se usa en su lugar.

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

Así, con el fin de preservar también la marcas de tiempo, aquí hay un script bash, que en realidad es un "one-liner", aunque algo complicado, por lo 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 asume que está exportando el contenido en el directorio "actual" (arriba, /media/disk/git_svn/subdir) - y el destino al que está exportando está algo incómodo, 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ía ser capaz de comparar:

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

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

Espero que esto ayude a alguien,{[59]]} ¡Salud!

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

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

Vea esta respuesta para más detalles: ¿Cómo puedo copiar mi repositorio git desde mi máquina windows a una máquina linux a través de una unidad USB?

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

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 muchos anwsers aquí lo hacen).

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 es (era?) supuestamente 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
}

La opción 1 no suena demasiado eficiente. ¿Qué pasa si no hay espacio en el cliente para hacer un clon y luego eliminar la carpeta .git?

Hoy me encontré tratando de hacer esto, donde el cliente es una Raspberry Pi con casi no queda espacio. Además, también quiero excluir alguna carpeta pesada del repositorio.

La opción 2 y otras respuestas aquí no ayudan en este escenario. Tampoco git archive (porque requieren confirmar un archivo .gitattributes, y no quiero guardar esto 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 línea rsync por una línea equivalente para compress también funcionará como git archivepero con una especie de opción de exclusión (como se pregunta aquí).

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 desea obtener 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 desnudo, que es más adecuado en este situación)