Apakah "git export" (seperti "svn export")?

Saya telah bertanya-tanya apakah ada solusi "git export" yang baik yang membuat salinan pohon tanpa .gitdirektori repositori. Setidaknya ada tiga metode yang saya tahu:

1. git clonediikuti dengan menghapus .gitdirektori repositori.
2. git checkout-index menyinggung fungsi ini tetapi dimulai dengan "Baca saja pohon yang diinginkan ke dalam indeks ..." yang saya tidak sepenuhnya yakin bagaimana melakukannya.
3. git-exportadalah skrip pihak ketiga yang pada dasarnya melakukan a git cloneke lokasi sementara diikuti oleh rsync --exclude='.git'ke tujuan akhir.

Tak satu pun dari solusi ini yang menurut saya memuaskan. Yang terdekat svn exportmungkin adalah opsi 1, karena keduanya memerlukan direktori target menjadi kosong terlebih dahulu. Tetapi opsi 2 tampaknya lebih baik, dengan asumsi saya bisa mencari tahu apa artinya membaca pohon ke dalam indeks.

Mungkin cara paling sederhana untuk mencapai ini adalah dengan git archive. Jika Anda benar-benar membutuhkan hanya pohon yang diperluas, Anda dapat melakukan sesuatu seperti ini.

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

Sebagian besar waktu saya perlu 'mengekspor' sesuatu dari git, saya ingin arsip terkompresi dalam hal apa pun jadi saya melakukan sesuatu seperti ini.

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

Arsip ZIP:

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

git help archive untuk lebih jelasnya cukup fleksibel.

Ketahuilah bahwa meskipun arsip tidak akan berisi direktori .git, namun, arsip itu akan berisi file tersembunyi khusus git seperti .gitignore, .gitattributes, dll. Jika Anda tidak menginginkannya di arsip, pastikan Anda gunakan atribut ekspor-abaikan dalam file .gitattributes dan lakukan ini sebelum melakukan arsip Anda. Baca lebih banyak...

Catatan: Jika Anda tertarik untuk mengekspor indeks, perintahnya adalah

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

(Lihat jawaban Greg untuk lebih jelasnya)

Saya menemukan apa artinya opsi 2. Dari repositori, Anda dapat melakukan:

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

Slash pada akhir path penting, jika tidak maka akan menghasilkan file / tujuan dengan awalan 'path'.

Karena dalam situasi normal indeks berisi isi repositori, tidak ada yang istimewa untuk dilakukan "membaca pohon yang diinginkan ke dalam indeks". Sudah ada di sana.

The -aflag diperlukan untuk memeriksa semua file dalam indeks (saya tidak yakin apa artinya untuk menghilangkan bendera ini dalam situasi ini, karena tidak melakukan apa yang saya inginkan). The -fpasukan bendera Timpa file yang ada dalam output, yang perintah ini tidak biasanya melakukan.

Tampaknya ini semacam "ekspor git" yang saya cari.

git archive juga bekerja dengan repositori jarak jauh.

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

Untuk mengekspor path tertentu di dalam repo, tambahkan path sebanyak yang Anda inginkan sebagai argumen terakhir ke git, misalnya:

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

Jawaban kasus khusus jika repositori di-host di GitHub.

Gunakan saja svn export.

Sejauh yang saya tahu Github tidak mengizinkan archive --remote. Meskipun GitHub kompatibel dengan svn dan mereka memiliki semua repositori git svndapat diakses sehingga Anda bisa menggunakannya svn exportseperti biasanya dengan beberapa penyesuaian pada url GitHub Anda.

Misalnya untuk mengekspor seluruh repositori, perhatikan bagaimana trunkURL menggantikan master(atau apa pun cabang HEAD proyek diatur ke ):

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

Dan Anda dapat mengekspor satu file atau bahkan path atau folder tertentu:

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

Contoh dengan jQuery JavaScript Library

The HEADcabang atau Master cabang akan menggunakan tersedia trunk:

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

