Add new command "switch"
Subsystems (2)
PATCH v6 9/27 checkout: factor out some code in parse_branchname_arg()
In reply to Nguyễn Thái Ngọc DuyThis is in preparation for the new command restore, which also needs to parse opts->source_tree but does not need all the disambiguation logic.
--- builtin/checkout.c | 51 ++++++++++++++++++++++++++++------------------ 1 file changed, 31 insertions(+), 20 deletions(-)
builtin/checkout.c +31 -20
@@ -1081,6 +1081,34 @@ static int git_checkout_config(const char *var, const char *value, void *cb)return git_xmerge_config (var, value,NULL ); } +static void setup_new_branch_info_and_source_tree ( +struct branch_info *new_branch_info, +struct checkout_opts *opts, +struct object_id *rev, +const char *arg) +{ +struct tree **source_tree = &opts->source_tree; +struct object_id branch_rev; + + new_branch_info->name = arg; +setup_branch_path (new_branch_info); + +if (!check_refname_format (new_branch_info->path,0 ) && + !read_ref (new_branch_info->path, &branch_rev)) +oidcpy (rev, &branch_rev); +else + new_branch_info->path =NULL ;/* not an existing branch */ + + new_branch_info->commit =lookup_commit_reference_gently (the_repository, rev,1 ); +if (!new_branch_info->commit) { +/* not a commit */ + *source_tree =parse_tree_indirect (rev); + }else { +parse_commit_or_die (new_branch_info->commit); + *source_tree =get_commit_tree (new_branch_info->commit); + } +} + static int parse_branchname_arg(int argc, const char **argv, int dwim_new_local_branch_ok, struct branch_info *new_branch_info,
@@ -1088,10 +1116,8 @@ static int parse_branchname_arg(int argc, const char **argv,struct object_id *rev, int *dwim_remotes_matched) { - struct tree **source_tree = &opts->source_tree; const char **new_branch = &opts->new_branch;int argcount =0 ; -struct object_id branch_rev;const char *arg;int dash_dash_pos;int has_dash_dash =0 ;
@@ -1213,26 +1239,11 @@ static int parse_branchname_arg(int argc, const char **argv, argv++; argc--; - new_branch_info->name = arg; -setup_branch_path (new_branch_info); - -if (!check_refname_format (new_branch_info->path,0 ) && - !read_ref (new_branch_info->path, &branch_rev)) -oidcpy (rev, &branch_rev); -else - new_branch_info->path =NULL ;/* not an existing branch */ +setup_new_branch_info_and_source_tree (new_branch_info, opts, rev, arg); - new_branch_info->commit =lookup_commit_reference_gently (the_repository, rev,1 ); -if (!new_branch_info->commit) { -/* not a commit */ - *source_tree =parse_tree_indirect (rev); - }else { -parse_commit_or_die (new_branch_info->commit); - *source_tree =get_commit_tree (new_branch_info->commit); - } - -if (!*source_tree)/* case (1): want a tree */ +if (!opts->source_tree)/* case (1): want a tree */ die (_ ("reference is not a tree: %s" ), arg); +if (!has_dash_dash) {/* case (3).(d) -> (1) */ /* * Do not complain the most common case
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 10/27 checkout: make "opts" in cmd_checkout() a pointer
In reply to Nguyễn Thái Ngọc Duy"opts" will soon be moved out of cmd_checkout(). To keep changes in that patch smaller, convert "opts" to a pointer and keep the real thing behind "real_opts".
--- builtin/checkout.c | 115 +++++++++++++++++++++++---------------------- 1 file changed, 58 insertions(+), 57 deletions(-)
builtin/checkout.c +58 -57
@@ -1341,82 +1341,83 @@ static int checkout_branch(struct checkout_opts *opts,int cmd_checkout (int argc,const char **argv,const char *prefix) { -struct checkout_opts opts; +struct checkout_opts real_opts; +struct checkout_opts *opts = &real_opts;struct branch_info new_branch_info;char *conflict_style =NULL ;int dwim_new_local_branch, no_dwim_new_local_branch =0 ;int dwim_remotes_matched =0 ;struct option options[] = { -OPT__QUIET (&opts.quiet,N_ ("suppress progress reporting" )), -OPT_STRING ('b' ,NULL , &opts.new_branch,N_ ("branch" ), +OPT__QUIET (&opts->quiet,N_ ("suppress progress reporting" )), +OPT_STRING ('b' ,NULL , &opts->new_branch,N_ ("branch" ),N_ ("create and checkout a new branch" )), -OPT_STRING ('B' ,NULL , &opts.new_branch_force,N_ ("branch" ), +OPT_STRING ('B' ,NULL , &opts->new_branch_force,N_ ("branch" ),N_ ("create/reset and checkout a branch" )), -OPT_BOOL ('l' ,NULL , &opts.new_branch_log,N_ ("create reflog for new branch" )), -OPT_BOOL (0 ,"detach" , &opts.force_detach,N_ ("detach HEAD at named commit" )), -OPT_SET_INT ('t' ,"track" , &opts.track,N_ ("set upstream info for new branch" ), +OPT_BOOL ('l' ,NULL , &opts->new_branch_log,N_ ("create reflog for new branch" )), +OPT_BOOL (0 ,"detach" , &opts->force_detach,N_ ("detach HEAD at named commit" )), +OPT_SET_INT ('t' ,"track" , &opts->track,N_ ("set upstream info for new branch" ),BRANCH_TRACK_EXPLICIT ), -OPT_STRING (0 ,"orphan" , &opts.new_orphan_branch,N_ ("new-branch" ),N_ ("new unparented branch" )), -OPT_SET_INT_F ('2' ,"ours" , &opts.writeout_stage, +OPT_STRING (0 ,"orphan" , &opts->new_orphan_branch,N_ ("new-branch" ),N_ ("new unparented branch" )), +OPT_SET_INT_F ('2' ,"ours" , &opts->writeout_stage,N_ ("checkout our version for unmerged files" ),2 ,PARSE_OPT_NONEG ), -OPT_SET_INT_F ('3' ,"theirs" , &opts.writeout_stage, +OPT_SET_INT_F ('3' ,"theirs" , &opts->writeout_stage,N_ ("checkout their version for unmerged files" ),3 ,PARSE_OPT_NONEG ), -OPT__FORCE (&opts.force,N_ ("force checkout (throw away local modifications)" ), +OPT__FORCE (&opts->force,N_ ("force checkout (throw away local modifications)" ),PARSE_OPT_NOCOMPLETE ), -OPT_BOOL ('m' ,"merge" , &opts.merge,N_ ("perform a 3-way merge with the new branch" )), -OPT_BOOL_F (0 ,"overwrite-ignore" , &opts.overwrite_ignore, +OPT_BOOL ('m' ,"merge" , &opts->merge,N_ ("perform a 3-way merge with the new branch" )), +OPT_BOOL_F (0 ,"overwrite-ignore" , &opts->overwrite_ignore,N_ ("update ignored files (default)" ),PARSE_OPT_NOCOMPLETE ),OPT_STRING (0 ,"conflict" , &conflict_style,N_ ("style" ),N_ ("conflict style (merge or diff3)" )), -OPT_BOOL ('p' ,"patch" , &opts.patch_mode,N_ ("select hunks interactively" )), -OPT_BOOL (0 ,"ignore-skip-worktree-bits" , &opts.ignore_skipworktree, +OPT_BOOL ('p' ,"patch" , &opts->patch_mode,N_ ("select hunks interactively" )), +OPT_BOOL (0 ,"ignore-skip-worktree-bits" , &opts->ignore_skipworktree,N_ ("do not limit pathspecs to sparse entries only" )),OPT_BOOL (0 ,"no-guess" , &no_dwim_new_local_branch,N_ ("do not second guess 'git checkout <no-such-branch>'" )), -OPT_BOOL (0 ,"ignore-other-worktrees" , &opts.ignore_other_worktrees, +OPT_BOOL (0 ,"ignore-other-worktrees" , &opts->ignore_other_worktrees,N_ ("do not check if another worktree is holding the given ref" )), {OPTION_CALLBACK ,0 ,"recurse-submodules" ,NULL ,"checkout" ,"control recursive updating of submodules" ,PARSE_OPT_OPTARG , option_parse_recurse_submodules_worktree_updater }, -OPT_BOOL (0 ,"progress" , &opts.show_progress,N_ ("force progress reporting" )), -OPT_BOOL (0 ,"overlay" , &opts.overlay_mode,N_ ("use overlay mode (default)" )), +OPT_BOOL (0 ,"progress" , &opts->show_progress,N_ ("force progress reporting" )), +OPT_BOOL (0 ,"overlay" , &opts->overlay_mode,N_ ("use overlay mode (default)" )),OPT_END (), }; -memset (&opts,0 ,sizeof (opts)); +memset (opts,0 ,sizeof (*opts));memset (&new_branch_info,0 ,sizeof (new_branch_info)); - opts.overwrite_ignore =1 ; - opts.prefix = prefix; - opts.show_progress =-1 ; - opts.overlay_mode =-1 ; + opts->overwrite_ignore =1 ; + opts->prefix = prefix; + opts->show_progress =-1 ; + opts->overlay_mode =-1 ; -git_config (git_checkout_config, &opts); +git_config (git_checkout_config, opts); - opts.track =BRANCH_TRACK_UNSPECIFIED ; + opts->track =BRANCH_TRACK_UNSPECIFIED ; argc =parse_options (argc, argv, prefix, options, checkout_usage,PARSE_OPT_KEEP_DASHDASH ); dwim_new_local_branch = !no_dwim_new_local_branch; -if (opts.show_progress <0 ) { -if (opts.quiet) - opts.show_progress =0 ; +if (opts->show_progress <0 ) { +if (opts->quiet) + opts->show_progress =0 ;else - opts.show_progress =isatty (2 ); + opts->show_progress =isatty (2 ); }if (conflict_style) { - opts.merge =1 ;/* implied */ + opts->merge =1 ;/* implied */ git_xmerge_config ("merge.conflictstyle" , conflict_style,NULL ); } -if ((!!opts.new_branch + !!opts.new_branch_force + !!opts.new_orphan_branch) >1 ) +if ((!!opts->new_branch + !!opts->new_branch_force + !!opts->new_orphan_branch) >1 )die (_ ("-b, -B and --orphan are mutually exclusive" )); -if (opts.overlay_mode ==1 && opts.patch_mode) +if (opts->overlay_mode ==1 && opts->patch_mode)die (_ ("-p and --overlay are mutually exclusive" ));/*
@@ -1424,14 +1425,14 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)* and new_branch_force and new_orphan_branch will tell us which one of * -b/-B/--orphan is being used. */ -if (opts.new_branch_force) - opts.new_branch = opts.new_branch_force; +if (opts->new_branch_force) + opts->new_branch = opts->new_branch_force; -if (opts.new_orphan_branch) - opts.new_branch = opts.new_orphan_branch; +if (opts->new_orphan_branch) + opts->new_branch = opts->new_orphan_branch;/* --track without -b/-B/--orphan should DWIM */ -if (opts.track !=BRANCH_TRACK_UNSPECIFIED && !opts.new_branch) { +if (opts->track !=BRANCH_TRACK_UNSPECIFIED && !opts->new_branch) {const char *argv0 = argv[0 ];if (!argc || !strcmp (argv0,"--" ))die (_ ("--track needs a branch name" ));
@@ -1440,7 +1441,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix) argv0 =strchr (argv0,'/' );if (!argv0 || !argv0[1 ])die (_ ("missing branch name; try -b" )); - opts.new_branch = argv0 +1 ; + opts->new_branch = argv0 +1 ; }/*
@@ -1459,56 +1460,56 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)if (argc) {struct object_id rev;int dwim_ok = - !opts.patch_mode && + !opts->patch_mode && dwim_new_local_branch && - opts.track ==BRANCH_TRACK_UNSPECIFIED && - !opts.new_branch; + opts->track ==BRANCH_TRACK_UNSPECIFIED && + !opts->new_branch;int n =parse_branchname_arg (argc, argv, dwim_ok, - &new_branch_info, &opts, &rev, + &new_branch_info, opts, &rev, &dwim_remotes_matched); argv += n; argc -= n; }if (argc) { -parse_pathspec (&opts.pathspec,0 , - opts.patch_mode ?PATHSPEC_PREFIX_ORIGIN :0 , +parse_pathspec (&opts->pathspec,0 , + opts->patch_mode ?PATHSPEC_PREFIX_ORIGIN :0 , prefix, argv); -if (!opts.pathspec.nr) +if (!opts->pathspec.nr)die (_ ("invalid path specification" ));/* * Try to give more helpful suggestion. * new_branch && argc > 1 will be caught later. */ -if (opts.new_branch && argc ==1 ) +if (opts->new_branch && argc ==1 )die (_ ("'%s' is not a commit and a branch '%s' cannot be created from it" ), - argv[0 ], opts.new_branch); + argv[0 ], opts->new_branch); -if (opts.force_detach) +if (opts->force_detach)die (_ ("git checkout: --detach does not take a path argument '%s'" ), argv[0 ]); -if (1 < !!opts.writeout_stage + !!opts.force + !!opts.merge) +if (1 < !!opts->writeout_stage + !!opts->force + !!opts->merge)die (_ ("git checkout: --ours/--theirs, --force and --merge are incompatible when\n" "checking out of the index." )); } -if (opts.new_branch) { +if (opts->new_branch) {struct strbuf buf =STRBUF_INIT ; -if (opts.new_branch_force) - opts.branch_exists =validate_branchname (opts.new_branch, &buf); +if (opts->new_branch_force) + opts->branch_exists =validate_branchname (opts->new_branch, &buf);else - opts.branch_exists = -validate_new_branchname (opts.new_branch, &buf,0 ); + opts->branch_exists = +validate_new_branchname (opts->new_branch, &buf,0 );strbuf_release (&buf); }UNLEAK (opts); -if (opts.patch_mode || opts.pathspec.nr) { -int ret =checkout_paths (&opts, new_branch_info.name); +if (opts->patch_mode || opts->pathspec.nr) { +int ret =checkout_paths (opts, new_branch_info.name);if (ret && dwim_remotes_matched >1 && advice_checkout_ambiguous_remote_branch_name) advise(_("'%s' matched more than one remote tracking branch.\n"
@@ -1527,6 +1528,6 @@ int cmd_checkout(int argc, const char **argv, const char *prefix) dwim_remotes_matched);return ret; }else { -return checkout_branch (&opts, &new_branch_info); +return checkout_branch (opts, &new_branch_info); } }
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 11/27 checkout: move 'confict_style' and 'dwim_..' to checkout_opts
In reply to Nguyễn Thái Ngọc DuyThese local variables are referenced by struct option[]. This struct will soon be broken down, moved away and we can't rely on local variables anymore. Move these two to struct checkout_opts in preparation for that.
--- builtin/checkout.c | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-)
builtin/checkout.c +10 -7
@@ -47,6 +47,8 @@ struct checkout_opts {int show_progress;int count_checkout_paths;int overlay_mode; +int no_dwim_new_local_branch; +/* * If new checkout options are added, skip_merge_working_tree * should be updated accordingly.
@@ -58,6 +60,7 @@ struct checkout_opts {int new_branch_log;enum branch_track track;struct diff_options diff_options; +char *conflict_style;int branch_exists;const char *prefix;
@@ -1344,8 +1347,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)struct checkout_opts real_opts;struct checkout_opts *opts = &real_opts;struct branch_info new_branch_info; -char *conflict_style =NULL ; -int dwim_new_local_branch, no_dwim_new_local_branch =0 ; +int dwim_new_local_branch;int dwim_remotes_matched =0 ;struct option options[] = {OPT__QUIET (&opts->quiet,N_ ("suppress progress reporting" )),
@@ -1370,12 +1372,12 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)OPT_BOOL_F (0 ,"overwrite-ignore" , &opts->overwrite_ignore,N_ ("update ignored files (default)" ),PARSE_OPT_NOCOMPLETE ), -OPT_STRING (0 ,"conflict" , &conflict_style,N_ ("style" ), +OPT_STRING (0 ,"conflict" , &opts->conflict_style,N_ ("style" ),N_ ("conflict style (merge or diff3)" )),OPT_BOOL ('p' ,"patch" , &opts->patch_mode,N_ ("select hunks interactively" )),OPT_BOOL (0 ,"ignore-skip-worktree-bits" , &opts->ignore_skipworktree,N_ ("do not limit pathspecs to sparse entries only" )), -OPT_BOOL (0 ,"no-guess" , &no_dwim_new_local_branch, +OPT_BOOL (0 ,"no-guess" , &opts->no_dwim_new_local_branch,N_ ("do not second guess 'git checkout <no-such-branch>'" )),OPT_BOOL (0 ,"ignore-other-worktrees" , &opts->ignore_other_worktrees, N_("do not check if another worktree is holding the given ref")),
@@ -1393,6 +1395,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix) opts->prefix = prefix; opts->show_progress =-1 ; opts->overlay_mode =-1 ; + opts->no_dwim_new_local_branch =0 ;git_config (git_checkout_config, opts);
@@ -1401,7 +1404,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix) argc =parse_options (argc, argv, prefix, options, checkout_usage,PARSE_OPT_KEEP_DASHDASH ); - dwim_new_local_branch = !no_dwim_new_local_branch; + dwim_new_local_branch = !opts->no_dwim_new_local_branch;if (opts->show_progress <0 ) {if (opts->quiet) opts->show_progress =0 ;
@@ -1409,9 +1412,9 @@ int cmd_checkout(int argc, const char **argv, const char *prefix) opts->show_progress =isatty (2 ); } -if (conflict_style) { +if (opts->conflict_style) { opts->merge =1 ;/* implied */ -git_xmerge_config ("merge.conflictstyle" , conflict_style,NULL ); +git_xmerge_config ("merge.conflictstyle" , opts->conflict_style,NULL ); }if ((!!opts->new_branch + !!opts->new_branch_force + !!opts->new_orphan_branch) >1 )
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 12/27 checkout: split options[] array in three pieces
In reply to Nguyễn Thái Ngọc DuyThis is a preparation step for introducing new commands that do parts of what checkout does. There will be two new commands, one is about switching branches, detaching HEAD... one about checking out paths. These share the a subset of command line options. The rest of command line options are separate.
--- builtin/checkout.c | 82 +++++++++++++++++++++++++++++++++------------- parse-options-cb.c | 17 ++++++++++ parse-options.h | 1 + 3 files changed, 77 insertions(+), 23 deletions(-)
builtin/checkout.c +59 -23
@@ -1342,15 +1342,31 @@ static int checkout_branch(struct checkout_opts *opts,return switch_branches (opts, new_branch_info); } -int cmd_checkout(int argc, const char **argv, const char *prefix) +static struct option *add_common_options (struct checkout_opts *opts, +struct option *prevopts) { - struct checkout_opts real_opts; - struct checkout_opts *opts = &real_opts; - struct branch_info new_branch_info; - int dwim_new_local_branch; - int dwim_remotes_matched = 0;struct option options[] = {OPT__QUIET (&opts->quiet,N_ ("suppress progress reporting" )), + {OPTION_CALLBACK ,0 ,"recurse-submodules" ,NULL , +"checkout" ,"control recursive updating of submodules" , +PARSE_OPT_OPTARG , option_parse_recurse_submodules_worktree_updater }, +OPT_BOOL (0 ,"progress" , &opts->show_progress,N_ ("force progress reporting" )), +OPT__FORCE (&opts->force,N_ ("force checkout (throw away local modifications)" ), +PARSE_OPT_NOCOMPLETE ), +OPT_BOOL ('m' ,"merge" , &opts->merge,N_ ("perform a 3-way merge with the new branch" )), +OPT_STRING (0 ,"conflict" , &opts->conflict_style,N_ ("style" ), +N_ ("conflict style (merge or diff3)" )), +OPT_END () + }; +struct option *newopts =parse_options_concat (prevopts, options); +free (prevopts); +return newopts; +} + +static struct option *add_switch_branch_options(struct checkout_opts *opts, + struct option *prevopts) +{ + struct option options[] = { OPT_STRING('b', NULL, &opts->new_branch, N_("branch"), N_("create and checkout a new branch")), OPT_STRING('B', NULL, &opts->new_branch_force, N_("branch"),
@@ -1360,34 +1376,49 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)OPT_SET_INT ('t' ,"track" , &opts->track,N_ ("set upstream info for new branch" ),BRANCH_TRACK_EXPLICIT ),OPT_STRING (0 ,"orphan" , &opts->new_orphan_branch,N_ ("new-branch" ),N_ ("new unparented branch" )), +OPT_BOOL_F (0 ,"overwrite-ignore" , &opts->overwrite_ignore, +N_ ("update ignored files (default)" ), +PARSE_OPT_NOCOMPLETE ), +OPT_BOOL (0 ,"no-guess" , &opts->no_dwim_new_local_branch, +N_ ("second guess 'git checkout <no-such-branch>'" )), +OPT_BOOL (0 ,"ignore-other-worktrees" , &opts->ignore_other_worktrees, +N_ ("do not check if another worktree is holding the given ref" )), +OPT_END () + }; +struct option *newopts =parse_options_concat (prevopts, options); +free (prevopts); +return newopts; +} + +static struct option *add_checkout_path_options (struct checkout_opts *opts, +struct option *prevopts) +{ +struct option options[] = {OPT_SET_INT_F ('2' ,"ours" , &opts->writeout_stage,N_ ("checkout our version for unmerged files" ),2 ,PARSE_OPT_NONEG ),OPT_SET_INT_F ('3' ,"theirs" , &opts->writeout_stage,N_ ("checkout their version for unmerged files" ),3 ,PARSE_OPT_NONEG ), -OPT__FORCE (&opts->force,N_ ("force checkout (throw away local modifications)" ), -PARSE_OPT_NOCOMPLETE ), -OPT_BOOL ('m' ,"merge" , &opts->merge,N_ ("perform a 3-way merge with the new branch" )), -OPT_BOOL_F (0 ,"overwrite-ignore" , &opts->overwrite_ignore, -N_ ("update ignored files (default)" ), -PARSE_OPT_NOCOMPLETE ), -OPT_STRING (0 ,"conflict" , &opts->conflict_style,N_ ("style" ), -N_ ("conflict style (merge or diff3)" )),OPT_BOOL ('p' ,"patch" , &opts->patch_mode,N_ ("select hunks interactively" )),OPT_BOOL (0 ,"ignore-skip-worktree-bits" , &opts->ignore_skipworktree,N_ ("do not limit pathspecs to sparse entries only" )), -OPT_BOOL (0 ,"no-guess" , &opts->no_dwim_new_local_branch, -N_ ("do not second guess 'git checkout <no-such-branch>'" )), -OPT_BOOL (0 ,"ignore-other-worktrees" , &opts->ignore_other_worktrees, -N_ ("do not check if another worktree is holding the given ref" )), - { OPTION_CALLBACK, 0, "recurse-submodules", NULL, -"checkout" ,"control recursive updating of submodules" , - PARSE_OPT_OPTARG, option_parse_recurse_submodules_worktree_updater }, -OPT_BOOL (0 ,"progress" , &opts->show_progress,N_ ("force progress reporting" )),OPT_BOOL (0 ,"overlay" , &opts->overlay_mode,N_ ("use overlay mode (default)" )), - OPT_END(), +OPT_END () }; +struct option *newopts =parse_options_concat (prevopts, options); +free (prevopts); +return newopts; +} + +int cmd_checkout (int argc,const char **argv,const char *prefix) +{ +struct checkout_opts real_opts; +struct checkout_opts *opts = &real_opts; +struct branch_info new_branch_info; +int dwim_remotes_matched =0 ; +int dwim_new_local_branch; +struct option *options =NULL ;memset (opts,0 ,sizeof (*opts));memset (&new_branch_info,0 ,sizeof (new_branch_info));
@@ -1401,6 +1432,11 @@ int cmd_checkout(int argc, const char **argv, const char *prefix) opts->track =BRANCH_TRACK_UNSPECIFIED ; + options =parse_options_dup (options); + options =add_common_options (opts, options); + options =add_switch_branch_options (opts, options); + options =add_checkout_path_options (opts, options); + argc =parse_options (argc, argv, prefix, options, checkout_usage,PARSE_OPT_KEEP_DASHDASH );
parse-options-cb.c +17 -0
@@ -122,6 +122,23 @@ int parse_opt_tertiary(const struct option *opt, const char *arg, int unset)return 0 ; } +struct option *parse_options_dup (const struct option *o) +{ +struct option *opts; +int nr =0 ; + +while (o && o->type !=OPTION_END ) { + nr++; + o++; + } + +ALLOC_ARRAY (opts, nr +1 ); +memcpy (opts, o - nr,sizeof (*o) * nr); +memset (opts + nr,0 ,sizeof (*opts)); + opts[nr].type =OPTION_END ; +return opts; +} +struct option *parse_options_concat (struct option *a,struct option *b) {struct option *ret;
parse-options.h +1 -0
@@ -257,6 +257,7 @@ int parse_options_step(struct parse_opt_ctx_t *ctx,int parse_options_end (struct parse_opt_ctx_t *ctx); +struct option *parse_options_dup (const struct option *a);struct option *parse_options_concat (struct option *a,struct option *b);/*----- some often used options -----*/
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 13/27 checkout: split part of it to new command 'switch'
In reply to Nguyễn Thái Ngọc Duy"git checkout" doing too many things is a source of confusion for many users (and it even bites old timers sometimes). To remedy that, the command will be split into two new ones: switch and restore. The good old "git checkout" command is still here and will be until all (or most of users) are sick of it.
See the new man page for the final design of switch. The actual implementation though is still pretty much the same as "git checkout" and not completely aligned with the man page. Following patches will adjust their behavior to match the man page.
--- .gitignore | 1 + Documentation/config/advice.txt | 13 +- Documentation/config/branch.txt | 4 +- Documentation/config/checkout.txt | 9 +- Documentation/config/diff.txt | 3 +- Documentation/git-checkout.txt | 4 + Documentation/git-switch.txt (new) | 271 +++++++++++++++++++++++++++++ Documentation/gitattributes.txt | 3 +- Documentation/githooks.txt | 8 +- Makefile | 1 + builtin.h | 1 + builtin/checkout.c | 60 +++++-- command-list.txt | 1 + git.c | 1 + 14 files changed, 353 insertions(+), 27 deletions(-)
.gitignore +1 -0
@@ -167,6 +167,7 @@ /git-submodule /git-submodule--helper /git-svn +/git-switch /git-symbolic-ref /git-tag /git-unpack-file
Documentation/config/advice.txt +8 -5
@@ -42,7 +42,8 @@ advice.*:: state in the output of linkgit:git-status[1], in the template shown when writing commit messages in linkgit:git-commit[1], and in the help message shown - by linkgit:git-checkout[1] when switching branch. + by linkgit:git-switch[1] or + linkgit:git-checkout[1] when switching branch. statusUoption:: Advise to consider using the `-u` option to linkgit:git-status[1] when the command takes more than 2 seconds to enumerate untracked
@@ -62,12 +63,14 @@ advice.*:: your information is guessed from the system username and domain name. detachedHead:: - Advice shown when you used linkgit:git-checkout[1] to - move to the detach HEAD state, to instruct how to create - a local branch after the fact. + Advice shown when you used + linkgit:git-switch[1] or linkgit:git-checkout[1] + to move to the detach HEAD state, to instruct how to + create a local branch after the fact. checkoutAmbiguousRemoteBranchName:: Advice shown when the argument to - linkgit:git-checkout[1] ambiguously resolves to a + linkgit:git-checkout[1] and linkgit:git-switch[1] + ambiguously resolves to a remote tracking branch on more than one remote in situations where an unambiguous argument would have otherwise caused a remote-tracking branch to be
Documentation/config/branch.txt +2 -2
@@ -1,5 +1,5 @@ branch.autoSetupMerge:: - Tells 'git branch' and 'git checkout' to set up new branches + Tells 'git branch', 'git switch' and 'git checkout' to set up new branches so that linkgit:git-pull[1] will appropriately merge from the starting point branch. Note that even if this option is not set, this behavior can be chosen per-branch using the `--track`
@@ -11,7 +11,7 @@ branch.autoSetupMerge:: branch. This option defaults to true. branch.autoSetupRebase:: - When a new branch is created with 'git branch' or 'git checkout' + When a new branch is created with 'git branch', 'git switch' or 'git checkout' that tracks another branch, this variable tells Git to set up pull to rebase instead of merge (see "branch.<name>.rebase"). When `never`, rebase is never automatically set to true.
Documentation/config/checkout.txt +6 -3
@@ -1,5 +1,6 @@ checkout.defaultRemote:: - When you run 'git checkout <something>' and only have one + When you run 'git checkout <something>' + or 'git switch <something>' and only have one remote, it may implicitly fall back on checking out and tracking e.g. 'origin/<something>'. This stops working as soon as you have more than one remote with a '<something>'
@@ -8,8 +9,10 @@ checkout.defaultRemote:: disambiguation. The typical use-case is to set this to `origin`. + -Currently this is used by linkgit:git-checkout[1] when 'git checkout -<something>' will checkout the '<something>' branch on another remote, +Currently this is used by linkgit:git-switch[1] and +linkgit:git-checkout[1] when 'git checkout <something>' +or 'git switch <something>' +will checkout the '<something>' branch on another remote, and by linkgit:git-worktree[1] when 'git worktree add' refers to a remote branch. This setting might be used for other checkout-like commands or functionality in the future.
Documentation/config/diff.txt +2 -1
@@ -78,7 +78,8 @@ diff.external:: diff.ignoreSubmodules:: Sets the default value of --ignore-submodules. Note that this affects only 'git diff' Porcelain, and not lower level 'diff' - commands such as 'git diff-files'. 'git checkout' also honors + commands such as 'git diff-files'. 'git checkout' + and 'git switch' also honor this setting when reporting uncommitted changes. Setting it to 'all' disables the submodule summary normally shown by 'git commit' and 'git status' when `status.submoduleSummary` is set unless it is
Documentation/git-checkout.txt +4 -0
@@ -560,6 +560,10 @@ $ edit frotz $ git add frotz ------------ +SEE ALSO +-------- +linkgit:git-switch[1] + GIT --- Part of the linkgit:git[1] suite
Documentation/git-switch.txt new file +271 -0
271 lines not on this page · raw message
Documentation/gitattributes.txt +2 -1
@@ -112,7 +112,8 @@ Checking-out and checking-in These attributes affect how the contents stored in the repository are copied to the working tree files when commands -such as 'git checkout' and 'git merge' run. They also affect how +such as 'git switch', 'git checkout' and 'git merge' run. +They also affect how Git stores the contents you prepare in the working tree in the repository upon 'git add' and 'git commit'.
Documentation/githooks.txt +5 -3
@@ -165,12 +165,13 @@ rebased, and is not set when rebasing the current branch. post-checkout ~~~~~~~~~~~~~ -This hook is invoked when a linkgit:git-checkout[1] is run after having updated the +This hook is invoked when a linkgit:git-checkout[1] or +linkgit:git-switch[1] is run after having updated the worktree. The hook is given three parameters: the ref of the previous HEAD, the ref of the new HEAD (which may or may not have changed), and a flag indicating whether the checkout was a branch checkout (changing branches, flag=1) or a file checkout (retrieving a file from the index, flag=0). -This hook cannot affect the outcome of `git checkout`. +This hook cannot affect the outcome of `git switch` or `git checkout`. It is also run after linkgit:git-clone[1], unless the `--no-checkout` (`-n`) option is used. The first parameter given to the hook is the null-ref, the second the
@@ -406,7 +407,8 @@ exit with a zero status. For example, the hook can simply run `git read-tree -u -m HEAD "$1"` in order to emulate `git fetch` that is run in the reverse direction with `git push`, as the two-tree form of `git read-tree -u -m` is -essentially the same as `git checkout` that switches branches while +essentially the same as `git switch` or `git checkout` +that switches branches while keeping the local changes in the working tree that do not interfere with the difference between the branches.
Makefile +1 -0
@@ -802,6 +802,7 @@ BUILT_INS += git-merge-subtree$X BUILT_INS += git-show$X BUILT_INS += git-stage$X BUILT_INS += git-status$X +BUILT_INS += git-switch$X BUILT_INS += git-whatchanged$X # what 'all' will build and 'install' will install in gitexecdir,
builtin.h +1 -0
@@ -227,6 +227,7 @@ extern int cmd_show_index(int argc, const char **argv, const char *prefix);extern int cmd_status (int argc,const char **argv,const char *prefix);extern int cmd_stripspace (int argc,const char **argv,const char *prefix);extern int cmd_submodule__helper (int argc,const char **argv,const char *prefix); +extern int cmd_switch (int argc,const char **argv,const char *prefix);extern int cmd_symbolic_ref (int argc,const char **argv,const char *prefix);extern int cmd_tag (int argc,const char **argv,const char *prefix);extern int cmd_tar_tree (int argc,const char **argv,const char *prefix);
builtin/checkout.c +48 -12
90 lines not on this page · raw message
command-list.txt +1 -0
@@ -171,6 +171,7 @@ git-status mainporcelain info git-stripspace purehelpers git-submodule mainporcelain git-svn foreignscminterface +git-switch mainporcelain history git-symbolic-ref plumbingmanipulators git-tag mainporcelain history git-unpack-file plumbinginterrogators
git.c +1 -0
@@ -573,6 +573,7 @@ static struct cmd_struct commands[] = { { "status", cmd_status, RUN_SETUP | NEED_WORK_TREE }, { "stripspace", cmd_stripspace }, { "submodule--helper", cmd_submodule__helper, RUN_SETUP | SUPPORT_SUPER_PREFIX | NO_PARSEOPT }, + { "switch", cmd_switch, RUN_SETUP | NEED_WORK_TREE }, { "symbolic-ref", cmd_symbolic_ref, RUN_SETUP }, { "tag", cmd_tag, RUN_SETUP | DELAY_PAGER_CONFIG }, { "unpack-file", cmd_unpack_file, RUN_SETUP | NO_PARSEOPT },
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 14/27 switch: better names for -b and -B
In reply to Nguyễn Thái Ngọc DuyThe shortcut of these options do not make much sense when used with switch. And their descriptions are also tied to checkout. Move -b/-B to cmd_checkout() and new -c/-C with the same functionality in cmd_switch_branch()
--- builtin/checkout.c | 32 +++++++++++++++++++++----------- 1 file changed, 21 insertions(+), 11 deletions(-)
builtin/checkout.c +21 -11
@@ -1368,14 +1368,10 @@ static struct option *add_common_options(struct checkout_opts *opts,return newopts; } -static struct option *add_switch_branch_options(struct checkout_opts *opts, - struct option *prevopts) +static struct option *add_common_switch_branch_options( + struct checkout_opts *opts, struct option *prevopts) { struct option options[] = { - OPT_STRING('b', NULL, &opts->new_branch, N_("branch"), - N_("create and checkout a new branch")), - OPT_STRING('B', NULL, &opts->new_branch_force, N_("branch"), - N_("create/reset and checkout a branch")), OPT_BOOL('l', NULL, &opts->new_branch_log, N_("create reflog for new branch")), OPT_BOOL(0, "detach", &opts->force_detach, N_("detach HEAD at named commit")), OPT_SET_INT('t', "track", &opts->track, N_("set upstream info for new branch"),
@@ -1571,15 +1567,22 @@ static int checkout_main(int argc, const char **argv, const char *prefix,int cmd_checkout (int argc,const char **argv,const char *prefix) {struct checkout_opts opts; -struct option *options =NULL ; +struct option *options; +struct option checkout_options[] = { +OPT_STRING ('b' ,NULL , &opts.new_branch,N_ ("branch" ), +N_ ("create and checkout a new branch" )), +OPT_STRING ('B' ,NULL , &opts.new_branch_force,N_ ("branch" ), +N_ ("create/reset and checkout a branch" )), +OPT_END () + };int ret;memset (&opts,0 ,sizeof (opts)); opts.no_dwim_new_local_branch =0 ; - options =parse_options_dup (options); + options =parse_options_dup (checkout_options); options =add_common_options (&opts, options); - options =add_switch_branch_options (&opts, options); + options =add_common_switch_branch_options (&opts, options); options =add_checkout_path_options (&opts, options); ret = checkout_main(argc, argv, prefix, &opts,
@@ -1592,14 +1595,21 @@ int cmd_switch(int argc, const char **argv, const char *prefix) {struct checkout_opts opts;struct option *options =NULL ; +struct option switch_options[] = { +OPT_STRING ('c' ,"create" , &opts.new_branch,N_ ("branch" ), +N_ ("create and switch to a new branch" )), +OPT_STRING ('C' ,"force-create" , &opts.new_branch_force,N_ ("branch" ), +N_ ("create/reset and switch to a branch" )), +OPT_END () + };int ret;memset (&opts,0 ,sizeof (opts)); opts.no_dwim_new_local_branch =0 ; - options =parse_options_dup (options); + options =parse_options_dup (switch_options); options =add_common_options (&opts, options); - options =add_switch_branch_options (&opts, options); + options =add_common_switch_branch_options (&opts, options); ret =checkout_main (argc, argv, prefix, &opts, options, switch_branch_usage);
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 15/27 switch: add --discard-changes
In reply to Nguyễn Thái Ngọc Duy--discard-changes is a better name than --force for this option since it's what really happens. --force is turned to an alias for --discard-changes. But it's meant to be an alias for potentially more force options in the future.
Side note. It's not obvious from the patch but --discard-changes also affects submodules if --recurse-submodules is used. The knob to force updating submodules is hidden behind unpack-trees.c
--- builtin/checkout.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)
builtin/checkout.c +10 -2
@@ -53,6 +53,7 @@ struct checkout_opts {int count_checkout_paths;int overlay_mode;int no_dwim_new_local_branch; +int discard_changes;/* * If new checkout options are added, skip_merge_working_tree
@@ -680,7 +681,7 @@ static int merge_working_tree(const struct checkout_opts *opts,return error (_ ("index file corrupt" ));resolve_undo_clear (); -if (opts->force) { +if (opts->discard_changes) { ret =reset_tree (get_commit_tree (new_branch_info->commit), opts,1 , writeout_error);if (ret)
@@ -802,7 +803,7 @@ static int merge_working_tree(const struct checkout_opts *opts,if (write_locked_index (&the_index, &lock_file,COMMIT_LOCK ))die (_ ("unable to write new index file" )); -if (!opts->force && !opts->quiet) +if (!opts->discard_changes && !opts->quiet)show_local_changes (&new_branch_info->commit->object, &opts->diff_options);return 0 ;
@@ -1309,6 +1310,9 @@ static int checkout_branch(struct checkout_opts *opts,if (opts->force && opts->merge)die (_ ("'%s' cannot be used with '%s'" ),"-f" ,"-m" ); +if (opts->discard_changes && opts->merge) +die (_ ("'%s' cannot be used with '%s'" ),"--discard-changes" ,"--merge" ); +if (opts->force_detach && opts->new_branch)die (_ ("'%s' cannot be used with '%s'" ),"--detach" ,"-b/-B/--orphan" );
@@ -1445,6 +1449,8 @@ static int checkout_main(int argc, const char **argv, const char *prefix, opts->merge =1 ;/* implied */ git_xmerge_config ("merge.conflictstyle" , opts->conflict_style,NULL ); } +if (opts->force) + opts->discard_changes =1 ;if ((!!opts->new_branch + !!opts->new_branch_force + !!opts->new_orphan_branch) >1 )die (_ ("-b, -B and --orphan are mutually exclusive" ));
@@ -1600,6 +1606,8 @@ int cmd_switch(int argc, const char **argv, const char *prefix) N_("create and switch to a new branch")),OPT_STRING ('C' ,"force-create" , &opts.new_branch_force,N_ ("branch" ),N_ ("create/reset and switch to a branch" )), +OPT_BOOL (0 ,"discard-changes" , &opts.discard_changes, +N_ ("throw away local modifications" )), OPT_END() };int ret;
Signature · 1 line
2.21.0.479.g47ac719cd3
Re: [PATCH v6 15/27] switch: add --discard-changes
Quoted 2 lines · Nguyễn Thái Ngọc Duy
--discard-changes is a better name than --force for this option since it's what really happens.
I didn't realize when I suggested the name that --force overwrites untracked files as well as discarding changes from tracked files. I think we should document that. It would be nice if read-tree --reset -u took an optional argument so read-tree --reset=tracked -u would not overwrite untracked files. Then we could have --discard-changes just discard the changes and not overwrite untracked files. I had a quick look at unpack trees and it looks like a fairly straight forward change (famous last words) - perhaps I'll have a go at it next week.
Best Wishes
Phillip
Quoted 72 lines
--force is turned to an alias for
--discard-changes. But it's meant to be an alias for potentially more force options in the future.Side note. It's not obvious from the patch but --discard-changes also affects submodules if --recurse-submodules is used. The knob to force updating submodules is hidden behind
unpack-trees.cSigned-off-by Nguyễn Thái Ngọc Duy <[email protected]>--- builtin/checkout.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)builtin/checkout.c +10
-2@@ -53,6 +53,7 @@ struct checkout_opts {int count_checkout_paths;int overlay_mode;int no_dwim_new_local_branch; +int discard_changes;/* * If new checkout options are added, skip_merge_working_tree @@ -680,7 +681,7 @@ static int merge_working_tree(const struct checkout_opts *opts,return error (_ ("index file corrupt" ));resolve_undo_clear (); -if (opts->force) { +if (opts->discard_changes) { ret =reset_tree (get_commit_tree (new_branch_info->commit), opts,1 , writeout_error);if (ret)@@ -802,7 +803,7 @@ static int merge_working_tree(const struct checkout_opts *opts,if (write_locked_index (&the_index, &lock_file,COMMIT_LOCK ))die (_ ("unable to write new index file" )); -if (!opts->force && !opts->quiet) +if (!opts->discard_changes && !opts->quiet)show_local_changes (&new_branch_info->commit->object, &opts->diff_options);return 0 ;@@ -1309,6 +1310,9 @@ static int checkout_branch(struct checkout_opts *opts,if (opts->force && opts->merge)die (_ ("'%s' cannot be used with '%s'" ),"-f" ,"-m" ); +if (opts->discard_changes && opts->merge) +die (_ ("'%s' cannot be used with '%s'" ),"--discard-changes" ,"--merge" ); +if (opts->force_detach && opts->new_branch)die (_ ("'%s' cannot be used with '%s'" ),"--detach" ,"-b/-B/--orphan" );@@ -1445,6 +1449,8 @@ static int checkout_main(int argc, const char **argv, const char *prefix, opts->merge =1 ;/* implied */ git_xmerge_config ("merge.conflictstyle" , opts->conflict_style,NULL ); } +if (opts->force) + opts->discard_changes =1 ;if ((!!opts->new_branch + !!opts->new_branch_force + !!opts->new_orphan_branch) >1 )die (_ ("-b, -B and --orphan are mutually exclusive" ));@@ -1600,6 +1606,8 @@ int cmd_switch(int argc, const char **argv, const char *prefix) N_("create and switch to a new branch")),OPT_STRING ('C' ,"force-create" , &opts.new_branch_force,N_ ("branch" ),N_ ("create/reset and switch to a branch" )), +OPT_BOOL (0 ,"discard-changes" , &opts.discard_changes, +N_ ("throw away local modifications" )), OPT_END() };int ret;
Re: [PATCH v6 15/27] switch: add --discard-changes
Quoted 5 lines · Phillip Wood
Quoted 2 lines · Nguyễn Thái Ngọc Duy
--discard-changes is a better name than --force for this option since it's what really happens.
Quoted 8 lines
I didn't realize when I suggested the name that --force overwrites untracked files as well as discarding changes from tracked files. I think we should document that. It would be nice if read-tree --reset -u took an optional argument so read-tree --reset=tracked -u would not overwrite untracked files. Then we could have --discard-changes just discard the changes and not overwrite untracked files. I had a quick look at unpack trees and it looks like a fairly straight forward change (famous last words) - perhaps I'll have a go at it next week.
So, --discard-changes is all about tracked changes, and we may have --overwrite-untracked to cover the other part, and --force enables both? That does not sound so bad (and maybe a good cure for those "overwriting untracked" reports we've seen quite often lately).
Good luck with unpack-trees.c. But if it turns out you're too busy, just let me know if want to hand that back to me.
Signature · 1 line
Duy
Re: [PATCH v6 15/27] switch: add --discard-changes
Quoted 15 lines · Duy Nguyen
Quoted 5 lines · Phillip Wood
Quoted 2 lines · Nguyễn Thái Ngọc Duy
--discard-changes is a better name than --force for this option since it's what really happens.
Quoted 8 lines
I didn't realize when I suggested the name that --force overwrites untracked files as well as discarding changes from tracked files. I think we should document that. It would be nice if read-tree --reset -u took an optional argument so read-tree --reset=tracked -u would not overwrite untracked files. Then we could have --discard-changes just discard the changes and not overwrite untracked files. I had a quick look at unpack trees and it looks like a fairly straight forward change (famous last words) - perhaps I'll have a go at it next week.
Quoted 3 lines
So, --discard-changes is all about tracked changes, and we may have --overwrite-untracked to cover the other part, and --force enables both?
I was thinking of --discard-changes dealing with tracked changes and having --force for untracked changes as well. I'm not sure we need --overwrite-untracked for switch, just for read-tree.
That does not sound so bad (and maybe a good cure for those
Quoted 4 lines
"overwriting untracked" reports we've seen quite often lately).
Good luck with
unpack-trees.c. But if it turns out you're too busy, just let me know if want to hand that back to me.
Thanks, I've got something working, I'll clean it up and send it later in the week.
Best Wishes
Phillip
PATCH v6 16/27 switch: remove -l
In reply to Nguyễn Thái Ngọc DuyThis option is ancient. Nowadays reflog is enabled by default and automatically created for new branches. Keep it in git-checkout only.
--- builtin/checkout.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
builtin/checkout.c +1 -1
@@ -1376,7 +1376,6 @@ static struct option *add_common_switch_branch_options( struct checkout_opts *opts, struct option *prevopts) { struct option options[] = { - OPT_BOOL('l', NULL, &opts->new_branch_log, N_("create reflog for new branch")), OPT_BOOL(0, "detach", &opts->force_detach, N_("detach HEAD at named commit")), OPT_SET_INT('t', "track", &opts->track, N_("set upstream info for new branch"), BRANCH_TRACK_EXPLICIT),
@@ -1579,6 +1578,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix) N_("create and checkout a new branch")),OPT_STRING ('B' ,NULL , &opts.new_branch_force,N_ ("branch" ),N_ ("create/reset and checkout a branch" )), +OPT_BOOL ('l' ,NULL , &opts.new_branch_log,N_ ("create reflog for new branch" )), OPT_END() };int ret;
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 17/27 switch: stop accepting pathspec
In reply to Nguyễn Thái Ngọc DuyThis command is about switching branch (or creating a new one) and should not accept pathspec. This helps simplify ambiguation handling. The other two ("git checkout" and "git restore") of course do accept pathspec as before.
--- builtin/checkout.c | 20 +++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-)
builtin/checkout.c +15 -5
@@ -54,6 +54,7 @@ struct checkout_opts {int overlay_mode;int no_dwim_new_local_branch;int discard_changes; +int accept_pathspec;/* * If new checkout options are added, skip_merge_working_tree
@@ -1176,10 +1177,16 @@ static int parse_branchname_arg(int argc, const char **argv,if (!argc)return 0 ; +if (!opts->accept_pathspec) { +if (argc >1 ) +die (_ ("only one reference expected" )); + has_dash_dash =1 ;/* helps disambiguate */ + } + arg = argv[0 ]; dash_dash_pos =-1 ;for (i =0 ; i < argc; i++) { -if (!strcmp (argv[i],"--" )) { +if (opts->accept_pathspec && !strcmp (argv[i],"--" )) { dash_dash_pos = i;break ; }
@@ -1213,11 +1220,12 @@ static int parse_branchname_arg(int argc, const char **argv, recover_with_dwim =0 ;/* -* Accept "git checkout foo" and "git checkout foo --" -* as candidates for dwim. +* Accept "git checkout foo", "git checkout foo --" +* and "git switch foo" as candidates for dwim. */ if (!(argc ==1 && !has_dash_dash) && - !(argc ==2 && has_dash_dash)) + !(argc ==2 && has_dash_dash) && + opts->accept_pathspec) recover_with_dwim =0 ;if (recover_with_dwim) {
@@ -1262,7 +1270,7 @@ static int parse_branchname_arg(int argc, const char **argv,*/ if (argc)verify_non_filename (opts->prefix, arg); - }else { + }else if (opts->accept_pathspec) { argcount++; argv++; argc--;
@@ -1585,6 +1593,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)memset (&opts,0 ,sizeof (opts)); opts.no_dwim_new_local_branch =0 ; + opts.accept_pathspec =1 ; options =parse_options_dup (checkout_options); options =add_common_options (&opts, options);
@@ -1614,6 +1623,7 @@ int cmd_switch(int argc, const char **argv, const char *prefix)memset (&opts,0 ,sizeof (opts)); opts.no_dwim_new_local_branch =0 ; + opts.accept_pathspec =0 ; options =parse_options_dup (switch_options); options =add_common_options (&opts, options);
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 18/27 switch: reject "do nothing" case
In reply to Nguyễn Thái Ngọc Duy"git checkout" can be executed without any arguments. What it does is not exactly great: it switches from HEAD to HEAD and shows worktree modification as a side effect.
Make switch reject this case. Just use "git status" if you want that side effect. For switch, you have to either
- really switch a branch
- (explicitly) detach from the current branch
- create a new branch
--- builtin/checkout.c | 9 +++++++++ 1 file changed, 9 insertions(+)
builtin/checkout.c +9 -0
@@ -55,6 +55,7 @@ struct checkout_opts {int no_dwim_new_local_branch;int discard_changes;int accept_pathspec; +int switch_branch_doing_nothing_is_ok;/* * If new checkout options are added, skip_merge_working_tree
@@ -1338,6 +1339,12 @@ static int checkout_branch(struct checkout_opts *opts,die (_ ("Cannot switch branch to a non-commit '%s'" ), new_branch_info->name); +if (!opts->switch_branch_doing_nothing_is_ok && + !new_branch_info->name && + !opts->new_branch && + !opts->force_detach) +die (_ ("missing branch or commit argument" )); +if (new_branch_info->path && !opts->force_detach && !opts->new_branch && !opts->ignore_other_worktrees) {int flag;
@@ -1593,6 +1600,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)memset (&opts,0 ,sizeof (opts)); opts.no_dwim_new_local_branch =0 ; + opts.switch_branch_doing_nothing_is_ok =1 ; opts.accept_pathspec =1 ; options =parse_options_dup (checkout_options);
@@ -1624,6 +1632,7 @@ int cmd_switch(int argc, const char **argv, const char *prefix)memset (&opts,0 ,sizeof (opts)); opts.no_dwim_new_local_branch =0 ; opts.accept_pathspec =0 ; + opts.switch_branch_doing_nothing_is_ok =0 ; options =parse_options_dup (switch_options); options =add_common_options (&opts, options);
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 19/27 switch: only allow explicit detached HEAD
In reply to Nguyễn Thái Ngọc Duy"git checkout <commit>" will checkout the commit in question and detach HEAD from the current branch. It is naturally a right thing to do once you get git references. But detached HEAD is a scary concept to new users because we show a lot of warnings and stuff, and it could be hard to get out of (until you know better).
To keep switch a bit more friendly to new users, we only allow entering detached HEAD mode when --detach is given. "git switch" must take a branch (unless you create a new branch, then of course switch can take any commit-ish)
--- builtin/checkout.c | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+)
builtin/checkout.c +34 -0
@@ -45,6 +45,7 @@ struct checkout_opts {int merge;int force;int force_detach; +int implicit_detach;int writeout_stage;int overwrite_ignore;int ignore_skipworktree;
@@ -1298,6 +1299,29 @@ static int switch_unborn_to_new_branch(const struct checkout_opts *opts)return status; } +static void die_expecting_a_branch (const struct branch_info *branch_info) +{ +struct object_id oid; +char *to_free; + +if (dwim_ref (branch_info->name,strlen (branch_info->name), &oid, &to_free) ==1 ) { +const char *ref = to_free; + +if (skip_prefix (ref,"refs/tags/" , &ref)) +die (_ ("a branch is expected, got tag '%s'" ), ref); +if (skip_prefix (ref,"refs/remotes/" , &ref)) +die (_ ("a branch is expected, got remote branch '%s'" ), ref); +die (_ ("a branch is expected, got '%s'" ), ref); + } +if (branch_info->commit) +die (_ ("a branch is expected, got commit '%s'" ), branch_info->name); +/* +* This case should never happen because we already die() on +* non-commit, but just in case. +*/ +die (_ ("a branch is expected, got '%s'" ), branch_info->name); +} +static int checkout_branch (struct checkout_opts *opts,struct branch_info *new_branch_info) {
@@ -1345,6 +1369,14 @@ static int checkout_branch(struct checkout_opts *opts, !opts->force_detach)die (_ ("missing branch or commit argument" )); +if (!opts->implicit_detach && + !opts->force_detach && + !opts->new_branch && + !opts->new_branch_force && + new_branch_info->name && + !new_branch_info->path) +die_expecting_a_branch (new_branch_info); +if (new_branch_info->path && !opts->force_detach && !opts->new_branch && !opts->ignore_other_worktrees) {int flag;
@@ -1602,6 +1634,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix) opts.no_dwim_new_local_branch =0 ; opts.switch_branch_doing_nothing_is_ok =1 ; opts.accept_pathspec =1 ; + opts.implicit_detach =1 ; options =parse_options_dup (checkout_options); options =add_common_options (&opts, options);
@@ -1633,6 +1666,7 @@ int cmd_switch(int argc, const char **argv, const char *prefix) opts.no_dwim_new_local_branch =0 ; opts.accept_pathspec =0 ; opts.switch_branch_doing_nothing_is_ok =0 ; + opts.implicit_detach =0 ; options =parse_options_dup (switch_options); options =add_common_options (&opts, options);
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 20/27 switch: add short option for --detach
In reply to Nguyễn Thái Ngọc Duy"git checkout" automatically detaches branches and --detach is not that useful (--no-detach is more likely). But for "switch", you may want to use it more often once you're used to detached HEAD. This of course adds -d to git-checkout but it does not harm (yet?) to do it.
--- builtin/checkout.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
builtin/checkout.c +1 -1
@@ -1423,7 +1423,7 @@ static struct option *add_common_switch_branch_options( struct checkout_opts *opts, struct option *prevopts) { struct option options[] = { - OPT_BOOL(0, "detach", &opts->force_detach, N_("detach HEAD at named commit")), + OPT_BOOL('d', "detach", &opts->force_detach, N_("detach HEAD at named commit")), OPT_SET_INT('t', "track", &opts->track, N_("set upstream info for new branch"), BRANCH_TRACK_EXPLICIT), OPT_STRING(0, "orphan", &opts->new_orphan_branch, N_("new-branch"), N_("new unparented branch")),
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 21/27 switch: implicit dwim, use --no-guess to disable it
In reply to Nguyễn Thái Ngọc DuyThis is already the default in git-checkout. The real change in here is just minor cleanup. The main excuse is to explain why dwim is kept default.
Contrary to detach mode that is easy to get into and confusing to get back out. Automatically creating a tracking branch often does not kick in as often (you would need a branch of the same name on a remote). And since the branch creation is reported clearly, the user should be able to undo/delete it if it's unwanted.
--- Documentation/git-checkout.txt | 38 ++++++++++++++++++++-------------- builtin/checkout.c | 16 +++++++------- 2 files changed, 31 insertions(+), 23 deletions(-)
Documentation/git-checkout.txt +23 -15
@@ -31,22 +31,13 @@ branch. `<branch>`. + If `<branch>` is not found but there does exist a tracking branch in -exactly one remote (call it `<remote>`) with a matching name, treat as -equivalent to +exactly one remote (call it `<remote>`) with a matching name and +`--no-guess` is not specified, treat as equivalent to + ------------ $ git checkout -b <branch> --track <remote>/<branch> ------------ + -If the branch exists in multiple remotes and one of them is named by -the `checkout.defaultRemote` configuration variable, we'll use that -one for the purposes of disambiguation, even if the `<branch>` isn't -unique across all remotes. Set it to -e.g. `checkout.defaultRemote=origin` to always checkout remote -branches from there if `<branch>` is ambiguous but exists on the -'origin' remote. See also `checkout.defaultRemote` in -linkgit:git-config[1]. -+ You could omit `<branch>`, in which case the command degenerates to "check out the current branch", which is a glorified no-op with rather expensive side-effects to show only the tracking information,
@@ -183,6 +174,27 @@ explicitly give a name with `-b` in such a case. Do not set up "upstream" configuration, even if the `branch.autoSetupMerge` configuration variable is true. +--guess:: +--no-guess:: + If `<branch>` is not found but there does exist a tracking + branch in exactly one remote (call it `<remote>`) with a + matching name, treat as equivalent to ++ +------------ +$ git checkout -b <branch> --track <remote>/<branch> +------------ ++ +If the branch exists in multiple remotes and one of them is named by +the `checkout.defaultRemote` configuration variable, we'll use that +one for the purposes of disambiguation, even if the `<branch>` isn't +unique across all remotes. Set it to +e.g. `checkout.defaultRemote=origin` to always checkout remote +branches from there if `<branch>` is ambiguous but exists on the +'origin' remote. See also `checkout.defaultRemote` in +linkgit:git-config[1]. ++ +Use `--no-guess` to disable this. + -l:: Create the new branch's reflog; see linkgit:git-branch[1] for details.
@@ -287,10 +299,6 @@ Note that this option uses the no overlay mode by default (see also Just like linkgit:git-submodule[1], this will detach `HEAD` of the submodule. ---no-guess:: - Do not attempt to create a branch if a remote tracking branch - of the same name exists. - --overlay:: --no-overlay:: In the default overlay mode, `git checkout` never
builtin/checkout.c +8 -8
@@ -53,7 +53,7 @@ struct checkout_opts {int show_progress;int count_checkout_paths;int overlay_mode; -int no_dwim_new_local_branch; +int dwim_new_local_branch;int discard_changes;int accept_pathspec;int switch_branch_doing_nothing_is_ok;
@@ -1430,8 +1430,6 @@ static struct option *add_common_switch_branch_options(OPT_BOOL_F (0 ,"overwrite-ignore" , &opts->overwrite_ignore,N_ ("update ignored files (default)" ),PARSE_OPT_NOCOMPLETE ), -OPT_BOOL (0 ,"no-guess" , &opts->no_dwim_new_local_branch, -N_ ("second guess 'git checkout <no-such-branch>'" )),OPT_BOOL (0 ,"ignore-other-worktrees" , &opts->ignore_other_worktrees,N_ ("do not check if another worktree is holding the given ref" )),OPT_END ()
@@ -1468,7 +1466,6 @@ static int checkout_main(int argc, const char **argv, const char *prefix, {struct branch_info new_branch_info;int dwim_remotes_matched =0 ; -int dwim_new_local_branch;memset (&new_branch_info,0 ,sizeof (new_branch_info)); opts->overwrite_ignore =1 ;
@@ -1483,7 +1480,6 @@ static int checkout_main(int argc, const char **argv, const char *prefix, argc =parse_options (argc, argv, prefix, options, usagestr,PARSE_OPT_KEEP_DASHDASH ); - dwim_new_local_branch = !opts->no_dwim_new_local_branch;if (opts->show_progress <0 ) {if (opts->quiet) opts->show_progress =0 ;
@@ -1545,7 +1541,7 @@ static int checkout_main(int argc, const char **argv, const char *prefix,struct object_id rev;int dwim_ok = !opts->patch_mode && - dwim_new_local_branch && + opts->dwim_new_local_branch && opts->track ==BRANCH_TRACK_UNSPECIFIED && !opts->new_branch; int n = parse_branchname_arg(argc, argv, dwim_ok,
@@ -1626,12 +1622,14 @@ int cmd_checkout(int argc, const char **argv, const char *prefix)OPT_STRING ('B' ,NULL , &opts.new_branch_force,N_ ("branch" ),N_ ("create/reset and checkout a branch" )),OPT_BOOL ('l' ,NULL , &opts.new_branch_log,N_ ("create reflog for new branch" )), +OPT_BOOL (0 ,"guess" , &opts.dwim_new_local_branch, +N_ ("second guess 'git checkout <no-such-branch>' (default)" )), OPT_END() };int ret;memset (&opts,0 ,sizeof (opts)); - opts.no_dwim_new_local_branch =0 ; + opts.dwim_new_local_branch =1 ; opts.switch_branch_doing_nothing_is_ok =1 ; opts.accept_pathspec =1 ; opts.implicit_detach =1 ;
@@ -1656,6 +1654,8 @@ int cmd_switch(int argc, const char **argv, const char *prefix) N_("create and switch to a new branch")),OPT_STRING ('C' ,"force-create" , &opts.new_branch_force,N_ ("branch" ),N_ ("create/reset and switch to a branch" )), +OPT_BOOL (0 ,"guess" , &opts.dwim_new_local_branch, +N_ ("second guess 'git switch <no-such-branch>'" )),OPT_BOOL (0 ,"discard-changes" , &opts.discard_changes,N_ ("throw away local modifications" )),OPT_END ()
@@ -1663,7 +1663,7 @@ int cmd_switch(int argc, const char **argv, const char *prefix)int ret;memset (&opts,0 ,sizeof (opts)); - opts.no_dwim_new_local_branch =0 ; + opts.dwim_new_local_branch =1 ; opts.accept_pathspec =0 ; opts.switch_branch_doing_nothing_is_ok =0 ; opts.implicit_detach =0 ;
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 22/27 switch: no worktree status unless real branch switch happens
In reply to Nguyễn Thái Ngọc DuyWhen we switch from one branch to another, it makes sense to show a summary of local changes since there could be conflicts, or some files left modified.... When switch is used solely for creating a new branch (and "switch" to the same commit) or detaching, we don't really need to show anything.
"git checkout" does it anyway for historical reasons. But we can start with a clean slate with switch and don't have to.
This essentially reverts fa655d8411 (checkout: optimize "git checkout -b <new_branch>" - 2018-08-16) and make it default for switch, but also for -B and --detach. Users of big repos are encouraged to move to switch.
--- Documentation/config/checkout.txt | 8 -- builtin/checkout.c | 134 ++---------------------------- t/t1090-sparse-checkout-scope.sh | 14 ---- 3 files changed, 8 insertions(+), 148 deletions(-)
Documentation/config/checkout.txt +0 -8
@@ -16,11 +16,3 @@ will checkout the '<something>' branch on another remote, and by linkgit:git-worktree[1] when 'git worktree add' refers to a remote branch. This setting might be used for other checkout-like commands or functionality in the future. - -checkout.optimizeNewBranch:: - Optimizes the performance of "git checkout -b <new_branch>" when - using sparse-checkout. When set to true, git will not update the - repo based on the current sparse-checkout settings. This means it - will not update the skip-worktree bit in the index nor add/remove - files in the working directory to reflect the current sparse checkout - settings nor will it show the local changes.
builtin/checkout.c +8 -126
184 lines not on this page · raw message
t/t1090-sparse-checkout-scope.sh +0 -14
@@ -31,20 +31,6 @@ test_expect_success 'perform sparse checkout of master' ' test_path_is_file c ' -test_expect_success 'checkout -b checkout.optimizeNewBranch interaction' ' - cp .git/info/sparse-checkout .git/info/sparse-checkout.bak && - test_when_finished " - mv -f .git/info/sparse-checkout.bak .git/info/sparse-checkout - git checkout master - " && - echo "/b" >>.git/info/sparse-checkout && - test "$(git ls-files -t b)" = "S b" && - git -c checkout.optimizeNewBranch=true checkout -b fast && - test "$(git ls-files -t b)" = "S b" && - git checkout -b slow && - test "$(git ls-files -t b)" = "H b" -' - test_expect_success 'merge feature branch into sparse checkout of master' ' git merge feature && test_path_is_file a &&
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 23/27 switch: reject if some operation is in progress
In reply to Nguyễn Thái Ngọc DuyUnless you know what you're doing, switching to another branch to do something then switching back could be confusing. Worse, you may even forget that you're in the middle of something. By the time you realize, you may have done a ton of work and it gets harder to go back.
A new option --ignore-in-progress was considered but dropped because it was not exactly clear what should happen. Sometimes you can switch away and get back safely and resume the operation. Sometimes not. And the git-checkout behavior is automatically clear merge/revert/cherry-pick, which makes it a bit even more confusing [1].
We may revisit and add this option in the future. But for now play it safe and not allow it (you can't even skip this check with --force). The user is suggested to cancel the operation by themselves (and hopefully they do consider the consequences, not blindly type the command), or to create a separate worktree instead of switching. The third option is the good old "git checkout", but it's not mentioned.
[1] CACsJy8Axa5WsLSjiscjnxVK6jQHkfs-gH959=YtUvQkWriAk5w@mail.gmail.com
--- builtin/checkout.c | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+)
builtin/checkout.c +40 -0
@@ -24,6 +24,7 @@#include "tree.h" #include "tree-walk.h" #include "unpack-trees.h" +#include "wt-status.h" #include "xdiff-interface.h" static const char *const checkout_usage[] = {
@@ -56,6 +57,7 @@ struct checkout_opts {int accept_pathspec;int switch_branch_doing_nothing_is_ok;int only_merge_on_switching_branches; +int can_switch_when_in_progress;const char *new_branch;const char *new_branch_force;
@@ -1202,6 +1204,39 @@ static void die_expecting_a_branch(const struct branch_info *branch_info)die (_ ("a branch is expected, got '%s'" ), branch_info->name); } +static void die_if_some_operation_in_progress (void ) +{ +struct wt_status_state state; + +memset (&state,0 ,sizeof (state)); +wt_status_get_state (the_repository, &state,0 ); + +if (state.merge_in_progress) +die (_ ("cannot switch branch while merging\n" +"Consider \"git merge --quit\" " +"or \"git worktree add\"." )); +if (state.am_in_progress) +die (_ ("cannot switch branch in the middle of an am session\n" +"Consider \"git am --quit\" " +"or \"git worktree add\"." )); +if (state.rebase_interactive_in_progress || state.rebase_in_progress) +die (_ ("cannot switch branch while rebasing\n" +"Consider \"git rebase --quit\" " +"or \"git worktree add\"." )); +if (state.cherry_pick_in_progress) +die (_ ("cannot switch branch while cherry-picking\n" +"Consider \"git cherry-pick --quit\" " +"or \"git worktree add\"." )); +if (state.revert_in_progress) +die (_ ("cannot switch branch while reverting\n" +"Consider \"git revert --quit\" " +"or \"git worktree add\"." )); +if (state.bisect_in_progress) +die (_ ("cannot switch branch while bisecting\n" +"Consider \"git bisect reset HEAD\" " +"or \"git worktree add\"." )); +} +static int checkout_branch (struct checkout_opts *opts,struct branch_info *new_branch_info) {
@@ -1257,6 +1292,9 @@ static int checkout_branch(struct checkout_opts *opts, !new_branch_info->path)die_expecting_a_branch (new_branch_info); +if (!opts->can_switch_when_in_progress) +die_if_some_operation_in_progress (); +if (new_branch_info->path && !opts->force_detach && !opts->new_branch && !opts->ignore_other_worktrees) {int flag;
@@ -1514,6 +1552,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix) opts.only_merge_on_switching_branches =0 ; opts.accept_pathspec =1 ; opts.implicit_detach =1 ; + opts.can_switch_when_in_progress =1 ; options =parse_options_dup (checkout_options); options =add_common_options (&opts, options);
@@ -1549,6 +1588,7 @@ int cmd_switch(int argc, const char **argv, const char *prefix) opts.switch_branch_doing_nothing_is_ok =0 ; opts.only_merge_on_switching_branches =1 ; opts.implicit_detach =0 ; + opts.can_switch_when_in_progress =0 ; options =parse_options_dup (switch_options); options =add_common_options (&opts, options);
Signature · 1 line
2.21.0.479.g47ac719cd3
Re: [PATCH v6 23/27] switch: reject if some operation is in progress
Quoted 12 lines · Nguyễn Thái Ngọc Duy
Unless you know what you're doing, switching to another branch to do something then switching back could be confusing. Worse, you may even forget that you're in the middle of something. By the time you realize, you may have done a ton of work and it gets harder to go back.
A new option --ignore-in-progress was considered but dropped because it was not exactly clear what should happen. Sometimes you can switch away and get back safely and resume the operation. Sometimes not. And the git-checkout behavior is automatically clear merge/revert/cherry-pick, which makes it a bit even more confusing [1].
Quoted 6 lines
We may revisit and add this option in the future. But for now play it safe and not allow it (you can't even skip this check with --force). The user is suggested to cancel the operation by themselves (and hopefully they do consider the consequences, not blindly type the command), or to create a separate worktree instead of switching. The third option is the good old "git checkout", but it's not mentioned.
I think these safety checks are pretty important for checkout too...
Quoted 79 lines
[1] CACsJy8Axa5WsLSjiscjnxVK6jQHkfs-gH959=YtUvQkWriAk5w@mail.gmail.com
Signed-off-by Nguyễn Thái Ngọc Duy <[email protected]>--- builtin/checkout.c | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+)builtin/checkout.c +38
-0@@ -24,6 +24,7 @@#include "tree.h" #include "tree-walk.h" #include "unpack-trees.h" +#include "wt-status.h" #include "xdiff-interface.h" static const char *const checkout_usage[] = {@@ -56,6 +57,7 @@ struct checkout_opts {int accept_pathspec;int switch_branch_doing_nothing_is_ok;int only_merge_on_switching_branches; +int can_switch_when_in_progress;const char *new_branch;const char *new_branch_force;@@ -1202,6 +1204,39 @@ static void die_expecting_a_branch(const struct branch_info *branch_info)die (_ ("a branch is expected, got '%s'" ), branch_info->name); } +static void die_if_some_operation_in_progress (void ) +{ +struct wt_status_state state; + +memset (&state,0 ,sizeof (state)); +wt_status_get_state (the_repository, &state,0 ); + +if (state.merge_in_progress) +die (_ ("cannot switch branch while merging\n" +"Consider \"git merge --quit\" " +"or \"git worktree add\"." )); +if (state.am_in_progress) +die (_ ("cannot switch branch in the middle of an am session\n" +"Consider \"git am --quit\" " +"or \"git worktree add\"." )); +if (state.rebase_interactive_in_progress || state.rebase_in_progress) +die (_ ("cannot switch branch while rebasing\n" +"Consider \"git rebase --quit\" " +"or \"git worktree add\"." )); +if (state.cherry_pick_in_progress) +die (_ ("cannot switch branch while cherry-picking\n" +"Consider \"git cherry-pick --quit\" " +"or \"git worktree add\"." )); +if (state.revert_in_progress) +die (_ ("cannot switch branch while reverting\n" +"Consider \"git revert --quit\" " +"or \"git worktree add\"." )); +if (state.bisect_in_progress) +die (_ ("cannot switch branch while bisecting\n" +"Consider \"git bisect reset HEAD\" " +"or \"git worktree add\"." )); +} +static int checkout_branch (struct checkout_opts *opts,struct branch_info *new_branch_info) {@@ -1257,6 +1292,9 @@ static int checkout_branch(struct checkout_opts *opts, !new_branch_info->path)die_expecting_a_branch (new_branch_info); +if (!opts->can_switch_when_in_progress) +die_if_some_operation_in_progress (); +if (new_branch_info->path && !opts->force_detach && !opts->new_branch && !opts->ignore_other_worktrees) {int flag;
builtin/checkout.c int cmd_checkout(int argc, const char **argv, const char *prefix) · line 1555
Quoted 4 lines
builtin/checkout.c +1
-0@@ -1514,6 +1552,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix) opts.only_merge_on_switching_branches =0 ; opts.accept_pathspec =1 ; opts.implicit_detach =1 ; + opts.can_switch_when_in_progress =1 ;
I think this should be 0 too; this check is good for both checkout and switch. And if people really do want to use it during in-progress operations because it is sometimes safe enough, then both operations deserve some kind of override flag that checks for the appropriate safety conditions (as we're discussing in the other thread) and then allows or rejects it.
However, I'm totally fine with proposing another patch after your series lands to do all of this; this patch is fine as-is for now.
Quoted 12 lines
builtin/checkout.c +1
-1options =parse_options_dup (checkout_options); options =add_common_options (&opts, options);@@ -1549,6 +1588,7 @@ int cmd_switch(int argc, const char **argv, const char *prefix) opts.switch_branch_doing_nothing_is_ok =0 ; opts.only_merge_on_switching_branches =1 ; opts.implicit_detach =0 ; + opts.can_switch_when_in_progress =0 ; options =parse_options_dup (switch_options); options =add_common_options (&opts, options); --2.21.0.479.g47ac719cd3
Re: [PATCH v6 23/27] switch: reject if some operation is in progress
In reply to Nguyễn Thái Ngọc DuyQuoted 5 lines · Nguyễn Thái Ngọc Duy
Unless you know what you're doing, switching to another branch to do something then switching back could be confusing. Worse, you may even forget that you're in the middle of something. By the time you realize, you may have done a ton of work and it gets harder to go back.
Quoted 8 lines
A new option --ignore-in-progress was considered but dropped because it was not exactly clear what should happen. Sometimes you can switch away and get back safely and resume the operation. Sometimes not. And the git-checkout behavior is automatically clear merge/revert/cherry-pick, which makes it a bit even more confusing [1].
We may revisit and add this option in the future. But for now play it safe and not allow it (you can't even skip this check with --force).
I think this is a good compromise, lets see how it goes (I think I broadly agree with Elijah's suggestion to allow the switch if we can safely switch back again if we want to add --ignore-in-progress in the future).
Quoted 38 lines
The
user is suggested to cancel the operation by themselves (and hopefully they do consider the consequences, not blindly type the command), or to create a separate worktree instead of switching. The third option is the good old "git checkout", but it's not mentioned.[1] CACsJy8Axa5WsLSjiscjnxVK6jQHkfs-gH959=YtUvQkWriAk5w@mail.gmail.com
Signed-off-by Nguyễn Thái Ngọc Duy <[email protected]>--- builtin/checkout.c | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+)builtin/checkout.c +3
-0@@ -24,6 +24,7 @@#include "tree.h" #include "tree-walk.h" #include "unpack-trees.h" +#include "wt-status.h" #include "xdiff-interface.h" static const char *const checkout_usage[] = {@@ -56,6 +57,7 @@ struct checkout_opts {int accept_pathspec;int switch_branch_doing_nothing_is_ok;int only_merge_on_switching_branches; +int can_switch_when_in_progress;const char *new_branch;const char *new_branch_force;@@ -1202,6 +1204,39 @@ static void die_expecting_a_branch(const struct branch_info *branch_info)die (_ ("a branch is expected, got '%s'" ), branch_info->name); } +static void die_if_some_operation_in_progress (void )
builtin/checkout.c static void die_expecting_a_branch(const struct branch_info *branch_info) · line 1217
Quoted 10 lines
builtin/checkout.c +10
-0+{ +struct wt_status_state state; + +memset (&state,0 ,sizeof (state)); +wt_status_get_state (the_repository, &state,0 ); + +if (state.merge_in_progress) +die (_ ("cannot switch branch while merging\n" +"Consider \"git merge --quit\" " +"or \"git worktree add\"." ));
I'm not sure merge --quit exists, 'git grep \"quit origin/pu' shows matches for builtin/{am.c,rebase.c,revert.c}. The --quit option for the sequencer command does not touch the index or working tree (that's the difference between --quit and --abort) so the switch can still fail due changes in the index and worktree that would be overwritten by the switch.
Best Wishes
Phillip
Quoted 52 lines
builtin/checkout.c +27
-0+if (state.am_in_progress) +die (_ ("cannot switch branch in the middle of an am session\n" +"Consider \"git am --quit\" " +"or \"git worktree add\"." )); +if (state.rebase_interactive_in_progress || state.rebase_in_progress) +die (_ ("cannot switch branch while rebasing\n" +"Consider \"git rebase --quit\" " +"or \"git worktree add\"." )); +if (state.cherry_pick_in_progress) +die (_ ("cannot switch branch while cherry-picking\n" +"Consider \"git cherry-pick --quit\" " +"or \"git worktree add\"." )); +if (state.revert_in_progress) +die (_ ("cannot switch branch while reverting\n" +"Consider \"git revert --quit\" " +"or \"git worktree add\"." )); +if (state.bisect_in_progress) +die (_ ("cannot switch branch while bisecting\n" +"Consider \"git bisect reset HEAD\" " +"or \"git worktree add\"." )); +} +static int checkout_branch (struct checkout_opts *opts,struct branch_info *new_branch_info) {@@ -1257,6 +1292,9 @@ static int checkout_branch(struct checkout_opts *opts, !new_branch_info->path)die_expecting_a_branch (new_branch_info); +if (!opts->can_switch_when_in_progress) +die_if_some_operation_in_progress (); +if (new_branch_info->path && !opts->force_detach && !opts->new_branch && !opts->ignore_other_worktrees) {int flag;@@ -1514,6 +1552,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix) opts.only_merge_on_switching_branches =0 ; opts.accept_pathspec =1 ; opts.implicit_detach =1 ; + opts.can_switch_when_in_progress =1 ; options =parse_options_dup (checkout_options); options =add_common_options (&opts, options);@@ -1549,6 +1588,7 @@ int cmd_switch(int argc, const char **argv, const char *prefix) opts.switch_branch_doing_nothing_is_ok =0 ; opts.only_merge_on_switching_branches =1 ; opts.implicit_detach =0 ; + opts.can_switch_when_in_progress =0 ; options =parse_options_dup (switch_options); options =add_common_options (&opts, options);
Re: [PATCH v6 23/27] switch: reject if some operation is in progress
Quoted 13 lines · Phillip Wood
Quoted 11 lines · Nguyễn Thái Ngọc Duy
Unless you know what you're doing, switching to another branch to do something then switching back could be confusing. Worse, you may even forget that you're in the middle of something. By the time you realize, you may have done a ton of work and it gets harder to go back.
A new option --ignore-in-progress was considered but dropped because it was not exactly clear what should happen. Sometimes you can switch away and get back safely and resume the operation. Sometimes not. And the git-checkout behavior is automatically clear merge/revert/cherry-pick, which makes it a bit even more confusing [1].
Quoted 7 lines
Quoted 2 lines
We may revisit and add this option in the future. But for now play it safe and not allow it (you can't even skip this check with --force).
I think this is a good compromise, lets see how it goes (I think I broadly agree with Elijah's suggestion to allow the switch if we can safely switch back again if we want to add --ignore-in-progress in the future).
I probably will revisit this topic much sooner than I thought. I did a bisect today and found out "git switch" would not let me choose some "random" commit to test, which I suspected more likely where the problem was, or at least helped reduce the bisect steps. I had to go back to "git checkout" and was not so happy.
This probably falls under the "safe to switch" (and not even back) category, as long as switching does not destroy any data, since bisect is basically jumping between commits with a clean worktree/index until you find the right one.
Quoted 9 lines
Quoted 9 lines
builtin/checkout.c +9
-0+static void die_if_some_operation_in_progress (void ) +{ +struct wt_status_state state; + +memset (&state,0 ,sizeof (state)); +wt_status_get_state (the_repository, &state,0 ); + +if (state.merge_in_progress) + die(_("cannot switch branch while merging\n"
Quoted 8 lines
Review
Quoted 2 lines
(quoted diff) +2
-0+ "Consider \"git merge --quit\" " + "or \"git worktree add\"."));I'm not sure merge --quit exists, 'git grep \"quit origin/pu' shows matches for builtin/{am.c,rebase.c,revert.c}. The --quit option for the sequencer command does not touch the index or working tree (that's the difference between --quit and --abort) so the switch can still fail due changes in the index and worktree that would be overwritten by the switch.
Eck! Let me check if --abort is the same thing there or we need to add --quit...
Signature · 1 line
Duy
Re: [PATCH v6 23/27] switch: reject if some operation is in progress
Quoted 22 lines · Duy Nguyen
Quoted 13 lines · Phillip Wood
Quoted 11 lines · Nguyễn Thái Ngọc Duy
Unless you know what you're doing, switching to another branch to do something then switching back could be confusing. Worse, you may even forget that you're in the middle of something. By the time you realize, you may have done a ton of work and it gets harder to go back.
A new option --ignore-in-progress was considered but dropped because it was not exactly clear what should happen. Sometimes you can switch away and get back safely and resume the operation. Sometimes not. And the git-checkout behavior is automatically clear merge/revert/cherry-pick, which makes it a bit even more confusing [1].
Quoted 7 lines
Quoted 2 lines
We may revisit and add this option in the future. But for now play it safe and not allow it (you can't even skip this check with --force).
I think this is a good compromise, lets see how it goes (I think I broadly agree with Elijah's suggestion to allow the switch if we can safely switch back again if we want to add --ignore-in-progress in the future).
Quoted 5 lines
I probably will revisit this topic much sooner than I thought. I did a bisect today and found out "git switch" would not let me choose some "random" commit to test, which I suspected more likely where the problem was, or at least helped reduce the bisect steps. I had to go back to "git checkout" and was not so happy.
Oh that's a pain, but should be safe as you describe below.
Quoted 21 lines
This probably falls under the "safe to switch" (and not even back) category, as long as switching does not destroy any data, since bisect is basically jumping between commits with a clean worktree/index until you find the right one. >>> +static void
die_if_some_operation_in_progress(void)Quoted 8 lines
Quoted 8 lines
builtin/checkout.c +8
-0+{ +struct wt_status_state state; + +memset (&state,0 ,sizeof (state)); +wt_status_get_state (the_repository, &state,0 ); + +if (state.merge_in_progress) + die(_("cannot switch branch while merging\n"Quoted 8 lines
Review
Quoted 2 lines
(quoted diff) +2
-0+ "Consider \"git merge --quit\" " + "or \"git worktree add\"."));I'm not sure merge --quit exists, 'git grep \"quit origin/pu' shows matches for builtin/{am.c,rebase.c,revert.c}. The --quit option for the sequencer command does not touch the index or working tree (that's the difference between --quit and --abort) so the switch can still fail due changes in the index and worktree that would be overwritten by the switch.
Quoted 1 line
Eck! Let me check if --abort is the same thing there or we need to add --quit...
I think the --quit options generally leave the index and worktree alone, they just remove the state files whereas abort resets the index and worktree (with reset --mixed for merge and cherry-pick/revert, I think rebase does reset --hard) and also rewinds HEAD for rebases and sequences of cherry-picks and revert but that wont apply to merges as they are one-shot operations.
Best Wishes
Phillip
PATCH v6 24/27 switch: make --orphan switch to an empty tree
In reply to Nguyễn Thái Ngọc DuySwitching and creating branches always involves knowing the <start-point> to begin the new branch from. Sometimes, people want to create a new branch that does not have any commits yet; --orphan is a flag to allow that.
--orphan overrides the default of HEAD for <start-point> instead causing us to start from an empty history with all tracked files removed from the index and working tree. The use of --orphan is incompatible with specifying a <start-point>.
A note on the implementation. An alternative is just create a dummy commit in-core with empty tree and switch to it. But there's a chance the commit's SHA-1 may end up somewhere permanent like reflog. It's best to make sure "commit" pointer is NULL to avoid it.
--- builtin/checkout.c | 39 +++++++++++++++++++++++++++++++-------- 1 file changed, 31 insertions(+), 8 deletions(-)
builtin/checkout.c +31 -8
@@ -58,6 +58,7 @@ struct checkout_opts {int switch_branch_doing_nothing_is_ok;int only_merge_on_switching_branches;int can_switch_when_in_progress; +int orphan_from_empty_tree;const char *new_branch;const char *new_branch_force;
@@ -568,15 +569,21 @@ static int merge_working_tree(const struct checkout_opts *opts, {int ret;struct lock_file lock_file =LOCK_INIT ; +struct tree *new_tree;hold_locked_index (&lock_file,LOCK_DIE_ON_ERROR );if (read_cache_preload (NULL ) <0 )return error (_ ("index file corrupt" ));resolve_undo_clear (); +if (opts->new_orphan_branch && opts->orphan_from_empty_tree) { +if (new_branch_info->commit) +BUG ("'switch --orphan' should never accept a commit as starting point" ); + new_tree =parse_tree_indirect (the_hash_algo->empty_tree); + }else + new_tree =get_commit_tree (new_branch_info->commit);if (opts->discard_changes) { - ret =reset_tree (get_commit_tree (new_branch_info->commit), - opts,1 , writeout_error); + ret =reset_tree (new_tree, opts,1 , writeout_error);if (ret)return ret; }else {
@@ -614,7 +621,8 @@ static int merge_working_tree(const struct checkout_opts *opts, &old_branch_info->commit->object.oid : the_hash_algo->empty_tree);init_tree_desc (&trees[0 ], tree->buffer, tree->size); - tree =parse_tree_indirect (&new_branch_info->commit->object.oid); +parse_tree (new_tree); + tree = new_tree;init_tree_desc (&trees[1 ], tree->buffer, tree->size); ret =unpack_trees (2 , trees, &topts);
@@ -663,7 +671,7 @@ static int merge_working_tree(const struct checkout_opts *opts, o.verbosity =0 ; work =write_tree_from_memory (&o); - ret =reset_tree (get_commit_tree (new_branch_info->commit), + ret =reset_tree (new_tree, opts,1 , writeout_error);if (ret)
@@ -672,13 +680,13 @@ static int merge_working_tree(const struct checkout_opts *opts, o.branch1 = new_branch_info->name; o.branch2 ="local" ; ret =merge_trees (&o, -get_commit_tree (new_branch_info->commit), + new_tree, work,get_commit_tree (old_branch_info->commit), &result);if (ret <0 )exit (128 ); - ret =reset_tree (get_commit_tree (new_branch_info->commit), + ret =reset_tree (new_tree, opts,0 , writeout_error);strbuf_release (&o.obuf);
@@ -696,7 +704,7 @@ static int merge_working_tree(const struct checkout_opts *opts,if (write_locked_index (&the_index, &lock_file,COMMIT_LOCK ))die (_ ("unable to write new index file" )); -if (!opts->discard_changes && !opts->quiet) +if (!opts->discard_changes && !opts->quiet && new_branch_info->commit)show_local_changes (&new_branch_info->commit->object, &opts->diff_options);return 0 ;
@@ -897,7 +905,10 @@ static void orphaned_commit_warning(struct commit *old_commit, struct commit *neadd_pending_object (&revs, object,oid_to_hex (&object->oid));for_each_ref (add_pending_uninteresting_ref, &revs); -add_pending_oid (&revs,"HEAD" , &new_commit->object.oid,UNINTERESTING ); +if (new_commit) +add_pending_oid (&revs,"HEAD" , + &new_commit->object.oid, +UNINTERESTING );if (prepare_revision_walk (&revs))die (_ ("internal error in revision walk" ));
@@ -932,6 +943,14 @@ static int switch_branches(const struct checkout_opts *opts,if (old_branch_info.path)skip_prefix (old_branch_info.path,"refs/heads/" , &old_branch_info.name); +if (opts->new_orphan_branch && opts->orphan_from_empty_tree) { +if (new_branch_info->name) +BUG ("'switch --orphan' should never accept a commit as starting point" ); + new_branch_info->commit =NULL ; + new_branch_info->name ="(empty)" ; + do_merge =1 ; + } +if (!new_branch_info->name) { new_branch_info->name ="HEAD" ; new_branch_info->commit = old_branch_info.commit;
@@ -1268,6 +1287,8 @@ static int checkout_branch(struct checkout_opts *opts,if (opts->new_orphan_branch) {if (opts->track !=BRANCH_TRACK_UNSPECIFIED )die (_ ("'%s' cannot be used with '%s'" ),"--orphan" ,"-t" ); +if (opts->orphan_from_empty_tree && new_branch_info->name) +die (_ ("'%s' cannot take <start-point>" ),"--orphan" ); }else if (opts->force_detach) {if (opts->track !=BRANCH_TRACK_UNSPECIFIED )die (_ ("'%s' cannot be used with '%s'" ),"--detach" ,"-t" );
@@ -1553,6 +1574,7 @@ int cmd_checkout(int argc, const char **argv, const char *prefix) opts.accept_pathspec =1 ; opts.implicit_detach =1 ; opts.can_switch_when_in_progress =1 ; + opts.orphan_from_empty_tree =0 ; options =parse_options_dup (checkout_options); options =add_common_options (&opts, options);
@@ -1589,6 +1611,7 @@ int cmd_switch(int argc, const char **argv, const char *prefix) opts.only_merge_on_switching_branches =1 ; opts.implicit_detach =0 ; opts.can_switch_when_in_progress =0 ; + opts.orphan_from_empty_tree =1 ; options =parse_options_dup (switch_options); options =add_common_options (&opts, options);
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 25/27 t: add tests for switch
In reply to Nguyễn Thái Ngọc Duy--- t/t2060-switch.sh (new +x) | 96 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 96 insertions(+)
t/t2060-switch.sh new file +96 -0
@@ -0,0 +1,96 @@ +#!/bin/sh + +test_description='switch basic functionality' + +. ./test-lib.sh + +test_expect_success 'setup' ' + test_commit first && + git branch first-branch && + test_commit second && + test_commit third && + git remote add origin nohost:/nopath && + git update-ref refs/remotes/origin/foo first-branch +' + +test_expect_success 'switch branch no arguments' ' + test_must_fail git switch +' + +test_expect_success 'switch branch' ' + git switch first-branch && + test_path_is_missing second.t +' + +test_expect_success 'switch and detach' ' + test_when_finished git switch master && + test_must_fail git switch master^{commit} && + git switch --detach master^{commit} && + test_must_fail git symbolic-ref HEAD +' + +test_expect_success 'switch and detach current branch' ' + test_when_finished git switch master && + git switch master && + git switch --detach && + test_must_fail git symbolic-ref HEAD +' + +test_expect_success 'switch and create branch' ' + test_when_finished git switch master && + git switch -c temp master^ && + test_cmp_rev master^ refs/heads/temp && + echo refs/heads/temp >expected-branch && + git symbolic-ref HEAD >actual-branch && + test_cmp expected-branch actual-branch +' + +test_expect_success 'force create branch from HEAD' ' + test_when_finished git switch master && + git switch --detach master && + test_must_fail git switch -c temp && + git switch -C temp && + test_cmp_rev master refs/heads/temp && + echo refs/heads/temp >expected-branch && + git symbolic-ref HEAD >actual-branch && + test_cmp expected-branch actual-branch +' + +test_expect_success 'new orphan branch from empty' ' + test_when_finished git switch master && + test_must_fail git switch --orphan new-orphan HEAD && + git switch --orphan new-orphan && + test_commit orphan && + git cat-file commit refs/heads/new-orphan >commit && + ! grep ^parent commit && + git ls-files >tracked-files && + echo orphan.t >expected && + test_cmp expected tracked-files +' + +test_expect_success 'switching ignores file of same branch name' ' + test_when_finished git switch master && + : >first-branch && + git switch first-branch && + echo refs/heads/first-branch >expected && + git symbolic-ref HEAD >actual && + test_cmp expected actual +' + +test_expect_success 'guess and create branch ' ' + test_when_finished git switch master && + test_must_fail git switch --no-guess foo && + git switch foo && + echo refs/heads/foo >expected && + git symbolic-ref HEAD >actual && + test_cmp expected actual +' + +test_expect_success 'not switching when something is in progress' ' + test_when_finished rm -f .git/MERGE_HEAD && + # fake a merge-in-progress + cp .git/HEAD .git/MERGE_HEAD && + test_must_fail git switch -d @^ +' + +test_done
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 26/27 completion: support switch
In reply to Nguyễn Thái Ngọc DuyCompletion support for --guess could be made better. If no --detach is given, we should only provide a list of refs/heads/* and dwim ones, not the entire ref space. But I still can't penetrate that __git_refs() function yet.
--- contrib/completion/git-completion.bash | 37 +++++++++++++++++++++++++- 1 file changed, 36 insertions(+), 1 deletion(-)
contrib/completion/git-completion.bash +36 -1
@@ -37,7 +37,8 @@ # GIT_COMPLETION_CHECKOUT_NO_GUESS # # When set to "1", do not include "DWIM" suggestions in git-checkout -# completion (e.g., completing "foo" when "origin/foo" exists). +# and git-switch completion (e.g., completing "foo" when "origin/foo" +# exists). case "$COMP_WORDBREAKS" in *:*) : great ;;
@@ -2158,6 +2159,40 @@ _git_status () __git_complete_index_file "$complete_opt" } +_git_switch () +{ + case "$cur" in + --conflict=*) + __gitcomp "diff3 merge" "" "${cur##--conflict=}" + ;; + --*) + __gitcomp_builtin switch + ;; + *) + # check if --track, --no-track, or --no-guess was specified + # if so, disable DWIM mode + local track_opt="--track" only_local_ref=n + if [ "$GIT_COMPLETION_CHECKOUT_NO_GUESS" = "1" ] || + [ -n "$(__git_find_on_cmdline "--track --no-track --no-guess")" ]; then + track_opt='' + fi + # explicit --guess enables DWIM mode regardless of + # $GIT_COMPLETION_CHECKOUT_NO_GUESS + if [ -n "$(__git_find_on_cmdline "--guess")" ]; then + track_opt='--track' + fi + if [ -z "$(__git_find_on_cmdline "-d --detach")" ]; then + only_local_ref=y + fi + if [ $only_local_ref = y -a -z "$track_opt" ]; then + __gitcomp_direct "$(__git_heads "" "$cur" " ")" + else + __git_complete_refs $track_opt + fi + ;; + esac +} + __git_config_get_set_variables () { local prevword word config_file= c=$cword
Signature · 1 line
2.21.0.479.g47ac719cd3
PATCH v6 27/27 doc: promote "git switch"
In reply to Nguyễn Thái Ngọc DuyThe new command "git switch" is added to avoid the confusion of one-command-do-all "git checkout" for new users. They are also helpful to avoid ambiguation context.
For these reasons, promote it everywhere possible. This includes documentation, suggestions/advice from other commands...
The "Checking out files" progress line in unpack-trees.c is also updated to "Updating files" to be neutral to both git-checkout and git-switch.
--- Documentation/git-branch.txt | 12 +++--- Documentation/git-check-ref-format.txt | 3 +- Documentation/git-format-patch.txt | 2 +- Documentation/git-merge-base.txt | 2 +- Documentation/git-rebase.txt | 2 +- Documentation/git-remote.txt | 2 +- Documentation/git-rerere.txt | 10 ++--- Documentation/git-reset.txt | 20 ++++----- Documentation/git-stash.txt | 9 +++-- Documentation/gitcore-tutorial.txt | 19 +++++---- Documentation/giteveryday.txt | 24 +++++------ Documentation/gittutorial.txt | 4 +- Documentation/gitworkflows.txt | 3 +- Documentation/revisions.txt | 2 +- Documentation/user-manual.txt | 56 +++++++++++++------------- advice.c | 12 +++--- sha1-name.c | 2 +- t/t2020-checkout-detach.sh | 24 +++++------ unpack-trees.c | 2 +- 19 files changed, 105 insertions(+), 105 deletions(-)
Documentation/git-branch.txt +6 -6
@@ -48,7 +48,7 @@ The command's second form creates a new branch head named <branchname> which points to the current `HEAD`, or <start-point> if given. Note that this will create the new branch, but it will not switch the -working tree to it; use "git checkout <newbranch>" to switch to the +working tree to it; use "git switch <newbranch>" to switch to the new branch. When a local branch is started off a remote-tracking branch, Git sets up the
@@ -198,7 +198,7 @@ This option is only applicable in non-verbose mode. + This behavior is the default when the start point is a remote-tracking branch. Set the branch.autoSetupMerge configuration variable to `false` if you -want `git checkout` and `git branch` to always behave as if `--no-track` +want `git switch`, `git checkout` and `git branch` to always behave as if `--no-track` were given. Set it to `always` if you want this behavior when the start-point is either a local or remote-tracking branch.
@@ -297,7 +297,7 @@ Start development from a known tag:: $ git clone git://git.kernel.org/pub/scm/.../linux-2.6 my2.6 $ cd my2.6 $ git branch my2.6.14 v2.6.14 <1> -$ git checkout my2.6.14 +$ git switch my2.6.14 ------------ + <1> This step and the next one could be combined into a single step with
@@ -322,9 +322,9 @@ $ git branch -D test <2> NOTES ----- -If you are creating a branch that you want to checkout immediately, it is -easier to use the git checkout command with its `-b` option to create -a branch and check it out with a single command. +If you are creating a branch that you want to switch to immediately, +it is easier to use the "git switch" command with its `-c` option to +do the same thing with a single command. The options `--contains`, `--no-contains`, `--merged` and `--no-merged` serve four related but different purposes:
Documentation/git-check-ref-format.txt +2 -1
@@ -88,7 +88,8 @@ but it is explicitly forbidden at the beginning of a branch name). When run with `--branch` option in a repository, the input is first expanded for the ``previous checkout syntax'' `@{-n}`. For example, `@{-1}` is a way to refer the last thing that -was checked out using "git checkout" operation. This option should be +was checked out using "git switch" or "git checkout" operation. +This option should be used by porcelains to accept this syntax anywhere a branch name is expected, so they can act as if you typed the branch name. As an exception note that, the ``previous checkout operation'' might result
Documentation/git-format-patch.txt +1 -1
@@ -421,7 +421,7 @@ One way to test if your MUA is set up correctly is: * Apply it: $ git fetch <project> master:test-apply - $ git checkout test-apply + $ git switch test-apply $ git reset --hard $ git am a.patch
Documentation/git-merge-base.txt +1 -1
@@ -149,7 +149,7 @@ instead. Discussion on fork-point mode ----------------------------- -After working on the `topic` branch created with `git checkout -b +After working on the `topic` branch created with `git switch -c topic origin/master`, the history of remote-tracking branch `origin/master` may have been rewound and rebuilt, leading to a history of this shape:
Documentation/git-rebase.txt +1 -1
@@ -17,7 +17,7 @@ SYNOPSIS DESCRIPTION ----------- If <branch> is specified, 'git rebase' will perform an automatic -`git checkout <branch>` before doing anything else. Otherwise +`git switch <branch>` before doing anything else. Otherwise it remains on the current branch. If <upstream> is not specified, the upstream configured in
Documentation/git-remote.txt +1 -1
@@ -230,7 +230,7 @@ $ git branch -r staging/master staging/staging-linus staging/staging-next -$ git checkout -b staging staging/master +$ git switch -c staging staging/master ... ------------
Documentation/git-rerere.txt +5 -5
@@ -91,7 +91,7 @@ For such a test, you need to merge master and topic somehow. One way to do it is to pull master into the topic branch: ------------ - $ git checkout topic + $ git switch topic $ git merge master o---*---o---+ topic
@@ -113,10 +113,10 @@ the upstream might have been advanced since the test merge `+`, in which case the final commit graph would look like this: ------------ - $ git checkout topic + $ git switch topic $ git merge master $ ... work on both topic and master branches - $ git checkout master + $ git switch master $ git merge topic o---*---o---+---o---o topic
@@ -136,11 +136,11 @@ merges, you could blow away the test merge, and keep building on top of the tip before the test merge: ------------ - $ git checkout topic + $ git switch topic $ git merge master $ git reset --hard HEAD^ ;# rewind the test merge $ ... work on both topic and master branches - $ git checkout master + $ git switch master $ git merge topic o---*---o-------o---o topic
Documentation/git-reset.txt +10 -10
@@ -149,9 +149,9 @@ See also the `--amend` option to linkgit:git-commit[1]. Undo a commit, making it a topic branch:: + ------------ -$ git branch topic/wip <1> -$ git reset --hard HEAD~3 <2> -$ git checkout topic/wip <3> +$ git branch topic/wip <1> +$ git reset --hard HEAD~3 <2> +$ git switch topic/wip <3> ------------ + <1> You have made some commits, but realize they were premature
@@ -232,13 +232,13 @@ working tree are not in any shape to be committed yet, but you need to get to the other branch for a quick bugfix. + ------------ -$ git checkout feature ;# you were working in "feature" branch and -$ work work work ;# got interrupted +$ git switch feature ;# you were working in "feature" branch and +$ work work work ;# got interrupted $ git commit -a -m "snapshot WIP" <1> -$ git checkout master +$ git switch master $ fix fix fix $ git commit ;# commit with real log -$ git checkout feature +$ git switch feature $ git reset --soft HEAD^ ;# go back to WIP state <2> $ git reset <3> ------------
@@ -279,18 +279,18 @@ reset it while keeping the changes in your working tree. + ------------ $ git tag start -$ git checkout -b branch1 +$ git switch -c branch1 $ edit $ git commit ... <1> $ edit -$ git checkout -b branch2 <2> +$ git switch -c branch2 <2> $ git reset --keep start <3> ------------ + <1> This commits your first edits in `branch1`. <2> In the ideal world, you could have realized that the earlier commit did not belong to the new topic when you created and switched - to `branch2` (i.e. `git checkout -b branch2 start`), but nobody is + to `branch2` (i.e. `git switch -c branch2 start`), but nobody is perfect. <3> But you can use `reset --keep` to remove the unwanted commit after you switched to `branch2`.
Documentation/git-stash.txt +5 -4
@@ -235,12 +235,12 @@ return to your original branch to make the emergency fix, like this: + ---------------------------------------------------------------- # ... hack hack hack ... -$ git checkout -b my_wip +$ git switch -c my_wip $ git commit -a -m "WIP" -$ git checkout master +$ git switch master $ edit emergency fix $ git commit -a -m "Fix in a hurry" -$ git checkout my_wip +$ git switch my_wip $ git reset --soft HEAD^ # ... continue hacking ... ----------------------------------------------------------------
@@ -293,7 +293,8 @@ SEE ALSO linkgit:git-checkout[1], linkgit:git-commit[1], linkgit:git-reflog[1], -linkgit:git-reset[1] +linkgit:git-reset[1], +linkgit:git-switch[1] GIT ---
Documentation/gitcore-tutorial.txt +9 -10
@@ -741,7 +741,7 @@ used earlier, and create a branch in it. You do that by simply just saying that you want to check out a new branch: ------------ -$ git checkout -b mybranch +$ git switch -c mybranch ------------ will create a new branch based at the current `HEAD` position, and switch
@@ -755,7 +755,7 @@ just telling 'git checkout' what the base of the checkout would be. In other words, if you have an earlier tag or branch, you'd just do ------------ -$ git checkout -b mybranch earlier-commit +$ git switch -c mybranch earlier-commit ------------ and it would create the new branch `mybranch` at the earlier commit,
@@ -765,7 +765,7 @@ and check out the state at that time. You can always just jump back to your original `master` branch by doing ------------ -$ git checkout master +$ git switch master ------------ (or any other branch-name, for that matter) and if you forget which
@@ -794,7 +794,7 @@ $ git branch <branchname> [startingpoint] which will simply _create_ the branch, but will not do anything further. You can then later -- once you decide that you want to actually develop -on that branch -- switch to that branch with a regular 'git checkout' +on that branch -- switch to that branch with a regular 'git switch' with the branchname as the argument.
@@ -808,7 +808,7 @@ being the same as the original `master` branch, let's make sure we're in that branch, and do some work there. ------------------------------------------------ -$ git checkout mybranch +$ git switch mybranch $ echo "Work, work, work" >>hello $ git commit -m "Some work." -i hello ------------------------------------------------
@@ -825,7 +825,7 @@ does some work in the original branch, and simulate that by going back to the master branch, and editing the same file differently there: ------------ -$ git checkout master +$ git switch master ------------ Here, take a moment to look at the contents of `hello`, and notice how they
@@ -958,7 +958,7 @@ to the `master` branch. Let's go back to `mybranch`, and run 'git merge' to get the "upstream changes" back to your branch. ------------ -$ git checkout mybranch +$ git switch mybranch $ git merge -m "Merge upstream changes." master ------------
@@ -1133,9 +1133,8 @@ Remember, before running 'git merge', our `master` head was at work." commit. ------------ -$ git checkout mybranch -$ git reset --hard master^2 -$ git checkout master +$ git switch -C mybranch master^2 +$ git switch master $ git reset --hard master^ ------------
Documentation/giteveryday.txt +12 -12
@@ -41,7 +41,7 @@ following commands. * linkgit:git-log[1] to see what happened. - * linkgit:git-checkout[1] and linkgit:git-branch[1] to switch + * linkgit:git-switch[1] and linkgit:git-branch[1] to switch branches. * linkgit:git-add[1] to manage the index file.
@@ -80,7 +80,7 @@ $ git tag v2.43 <2> Create a topic branch and develop.:: + ------------ -$ git checkout -b alsa-audio <1> +$ git switch -c alsa-audio <1> $ edit/compile/test $ git checkout -- curses/ux_audio_oss.c <2> $ git add curses/ux_audio_alsa.c <3>
@@ -90,7 +90,7 @@ $ git commit -a -s <5> $ edit/compile/test $ git diff HEAD^ <6> $ git commit -a --amend <7> -$ git checkout master <8> +$ git switch master <8> $ git merge alsa-audio <9> $ git log --since='3 days ago' <10> $ git log v2.43.. curses/ <11>
@@ -148,11 +148,11 @@ Clone the upstream and work on it. Feed changes to upstream.:: ------------ $ git clone git://git.kernel.org/pub/scm/.../torvalds/linux-2.6 my2.6 $ cd my2.6 -$ git checkout -b mine master <1> +$ git switch -c mine master <1> $ edit/compile/test; git commit -a -s <2> $ git format-patch master <3> $ git send-email --to="person <[email protected]>" 00*.patch <4> -$ git checkout master <5> +$ git switch master <5> $ git pull <6> $ git log -p ORIG_HEAD.. arch/i386 include/asm-i386 <7> $ git ls-remote --heads http://git.kernel.org/.../jgarzik/libata-dev.git <8>
@@ -194,7 +194,7 @@ satellite$ edit/compile/test/commit satellite$ git push origin <4> mothership$ cd frotz -mothership$ git checkout master +mothership$ git switch master mothership$ git merge satellite/master <5> ------------ +
@@ -216,7 +216,7 @@ machine into the master branch. Branch off of a specific tag.:: + ------------ -$ git checkout -b private2.6.14 v2.6.14 <1> +$ git switch -c private2.6.14 v2.6.14 <1> $ edit/compile/test; git commit -a $ git checkout master $ git cherry-pick v2.6.14..private2.6.14 <2>
@@ -274,14 +274,14 @@ $ mailx <3> & s 2 3 4 5 ./+to-apply & s 7 8 ./+hold-linus & q -$ git checkout -b topic/one master +$ git switch -c topic/one master $ git am -3 -i -s ./+to-apply <4> $ compile/test -$ git checkout -b hold/linus && git am -3 -i -s ./+hold-linus <5> -$ git checkout topic/one && git rebase master <6> -$ git checkout pu && git reset --hard next <7> +$ git switch -c hold/linus && git am -3 -i -s ./+hold-linus <5> +$ git switch topic/one && git rebase master <6> +$ git switch -C pu next <7> $ git merge topic/one topic/two && git merge hold/linus <8> -$ git checkout maint +$ git switch maint $ git cherry-pick master~4 <9> $ compile/test $ git tag -s -m "GIT 0.99.9x" v0.99.9x <10>
Documentation/gittutorial.txt +2 -2
@@ -207,7 +207,7 @@ automatically. The asterisk marks the branch you are currently on; type ------------------------------------------------ -$ git checkout experimental +$ git switch experimental ------------------------------------------------ to switch to the experimental branch. Now edit a file, commit the
@@ -216,7 +216,7 @@ change, and switch back to the master branch: ------------------------------------------------ (edit file) $ git commit -a -$ git checkout master +$ git switch master ------------------------------------------------ Check that the change you made is no longer visible, since it was
Documentation/gitworkflows.txt +1 -2
@@ -301,8 +301,7 @@ topics on 'next': .Rewind and rebuild next [caption="Recipe: "] ===================================== -* `git checkout next` -* `git reset --hard master` +* `git switch -C next master` * `git merge ai/topic_in_next1` * `git merge ai/topic_in_next2` * ...
Documentation/revisions.txt +1 -1
@@ -115,7 +115,7 @@ Here's an example to make it more clear: ------------------------------ $ git config push.default current $ git config remote.pushdefault myfork -$ git checkout -b mybranch origin/master +$ git switch -c mybranch origin/master $ git rev-parse --symbolic-full-name @{upstream} refs/remotes/origin/master
Documentation/user-manual.txt +28 -28
164 lines not on this page · raw message
advice.c +6 -6
@@ -191,20 +191,20 @@ void NORETURN die_conclude_merge(void)void detach_advice (const char *new_name) {const char *fmt = -_ ("Note: checking out '%s'.\n" +_ ("Note: switching to '%s'.\n" "\n" "You are in 'detached HEAD' state. You can look around, make experimental\n" "changes and commit them, and you can discard any commits you make in this\n" -"state without impacting any branches by performing another checkout.\n" +"state without impacting any branches by switching back to a branch.\n" "\n" "If you want to create a new branch to retain commits you create, you may\n" -"do so (now or later) by using -b with the checkout command again. Example:\n" +"do so (now or later) by using -c with the switch command. Example:\n" "\n" -" git checkout -b <new-branch-name>\n" +" git switch -c <new-branch-name>\n" "\n" -"Or undo this checkout with:\n" +"Or undo this operation with:\n" "\n" -" git checkout -\n" +" git switch -\n" "\n" "Turn off this advice by setting config variable advice.detachedHead to false\n\n" );
sha1-name.c +1 -1
@@ -743,7 +743,7 @@ static int get_oid_basic(const char *str, int len, struct object_id *oid,"because it will be ignored when you just specify 40-hex. These refs\n" "may be created by mistake. For example,\n" "\n" -" git checkout -b $br $(git rev-parse ...)\n" +" git switch -c $br $(git rev-parse ...)\n" "\n" "where \"$br\" is somehow empty and a 40-hex ref is created. Please\n" "examine these refs and maybe delete them. Turn this message off by\n"
t/t2020-checkout-detach.sh +12 -12
@@ -195,20 +195,20 @@ test_expect_success 'describe_detached_head prints no SHA-1 ellipsis when not as # The first detach operation is more chatty than the following ones. cat >1st_detach <<-EOF && - Note: checking out 'HEAD^'. + Note: switching to 'HEAD^'. You are in 'detached HEAD' state. You can look around, make experimental changes and commit them, and you can discard any commits you make in this - state without impacting any branches by performing another checkout. + state without impacting any branches by switching back to a branch. If you want to create a new branch to retain commits you create, you may - do so (now or later) by using -b with the checkout command again. Example: + do so (now or later) by using -c with the switch command. Example: - git checkout -b <new-branch-name> + git switch -c <new-branch-name> - Or undo this checkout with: + Or undo this operation with: - git checkout - + git switch - Turn off this advice by setting config variable advice.detachedHead to false
@@ -277,20 +277,20 @@ test_expect_success 'describe_detached_head does print SHA-1 ellipsis when asked # The first detach operation is more chatty than the following ones. cat >1st_detach <<-EOF && - Note: checking out 'HEAD^'. + Note: switching to 'HEAD^'. You are in 'detached HEAD' state. You can look around, make experimental changes and commit them, and you can discard any commits you make in this - state without impacting any branches by performing another checkout. + state without impacting any branches by switching back to a branch. If you want to create a new branch to retain commits you create, you may - do so (now or later) by using -b with the checkout command again. Example: + do so (now or later) by using -c with the switch command. Example: - git checkout -b <new-branch-name> + git switch -c <new-branch-name> - Or undo this checkout with: + Or undo this operation with: - git checkout - + git switch - Turn off this advice by setting config variable advice.detachedHead to false
unpack-trees.c +1 -1
@@ -313,7 +313,7 @@ static struct progress *get_progress(struct unpack_trees_options *o) total++; } -return start_delayed_progress (_ ("Checking out files" ), total); +return start_delayed_progress (_ ("Updating files" ), total); } static void setup_collided_checkout_detection(struct checkout *state,
Signature · 1 line
2.21.0.479.g47ac719cd3
Re: [PATCH v6 00/27] Add new command 'switch'
In reply to Nguyễn Thái Ngọc DuyQuoted 13 lines · Nguyễn Thái Ngọc Duy
This adds a new command 'git-switch' as the half-replacement for 'git-checkout'. Jump to 13/27 as the starting point. The other half is git-restore, which is dealt with separately.
The sixth time must be the charm, because the seventh time may be the curse!
The last big change since v5 is from the discussion about
remove_branch_state()and its relation with --ignore-in-progress. By popular demand, --ignore-in-progress is gone. The discussion is linked in 23/27, which is also improved to suggest a way out.
Quoted 5 lines
That discussion also leads to a new patch, 07/27, which improves 'git checkout' and tells the user when merge/revert/cherry-pick is canceled.
The rest is just minor updates here and there. And I made sure the sign-off is back this time :D
I looked through the range-diff and it looks good to me. I think the safety we added to switch could also be added to checkout, and I think we're narrowing down on how to safely support --ignore-in-progress in certain situations, but both of those things could go in after this series lands...and both might generate more discussion that doesn't need to derail the rest of this series.