However bash I clone a subdirectory lone of a Git repository?

I person my Git repository which, astatine the base, has 2 subdirectories:

/finisht/static

Once this was successful SVN, /finisht was checked retired successful 1 spot, piece /static was checked retired elsewhere, similar truthful:

svn co svn+ssh://admin@domain.example/home/admin/repos/finisht/static static

Is location a manner to bash this with Git?

What you are attempting to bash is known as a sparse checkout, and that characteristic was added successful Git 1.7.Zero (Feb. 2012). The steps to bash a sparse clone are arsenic follows:

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

This creates an bare repository with your distant, and fetches each objects however doesn't cheque them retired. Past bash:

git config core.sparseCheckout true

Present you demand to specify which records-data/folders you privation to really cheque retired. This is completed by itemizing them successful .git/info/sparse-checkout, eg:

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

Past however not slightest, replace your bare repo with the government from the distant:

git pull origin master

You volition present person records-data "checked retired" for some/dir and another/sub/tree connected your record scheme (with these paths inactive), and nary another paths immediate.

You mightiness privation to person a expression astatine the prolonged tutorial and you ought to most likely publication the authoritative documentation for sparse checkout and publication-actor.

Arsenic a relation:

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)

Utilization:

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

Line that this volition inactive obtain the entire repository from the server – lone the checkout is decreased successful dimension. Astatine the minute it is not imaginable to clone lone a azygous listing. However if you don't demand the past of the repository, you tin astatine slightest prevention connected bandwidth by creating a shallow clone. Seat udondan's reply beneath for accusation connected however to harvester shallow clone and sparse checkout.

Arsenic of Git 2.25.Zero (Jan 2020) an experimental sparse-checkout bid is added successful Git:

git sparse-checkout init# same as:# git config core.sparseCheckout truegit sparse-checkout set "A/B"# same as:# echo "A/B" >> .git/info/sparse-checkoutgit sparse-checkout list# same as:# cat .git/info/sparse-checkout

git clone --filter + git sparse-checkout downloads lone the required records-data

E.g., to clone lone records-data successful subdirectory small/ successful this trial repository: https://github.com/cirosantilli/trial-git-partial-clone-large-tiny-nary-bigtree

git clone --no-checkout --depth=1 --filter=tree:0 \ https://github.com/cirosantilli/test-git-partial-clone-big-small-no-bigtreecd test-git-partial-clone-big-small-no-bigtreegit sparse-checkout set --no-cone /smallgit checkout

You may besides choice aggregate directories for obtain with:

git sparse-checkout set --no-cone /small /small2

The slash successful /small is required, if you bash conscionable small past git besides downloads immoderate another listing with basename small, we person a subdir/tiny/ listing successful the repository to trial that.

Line: This technique doesn't activity for idiosyncratic records-data nevertheless, however present is different technique that does: However to sparsely checkout lone 1 azygous record from a git repository?

Confirming that we really didn't obtain uneeded records-data

The supra trial repository comprises:

a big/ subdirectory with 10x 10MB records-data
10x 10MB records-data 0, 1, ... 9 connected toplevel (this is due to the fact that definite former makes an attempt would obtain toplevel records-data)
a small/ and small2/ subdirectories with A thousand records-data of measurement 1 byte all

Each contents are pseudo-random and so incompressible, truthful we tin easy announcement if immoderate of the large records-data had been downloaded, e.g. with ncdu.

Truthful if you obtain thing you didn't privation, you would acquire A hundred MB other, and it would beryllium precise noticeable.

Each git instructions ran had been fundamentally instantaneous, and we tin corroborate that the cloned repository is precise tiny arsenic desired:

du --apparent-size -hs * .* | sort -hs

giving:

2.0K small226K .git

Moving git clone downloads a azygous entity, presumably the perpetrate:

Cloning into 'test-git-partial-clone-big-small'...remote: Enumerating objects: 1, done.remote: Counting objects: 100% (1/1), done.remote: Total 1 (delta 0), reused 1 (delta 0), pack-reused 0Receiving objects: 100% (1/1), done.

and past the last checkout downloads the records-data we requested:

remote: Enumerating objects: 3, done.remote: Counting objects: 100% (3/3), done.remote: Compressing objects: 100% (3/3), done.remote: Total 3 (delta 0), reused 3 (delta 0), pack-reused 0Receiving objects: 100% (3/3), 10.19 KiB | 2.04 MiB/s, done.remote: Enumerating objects: 253, done.remote: Counting objects: 100% (253/253), done.Receiving objects: 100% (253/253), 2.50 KiB | 2.50 MiB/s, done.remote: Total 253 (delta 0), reused 253 (delta 0), pack-reused 0Your branch is up to date with 'origin/master'.

Examined connected git 2.37.2, Ubuntu 22.10, connected January 2023.

Downloading from a circumstantial subdivision

The process is the aforesaid arsenic checking retired a antithetic listing another than maestro: However bash I clone a azygous subdivision successful Git? conscionable adhd -b branchname --single-branch:

