Faça uma "exportação git" (como "svn export")?

Fiquei me perguntando se existe uma boa solução "git export" que crie uma cópia de uma árvore sem o .gitdiretório do repositório. Existem pelo menos três métodos que conheço:

1. git cloneseguido pela remoção do .gitdiretório do repositório.
2. git checkout-index alude a essa funcionalidade, mas começa com "Basta ler a árvore desejada no índice ...", o que não sei ao certo como fazer.
3. git-exporté um script de terceiros que essencialmente faz um git cloneem um local temporário seguido pelo rsync --exclude='.git'destino final.

Nenhuma dessas soluções realmente me parece satisfatória. O mais próximo svn exportpode ser a opção 1, porque ambos exigem que o diretório de destino esteja vazio primeiro. Mas a opção 2 parece ainda melhor, supondo que eu possa descobrir o que significa ler uma árvore no índice.

Provavelmente, a maneira mais simples de conseguir isso é com git archive. Se você realmente precisa apenas da árvore expandida, pode fazer algo assim.

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

Na maioria das vezes eu preciso 'exportar' algo do git, eu quero um arquivo compactado em qualquer caso, então faço algo assim.

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

Arquivo ZIP:

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

git help archive para mais detalhes, é bastante flexível.

Esteja ciente de que, embora o arquivo morto não contenha o diretório .git, ele conterá outros arquivos específicos do git ocultos, como .gitignore, .gitattributes, etc. Se você não os quiser no arquivo, certifique-se de use o atributo export-ignore em um arquivo .gitattributes e confirme isso antes de fazer seu archive. Consulte Mais informação...

Nota: Se você estiver interessado em exportar o índice, o comando é

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

(Veja a resposta de Greg para mais detalhes)

Eu descobri o que a opção 2 significa. Em um repositório, você pode fazer:

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

A barra no final do caminho é importante, caso contrário, os arquivos estarão no / destino com um prefixo de 'caminho'.

Como em uma situação normal, o índice contém o conteúdo do repositório, não há nada de especial a fazer para "ler a árvore desejada no índice". Já está lá.

O -asinalizador é necessário para verificar todos os arquivos no índice (não sei o que significa omitir esse sinalizador nessa situação, pois ele não faz o que eu quero). O -fsinalizador força a substituição de arquivos existentes na saída, o que esse comando normalmente não faz.

Esse parece ser o tipo de "exportação de git" que eu estava procurando.

git archive também funciona com repositório remoto.

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

Para exportar um caminho específico dentro do repositório, adicione quantos caminhos você desejar como último argumento para o git, por exemplo:

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

Uma resposta de caso especial se o repositório estiver hospedado no GitHub.

Basta usar svn export.

Tanto quanto sei, o Github não permite archive --remote. Embora o GitHub seja compatível com svn e eles tenham todos os repositórios git svnacessíveis, você pode usar svn exportcomo faria normalmente com alguns ajustes no seu URL do GitHub.

Por exemplo, para exportar um repositório inteiro, observe como trunko URL substitui master(ou o que a ramificação HEAD do projeto está configurada ):

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

E você pode exportar um único arquivo ou mesmo um determinado caminho ou pasta:

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

Exemplo com a biblioteca JavaScript jQuery

A HEADfilial ou filial principal estará disponível usando trunk:

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

As não HEAD filiais estarão acessíveis em /branches/:

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

Todas as tags abaixo /tags/da mesma maneira:

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

No manual do Git :

Usando o git-checkout-index para "exportar uma árvore inteira"

A capacidade do prefixo basicamente torna trivial o uso do git-checkout-index como uma função "exportar como árvore". Basta ler a árvore desejada no índice e fazer:

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

Eu escrevi um invólucro simples git-checkout-indexque você pode usar assim:

git export ~/the/destination/dir

Se o diretório de destino já existir, você precisará adicionar -fou --force.

A instalação é simples; basta soltar o script em algum lugar no seu PATHe verifique se ele é executável.

O repositório do github para git-export

Parece que este é um problema menor no Git que no SVN. O Git coloca apenas uma pasta .git na raiz do repositório, enquanto o SVN coloca uma pasta .svn em todos os subdiretórios. Portanto, "svn export" evita a magia recursiva da linha de comando, enquanto que com o Git a recursão não é necessária.