Non- HEAD cabang akan dapat diakses di bawah /branches/:

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

Semua tag dengan /tags/cara yang sama:

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

Dari Manual Git :

Menggunakan git-checkout-index untuk "mengekspor seluruh pohon"

Kemampuan awalan pada dasarnya membuatnya sepele untuk menggunakan git-checkout-index sebagai fungsi "ekspor sebagai pohon". Baca saja pohon yang diinginkan ke dalam indeks, dan lakukan:

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

Saya telah menulis pembungkus sederhana git-checkout-indexyang dapat Anda gunakan seperti ini:

git export ~/the/destination/dir

Jika direktori tujuan sudah ada, Anda harus menambahkan -fatau --force.

Instalasi sederhana; cukup letakkan script di suatu tempat di Anda PATH, dan pastikan itu dapat dieksekusi.

Repositori github untuk git-export

Tampaknya ini bukan masalah dengan Git daripada SVN. Git hanya menempatkan folder .git di root repositori, sedangkan SVN menempatkan folder .svn di setiap subdirektori. Jadi "ekspor svn" menghindari sihir baris perintah rekursif, sedangkan dengan rekursi Git tidak diperlukan.

Setara dengan

svn export . otherpath

di dalam repo yang ada adalah

git archive branchname | (cd otherpath; tar x)

Setara dengan

svn export url otherpath

adalah

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

Jika Anda tidak termasuk file dengan .gitattributes export-ignoremaka cobagit checkout

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

-f
Saat memeriksa jalur dari indeks, jangan gagal pada entri yang tidak di-emergasi; sebagai gantinya, entri yang tidak dihapus diabaikan.

dan

-q
Hindari verbose

Selain itu Anda bisa mendapatkan Cabang atau Tag atau dari Revisi Komit tertentu seperti di SVN hanya menambahkan SHA1 (SHA1 di Git adalah setara dengan Nomor Revisi di SVN)

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

The /path/to/checkout/harus kosong, Git tidak akan menghapus file apapun, tetapi akan menimpa file-file dengan nama yang sama tanpa peringatan

PEMBARUAN: Untuk menghindari masalah pemenggalan kepala atau meninggalkan repositori yang berfungsi saat menggunakan checkout untuk ekspor dengan tag, cabang atau SHA1, Anda perlu menambahkan -- ./di bagian akhir

Tanda hubung ganda --memberitahu git bahwa segala sesuatu setelah tanda hubung adalah path atau file, dan juga dalam hal ini memberitahu git checkoutuntuk tidak mengubahHEAD

Contoh:

Perintah ini hanya akan mendapatkan direktori libs dan juga readme.txtfile dari commit tersebut

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

Ini akan membuat (menimpa) my_file_2_behind_HEAD.txtdua komit di belakang kepalaHEAD^2

git --git-dir=/path/to/repo/.git --work-tree=/path/to/checkout/ checkout HEAD^2 -f -q -- ./my_file_2_behind_HEAD.txt

Untuk mendapatkan ekspor cabang lain

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

Perhatikan bahwa ./itu relatif terhadap akar repositori

Saya menggunakan git-submodules secara ekstensif. Yang ini bekerja untuk saya:

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

Saya sering mengenai halaman ini ketika mencari cara untuk mengekspor repositori git. Jawaban saya untuk pertanyaan ini mempertimbangkan tiga properti yang svn ekspor telah desain dibandingkan dengan git, karena svn mengikuti pendekatan repositori terpusat:

• Ini meminimalkan lalu lintas ke lokasi repositori jauh dengan tidak mengekspor semua revisi
• Itu tidak termasuk informasi meta dalam direktori ekspor

• Mengekspor cabang tertentu menggunakan svn dilakukan dengan menentukan jalur yang sesuai

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

Saat membuat rilis tertentu, penting untuk mengkloning cabang stabil seperti misalnya --branch stableatau --branch release/0.9.

Ini akan menyalin semua konten, minus file .dot. Saya menggunakan ini untuk mengekspor proyek klon git ke repo git aplikasi web saya tanpa barang .git.