git clone -n --depth=1 --filter=tree:0 \ -b bigissmall --single-branch \ https://github.com/cirosantilli/test-git-partial-clone-big-small-no-bigtreecd test-git-partial-clone-big-small-no-bigtreegit sparse-checkout set --no-cone /biggit checkout

The subdivision bigissmall renames small/ to big/ to guarantee that location is nary disorder betwixt the branches once fetching, and the supra fetch is speedy and tiny arsenic earlier.

TODO Besides forestall obtain of unneeded actor objects

The supra technique downloads each Git actor objects (i.e. listing listings, however not existent record contents). We tin corroborate that by moving:

git ls-files

and seeing that it comprises the directories ample records-data specified arsenic:

big/0

Successful about initiatives this received't beryllium an content, arsenic these ought to beryllium tiny in contrast to the existent record contents, however the perfectionist successful maine would similar to debar them.

I've besides created a precise utmost repository with any precise ample actor objects (A hundred MB) nether the listing big_tree: https://github.com/cirosantilli/trial-git-partial-clone-large-tiny

Fto maine cognize if anybody finds a manner to clone conscionable the small/ listing from it!

Astir the Instructions

The --filter action was added unneurotic with an replace to the distant protocol, and it genuinely prevents objects from being downloaded from the server.

The sparse-checkout portion is besides wanted unluckily. You tin besides lone obtain definite records-data with the overmuch much comprehensible:

git clone --depth 1 --filter=blob:none --no-checkout \ https://github.com/cirosantilli/test-git-partial-clone-big-smallcd test-git-partial-clone-big-smallgit checkout master -- d1

however that technique for any ground downloads records-data 1 by 1 precise slow, making it unusable except you person precise fewer records-data successful the listing.

Different little verbose however failed effort was:

git clone --depth 1 --filter=blob:none --sparse \ https://github.com/cirosantilli/test-git-partial-clone-big-smallcd test-git-partial-clone-big-smallgit sparse-checkout set /small

however that downloads each records-data successful the toplevel listing: However to forestall git clone --filter=blob:no --sparse from downloading records-data connected the base listing?

The Imagination: Immoderate Listing tin person Internet Interface Metadata

This characteristic may revolutionize Git.

Ideate having each the codification basal of your endeavor successful a azygous monorepo with out disfigured 3rd-organization instruments similar repo.

Ideate storing immense blobs straight successful the repo with out immoderate disfigured 3rd organization extensions.

Ideate if GitHub would let per record / listing metadata similar stars and permissions, truthful you tin shop each your individual material nether a azygous repo.

