2019-11-21 22:04:33 +00:00
|
|
|
#!/bin/sh
|
|
|
|
|
|
|
|
test_description='sparse checkout builtin tests'
|
|
|
|
|
2020-11-18 23:44:21 +00:00
|
|
|
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=main
|
tests: mark tests relying on the current default for `init.defaultBranch`
In addition to the manual adjustment to let the `linux-gcc` CI job run
the test suite with `master` and then with `main`, this patch makes sure
that GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME is set in all test scripts
that currently rely on the initial branch name being `master by default.
To determine which test scripts to mark up, the first step was to
force-set the default branch name to `master` in
- all test scripts that contain the keyword `master`,
- t4211, which expects `t/t4211/history.export` with a hard-coded ref to
initialize the default branch,
- t5560 because it sources `t/t556x_common` which uses `master`,
- t8002 and t8012 because both source `t/annotate-tests.sh` which also
uses `master`)
This trick was performed by this command:
$ sed -i '/^ *\. \.\/\(test-lib\|lib-\(bash\|cvs\|git-svn\)\|gitweb-lib\)\.sh$/i\
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=master\
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME\
' $(git grep -l master t/t[0-9]*.sh) \
t/t4211*.sh t/t5560*.sh t/t8002*.sh t/t8012*.sh
After that, careful, manual inspection revealed that some of the test
scripts containing the needle `master` do not actually rely on a
specific default branch name: either they mention `master` only in a
comment, or they initialize that branch specificially, or they do not
actually refer to the current default branch. Therefore, the
aforementioned modification was undone in those test scripts thusly:
$ git checkout HEAD -- \
t/t0027-auto-crlf.sh t/t0060-path-utils.sh \
t/t1011-read-tree-sparse-checkout.sh \
t/t1305-config-include.sh t/t1309-early-config.sh \
t/t1402-check-ref-format.sh t/t1450-fsck.sh \
t/t2024-checkout-dwim.sh \
t/t2106-update-index-assume-unchanged.sh \
t/t3040-subprojects-basic.sh t/t3301-notes.sh \
t/t3308-notes-merge.sh t/t3423-rebase-reword.sh \
t/t3436-rebase-more-options.sh \
t/t4015-diff-whitespace.sh t/t4257-am-interactive.sh \
t/t5323-pack-redundant.sh t/t5401-update-hooks.sh \
t/t5511-refspec.sh t/t5526-fetch-submodules.sh \
t/t5529-push-errors.sh t/t5530-upload-pack-error.sh \
t/t5548-push-porcelain.sh \
t/t5552-skipping-fetch-negotiator.sh \
t/t5572-pull-submodule.sh t/t5608-clone-2gb.sh \
t/t5614-clone-submodules-shallow.sh \
t/t7508-status.sh t/t7606-merge-custom.sh \
t/t9302-fast-import-unpack-limit.sh
We excluded one set of test scripts in these commands, though: the range
of `git p4` tests. The reason? `git p4` stores the (foreign) remote
branch in the branch called `p4/master`, which is obviously not the
default branch. Manual analysis revealed that only five of these tests
actually require a specific default branch name to pass; They were
modified thusly:
$ sed -i '/^ *\. \.\/lib-git-p4\.sh$/i\
GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME=master\
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME\
' t/t980[0167]*.sh t/t9811*.sh
Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-11-18 23:44:19 +00:00
|
|
|
export GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME
|
|
|
|
|
2022-01-19 17:29:38 +00:00
|
|
|
GIT_TEST_SPLIT_INDEX=false
|
|
|
|
export GIT_TEST_SPLIT_INDEX
|
|
|
|
|
2019-11-21 22:04:33 +00:00
|
|
|
. ./test-lib.sh
|
|
|
|
|
2019-12-20 19:41:14 +00:00
|
|
|
list_files() {
|
|
|
|
# Do not replace this with 'ls "$1"', as "ls" with BSD-lineage
|
|
|
|
# enables "-A" by default for root and ends up including ".git" and
|
|
|
|
# such in its output. (Note, though, that running the test suite as
|
|
|
|
# root is generally not recommended.)
|
|
|
|
(cd "$1" && printf '%s\n' *)
|
|
|
|
}
|
|
|
|
|
2020-01-24 21:19:31 +00:00
|
|
|
check_files() {
|
|
|
|
list_files "$1" >actual &&
|
|
|
|
shift &&
|
|
|
|
printf "%s\n" $@ >expect &&
|
|
|
|
test_cmp expect actual
|
|
|
|
}
|
|
|
|
|
2019-11-21 22:04:33 +00:00
|
|
|
test_expect_success 'setup' '
|
|
|
|
git init repo &&
|
|
|
|
(
|
|
|
|
cd repo &&
|
|
|
|
echo "initial" >a &&
|
|
|
|
mkdir folder1 folder2 deep &&
|
|
|
|
mkdir deep/deeper1 deep/deeper2 &&
|
|
|
|
mkdir deep/deeper1/deepest &&
|
|
|
|
cp a folder1 &&
|
|
|
|
cp a folder2 &&
|
|
|
|
cp a deep &&
|
|
|
|
cp a deep/deeper1 &&
|
|
|
|
cp a deep/deeper2 &&
|
|
|
|
cp a deep/deeper1/deepest &&
|
|
|
|
git add . &&
|
|
|
|
git commit -m "initial commit"
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2021-12-14 04:09:05 +00:00
|
|
|
test_expect_success 'git sparse-checkout list (not sparse)' '
|
|
|
|
test_must_fail git -C repo sparse-checkout list >list 2>err &&
|
|
|
|
test_must_be_empty list &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "this worktree is not sparse" err
|
2021-12-14 04:09:05 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'git sparse-checkout list (not sparse)' '
|
|
|
|
git -C repo sparse-checkout set &&
|
|
|
|
rm repo/.git/info/sparse-checkout &&
|
2019-11-21 22:04:33 +00:00
|
|
|
git -C repo sparse-checkout list >list 2>err &&
|
|
|
|
test_must_be_empty list &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "this worktree is not sparse (sparse-checkout file may not exist)" err
|
2019-11-21 22:04:33 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'git sparse-checkout list (populated)' '
|
|
|
|
test_when_finished rm -f repo/.git/info/sparse-checkout &&
|
2020-01-24 21:19:32 +00:00
|
|
|
cat >repo/.git/info/sparse-checkout <<-\EOF &&
|
|
|
|
/folder1/*
|
|
|
|
/deep/
|
|
|
|
**/a
|
|
|
|
!*bin*
|
2019-11-21 22:04:33 +00:00
|
|
|
EOF
|
|
|
|
cp repo/.git/info/sparse-checkout expect &&
|
|
|
|
git -C repo sparse-checkout list >list &&
|
|
|
|
test_cmp expect list
|
|
|
|
'
|
|
|
|
|
2019-11-21 22:04:34 +00:00
|
|
|
test_expect_success 'git sparse-checkout init' '
|
2022-04-22 02:32:18 +00:00
|
|
|
git -C repo sparse-checkout init --no-cone &&
|
2020-01-24 21:19:32 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
2019-11-21 22:04:34 +00:00
|
|
|
EOF
|
|
|
|
test_cmp expect repo/.git/info/sparse-checkout &&
|
|
|
|
test_cmp_config -C repo true core.sparsecheckout &&
|
2020-01-24 21:19:31 +00:00
|
|
|
check_files repo a
|
2019-11-21 22:04:34 +00:00
|
|
|
'
|
|
|
|
|
2022-01-21 17:44:41 +00:00
|
|
|
test_expect_success 'git sparse-checkout init in empty repo' '
|
|
|
|
test_when_finished rm -rf empty-repo blank-template &&
|
|
|
|
git init --template= empty-repo &&
|
|
|
|
git -C empty-repo sparse-checkout init
|
|
|
|
'
|
|
|
|
|
2019-11-21 22:04:34 +00:00
|
|
|
test_expect_success 'git sparse-checkout list after init' '
|
|
|
|
git -C repo sparse-checkout list >actual &&
|
2020-01-24 21:19:32 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
2019-11-21 22:04:34 +00:00
|
|
|
EOF
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'init with existing sparse-checkout' '
|
|
|
|
echo "*folder*" >> repo/.git/info/sparse-checkout &&
|
|
|
|
git -C repo sparse-checkout init &&
|
2020-01-24 21:19:32 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
*folder*
|
2019-11-21 22:04:34 +00:00
|
|
|
EOF
|
|
|
|
test_cmp expect repo/.git/info/sparse-checkout &&
|
2020-01-24 21:19:31 +00:00
|
|
|
check_files repo a folder1 folder2
|
2019-11-21 22:04:34 +00:00
|
|
|
'
|
|
|
|
|
2019-11-21 22:04:35 +00:00
|
|
|
test_expect_success 'clone --sparse' '
|
2020-01-24 21:19:34 +00:00
|
|
|
git clone --sparse "file://$(pwd)/repo" clone &&
|
2022-04-22 02:32:18 +00:00
|
|
|
git -C clone sparse-checkout reapply --no-cone &&
|
2019-11-21 22:04:35 +00:00
|
|
|
git -C clone sparse-checkout list >actual &&
|
2020-01-24 21:19:32 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
2019-11-21 22:04:35 +00:00
|
|
|
EOF
|
|
|
|
test_cmp expect actual &&
|
2020-01-24 21:19:31 +00:00
|
|
|
check_files clone a
|
2019-11-21 22:04:35 +00:00
|
|
|
'
|
|
|
|
|
2021-12-16 16:13:41 +00:00
|
|
|
test_expect_success 'switching to cone mode with non-cone mode patterns' '
|
|
|
|
git init bad-patterns &&
|
|
|
|
(
|
|
|
|
cd bad-patterns &&
|
2022-04-22 02:32:18 +00:00
|
|
|
git sparse-checkout init --no-cone &&
|
2021-12-16 16:13:41 +00:00
|
|
|
git sparse-checkout add dir &&
|
sparse-checkout: set worktree-config correctly
`git sparse-checkout set/init` enables worktree-specific
configuration[*] by setting extensions.worktreeConfig=true, but neglects
to perform the additional necessary bookkeeping of relocating
`core.bare=true` and `core.worktree` from $GIT_COMMON_DIR/config to
$GIT_COMMON_DIR/config.worktree, as documented in git-worktree.txt. As a
result of this oversight, these settings, which are nonsensical for
secondary worktrees, can cause Git commands to incorrectly consider a
worktree bare (in the case of `core.bare`) or operate on the wrong
worktree (in the case of `core.worktree`). Fix this problem by taking
advantage of the recently-added init_worktree_config() which enables
`extensions.worktreeConfig` and takes care of necessary bookkeeping.
While at it, for backward-compatibility reasons, also stop upgrading the
repository format to "1" since doing so is (unintentionally) not
required to take advantage of `extensions.worktreeConfig`, as explained
by 11664196ac ("Revert "check_repository_format_gently(): refuse
extensions for old repositories"", 2020-07-15).
[*] The main reason to use worktree-specific config for the
sparse-checkout builtin was to avoid enabling sparse-checkout patterns
in one and causing a loss of files in another. If a worktree does not
have a sparse-checkout patterns file, then the sparse-checkout logic
will not kick in on that worktree.
Reported-by: Sean Allred <allred.sean@gmail.com>
Helped-by: Eric Sunshine <sunshine@sunshineco.com>
Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Reviewed-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-02-07 21:33:01 +00:00
|
|
|
git config --worktree core.sparseCheckoutCone true &&
|
2021-12-16 16:13:42 +00:00
|
|
|
test_must_fail git sparse-checkout add dir 2>err &&
|
|
|
|
grep "existing sparse-checkout patterns do not use cone mode" err
|
2021-12-16 16:13:41 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
sparse-checkout: avoid staging deletions of all files
sparse-checkout's purpose is to update the working tree to have it
reflect a subset of the tracked files. As such, it shouldn't be
switching branches, making commits, downloading or uploading data, or
staging or unstaging changes. Other than updating the worktree, the
only thing sparse-checkout should touch is the SKIP_WORKTREE bit of the
index. In particular, this sets up a nice invariant: running
sparse-checkout will never change the status of any file in `git status`
(reflecting the fact that we only set the SKIP_WORKTREE bit if the file
is safe to delete, i.e. if the file is unmodified).
Traditionally, we did a _really_ bad job with this goal. The
predecessor to sparse-checkout involved manual editing of
.git/info/sparse-checkout and running `git read-tree -mu HEAD`. That
command would stage and unstage changes and overwrite dirty changes in
the working tree.
The initial implementation of the sparse-checkout command was no better;
it simply invoked `git read-tree -mu HEAD` as a subprocess and had the
same caveats, though this issue came up repeatedly in review comments
and workarounds for the problems were put in place before the feature
was merged[1, 2, 3, 4, 5, 6; especially see 4 & 6].
[1] https://lore.kernel.org/git/CABPp-BFT9A5n=_bx5LsjCvbogqwSjiwgr5amcjgbU1iAk4KLJg@mail.gmail.com/
[2] https://lore.kernel.org/git/CABPp-BEmwSwg4tgJg6nVG8a3Hpn_g-=ZjApZF4EiJO+qVgu4uw@mail.gmail.com/
[3] https://lore.kernel.org/git/CABPp-BFV7TA0qwZCQpHCqx9N+JifyRyuBQ-pZ_oGfe-NOgyh7A@mail.gmail.com/
[4] https://lore.kernel.org/git/CABPp-BHYCCD+Vx5fq35jH82eHc1-P53Lz_aGNpHJNcx9kg2K-A@mail.gmail.com/
[5] https://lore.kernel.org/git/CABPp-BF+JWYZfDqp2Tn4AEKVp4b0YMA=Mbz4Nz62D-gGgiduYQ@mail.gmail.com/
[6] https://lore.kernel.org/git/20191121163706.GV23183@szeder.dev/
However, these workarounds, in addition to disabling the feature in a
number of important cases, also missed one special case. I'll get back
to it later.
In the 2.27.0 cycle, the disabling of the feature was lifted by finally
replacing the internal equivalent of `git read-tree -mu HEAD` with
something that did what we wanted: the new update_sparsity() function in
unpack-trees.c that only ever updates SKIP_WORKTREE bits in the index
and updates the working tree to match. This new function handles all
the cases that were problematic for the old implementation, except that
it breaks the same special case that avoided the workarounds of the old
implementation, but broke it in a different way.
So...that brings us to the special case: a git clone performed with
--no-checkout. As per the meaning of the flag, --no-checkout does not
check out any branch, with the implication that you aren't on one and
need to switch to one after the clone. Implementationally, HEAD is
still set (so in some sense you are partially on a branch), but
* the index is "unborn" (non-existent)
* there are no files in the working tree (other than .git/)
* the next time git switch (or git checkout) is run it will run
unpack_trees with `initial_checkout` flag set to true.
It is not until you run, e.g. `git switch <somebranch>` that the index
will be written and files in the working tree populated.
With this special --no-checkout case, the traditional `read-tree -mu
HEAD` behavior would have done the equivalent of acting like checkout --
switch to the default branch (HEAD), write out an index that matches
HEAD, and update the working tree to match. This special case slipped
through the avoid-making-changes checks in the original sparse-checkout
command and thus continued there.
After update_sparsity() was introduced and used (see commit f56f31af03
("sparse-checkout: use new update_sparsity() function", 2020-03-27)),
the behavior for the --no-checkout case changed: Due to git's
auto-vivification of an empty in-memory index (see do_read_index() and
note that `must_exist` is false), and due to sparse-checkout's
update_working_directory() code to always write out the index after it
was done, we got a new bug. That made it so that sparse-checkout would
switch the repository from a clone with an "unborn" index (i.e. still
needing an initial_checkout), to one that had a recorded index with no
entries. Thus, instead of all the files appearing deleted in `git
status` being known to git as a special artifact of not yet being on a
branch, our recording of an empty index made it suddenly look to git as
though it was definitely on a branch with ALL files staged for deletion!
A subsequent checkout or switch then had to contend with the fact that
it wasn't on an initial_checkout but had a bunch of staged deletions.
Make sure that sparse-checkout changes nothing in the index other than
the SKIP_WORKTREE bit; in particular, when the index is unborn we do not
have any branch checked out so there is no sparsification or
de-sparsification work to do. Simply return from
update_working_directory() early.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-06-05 02:41:39 +00:00
|
|
|
test_expect_success 'interaction with clone --no-checkout (unborn index)' '
|
|
|
|
git clone --no-checkout "file://$(pwd)/repo" clone_no_checkout &&
|
|
|
|
git -C clone_no_checkout sparse-checkout init --cone &&
|
|
|
|
git -C clone_no_checkout sparse-checkout set folder1 &&
|
|
|
|
|
|
|
|
git -C clone_no_checkout sparse-checkout list >actual &&
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
folder1
|
|
|
|
EOF
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
# nothing checked out, expect "No such file or directory"
|
|
|
|
! ls clone_no_checkout/* >actual &&
|
|
|
|
test_must_be_empty actual &&
|
|
|
|
test_path_is_missing clone_no_checkout/.git/index &&
|
|
|
|
|
|
|
|
# No branch is checked out until we manually switch to one
|
2020-11-18 23:44:21 +00:00
|
|
|
git -C clone_no_checkout switch main &&
|
sparse-checkout: avoid staging deletions of all files
sparse-checkout's purpose is to update the working tree to have it
reflect a subset of the tracked files. As such, it shouldn't be
switching branches, making commits, downloading or uploading data, or
staging or unstaging changes. Other than updating the worktree, the
only thing sparse-checkout should touch is the SKIP_WORKTREE bit of the
index. In particular, this sets up a nice invariant: running
sparse-checkout will never change the status of any file in `git status`
(reflecting the fact that we only set the SKIP_WORKTREE bit if the file
is safe to delete, i.e. if the file is unmodified).
Traditionally, we did a _really_ bad job with this goal. The
predecessor to sparse-checkout involved manual editing of
.git/info/sparse-checkout and running `git read-tree -mu HEAD`. That
command would stage and unstage changes and overwrite dirty changes in
the working tree.
The initial implementation of the sparse-checkout command was no better;
it simply invoked `git read-tree -mu HEAD` as a subprocess and had the
same caveats, though this issue came up repeatedly in review comments
and workarounds for the problems were put in place before the feature
was merged[1, 2, 3, 4, 5, 6; especially see 4 & 6].
[1] https://lore.kernel.org/git/CABPp-BFT9A5n=_bx5LsjCvbogqwSjiwgr5amcjgbU1iAk4KLJg@mail.gmail.com/
[2] https://lore.kernel.org/git/CABPp-BEmwSwg4tgJg6nVG8a3Hpn_g-=ZjApZF4EiJO+qVgu4uw@mail.gmail.com/
[3] https://lore.kernel.org/git/CABPp-BFV7TA0qwZCQpHCqx9N+JifyRyuBQ-pZ_oGfe-NOgyh7A@mail.gmail.com/
[4] https://lore.kernel.org/git/CABPp-BHYCCD+Vx5fq35jH82eHc1-P53Lz_aGNpHJNcx9kg2K-A@mail.gmail.com/
[5] https://lore.kernel.org/git/CABPp-BF+JWYZfDqp2Tn4AEKVp4b0YMA=Mbz4Nz62D-gGgiduYQ@mail.gmail.com/
[6] https://lore.kernel.org/git/20191121163706.GV23183@szeder.dev/
However, these workarounds, in addition to disabling the feature in a
number of important cases, also missed one special case. I'll get back
to it later.
In the 2.27.0 cycle, the disabling of the feature was lifted by finally
replacing the internal equivalent of `git read-tree -mu HEAD` with
something that did what we wanted: the new update_sparsity() function in
unpack-trees.c that only ever updates SKIP_WORKTREE bits in the index
and updates the working tree to match. This new function handles all
the cases that were problematic for the old implementation, except that
it breaks the same special case that avoided the workarounds of the old
implementation, but broke it in a different way.
So...that brings us to the special case: a git clone performed with
--no-checkout. As per the meaning of the flag, --no-checkout does not
check out any branch, with the implication that you aren't on one and
need to switch to one after the clone. Implementationally, HEAD is
still set (so in some sense you are partially on a branch), but
* the index is "unborn" (non-existent)
* there are no files in the working tree (other than .git/)
* the next time git switch (or git checkout) is run it will run
unpack_trees with `initial_checkout` flag set to true.
It is not until you run, e.g. `git switch <somebranch>` that the index
will be written and files in the working tree populated.
With this special --no-checkout case, the traditional `read-tree -mu
HEAD` behavior would have done the equivalent of acting like checkout --
switch to the default branch (HEAD), write out an index that matches
HEAD, and update the working tree to match. This special case slipped
through the avoid-making-changes checks in the original sparse-checkout
command and thus continued there.
After update_sparsity() was introduced and used (see commit f56f31af03
("sparse-checkout: use new update_sparsity() function", 2020-03-27)),
the behavior for the --no-checkout case changed: Due to git's
auto-vivification of an empty in-memory index (see do_read_index() and
note that `must_exist` is false), and due to sparse-checkout's
update_working_directory() code to always write out the index after it
was done, we got a new bug. That made it so that sparse-checkout would
switch the repository from a clone with an "unborn" index (i.e. still
needing an initial_checkout), to one that had a recorded index with no
entries. Thus, instead of all the files appearing deleted in `git
status` being known to git as a special artifact of not yet being on a
branch, our recording of an empty index made it suddenly look to git as
though it was definitely on a branch with ALL files staged for deletion!
A subsequent checkout or switch then had to contend with the fact that
it wasn't on an initial_checkout but had a bunch of staged deletions.
Make sure that sparse-checkout changes nothing in the index other than
the SKIP_WORKTREE bit; in particular, when the index is unborn we do not
have any branch checked out so there is no sparsification or
de-sparsification work to do. Simply return from
update_working_directory() early.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-06-05 02:41:39 +00:00
|
|
|
test_path_is_file clone_no_checkout/.git/index &&
|
|
|
|
check_files clone_no_checkout a folder1
|
|
|
|
'
|
|
|
|
|
2019-11-21 22:04:36 +00:00
|
|
|
test_expect_success 'set enables config' '
|
2022-02-07 21:33:02 +00:00
|
|
|
git init worktree-config &&
|
2019-11-21 22:04:36 +00:00
|
|
|
(
|
2022-02-07 21:33:02 +00:00
|
|
|
cd worktree-config &&
|
2019-11-21 22:04:36 +00:00
|
|
|
test_commit test file &&
|
|
|
|
test_path_is_missing .git/config.worktree &&
|
2020-05-04 18:27:43 +00:00
|
|
|
git sparse-checkout set nothing &&
|
2019-11-21 22:04:36 +00:00
|
|
|
test_path_is_file .git/config.worktree &&
|
|
|
|
test_cmp_config true core.sparseCheckout
|
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'set sparse-checkout using builtin' '
|
|
|
|
git -C repo sparse-checkout set "/*" "!/*/" "*folder*" &&
|
2020-01-24 21:19:32 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
*folder*
|
2019-11-21 22:04:36 +00:00
|
|
|
EOF
|
|
|
|
git -C repo sparse-checkout list >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
test_cmp expect repo/.git/info/sparse-checkout &&
|
2020-01-24 21:19:31 +00:00
|
|
|
check_files repo a folder1 folder2
|
2019-11-21 22:04:36 +00:00
|
|
|
'
|
|
|
|
|
2019-11-21 22:04:37 +00:00
|
|
|
test_expect_success 'set sparse-checkout using --stdin' '
|
2020-01-24 21:19:32 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/folder1/
|
|
|
|
/folder2/
|
2019-11-21 22:04:37 +00:00
|
|
|
EOF
|
|
|
|
git -C repo sparse-checkout set --stdin <expect &&
|
|
|
|
git -C repo sparse-checkout list >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
test_cmp expect repo/.git/info/sparse-checkout &&
|
2020-01-24 21:19:31 +00:00
|
|
|
check_files repo "a folder1 folder2"
|
2019-11-21 22:04:37 +00:00
|
|
|
'
|
|
|
|
|
2020-02-11 15:02:23 +00:00
|
|
|
test_expect_success 'add to sparse-checkout' '
|
2021-12-16 16:13:42 +00:00
|
|
|
cat repo/.git/info/sparse-checkout >old &&
|
|
|
|
test_when_finished cp old repo/.git/info/sparse-checkout &&
|
2020-02-11 15:02:23 +00:00
|
|
|
cat >add <<-\EOF &&
|
|
|
|
pattern1
|
|
|
|
/folder1/
|
|
|
|
pattern2
|
|
|
|
EOF
|
2021-12-16 16:13:42 +00:00
|
|
|
cat old >expect &&
|
2020-02-11 15:02:23 +00:00
|
|
|
cat add >>expect &&
|
|
|
|
git -C repo sparse-checkout add --stdin <add &&
|
|
|
|
git -C repo sparse-checkout list >actual &&
|
|
|
|
test_cmp expect actual &&
|
|
|
|
test_cmp expect repo/.git/info/sparse-checkout &&
|
|
|
|
check_files repo "a folder1 folder2"
|
|
|
|
'
|
|
|
|
|
2022-02-07 21:33:02 +00:00
|
|
|
test_expect_success 'worktree: add copies sparse-checkout patterns' '
|
|
|
|
cat repo/.git/info/sparse-checkout >old &&
|
|
|
|
test_when_finished cp old repo/.git/info/sparse-checkout &&
|
|
|
|
test_when_finished git -C repo worktree remove ../worktree &&
|
|
|
|
git -C repo sparse-checkout set --no-cone "/*" &&
|
|
|
|
git -C repo worktree add --quiet ../worktree 2>err &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
new="$(git -C worktree rev-parse --git-path info/sparse-checkout)" &&
|
|
|
|
test_path_is_file "$new" &&
|
|
|
|
test_cmp repo/.git/info/sparse-checkout "$new" &&
|
|
|
|
git -C worktree sparse-checkout set --cone &&
|
|
|
|
test_cmp_config -C worktree true core.sparseCheckoutCone &&
|
|
|
|
test_must_fail git -C repo core.sparseCheckoutCone
|
|
|
|
'
|
|
|
|
|
2019-11-21 22:04:40 +00:00
|
|
|
test_expect_success 'cone mode: match patterns' '
|
|
|
|
git -C repo config --worktree core.sparseCheckoutCone true &&
|
|
|
|
rm -rf repo/a repo/folder1 repo/folder2 &&
|
2019-11-21 22:04:41 +00:00
|
|
|
git -C repo read-tree -mu HEAD 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep ! "disabling cone patterns" err &&
|
2019-11-21 22:04:40 +00:00
|
|
|
git -C repo reset --hard &&
|
2020-01-24 21:19:31 +00:00
|
|
|
check_files repo a folder1 folder2
|
2019-11-21 22:04:40 +00:00
|
|
|
'
|
|
|
|
|
2019-11-21 22:04:41 +00:00
|
|
|
test_expect_success 'cone mode: warn on bad pattern' '
|
|
|
|
test_when_finished mv sparse-checkout repo/.git/info/ &&
|
|
|
|
cp repo/.git/info/sparse-checkout . &&
|
dir: check for single file cone patterns
The sparse checkout documentation states that the cone mode pattern set
is limited to patterns that either recursively include directories or
patterns that match all files in a directory. In the sparse checkout
file, the former manifest in the form:
/A/B/C/
while the latter become a pair of patterns either in the form:
/A/B/
!/A/B/*/
or in the special case of matching the toplevel files:
/*
!/*/
The 'add_pattern_to_hashsets()' function contains checks which serve to
disable cone-mode when non-cone patterns are encountered. However, these
do not catch when the pattern list attempts to match a single file or
directory, e.g. a pattern in the form:
/A/B/C
This causes sparse-checkout to exhibit unexpected behaviour when such a
pattern is in the sparse-checkout file and cone mode is enabled.
Concretely, with the pattern like the above, sparse-checkout, in
non-cone mode, will only include the directory or file located at
'/A/B/C'. However, with cone mode enabled, sparse-checkout will instead
just manifest the toplevel files but not any file located at '/A/B/C'.
Relatedly, issues occur when supplying the same kind of filter when
partial cloning with '--filter=sparse:oid=<oid>'. 'upload-pack' will
correctly just include the objects that match the non-cone pattern
matching. Which means that checking out the newly cloned repo with the
same filter, but with cone mode enabled, fails due to missing objects.
To fix these issues, add a cone mode pattern check that asserts that
every pattern is either a directory match or the pattern '/*'. Add a
test to verify the new pattern check and modify another to reflect that
non-directory patterns are caught earlier.
Signed-off-by: William Sprent <williams@unity3d.com>
Acked-by: Victoria Dye <vdye@github.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-01-03 08:20:59 +00:00
|
|
|
echo "!/deep/deeper/*/" >>repo/.git/info/sparse-checkout &&
|
2019-11-21 22:04:41 +00:00
|
|
|
git -C repo read-tree -mu HEAD 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "unrecognized negative pattern" err
|
2019-11-21 22:04:41 +00:00
|
|
|
'
|
|
|
|
|
2019-11-21 22:04:38 +00:00
|
|
|
test_expect_success 'sparse-checkout disable' '
|
2019-11-21 22:04:47 +00:00
|
|
|
test_when_finished rm -rf repo/.git/info/sparse-checkout &&
|
2019-11-21 22:04:38 +00:00
|
|
|
git -C repo sparse-checkout disable &&
|
2019-11-21 22:04:47 +00:00
|
|
|
test_path_is_file repo/.git/info/sparse-checkout &&
|
2019-11-21 22:04:38 +00:00
|
|
|
git -C repo config --list >config &&
|
|
|
|
test_must_fail git config core.sparseCheckout &&
|
2020-01-24 21:19:31 +00:00
|
|
|
check_files repo a deep folder1 folder2
|
2019-11-21 22:04:38 +00:00
|
|
|
'
|
|
|
|
|
2021-03-30 13:11:01 +00:00
|
|
|
test_expect_success 'sparse-index enabled and disabled' '
|
2022-01-19 17:29:38 +00:00
|
|
|
git -C repo sparse-checkout init --cone --sparse-index &&
|
|
|
|
test_cmp_config -C repo true index.sparse &&
|
|
|
|
git -C repo ls-files --sparse >sparse &&
|
|
|
|
git -C repo sparse-checkout disable &&
|
|
|
|
git -C repo ls-files --sparse >full &&
|
2021-12-22 14:20:55 +00:00
|
|
|
|
2022-01-19 17:29:38 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
@@ -1,4 +1,7 @@
|
|
|
|
a
|
|
|
|
-deep/
|
|
|
|
-folder1/
|
|
|
|
-folder2/
|
|
|
|
+deep/a
|
|
|
|
+deep/deeper1/a
|
|
|
|
+deep/deeper1/deepest/a
|
|
|
|
+deep/deeper2/a
|
|
|
|
+folder1/a
|
|
|
|
+folder2/a
|
|
|
|
EOF
|
2021-12-22 14:20:55 +00:00
|
|
|
|
2022-01-19 17:29:38 +00:00
|
|
|
diff -u sparse full | tail -n +3 >actual &&
|
|
|
|
test_cmp expect actual &&
|
2021-12-22 14:20:55 +00:00
|
|
|
|
2022-01-19 17:29:38 +00:00
|
|
|
git -C repo config --list >config &&
|
2022-02-25 23:47:33 +00:00
|
|
|
test_cmp_config -C repo false index.sparse
|
2021-03-30 13:11:01 +00:00
|
|
|
'
|
|
|
|
|
2019-11-21 22:04:42 +00:00
|
|
|
test_expect_success 'cone mode: init and set' '
|
|
|
|
git -C repo sparse-checkout init --cone &&
|
|
|
|
git -C repo config --list >config &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "core.sparsecheckoutcone=true" config &&
|
2019-12-20 19:41:14 +00:00
|
|
|
list_files repo >dir &&
|
2019-11-21 22:04:42 +00:00
|
|
|
echo a >expect &&
|
|
|
|
test_cmp expect dir &&
|
|
|
|
git -C repo sparse-checkout set deep/deeper1/deepest/ 2>err &&
|
|
|
|
test_must_be_empty err &&
|
2020-01-24 21:19:31 +00:00
|
|
|
check_files repo a deep &&
|
|
|
|
check_files repo/deep a deeper1 &&
|
|
|
|
check_files repo/deep/deeper1 a deepest &&
|
2020-01-24 21:19:32 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/deep/
|
|
|
|
!/deep/*/
|
|
|
|
/deep/deeper1/
|
|
|
|
!/deep/deeper1/*/
|
|
|
|
/deep/deeper1/deepest/
|
2019-11-21 22:04:42 +00:00
|
|
|
EOF
|
|
|
|
test_cmp expect repo/.git/info/sparse-checkout &&
|
2020-01-24 21:19:32 +00:00
|
|
|
git -C repo sparse-checkout set --stdin 2>err <<-\EOF &&
|
|
|
|
folder1
|
|
|
|
folder2
|
2019-11-21 22:04:42 +00:00
|
|
|
EOF
|
|
|
|
test_must_be_empty err &&
|
2020-01-24 21:19:31 +00:00
|
|
|
check_files repo a folder1 folder2
|
2019-11-21 22:04:42 +00:00
|
|
|
'
|
|
|
|
|
2019-12-30 15:33:12 +00:00
|
|
|
test_expect_success 'cone mode: list' '
|
2020-01-24 21:19:32 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
folder1
|
|
|
|
folder2
|
2019-12-30 15:33:12 +00:00
|
|
|
EOF
|
|
|
|
git -C repo sparse-checkout set --stdin <expect &&
|
|
|
|
git -C repo sparse-checkout list >actual 2>err &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
2019-11-21 22:04:45 +00:00
|
|
|
test_expect_success 'cone mode: set with nested folders' '
|
|
|
|
git -C repo sparse-checkout set deep deep/deeper1/deepest 2>err &&
|
|
|
|
test_line_count = 0 err &&
|
2020-01-24 21:19:32 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/deep/
|
2019-11-21 22:04:45 +00:00
|
|
|
EOF
|
|
|
|
test_cmp repo/.git/info/sparse-checkout expect
|
|
|
|
'
|
|
|
|
|
2020-02-11 15:02:23 +00:00
|
|
|
test_expect_success 'cone mode: add independent path' '
|
|
|
|
git -C repo sparse-checkout set deep/deeper1 &&
|
sparse-checkout: be consistent with end of options markers
93851746 (parse-options: decouple "--end-of-options" and "--",
2023-12-06) updated the world order to make callers of parse-options
that set PARSE_OPT_KEEP_UNKNOWN_OPT responsible for deciding what to
do with "--end-of-options" they may see after parse_options() returns.
This made a previous bug in sparse-checkout more visible; namely,
that
git sparse-checkout [add|set] --[no-]cone --end-of-options ...
would simply treat "--end-of-options" as one of the paths to include in
the sparse-checkout. But this was already problematic before; namely,
git sparse-checkout [add|set| --[no-]cone --sikp-checks ...
would not give an error on the mis-typed "--skip-checks" but instead
simply treat "--sikp-checks" as a path or pattern to include in the
sparse-checkout, which is highly unfriendly.
This behavior began when the command was converted to parse-options in
7bffca95ea (sparse-checkout: add '--stdin' option to set subcommand,
2019-11-21). Back then it was just called KEEP_UNKNOWN. Later it was
renamed to KEEP_UNKNOWN_OPT in 99d86d60e5 (parse-options:
PARSE_OPT_KEEP_UNKNOWN only applies to --options, 2022-08-19) to clarify
that it was only about dashed options; we always keep non-option
arguments. Looking at that original patch, both Peff and I think that
the author was simply confused about the mis-named option, and really
just wanted to keep the non-option arguments. We never should have used
the flag all along (and the other cases were cargo-culted within the
file).
Remove the erroneous PARSE_OPT_KEEP_UNKNOWN_OPT flag now to fix this
bug. Note that this does mean that anyone who might have been using
git sparse-checkout [add|set] [--[no-]cone] --foo --bar
to request paths or patterns '--foo' and '--bar' will now have to use
git sparse-checkout [add|set] [--[no-]cone] -- --foo --bar
That makes sparse-checkout more consistent with other git commands,
provides users much friendlier error messages and behavior, and is
consistent with the all-caps warning in git-sparse-checkout.txt that
this command "is experimental...its behavior...will likely change". :-)
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-12-26 19:39:22 +00:00
|
|
|
git -C repo sparse-checkout add --end-of-options folder1 &&
|
2020-02-11 15:02:23 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/deep/
|
|
|
|
!/deep/*/
|
|
|
|
/deep/deeper1/
|
|
|
|
/folder1/
|
|
|
|
EOF
|
|
|
|
test_cmp expect repo/.git/info/sparse-checkout &&
|
|
|
|
check_files repo a deep folder1
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'cone mode: add sibling path' '
|
|
|
|
git -C repo sparse-checkout set deep/deeper1 &&
|
|
|
|
git -C repo sparse-checkout add deep/deeper2 &&
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/deep/
|
|
|
|
!/deep/*/
|
|
|
|
/deep/deeper1/
|
|
|
|
/deep/deeper2/
|
|
|
|
EOF
|
|
|
|
test_cmp expect repo/.git/info/sparse-checkout &&
|
|
|
|
check_files repo a deep
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'cone mode: add parent path' '
|
|
|
|
git -C repo sparse-checkout set deep/deeper1 folder1 &&
|
|
|
|
git -C repo sparse-checkout add deep &&
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/deep/
|
|
|
|
/folder1/
|
|
|
|
EOF
|
|
|
|
test_cmp expect repo/.git/info/sparse-checkout &&
|
|
|
|
check_files repo a deep folder1
|
|
|
|
'
|
|
|
|
|
2020-03-27 00:48:53 +00:00
|
|
|
test_expect_success 'not-up-to-date does not block rest of sparsification' '
|
2020-03-27 00:48:48 +00:00
|
|
|
test_when_finished git -C repo sparse-checkout disable &&
|
2019-11-21 22:04:51 +00:00
|
|
|
test_when_finished git -C repo reset --hard &&
|
2020-02-11 15:02:23 +00:00
|
|
|
git -C repo sparse-checkout set deep &&
|
2020-03-27 00:48:53 +00:00
|
|
|
|
2019-11-21 22:04:46 +00:00
|
|
|
echo update >repo/deep/deeper2/a &&
|
|
|
|
cp repo/.git/info/sparse-checkout expect &&
|
2020-03-27 00:48:53 +00:00
|
|
|
test_write_lines "!/deep/*/" "/deep/deeper1/" >>expect &&
|
|
|
|
|
|
|
|
git -C repo sparse-checkout set deep/deeper1 2>err &&
|
|
|
|
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "The following paths are not up to date" err &&
|
2020-03-27 00:48:53 +00:00
|
|
|
test_cmp expect repo/.git/info/sparse-checkout &&
|
|
|
|
check_files repo/deep a deeper1 deeper2 &&
|
|
|
|
check_files repo/deep/deeper1 a deepest &&
|
|
|
|
check_files repo/deep/deeper1/deepest a &&
|
|
|
|
check_files repo/deep/deeper2 a
|
2019-11-21 22:04:46 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'revert to old sparse-checkout on empty update' '
|
|
|
|
git init empty-test &&
|
|
|
|
(
|
|
|
|
echo >file &&
|
|
|
|
git add file &&
|
|
|
|
git commit -m "test" &&
|
2020-05-04 18:27:43 +00:00
|
|
|
git sparse-checkout set nothing 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep ! "Sparse checkout leaves no entry on working directory" err &&
|
|
|
|
test_grep ! ".git/index.lock" err &&
|
2022-04-22 02:32:18 +00:00
|
|
|
git sparse-checkout set --no-cone file
|
2019-11-21 22:04:46 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
2019-11-21 22:04:48 +00:00
|
|
|
test_expect_success 'fail when lock is taken' '
|
|
|
|
test_when_finished rm -rf repo/.git/info/sparse-checkout.lock &&
|
|
|
|
touch repo/.git/info/sparse-checkout.lock &&
|
|
|
|
test_must_fail git -C repo sparse-checkout set deep 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "Unable to create .*\.lock" err
|
2019-11-21 22:04:48 +00:00
|
|
|
'
|
|
|
|
|
2019-11-21 22:04:49 +00:00
|
|
|
test_expect_success '.gitignore should not warn about cone mode' '
|
|
|
|
git -C repo config --worktree core.sparseCheckoutCone true &&
|
|
|
|
echo "**/bin/*" >repo/.gitignore &&
|
|
|
|
git -C repo reset --hard 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep ! "disabling cone patterns" err
|
2019-11-21 22:04:49 +00:00
|
|
|
'
|
|
|
|
|
2020-03-27 00:48:53 +00:00
|
|
|
test_expect_success 'sparse-checkout (init|set|disable) warns with dirty status' '
|
2019-11-21 22:04:51 +00:00
|
|
|
git clone repo dirty &&
|
|
|
|
echo dirty >dirty/folder1/a &&
|
2020-03-27 00:48:53 +00:00
|
|
|
|
2022-04-22 02:32:18 +00:00
|
|
|
git -C dirty sparse-checkout init --no-cone 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "warning.*The following paths are not up to date" err &&
|
2020-03-27 00:48:53 +00:00
|
|
|
|
|
|
|
git -C dirty sparse-checkout set /folder2/* /deep/deeper1/* 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "warning.*The following paths are not up to date" err &&
|
2020-03-27 00:48:53 +00:00
|
|
|
test_path_is_file dirty/folder1/a &&
|
|
|
|
|
|
|
|
git -C dirty sparse-checkout disable 2>err &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
|
2019-11-21 22:04:51 +00:00
|
|
|
git -C dirty reset --hard &&
|
2022-04-22 02:32:18 +00:00
|
|
|
git -C dirty sparse-checkout init --no-cone &&
|
2019-11-21 22:04:51 +00:00
|
|
|
git -C dirty sparse-checkout set /folder2/* /deep/deeper1/* &&
|
2020-03-27 00:48:53 +00:00
|
|
|
test_path_is_missing dirty/folder1/a &&
|
|
|
|
git -C dirty sparse-checkout disable &&
|
|
|
|
test_path_is_file dirty/folder1/a
|
2019-11-21 22:04:51 +00:00
|
|
|
'
|
|
|
|
|
2020-03-27 00:48:59 +00:00
|
|
|
test_expect_success 'sparse-checkout (init|set|disable) warns with unmerged status' '
|
|
|
|
git clone repo unmerged &&
|
|
|
|
|
|
|
|
cat >input <<-EOF &&
|
2020-07-29 23:13:51 +00:00
|
|
|
0 $ZERO_OID folder1/a
|
2020-03-27 00:48:59 +00:00
|
|
|
100644 $(git -C unmerged rev-parse HEAD:folder1/a) 1 folder1/a
|
|
|
|
EOF
|
|
|
|
git -C unmerged update-index --index-info <input &&
|
|
|
|
|
2022-04-22 02:32:18 +00:00
|
|
|
git -C unmerged sparse-checkout init --no-cone 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "warning.*The following paths are unmerged" err &&
|
2020-03-27 00:48:59 +00:00
|
|
|
|
|
|
|
git -C unmerged sparse-checkout set /folder2/* /deep/deeper1/* 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "warning.*The following paths are unmerged" err &&
|
2020-03-27 00:48:59 +00:00
|
|
|
test_path_is_file dirty/folder1/a &&
|
|
|
|
|
|
|
|
git -C unmerged sparse-checkout disable 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "warning.*The following paths are unmerged" err &&
|
2020-03-27 00:48:59 +00:00
|
|
|
|
|
|
|
git -C unmerged reset --hard &&
|
2022-04-22 02:32:18 +00:00
|
|
|
git -C unmerged sparse-checkout init --no-cone &&
|
2020-03-27 00:48:59 +00:00
|
|
|
git -C unmerged sparse-checkout set /folder2/* /deep/deeper1/* &&
|
|
|
|
git -C unmerged sparse-checkout disable
|
|
|
|
'
|
|
|
|
|
2021-09-24 15:39:07 +00:00
|
|
|
test_expect_failure 'sparse-checkout reapply' '
|
2020-03-27 00:49:01 +00:00
|
|
|
git clone repo tweak &&
|
|
|
|
|
|
|
|
echo dirty >tweak/deep/deeper2/a &&
|
|
|
|
|
|
|
|
cat >input <<-EOF &&
|
2020-07-29 23:13:51 +00:00
|
|
|
0 $ZERO_OID folder1/a
|
2020-03-27 00:49:01 +00:00
|
|
|
100644 $(git -C tweak rev-parse HEAD:folder1/a) 1 folder1/a
|
|
|
|
EOF
|
|
|
|
git -C tweak update-index --index-info <input &&
|
|
|
|
|
|
|
|
git -C tweak sparse-checkout init --cone 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "warning.*The following paths are not up to date" err &&
|
|
|
|
test_grep "warning.*The following paths are unmerged" err &&
|
2020-03-27 00:49:01 +00:00
|
|
|
|
|
|
|
git -C tweak sparse-checkout set folder2 deep/deeper1 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "warning.*The following paths are not up to date" err &&
|
|
|
|
test_grep "warning.*The following paths are unmerged" err &&
|
2020-03-27 00:49:01 +00:00
|
|
|
|
|
|
|
git -C tweak sparse-checkout reapply 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "warning.*The following paths are not up to date" err &&
|
2020-03-27 00:49:01 +00:00
|
|
|
test_path_is_file tweak/deep/deeper2/a &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "warning.*The following paths are unmerged" err &&
|
2020-03-27 00:49:01 +00:00
|
|
|
test_path_is_file tweak/folder1/a &&
|
|
|
|
|
|
|
|
git -C tweak checkout HEAD deep/deeper2/a &&
|
|
|
|
git -C tweak sparse-checkout reapply 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep ! "warning.*The following paths are not up to date" err &&
|
2020-03-27 00:49:01 +00:00
|
|
|
test_path_is_missing tweak/deep/deeper2/a &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "warning.*The following paths are unmerged" err &&
|
2020-03-27 00:49:01 +00:00
|
|
|
test_path_is_file tweak/folder1/a &&
|
|
|
|
|
2021-09-24 15:39:07 +00:00
|
|
|
# NEEDSWORK: We are asking to update a file outside of the
|
|
|
|
# sparse-checkout cone, but this is no longer allowed.
|
2020-03-27 00:49:01 +00:00
|
|
|
git -C tweak add folder1/a &&
|
|
|
|
git -C tweak sparse-checkout reapply 2>err &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
test_path_is_missing tweak/deep/deeper2/a &&
|
|
|
|
test_path_is_missing tweak/folder1/a &&
|
|
|
|
|
|
|
|
git -C tweak sparse-checkout disable
|
|
|
|
'
|
|
|
|
|
2022-02-19 16:44:41 +00:00
|
|
|
test_expect_success 'reapply can handle config options' '
|
|
|
|
git -C repo sparse-checkout init --cone --no-sparse-index &&
|
|
|
|
git -C repo config --worktree --list >actual &&
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
core.sparsecheckout=true
|
|
|
|
core.sparsecheckoutcone=true
|
2022-03-07 05:25:30 +00:00
|
|
|
index.sparse=false
|
2022-02-19 16:44:41 +00:00
|
|
|
EOF
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git -C repo sparse-checkout reapply --no-cone --no-sparse-index &&
|
|
|
|
git -C repo config --worktree --list >actual &&
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
core.sparsecheckout=true
|
2022-03-07 05:25:30 +00:00
|
|
|
core.sparsecheckoutcone=false
|
|
|
|
index.sparse=false
|
2022-02-19 16:44:41 +00:00
|
|
|
EOF
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git -C repo sparse-checkout reapply --cone --sparse-index &&
|
|
|
|
git -C repo config --worktree --list >actual &&
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
core.sparsecheckout=true
|
|
|
|
core.sparsecheckoutcone=true
|
|
|
|
index.sparse=true
|
|
|
|
EOF
|
|
|
|
test_cmp expect actual &&
|
|
|
|
|
|
|
|
git -C repo sparse-checkout disable
|
|
|
|
'
|
|
|
|
|
sparse-checkout: respect core.ignoreCase in cone mode
When a user uses the sparse-checkout feature in cone mode, they
add patterns using "git sparse-checkout set <dir1> <dir2> ..."
or by using "--stdin" to provide the directories line-by-line over
stdin. This behaviour naturally looks a lot like the way a user
would type "git add <dir1> <dir2> ..."
If core.ignoreCase is enabled, then "git add" will match the input
using a case-insensitive match. Do the same for the sparse-checkout
feature.
Perform case-insensitive checks while updating the skip-worktree
bits during unpack_trees(). This is done by changing the hash
algorithm and hashmap comparison methods to optionally use case-
insensitive methods.
When this is enabled, there is a small performance cost in the
hashing algorithm. To tease out the worst possible case, the
following was run on a repo with a deep directory structure:
git ls-tree -d -r --name-only HEAD |
git sparse-checkout set --stdin
The 'set' command was timed with core.ignoreCase disabled or
enabled. For the repo with a deep history, the numbers were
core.ignoreCase=false: 62s
core.ignoreCase=true: 74s (+19.3%)
For reproducibility, the equivalent test on the Linux kernel
repository had these numbers:
core.ignoreCase=false: 3.1s
core.ignoreCase=true: 3.6s (+16%)
Now, this is not an entirely fair comparison, as most users
will define their sparse cone using more shallow directories,
and the performance improvement from eb42feca97 ("unpack-trees:
hash less in cone mode" 2019-11-21) can remove most of the
hash cost. For a more realistic test, drop the "-r" from the
ls-tree command to store only the first-level directories.
In that case, the Linux kernel repository takes 0.2-0.25s in
each case, and the deep repository takes one second, plus or
minus 0.05s, in each case.
Thus, we _can_ demonstrate a cost to this change, but it is
unlikely to matter to any reasonable sparse-checkout cone.
Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-12-13 18:09:53 +00:00
|
|
|
test_expect_success 'cone mode: set with core.ignoreCase=true' '
|
2020-03-27 00:48:48 +00:00
|
|
|
rm repo/.git/info/sparse-checkout &&
|
sparse-checkout: respect core.ignoreCase in cone mode
When a user uses the sparse-checkout feature in cone mode, they
add patterns using "git sparse-checkout set <dir1> <dir2> ..."
or by using "--stdin" to provide the directories line-by-line over
stdin. This behaviour naturally looks a lot like the way a user
would type "git add <dir1> <dir2> ..."
If core.ignoreCase is enabled, then "git add" will match the input
using a case-insensitive match. Do the same for the sparse-checkout
feature.
Perform case-insensitive checks while updating the skip-worktree
bits during unpack_trees(). This is done by changing the hash
algorithm and hashmap comparison methods to optionally use case-
insensitive methods.
When this is enabled, there is a small performance cost in the
hashing algorithm. To tease out the worst possible case, the
following was run on a repo with a deep directory structure:
git ls-tree -d -r --name-only HEAD |
git sparse-checkout set --stdin
The 'set' command was timed with core.ignoreCase disabled or
enabled. For the repo with a deep history, the numbers were
core.ignoreCase=false: 62s
core.ignoreCase=true: 74s (+19.3%)
For reproducibility, the equivalent test on the Linux kernel
repository had these numbers:
core.ignoreCase=false: 3.1s
core.ignoreCase=true: 3.6s (+16%)
Now, this is not an entirely fair comparison, as most users
will define their sparse cone using more shallow directories,
and the performance improvement from eb42feca97 ("unpack-trees:
hash less in cone mode" 2019-11-21) can remove most of the
hash cost. For a more realistic test, drop the "-r" from the
ls-tree command to store only the first-level directories.
In that case, the Linux kernel repository takes 0.2-0.25s in
each case, and the deep repository takes one second, plus or
minus 0.05s, in each case.
Thus, we _can_ demonstrate a cost to this change, but it is
unlikely to matter to any reasonable sparse-checkout cone.
Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-12-13 18:09:53 +00:00
|
|
|
git -C repo sparse-checkout init --cone &&
|
|
|
|
git -C repo -c core.ignoreCase=true sparse-checkout set folder1 &&
|
2020-01-24 21:19:32 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/folder1/
|
sparse-checkout: respect core.ignoreCase in cone mode
When a user uses the sparse-checkout feature in cone mode, they
add patterns using "git sparse-checkout set <dir1> <dir2> ..."
or by using "--stdin" to provide the directories line-by-line over
stdin. This behaviour naturally looks a lot like the way a user
would type "git add <dir1> <dir2> ..."
If core.ignoreCase is enabled, then "git add" will match the input
using a case-insensitive match. Do the same for the sparse-checkout
feature.
Perform case-insensitive checks while updating the skip-worktree
bits during unpack_trees(). This is done by changing the hash
algorithm and hashmap comparison methods to optionally use case-
insensitive methods.
When this is enabled, there is a small performance cost in the
hashing algorithm. To tease out the worst possible case, the
following was run on a repo with a deep directory structure:
git ls-tree -d -r --name-only HEAD |
git sparse-checkout set --stdin
The 'set' command was timed with core.ignoreCase disabled or
enabled. For the repo with a deep history, the numbers were
core.ignoreCase=false: 62s
core.ignoreCase=true: 74s (+19.3%)
For reproducibility, the equivalent test on the Linux kernel
repository had these numbers:
core.ignoreCase=false: 3.1s
core.ignoreCase=true: 3.6s (+16%)
Now, this is not an entirely fair comparison, as most users
will define their sparse cone using more shallow directories,
and the performance improvement from eb42feca97 ("unpack-trees:
hash less in cone mode" 2019-11-21) can remove most of the
hash cost. For a more realistic test, drop the "-r" from the
ls-tree command to store only the first-level directories.
In that case, the Linux kernel repository takes 0.2-0.25s in
each case, and the deep repository takes one second, plus or
minus 0.05s, in each case.
Thus, we _can_ demonstrate a cost to this change, but it is
unlikely to matter to any reasonable sparse-checkout cone.
Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-12-13 18:09:53 +00:00
|
|
|
EOF
|
|
|
|
test_cmp expect repo/.git/info/sparse-checkout &&
|
2020-01-24 21:19:31 +00:00
|
|
|
check_files repo a folder1
|
sparse-checkout: respect core.ignoreCase in cone mode
When a user uses the sparse-checkout feature in cone mode, they
add patterns using "git sparse-checkout set <dir1> <dir2> ..."
or by using "--stdin" to provide the directories line-by-line over
stdin. This behaviour naturally looks a lot like the way a user
would type "git add <dir1> <dir2> ..."
If core.ignoreCase is enabled, then "git add" will match the input
using a case-insensitive match. Do the same for the sparse-checkout
feature.
Perform case-insensitive checks while updating the skip-worktree
bits during unpack_trees(). This is done by changing the hash
algorithm and hashmap comparison methods to optionally use case-
insensitive methods.
When this is enabled, there is a small performance cost in the
hashing algorithm. To tease out the worst possible case, the
following was run on a repo with a deep directory structure:
git ls-tree -d -r --name-only HEAD |
git sparse-checkout set --stdin
The 'set' command was timed with core.ignoreCase disabled or
enabled. For the repo with a deep history, the numbers were
core.ignoreCase=false: 62s
core.ignoreCase=true: 74s (+19.3%)
For reproducibility, the equivalent test on the Linux kernel
repository had these numbers:
core.ignoreCase=false: 3.1s
core.ignoreCase=true: 3.6s (+16%)
Now, this is not an entirely fair comparison, as most users
will define their sparse cone using more shallow directories,
and the performance improvement from eb42feca97 ("unpack-trees:
hash less in cone mode" 2019-11-21) can remove most of the
hash cost. For a more realistic test, drop the "-r" from the
ls-tree command to store only the first-level directories.
In that case, the Linux kernel repository takes 0.2-0.25s in
each case, and the deep repository takes one second, plus or
minus 0.05s, in each case.
Thus, we _can_ demonstrate a cost to this change, but it is
unlikely to matter to any reasonable sparse-checkout cone.
Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-12-13 18:09:53 +00:00
|
|
|
'
|
|
|
|
|
2023-03-27 07:55:03 +00:00
|
|
|
test_expect_success 'setup submodules' '
|
2019-12-30 15:33:13 +00:00
|
|
|
git clone repo super &&
|
|
|
|
(
|
|
|
|
cd super &&
|
|
|
|
mkdir modules &&
|
2022-07-29 19:16:10 +00:00
|
|
|
git -c protocol.file.allow=always \
|
|
|
|
submodule add ../repo modules/child &&
|
2019-12-30 15:33:13 +00:00
|
|
|
git add . &&
|
|
|
|
git commit -m "add submodule" &&
|
|
|
|
git sparse-checkout init --cone &&
|
|
|
|
git sparse-checkout set folder1
|
2023-03-27 07:55:03 +00:00
|
|
|
)
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'interaction with submodules' '
|
2020-01-24 21:19:31 +00:00
|
|
|
check_files super a folder1 modules &&
|
|
|
|
check_files super/modules/child a deep folder1 folder2
|
2019-12-30 15:33:13 +00:00
|
|
|
'
|
|
|
|
|
2023-03-27 07:55:03 +00:00
|
|
|
test_expect_success 'check-rules interaction with submodules' '
|
|
|
|
git -C super ls-tree --name-only -r HEAD >all-files &&
|
|
|
|
git -C super sparse-checkout check-rules >check-rules-matches <all-files &&
|
|
|
|
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep ! "modules/" check-rules-matches &&
|
|
|
|
test_grep "folder1/" check-rules-matches
|
2023-03-27 07:55:03 +00:00
|
|
|
'
|
|
|
|
|
2020-01-24 21:19:33 +00:00
|
|
|
test_expect_success 'different sparse-checkouts with worktrees' '
|
2022-02-07 21:33:02 +00:00
|
|
|
git -C repo sparse-checkout set --cone deep folder1 &&
|
2020-01-24 21:19:33 +00:00
|
|
|
git -C repo worktree add --detach ../worktree &&
|
2022-02-07 21:33:02 +00:00
|
|
|
check_files worktree "a deep folder1" &&
|
|
|
|
git -C repo sparse-checkout set --cone folder1 &&
|
|
|
|
git -C worktree sparse-checkout set --cone deep/deeper1 &&
|
|
|
|
check_files repo "a folder1" &&
|
|
|
|
check_files worktree "a deep"
|
2020-01-24 21:19:33 +00:00
|
|
|
'
|
|
|
|
|
2020-01-31 20:16:15 +00:00
|
|
|
test_expect_success 'set using filename keeps file on-disk' '
|
2022-02-19 16:44:44 +00:00
|
|
|
git -C repo sparse-checkout set --skip-checks a deep &&
|
2020-01-31 20:16:15 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/a/
|
|
|
|
/deep/
|
|
|
|
EOF
|
|
|
|
test_cmp expect repo/.git/info/sparse-checkout &&
|
|
|
|
check_files repo a deep
|
|
|
|
'
|
|
|
|
|
2020-01-24 21:19:36 +00:00
|
|
|
check_read_tree_errors () {
|
|
|
|
REPO=$1
|
|
|
|
FILES=$2
|
|
|
|
ERRORS=$3
|
2020-01-31 20:16:10 +00:00
|
|
|
git -C $REPO -c core.sparseCheckoutCone=false read-tree -mu HEAD 2>err &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
check_files $REPO "$FILES" &&
|
2020-01-24 21:19:36 +00:00
|
|
|
git -C $REPO read-tree -mu HEAD 2>err &&
|
|
|
|
if test -z "$ERRORS"
|
|
|
|
then
|
|
|
|
test_must_be_empty err
|
|
|
|
else
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "$ERRORS" err
|
2020-01-24 21:19:36 +00:00
|
|
|
fi &&
|
|
|
|
check_files $REPO $FILES
|
|
|
|
}
|
|
|
|
|
|
|
|
test_expect_success 'pattern-checks: /A/**' '
|
|
|
|
cat >repo/.git/info/sparse-checkout <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/folder1/**
|
|
|
|
EOF
|
|
|
|
check_read_tree_errors repo "a folder1" "disabling cone pattern matching"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'pattern-checks: /A/**/B/' '
|
|
|
|
cat >repo/.git/info/sparse-checkout <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/deep/**/deepest
|
|
|
|
EOF
|
|
|
|
check_read_tree_errors repo "a deep" "disabling cone pattern matching" &&
|
|
|
|
check_files repo/deep "deeper1" &&
|
|
|
|
check_files repo/deep/deeper1 "deepest"
|
|
|
|
'
|
|
|
|
|
2020-01-24 21:19:37 +00:00
|
|
|
test_expect_success 'pattern-checks: too short' '
|
|
|
|
cat >repo/.git/info/sparse-checkout <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
sparse-checkout: allow one-character directories in cone mode
In 9e6d3e64 (sparse-checkout: detect short patterns, 2020-01-24), a
condition on the minimum length of a cone-mode pattern was introduced.
However, this condition was off-by-one.
If we have a directory with a single character, say "b", then the
command
git sparse-checkout set b
will correctly add the pattern "/b/" to the sparse-checkout file. When
this is interpeted in dir.c, the pattern is "/b" with the
PATTERN_FLAG_MUSTBEDIR flag. This string has length two, which satisfies
our inclusive inequality (<= 2).
The reason for this inequality is that we will start to read the pattern
string character-by-character using three char pointers: prev, cur,
next. In particular, next is set to the current pattern plus two. The
mistake was that next will still be a valid pointer when the pattern
length is two, since the string is null-terminated.
Make this inequality strict so these patterns work.
Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-02-20 20:07:06 +00:00
|
|
|
/
|
2020-01-24 21:19:37 +00:00
|
|
|
EOF
|
|
|
|
check_read_tree_errors repo "a" "disabling cone pattern matching"
|
|
|
|
'
|
sparse-checkout: allow one-character directories in cone mode
In 9e6d3e64 (sparse-checkout: detect short patterns, 2020-01-24), a
condition on the minimum length of a cone-mode pattern was introduced.
However, this condition was off-by-one.
If we have a directory with a single character, say "b", then the
command
git sparse-checkout set b
will correctly add the pattern "/b/" to the sparse-checkout file. When
this is interpeted in dir.c, the pattern is "/b" with the
PATTERN_FLAG_MUSTBEDIR flag. This string has length two, which satisfies
our inclusive inequality (<= 2).
The reason for this inequality is that we will start to read the pattern
string character-by-character using three char pointers: prev, cur,
next. In particular, next is set to the current pattern plus two. The
mistake was that next will still be a valid pointer when the pattern
length is two, since the string is null-terminated.
Make this inequality strict so these patterns work.
Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-02-20 20:07:06 +00:00
|
|
|
test_expect_success 'pattern-checks: not too short' '
|
|
|
|
cat >repo/.git/info/sparse-checkout <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/b/
|
|
|
|
EOF
|
|
|
|
git -C repo read-tree -mu HEAD 2>err &&
|
|
|
|
test_must_be_empty err &&
|
|
|
|
check_files repo a
|
|
|
|
'
|
2020-01-24 21:19:37 +00:00
|
|
|
|
2020-01-31 20:16:08 +00:00
|
|
|
test_expect_success 'pattern-checks: trailing "*"' '
|
|
|
|
cat >repo/.git/info/sparse-checkout <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/a*
|
|
|
|
EOF
|
|
|
|
check_read_tree_errors repo "a" "disabling cone pattern matching"
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'pattern-checks: starting "*"' '
|
|
|
|
cat >repo/.git/info/sparse-checkout <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
*eep/
|
|
|
|
EOF
|
|
|
|
check_read_tree_errors repo "a deep" "disabling cone pattern matching"
|
|
|
|
'
|
|
|
|
|
dir: check for single file cone patterns
The sparse checkout documentation states that the cone mode pattern set
is limited to patterns that either recursively include directories or
patterns that match all files in a directory. In the sparse checkout
file, the former manifest in the form:
/A/B/C/
while the latter become a pair of patterns either in the form:
/A/B/
!/A/B/*/
or in the special case of matching the toplevel files:
/*
!/*/
The 'add_pattern_to_hashsets()' function contains checks which serve to
disable cone-mode when non-cone patterns are encountered. However, these
do not catch when the pattern list attempts to match a single file or
directory, e.g. a pattern in the form:
/A/B/C
This causes sparse-checkout to exhibit unexpected behaviour when such a
pattern is in the sparse-checkout file and cone mode is enabled.
Concretely, with the pattern like the above, sparse-checkout, in
non-cone mode, will only include the directory or file located at
'/A/B/C'. However, with cone mode enabled, sparse-checkout will instead
just manifest the toplevel files but not any file located at '/A/B/C'.
Relatedly, issues occur when supplying the same kind of filter when
partial cloning with '--filter=sparse:oid=<oid>'. 'upload-pack' will
correctly just include the objects that match the non-cone pattern
matching. Which means that checking out the newly cloned repo with the
same filter, but with cone mode enabled, fails due to missing objects.
To fix these issues, add a cone mode pattern check that asserts that
every pattern is either a directory match or the pattern '/*'. Add a
test to verify the new pattern check and modify another to reflect that
non-directory patterns are caught earlier.
Signed-off-by: William Sprent <williams@unity3d.com>
Acked-by: Victoria Dye <vdye@github.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-01-03 08:20:59 +00:00
|
|
|
test_expect_success 'pattern-checks: non directory pattern' '
|
|
|
|
cat >repo/.git/info/sparse-checkout <<-\EOF &&
|
|
|
|
/deep/deeper1/a
|
|
|
|
EOF
|
|
|
|
check_read_tree_errors repo deep "disabling cone pattern matching" &&
|
|
|
|
check_files repo/deep deeper1 &&
|
|
|
|
check_files repo/deep/deeper1 a
|
|
|
|
'
|
|
|
|
|
2020-01-31 20:16:08 +00:00
|
|
|
test_expect_success 'pattern-checks: contained glob characters' '
|
|
|
|
for c in "[a]" "\\" "?" "*"
|
|
|
|
do
|
|
|
|
cat >repo/.git/info/sparse-checkout <<-EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
something$c-else/
|
|
|
|
EOF
|
2021-12-09 05:11:12 +00:00
|
|
|
check_read_tree_errors repo "a" "disabling cone pattern matching" || return 1
|
2020-01-31 20:16:08 +00:00
|
|
|
done
|
|
|
|
'
|
|
|
|
|
2020-01-31 20:16:13 +00:00
|
|
|
test_expect_success BSLASHPSPEC 'pattern-checks: escaped characters' '
|
2020-01-31 20:16:09 +00:00
|
|
|
git clone repo escaped &&
|
|
|
|
TREEOID=$(git -C escaped rev-parse HEAD:folder1) &&
|
|
|
|
NEWTREE=$(git -C escaped mktree <<-EOF
|
|
|
|
$(git -C escaped ls-tree HEAD)
|
|
|
|
040000 tree $TREEOID zbad\\dir
|
|
|
|
040000 tree $TREEOID zdoes*exist
|
2020-01-31 20:16:13 +00:00
|
|
|
040000 tree $TREEOID zglob[!a]?
|
2020-01-31 20:16:09 +00:00
|
|
|
EOF
|
|
|
|
) &&
|
|
|
|
COMMIT=$(git -C escaped commit-tree $NEWTREE -p HEAD) &&
|
|
|
|
git -C escaped reset --hard $COMMIT &&
|
2020-01-31 20:16:13 +00:00
|
|
|
check_files escaped "a deep folder1 folder2 zbad\\dir zdoes*exist" zglob[!a]? &&
|
2020-01-31 20:16:09 +00:00
|
|
|
git -C escaped sparse-checkout init --cone &&
|
2022-02-19 16:44:45 +00:00
|
|
|
git -C escaped sparse-checkout set --skip-checks zbad\\dir/bogus "zdoes*not*exist" "zdoes*exist" "zglob[!a]?" &&
|
2020-01-31 20:16:10 +00:00
|
|
|
cat >expect <<-\EOF &&
|
2020-01-31 20:16:08 +00:00
|
|
|
/*
|
|
|
|
!/*/
|
2020-01-31 20:16:09 +00:00
|
|
|
/zbad\\dir/
|
|
|
|
!/zbad\\dir/*/
|
2020-01-31 20:16:10 +00:00
|
|
|
/zbad\\dir/bogus/
|
2020-01-31 20:16:09 +00:00
|
|
|
/zdoes\*exist/
|
2020-01-31 20:16:10 +00:00
|
|
|
/zdoes\*not\*exist/
|
2020-01-31 20:16:13 +00:00
|
|
|
/zglob\[!a]\?/
|
2020-01-31 20:16:08 +00:00
|
|
|
EOF
|
2020-01-31 20:16:10 +00:00
|
|
|
test_cmp expect escaped/.git/info/sparse-checkout &&
|
2020-01-31 20:16:13 +00:00
|
|
|
check_read_tree_errors escaped "a zbad\\dir zdoes*exist zglob[!a]?" &&
|
2020-01-31 20:16:12 +00:00
|
|
|
git -C escaped ls-tree -d --name-only HEAD >list-expect &&
|
|
|
|
git -C escaped sparse-checkout set --stdin <list-expect &&
|
2020-01-31 20:16:11 +00:00
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/deep/
|
|
|
|
/folder1/
|
|
|
|
/folder2/
|
|
|
|
/zbad\\dir/
|
|
|
|
/zdoes\*exist/
|
2020-01-31 20:16:13 +00:00
|
|
|
/zglob\[!a]\?/
|
2020-01-31 20:16:11 +00:00
|
|
|
EOF
|
|
|
|
test_cmp expect escaped/.git/info/sparse-checkout &&
|
2020-01-31 20:16:13 +00:00
|
|
|
check_files escaped "a deep folder1 folder2 zbad\\dir zdoes*exist" zglob[!a]? &&
|
2020-01-31 20:16:12 +00:00
|
|
|
git -C escaped sparse-checkout list >list-actual &&
|
|
|
|
test_cmp list-expect list-actual
|
2020-01-31 20:16:08 +00:00
|
|
|
'
|
|
|
|
|
2020-02-11 15:02:24 +00:00
|
|
|
test_expect_success MINGW 'cone mode replaces backslashes with slashes' '
|
|
|
|
git -C repo sparse-checkout set deep\\deeper1 &&
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/deep/
|
|
|
|
!/deep/*/
|
|
|
|
/deep/deeper1/
|
|
|
|
EOF
|
|
|
|
test_cmp expect repo/.git/info/sparse-checkout &&
|
|
|
|
check_files repo a deep &&
|
|
|
|
check_files repo/deep a deeper1
|
|
|
|
'
|
|
|
|
|
sparse-checkout: clear tracked sparse dirs
When changing the scope of a sparse-checkout using cone mode, we might
have some tracked directories go out of scope. The current logic removes
the tracked files from within those directories, but leaves the ignored
files within those directories. This is a bit unexpected to users who
have given input to Git saying they don't need those directories
anymore.
This is something that is new to the cone mode pattern type: the user
has explicitly said "I want these directories and _not_ those
directories." The typical sparse-checkout patterns more generally apply
to "I want files with with these patterns" so it is natural to leave
ignored files as they are. This focus on directories in cone mode
provides us an opportunity to change the behavior.
Leaving these ignored files in the sparse directories makes it
impossible to gain performance benefits in the sparse index. When we
track into these directories, we need to know if the files are ignored
or not, which might depend on the _tracked_ .gitignore file(s) within
the sparse directory. This depends on the indexed version of the file,
so the sparse directory must be expanded.
We must take special care to look for untracked, non-ignored files in
these directories before deleting them. We do not want to delete any
meaningful work that the users were doing in those directories and
perhaps forgot to add and commit before switching sparse-checkout
definitions. Since those untracked files might be code files that
generated ignored build output, also do not delete any ignored files
from these directories in that case. The users can recover their state
by resetting their sparse-checkout definition to include that directory
and continue. Alternatively, they can see the warning that is presented
and delete the directory themselves to regain the performance they
expect.
By deleting the sparse directories when changing scope (or running 'git
sparse-checkout reapply') we regain these performance benefits as if the
repository was in a clean state.
Since these ignored files are frequently build output or helper files
from IDEs, the users should not need the files now that the tracked
files are removed. If the tracked files reappear, then they will have
newer timestamps than the build artifacts, so the artifacts will need to
be regenerated anyway.
Use the sparse-index as a data structure in order to find the sparse
directories that can be safely deleted. Re-expand the index to a full
one if it was full before.
Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Reviewed-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-09-08 01:42:33 +00:00
|
|
|
test_expect_success 'cone mode clears ignored subdirectories' '
|
|
|
|
rm repo/.git/info/sparse-checkout &&
|
|
|
|
|
|
|
|
git -C repo sparse-checkout init --cone &&
|
|
|
|
git -C repo sparse-checkout set deep/deeper1 &&
|
|
|
|
|
|
|
|
cat >repo/.gitignore <<-\EOF &&
|
|
|
|
obj/
|
|
|
|
*.o
|
|
|
|
EOF
|
|
|
|
|
|
|
|
git -C repo add .gitignore &&
|
|
|
|
git -C repo commit -m ".gitignore" &&
|
|
|
|
|
|
|
|
mkdir -p repo/obj repo/folder1/obj repo/deep/deeper2/obj &&
|
|
|
|
for file in folder1/obj/a obj/a folder1/file.o folder1.o \
|
|
|
|
deep/deeper2/obj/a deep/deeper2/file.o file.o
|
|
|
|
do
|
|
|
|
echo ignored >repo/$file || return 1
|
|
|
|
done &&
|
|
|
|
|
|
|
|
git -C repo status --porcelain=v2 >out &&
|
|
|
|
test_must_be_empty out &&
|
|
|
|
|
|
|
|
git -C repo sparse-checkout reapply &&
|
|
|
|
test_path_is_missing repo/folder1 &&
|
|
|
|
test_path_is_missing repo/deep/deeper2 &&
|
|
|
|
test_path_is_dir repo/obj &&
|
|
|
|
test_path_is_file repo/file.o &&
|
|
|
|
|
|
|
|
git -C repo status --porcelain=v2 >out &&
|
|
|
|
test_must_be_empty out &&
|
|
|
|
|
|
|
|
git -C repo sparse-checkout set deep/deeper2 &&
|
|
|
|
test_path_is_missing repo/deep/deeper1 &&
|
|
|
|
test_path_is_dir repo/deep/deeper2 &&
|
|
|
|
test_path_is_dir repo/obj &&
|
|
|
|
test_path_is_file repo/file.o &&
|
|
|
|
|
|
|
|
>repo/deep/deeper2/ignored.o &&
|
|
|
|
>repo/deep/deeper2/untracked &&
|
|
|
|
|
|
|
|
# When an untracked file is in the way, all untracked files
|
|
|
|
# (even ignored files) are preserved.
|
|
|
|
git -C repo sparse-checkout set folder1 2>err &&
|
|
|
|
grep "contains untracked files" err &&
|
|
|
|
test_path_is_file repo/deep/deeper2/ignored.o &&
|
|
|
|
test_path_is_file repo/deep/deeper2/untracked &&
|
|
|
|
|
|
|
|
# The rest of the cone matches expectation
|
|
|
|
test_path_is_missing repo/deep/deeper1 &&
|
|
|
|
test_path_is_dir repo/obj &&
|
|
|
|
test_path_is_file repo/file.o &&
|
|
|
|
|
|
|
|
git -C repo status --porcelain=v2 >out &&
|
|
|
|
echo "? deep/deeper2/untracked" >expect &&
|
|
|
|
test_cmp expect out
|
|
|
|
'
|
|
|
|
|
2021-12-16 16:13:40 +00:00
|
|
|
test_expect_success 'malformed cone-mode patterns' '
|
|
|
|
git -C repo sparse-checkout init --cone &&
|
|
|
|
mkdir -p repo/foo/bar &&
|
|
|
|
touch repo/foo/bar/x repo/foo/y &&
|
|
|
|
cat >repo/.git/info/sparse-checkout <<-\EOF &&
|
|
|
|
/*
|
|
|
|
!/*/
|
|
|
|
/foo/
|
|
|
|
!/foo/*/
|
|
|
|
/foo/\*/
|
|
|
|
EOF
|
|
|
|
|
|
|
|
# Listing the patterns will notice the duplicate pattern and
|
|
|
|
# emit a warning. It will list the patterns directly instead
|
|
|
|
# of using the cone-mode translation to a set of directories.
|
|
|
|
git -C repo sparse-checkout list >actual 2>err &&
|
|
|
|
test_cmp repo/.git/info/sparse-checkout actual &&
|
|
|
|
grep "warning: your sparse-checkout file may have issues: pattern .* is repeated" err &&
|
|
|
|
grep "warning: disabling cone pattern matching" err
|
|
|
|
'
|
|
|
|
|
2022-02-19 16:44:43 +00:00
|
|
|
test_expect_success 'set from subdir pays attention to prefix' '
|
|
|
|
git -C repo sparse-checkout disable &&
|
|
|
|
git -C repo/deep sparse-checkout set --cone deeper2 ../folder1 &&
|
|
|
|
|
|
|
|
git -C repo sparse-checkout list >actual &&
|
|
|
|
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
deep/deeper2
|
|
|
|
folder1
|
|
|
|
EOF
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'add from subdir pays attention to prefix' '
|
|
|
|
git -C repo sparse-checkout set --cone deep/deeper2 &&
|
|
|
|
git -C repo/deep sparse-checkout add deeper1/deepest ../folder1 &&
|
|
|
|
|
|
|
|
git -C repo sparse-checkout list >actual &&
|
|
|
|
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
deep/deeper1/deepest
|
|
|
|
deep/deeper2
|
|
|
|
folder1
|
|
|
|
EOF
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'set from subdir in non-cone mode throws an error' '
|
|
|
|
git -C repo sparse-checkout disable &&
|
|
|
|
test_must_fail git -C repo/deep sparse-checkout set --no-cone deeper2 ../folder1 2>error &&
|
|
|
|
|
|
|
|
grep "run from the toplevel directory in non-cone mode" error
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'set from subdir in non-cone mode throws an error' '
|
|
|
|
git -C repo sparse-checkout set --no-cone deep/deeper2 &&
|
|
|
|
test_must_fail git -C repo/deep sparse-checkout add deeper1/deepest ../folder1 2>error &&
|
|
|
|
|
|
|
|
grep "run from the toplevel directory in non-cone mode" error
|
|
|
|
'
|
|
|
|
|
2022-02-19 16:44:44 +00:00
|
|
|
test_expect_success 'by default, cone mode will error out when passed files' '
|
|
|
|
git -C repo sparse-checkout reapply --cone &&
|
|
|
|
test_must_fail git -C repo sparse-checkout add .gitignore 2>error &&
|
|
|
|
|
|
|
|
grep ".gitignore.*is not a directory" error
|
|
|
|
'
|
|
|
|
|
sparse-checkout: be consistent with end of options markers
93851746 (parse-options: decouple "--end-of-options" and "--",
2023-12-06) updated the world order to make callers of parse-options
that set PARSE_OPT_KEEP_UNKNOWN_OPT responsible for deciding what to
do with "--end-of-options" they may see after parse_options() returns.
This made a previous bug in sparse-checkout more visible; namely,
that
git sparse-checkout [add|set] --[no-]cone --end-of-options ...
would simply treat "--end-of-options" as one of the paths to include in
the sparse-checkout. But this was already problematic before; namely,
git sparse-checkout [add|set| --[no-]cone --sikp-checks ...
would not give an error on the mis-typed "--skip-checks" but instead
simply treat "--sikp-checks" as a path or pattern to include in the
sparse-checkout, which is highly unfriendly.
This behavior began when the command was converted to parse-options in
7bffca95ea (sparse-checkout: add '--stdin' option to set subcommand,
2019-11-21). Back then it was just called KEEP_UNKNOWN. Later it was
renamed to KEEP_UNKNOWN_OPT in 99d86d60e5 (parse-options:
PARSE_OPT_KEEP_UNKNOWN only applies to --options, 2022-08-19) to clarify
that it was only about dashed options; we always keep non-option
arguments. Looking at that original patch, both Peff and I think that
the author was simply confused about the mis-named option, and really
just wanted to keep the non-option arguments. We never should have used
the flag all along (and the other cases were cargo-culted within the
file).
Remove the erroneous PARSE_OPT_KEEP_UNKNOWN_OPT flag now to fix this
bug. Note that this does mean that anyone who might have been using
git sparse-checkout [add|set] [--[no-]cone] --foo --bar
to request paths or patterns '--foo' and '--bar' will now have to use
git sparse-checkout [add|set] [--[no-]cone] -- --foo --bar
That makes sparse-checkout more consistent with other git commands,
provides users much friendlier error messages and behavior, and is
consistent with the all-caps warning in git-sparse-checkout.txt that
this command "is experimental...its behavior...will likely change". :-)
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2023-12-26 19:39:22 +00:00
|
|
|
test_expect_success 'error on mistyped command line options' '
|
|
|
|
test_must_fail git -C repo sparse-checkout add --sikp-checks .gitignore 2>error &&
|
|
|
|
|
|
|
|
grep "unknown option.*sikp-checks" error
|
|
|
|
'
|
|
|
|
|
2022-02-19 16:44:44 +00:00
|
|
|
test_expect_success 'by default, non-cone mode will warn on individual files' '
|
|
|
|
git -C repo sparse-checkout reapply --no-cone &&
|
|
|
|
git -C repo sparse-checkout add .gitignore 2>warning &&
|
|
|
|
|
|
|
|
grep "pass a leading slash before paths.*if you want a single file" warning
|
|
|
|
'
|
|
|
|
|
2023-03-27 07:55:02 +00:00
|
|
|
test_expect_success 'setup bare repo' '
|
|
|
|
git clone --bare "file://$(pwd)/repo" bare
|
|
|
|
'
|
|
|
|
test_expect_success 'list fails outside work tree' '
|
|
|
|
test_must_fail git -C bare sparse-checkout list 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "this operation must be run in a work tree" err
|
2023-03-27 07:55:02 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'add fails outside work tree' '
|
|
|
|
test_must_fail git -C bare sparse-checkout add deeper 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "this operation must be run in a work tree" err
|
2023-03-27 07:55:02 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'set fails outside work tree' '
|
|
|
|
test_must_fail git -C bare sparse-checkout set deeper 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "this operation must be run in a work tree" err
|
2023-03-27 07:55:02 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'init fails outside work tree' '
|
|
|
|
test_must_fail git -C bare sparse-checkout init 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "this operation must be run in a work tree" err
|
2023-03-27 07:55:02 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'reapply fails outside work tree' '
|
|
|
|
test_must_fail git -C bare sparse-checkout reapply 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "this operation must be run in a work tree" err
|
2023-03-27 07:55:02 +00:00
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'disable fails outside work tree' '
|
|
|
|
test_must_fail git -C bare sparse-checkout disable 2>err &&
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "this operation must be run in a work tree" err
|
2023-03-27 07:55:02 +00:00
|
|
|
'
|
|
|
|
|
2023-03-27 07:55:03 +00:00
|
|
|
test_expect_success 'setup clean' '
|
|
|
|
git -C repo clean -fdx
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'check-rules cone mode' '
|
|
|
|
cat >rules <<-\EOF &&
|
|
|
|
folder1
|
|
|
|
deep/deeper1/deepest
|
|
|
|
EOF
|
|
|
|
|
|
|
|
git -C bare ls-tree -r --name-only HEAD >all-files &&
|
|
|
|
git -C bare sparse-checkout check-rules --cone \
|
|
|
|
--rules-file ../rules >check-rules-file <all-files &&
|
|
|
|
|
|
|
|
git -C repo sparse-checkout set --cone --stdin <rules&&
|
|
|
|
git -C repo ls-files -t >out &&
|
|
|
|
sed -n "/^S /!s/^. //p" out >ls-files &&
|
|
|
|
|
|
|
|
git -C repo sparse-checkout check-rules >check-rules-default <all-files &&
|
|
|
|
|
2023-10-31 05:23:30 +00:00
|
|
|
test_grep "deep/deeper1/deepest/a" check-rules-file &&
|
|
|
|
test_grep ! "deep/deeper2" check-rules-file &&
|
2023-03-27 07:55:03 +00:00
|
|
|
|
|
|
|
test_cmp check-rules-file ls-files &&
|
|
|
|
test_cmp check-rules-file check-rules-default
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'check-rules non-cone mode' '
|
|
|
|
cat >rules <<-\EOF &&
|
|
|
|
deep/deeper1/deepest/a
|
|
|
|
EOF
|
|
|
|
|
|
|
|
git -C bare ls-tree -r --name-only HEAD >all-files &&
|
|
|
|
git -C bare sparse-checkout check-rules --no-cone --rules-file ../rules\
|
|
|
|
>check-rules-file <all-files &&
|
|
|
|
|
|
|
|
cat rules | git -C repo sparse-checkout set --no-cone --stdin &&
|
|
|
|
git -C repo ls-files -t >out &&
|
|
|
|
sed -n "/^S /!s/^. //p" out >ls-files &&
|
|
|
|
|
|
|
|
git -C repo sparse-checkout check-rules >check-rules-default <all-files &&
|
|
|
|
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
deep/deeper1/deepest/a
|
|
|
|
EOF
|
|
|
|
|
|
|
|
test_cmp expect check-rules-file &&
|
|
|
|
test_cmp check-rules-file ls-files &&
|
|
|
|
test_cmp check-rules-file check-rules-default
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'check-rules cone mode is default' '
|
|
|
|
cat >rules <<-\EOF &&
|
|
|
|
folder1
|
|
|
|
EOF
|
|
|
|
|
|
|
|
cat >all-files <<-\EOF &&
|
|
|
|
toplevel
|
|
|
|
folder2/file
|
|
|
|
folder1/file
|
|
|
|
EOF
|
|
|
|
|
|
|
|
cat >expect <<-\EOF &&
|
|
|
|
toplevel
|
|
|
|
folder1/file
|
|
|
|
EOF
|
|
|
|
|
|
|
|
git -C repo sparse-checkout set --no-cone &&
|
|
|
|
git -C repo sparse-checkout check-rules \
|
|
|
|
--rules-file ../rules >actual <all-files &&
|
|
|
|
|
|
|
|
git -C bare sparse-checkout check-rules \
|
|
|
|
--rules-file ../rules >actual-bare <all-files &&
|
|
|
|
|
|
|
|
test_cmp expect actual &&
|
|
|
|
test_cmp expect actual-bare
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'check-rules quoting' '
|
|
|
|
cat >rules <<-EOF &&
|
|
|
|
"folder\" a"
|
|
|
|
EOF
|
|
|
|
cat >files <<-EOF &&
|
|
|
|
"folder\" a/file"
|
|
|
|
"folder\" b/file"
|
|
|
|
EOF
|
|
|
|
cat >expect <<-EOF &&
|
|
|
|
"folder\" a/file"
|
|
|
|
EOF
|
|
|
|
git sparse-checkout check-rules --cone \
|
|
|
|
--rules-file rules >actual <files &&
|
|
|
|
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
test_expect_success 'check-rules null termination' '
|
|
|
|
cat >rules <<-EOF &&
|
|
|
|
"folder\" a"
|
|
|
|
EOF
|
|
|
|
|
|
|
|
lf_to_nul >files <<-EOF &&
|
|
|
|
folder" a/a
|
|
|
|
folder" a/b
|
|
|
|
folder" b/fileQ
|
|
|
|
EOF
|
|
|
|
|
|
|
|
cat >expect <<-EOF &&
|
|
|
|
folder" a/aQfolder" a/bQ
|
|
|
|
EOF
|
|
|
|
|
|
|
|
git sparse-checkout check-rules --cone -z \
|
|
|
|
--rules-file rules >actual.nul <files &&
|
|
|
|
nul_to_q <actual.nul >actual &&
|
|
|
|
echo >>actual &&
|
|
|
|
|
|
|
|
test_cmp expect actual
|
|
|
|
'
|
|
|
|
|
|
|
|
|
2019-11-21 22:04:33 +00:00
|
|
|
test_done
|