cp -R ./path-to-git-repo / path / ke / tujuan /

Pesta tua polos bekerja sangat bagus :)

Sesederhana klon kemudian hapus folder .git:

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

Untuk pengguna GitHub, git archive --remotemetode ini tidak akan berfungsi secara langsung, karena URL ekspor bersifat sementara . Anda harus meminta URL GitHub, lalu unduh URL itu. curlmembuatnya mudah:

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

Ini akan memberi Anda kode yang diekspor di direktori lokal. Contoh:

$ 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

Sunting
Jika Anda ingin kode dimasukkan ke direktori tertentu yang ada (bukan yang acak dari github):

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

Ya, ini adalah perintah yang bersih dan rapi untuk mengarsipkan kode Anda tanpa ada git yang dimasukkan dalam arsip dan baik untuk diedarkan tanpa khawatir tentang riwayat git commit.

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

Saya hanya ingin menunjukkan bahwa dalam kasus Anda

1. mengekspor sub folder repositori (itulah yang saya gunakan untuk menggunakan fitur ekspor SVN)
2. tidak masalah dengan menyalin segala sesuatu dari folder itu ke tujuan penyebaran
3. dan karena Anda sudah memiliki salinan seluruh repositori di tempatnya.

Maka Anda bisa menggunakan cp foo [destination]bukan yang disebutkan git-archive master foo | -x -C [destination].

Anda dapat mengarsipkan repo jarak jauh di komit apa pun sebagai file zip.

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

Bash-implementasi git-ekspor.

Saya telah mensegmentasi proses pembuatan dan penghapusan file .empty pada fungsinya sendiri, dengan tujuan untuk menggunakannya kembali dalam implementasi 'git-archive' (akan diposting nanti).

Saya juga telah menambahkan file '.gitattributes' ke proses untuk menghapus file yang tidak diinginkan dari folder ekspor target. Termasuk verbosity ke proses sementara membuat fungsi 'git-ekspor' lebih efisien.

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

Keluaran:

$ git-export /tmp/rel-1.0.0

Menambahkan file '.empty' ke folder kosong: ... selesai.

Komponen Indeks Memeriksa: ... selesai.

Menyetel ulang KEPALA dan Indeks: ... selesai.

Membersihkan komponen Khusus Git: ...

'/tmp/rel-1.0.0/{.buildpath}' file ... selesai. '

'/tmp/rel-1.0.0/{.project}' file ... selesai. '

'/tmp/rel-1.0.0/{.gitignore}' file ... selesai. '

'/tmp/rel-1.0.0/{.git}' file ... selesai. '

'/tmp/rel-1.0.0/{.gitattributes}' file ... selesai. '

'/tmp/rel-1.0.0/{*.mno}' file ... selesai. '

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

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

'/tmp/rel-1.0.0/{*.swp}' file ... selesai. '

'/tmp/rel-1.0.0/{*.swo}' file ... selesai. '

'/tmp/rel-1.0.0/{.DS_Store}' file ... selesai. '

'/tmp/rel-1.0.0/{.settings}' file ... selesai. '

'/tmp/rel-1.0.0/{.empty}' file ... selesai. '

selesai

Komponen Pengarsipan Diperiksa: ... selesai.

-rw-r - r-- 1 admin roda 25445901 3 Nov 12:57 /tmp/rel-1.0.0.tgz

Saya sekarang telah memasukkan fungsionalitas 'arsip git' ke dalam satu proses yang memanfaatkan fungsi 'create_empty' dan fitur lainnya.

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

Jika Anda menginginkan sesuatu yang berfungsi dengan submodula, ini mungkin layak untuk dicoba.

catatan:

• MASTER_DIR = checkout dengan kiriman Anda juga diperiksa
• DEST_DIR = tempat ekspor ini akan berakhir
• Jika Anda memiliki rsync, saya pikir Anda akan dapat melakukan hal yang sama dengan sakit bola yang bahkan lebih sedikit.