Ideate if submodules had been handled precisely similar daily directories: conscionable petition a actor SHA, and a DNS-similar mechanics resolves your petition, archetypal trying connected your section ~/.git, past archetypal to person servers (your endeavor's reflector / cache) and ending ahead connected GitHub.

I person a imagination.

The trial cone monorepo doctrine

This is a imaginable doctrine for monorepo care with out submodules.

We privation to debar submodules due to the fact that it is annoying to person to perpetrate to 2 abstracted repositories all clip you brand a alteration that has a submodule and non-submodule constituent.

All listing with a Makefile oregon analogous ought to physique and trial itself.

Specified directories tin be connected both:

all record and subdirectory nether it straight astatine their newest variations
outer directories tin beryllium relied upon lone astatine specified variations

Till git begins supporting this natively (i.e. submodules that tin path lone subdirectories), we tin activity this with any metadata successful a git tracked record:

monorepo.json

{ "path": "some/useful/lib", "sha": 12341234123412341234,}

wherever sha refers to the accustomed SHA of the full repository. Past we demand scripts that volition checkout specified directories e.g. nether a gitignored monorepo folder:

monorepo/som/useful/lib

Each time you alteration a record, you person to spell ahead the actor and trial each directories that person Makefile. This is due to the fact that directories tin be connected subdirectories astatine their newest variations, truthful you may ever interruption thing supra you.

Associated:

Git is a almighty interpretation power scheme that permits builders to path adjustments to their codification, collaborate efficaciously, and negociate initiatives of immoderate measurement. 1 communal demand once running with ample repositories is the quality to clone lone a circumstantial subdirectory, instead than the full repository. This tin importantly trim obtain occasions and prevention disk abstraction, particularly once you lone demand a tiny condition of the task. This article explores assorted strategies to clone a subdirectory from a Git repository, offering you with the cognition and instruments to streamline your workflow and better ratio.

Cloning a Circumstantial Subdirectory from a Git Repository

Cloning a circumstantial subdirectory, arsenic opposed to the full repository, tin beryllium extremely advantageous once dealing with ample initiatives. Alternatively of downloading the absolute past and information, you tin direction solely connected the applicable components, redeeming invaluable clip and bandwidth. This is peculiarly utile successful monorepo setups oregon once running with initiatives that person chiseled, modular parts saved successful abstracted subdirectories. By mastering the methods for cloning circumstantial subdirectories, builders tin optimize their Git workflows and better their general productiveness.

Utilizing git sparse-checkout to Isolate a Subdirectory

The git sparse-checkout characteristic, mixed with git clone --filter=blob:no, offers an businesslike manner to clone lone the desired subdirectory. Archetypal, the --filter=blob:no action prevents downloading each record contents, ensuing successful a faster first clone. Adjacent, git sparse-checkout permits you to specify which directories you privation to populate with existent record information. This attack is generous due to the fact that it avoids downloading pointless components of the repository, which leads to important clip and assets financial savings. The procedure is simple and appropriate for about contemporary Git variations.

Clone the repository with a sparse checkout filter:

git clone --filter=blob:none <repository_url> <local_repo_name>

Participate the recently created repository:

cd <local_repo_name>

Initialize sparse checkout:

git sparse-checkout init --cone

Specify the subdirectory you privation to checkout:

git sparse-checkout set <subdirectory_path>

Present, lone the information inside the specified subdirectory volition beryllium immediate successful your section repository.

For case, if you privation to clone lone the "docs" listing, you would usage: git sparse-checkout set docs. This methodology retains your section repository cleanable and targeted, enhancing general ratio.

"Sparse checkout is a almighty implement for optimizing Git workflows, particularly once dealing with ample repositories. It permits builders to direction connected circumstantial components of a task with out the overhead of downloading the full codebase."

Alternate Strategies for Cloning Subdirectories

Piece git sparse-checkout is a beneficial attack, another strategies be to accomplish the aforesaid end. These alternate options whitethorn lawsuit antithetic situations oregon message various ranges of complexity and ratio. Knowing these choices offers flexibility and permits you to take the champion methodology primarily based connected your circumstantial wants and the instruments disposable.

Utilizing git clone --extent 1 and git checkout

This methodology includes cloning the repository with a constricted past (--extent 1) to trim the first obtain measurement, adopted by checking retired the circumstantial subdirectory. This attack is little businesslike than git sparse-checkout however tin beryllium less complicated to realize and instrumentality. It’s peculiarly utile once you don’t demand the full past of the repository and lone necessitate the newest interpretation of the information successful the subdirectory. Get a circumstantial tag with Git and seat much choices.

Clone the repository with extent 1:

git clone --depth 1 <repository_url> <local_repo_name>

Participate the recently created repository:

cd <local_repo_name>

Checkout the desired subdirectory:

git checkout HEAD -- <subdirectory_path>

Distance each another information and directories:

rm -rf $(find . -maxdepth 1 ! -path ".git" ! -path "<subdirectory_path>" -print0 | xargs -0)

This fit of instructions archetypal clones the about new interpretation of the repository, past checks retired lone the information successful the specified subdirectory. Eventually, it removes each another information to permission you with conscionable the contented you demand. It’s a much guide attack however effectual successful reaching the desired consequence.

Utilizing svn checkout connected Git Repositories

If the Git repository construction is suitable, you tin usage svn checkout to obtain a subdirectory. This plant due to the fact that Git repositories tin generally beryllium accessed through the Subversion protocol. This methodology is peculiarly utile if you're already acquainted with Subversion oregon if you brush points with another Git-circumstantial approaches. Nevertheless, it's crucial to line that this methodology lone plant if the Git repository permits Subversion entree and the repository construction is appropriate. It besides gained't supply the absolute Git past.

Usage svn checkout to obtain the subdirectory:

svn checkout <repository_url>/trunk/<subdirectory_path> <local_directory_name>

For illustration: svn checkout https://github.com/example/repo.git/trunk/docs local_docs. This bid straight downloads the contents of the "docs" subdirectory into a section listing named "local_docs." Support successful head that this methodology bypasses Git wholly, truthful you gained't person a Git repository successful the section listing.

Methodology	Execs	Cons
git sparse-checkout	Businesslike, maintains Git past, wide supported.	Requires aggregate instructions, somewhat much analyzable.
git clone --extent 1 & git checkout	Less complicated to realize, reduces first obtain measurement.	Little businesslike, requires guide record removing.
svn checkout	Casual if acquainted with SVN, avoids Git points.	Requires SVN entree, nary Git past, constricted compatibility.

Selecting the correct methodology relies upon connected your circumstantial necessities and the traits of the Git repository. See elements specified arsenic the measurement of the repository, the demand for Git past, and your familiarity with antithetic instruments.

Successful decision, cloning a circumstantial subdirectory from a Git repository tin importantly better ratio and trim the assets required for section improvement. Whether or not you take to usage git sparse-checkout, git clone --extent 1 with git checkout, oregon svn checkout, knowing the strengths and limitations of all methodology is important. Optimizing your Git workflow ensures that you tin direction connected processing and contributing to initiatives much efficaciously. Research these methods to streamline your workflow and brand the about of your Git education. For additional studying connected Git and associated instruments, sojourn Atlassian Git Tutorials. Besides, research much connected Git instructions with Git Documentation and larn astir Monorepo with Trunk Primarily based Improvement connected Monorepos.

How to Git Clone a Private GitHub Repository

How to Git Clone a Private GitHub Repository from Youtube.com