O equivalente a

svn export . otherpath

dentro de um repo existente é

git archive branchname | (cd otherpath; tar x)

O equivalente a

svn export url otherpath

é

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

Se você não estiver excluindo arquivos com .gitattributes export-ignore, tentegit checkout

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

-f
Ao fazer o check-out de caminhos do índice, não falhe nas entradas não imersas; em vez disso, entradas não mescladas são ignoradas.

e

-q
Evite detalhado

Além disso, você pode obter qualquer ramificação ou etiqueta ou de uma revisão de confirmação específica, como no SVN, apenas adicionando o SHA1 (SHA1 no Git é o equivalente ao número da revisão no SVN)

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

Ele /path/to/checkout/deve estar vazio, o Git não excluirá nenhum arquivo, mas substituirá os arquivos com o mesmo nome sem nenhum aviso

ATUALIZAÇÃO: para evitar o problema decapitado ou deixar intacto o repositório de trabalho ao usar o checkout para exportar com tags, branches ou SHA1, é necessário adicionar -- ./no final

O traço duplo --informa ao git que tudo após os traços são caminhos ou arquivos, e também neste caso diz git checkoutpara não alterar oHEAD

Exemplos:

Este comando obterá apenas o diretório libs e também o readme.txtarquivo que confirma exatamente

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

Isso criará (substituirá) my_file_2_behind_HEAD.txtdois commits atrás da cabeçaHEAD^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 obter a exportação de outra filial

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

Observe que ./é relativo à raiz do repositório

Eu uso os submódulos git extensivamente. Este funciona para mim:

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

Acessei esta página frequentemente ao procurar uma maneira de exportar um repositório git. Minha resposta a esta pergunta considera três propriedades que o svn export possui por design em comparação com o git, pois o svn segue uma abordagem de repositório centralizado:

• Minimiza o tráfego para um local de repositório remoto, não exportando todas as revisões
• Não inclui informações meta no diretório de exportação

• A exportação de um determinado ramo usando svn é realizada especificando o caminho apropriado

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

Ao criar uma certa versão, é útil clonar uma ramificação estável como por exemplo --branch stableou --branch release/0.9.

Isso copiará todo o conteúdo, menos os arquivos .dot. Eu uso isso para exportar projetos clonados git para o repositório git do meu aplicativo Web sem o material .git.

cp -R ./path-to-git-repo / caminho / para / destino /

Plain old bash funciona muito bem :)

Tão simples quanto o clone, exclua a pasta .git:

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

Para usuários do GitHub, o git archive --remotemétodo não funcionará diretamente, pois o URL de exportação é efêmero . Você deve solicitar o URL ao GitHub e fazer o download desse URL. curlfacilita isso:

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

Isso fornecerá o código exportado em um diretório local. Exemplo:

$ 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
Se você deseja que o código seja colocado em um diretório existente específico (e não no diretório aleatório do github):

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

Sim, este é um comando limpo e arrumado para arquivar seu código sem nenhuma inclusão do git no arquivo morto e é bom distribuir sem se preocupar com o histórico de confirmação do git.

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

Eu só quero salientar que no caso de você estar

1. exportar uma subpasta do repositório (era assim que eu costumava usar o recurso de exportação SVN)
2. tudo bem em copiar tudo dessa pasta para o destino de implantação
3. e já que você já possui uma cópia de todo o repositório.

Então você pode apenas usar em cp foo [destination]vez do mencionado git-archive master foo | -x -C [destination].

Você pode arquivar um repositório remoto em qualquer confirmação como arquivo zip.

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

Implementação bash do git-export.

Eu segmente os processos de criação e remoção de arquivos .empty por sua própria função, com o objetivo de reutilizá-los na implementação do 'git-archive' (será publicado posteriormente).

Também adicionei o arquivo '.gitattributes' ao processo para remover arquivos indesejados da pasta de exportação de destino. Inclusão de verbosidade no processo, além de tornar a função 'git-export' mais eficiente.

EMPTY_FILE = ". Vazio";

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

Resultado:

$ git-export /tmp/rel-1.0.0

Adicionando arquivos '.empty' às pastas vazias: ... pronto.

Componente (s) do índice de check-out: ... pronto.

Redefinindo HEAD e Índice: ... pronto.