Asumsi:

• Anda perlu menjalankan ini dari direktori induk MASTER_DIR (yaitu dari MASTER_DIR cd ..)
• DEST_DIR diasumsikan telah dibuat. Ini cukup mudah dimodifikasi untuk memasukkan pembuatan DEST_DIR jika Anda mau

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

Preferensi saya sebenarnya adalah memiliki dist target di Makefile Anda (atau sistem build lain) yang mengekspor arsip yang dapat didistribusikan kode Anda (.tar.bz2, .zip, .jar, atau apa pun yang sesuai). Jika Anda menggunakan autotools GNU atau sistem MakeMaker Perl, saya pikir ini ada untuk Anda secara otomatis. Jika tidak, saya sangat merekomendasikan untuk menambahkannya.

ETA (2012-09-06): Wow, downvotes yang keras. Saya masih percaya bahwa lebih baik untuk membangun distribusi Anda dengan alat membangun Anda daripada alat kontrol kode sumber Anda. Saya percaya dalam membangun artefak dengan alat membangun. Dalam pekerjaan saya saat ini, produk utama kami dibangun dengan target semut. Kami berada di tengah-tengah beralih sistem kontrol kode sumber, dan keberadaan target semut ini berarti satu kerumitan dalam migrasi.

Ini akan menyalin file dalam rentang komit (C ke G) ke file tar. Catatan: ini hanya akan membuat file berkomitmen. Bukan seluruh repositori. Sedikit dimodifikasi dari sini

Contoh Sejarah Komit

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

Halaman Manual git-diff-tree

-r -> recurse menjadi sub-tree

--no-commit-id -> git diff-tree menampilkan baris dengan ID komit jika berlaku. Bendera ini menekan output ID komit.

--nama-saja -> Tampilkan hanya nama file yang diubah.

--diff-filter = ACMRT -> Pilih hanya file-file ini. Lihat di sini untuk daftar lengkap file

C..G -> File dalam rentang komit ini

C ~ -> Sertakan file dari Komit C. Bukan hanya file sejak Komit C.

| xargs tar -rf myTarFile -> output ke tar

Seperti yang saya pahami pertanyaannya, ini lebih tentang mengunduh keadaan tertentu dari server, tanpa riwayat, dan tanpa data cabang lain, daripada mengekstraksi keadaan dari repositori lokal (seperti yang dilakukan banyak penjawab di sini).

Itu bisa dilakukan seperti ini:

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

• --single-branch tersedia sejak Git 1.7.10 (April 2012).
• --depthapakah (ternyata?) dilaporkan salah, tetapi untuk kasus ekspor, masalah yang disebutkan seharusnya tidak menjadi masalah.

Saya membutuhkan ini untuk skrip penyebaran dan saya tidak bisa menggunakan salah satu pendekatan yang disebutkan di atas. Sebaliknya saya menemukan solusi yang berbeda:

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

