¿Cómo clono un subdirectorio solo de un repositorio Git?

Lo que está tratando de hacer se llama pago escaso, y esa característica se agregó en git 1.7.0 (Feb. 2012). Los pasos para hacer un clon disperso son los siguientes:

mkdir <repo>
cd <repo>
git init
git remote add -f origin <url>

Esto crea un repositorio vacío con su control remoto, y obtiene todos los objetos pero no los comprueba. Entonces haz:

git config core.sparseCheckout true

Ahora necesita definir qué archivos/carpetas desea revisar realmente. Esto se hace listándolos en .git/info/sparse-checkout, por ejemplo:

echo "some/dir/" >> .git/info/sparse-checkout
echo "another/sub/tree" >> .git/info/sparse-checkout

Por último, pero no menos importante, actualiza tu repositorio vacío con el estado del remoto:

git pull origin master

Ahora tendrá archivos "extraídos" para some/dir y another/sub/tree en su sistema de archivos (con esas rutas todavía), y no hay otras rutas presentes.

Es posible que desee echar un vistazo a la tutorial extendido y probablemente debería leer la documentación oficial para el pago escaso.

Como una función:

function git_sparse_clone() (
  rurl="$1" localdir="$2" && shift 2

  mkdir -p "$localdir"
  cd "$localdir"

  git init
  git remote add -f origin "$rurl"

  git config core.sparseCheckout true

  # Loops over remaining args
  for i; do
    echo "$i" >> .git/info/sparse-checkout
  done

  git pull origin master
)

Uso:

git_sparse_clone "http://github.com/tj/n" "./local/location" "/bin"

Tenga en cuenta que esto todavía descargará todo repositorio desde el servidor-solo el checkout es reducido en tamaño. Por el momento no es posible clonar un solo directorio. Pero si no necesita el historial del repositorio, al menos puede ahorrar en ancho de banda creando un clon superficial. Vea la respuesta de udondan a continuación para obtener información sobre cómo combinar un clon superficial y un checkout escaso.

Puede combinar las características sparse checkout y shallow clone. El clon superficial corta el historial y el checkout disperso solo extrae los archivos que coinciden con sus patrones.

git init <repo>
cd <repo>
git remote add origin <url>
git config core.sparsecheckout true
echo "finisht/*" >> .git/info/sparse-checkout
git pull --depth=1 origin master

Necesitarás git 1.9 como mínimo para que esto funcione. Lo probé solo con 2.2.0 y 2.2.2.

De esta manera todavía podrás empujar, lo que no es posible con git archive.

Para otros usuarios que solo quiero descargar un archivo / carpeta de github, simplemente use:

svn export <repo>/trunk/<folder>

Por ejemplo

svn export https://github.com/lodash/lodash.com/trunk/docs

(sí, eso es svn aquí. aparentemente en 2016 todavía necesitas svn para simplemente descargar algunos archivos de github)

Cortesía: Descarga una sola carpeta o directorio desde un repositorio de GitHub

Importante - Asegúrate de actualizar la URL de github y reemplazar /tree/master/ con '/trunk/'.

Como bash script:

git-download(){
    folder=${@/tree\/master/trunk}
    folder=${folder/blob\/master/trunk}
    svn export $folder
}

Nota Este método descarga una carpeta, no la clona/descarga. No puede devolver los cambios al repositorio. Por otro lado, esto resulta en una descarga más pequeña en comparación con el pago escaso o el pago superficial.

Git 1.7.0 tiene "checkouts dispersos". Ver "núcleo.sparseCheckout " en el git config página de manual , "Pago escaso" en el git read-tree manpage , y "Saltar-worktree bit" en el git update-index manpage.

La interfaz no es tan conveniente como la de SVN (por ejemplo, no hay forma de hacer una comprobación dispersa en el momento de un clon inicial), pero la funcionalidad base sobre la que se podrían construir interfaces más simples ahora está disponible.

Si nunca planeas interactuar con el repositorio desde el que clonaste, puedes hacer un completo git clone y reescribir tu repositorio usando git filter-branch subdi subdirectory-filter. De esta manera, al menos se preservará la historia.

Esto parece mucho más simple:

git archive --remote=<repo_url> <branch> <path> | tar xvf -

No es posible clonar el subdirectorio solo con Git, pero a continuación hay algunas soluciones.

Filter branch

Es posible que desee reescribir el repositorio para que parezca como si trunk/public_html/ hubiera sido su raíz de proyecto, y descartar todo el resto del historial (usando filter-branch), pruebe ya en la rama de pago:

git filter-branch --subdirectory-filter trunk/public_html -- --all

^{Notas: El -- que separa las opciones de rama de filtro de las opciones de revisión, y el --all para reescribir todas las ramas y etiquetas. Toda la información incluyendo original los tiempos de confirmación o la información de fusión se conservarán . Este comando respeta el archivo .git/info/grafts y refs en el espacio de nombres refs/replace/, por lo que si tiene cualquier injerto o reemplazo refs definido, ejecutar este comando los hará permanentes.}

