Zrobić "git export" (jak "svn export")?

Dowiedziałem się, co oznacza opcja 2. Z repozytorium można zrobić:

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

Ukośnik na końcu ścieżki jest ważny, w przeciwnym razie spowoduje, że pliki będą w / destination z prefiksem 'path'.

Ponieważ w normalnej sytuacji indeks zawiera zawartość repozytorium, nie ma nic specjalnego do zrobienia, aby "odczytać żądane drzewo do indeksu". Już tam jest.

Znacznik -a jest wymagany do sprawdzenia wszystkich plików w indeksie (Nie wiem co to znaczy pominąć tę flagę w tej sytuacji, ponieważ nie robi tego, co chcę). Znacznik -f wymusza nadpisanie wszystkich istniejących plików na wyjściu, czego normalnie nie robi to polecenie.

To wygląda na rodzaj "git export", którego szukałem.

git archive działa również ze zdalnym repozytorium.

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

Aby wyeksportować konkretną ścieżkę wewnątrz repo Dodaj do git tyle ścieżek ile chcesz jako ostatni argument, np.:

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

Odpowiedź na specjalny przypadek, jeśli repozytorium jest hostowane na Githubie.

Po prostu użyj svn export.

Z tego co wiem Github nie pozwala archive --remote. Chociaż GitHub jest kompatybilny z svn i mają wszystkie repozytoria git svn dostępne, więc możesz po prostu użyć svn export, Jak zwykle z kilkoma poprawkami adresu URL Githuba.

Na przykład, aby wyeksportować całe repozytorium, zwróć uwagę, jak trunk w adresie URL zastępuje master (lub cokolwiek innego gałąź główna projektu jest ustawiona na):

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

I możesz wyeksportować pojedynczy plik lub nawet określoną ścieżkę lub folder:

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

Przykład z jquery JavaScript Library

The HEAD branch or master branch będzie dostępny za pomocą trunk:

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

The non-HEAD oddziały będą dostępne pod /branches/:

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

Wszystkie tagi pod /tags/ W ten sam sposób:

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

From the Git Manual :

Użycie git-checkout-index do "Eksportuj całe drzewo"

Możliwość przedrostka sprawia, że używanie git-checkout-index jako funkcji "export as tree" jest banalne. Po prostu Wczytaj żądane drzewo do indeksu i wykonaj:

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

Napisałem prosty wrapper git-checkout-index, którego możesz użyć Tak:

git export ~/the/destination/dir

Jeśli katalog docelowy już istnieje, musisz dodać -f lub --force.

Instalacja jest prosta; po prostu upuść skrypt gdzieś w swoim PATH i upewnij się, że jest wykonywalny.

Repozytorium github dla git-export

Wygląda na to, że jest to mniej problem z Git niż SVN. Git stawia tylko a .folder git w katalogu głównym repozytorium, podczas gdy SVN umieszcza .folder svn w każdym podkatalogu. Tak więc "svn export" unika rekurencyjnej magii wiersza poleceń, podczas gdy w przypadku Gita rekurencja nie jest konieczna.

Odpowiednik

svn export . otherpath

Wewnątrz istniejącego repo jest

git archive branchname | (cd otherpath; tar x)

Odpowiednik

svn export url otherpath

Jest

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

Używam Git-submodules intensywnie. Ten mi działa:

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

Jeśli nie wykluczasz plików z .gitattributes export-ignore Następnie spróbuj git checkout

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

-f
Podczas sprawdzania ścieżek z indeksu, nie zawiedź po niezaangażowaniu wpisy; zamiast tego niezerowane wpisy są ignorowane.

I

-q
Avoid verbose

Dodatkowo możesz uzyskać dowolną gałąź lub Tag lub z określonej rewizji Commit, jak w SVN po prostu dodając SHA1 (SHA1 w Git jest odpowiednikiem numeru rewizji w SVN)

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

/path/to/checkout/ musi być pusty, Git nie usunie żadnego pliku, ale nadpisze pliki o tej samej nazwie bez ostrzeżenia

UPDATE: Aby uniknąć problemu ścięcia głowy lub pozostawić nienaruszone działające repozytorium podczas korzystania z checkout do eksportu z tagami, gałęziami lub SHA1, musisz dodać -- ./ na końcu

Podwójny dash -- mówi gitowi, że wszystko po myślnikach to ścieżki lub pliki, a także w tym przypadku mówi git checkout, aby nie zmieniać HEAD

Przykłady:

To polecenie otrzyma tylko katalog libs, a także plik readme.txt z tego właśnie commita

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

Spowoduje to utworzenie(nadpisanie) my_file_2_behind_HEAD.txt dwóch commitów za głową 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