Limpando componentes específicos do Git: ...

arquivos '/tmp/rel-1.0.0/{.buildpath}' ... concluído. '

arquivos '/tmp/rel-1.0.0/{.project}' finalizados. '

arquivos '/tmp/rel-1.0.0/{.gitignore}' ... concluído. '

'/tmp/rel-1.0.0/{.git}' arquivos ... concluídos. '

arquivos '/tmp/rel-1.0.0/{.gitattributes}' ... concluído. '

'/tmp/rel-1.0.0/{*.mno}' arquivos ... concluídos. '

'/tmp/rel-1.0.0/{*~}' arquivos ... concluídos. '

'/tmp/rel-1.0.0/{.*~}' arquivos ... concluídos. '

'/tmp/rel-1.0.0/{*.swp}' arquivos ... concluídos. '

'/tmp/rel-1.0.0/{*.swo}' arquivos ... concluídos. '

arquivos '/tmp/rel-1.0.0/{.DS_Store}' ... concluído. '

arquivos '/tmp/rel-1.0.0/{.settings}' concluído ... '.

arquivos '/tmp/rel-1.0.0/{.empty}' ... concluído. '

feito.

Arquivando componente (s) com check-out: ... concluído.

-rw-r - r-- 1 roda de administração 25445901 3 Nov 12:57 /tmp/rel-1.0.0.tgz

Agora incorporei a funcionalidade 'git archive' em um único processo que utiliza a função 'create_empty' e outros recursos.

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

Se você quiser algo que funcione com submódulos, isso pode valer a pena.

Nota:

• MASTER_DIR = um check-out com seus submódulos em check-out também
• DEST_DIR = onde esta exportação terminará
• Se você tem o rsync, acho que seria capaz de fazer a mesma coisa com ainda menos dor de bola.

Premissas:

• Você precisa executá-lo no diretório pai do MASTER_DIR (ou seja, do MASTER_DIR cd ..)
• Supõe-se que DEST_DIR tenha sido criado. É muito fácil modificar isso para incluir a criação de um DEST_DIR se você quiser

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

Minha preferência seria realmente ter um destino dist no seu Makefile (ou outro sistema de compilação) que exporte um arquivo distribuível do seu código (.tar.bz2, .zip, .jar ou o que for apropriado). Se você estiver usando ferramentas automáticas GNU ou sistemas MakeMaker da Perl, acho que isso existe automaticamente para você. Caso contrário, eu recomendo adicioná-lo.

ETA (06/09/2012): Uau, votos duros. Ainda acredito que é melhor criar suas distribuições com suas ferramentas de compilação do que com a ferramenta de controle de código-fonte. Acredito na construção de artefatos com ferramentas de construção. No meu trabalho atual, nosso principal produto é construído com um alvo de formigas. Estamos no meio da troca de sistemas de controle de código fonte, e a presença desse alvo formiga significa menos problemas na migração.

Isso copiará os arquivos em um intervalo de confirmações (C a G) para um arquivo tar. Nota: isso só obterá os arquivos confirmados. Não é o repositório inteiro. Ligeiramente modificado daqui

Exemplo de histórico de confirmação

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

Página de manual do git-diff-tree

-r -> recursão em subárvores

--no-commit-id -> git diff-tree gera uma linha com o ID de confirmação, quando aplicável. Este sinalizador suprimiu a saída do ID de confirmação.

--name-only -> Mostra apenas os nomes dos arquivos alterados.

--diff-filter = ACMRT -> Selecione apenas esses arquivos. Veja aqui a lista completa de arquivos

C..G -> arquivos neste intervalo de confirmações

C ~ -> Incluir arquivos do Commit C. Não apenas arquivos desde o Commit C.

| xargs tar -rf myTarFile -> saídas para tar

Pelo que entendi, é mais sobre baixar apenas um determinado estado do servidor, sem histórico e sem dados de outras ramificações, em vez de extrair um estado de um repositório local (como muitas respostas aqui fazem).

Isso pode ser feito assim:

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

• --single-branch está disponível desde Git 1.7.10 (abril de 2012).
• --depthé (foi?) supostamente defeituoso, mas, no caso de uma exportação, os problemas mencionados não devem importar.

Eu precisava disso para um script de implantação e não podia usar nenhuma das abordagens mencionadas acima. Em vez disso, descobri uma solução 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

