2019-11-21 22:04:33 +00:00
# include "builtin.h"
# include "config.h"
# include "dir.h"
2023-03-21 06:26:03 +00:00
# include "environment.h"
2023-03-21 06:25:54 +00:00
# include "gettext.h"
2023-04-11 07:41:53 +00:00
# include "object-file.h"
2023-04-11 07:41:49 +00:00
# include "object-name.h"
2019-11-21 22:04:33 +00:00
# include "parse-options.h"
# include "pathspec.h"
# include "repository.h"
# include "strbuf.h"
2019-11-21 22:04:42 +00:00
# include "string-list.h"
2019-11-21 22:04:46 +00:00
# include "lockfile.h"
# include "unpack-trees.h"
2020-01-31 20:16:10 +00:00
# include "quote.h"
2023-03-21 06:26:05 +00:00
# include "setup.h"
2021-03-30 13:11:00 +00:00
# include "sparse-index.h"
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
# include "worktree.h"
2019-11-21 22:04:33 +00:00
2019-11-21 22:04:50 +00:00
static const char * empty_base = " " ;
2019-11-21 22:04:33 +00:00
static char const * const builtin_sparse_checkout_usage [ ] = {
2023-03-27 07:55:03 +00:00
N_ ( " git sparse-checkout (init | list | set | add | reapply | disable | check-rules) [<options>] " ) ,
2019-11-21 22:04:33 +00:00
NULL
} ;
static void write_patterns_to_file ( FILE * fp , struct pattern_list * pl )
{
int i ;
for ( i = 0 ; i < pl - > nr ; i + + ) {
struct path_pattern * p = pl - > patterns [ i ] ;
if ( p - > flags & PATTERN_FLAG_NEGATIVE )
fprintf ( fp , " ! " ) ;
fprintf ( fp , " %s " , p - > pattern ) ;
if ( p - > flags & PATTERN_FLAG_MUSTBEDIR )
fprintf ( fp , " / " ) ;
fprintf ( fp , " \n " ) ;
}
}
2020-09-30 12:30:10 +00:00
static char const * const builtin_sparse_checkout_list_usage [ ] = {
2022-01-31 22:07:48 +00:00
" git sparse-checkout list " ,
2020-09-30 12:30:10 +00:00
NULL
} ;
2022-08-19 16:04:09 +00:00
static int sparse_checkout_list ( int argc , const char * * argv , const char * prefix )
2019-11-21 22:04:33 +00:00
{
2020-09-30 12:30:10 +00:00
static struct option builtin_sparse_checkout_list_options [ ] = {
OPT_END ( ) ,
} ;
2019-11-21 22:04:33 +00:00
struct pattern_list pl ;
char * sparse_filename ;
int res ;
2023-03-27 07:55:02 +00:00
setup_work_tree ( ) ;
2021-12-14 04:09:05 +00:00
if ( ! core_apply_sparse_checkout )
die ( _ ( " this worktree is not sparse " ) ) ;
pass subcommand "prefix" arguments to parse_options()
Recent commits such as bf0a6b65fc (builtin/multi-pack-index.c: let
parse-options parse subcommands, 2022-08-19) converted a few functions
to match our usual argc/argv/prefix conventions, but the prefix argument
remains unused.
However, there is a good use for it: they should pass it to their own
parse_options() functions, where it may be used to adjust the value of
any filename options. In all but one of these functions, there's no
behavior change, since they don't use OPT_FILENAME. But this is an
actual fix for one option, which you can see by modifying the test suite
like so:
diff --git a/t/t5326-multi-pack-bitmaps.sh b/t/t5326-multi-pack-bitmaps.sh
index 4fe57414c1..d0974d4371 100755
--- a/t/t5326-multi-pack-bitmaps.sh
+++ b/t/t5326-multi-pack-bitmaps.sh
@@ -186,7 +186,11 @@ test_expect_success 'writing a bitmap with --refs-snapshot' '
# Then again, but with a refs snapshot which only sees
# refs/tags/one.
- git multi-pack-index write --bitmap --refs-snapshot=snapshot &&
+ (
+ mkdir subdir &&
+ cd subdir &&
+ git multi-pack-index write --bitmap --refs-snapshot=../snapshot
+ ) &&
test_path_is_file $midx &&
test_path_is_file $midx-$(midx_checksum $objdir).bitmap &&
I'd emphasize that this wasn't broken by bf0a6b65fc; it has been broken
all along, because the sub-function never got to see the prefix. It is
that commit which is actually enabling us to fix it (and which also
brought attention to the problem because it triggers -Wunused-parameter!)
The other functions changed here don't use OPT_FILENAME at all. In their
cases this isn't fixing anything visible, but it's following the usual
pattern and future-proofing them against somebody adding new options and
being surprised.
I didn't include a test for the one visible case above. We don't
generally test routine parse-options behavior for individual options.
The challenge here was finding the problem, and now that this has been
done, it's not likely to regress. Likewise, we could apply the patch
above to cover it "for free" but it makes reading the rest of the test
unnecessarily complicated.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-08-25 10:47:00 +00:00
argc = parse_options ( argc , argv , prefix ,
2020-09-30 12:30:10 +00:00
builtin_sparse_checkout_list_options ,
builtin_sparse_checkout_list_usage , 0 ) ;
2019-11-21 22:04:33 +00:00
memset ( & pl , 0 , sizeof ( pl ) ) ;
2019-12-30 15:33:12 +00:00
pl . use_cone_patterns = core_sparse_checkout_cone ;
2019-11-21 22:04:33 +00:00
sparse_filename = get_sparse_checkout_filename ( ) ;
2021-02-16 14:44:28 +00:00
res = add_patterns_from_file_to_list ( sparse_filename , " " , 0 , & pl , NULL , 0 ) ;
2019-11-21 22:04:33 +00:00
free ( sparse_filename ) ;
if ( res < 0 ) {
warning ( _ ( " this worktree is not sparse (sparse-checkout file may not exist) " ) ) ;
return 0 ;
}
2019-12-30 15:33:12 +00:00
if ( pl . use_cone_patterns ) {
int i ;
struct pattern_entry * pe ;
struct hashmap_iter iter ;
struct string_list sl = STRING_LIST_INIT_DUP ;
hashmap_for_each_entry ( & pl . recursive_hashmap , & iter , pe , ent ) {
/* pe->pattern starts with "/", skip it */
string_list_insert ( & sl , pe - > pattern + 1 ) ;
}
string_list_sort ( & sl ) ;
2020-01-31 20:16:12 +00:00
for ( i = 0 ; i < sl . nr ; i + + ) {
quote_c_style ( sl . items [ i ] . string , NULL , stdout , 0 ) ;
printf ( " \n " ) ;
}
2019-12-30 15:33:12 +00:00
return 0 ;
}
2019-11-21 22:04:33 +00:00
write_patterns_to_file ( stdout , & pl ) ;
clear_pattern_list ( & pl ) ;
return 0 ;
}
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
static void clean_tracked_sparse_directories ( struct repository * r )
{
int i , was_full = 0 ;
struct strbuf path = STRBUF_INIT ;
size_t pathlen ;
struct string_list_item * item ;
struct string_list sparse_dirs = STRING_LIST_INIT_DUP ;
/*
* If we are not using cone mode patterns , then we cannot
* delete directories outside of the sparse cone .
*/
if ( ! r | | ! r - > index | | ! r - > worktree )
return ;
if ( init_sparse_checkout_patterns ( r - > index ) | |
! r - > index - > sparse_checkout_patterns - > use_cone_patterns )
return ;
/*
* Use the sparse index as a data structure to assist finding
* directories that are safe to delete . This conversion to a
* sparse index will not delete directories that contain
* conflicted entries or submodules .
*/
2022-05-23 13:48:40 +00:00
if ( r - > index - > sparse_index = = INDEX_EXPANDED ) {
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
/*
* If something , such as a merge conflict or other concern ,
* prevents us from converting to a sparse index , then do
* not try deleting files .
*/
if ( convert_to_sparse ( r - > index , SPARSE_INDEX_MEMORY_ONLY ) )
return ;
was_full = 1 ;
}
strbuf_addstr ( & path , r - > worktree ) ;
strbuf_complete ( & path , ' / ' ) ;
pathlen = path . len ;
/*
* Collect directories that have gone out of scope but also
* exist on disk , so there is some work to be done . We need to
* store the entries in a list before exploring , since that might
* expand the sparse - index again .
*/
for ( i = 0 ; i < r - > index - > cache_nr ; i + + ) {
struct cache_entry * ce = r - > index - > cache [ i ] ;
if ( S_ISSPARSEDIR ( ce - > ce_mode ) & &
repo_file_exists ( r , ce - > name ) )
string_list_append ( & sparse_dirs , ce - > name ) ;
}
for_each_string_list_item ( item , & sparse_dirs ) {
struct dir_struct dir = DIR_INIT ;
struct pathspec p = { 0 } ;
struct strvec s = STRVEC_INIT ;
strbuf_setlen ( & path , pathlen ) ;
strbuf_addstr ( & path , item - > string ) ;
dir . flags | = DIR_SHOW_IGNORED_TOO ;
setup_standard_excludes ( & dir ) ;
strvec_push ( & s , path . buf ) ;
parse_pathspec ( & p , PATHSPEC_GLOB , 0 , NULL , s . v ) ;
fill_directory ( & dir , r - > index , & p ) ;
if ( dir . nr ) {
warning ( _ ( " directory '%s' contains untracked files, "
" but is not in the sparse-checkout cone " ) ,
item - > string ) ;
} else if ( remove_dir_recursively ( & path , 0 ) ) {
/*
* Removal is " best effort " . If something blocks
* the deletion , then continue with a warning .
*/
warning ( _ ( " failed to remove directory '%s' " ) ,
item - > string ) ;
}
2022-01-28 01:58:18 +00:00
strvec_clear ( & s ) ;
clear_pathspec ( & p ) ;
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
dir_clear ( & dir ) ;
}
string_list_clear ( & sparse_dirs , 0 ) ;
strbuf_release ( & path ) ;
if ( was_full )
ensure_full_index ( r - > index ) ;
}
2019-11-21 22:04:46 +00:00
static int update_working_directory ( struct pattern_list * pl )
2019-11-21 22:04:34 +00:00
{
2020-03-27 00:48:53 +00:00
enum update_sparsity_result result ;
2019-11-21 22:04:46 +00:00
struct unpack_trees_options o ;
struct lock_file lock_file = LOCK_INIT ;
struct repository * r = the_repository ;
2019-11-21 22:04:34 +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
/* If no branch has been checked out, there are no updates to make. */
if ( is_index_unborn ( r - > index ) )
return UPDATE_SPARSITY_SUCCESS ;
2021-03-30 13:10:53 +00:00
r - > index - > sparse_checkout_patterns = pl ;
2019-11-21 22:04:46 +00:00
memset ( & o , 0 , sizeof ( o ) ) ;
o . verbose_update = isatty ( 2 ) ;
o . update = 1 ;
o . head_idx = - 1 ;
o . src_index = r - > index ;
o . dst_index = r - > index ;
o . skip_sparse_checkout = 0 ;
setup_work_tree ( ) ;
repo_hold_locked_index ( r , & lock_file , LOCK_DIE_ON_ERROR ) ;
2020-03-27 00:48:54 +00:00
setup_unpack_trees_porcelain ( & o , " sparse-checkout " ) ;
2023-02-27 15:28:14 +00:00
result = update_sparsity ( & o , pl ) ;
2020-03-27 00:48:54 +00:00
clear_unpack_trees_porcelain ( & o ) ;
2019-11-21 22:04:46 +00:00
2020-03-27 00:48:53 +00:00
if ( result = = UPDATE_SPARSITY_WARNINGS )
/*
* We don ' t do any special handling of warnings from untracked
* files in the way or dirty entries that can ' t be removed .
*/
result = UPDATE_SPARSITY_SUCCESS ;
if ( result = = UPDATE_SPARSITY_SUCCESS )
2019-11-21 22:04:46 +00:00
write_locked_index ( r - > index , & lock_file , COMMIT_LOCK ) ;
2020-03-27 00:48:53 +00:00
else
2019-11-21 22:04:46 +00:00
rollback_lock_file ( & lock_file ) ;
2019-11-21 22:04:34 +00:00
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
clean_tracked_sparse_directories ( r ) ;
2021-03-30 13:10:53 +00:00
r - > index - > sparse_checkout_patterns = NULL ;
2019-11-21 22:04:34 +00:00
return result ;
}
2020-01-31 20:16:10 +00:00
static char * escaped_pattern ( char * pattern )
{
char * p = pattern ;
struct strbuf final = STRBUF_INIT ;
while ( * p ) {
2020-01-31 20:16:13 +00:00
if ( is_glob_special ( * p ) )
2020-01-31 20:16:10 +00:00
strbuf_addch ( & final , ' \\ ' ) ;
strbuf_addch ( & final , * p ) ;
p + + ;
}
return strbuf_detach ( & final , NULL ) ;
}
2019-11-21 22:04:42 +00:00
static void write_cone_to_file ( FILE * fp , struct pattern_list * pl )
{
int i ;
struct pattern_entry * pe ;
struct hashmap_iter iter ;
struct string_list sl = STRING_LIST_INIT_DUP ;
2019-11-21 22:04:45 +00:00
struct strbuf parent_pattern = STRBUF_INIT ;
2019-11-21 22:04:42 +00:00
2019-11-21 22:04:45 +00:00
hashmap_for_each_entry ( & pl - > parent_hashmap , & iter , pe , ent ) {
if ( hashmap_get_entry ( & pl - > recursive_hashmap , pe , ent , NULL ) )
continue ;
if ( ! hashmap_contains_parent ( & pl - > recursive_hashmap ,
pe - > pattern ,
& parent_pattern ) )
string_list_insert ( & sl , pe - > pattern ) ;
}
2019-11-21 22:04:42 +00:00
string_list_sort ( & sl ) ;
string_list_remove_duplicates ( & sl , 0 ) ;
fprintf ( fp , " /* \n !/*/ \n " ) ;
for ( i = 0 ; i < sl . nr ; i + + ) {
2020-01-31 20:16:10 +00:00
char * pattern = escaped_pattern ( sl . items [ i ] . string ) ;
2019-11-21 22:04:42 +00:00
if ( strlen ( pattern ) )
fprintf ( fp , " %s/ \n !%s/*/ \n " , pattern , pattern ) ;
2020-01-31 20:16:10 +00:00
free ( pattern ) ;
2019-11-21 22:04:42 +00:00
}
string_list_clear ( & sl , 0 ) ;
2019-11-21 22:04:45 +00:00
hashmap_for_each_entry ( & pl - > recursive_hashmap , & iter , pe , ent ) {
if ( ! hashmap_contains_parent ( & pl - > recursive_hashmap ,
pe - > pattern ,
& parent_pattern ) )
string_list_insert ( & sl , pe - > pattern ) ;
}
strbuf_release ( & parent_pattern ) ;
2019-11-21 22:04:42 +00:00
string_list_sort ( & sl ) ;
string_list_remove_duplicates ( & sl , 0 ) ;
for ( i = 0 ; i < sl . nr ; i + + ) {
2020-01-31 20:16:10 +00:00
char * pattern = escaped_pattern ( sl . items [ i ] . string ) ;
2019-11-21 22:04:42 +00:00
fprintf ( fp , " %s/ \n " , pattern ) ;
2020-01-31 20:16:10 +00:00
free ( pattern ) ;
2019-11-21 22:04:42 +00:00
}
}
static int write_patterns_and_update ( struct pattern_list * pl )
{
char * sparse_filename ;
FILE * fp ;
2019-11-21 22:04:48 +00:00
int fd ;
struct lock_file lk = LOCK_INIT ;
2019-11-21 22:04:46 +00:00
int result ;
2019-11-21 22:04:48 +00:00
sparse_filename = get_sparse_checkout_filename ( ) ;
2020-01-24 21:19:33 +00:00
if ( safe_create_leading_directories ( sparse_filename ) )
die ( _ ( " failed to create directory for sparse-checkout file " ) ) ;
2019-11-21 22:04:48 +00:00
fd = hold_lock_file_for_update ( & lk , sparse_filename ,
LOCK_DIE_ON_ERROR ) ;
2022-03-04 18:32:14 +00:00
free ( sparse_filename ) ;
2019-11-21 22:04:46 +00:00
2019-11-21 22:04:48 +00:00
result = update_working_directory ( pl ) ;
2019-11-21 22:04:46 +00:00
if ( result ) {
2019-11-21 22:04:48 +00:00
rollback_lock_file ( & lk ) ;
2019-11-21 22:04:46 +00:00
clear_pattern_list ( pl ) ;
update_working_directory ( NULL ) ;
return result ;
}
2019-11-21 22:04:42 +00:00
2019-11-21 22:04:48 +00:00
fp = xfdopen ( fd , " w " ) ;
2019-11-21 22:04:42 +00:00
if ( core_sparse_checkout_cone )
write_cone_to_file ( fp , pl ) ;
else
write_patterns_to_file ( fp , pl ) ;
2019-11-21 22:04:48 +00:00
fflush ( fp ) ;
commit_lock_file ( & lk ) ;
2019-11-21 22:04:46 +00:00
clear_pattern_list ( pl ) ;
2019-11-21 22:04:42 +00:00
2019-11-21 22:04:46 +00:00
return 0 ;
2019-11-21 22:04:42 +00:00
}
2019-11-21 22:04:34 +00:00
enum sparse_checkout_mode {
MODE_NO_PATTERNS = 0 ,
MODE_ALL_PATTERNS = 1 ,
2019-11-21 22:04:42 +00:00
MODE_CONE_PATTERNS = 2 ,
2019-11-21 22:04:34 +00:00
} ;
static int set_config ( enum sparse_checkout_mode mode )
{
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
/* Update to use worktree config, if not already. */
if ( init_worktree_config ( the_repository ) ) {
error ( _ ( " failed to initialize worktree config " ) ) ;
2019-11-21 22:04:34 +00:00
return 1 ;
}
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
if ( repo_config_set_worktree_gently ( the_repository ,
" core.sparseCheckout " ,
mode ? " true " : " false " ) | |
repo_config_set_worktree_gently ( the_repository ,
" core.sparseCheckoutCone " ,
mode = = MODE_CONE_PATTERNS ?
" true " : " false " ) )
return 1 ;
2019-11-21 22:04:42 +00:00
2021-03-30 13:11:01 +00:00
if ( mode = = MODE_NO_PATTERNS )
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
return set_sparse_index_config ( the_repository , 0 ) ;
2021-03-30 13:11:01 +00:00
2019-11-21 22:04:34 +00:00
return 0 ;
}
2023-03-27 07:55:03 +00:00
static enum sparse_checkout_mode update_cone_mode ( int * cone_mode ) {
2021-12-14 04:09:07 +00:00
/* If not specified, use previous definition of cone mode */
if ( * cone_mode = = - 1 & & core_apply_sparse_checkout )
* cone_mode = core_sparse_checkout_cone ;
/* Set cone/non-cone mode appropriately */
core_apply_sparse_checkout = 1 ;
2022-04-22 02:32:19 +00:00
if ( * cone_mode = = 1 | | * cone_mode = = - 1 ) {
2021-12-14 04:09:07 +00:00
core_sparse_checkout_cone = 1 ;
2023-03-27 07:55:03 +00:00
return MODE_CONE_PATTERNS ;
2021-12-14 04:09:07 +00:00
}
2023-03-27 07:55:03 +00:00
core_sparse_checkout_cone = 0 ;
return MODE_ALL_PATTERNS ;
}
static int update_modes ( int * cone_mode , int * sparse_index )
{
int mode , record_mode ;
/* Determine if we need to record the mode; ensure sparse checkout on */
record_mode = ( * cone_mode ! = - 1 ) | | ! core_apply_sparse_checkout ;
mode = update_cone_mode ( cone_mode ) ;
2021-12-14 04:09:07 +00:00
if ( record_mode & & set_config ( mode ) )
return 1 ;
/* Set sparse-index/non-sparse-index mode if specified */
if ( * sparse_index > = 0 ) {
if ( set_sparse_index_config ( the_repository , * sparse_index ) < 0 )
die ( _ ( " failed to modify sparse-index config " ) ) ;
/* force an index rewrite */
repo_read_index ( the_repository ) ;
the_repository - > index - > updated_workdir = 1 ;
2022-05-23 13:48:42 +00:00
if ( ! * sparse_index )
ensure_full_index ( the_repository - > index ) ;
2021-12-14 04:09:07 +00:00
}
return 0 ;
}
2019-11-21 22:04:42 +00:00
static char const * const builtin_sparse_checkout_init_usage [ ] = {
2022-01-31 22:07:48 +00:00
" git sparse-checkout init [--cone] [--[no-]sparse-index] " ,
2019-11-21 22:04:42 +00:00
NULL
} ;
static struct sparse_checkout_init_opts {
int cone_mode ;
2021-03-30 13:11:00 +00:00
int sparse_index ;
2019-11-21 22:04:42 +00:00
} init_opts ;
2022-08-19 16:04:09 +00:00
static int sparse_checkout_init ( int argc , const char * * argv , const char * prefix )
2019-11-21 22:04:34 +00:00
{
struct pattern_list pl ;
char * sparse_filename ;
int res ;
2019-11-21 22:04:35 +00:00
struct object_id oid ;
2019-11-21 22:04:50 +00:00
struct strbuf pattern = STRBUF_INIT ;
2019-11-21 22:04:34 +00:00
2019-11-21 22:04:42 +00:00
static struct option builtin_sparse_checkout_init_options [ ] = {
OPT_BOOL ( 0 , " cone " , & init_opts . cone_mode ,
N_ ( " initialize the sparse-checkout in cone mode " ) ) ,
2021-03-30 13:11:00 +00:00
OPT_BOOL ( 0 , " sparse-index " , & init_opts . sparse_index ,
N_ ( " toggle the use of a sparse index " ) ) ,
2019-11-21 22:04:42 +00:00
OPT_END ( ) ,
} ;
2023-03-27 07:55:02 +00:00
setup_work_tree ( ) ;
2019-11-21 22:04:51 +00:00
repo_read_index ( the_repository ) ;
2021-12-14 04:09:07 +00:00
init_opts . cone_mode = - 1 ;
2021-03-30 13:11:00 +00:00
init_opts . sparse_index = - 1 ;
pass subcommand "prefix" arguments to parse_options()
Recent commits such as bf0a6b65fc (builtin/multi-pack-index.c: let
parse-options parse subcommands, 2022-08-19) converted a few functions
to match our usual argc/argv/prefix conventions, but the prefix argument
remains unused.
However, there is a good use for it: they should pass it to their own
parse_options() functions, where it may be used to adjust the value of
any filename options. In all but one of these functions, there's no
behavior change, since they don't use OPT_FILENAME. But this is an
actual fix for one option, which you can see by modifying the test suite
like so:
diff --git a/t/t5326-multi-pack-bitmaps.sh b/t/t5326-multi-pack-bitmaps.sh
index 4fe57414c1..d0974d4371 100755
--- a/t/t5326-multi-pack-bitmaps.sh
+++ b/t/t5326-multi-pack-bitmaps.sh
@@ -186,7 +186,11 @@ test_expect_success 'writing a bitmap with --refs-snapshot' '
# Then again, but with a refs snapshot which only sees
# refs/tags/one.
- git multi-pack-index write --bitmap --refs-snapshot=snapshot &&
+ (
+ mkdir subdir &&
+ cd subdir &&
+ git multi-pack-index write --bitmap --refs-snapshot=../snapshot
+ ) &&
test_path_is_file $midx &&
test_path_is_file $midx-$(midx_checksum $objdir).bitmap &&
I'd emphasize that this wasn't broken by bf0a6b65fc; it has been broken
all along, because the sub-function never got to see the prefix. It is
that commit which is actually enabling us to fix it (and which also
brought attention to the problem because it triggers -Wunused-parameter!)
The other functions changed here don't use OPT_FILENAME at all. In their
cases this isn't fixing anything visible, but it's following the usual
pattern and future-proofing them against somebody adding new options and
being surprised.
I didn't include a test for the one visible case above. We don't
generally test routine parse-options behavior for individual options.
The challenge here was finding the problem, and now that this has been
done, it's not likely to regress. Likewise, we could apply the patch
above to cover it "for free" but it makes reading the rest of the test
unnecessarily complicated.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-08-25 10:47:00 +00:00
argc = parse_options ( argc , argv , prefix ,
2019-11-21 22:04:42 +00:00
builtin_sparse_checkout_init_options ,
builtin_sparse_checkout_init_usage , 0 ) ;
2021-12-14 04:09:07 +00:00
if ( update_modes ( & init_opts . cone_mode , & init_opts . sparse_index ) )
2019-11-21 22:04:34 +00:00
return 1 ;
memset ( & pl , 0 , sizeof ( pl ) ) ;
sparse_filename = get_sparse_checkout_filename ( ) ;
2021-02-16 14:44:28 +00:00
res = add_patterns_from_file_to_list ( sparse_filename , " " , 0 , & pl , NULL , 0 ) ;
2019-11-21 22:04:34 +00:00
/* If we already have a sparse-checkout file, use it. */
if ( res > = 0 ) {
free ( sparse_filename ) ;
2019-11-21 22:04:50 +00:00
return update_working_directory ( NULL ) ;
2019-11-21 22:04:34 +00:00
}
2023-03-28 13:58:46 +00:00
if ( repo_get_oid ( the_repository , " HEAD " , & oid ) ) {
2019-11-21 22:04:50 +00:00
FILE * fp ;
2019-11-21 22:04:34 +00:00
2019-11-21 22:04:50 +00:00
/* assume we are in a fresh repo, but update the sparse-checkout file */
2022-01-21 17:44:41 +00:00
if ( safe_create_leading_directories ( sparse_filename ) )
die ( _ ( " unable to create leading directories of %s " ) ,
sparse_filename ) ;
2019-11-21 22:04:50 +00:00
fp = xfopen ( sparse_filename , " w " ) ;
if ( ! fp )
die ( _ ( " failed to open '%s' " ) , sparse_filename ) ;
2019-11-21 22:04:34 +00:00
2019-11-21 22:04:50 +00:00
free ( sparse_filename ) ;
fprintf ( fp , " /* \n !/*/ \n " ) ;
fclose ( fp ) ;
2019-11-21 22:04:35 +00:00
return 0 ;
}
2019-11-21 22:04:50 +00:00
strbuf_addstr ( & pattern , " /* " ) ;
add_pattern ( strbuf_detach ( & pattern , NULL ) , empty_base , 0 , & pl , 0 ) ;
strbuf_addstr ( & pattern , " !/*/ " ) ;
add_pattern ( strbuf_detach ( & pattern , NULL ) , empty_base , 0 , & pl , 0 ) ;
2021-03-30 13:11:01 +00:00
pl . use_cone_patterns = init_opts . cone_mode ;
2019-11-21 22:04:50 +00:00
return write_patterns_and_update ( & pl ) ;
2019-11-21 22:04:34 +00:00
}
2019-11-21 22:04:42 +00:00
static void insert_recursive_pattern ( struct pattern_list * pl , struct strbuf * path )
2019-11-21 22:04:36 +00:00
{
2019-11-21 22:04:42 +00:00
struct pattern_entry * e = xmalloc ( sizeof ( * e ) ) ;
e - > patternlen = path - > len ;
e - > pattern = strbuf_detach ( path , NULL ) ;
2021-07-30 19:06:58 +00:00
hashmap_entry_init ( & e - > ent , fspathhash ( e - > pattern ) ) ;
2019-11-21 22:04:36 +00:00
2019-11-21 22:04:42 +00:00
hashmap_add ( & pl - > recursive_hashmap , & e - > ent ) ;
2019-11-21 22:04:36 +00:00
2019-11-21 22:04:42 +00:00
while ( e - > patternlen ) {
char * slash = strrchr ( e - > pattern , ' / ' ) ;
char * oldpattern = e - > pattern ;
size_t newlen ;
2021-12-16 16:13:41 +00:00
if ( ! slash | | slash = = e - > pattern )
2019-11-21 22:04:42 +00:00
break ;
newlen = slash - e - > pattern ;
e = xmalloc ( sizeof ( struct pattern_entry ) ) ;
e - > patternlen = newlen ;
e - > pattern = xstrndup ( oldpattern , newlen ) ;
2021-07-30 19:06:58 +00:00
hashmap_entry_init ( & e - > ent , fspathhash ( e - > pattern ) ) ;
2019-11-21 22:04:42 +00:00
if ( ! hashmap_get_entry ( & pl - > parent_hashmap , e , ent , NULL ) )
hashmap_add ( & pl - > parent_hashmap , & e - > ent ) ;
}
}
static void strbuf_to_cone_pattern ( struct strbuf * line , struct pattern_list * pl )
{
strbuf_trim ( line ) ;
strbuf_trim_trailing_dir_sep ( line ) ;
2020-02-11 15:02:24 +00:00
if ( strbuf_normalize_path ( line ) )
die ( _ ( " could not normalize path %s " ) , line - > buf ) ;
2019-11-21 22:04:42 +00:00
if ( ! line - > len )
return ;
if ( line - > buf [ 0 ] ! = ' / ' )
2020-02-09 13:44:23 +00:00
strbuf_insertstr ( line , 0 , " / " ) ;
2019-11-21 22:04:42 +00:00
insert_recursive_pattern ( pl , line ) ;
2019-11-21 22:04:36 +00:00
}
2020-02-11 15:02:21 +00:00
static void add_patterns_from_input ( struct pattern_list * pl ,
2021-12-14 04:09:03 +00:00
int argc , const char * * argv ,
2023-03-27 07:55:03 +00:00
FILE * file )
2019-11-21 22:04:36 +00:00
{
int i ;
2019-11-21 22:04:42 +00:00
if ( core_sparse_checkout_cone ) {
2019-11-21 22:04:37 +00:00
struct strbuf line = STRBUF_INIT ;
2020-02-11 15:02:21 +00:00
hashmap_init ( & pl - > recursive_hashmap , pl_hashmap_cmp , NULL , 0 ) ;
hashmap_init ( & pl - > parent_hashmap , pl_hashmap_cmp , NULL , 0 ) ;
pl - > use_cone_patterns = 1 ;
2019-11-21 22:04:42 +00:00
2023-03-27 07:55:03 +00:00
if ( file ) {
2020-01-31 20:16:11 +00:00
struct strbuf unquoted = STRBUF_INIT ;
2023-03-27 07:55:03 +00:00
while ( ! strbuf_getline ( & line , file ) ) {
2020-01-31 20:16:11 +00:00
if ( line . buf [ 0 ] = = ' " ' ) {
strbuf_reset ( & unquoted ) ;
if ( unquote_c_style ( & unquoted , line . buf , NULL ) )
die ( _ ( " unable to unquote C-style string '%s' " ) ,
line . buf ) ;
strbuf_swap ( & unquoted , & line ) ;
}
2020-02-11 15:02:21 +00:00
strbuf_to_cone_pattern ( & line , pl ) ;
2020-01-31 20:16:11 +00:00
}
strbuf_release ( & unquoted ) ;
2019-11-21 22:04:42 +00:00
} else {
for ( i = 0 ; i < argc ; i + + ) {
strbuf_setlen ( & line , 0 ) ;
strbuf_addstr ( & line , argv [ i ] ) ;
2020-02-11 15:02:21 +00:00
strbuf_to_cone_pattern ( & line , pl ) ;
2019-11-21 22:04:42 +00:00
}
2019-11-21 22:04:37 +00:00
}
} else {
2023-03-27 07:55:03 +00:00
if ( file ) {
2019-11-21 22:04:42 +00:00
struct strbuf line = STRBUF_INIT ;
2023-03-27 07:55:03 +00:00
while ( ! strbuf_getline ( & line , file ) ) {
2019-11-21 22:04:42 +00:00
size_t len ;
char * buf = strbuf_detach ( & line , & len ) ;
2020-02-11 15:02:21 +00:00
add_pattern ( buf , empty_base , 0 , pl , 0 ) ;
2019-11-21 22:04:42 +00:00
}
} else {
for ( i = 0 ; i < argc ; i + + )
2020-02-11 15:02:21 +00:00
add_pattern ( argv [ i ] , empty_base , 0 , pl , 0 ) ;
2019-11-21 22:04:42 +00:00
}
2019-11-21 22:04:37 +00:00
}
2020-02-11 15:02:21 +00:00
}
2020-02-11 15:02:22 +00:00
enum modify_type {
REPLACE ,
2020-02-11 15:02:23 +00:00
ADD ,
2020-02-11 15:02:22 +00:00
} ;
2020-02-11 15:02:23 +00:00
static void add_patterns_cone_mode ( int argc , const char * * argv ,
2021-12-14 04:09:03 +00:00
struct pattern_list * pl ,
int use_stdin )
2020-02-11 15:02:23 +00:00
{
struct strbuf buffer = STRBUF_INIT ;
struct pattern_entry * pe ;
struct hashmap_iter iter ;
struct pattern_list existing ;
char * sparse_filename = get_sparse_checkout_filename ( ) ;
2023-03-27 07:55:03 +00:00
add_patterns_from_input ( pl , argc , argv ,
use_stdin ? stdin : NULL ) ;
2020-02-11 15:02:23 +00:00
memset ( & existing , 0 , sizeof ( existing ) ) ;
existing . use_cone_patterns = core_sparse_checkout_cone ;
if ( add_patterns_from_file_to_list ( sparse_filename , " " , 0 ,
2021-02-16 14:44:28 +00:00
& existing , NULL , 0 ) )
2020-02-11 15:02:23 +00:00
die ( _ ( " unable to load existing sparse-checkout patterns " ) ) ;
free ( sparse_filename ) ;
2021-12-16 16:13:42 +00:00
if ( ! existing . use_cone_patterns )
die ( _ ( " existing sparse-checkout patterns do not use cone mode " ) ) ;
2020-02-11 15:02:23 +00:00
hashmap_for_each_entry ( & existing . recursive_hashmap , & iter , pe , ent ) {
if ( ! hashmap_contains_parent ( & pl - > recursive_hashmap ,
pe - > pattern , & buffer ) | |
! hashmap_contains_parent ( & pl - > parent_hashmap ,
pe - > pattern , & buffer ) ) {
strbuf_reset ( & buffer ) ;
strbuf_addstr ( & buffer , pe - > pattern ) ;
insert_recursive_pattern ( pl , & buffer ) ;
}
}
clear_pattern_list ( & existing ) ;
strbuf_release ( & buffer ) ;
}
static void add_patterns_literal ( int argc , const char * * argv ,
2021-12-14 04:09:03 +00:00
struct pattern_list * pl ,
int use_stdin )
2020-02-11 15:02:23 +00:00
{
char * sparse_filename = get_sparse_checkout_filename ( ) ;
if ( add_patterns_from_file_to_list ( sparse_filename , " " , 0 ,
2021-02-16 14:44:28 +00:00
pl , NULL , 0 ) )
2020-02-11 15:02:23 +00:00
die ( _ ( " unable to load existing sparse-checkout patterns " ) ) ;
free ( sparse_filename ) ;
2023-03-27 07:55:03 +00:00
add_patterns_from_input ( pl , argc , argv , use_stdin ? stdin : NULL ) ;
2020-02-11 15:02:23 +00:00
}
2021-12-14 04:09:03 +00:00
static int modify_pattern_list ( int argc , const char * * argv , int use_stdin ,
enum modify_type m )
2020-02-11 15:02:21 +00:00
{
int result ;
int changed_config = 0 ;
2021-03-30 13:10:53 +00:00
struct pattern_list * pl = xcalloc ( 1 , sizeof ( * pl ) ) ;
2020-02-11 15:02:21 +00:00
2020-02-11 15:02:23 +00:00
switch ( m ) {
case ADD :
if ( core_sparse_checkout_cone )
2021-12-14 04:09:03 +00:00
add_patterns_cone_mode ( argc , argv , pl , use_stdin ) ;
2020-02-11 15:02:23 +00:00
else
2021-12-14 04:09:03 +00:00
add_patterns_literal ( argc , argv , pl , use_stdin ) ;
2020-02-11 15:02:23 +00:00
break ;
case REPLACE :
2023-03-27 07:55:03 +00:00
add_patterns_from_input ( pl , argc , argv ,
use_stdin ? stdin : NULL ) ;
2020-02-11 15:02:23 +00:00
break ;
}
2019-11-21 22:04:36 +00:00
if ( ! core_apply_sparse_checkout ) {
set_config ( MODE_ALL_PATTERNS ) ;
core_apply_sparse_checkout = 1 ;
changed_config = 1 ;
}
2021-03-30 13:10:53 +00:00
result = write_patterns_and_update ( pl ) ;
2019-11-21 22:04:36 +00:00
if ( result & & changed_config )
set_config ( MODE_NO_PATTERNS ) ;
2021-03-30 13:10:53 +00:00
clear_pattern_list ( pl ) ;
free ( pl ) ;
2019-11-21 22:04:36 +00:00
return result ;
}
2022-02-19 16:44:44 +00:00
static void sanitize_paths ( int argc , const char * * argv ,
const char * prefix , int skip_checks )
2022-02-19 16:44:43 +00:00
{
2022-02-19 16:44:44 +00:00
int i ;
2022-02-19 16:44:43 +00:00
if ( ! argc )
return ;
if ( prefix & & * prefix & & core_sparse_checkout_cone ) {
/*
* The args are not pathspecs , so unfortunately we
* cannot imitate how cmd_add ( ) uses parse_pathspec ( ) .
*/
int prefix_len = strlen ( prefix ) ;
for ( i = 0 ; i < argc ; i + + )
argv [ i ] = prefix_path ( prefix , prefix_len , argv [ i ] ) ;
}
2022-02-19 16:44:44 +00:00
if ( skip_checks )
return ;
2022-02-19 16:44:43 +00:00
if ( prefix & & * prefix & & ! core_sparse_checkout_cone )
die ( _ ( " please run from the toplevel directory in non-cone mode " ) ) ;
2022-02-19 16:44:45 +00:00
if ( core_sparse_checkout_cone ) {
for ( i = 0 ; i < argc ; i + + ) {
if ( argv [ i ] [ 0 ] = = ' / ' )
die ( _ ( " specify directories rather than patterns (no leading slash) " ) ) ;
if ( argv [ i ] [ 0 ] = = ' ! ' )
die ( _ ( " specify directories rather than patterns. If your directory starts with a '!', pass --skip-checks " ) ) ;
if ( strpbrk ( argv [ i ] , " *?[] " ) )
die ( _ ( " specify directories rather than patterns. If your directory really has any of '*?[] \\ ' in it, pass --skip-checks " ) ) ;
}
}
2022-02-19 16:44:44 +00:00
for ( i = 0 ; i < argc ; i + + ) {
struct cache_entry * ce ;
struct index_state * index = the_repository - > index ;
int pos = index_name_pos ( index , argv [ i ] , strlen ( argv [ i ] ) ) ;
if ( pos < 0 )
continue ;
ce = index - > cache [ pos ] ;
if ( S_ISSPARSEDIR ( ce - > ce_mode ) )
continue ;
if ( core_sparse_checkout_cone )
die ( _ ( " '%s' is not a directory; to treat it as a directory anyway, rerun with --skip-checks " ) , argv [ i ] ) ;
else
warning ( _ ( " pass a leading slash before paths such as '%s' if you want a single file (see NON-CONE PROBLEMS in the git-sparse-checkout manual). " ) , argv [ i ] ) ;
}
2022-02-19 16:44:43 +00:00
}
2021-12-14 04:09:04 +00:00
static char const * const builtin_sparse_checkout_add_usage [ ] = {
2022-02-19 16:44:44 +00:00
N_ ( " git sparse-checkout add [--skip-checks] (--stdin | <patterns>) " ) ,
2021-12-14 04:09:04 +00:00
NULL
} ;
static struct sparse_checkout_add_opts {
2022-02-19 16:44:44 +00:00
int skip_checks ;
2021-12-14 04:09:04 +00:00
int use_stdin ;
} add_opts ;
static int sparse_checkout_add ( int argc , const char * * argv , const char * prefix )
{
static struct option builtin_sparse_checkout_add_options [ ] = {
2022-02-19 16:44:44 +00:00
OPT_BOOL_F ( 0 , " skip-checks " , & add_opts . skip_checks ,
N_ ( " skip some sanity checks on the given paths that might give false positives " ) ,
PARSE_OPT_NONEG ) ,
2021-12-14 04:09:04 +00:00
OPT_BOOL ( 0 , " stdin " , & add_opts . use_stdin ,
N_ ( " read patterns from standard in " ) ) ,
OPT_END ( ) ,
} ;
2023-03-27 07:55:02 +00:00
setup_work_tree ( ) ;
2021-12-14 04:09:05 +00:00
if ( ! core_apply_sparse_checkout )
die ( _ ( " no sparse-checkout to add to " ) ) ;
2021-12-14 04:09:04 +00:00
repo_read_index ( the_repository ) ;
argc = parse_options ( argc , argv , prefix ,
builtin_sparse_checkout_add_options ,
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
builtin_sparse_checkout_add_usage , 0 ) ;
2021-12-14 04:09:04 +00:00
2022-02-19 16:44:44 +00:00
sanitize_paths ( argc , argv , prefix , add_opts . skip_checks ) ;
2022-02-19 16:44:43 +00:00
2021-12-14 04:09:04 +00:00
return modify_pattern_list ( argc , argv , add_opts . use_stdin , ADD ) ;
}
static char const * const builtin_sparse_checkout_set_usage [ ] = {
2022-02-19 16:44:44 +00:00
N_ ( " git sparse-checkout set [--[no-]cone] [--[no-]sparse-index] [--skip-checks] (--stdin | <patterns>) " ) ,
2021-12-14 04:09:04 +00:00
NULL
} ;
static struct sparse_checkout_set_opts {
2021-12-14 04:09:08 +00:00
int cone_mode ;
int sparse_index ;
2022-02-19 16:44:44 +00:00
int skip_checks ;
2021-12-14 04:09:04 +00:00
int use_stdin ;
} set_opts ;
static int sparse_checkout_set ( int argc , const char * * argv , const char * prefix )
2020-02-11 15:02:22 +00:00
{
2021-12-14 04:09:08 +00:00
int default_patterns_nr = 2 ;
const char * default_patterns [ ] = { " /* " , " !/*/ " , NULL } ;
2020-02-11 15:02:22 +00:00
static struct option builtin_sparse_checkout_set_options [ ] = {
2021-12-14 04:09:08 +00:00
OPT_BOOL ( 0 , " cone " , & set_opts . cone_mode ,
N_ ( " initialize the sparse-checkout in cone mode " ) ) ,
OPT_BOOL ( 0 , " sparse-index " , & set_opts . sparse_index ,
N_ ( " toggle the use of a sparse index " ) ) ,
2022-02-19 16:44:44 +00:00
OPT_BOOL_F ( 0 , " skip-checks " , & set_opts . skip_checks ,
N_ ( " skip some sanity checks on the given paths that might give false positives " ) ,
PARSE_OPT_NONEG ) ,
2021-12-14 04:09:06 +00:00
OPT_BOOL_F ( 0 , " stdin " , & set_opts . use_stdin ,
N_ ( " read patterns from standard in " ) ,
PARSE_OPT_NONEG ) ,
2020-02-11 15:02:22 +00:00
OPT_END ( ) ,
} ;
2023-03-27 07:55:02 +00:00
setup_work_tree ( ) ;
2020-02-11 15:02:22 +00:00
repo_read_index ( the_repository ) ;
2021-12-14 04:09:08 +00:00
set_opts . cone_mode = - 1 ;
set_opts . sparse_index = - 1 ;
2020-02-11 15:02:22 +00:00
argc = parse_options ( argc , argv , prefix ,
builtin_sparse_checkout_set_options ,
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
builtin_sparse_checkout_set_usage , 0 ) ;
2020-02-11 15:02:22 +00:00
2021-12-14 04:09:08 +00:00
if ( update_modes ( & set_opts . cone_mode , & set_opts . sparse_index ) )
return 1 ;
/*
* Cone mode automatically specifies the toplevel directory . For
* non - cone mode , if nothing is specified , manually select just the
* top - level directory ( much as ' init ' would do ) .
*/
2023-12-21 06:59:24 +00:00
if ( ! core_sparse_checkout_cone & & ! set_opts . use_stdin & & argc = = 0 ) {
2021-12-14 04:09:08 +00:00
argv = default_patterns ;
argc = default_patterns_nr ;
2022-02-19 16:44:43 +00:00
} else {
2022-02-19 16:44:44 +00:00
sanitize_paths ( argc , argv , prefix , set_opts . skip_checks ) ;
2021-12-14 04:09:08 +00:00
}
2021-12-14 04:09:04 +00:00
return modify_pattern_list ( argc , argv , set_opts . use_stdin , REPLACE ) ;
2020-02-11 15:02:22 +00:00
}
2020-09-30 12:30:10 +00:00
static char const * const builtin_sparse_checkout_reapply_usage [ ] = {
2022-01-31 22:07:48 +00:00
" git sparse-checkout reapply [--[no-]cone] [--[no-]sparse-index] " ,
2020-09-30 12:30:10 +00:00
NULL
} ;
2021-12-14 04:09:09 +00:00
static struct sparse_checkout_reapply_opts {
int cone_mode ;
int sparse_index ;
} reapply_opts ;
2022-08-19 16:04:09 +00:00
static int sparse_checkout_reapply ( int argc , const char * * argv ,
const char * prefix )
2020-03-27 00:49:01 +00:00
{
2020-09-30 12:30:10 +00:00
static struct option builtin_sparse_checkout_reapply_options [ ] = {
2021-12-14 04:09:09 +00:00
OPT_BOOL ( 0 , " cone " , & reapply_opts . cone_mode ,
N_ ( " initialize the sparse-checkout in cone mode " ) ) ,
OPT_BOOL ( 0 , " sparse-index " , & reapply_opts . sparse_index ,
N_ ( " toggle the use of a sparse index " ) ) ,
2020-09-30 12:30:10 +00:00
OPT_END ( ) ,
} ;
2023-03-27 07:55:02 +00:00
setup_work_tree ( ) ;
2021-12-14 04:09:05 +00:00
if ( ! core_apply_sparse_checkout )
die ( _ ( " must be in a sparse-checkout to reapply sparsity patterns " ) ) ;
2022-02-19 16:44:41 +00:00
reapply_opts . cone_mode = - 1 ;
reapply_opts . sparse_index = - 1 ;
pass subcommand "prefix" arguments to parse_options()
Recent commits such as bf0a6b65fc (builtin/multi-pack-index.c: let
parse-options parse subcommands, 2022-08-19) converted a few functions
to match our usual argc/argv/prefix conventions, but the prefix argument
remains unused.
However, there is a good use for it: they should pass it to their own
parse_options() functions, where it may be used to adjust the value of
any filename options. In all but one of these functions, there's no
behavior change, since they don't use OPT_FILENAME. But this is an
actual fix for one option, which you can see by modifying the test suite
like so:
diff --git a/t/t5326-multi-pack-bitmaps.sh b/t/t5326-multi-pack-bitmaps.sh
index 4fe57414c1..d0974d4371 100755
--- a/t/t5326-multi-pack-bitmaps.sh
+++ b/t/t5326-multi-pack-bitmaps.sh
@@ -186,7 +186,11 @@ test_expect_success 'writing a bitmap with --refs-snapshot' '
# Then again, but with a refs snapshot which only sees
# refs/tags/one.
- git multi-pack-index write --bitmap --refs-snapshot=snapshot &&
+ (
+ mkdir subdir &&
+ cd subdir &&
+ git multi-pack-index write --bitmap --refs-snapshot=../snapshot
+ ) &&
test_path_is_file $midx &&
test_path_is_file $midx-$(midx_checksum $objdir).bitmap &&
I'd emphasize that this wasn't broken by bf0a6b65fc; it has been broken
all along, because the sub-function never got to see the prefix. It is
that commit which is actually enabling us to fix it (and which also
brought attention to the problem because it triggers -Wunused-parameter!)
The other functions changed here don't use OPT_FILENAME at all. In their
cases this isn't fixing anything visible, but it's following the usual
pattern and future-proofing them against somebody adding new options and
being surprised.
I didn't include a test for the one visible case above. We don't
generally test routine parse-options behavior for individual options.
The challenge here was finding the problem, and now that this has been
done, it's not likely to regress. Likewise, we could apply the patch
above to cover it "for free" but it makes reading the rest of the test
unnecessarily complicated.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-08-25 10:47:00 +00:00
argc = parse_options ( argc , argv , prefix ,
2020-09-30 12:30:10 +00:00
builtin_sparse_checkout_reapply_options ,
builtin_sparse_checkout_reapply_usage , 0 ) ;
2020-03-27 00:49:01 +00:00
repo_read_index ( the_repository ) ;
2021-12-14 04:09:09 +00:00
if ( update_modes ( & reapply_opts . cone_mode , & reapply_opts . sparse_index ) )
return 1 ;
2020-03-27 00:49:01 +00:00
return update_working_directory ( NULL ) ;
}
2020-09-30 12:30:10 +00:00
static char const * const builtin_sparse_checkout_disable_usage [ ] = {
2022-01-31 22:07:48 +00:00
" git sparse-checkout disable " ,
2020-09-30 12:30:10 +00:00
NULL
} ;
2022-08-19 16:04:09 +00:00
static int sparse_checkout_disable ( int argc , const char * * argv ,
const char * prefix )
2019-11-21 22:04:38 +00:00
{
2020-09-30 12:30:10 +00:00
static struct option builtin_sparse_checkout_disable_options [ ] = {
OPT_END ( ) ,
} ;
2019-11-21 22:04:47 +00:00
struct pattern_list pl ;
struct strbuf match_all = STRBUF_INIT ;
2019-11-21 22:04:38 +00:00
2021-12-14 04:09:05 +00:00
/*
* We do not exit early if ! core_apply_sparse_checkout ; due to the
* ability for users to manually muck things up between
* direct editing of . git / info / sparse - checkout
* running read - tree - m u HEAD or update - index - - skip - worktree
* direct toggling of config options
* users might end up with an index with SKIP_WORKTREE bit set on
* some files and not know how to undo it . So , here we just
* forcibly return to a dense checkout regardless of initial state .
*/
2023-03-27 07:55:02 +00:00
setup_work_tree ( ) ;
pass subcommand "prefix" arguments to parse_options()
Recent commits such as bf0a6b65fc (builtin/multi-pack-index.c: let
parse-options parse subcommands, 2022-08-19) converted a few functions
to match our usual argc/argv/prefix conventions, but the prefix argument
remains unused.
However, there is a good use for it: they should pass it to their own
parse_options() functions, where it may be used to adjust the value of
any filename options. In all but one of these functions, there's no
behavior change, since they don't use OPT_FILENAME. But this is an
actual fix for one option, which you can see by modifying the test suite
like so:
diff --git a/t/t5326-multi-pack-bitmaps.sh b/t/t5326-multi-pack-bitmaps.sh
index 4fe57414c1..d0974d4371 100755
--- a/t/t5326-multi-pack-bitmaps.sh
+++ b/t/t5326-multi-pack-bitmaps.sh
@@ -186,7 +186,11 @@ test_expect_success 'writing a bitmap with --refs-snapshot' '
# Then again, but with a refs snapshot which only sees
# refs/tags/one.
- git multi-pack-index write --bitmap --refs-snapshot=snapshot &&
+ (
+ mkdir subdir &&
+ cd subdir &&
+ git multi-pack-index write --bitmap --refs-snapshot=../snapshot
+ ) &&
test_path_is_file $midx &&
test_path_is_file $midx-$(midx_checksum $objdir).bitmap &&
I'd emphasize that this wasn't broken by bf0a6b65fc; it has been broken
all along, because the sub-function never got to see the prefix. It is
that commit which is actually enabling us to fix it (and which also
brought attention to the problem because it triggers -Wunused-parameter!)
The other functions changed here don't use OPT_FILENAME at all. In their
cases this isn't fixing anything visible, but it's following the usual
pattern and future-proofing them against somebody adding new options and
being surprised.
I didn't include a test for the one visible case above. We don't
generally test routine parse-options behavior for individual options.
The challenge here was finding the problem, and now that this has been
done, it's not likely to regress. Likewise, we could apply the patch
above to cover it "for free" but it makes reading the rest of the test
unnecessarily complicated.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-08-25 10:47:00 +00:00
argc = parse_options ( argc , argv , prefix ,
2020-09-30 12:30:10 +00:00
builtin_sparse_checkout_disable_options ,
builtin_sparse_checkout_disable_usage , 0 ) ;
2019-11-21 22:04:51 +00:00
repo_read_index ( the_repository ) ;
2019-11-21 22:04:47 +00:00
memset ( & pl , 0 , sizeof ( pl ) ) ;
hashmap_init ( & pl . recursive_hashmap , pl_hashmap_cmp , NULL , 0 ) ;
hashmap_init ( & pl . parent_hashmap , pl_hashmap_cmp , NULL , 0 ) ;
pl . use_cone_patterns = 0 ;
core_apply_sparse_checkout = 1 ;
2019-11-21 22:04:38 +00:00
2019-11-21 22:04:47 +00:00
strbuf_addstr ( & match_all , " /* " ) ;
add_pattern ( strbuf_detach ( & match_all , NULL ) , empty_base , 0 , & pl , 0 ) ;
2019-11-21 22:04:38 +00:00
2021-03-30 13:11:01 +00:00
prepare_repo_settings ( the_repository ) ;
the_repository - > settings . sparse_index = 0 ;
2019-11-21 22:04:47 +00:00
if ( update_working_directory ( & pl ) )
2019-11-21 22:04:38 +00:00
die ( _ ( " error while refreshing working directory " ) ) ;
2019-11-21 22:04:47 +00:00
clear_pattern_list ( & pl ) ;
2019-11-21 22:04:38 +00:00
return set_config ( MODE_NO_PATTERNS ) ;
}
2023-03-27 07:55:03 +00:00
static char const * const builtin_sparse_checkout_check_rules_usage [ ] = {
N_ ( " git sparse-checkout check-rules [-z] [--skip-checks] "
" [--[no-]cone] [--rules-file <file>] " ) ,
NULL
} ;
static struct sparse_checkout_check_rules_opts {
int cone_mode ;
int null_termination ;
char * rules_file ;
} check_rules_opts ;
static int check_rules ( struct pattern_list * pl , int null_terminated ) {
struct strbuf line = STRBUF_INIT ;
struct strbuf unquoted = STRBUF_INIT ;
char * path ;
int line_terminator = null_terminated ? 0 : ' \n ' ;
strbuf_getline_fn getline_fn = null_terminated ? strbuf_getline_nul
: strbuf_getline ;
the_repository - > index - > sparse_checkout_patterns = pl ;
while ( ! getline_fn ( & line , stdin ) ) {
path = line . buf ;
if ( ! null_terminated & & line . buf [ 0 ] = = ' " ' ) {
strbuf_reset ( & unquoted ) ;
if ( unquote_c_style ( & unquoted , line . buf , NULL ) )
die ( _ ( " unable to unquote C-style string '%s' " ) ,
line . buf ) ;
path = unquoted . buf ;
}
if ( path_in_sparse_checkout ( path , the_repository - > index ) )
write_name_quoted ( path , stdout , line_terminator ) ;
}
strbuf_release ( & line ) ;
strbuf_release ( & unquoted ) ;
return 0 ;
}
static int sparse_checkout_check_rules ( int argc , const char * * argv , const char * prefix )
{
static struct option builtin_sparse_checkout_check_rules_options [ ] = {
OPT_BOOL ( ' z ' , NULL , & check_rules_opts . null_termination ,
N_ ( " terminate input and output files by a NUL character " ) ) ,
OPT_BOOL ( 0 , " cone " , & check_rules_opts . cone_mode ,
N_ ( " when used with --rules-file interpret patterns as cone mode patterns " ) ) ,
OPT_FILENAME ( 0 , " rules-file " , & check_rules_opts . rules_file ,
N_ ( " use patterns in <file> instead of the current ones. " ) ) ,
OPT_END ( ) ,
} ;
FILE * fp ;
int ret ;
struct pattern_list pl = { 0 } ;
char * sparse_filename ;
check_rules_opts . cone_mode = - 1 ;
argc = parse_options ( argc , argv , prefix ,
builtin_sparse_checkout_check_rules_options ,
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
builtin_sparse_checkout_check_rules_usage , 0 ) ;
2023-03-27 07:55:03 +00:00
if ( check_rules_opts . rules_file & & check_rules_opts . cone_mode < 0 )
check_rules_opts . cone_mode = 1 ;
update_cone_mode ( & check_rules_opts . cone_mode ) ;
pl . use_cone_patterns = core_sparse_checkout_cone ;
if ( check_rules_opts . rules_file ) {
fp = xfopen ( check_rules_opts . rules_file , " r " ) ;
add_patterns_from_input ( & pl , argc , argv , fp ) ;
fclose ( fp ) ;
} else {
sparse_filename = get_sparse_checkout_filename ( ) ;
if ( add_patterns_from_file_to_list ( sparse_filename , " " , 0 , & pl ,
NULL , 0 ) )
die ( _ ( " unable to load existing sparse-checkout patterns " ) ) ;
free ( sparse_filename ) ;
}
ret = check_rules ( & pl , check_rules_opts . null_termination ) ;
clear_pattern_list ( & pl ) ;
return ret ;
}
2019-11-21 22:04:33 +00:00
int cmd_sparse_checkout ( int argc , const char * * argv , const char * prefix )
{
2022-08-19 16:04:09 +00:00
parse_opt_subcommand_fn * fn = NULL ;
struct option builtin_sparse_checkout_options [ ] = {
OPT_SUBCOMMAND ( " list " , & fn , sparse_checkout_list ) ,
OPT_SUBCOMMAND ( " init " , & fn , sparse_checkout_init ) ,
OPT_SUBCOMMAND ( " set " , & fn , sparse_checkout_set ) ,
OPT_SUBCOMMAND ( " add " , & fn , sparse_checkout_add ) ,
OPT_SUBCOMMAND ( " reapply " , & fn , sparse_checkout_reapply ) ,
OPT_SUBCOMMAND ( " disable " , & fn , sparse_checkout_disable ) ,
2023-03-27 07:55:03 +00:00
OPT_SUBCOMMAND ( " check-rules " , & fn , sparse_checkout_check_rules ) ,
2019-11-21 22:04:33 +00:00
OPT_END ( ) ,
} ;
argc = parse_options ( argc , argv , prefix ,
builtin_sparse_checkout_options ,
2022-08-19 16:04:09 +00:00
builtin_sparse_checkout_usage , 0 ) ;
2019-11-21 22:04:33 +00:00
git_config ( git_default_config , NULL ) ;
2022-05-23 13:48:46 +00:00
prepare_repo_settings ( the_repository ) ;
the_repository - > settings . command_requires_full_index = 0 ;
2022-08-19 16:04:09 +00:00
return fn ( argc , argv , prefix ) ;
2019-11-21 22:04:33 +00:00
}