Aby uzyskać eksport innego oddziału

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

Zauważ, że {[16] } jest względem katalogu głównego repozytorium

To skopiuje całą zawartość, minus .pliki dot. Używam tego do eksportowania projektów Git klonowane do mojej aplikacji internetowej Git repo bez .git stuff.

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

Zwykły stary bash działa po prostu świetnie:)

Często trafiałem na tę stronę, szukając sposobu na eksport repozytorium git. Moja odpowiedź na to pytanie dotyczy trzech właściwości, które svn export ma z założenia w porównaniu z Gitem, ponieważ svn działa w oparciu o scentralizowane repozytorium:

• minimalizuje ruch do zdalnego repozytorium, nie eksportując wszystkich wersji
• nie zawiera meta informacji w katalogu eksportu

• Eksportowanie określonej gałęzi za pomocą svn odbywa się przez określenie odpowiedniej ścieżki

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

Przy budowaniu pewnego wydania warto sklonować stabilną gałąź, jak na przykład --branch stable lub --branch release/0.9.

Tak proste jak klon, a następnie usuń .folder git:

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

Chcę tylko zaznaczyć, że w przypadku, gdy jesteś

1. eksportowanie podfolderu repozytorium (w ten sposób korzystałem z funkcji eksportu SVN)
2. są w porządku z kopiowaniem wszystkiego z tego folderu do miejsca docelowego wdrożenia
3. a ponieważ masz już kopię całego repozytorium.

Wtedy możesz po prostu użyć cp foo [destination] zamiast wspomnianego git-archive master foo | -x -C [destination].

Dla użytkowników GitHub, metoda git archive --remote nie będzie działać bezpośrednio, ponieważ adres URL eksportu jest efemeryczny . Musisz poprosić GitHub o adres URL, a następnie pobrać ten adres URL. curl ułatwia:

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

To da ci wyeksportowany kod w lokalnym katalogu. Przykład:

$ 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

Edit
Jeśli chcesz umieścić kod w konkretnym, istniejącym katalogu (zamiast losowego z github):

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

Możesz zarchiwizować zdalne repo w dowolnym commicie jako plik zip.

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

Tak, to jest czystym i schludnym poleceniem do archiwizacji Twojego kodu bez włączania git do archiwum i jest dobre do przekazania bez martwienia się o historię zatwierdzeń git.

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

Bash-implementacja git-export.

Podzieliłem ... procesy tworzenia i usuwania pustych plików we własnej funkcji, w celu ich ponownego wykorzystania w implementacji 'Git-archive' (zostaną opublikowane później).

Dodałem również '.gitatt przypisuje plik do procesu w celu usunięcia nie poszukiwanych plików z docelowego folderu eksportu. Dodano szczegółowość procesu, czyniąc funkcję' Git-export ' bardziej wydajny.

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

Wyjście:

$ git-export /tmp/rel-1.0.0

Dodawanie".empty ' pliki do pustych folderów: ... załatwione.

Sprawdzanie składowych indeksu (- ów): ... załatwione.

Resetowanie głowicy i indeksu: ... załatwione.

Czyszczenie specyficznych dla Gita komponentów: ...

' / tmp / rel-1.0.0 / {.buildpath}' pliki ... załatwione.'

' / tmp / rel-1.0.0 / {./ align = "left" / .. załatwione.'

' / tmp / rel-1.0.0 / {./ align = "left" / .. załatwione.'

' / tmp / rel-1.0.0 / {./ align = "left" / .. załatwione.'

' / tmp / rel-1.0.0 / {.gitattributes} ' pliki... załatwione.'

' / tmp / rel-1.0.0 / { * ./ align = "left" / .. załatwione.'

'/tmp/rel-1.0.0/{*~}' pliki ... załatwione.'

' / tmp / rel-1.0.0 / {./ align = "left" / .. załatwione.'

' / tmp / rel-1.0.0 / { * .pliki swp ... załatwione.'

' / tmp / rel-1.0.0 / { * .pliki swo ... załatwione.'

' / tmp / rel-1.0.0 / {.DS_Store}" pliki ... załatwione.'

' / tmp / rel-1.0.0 / {.ustawienia} ' pliki... załatwione.'

' / tmp / rel-1.0.0 / {.puste} ' pliki ... załatwione.'

Zrobione.

Archiwizacja danych: ... załatwione.

-RW-R--R-- 1 Admin wheel 25445901 3 lis 12: 57/tmp / rel-1.0.0.tgz

Włączyłem teraz funkcjonalność 'Git archive' do jednego procesu, który korzysta z funkcji 'create_empty' i innych funkcji.

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