Melakukannya dengan cara mudah, ini adalah fungsi untuk .bash_profile, secara langsung membuka ritsleting arsip di lokasi saat ini, konfigurasikan dulu [url: path] Anda yang biasa. CATATAN: Dengan fungsi ini Anda menghindari operasi klon, itu langsung dari repo jarak jauh.

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 ​​untuk .gitconfig, konfigurasi yang sama diperlukan (TAKE CARE menjalankan perintah di dalam proyek .git, SELALU melompat ke dir basis sebelumnya seperti yang dikatakan di sini , sampai ini diperbaiki, saya pribadi lebih suka fungsi

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

Sejauh ini cara termudah yang pernah saya lihat untuk melakukannya (dan bekerja di windows juga) adalah git bundle:

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

Lihat jawaban ini untuk lebih jelasnya: Bagaimana saya bisa menyalin repositori git saya dari mesin windows saya ke mesin linux via usb drive?

Saya punya solusi lain yang berfungsi dengan baik jika Anda memiliki salinan lokal repositori di mesin tempat Anda ingin membuat ekspor. Dalam hal ini, pindah ke direktori repositori ini, dan masukkan perintah ini:

GIT_WORK_TREE=outputdirectory git checkout -f

Ini sangat berguna jika Anda mengelola situs web dengan repositori git dan ingin checkout versi bersih di /var/www/. Dalam hal ini, tambahkan perintah ini dalam .git/hooks/post-receiveskrip ( hooks/post-receivepada repositori kosong, yang lebih cocok dalam situasi ini)

Saya pikir posting @Aredridel adalah yang terdekat, tetapi ada sedikit lebih dari itu - jadi saya akan menambahkan ini di sini; masalahnya adalah, di svn, jika Anda berada dalam subfolder dari repo, dan Anda melakukannya:

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

kemudian svnakan mengekspor semua file yang berada di bawah kendali revisi (mereka mungkin juga baru saja ditambahkan; atau status yang dimodifikasi) - dan jika Anda memiliki "sampah" lain di direktori itu (dan saya tidak menghitung .svnsubfolder di sini, tetapi hal-hal yang terlihat seperti .ofile) , itu tidak akan diekspor; hanya file-file yang terdaftar oleh repo SVN yang akan diekspor. Bagi saya, satu hal yang menyenangkan adalah bahwa ekspor ini juga menyertakan file dengan perubahan lokal yang belum dilakukan; dan satu lagi yang menyenangkan adalah bahwa cap waktu dari file yang diekspor sama dengan yang asli. Atau, seperti yang svn help exportdikatakan:

2. Mengekspor pohon direktori bersih dari copy pekerjaan yang ditentukan oleh PATH1, pada revisi REV jika diberikan, jika tidak di BEKERJA, ke PATH2. ... Jika REV tidak ditentukan, semua perubahan lokal akan dipertahankan. File yang tidak di bawah kendali versi tidak akan disalin.

Untuk menyadari bahwa gittidak akan menyimpan stempel waktu, bandingkan output dari perintah-perintah ini (dalam subfolder dari gitrepo pilihan Anda):

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

... dan:

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

... dan saya, dalam hal apapun, pemberitahuan yang git archivemenyebabkan semua cap waktu dari file yang diarsipkan sama! git help archivemengatakan:

arsip git berperilaku berbeda ketika diberi ID pohon versus ketika diberikan ID komit atau ID tag. Dalam kasus pertama waktu saat ini digunakan sebagai waktu modifikasi setiap file dalam arsip. Dalam kasus terakhir, waktu komit yang dicatat dalam objek komit yang direferensikan digunakan sebagai gantinya.

... tetapi ternyata kedua kasus mengatur "waktu modifikasi setiap file"; dengan demikian tidak menjaga cap waktu yang sebenarnya dari file-file itu!

Jadi, untuk menjaga stempel waktu, berikut adalah bashskrip, yang sebenarnya adalah "satu-liner", meskipun agak rumit - jadi di bawah ini diposting dalam beberapa baris:

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

Perhatikan bahwa diasumsikan bahwa Anda mengekspor konten dalam direktori "saat ini" (di atas, /media/disk/git_svn/subdir) - dan tujuan tujuan Anda mengekspornya agak tidak nyaman, tetapi berada dalam DESTvariabel lingkungan. Perhatikan bahwa dengan skrip ini; Anda harus membuat DESTdirektori sendiri secara manual, sebelum menjalankan skrip di atas.

Setelah skrip dijalankan, Anda harus dapat membandingkan:

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

... dan semoga melihat cap waktu yang sama (untuk file-file yang berada di bawah kontrol versi).

Semoga ini bisa membantu seseorang,
Ceria!

git mengekspor ke arsip zip sambil menambahkan awalan (mis. nama direktori):

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

Jika Anda memerlukan submodula juga, ini harus melakukan trik: https://github.com/meitar/git-archive-all.sh/wiki

saya memiliki fungsi utilitas berikut dalam file .bashrc saya: ini membuat arsip cabang saat ini di repositori 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
}