È possibile effettuare un checkout sparso senza prima controllare l'intero repository?

Sto lavorando con un repository con un numero molto elevato di file che richiede ore per il checkout. Sto esaminando la possibilità che Git funzioni bene con questo tipo di repository ora che supporta checkout sparsi, ma ogni esempio che trovo fa quanto segue:

git clone <path>
git config core.sparsecheckout true
echo <dir> > .git/info/sparse-checkout
git read-tree -m -u HEAD

Il problema con questa sequenza di comandi è che anche il clone originale fa un checkout. Se si aggiunge -n al comando clone originale, il comando read-tree provoca il seguente errore:

errore: checkout sparso non lascia alcuna voce nella directory di lavoro

Come si può fare il checkout sparse senza prima verificare tutti i file?

Nel 2020 esiste un modo più semplice per gestire il checkout sparse senza doversi preoccupare dei file .git. Ecco come l'ho fatto:

git clone <URL> --no-checkout <directory>
cd <directory>
git sparse-checkout init --cone # to fetch only root files
git sparse-checkout set apps/my_app libs/my_lib # etc, to list sub-folders to checkout
# they are checked out immediately after this command, no need to run git pull

Si noti che richiede l'installazione della versione 2.25 di git. Maggiori informazioni qui: https://github.blog/2020-01-17-bring-your-monorepo-down-to-size-with-sparse-checkout/

AGGIORNARE:

Il git clonecomando sopra clonerà comunque il repository con la sua cronologia completa, anche se senza estrarre i file. Se non hai bisogno della cronologia completa, puoi aggiungere il parametro --depth al comando, in questo modo:

# create a shallow clone,
# with only 1 (since depth equals 1) latest commit in history
git clone <URL> --no-checkout <directory> --depth 1

Si noti che questa risposta scarica una copia completa dei dati da un repository. Il git remote add -fcomando clonerà l'intero repository. Dalla pagina man digit-remote :

Con l' -fopzione, git fetch <name>viene eseguito immediatamente dopo l'impostazione delle informazioni remote.

Prova questo:

mkdir myrepo
cd myrepo
git init
git config core.sparseCheckout true
git remote add -f origin git://...
echo "path/within_repo/to/desired_subdir/*" > .git/info/sparse-checkout
git checkout [branchname] # ex: master

Ora scoprirai di avere un checkout "eliminato" con solo i file da path / Within_repo / to / desiderata_subdir presente (e in quel percorso).

Si noti che sulla riga di comando di Windows non è necessario citare il percorso, ovvero è necessario modificare il sesto comando con questo:

echo path/within_repo/to/desired_subdir/* > .git/info/sparse-checkout

in caso contrario otterrai le virgolette nel file sparse-checkout e non funzionerà

Git clone ha un'opzione ( --no-checkouto -n) che fa quello che vuoi.

Nel tuo elenco di comandi, basta modificare:

git clone <path>

A questa:

git clone --no-checkout <path>

È quindi possibile utilizzare la cassa sparsa come indicato nella domanda.

Avevo un caso d'uso simile, tranne che volevo fare il checkout solo del commit per un tag e potare le directory. L'uso lo --depth 1rende veramente scarso e può davvero velocizzare le cose.

mkdir myrepo
cd myrepo
git init
git config core.sparseCheckout true
git remote add origin <url>  # Note: no -f option
echo "path/within_repo/to/subdir/" > .git/info/sparse-checkout
git fetch --depth 1 origin tag <tagname>
git checkout <tagname>

Ho trovato la risposta che cercavo nel one-liner pubblicato in precedenza da pavek (grazie!), Quindi volevo fornire una risposta completa in un'unica risposta che funziona su Linux (GIT 1.7.1):

1--> mkdir myrepo
2--> cd myrepo
3--> git init
4--> git config core.sparseCheckout true
5--> echo 'path/to/subdir/' > .git/info/sparse-checkout
6--> git remote add -f origin ssh://...
7--> git pull origin master

Ho cambiato un po 'l'ordine dei comandi, ma questo non sembra avere alcun impatto. La chiave è la presenza della barra finale "/" alla fine del percorso nel passaggio 5.

Purtroppo nessuno dei precedenti ha funzionato per me, quindi ho trascorso molto tempo a provare diverse combinazioni di sparse-checkoutfile.

Nel mio caso, volevo saltare le cartelle con le configurazioni IntelliJ IDEA.

Ecco cosa ho fatto:

Correre git clone https://github.com/myaccount/myrepo.git --no-checkout

Correre git config core.sparsecheckout true

Creato .git\info\sparse-checkoutcon il seguente contenuto

!.idea/*
!.idea_modules/*
/*

Esegui 'git checkout -' per ottenere tutti i file.

La cosa fondamentale per farlo funzionare era aggiungere /*il nome della cartella.

Ho git 1.9

Sì, è possibile scaricare una cartella invece di scaricare l'intero repository. Anche qualsiasi / ultimo commit

Bel modo di farlo

D:\Lab>git svn clone https://github.com/Qamar4P/LolAdapter.git/trunk/lol-adapter -r HEAD

1. -r HEAD scaricherà solo l'ultima revisione, ignorando tutta la cronologia.

2. Nota trunk e / cartella specifica

Copia e modifica l'URL prima e dopo /trunk/. Spero che questo possa aiutare qualcuno. Godere :)

Aggiornato il 26 set 2019

Risposta aggiornata 2020:

Ora c'è un comando git sparse-checkout, che presento in dettaglio con Git 2.25 (Q1 2020)

La risposta di nicono ne illustra l'utilizzo:

git sparse-checkout init --cone # to fetch only root files
git sparse-checkout add apps/my_app
git sparse-checkout add libs/my_lib

Si è evoluto con Git 2.27 e sa come "riapplicare" un checkout sparso, come qui .
Nota che con Git 2.28 git statusmenzionerai che sei in un repository con check-out sparso

Risposta originale: 2016

git 2.9 (giugno 2016) generalizzerà l' --no-checkoutopzione a git worktree add(il comando che consente di lavorare con più alberi di lavoro per un repository )

Vedi commit ef2a0ac (29 mar 2016) di Ray Zhang ( OneRaynyDay) .
Aiutato da: Eric Sunshine ( sunshineco) e Junio ​​C Hamano ( gitster) .
^{(Unita da Junio ​​C Hamano - gitster- in commit 0d8683c , 13 apr 2016)}

La git worktreepagina man ora include:

--[no-]checkout:

Per impostazione predefinita, addi controlli fuori <branch>, tuttavia, --no-checkoutpossono essere utilizzati per sopprimere cassa al fine di rendere le personalizzazioni, come la configurazione radi-checkout .

I passaggi per sparse checkout solo cartella specifica:

1) git clone --no-checkout  <project clone url>  
2) cd <project folder>
3) git config core.sparsecheckout true   [You must do this]
4) echo "<path you want to sparce>/*" > .git/info/sparse-checkout
    [You must enter /* at the end of the path such that it will take all contents of that folder]
5) git checkout <branch name> [Ex: master]

Sulla base di questa risposta di apenwarr e di questo commento di Miral, ho trovato la seguente soluzione che mi ha permesso di risparmiare quasi il 94% dello spazio su disco durante la clonazione locale del repository linux git mentre desideravo solo una sottodirectory Documentation:

$ cd linux
$ du -sh .git .
2.1G    .git
894M    .
$ du -sh 
2.9G    .
$ mkdir ../linux-sparse-test
$ cd ../linux-sparse-test
$ git init
Initialized empty Git repository in /…/linux-sparse-test/.git/
$ git config core.sparseCheckout true
$ git remote add origin ../linux
# Parameter "origin master" saves a tiny bit if there are other branches
$ git fetch --depth=1 origin master
remote: Enumerating objects: 65839, done.
remote: Counting objects: 100% (65839/65839), done.
remote: Compressing objects: 100% (61140/61140), done.
remote: Total 65839 (delta 6202), reused 22590 (delta 3703)
Receiving objects: 100% (65839/65839), 173.09 MiB | 10.05 MiB/s, done.
Resolving deltas: 100% (6202/6202), done.
From ../linux
 * branch              master     -> FETCH_HEAD
 * [new branch]        master     -> origin/master
$ echo "Documentation/hid/*" > .git/info/sparse-checkout
$ git checkout master
Branch 'master' set up to track remote branch 'master' from 'origin'.
Already on 'master'
$ ls -l
total 4
drwxr-xr-x 3 abe abe 4096 May  3 14:12 Documentation/
$  du -sh .git .
181M    .git
100K    .
$  du -sh
182M    .

Quindi sono sceso da 2,9 GB a 182 MB, il che è già abbastanza bello.

Tuttavia, non ho fatto in modo che funzionasse git clone --depth 1 --no-checkout --filter=blob:none file:///…/linux linux-sparse-test( suggerito qui ) poiché i file mancanti sono stati tutti aggiunti come file rimossi all'indice. Quindi, se qualcuno conosce l'equivalente di git clone --filter=blob:nonefor git fetch, probabilmente possiamo risparmiare qualche megabyte. (La lettura della pagina man di git-rev-listsuggerisce anche che c'è qualcosa del genere --filter=sparse:path=…, ma neanche io ho funzionato.

(Tutti hanno provato con git 2.20.1 da Debian Buster.)

Sono nuovo di Git ma sembra che se eseguo il checkout di Git per ogni directory, allora funziona. Inoltre, il file sparse-checkout deve avere una barra finale dopo ogni directory come indicato. Qualcuno in più di esperienza conferma che funzionerà.

È interessante notare che se si esegue il checkout di una directory che non si trova nel file sparse-checkout sembra non fare alcuna differenza. Non si presentano nello stato git e git read-tree -m -u HEAD non provoca la sua rimozione. git reset --hard non causa la rimozione della directory. Qualcuno ha più esperienza nel commentare cosa pensa git delle directory che sono state estratte ma che non sono nel file di checkout sparso?

In git 2.27, sembra che il checkout di git sparse si sia evoluto. La soluzione in questa risposta non funziona esattamente allo stesso modo (rispetto a git 2.25)

git clone <URL> --no-checkout <directory>
cd <directory>
git sparse-checkout init --cone # to fetch only root files
git sparse-checkout set apps/my_app libs/my_lib # etc, to list sub-folders to checkout
# they are checked out immediately after this command, no need to run git pull

Questi comandi hanno funzionato meglio:

git clone --sparse <URL> <directory>
cd <directory>
git sparse-checkout init --cone # to fetch only root files
git sparse-checkout add apps/my_app
git sparse-checkout add libs/my_lib

Vedi anche: git-clone --sparse e git-sparse-checkout add

Nel mio caso, voglio saltare la Podscartella durante la clonazione del progetto. Ho fatto un passo alla volta come sotto e funziona per me. Spero che sia d'aiuto.

mkdir my_folder
cd my_folder
git init
git remote add origin -f <URL>
git config core.sparseCheckout true 
echo '!Pods/*\n/*' > .git/info/sparse-checkout
git pull origin master

Promemoria, se si desidera saltare più cartelle, è sufficiente aggiungere più riga nel file di controllo sparse.