Jeśli chcesz coś, co działa z modułami podrzędnymi, może to być warte wypróbowania.

Uwaga:

• MASTER_DIR = a checkout with your submodules checkOut also
• DEST_DIR = gdzie skończy się ten eksport
• Jeśli masz rsync, myślę, że będziesz w stanie zrobić to samo z jeszcze mniejszym bólem piłki.

Założenia:

• musisz to uruchomić z katalogu nadrzędnego MASTER_DIR (tzn. z płyty MASTER_DIR.. )
• zakłada się DEST_DIR zostać stworzonym. Jest to dość łatwe do modyfikacji, aby uwzględnić utworzenie DEST_DIR, jeśli chcesz

Cd MASTER_DIR & & tar-zcvf ../ DEST_DIR / export.smoła.gz --exclude='.git*" . && Cd../ DEST_DIR / & & tar xvfz export.smoła.gz & & RM export.smoła.gz

Spowoduje skopiowanie plików w zakresie zatwierdzeń (od C do G) do pliku tar. Uwaga: spowoduje to tylko pobranie plików. Nie całe repozytorium. Nieco zmodyfikowany z Tutaj

Przykładowa Historia Zatwierdzania

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

Strona podręcznika Git-diff-tree

-r -- > recurse into sub-trees

--no-commit-id -- > git diff-tree wyświetla linię z identyfikatorem commit, jeśli ma to zastosowanie. Ta flaga wyłączono wyjście ID zatwierdzenia.

--name-only -- > pokazuje tylko nazwy zmienionych plików.

--diff-filter=ACMRT -- > wybierz tylko te pliki. zobacz tutaj pełną listę plików

C..G -- > pliki w tym zakresie commitów

C ~ -- > Dołącz pliki z Commit C. nie tylko pliki od Commit C.

/ xargs tar-RF myTarFile --> wyjścia do tar

Moją preferencją byłoby posiadanie Dist w pliku Makefile (lub innym systemie budowania), który eksportuje dystrybuowalne archiwum Twojego kodu (.tar.bz2,.zip,słoik, czy cokolwiek jest właściwe). Jeśli przypadkiem używasz Autotools GNU lub systemów Makemaker Perla, myślę, że istnieje to dla ciebie automatycznie. Jeśli nie, Gorąco polecam dodanie go.

ETA (2012-09-06): Wow, ostre dowcipy. Nadal uważam, że lepiej jest budować swoje dystrybucje za pomocą narzędzi do budowania zamiast narzędzia kontroli kodu źródłowego. Wierzę w budowanie artefaktów za pomocą narzędzi budowlanych. W mojej obecnej pracy, nasz główny produkt jest zbudowany z celu mrówki. Jesteśmy w trakcie przełączania systemów kontroli kodu źródłowego, a obecność tego celu ant oznacza jeden mniej kłopotów w migracji.

Potrzebowałem tego do skryptu deploy i nie mogłem użyć żadnego z wyżej wymienionych podejść. Zamiast tego wymyśliłem inne rozwiązanie:

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

Robiąc to w prosty sposób, jest to funkcja dla .bash_profile, bezpośrednio rozpakowuje archiwum w bieżącej lokalizacji, najpierw skonfiguruj swój zwykły [url:path]. Uwaga: dzięki tej funkcji unikasz operacji klonowania, dostaje się bezpośrednio ze zdalnego repo.

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 dla .gitconfig, ta sama konfiguracja wymagana (dbaj o wykonanie polecenia w środku .projekty git, zawsze przeskakuje do bazowego katalogu poprzednio Jak tu pisałem , dopóki to nie zostanie naprawione osobiście wolę function

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

Myślę, że @Aredridel 's post był najbliżej, ale jest trochę więcej do tego - więc dodam to tutaj; rzecz w tym, że w svn, jeśli jesteś w podfolderze repo, i robisz:

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

Wtedy svn wyeksportuje wszystkie pliki, które są pod kontrolą wersji (mogły być również świeżo dodane lub zmodyfikowane) - i jeśli masz inne "śmieci" w tym katalogu ( i nie liczę podfolderów .svn, ale widoczne rzeczy, takie jak .o Pliki), to Nie będą eksportowane; tylko te pliki zarejestrowane przez repo SVN będą eksportowane. Dla mnie jedną miłą rzeczą jest to, że ten eksport zawiera również pliki z lokalnymi zmianami, które nie zostały jeszcze zatwierdzone; a kolejną miłą rzeczą jest to, że znaczniki czasu wyeksportowanych plików są takie same jak oryginalne. Albo, jak to ujął svn help export:

1. eksportuje czyste drzewo katalogów z kopii roboczej określonej przez PATH1, przy rewizji REV, jeśli jest podana, w przeciwnym razie przy pracy, do PATH2. ... Jeżeli REV Nie podano, wszystkie lokalne zmiany zostaną zachowane. Pliki nie pod kontrolą wersji będą nie być kopiowane.

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

... oraz:

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

... i w każdym razie zauważam, że git archive powoduje, że wszystkie znaczniki czasu zarchiwizowanego pliku są takie same! git help archive says:

Git archiwum zachowuje się inaczej, gdy podano identyfikator drzewa, niż gdy podano identyfikator zatwierdzenia lub znacznika. W pierwszym przypadku czas bieżący jest używany jako czas modyfikacji KAŻDEGO pliku w archiwum. W tym drugim przypadku czas zatwierdzenia zapisany w odwołanym commit obiekt jest używany zamiast.

... ale najwyraźniej oba przypadki ustawiają " czas modyfikacji KAŻDEGO pliku "; tym samym Nie zachowując rzeczywiste znaczniki czasu tych plików!

Tak więc, aby również zachować w 1999 roku, w wyniku połączenia się z firmą, w 1999 roku, firma została założona przez firmę, która w 1999 roku została założona przez firmę, a w 1999 roku została założona przez firmę.]}

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