¡Atención! El historial reescrito tendrá diferentes nombres de objeto para todos los objetos y no convergerá con la rama original. Usted no será capaz de empujar y distribuir fácilmente la rama reescrita en la parte superior de la rama original. Por favor, no use este comando si no conoce todas las implicaciones, y evite usarlo de todos modos, si una simple confirmación única sería suficiente para solucionar su problema.

Pago escaso

Aquí hay pasos simples con el enfoque sparse checkout que llenará el directorio de trabajo escasamente, para que pueda decirle a Git qué carpeta(s) o archivo(s) en el directorio de trabajo vale la pena revisar.

1. Clonar el repositorio como de costumbre (--no-checkout es opcional):

   git clone --no-checkout git@foo/bar.git
   cd bar
   

   ^{Puede omitir este paso, si ya ha clonado su repositorio.}

   Sugerencia: Para repos grandes, considere clon superficial (--depth 1) para pagar solo la última revisión o / y --single-branch solamente.

2. Habilitar sparseCheckout opción:

   git config core.sparseCheckout true
   

3. Especifique la (s) carpeta (s) para la comprobación dispersa (sin espacio al final):

   echo "trunk/public_html/*"> .git/info/sparse-checkout
   

   O editar .git/info/sparse-checkout.

4. Checkout la rama (e. g. master):

   git checkout master
   

Ahora debería tener carpetas seleccionadas en su directorio actual.

Puede considerar enlaces simbólicos si tiene demasiados niveles de directorios o rama de filtrado en su lugar.

Acabo de escribir un scriptpara GitHub.

Uso:

python get_git_sub_dir.py path/to/sub/dir <RECURSIVE>

Aquí hay un script de shell que escribí para el caso de uso de un solo subdirectorio sparse checkout

CoSubDir.sh

localRepo=$1
remoteRepo=$2
subDir=$3


# Create local repository for subdirectory checkout, make it hidden to avoid having to drill down to the subfolder
mkdir ./.$localRepo
cd ./.$localRepo
git init
git remote add -f origin $remoteRepo
git config core.sparseCheckout true

# Add the subdirectory of interest to the sparse checkout.
echo $subDir >> .git/info/sparse-checkout

git pull origin master

# Create convenience symlink to the subdirectory of interest
cd ..
ln -s ./.$localRepo$subDir $localRepo

git clone --filter desde Git 2.19

Esta opción saltará la búsqueda de objetos innecesarios del servidor:

git clone --depth 1 --no-checkout --filter=blob:none \
  "file://$(pwd)/server_repo" local_repo
cd local_repo
git checkout master -- mydir/

El servidor debe configurarse con:

git config --local uploadpack.allowfilter 1
git config --local uploadpack.allowanysha1inwant 1

No hay soporte de servidor a partir de la versión 2.19.0, pero ya se puede probar localmente.

TODO: --filter=blob:none omite todos los blobs, pero aun así obtiene todos los objetos del árbol. Pero en un repositorio normal, esto debe ser pequeño en comparación con los archivos en sí, por lo que esto ya es lo suficientemente bueno. Asked at: https://www.spinics.net/lists/git/msg342006.html Los desarrolladores respondieron que --filter=tree:0 está en las obras para hacer eso.

Recuerde que --depth 1 ya implica --single-branch, vea también: ¿Cómo clonar una sola rama en git?

file://$(path) se requiere para superar git clone travesuras de protocolo: ¿Cómo clonar de forma superficial un repositorio git local con una ruta relativa?

El formato de --filter está documentado en man git-rev-list.

Documentos sobre Git árbol:

• https://github.com/git/git/blob/v2.19.0/Documentation/technical/partial-clone.txt
• https://github.com/git/git/blob/v2.19.0/Documentation/rev-list-options.txt#L720
• https://github.com/git/git/blob/v2.19.0/t/t5616-partial-clone.sh

Pruébalo

#!/usr/bin/env bash
set -eu

list-objects() (
  git rev-list --all --objects
  echo "master commit SHA: $(git log -1 --format="%H")"
  echo "mybranch commit SHA: $(git log -1 --format="%H")"
  git ls-tree master
  git ls-tree mybranch | grep mybranch
  git ls-tree master~ | grep root
)

# Reproducibility.
export GIT_COMMITTER_NAME='a'
export GIT_COMMITTER_EMAIL='a'
export GIT_AUTHOR_NAME='a'
export GIT_AUTHOR_EMAIL='a'
export GIT_COMMITTER_DATE='2000-01-01T00:00:00+0000'
export GIT_AUTHOR_DATE='2000-01-01T00:00:00+0000'

rm -rf server_repo local_repo
mkdir server_repo
cd server_repo

# Create repo.
git init --quiet
git config --local uploadpack.allowfilter 1
git config --local uploadpack.allowanysha1inwant 1

# First commit.
# Directories present in all branches.
mkdir d1 d2
printf 'd1/a' > ./d1/a
printf 'd1/b' > ./d1/b
printf 'd2/a' > ./d2/a
printf 'd2/b' > ./d2/b
# Present only in root.
mkdir 'root'
printf 'root' > ./root/root
git add .
git commit -m 'root' --quiet

