Fazer uma “exportação git” (como “svn exportação”)?
https://stackoverflow.com/questions/160608
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu estive pensando se não é uma boa solução "git exportação" que cria uma cópia de uma árvore sem o diretório do repositório .git. Há pelo menos três métodos que eu conheço:
-
git cloneseguido pela remoção do diretório do repositório.git. -
git checkout-indexalude a este funcionalidade, mas começa com "Basta ler a árvore desejado para o índice ...", que eu não sou inteiramente certo como fazer. -
git-exporté um script de terceiros que essencialmente faz umagit cloneem um local temporário seguido porrsync --exclude='.git'para o destino final.
Nenhuma destas soluções realmente me parece satisfatório. O mais próximo a svn export pode ser a opção 1, porque ambos os requerem o diretório de destino para estar vazio em primeiro lugar. Mas a opção 2 parece ainda melhor, supondo que eu possa descobrir o que isso significa para ler uma árvore no índice.
Solução
Provavelmente, a maneira mais simples de conseguir isso é com git archive . Se você realmente precisa apenas da árvore expandida você pode fazer algo como isto.
git archive master | tar -x -C /somewhere/else
Na maioria das vezes que eu preciso de algo 'exportação' do git, eu quero um arquivo comprimido em qualquer caso, então eu fazer algo assim.
git archive master | bzip2 >source-tree.tar.bz2
ZIP arquivo:
git archive --format zip --output /full/path/to/zipfile.zip master
git help archive para mais detalhes, é bastante flexível.
Esteja ciente de que, mesmo que o arquivo não irá conter o diretório .git, ele vai, no entanto, conter outros arquivos específicos do git escondido como .gitignore, .gitattributes, etc. Se você não quer que eles no arquivo, certifique-se de usar o atributo ignorar exportação em um arquivo .gitattributes e cometer este antes de fazer seu arquivo. Leia mais ...
Nota: Se você está interessado em exportar o índice, o comando é
git checkout-index -a -f --prefix=/destination/path/
(Veja Greg resposta para mais detalhes)
Outras dicas
Eu descobri que opção 2 meios. A partir de um repositório, você pode fazer:
git checkout-index -a -f --prefix=/destination/path/
A barra no final do caminho é importante, caso contrário ele irá resultar em arquivos de estar em / destino com um prefixo 'caminho'.
Uma vez que numa situação normal o índice contém o conteúdo do repositório, não há nada de especial para fazer a "ler a árvore desejado para o índice". Ele já está lá.
A bandeira -a é necessário para verificar todos os arquivos no índice (não tenho certeza o que significa omitir este sinalizador, nesta situação, uma vez que não faz o que eu quero). As forças bandeira -f substituindo quaisquer arquivos existentes na saída, que este comando não faz normalmente.
Este parece ser o tipo de "exportação git" Eu estava procurando.
git archive também funciona com o repositório remoto.
git archive --format=tar \
--remote=ssh://remote_server/remote_repository master | tar -xf -
Para exportar caminho particular dentro do add repo tantos caminhos como você deseja como último argumento para git, por exemplo:.
git archive --format=tar \
--remote=ssh://remote_server/remote_repository master path1/ path2/ | tar -xv
A resposta especial caso se o repositório está hospedado no GitHub.
Apenas uso svn export.
Tanto quanto eu sei Github não permite archive --remote. Embora GitHub é svn compatível e eles têm todos os repos git svn acessível para que você possa basta usar svn export como faria normalmente com alguns ajustes para o seu url GitHub.
Por exemplo, para exportar um repositório inteiro, observe como trunk na master substitui URL (ou qualquer que seja o ramo CABEÇA do projeto está definido para ):
svn export https://github.com/username/repo-name/trunk/
E você pode exportar um único arquivo ou até mesmo um certo caminho ou pasta:
svn export https://github.com/username/repo-name/trunk/src/lib/folder
Exemplo com jQuery JavaScript Biblioteca
O ramo HEAD ou mestre ramo estará disponível usando trunk:
svn ls https://github.com/jquery/jquery/trunk
A não HEAD ramos será acessível /branches/ em:
svn ls https://github.com/jquery/jquery/branches/2.1-stable
Todos marcas em /tags/ da mesma forma:
svn ls https://github.com/jquery/jquery/tags/2.1.3
A partir da manual do git :
Usando git-checkout-index para "exportar uma árvore inteira"
A capacidade prefixo basicamente torna trivial para usar 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 em torno git-checkout-index que você pode usar como esta:
git export ~/the/destination/dir
Se o diretório de destino já existe, você vai precisar adicionar -f ou --force.
A instalação é simples; basta soltar a algum lugar script em seu PATH, e ter certeza que é executável.
Parece que este é um problema menor com o Git do que SVN. Git só coloca uma pasta .git na raiz do repositório, enquanto SVN coloca uma pasta .svn em cada subdiretório. Assim, "svn exportação" evita recursiva magia de linha de comando, enquanto que com Git recursão não é necessário.
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 está excluindo arquivos com .gitattributes export-ignore tente git checkout
mkdir /path/to/checkout/
git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout -f -q
-f
Ao verificar os caminhos do índice, não falham em cima não mesclada entradas; em vez disso, as entradas não mescladas são ignorados.
e
q
Evite detalhado
Além disso, você pode obter qualquer ramo ou etiqueta ou de uma específica revisão de submissão como no SVN apenas adicionando o SHA1 (SHA1 no Git é o equivalente ao número de revisão no SVN)
mkdir /path/to/checkout/
git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout 2ef2e1f2de5f3d4f5e87df7d8 -f -q -- ./
O /path/to/checkout/ deve estar vazio, Git não vai apagar qualquer arquivo, mas irá sobrescrever arquivos com o mesmo nome, sem qualquer aviso
UPDATE:
Para evitar o problema decapitados ou deixar intacto o repositório de trabalho ao usar check-out para exportação com tags, ramos ou SHA1, você precisa adicionar -- ./ no final
O -- traço duplo diz git que tudo após os traços são caminhos ou arquivos, e também neste caso diz git checkout para não mudar o HEAD
Exemplos:
Este comando irá obter apenas o diretório libs e também o arquivo readme.txt do que exatamente cometer
git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout fef2e1f2de5f3d4f5e87df7d8 -f -q -- ./libs ./docs/readme.txt
Isto criará (substituir) my_file_2_behind_HEAD.txt dois commits atrás da cabeça 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 obter a exportação de um outro ramo
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 git-submódulos extensivamente. Este funciona para mim:
rsync -a ./FROM/ ./TO --exclude='.*'
Eu ter atingido esta página frequentemente quando procurando uma maneira de exportar um repositório git. Minha resposta a esta pergunta considera três propriedades que svn exportação tem por design em comparação com git, desde svn segue uma abordagem repositório centralizado:
- Ele minimiza o tráfego para um local remoto repositório por não exportar 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 construir uma certa liberação é útil para clonar um ramo estável como por exemplo --branch stable ou --branch release/0.9.
Isso irá copiar todo o conteúdo, menos os arquivos .dot. Eu uso isso para projectos clonados exportação git em repo git minha web do aplicativo sem o material .git.
cp -R ./path-to-git-repo / path / to / destino /
Plain festa velho trabalha apenas grande:)
Tão simples como clone exclua a pasta .git:
git clone url_of_your_repo path_to_export && rm -rf path_to_export/.git
Sim, este é um comando limpo e arrumado para arquivar seu código sem qualquer inclusão git no arquivo e é bom para passar ao redor sem se preocupar com qualquer git commit história.
git archive --format zip --output /full/path/to/zipfile.zip master
Eu só quero salientar que, no caso que você está
- exportar uma pasta sub do repositório (que é como eu costumava usar o recurso de exportação SVN)
- são OK com a cópia de tudo a partir dessa pasta para o destino implantação
- e desde que você já tem uma cópia de todo o repositório no lugar.
Em seguida, você pode apenas usar cp foo [destination] vez do mencionado git-archive master foo | -x -C [destination].
Para usuários GitHub, o método git archive --remote não funcionará diretamente, como o URL de exportação é efêmera . Você deve perguntar GitHub para o URL, em seguida, baixar esse URL. curl torna tão fácil:
curl -L https://api.github.com/repos/VENDOR/PROJECT/tarball | tar xzf -
Isto lhe dará 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ê quer a colocar o código em um específico, existente diretório (em vez de um aleatório de github):
curl -L https://api.github.com/repos/VENDOR/PROJECT/tarball | \
tar xzC /path/you/want --strip 1
Você pode arquivar um repo remoto a qualquer cometer como arquivo zip.
git archive --format=zip --output=archive.zip --remote=USERNAME@HOSTNAME:PROJECTNAME.git HASHOFGITCOMMIT
Bash-implementação de git-exportação.
Eu segmentado a criação do arquivo .empty e processos de remoção em sua própria função, com o objetivo de re-usá-los na implementação 'git-archive' (serão publicadas mais tarde).
Eu também adicionou o arquivo' .gitattributes' para o processo, a fim de remover os arquivos queria-un a partir da pasta de exportação alvo. verbosidade incluído para o processo ao fazer a função de 'git-exportação' mais eficiente.
EMPTY_FILE = "esvaziar.";
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;
}
Output:
$ git-exportação /tmp/rel-1.0.0
Adicionando '.empty' arquivos para a pasta vazia (s):. ... feito
Check-Out componente Índice (s):. ... feito
A redefinição HEAD e Índice:. ... feito
A purga Git-Specific componente (s): ...
'/ tmp / rel-1.0.0 / {. Buildpath}' arquivos ... feito. '
'/ tmp / rel-1.0.0 / {.} Projeto' arquivos ... feito. '
'/ tmp / rel-1.0.0 / {. Gitignore}' arquivos ... feito. '
'/ tmp / rel-1.0.0 / {. Git}' arquivos ... feito. '
'/ tmp / rel-1.0.0 / {. Gitattributes}' arquivos ... feito. '
'/ tmp / rel-1.0.0 / {*. Mno}' arquivos ... feito. '
'/ tmp / rel-1.0.0 / {* ~}' arquivos ... feito. '
'/ tmp / rel-1.0.0 /{.* ~}' arquivos ... feito. '
'/ tmp / rel-1.0.0 / {* SWP.}' Arquivos ... Done '.
'/ tmp / rel-1.0.0 / {* SWO.}' Arquivos ... feito. '
'/ tmp / rel-1.0.0 / {. DS_Store}' arquivos ... feito. '
'/ tmp / rel-1.0.0 / {. Configurações}' arquivos ... feito. '
'/ tmp / rel-1.0.0 / {. Esvaziar}' arquivos ... feito. '
feito.
arquivamento cuja saída componente (s):. ... feito
-rw-r - r-- uma roda de administração 25445901 03 de novembro 00:57 /tmp/rel-1.0.0.tgz
Eu já incorporou o 'git arquivo' funcionalidade em um único processo que faz uso da 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ê quer algo que funciona com submódulos isso pode valer a pena ir.
Nota:
- MASTER_DIR = um checkout com seus submódulos check-out também
- DEST_DIR = onde essa exportação vai acabar
- Se você tem rsync, eu acho que você seria capaz de fazer a mesma coisa com muito menos dor de bola.
Pressupostos:
- Você precisa executar este do diretório pai de MASTER_DIR (isto é, a partir MASTER_DIR cd ..)
- DEST_DIR é assumido ter sido criado. Isso é muito fácil de modificar para incluir a criação de um DEST_DIR se você quisesse
cd MASTER_DIR && tar -zcvf ../DEST_DIR/export.tar.gz --exclude = 'git. *' . && cd ../DEST_DIR/ && tar xvfz export.tar.gz && rm export.tar.gz
A minha preferência seria realmente ter um dist alvo em seu Makefile (ou outro sistema de construção) que as exportações de um arquivo de distribuição de seu código (.tar.bz2, .zip, .jar, ou o que for apropriado). Se acontecer de você estar usando GNU autotools ou sistemas MakeMaker do Perl, penso que este existe para você automaticamente. Se não, eu recomendo adicioná-lo.
ETA (2012/09/06): Uau, downvotes duras. Eu ainda acredito que é melhor para construir suas distribuições com suas ferramentas de compilação em vez de sua ferramenta de controle de código fonte. Eu acredito na construção de artefatos com ferramentas de compilação. No meu trabalho atual, nosso principal produto é construído com um alvo formiga. Estamos no meio de comutação sistemas de controle de código fonte, e a presença deste meio alvo de formigas um menos problemas na migração.
Isso irá copiar os arquivos em um intervalo de commits (C para G) para um arquivo tar. Nota: isto só irá obter os arquivos comprometidos. Não todo o repositório. Ligeiramente modificado a partir do Aqui
Exemplo Commit Histórico
A -> B ->
git diff-tree -r --no-commit-id --name-only --diff-filter=ACMRT C~..G | xargs tar -rf myTarFile.tar
-r -> recurse em sub-árvores
- não-comprometer-id -> git diff-árvore produz uma linha com o ID cometer quando aplicável. Esta bandeira suprimida a saída ID cometer.
- nome-only -.> Mostrar apenas nomes de arquivos alterados
- diff-filter = ACMRT -> Selecionar apenas esses arquivos. Veja aqui para lista completa dos arquivos
C..G -> Arquivos nesta faixa de commits
C ~ -.> Incluir arquivos de Commit C. Não apenas arquivos desde Commit C
| xargs tar-rf myTarFile -> saídas para tar
Eu precisava disso para um script de implantação e eu não poderia usar qualquer uma das abordagens acima mencionadas. Em vez disso eu 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
Fazê-lo da maneira mais fácil, esta é uma função para .bash_profile, ele descompacta diretamente o arquivo no local atual, configure primeiro o seu habitual [url: caminho]. NOTA:. Com esta função é evitar a operação clone, torna-se directamente a partir do repo 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, mesma configuração necessária (tome cuidado de executar o comando dentro projetos .git, ele sempre salta para o dir de base anteriormente como disse aqui , até que isso seja corrigido Eu 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' -
Como eu entendo a pergunta, ele mais sobre o download de apenas determinado estado do servidor, sem história e sem dados de outros ramos, ao invés de extrair um estado a partir de um repositório local (como muitos anwsers poderá fazê).
Isso pode ser feito da seguinte forma:
git clone -b someBranch --depth 1 --single-branch git://somewhere.com/repo.git \
&& rm -rf repo/.git/
-
--single-branchestá disponível desde o Git 1.7.10 (Abril de 2012). -
--depthé (era?) supostamente defeituoso, mas para o caso de uma exportação, as questões mencionadas não deve importar.
@Aredridel 's mensagem foi mais próximo, mas há um pouco mais para que - por isso vou adicionar este aqui; a coisa é, em svn, se 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
então svn irá exportar todos os arquivos que estão sob controle de revisão (que também poderia ter acabado Adicionado, ou estado Modified) - e se você tem outro "lixo" nesse diretório (e eu não estou contando subpastas .svn aqui, mas coisas visíveis como arquivos .o), ele irá não ser exportado; apenas os arquivos registrados pela repo SVN serão exportados. Para mim, um bom é que essa exportação também inclui arquivos com as mudanças locais que têm não foi ainda comprometida; e outra coisa boa é que a data e hora dos arquivos exportados são os mesmos que os originais. Ou, como coloca svn help export-lo:
- exporta uma árvore de diretórios limpa a partir da cópia de trabalho especificado pelo CAMINHO1, na revisão REV se for dado, caso contrário, no trabalho, em PATH2. ... Se REV não for especificado, todos os locais alterações será preservada. Arquivos que não estão sob a vontade de controle de versão não ser copiadas.
Para perceber que git não vai preservar as marcas de tempo, compare a saída desses comandos (em uma subpasta de um repo git 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, observe que git archive faz com que todos os timestamps do arquivo morto para ser o mesmo! git help archive diz:
comporta git archive diferente quando dado um ID árvore versus quando dada uma confirmação de identidade ou etiqueta de identificação. No primeiro caso, o hora atual é usado como o tempo de modificação de cada arquivo no arquivo. Neste último caso, o tempo de cometer como registrado no objeto referenciado cometer é usado em seu lugar.
... mas aparentemente ambos os casos, definir o "tempo de modificação de cada arquivo"; assim, não preservando a data e hora reais desses arquivos!
Assim, a fim de também preservar as marcas de tempo, aqui está um script bash, que é na verdade um "one-liner", embora um pouco complicado - assim abaixo que é publicado 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 \
)
Note que presume-se que você está exportando o conteúdo no diretório "corrente" (acima, /media/disk/git_svn/subdir) - e o destino que você está exportando para é um pouco inconvenientemente colocado, mas é na variável de ambiente DEST. Note-se que com este roteiro; você deve criar o diretório DEST manualmente mesmo, antes de executar o script acima.
Depois que o script é executado, você deve ser capaz de comparar:
ls -la /media/disk/git_svn/subdir
ls -la /media/diskC/tmp/subdirB # DEST
... e esperamos ver as mesmas marcas de tempo (para aqueles arquivos que estavam sob controle de versão).
Espero que isso ajude alguém,
Felicidades!
De longe a maneira mais fácil eu vi para fazê-lo (e funciona em Windows também) é git bundle:
git bundle create /some/bundle/path.bundle --all
Veja esta resposta para mais detalhes: Como posso copiar meu repositório git da minha máquina Windows para uma máquina linux via drive USB?
Eu tenho uma outra solução que funciona bem se você tiver uma cópia local do repositório na máquina em que você gostaria de criar a exportação. Neste caso mudança para este diretório repositório, e digite o comando:
GIT_WORK_TREE=outputdirectory git checkout -f
Isto é particularmente útil se você gerencia um website com um repositório git e gostaria de fazer o checkout uma versão limpa em /var/www/. Neste caso, adicione thiscommand em um script .git/hooks/post-receive (hooks/post-receive em um repositório nua, que é mais adequado nesta situação)
a exportação git para um arquivo zip enquanto a adição de um prefixo (por exemplo, nome do diretório):
git archive master --prefix=directoryWithinZip/ --format=zip -o out.zip
Se precisar de submódulos, bem, isso deve fazer o truque: https: / /github.com/meitar/git-archive-all.sh/wiki
Eu tenho a seguinte função de utilidade no meu arquivo .bashrc:. Ele cria um arquivo do ramo 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
}