Zauważ, że zakłada się, że eksportujesz zawartość w katalogu" current " (powyżej, /media/disk/git_svn/subdir) - a miejsce docelowe, do którego eksportujesz, jest nieco niewygodnie umieszczone, ale znajduje się w zmiennej środowiskowej DEST. Zauważ, że za pomocą tego skryptu musisz utworzyć katalog DEST ręcznie, przed uruchomieniem powyższego skryptu.

Po uruchomieniu skryptu powinieneś być w stanie porównać:

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

... i mam nadzieję, że zobaczą te same znaczniki czasu (dla tych plików, które były pod kontrolą wersji).

Mam nadzieję, że to komuś pomoże,
Zdrowie!

Zdecydowanie najprostszym sposobem, jaki widziałem, aby to zrobić (i działa również na windows) jest git bundle:

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

Zobacz tę odpowiedź po więcej szczegółów: Jak mogę skopiować moje repozytorium git z komputera z systemem windows na komputer z Linuksem za pomocą dysku usb?

Jeśli potrzebujesz również podmodułów, powinno to załatwić sprawę: https://github.com/meitar/git-archive-all.sh/wiki

Jak rozumiem pytanie, chodzi raczej o pobieranie tylko pewnego stanu z serwera, bez historii i bez danych z innych gałęzi, a nie wyciąganie stanu z lokalnego repozytorium(jak wiele anwserów tutaj robi).

To można zrobić tak:

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

• --single-branch jest dostępny od wersji Git 1.7.10 (kwiecień 2012).
• --depth is (was?) podobno wadliwe, ale w przypadku eksportu wymienione kwestie nie powinny mieć znaczenia.

Mam następujące funkcje użytkowe w moim .plik bashrc: tworzy archiwum bieżącej gałęzi w repozytorium 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
}

Opcja 1 brzmi niezbyt wydajnie. Co jeśli w kliencie nie ma miejsca na klonowanie i , a następnie usunięcie folderu .git?

Dzisiaj znalazłem się próbuje to zrobić, gdzie klient jest Raspberry Pi prawie nie ma miejsca w lewo. Co więcej, chcę również wykluczyć jakiś ciężki folder z repozytorium.

Opcja 2 i inne odpowiedzi tutaj nie pomagają w tym scenariuszu. Ani git archive (ponieważ wymaga zatwierdzenia pliku .gitattributes, a ja nie chcę tego zapisać wykluczenie w repozytorium).

Tutaj dzielę się moim rozwiązaniem, podobnym do opcji 3, ale bez potrzeby git clone:

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

Zmiana linii rsync na równoważną linię dla compressa będzie również działać jako git archive, ale z opcją wykluczania (tak jak jest to wymagane tutaj).

Mam inne rozwiązanie, które działa dobrze, jeśli masz lokalną kopię repozytorium na komputerze, na którym chcesz utworzyć eksport. W tym przypadku przejdź do tego katalogu repozytorium i wprowadź następujące polecenie:

GIT_WORK_TREE=outputdirectory git checkout -f

Jest to szczególnie przydatne, jeśli zarządzasz stroną internetową z repozytorium git i chcesz zamówić czystą wersję w /var/www/. W tym przypadku dodaj thiscommand w skrypcie .git/hooks/post-receive (hooks/post-receive na gołym repozytorium, co jest bardziej odpowiednie w tym situation)