# Second commit only on master.
git rm --quiet -r ./root
mkdir 'master'
printf 'master' > ./master/master
git add .
git commit -m 'master commit' --quiet

# Second commit only on mybranch.
git checkout -b mybranch --quiet master~
git rm --quiet -r ./root
mkdir 'mybranch'
printf 'mybranch' > ./mybranch/mybranch
git add .
git commit -m 'mybranch commit' --quiet

echo "# List and identify all objects"
list-objects
echo

# Restore master.
git checkout --quiet master
cd ..

# Clone. Don't checkout for now, only .git/ dir.
git clone --depth 1 --quiet --no-checkout --filter=blob:none "file://$(pwd)/server_repo" local_repo
cd local_repo

# List missing objects from master.
echo "# Missing objects after --no-checkout"
git rev-list --all --quiet --objects --missing=print
echo

echo "# Git checkout fails without internet"
mv ../server_repo ../server_repo.off
! git checkout master
echo

echo "# Git checkout fetches the missing directory from internet"
mv ../server_repo.off ../server_repo
git checkout master -- d1/
echo

echo "# Missing objects after checking out d1"
git rev-list --all --quiet --objects --missing=print

GitHub upstream .

Salida en Git v2.19.0:

# List and identify all objects
c6fcdfaf2b1462f809aecdad83a186eeec00f9c1
fc5e97944480982cfc180a6d6634699921ee63ec
7251a83be9a03161acde7b71a8fda9be19f47128
62d67bce3c672fe2b9065f372726a11e57bade7e
b64bf435a3e54c5208a1b70b7bcb0fc627463a75 d1
308150e8fddde043f3dbbb8573abb6af1df96e63 d1/a
f70a17f51b7b30fec48a32e4f19ac15e261fd1a4 d1/b
84de03c312dc741d0f2a66df7b2f168d823e122a d2
0975df9b39e23c15f63db194df7f45c76528bccb d2/a
41484c13520fcbb6e7243a26fdb1fc9405c08520 d2/b
7d5230379e4652f1b1da7ed1e78e0b8253e03ba3 master
8b25206ff90e9432f6f1a8600f87a7bd695a24af master/master
ef29f15c9a7c5417944cc09711b6a9ee51b01d89
19f7a4ca4a038aff89d803f017f76d2b66063043 mybranch
1b671b190e293aa091239b8b5e8c149411d00523 mybranch/mybranch
c3760bb1a0ece87cdbaf9a563c77a45e30a4e30e
a0234da53ec608b54813b4271fbf00ba5318b99f root
93ca1422a8da0a9effc465eccbcb17e23015542d root/root
master commit SHA: fc5e97944480982cfc180a6d6634699921ee63ec
mybranch commit SHA: fc5e97944480982cfc180a6d6634699921ee63ec
040000 tree b64bf435a3e54c5208a1b70b7bcb0fc627463a75    d1
040000 tree 84de03c312dc741d0f2a66df7b2f168d823e122a    d2
040000 tree 7d5230379e4652f1b1da7ed1e78e0b8253e03ba3    master
040000 tree 19f7a4ca4a038aff89d803f017f76d2b66063043    mybranch
040000 tree a0234da53ec608b54813b4271fbf00ba5318b99f    root

# Missing objects after --no-checkout
?f70a17f51b7b30fec48a32e4f19ac15e261fd1a4
?8b25206ff90e9432f6f1a8600f87a7bd695a24af
?41484c13520fcbb6e7243a26fdb1fc9405c08520
?0975df9b39e23c15f63db194df7f45c76528bccb
?308150e8fddde043f3dbbb8573abb6af1df96e63

# Git checkout fails without internet
fatal: '/home/ciro/bak/git/test-git-web-interface/other-test-repos/partial-clone.tmp/server_repo' does not appear to be a git repository
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

# Git checkout fetches the missing directory from internet
remote: Enumerating objects: 1, done.
remote: Counting objects: 100% (1/1), done.
remote: Total 1 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (1/1), 45 bytes | 45.00 KiB/s, done.
remote: Enumerating objects: 1, done.
remote: Counting objects: 100% (1/1), done.
remote: Total 1 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (1/1), 45 bytes | 45.00 KiB/s, done.

# Missing objects after checking out d1
?8b25206ff90e9432f6f1a8600f87a7bd695a24af
?41484c13520fcbb6e7243a26fdb1fc9405c08520
?0975df9b39e23c15f63db194df7f45c76528bccb

Conclusiones: todas las manchas del exterior de d1/ faltan. Por ejemplo, 0975df9b39e23c15f63db194df7f45c76528bccb, que es d2/b no está allí después de comprobar d1/a.

Tenga en cuenta que root/root y mybranch/mybranch también faltan, pero --depth 1 lo oculta de la lista de archivos que faltan. Si elimina --depth 1, entonces se muestran en la lista de archivos que faltan.