Fazendo da maneira mais fácil, esta é uma função para .bash_profile, descompacta diretamente o arquivo na localização atual, configure primeiro o seu habitual [url: path]. NOTA: Com essa função, você evita a operação de clone, ela é obtida diretamente do repositório 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, a mesma configuração necessária (TAKE CARE executando o comando dentro dos projetos .git, ele SEMPRE salta para o diretório base anteriormente como dito aqui , até que isso seja corrigido. Pessoalmente, prefiro a função

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

De longe, a maneira mais fácil de fazer (e também funciona no Windows) é git bundle:

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

Veja esta resposta para obter mais detalhes: Como copiar meu repositório git da minha máquina Windows para uma máquina Linux via drive USB?

Eu tenho outra solução que funciona bem se você tiver uma cópia local do repositório na máquina em que deseja criar a exportação. Nesse caso, vá para este diretório do repositório e digite este comando:

GIT_WORK_TREE=outputdirectory git checkout -f

Isso é particularmente útil se você gerencia um site com um repositório git e gostaria de fazer check-out de uma versão limpa /var/www/. Nesse caso, adicione este comando em um .git/hooks/post-receivescript ( hooks/post-receiveem um repositório vazio, o que é mais adequado nessa situação)

Eu acho que a postagem de @Aredridel foi a mais próxima, mas há um pouco mais disso - então eu adicionarei isso aqui; o problema é, svnse você estiver em uma subpasta de um repositório, e você faz:

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

em seguida svn, exportará todos os arquivos que estão sob controle de revisão (eles também podem ter o status Adicionado recentemente ou Modificado) - e se você tiver outro "lixo" nesse diretório (e não estou contando .svnsubpastas aqui, mas coisas visíveis, como .oarquivos) , não será exportado; somente os arquivos registrados pelo repositório SVN serão exportados. Para mim, uma coisa boa é que essa exportação também inclui arquivos com alterações locais que ainda não foram confirmadas; e outra coisa interessante é que os carimbos de data e hora dos arquivos exportados são os mesmos que os originais. Ou, como svn help exportcoloca:

2. Exporta uma árvore de diretórios limpa da cópia de trabalho especificada por PATH1, na revisão REV, se for fornecida, caso contrário em WORKING, para PATH2. ... Se REV não for especificado, todas as alterações locais serão preservadas. Arquivos que não estão sob controle de versão não serão copiados.

Para perceber que gitnão preservará os carimbos de data e hora, compare a saída desses comandos (em uma subpasta de um gitrepositório de sua escolha):

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

... e:

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

... e eu, em qualquer caso, noto que git archivefaz com que todos os carimbos de data e hora do arquivo arquivado sejam os mesmos! git help archivediz:

O arquivo git se comporta de maneira diferente quando recebe um ID de árvore e quando recebe um ID de confirmação ou ID de tag. No primeiro caso, a hora atual é usada como a hora de modificação de cada arquivo no arquivo morto. Neste último caso, o tempo de confirmação, conforme registrado no objeto de confirmação referenciado, é usado.

... mas aparentemente ambos os casos definem o "tempo de modificação de cada arquivo"; dessa forma, não preservando os registros de data e hora reais desses arquivos!

Portanto, para preservar também os registros de data e hora, aqui está um bashscript, que é realmente "uma linha", embora um pouco complicado - então, abaixo, ele é postado em várias linhas:

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

Observe que se supõe que você esteja exportando o conteúdo no diretório "atual" (acima /media/disk/git_svn/subdir) - e o destino para o qual você está exportando é um pouco inconveniente, mas está na DESTvariável de ambiente. Observe que com este script; você deve criar o DESTdiretório manualmente, antes de executar o script acima.

Após a execução do script, você poderá comparar:

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

... e espero ver os mesmos registros de data e hora (para os arquivos que estavam sob controle de versão).

Espero que isso ajude alguém,
Saúde!

uma exportação git para um arquivo zip ao adicionar um prefixo (por exemplo, nome do diretório):

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

Se você também precisar de submódulos, faça o seguinte: https://github.com/meitar/git-archive-all.sh/wiki

Eu tenho a seguinte função de utilitário no meu arquivo .bashrc: ele cria um arquivo da ramificação atual em um repositório 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
}