averello/git-mirror
1
0
Fork 0
mirror of https://github.com/git/git.git synced 2025-12-12 20:36:24 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'ps/history' into seen

Browse Source 
"git history" history rewriting UI.

Ready?

* ps/history:
  builtin/history: implement "split" subcommand
  cache-tree: allow writing in-memory index as tree
  add-patch: allow disabling editing of hunks
  add-patch: add support for in-memory index patching
  add-patch: remove dependency on "add-interactive" subsystem
  add-patch: split out `struct interactive_options`
  add-patch: split out header from "add-interactive.h"
  builtin/history: implement "reword" subcommand
  builtin: add new "history" command
  replay: stop using `the_repository`
  replay: extract logic to pick commits
  wt-status: provide function to expose status for trees
This commit is contained in:
Junio C Hamano
2025-12-12 22:11:50 +09:00
parent 6f23a2b952 d37c42ea66
commit 7ce315ce25
30 changed files with 2014 additions and 395 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -79,6 +79,7 @@
/git-grep
/git-hash-object
/git-help
/git-history
/git-hook
/git-http-backend
/git-http-fetch

109
Documentation/git-history.adoc Normal file
View File

@@ -0,0 +1,109 @@
git-history(1)
==============
NAME
----
git-history - EXPERIMENTAL: Rewrite history of the current branch
SYNOPSIS
--------
[synopsis]
git history reword <commit>
git history split <commit> [--] [<pathspec>...]
DESCRIPTION
-----------
Rewrite history by rearranging or modifying specific commits in the
history.
THIS COMMAND IS EXPERIMENTAL. THE BEHAVIOR MAY CHANGE.
This command is related to linkgit:git-rebase[1] in that both commands can be
used to rewrite history. You should use rebases if you want to reapply a range
of commits onto a different base, or interactive rebases if you want to edit a
range of commits.
Note that this command does not (yet) work with histories that contain
merges. You should use linkgit:git-rebase[1] with the `--rebase-merges`
flag instead.
COMMANDS
--------
Several commands are available to rewrite history in different ways:
`reword <commit>`::
Rewrite the commit message of the specified commit. All the other
details of this commit remain unchanged. This command will spawn an
editor with the current message of that commit.
`split <commit> [--] [<pathspec>...]`::
Interactively split up <commit> into two commits by choosing
hunks introduced by it that will be moved into the new split-out
commit. These hunks will then be written into a new commit that
becomes the parent of the previous commit. The original commit
stays intact, except that its parent will be the newly split-out
commit.
+
The commit messages of the split-up commits will be asked for by launching
the configured editor. Authorship of the commit will be the same as for the
original commit.
+
If passed, _<pathspec>_ can be used to limit which changes shall be split out
of the original commit. Files not matching any of the pathspecs will remain
part of the original commit. For more details, see the 'pathspec' entry in
linkgit:gitglossary[7].
+
It is invalid to select either all or no hunks, as that would lead to
one of the commits becoming empty.
CONFIGURATION
-------------
include::includes/cmd-config-section-all.adoc[]
EXAMPLES
--------
Split a commit
~~~~~~~~~~~~~~
----------
$ git log --stat --oneline
3f81232 (HEAD -> main) original
bar | 1 +
foo | 1 +
2 files changed, 2 insertions(+)
$ git history split HEAD
diff --git a/bar b/bar
new file mode 100644
index 0000000..5716ca5
--- /dev/null
+++ b/bar
@@ -0,0 +1 @@
+bar
(1/1) Stage addition [y,n,q,a,d,e,p,?]? y
diff --git a/foo b/foo
new file mode 100644
index 0000000..257cc56
--- /dev/null
+++ b/foo
@@ -0,0 +1 @@
+foo
(1/1) Stage addition [y,n,q,a,d,e,p,?]? n
$ git log --stat --oneline
7cebe64 (HEAD -> main) original
foo | 1 +
1 file changed, 1 insertion(+)
d1582f3 split-out commit
bar | 1 +
1 file changed, 1 insertion(+)
----------
GIT
---
Part of the linkgit:git[1] suite

1
Documentation/meson.build
View File

@@ -64,6 +64,7 @@ manpages = {
'git-gui.adoc' : 1,
'git-hash-object.adoc' : 1,
'git-help.adoc' : 1,
'git-history.adoc' : 1,
'git-hook.adoc' : 1,
'git-http-backend.adoc' : 1,
'git-http-fetch.adoc' : 1,

2
Makefile
View File

@@ -1276,6 +1276,7 @@ LIB_OBJS += repack-geometry.o
LIB_OBJS += repack-midx.o
LIB_OBJS += repack-promisor.o
LIB_OBJS += replace-object.o
LIB_OBJS += replay.o
LIB_OBJS += repo-settings.o
LIB_OBJS += repository.o
LIB_OBJS += rerere.o
@@ -1408,6 +1409,7 @@ BUILTIN_OBJS += builtin/get-tar-commit-id.o
BUILTIN_OBJS += builtin/grep.o
BUILTIN_OBJS += builtin/hash-object.o
BUILTIN_OBJS += builtin/help.o
BUILTIN_OBJS += builtin/history.o
BUILTIN_OBJS += builtin/hook.o
BUILTIN_OBJS += builtin/index-pack.o
BUILTIN_OBJS += builtin/init-db.o

174
add-interactive.c
View File

@@ -3,7 +3,6 @@
#include "git-compat-util.h"
#include "add-interactive.h"
#include "color.h"
#include "config.h"
#include "diffcore.h"
#include "gettext.h"
#include "hash.h"
@@ -20,119 +19,18 @@
#include "prompt.h"
#include "tree.h"
static void init_color(struct repository *r, enum git_colorbool use_color,
const char *section_and_slot, char *dst,
const char *default_color)
{
char *key = xstrfmt("color.%s", section_and_slot);
const char *value;
if (!want_color(use_color))
dst[0] = '\0';
else if (repo_config_get_value(r, key, &value) ||
color_parse(value, dst))
strlcpy(dst, default_color, COLOR_MAXLEN);
free(key);
}
static enum git_colorbool check_color_config(struct repository *r, const char *var)
{
const char *value;
enum git_colorbool ret;
if (repo_config_get_value(r, var, &value))
ret = GIT_COLOR_UNKNOWN;
else
ret = git_config_colorbool(var, value);
/*
* Do not rely on want_color() to fall back to color.ui for us. It uses
* the value parsed by git_color_config(), which may not have been
* called by the main command.
*/
if (ret == GIT_COLOR_UNKNOWN &&
!repo_config_get_value(r, "color.ui", &value))
ret = git_config_colorbool("color.ui", value);
return ret;
}
void init_add_i_state(struct add_i_state *s, struct repository *r,
struct add_p_opt *add_p_opt)
struct interactive_options *opts)
{
s->r = r;
s->context = -1;
s->interhunkcontext = -1;
s->use_color_interactive = check_color_config(r, "color.interactive");
init_color(r, s->use_color_interactive, "interactive.header",
s->header_color, GIT_COLOR_BOLD);
init_color(r, s->use_color_interactive, "interactive.help",
s->help_color, GIT_COLOR_BOLD_RED);
init_color(r, s->use_color_interactive, "interactive.prompt",
s->prompt_color, GIT_COLOR_BOLD_BLUE);
init_color(r, s->use_color_interactive, "interactive.error",
s->error_color, GIT_COLOR_BOLD_RED);
strlcpy(s->reset_color_interactive,
want_color(s->use_color_interactive) ? GIT_COLOR_RESET : "", COLOR_MAXLEN);
s->use_color_diff = check_color_config(r, "color.diff");
init_color(r, s->use_color_diff, "diff.frag", s->fraginfo_color,
diff_get_color(s->use_color_diff, DIFF_FRAGINFO));
init_color(r, s->use_color_diff, "diff.context", s->context_color,
"fall back");
if (!strcmp(s->context_color, "fall back"))
init_color(r, s->use_color_diff, "diff.plain",
s->context_color,
diff_get_color(s->use_color_diff, DIFF_CONTEXT));
init_color(r, s->use_color_diff, "diff.old", s->file_old_color,
diff_get_color(s->use_color_diff, DIFF_FILE_OLD));
init_color(r, s->use_color_diff, "diff.new", s->file_new_color,
diff_get_color(s->use_color_diff, DIFF_FILE_NEW));
strlcpy(s->reset_color_diff,
want_color(s->use_color_diff) ? GIT_COLOR_RESET : "", COLOR_MAXLEN);
FREE_AND_NULL(s->interactive_diff_filter);
repo_config_get_string(r, "interactive.difffilter",
&s->interactive_diff_filter);
FREE_AND_NULL(s->interactive_diff_algorithm);
repo_config_get_string(r, "diff.algorithm",
&s->interactive_diff_algorithm);
if (!repo_config_get_int(r, "diff.context", &s->context))
if (s->context < 0)
die(_("%s cannot be negative"), "diff.context");
if (!repo_config_get_int(r, "diff.interHunkContext", &s->interhunkcontext))
if (s->interhunkcontext < 0)
die(_("%s cannot be negative"), "diff.interHunkContext");
repo_config_get_bool(r, "interactive.singlekey", &s->use_single_key);
if (s->use_single_key)
setbuf(stdin, NULL);
if (add_p_opt->context != -1) {
if (add_p_opt->context < 0)
die(_("%s cannot be negative"), "--unified");
s->context = add_p_opt->context;
}
if (add_p_opt->interhunkcontext != -1) {
if (add_p_opt->interhunkcontext < 0)
die(_("%s cannot be negative"), "--inter-hunk-context");
s->interhunkcontext = add_p_opt->interhunkcontext;
}
interactive_config_init(&s->cfg, r, opts);
}
void clear_add_i_state(struct add_i_state *s)
{
FREE_AND_NULL(s->interactive_diff_filter);
FREE_AND_NULL(s->interactive_diff_algorithm);
interactive_config_clear(&s->cfg);
memset(s, 0, sizeof(*s));
s->use_color_interactive = GIT_COLOR_UNKNOWN;
s->use_color_diff = GIT_COLOR_UNKNOWN;
interactive_config_clear(&s->cfg);
}
/*
@@ -286,7 +184,7 @@ static void list(struct add_i_state *s, struct string_list *list, int *selected,
return;
if (opts->header)
color_fprintf_ln(stdout, s->header_color,
color_fprintf_ln(stdout, s->cfg.header_color,
"%s", opts->header);
for (i = 0; i < list->nr; i++) {
@@ -354,7 +252,7 @@ static ssize_t list_and_choose(struct add_i_state *s,
list(s, &items->items, items->selected, &opts->list_opts);
color_fprintf(stdout, s->prompt_color, "%s", opts->prompt);
color_fprintf(stdout, s->cfg.prompt_color, "%s", opts->prompt);
fputs(singleton ? "> " : ">> ", stdout);
fflush(stdout);
@@ -432,7 +330,7 @@ static ssize_t list_and_choose(struct add_i_state *s,
if (from < 0 || from >= items->items.nr ||
(singleton && from + 1 != to)) {
color_fprintf_ln(stderr, s->error_color,
color_fprintf_ln(stderr, s->cfg.error_color,
_("Huh (%s)?"), p);
break;
} else if (singleton) {
@@ -992,7 +890,7 @@ static int run_patch(struct add_i_state *s, const struct pathspec *ps,
free(files->items.items[i].string);
} else if (item->index.unmerged ||
item->worktree.unmerged) {
color_fprintf_ln(stderr, s->error_color,
color_fprintf_ln(stderr, s->cfg.error_color,
_("ignoring unmerged: %s"),
files->items.items[i].string);
free(item);
@@ -1014,9 +912,9 @@ static int run_patch(struct add_i_state *s, const struct pathspec *ps,
opts->prompt = N_("Patch update");
count = list_and_choose(s, files, opts);
if (count > 0) {
struct add_p_opt add_p_opt = {
.context = s->context,
.interhunkcontext = s->interhunkcontext,
struct interactive_options opts = {
.context = s->cfg.context,
.interhunkcontext = s->cfg.interhunkcontext,
};
struct strvec args = STRVEC_INIT;
struct pathspec ps_selected = { 0 };
@@ -1028,7 +926,7 @@ static int run_patch(struct add_i_state *s, const struct pathspec *ps,
parse_pathspec(&ps_selected,
PATHSPEC_ALL_MAGIC & ~PATHSPEC_LITERAL,
PATHSPEC_LITERAL_PATH, "", args.v);
res = run_add_p(s->r, ADD_P_ADD, &add_p_opt, NULL, &ps_selected);
res = run_add_p(s->r, ADD_P_ADD, &opts, NULL, &ps_selected, 0);
strvec_clear(&args);
clear_pathspec(&ps_selected);
}
@@ -1064,10 +962,10 @@ static int run_diff(struct add_i_state *s, const struct pathspec *ps,
struct child_process cmd = CHILD_PROCESS_INIT;
strvec_pushl(&cmd.args, "git", "diff", "-p", "--cached", NULL);
if (s->context != -1)
strvec_pushf(&cmd.args, "--unified=%i", s->context);
if (s->interhunkcontext != -1)
strvec_pushf(&cmd.args, "--inter-hunk-context=%i", s->interhunkcontext);
if (s->cfg.context != -1)
strvec_pushf(&cmd.args, "--unified=%i", s->cfg.context);
if (s->cfg.interhunkcontext != -1)
strvec_pushf(&cmd.args, "--inter-hunk-context=%i", s->cfg.interhunkcontext);
strvec_pushl(&cmd.args, oid_to_hex(!is_initial ? &oid :
s->r->hash_algo->empty_tree), "--", NULL);
for (i = 0; i < files->items.nr; i++)
@@ -1085,17 +983,17 @@ static int run_help(struct add_i_state *s, const struct pathspec *ps UNUSED,
struct prefix_item_list *files UNUSED,
struct list_and_choose_options *opts UNUSED)
{
color_fprintf_ln(stdout, s->help_color, "status - %s",
color_fprintf_ln(stdout, s->cfg.help_color, "status - %s",
_("show paths with changes"));
color_fprintf_ln(stdout, s->help_color, "update - %s",
color_fprintf_ln(stdout, s->cfg.help_color, "update - %s",
_("add working tree state to the staged set of changes"));
color_fprintf_ln(stdout, s->help_color, "revert - %s",
color_fprintf_ln(stdout, s->cfg.help_color, "revert - %s",
_("revert staged set of changes back to the HEAD version"));
color_fprintf_ln(stdout, s->help_color, "patch - %s",
color_fprintf_ln(stdout, s->cfg.help_color, "patch - %s",
_("pick hunks and update selectively"));
color_fprintf_ln(stdout, s->help_color, "diff - %s",
color_fprintf_ln(stdout, s->cfg.help_color, "diff - %s",
_("view diff between HEAD and index"));
color_fprintf_ln(stdout, s->help_color, "add untracked - %s",
color_fprintf_ln(stdout, s->cfg.help_color, "add untracked - %s",
_("add contents of untracked files to the staged set of changes"));
return 0;
@@ -1103,21 +1001,21 @@ static int run_help(struct add_i_state *s, const struct pathspec *ps UNUSED,
static void choose_prompt_help(struct add_i_state *s)
{
color_fprintf_ln(stdout, s->help_color, "%s",
color_fprintf_ln(stdout, s->cfg.help_color, "%s",
_("Prompt help:"));
color_fprintf_ln(stdout, s->help_color, "1 - %s",
color_fprintf_ln(stdout, s->cfg.help_color, "1 - %s",
_("select a single item"));
color_fprintf_ln(stdout, s->help_color, "3-5 - %s",
color_fprintf_ln(stdout, s->cfg.help_color, "3-5 - %s",
_("select a range of items"));
color_fprintf_ln(stdout, s->help_color, "2-3,6-9 - %s",
color_fprintf_ln(stdout, s->cfg.help_color, "2-3,6-9 - %s",
_("select multiple ranges"));
color_fprintf_ln(stdout, s->help_color, "foo - %s",
color_fprintf_ln(stdout, s->cfg.help_color, "foo - %s",
_("select item based on unique prefix"));
color_fprintf_ln(stdout, s->help_color, "-... - %s",
color_fprintf_ln(stdout, s->cfg.help_color, "-... - %s",
_("unselect specified items"));
color_fprintf_ln(stdout, s->help_color, "* - %s",
color_fprintf_ln(stdout, s->cfg.help_color, "* - %s",
_("choose all items"));
color_fprintf_ln(stdout, s->help_color, " - %s",
color_fprintf_ln(stdout, s->cfg.help_color, " - %s",
_("(empty) finish selecting"));
}
@@ -1152,7 +1050,7 @@ static void print_command_item(int i, int selected UNUSED,
static void command_prompt_help(struct add_i_state *s)
{
const char *help_color = s->help_color;
const char *help_color = s->cfg.help_color;
color_fprintf_ln(stdout, help_color, "%s", _("Prompt help:"));
color_fprintf_ln(stdout, help_color, "1 - %s",
_("select a numbered item"));
@@ -1163,7 +1061,7 @@ static void command_prompt_help(struct add_i_state *s)
}
int run_add_i(struct repository *r, const struct pathspec *ps,
struct add_p_opt *add_p_opt)
struct interactive_options *interactive_opts)
{
struct add_i_state s = { NULL };
struct print_command_item_data data = { "[", "]" };
@@ -1206,15 +1104,15 @@ int run_add_i(struct repository *r, const struct pathspec *ps,
->util = util;
}
init_add_i_state(&s, r, add_p_opt);
init_add_i_state(&s, r, interactive_opts);
/*
* When color was asked for, use the prompt color for
* highlighting, otherwise use square brackets.
*/
if (want_color(s.use_color_interactive)) {
data.color = s.prompt_color;
data.reset = s.reset_color_interactive;
if (want_color(s.cfg.use_color_interactive)) {
data.color = s.cfg.prompt_color;
data.reset = s.cfg.reset_color_interactive;
}
print_file_item_data.color = data.color;
print_file_item_data.reset = data.reset;

46
add-interactive.h
View File

@@ -1,55 +1,21 @@
#ifndef ADD_INTERACTIVE_H
#define ADD_INTERACTIVE_H
#include "color.h"
#include "add-patch.h"
struct add_p_opt {
int context;
int interhunkcontext;
};
#define ADD_P_OPT_INIT { .context = -1, .interhunkcontext = -1 }
struct pathspec;
struct repository;
struct add_i_state {
struct repository *r;
enum git_colorbool use_color_interactive;
enum git_colorbool use_color_diff;
char header_color[COLOR_MAXLEN];
char help_color[COLOR_MAXLEN];
char prompt_color[COLOR_MAXLEN];
char error_color[COLOR_MAXLEN];
char reset_color_interactive[COLOR_MAXLEN];
char fraginfo_color[COLOR_MAXLEN];
char context_color[COLOR_MAXLEN];
char file_old_color[COLOR_MAXLEN];
char file_new_color[COLOR_MAXLEN];
char reset_color_diff[COLOR_MAXLEN];
int use_single_key;
char *interactive_diff_filter, *interactive_diff_algorithm;
int context, interhunkcontext;
struct interactive_config cfg;
};
void init_add_i_state(struct add_i_state *s, struct repository *r,
struct add_p_opt *add_p_opt);
struct interactive_options *opts);
void clear_add_i_state(struct add_i_state *s);
struct repository;
struct pathspec;
int run_add_i(struct repository *r, const struct pathspec *ps,
struct add_p_opt *add_p_opt);
enum add_p_mode {
ADD_P_ADD,
ADD_P_STASH,
ADD_P_RESET,
ADD_P_CHECKOUT,
ADD_P_WORKTREE,
};
int run_add_p(struct repository *r, enum add_p_mode mode,
struct add_p_opt *o, const char *revision,
const struct pathspec *ps);
struct interactive_options *opts);
#endif

335
add-patch.c
View File

@@ -2,11 +2,15 @@
#define DISABLE_SIGN_COMPARE_WARNINGS
#include "git-compat-util.h"
#include "add-interactive.h"
#include "add-patch.h"
#include "advice.h"
#include "commit.h"
#include "config.h"
#include "diff.h"
#include "editor.h"
#include "environment.h"
#include "gettext.h"
#include "hex.h"
#include "object-name.h"
#include "pager.h"
#include "read-cache-ll.h"
@@ -45,7 +49,7 @@ static struct patch_mode patch_mode_add = {
N_("Stage mode change [y,n,q,a,d%s,?]? "),
N_("Stage deletion [y,n,q,a,d%s,?]? "),
N_("Stage addition [y,n,q,a,d%s,?]? "),
N_("Stage this hunk [y,n,q,a,d%s,?]? ")
N_("Stage this hunk [y,n,q,a,d%s,?]? "),
},
.edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
"will immediately be marked for staging."),
@@ -260,7 +264,10 @@ struct hunk {
};
struct add_p_state {
struct add_i_state s;
struct repository *r;
struct index_state *index;
const char *index_file;
struct interactive_config cfg;
struct strbuf answer, buf;
/* parsed diff */
@@ -278,6 +285,122 @@ struct add_p_state {
const char *revision;
};
static void init_color(struct repository *r,
enum git_colorbool use_color,
const char *section_and_slot, char *dst,
const char *default_color)
{
char *key = xstrfmt("color.%s", section_and_slot);
const char *value;
if (!want_color(use_color))
dst[0] = '\0';
else if (repo_config_get_value(r, key, &value) ||
color_parse(value, dst))
strlcpy(dst, default_color, COLOR_MAXLEN);
free(key);
}
static enum git_colorbool check_color_config(struct repository *r, const char *var)
{
const char *value;
enum git_colorbool ret;
if (repo_config_get_value(r, var, &value))
ret = GIT_COLOR_UNKNOWN;
else
ret = git_config_colorbool(var, value);
/*
* Do not rely on want_color() to fall back to color.ui for us. It uses
* the value parsed by git_color_config(), which may not have been
* called by the main command.
*/
if (ret == GIT_COLOR_UNKNOWN &&
!repo_config_get_value(r, "color.ui", &value))
ret = git_config_colorbool("color.ui", value);
return ret;
}
void interactive_config_init(struct interactive_config *cfg,
struct repository *r,
struct interactive_options *opts)
{
cfg->context = -1;
cfg->interhunkcontext = -1;
cfg->use_color_interactive = check_color_config(r, "color.interactive");
init_color(r, cfg->use_color_interactive, "interactive.header",
cfg->header_color, GIT_COLOR_BOLD);
init_color(r, cfg->use_color_interactive, "interactive.help",
cfg->help_color, GIT_COLOR_BOLD_RED);
init_color(r, cfg->use_color_interactive, "interactive.prompt",
cfg->prompt_color, GIT_COLOR_BOLD_BLUE);
init_color(r, cfg->use_color_interactive, "interactive.error",
cfg->error_color, GIT_COLOR_BOLD_RED);
strlcpy(cfg->reset_color_interactive,
want_color(cfg->use_color_interactive) ? GIT_COLOR_RESET : "", COLOR_MAXLEN);
cfg->use_color_diff = check_color_config(r, "color.diff");
init_color(r, cfg->use_color_diff, "diff.frag", cfg->fraginfo_color,
diff_get_color(cfg->use_color_diff, DIFF_FRAGINFO));
init_color(r, cfg->use_color_diff, "diff.context", cfg->context_color,
"fall back");
if (!strcmp(cfg->context_color, "fall back"))
init_color(r, cfg->use_color_diff, "diff.plain",
cfg->context_color,
diff_get_color(cfg->use_color_diff, DIFF_CONTEXT));
init_color(r, cfg->use_color_diff, "diff.old", cfg->file_old_color,
diff_get_color(cfg->use_color_diff, DIFF_FILE_OLD));
init_color(r, cfg->use_color_diff, "diff.new", cfg->file_new_color,
diff_get_color(cfg->use_color_diff, DIFF_FILE_NEW));
strlcpy(cfg->reset_color_diff,
want_color(cfg->use_color_diff) ? GIT_COLOR_RESET : "", COLOR_MAXLEN);
FREE_AND_NULL(cfg->interactive_diff_filter);
repo_config_get_string(r, "interactive.difffilter",
&cfg->interactive_diff_filter);
FREE_AND_NULL(cfg->interactive_diff_algorithm);
repo_config_get_string(r, "diff.algorithm",
&cfg->interactive_diff_algorithm);
if (!repo_config_get_int(r, "diff.context", &cfg->context))
if (cfg->context < 0)
die(_("%s cannot be negative"), "diff.context");
if (!repo_config_get_int(r, "diff.interHunkContext", &cfg->interhunkcontext))
if (cfg->interhunkcontext < 0)
die(_("%s cannot be negative"), "diff.interHunkContext");
repo_config_get_bool(r, "interactive.singlekey", &cfg->use_single_key);
if (cfg->use_single_key)
setbuf(stdin, NULL);
if (opts->context != -1) {
if (opts->context < 0)
die(_("%s cannot be negative"), "--unified");
cfg->context = opts->context;
}
if (opts->interhunkcontext != -1) {
if (opts->interhunkcontext < 0)
die(_("%s cannot be negative"), "--inter-hunk-context");
cfg->interhunkcontext = opts->interhunkcontext;
}
}
void interactive_config_clear(struct interactive_config *cfg)
{
FREE_AND_NULL(cfg->interactive_diff_filter);
FREE_AND_NULL(cfg->interactive_diff_algorithm);
memset(cfg, 0, sizeof(*cfg));
cfg->use_color_interactive = GIT_COLOR_UNKNOWN;
cfg->use_color_diff = GIT_COLOR_UNKNOWN;
}
static void add_p_state_clear(struct add_p_state *s)
{
size_t i;
@@ -289,7 +412,7 @@ static void add_p_state_clear(struct add_p_state *s)
for (i = 0; i < s->file_diff_nr; i++)
free(s->file_diff[i].hunk);
free(s->file_diff);
clear_add_i_state(&s->s);
interactive_config_clear(&s->cfg);
}
__attribute__((format (printf, 2, 3)))
@@ -298,9 +421,9 @@ static void err(struct add_p_state *s, const char *fmt, ...)
va_list args;
va_start(args, fmt);
fputs(s->s.error_color, stdout);
fputs(s->cfg.error_color, stdout);
vprintf(fmt, args);
puts(s->s.reset_color_interactive);
puts(s->cfg.reset_color_interactive);
va_end(args);
}
@@ -318,7 +441,7 @@ static void setup_child_process(struct add_p_state *s,
cp->git_cmd = 1;
strvec_pushf(&cp->env,
INDEX_ENVIRONMENT "=%s", s->s.r->index_file);
INDEX_ENVIRONMENT "=%s", s->index_file);
}
static int parse_range(const char **p,
@@ -423,12 +546,12 @@ static int parse_diff(struct add_p_state *s, const struct pathspec *ps)
int res;
strvec_pushv(&args, s->mode->diff_cmd);
if (s->s.context != -1)
strvec_pushf(&args, "--unified=%i", s->s.context);
if (s->s.interhunkcontext != -1)
strvec_pushf(&args, "--inter-hunk-context=%i", s->s.interhunkcontext);
if (s->s.interactive_diff_algorithm)
strvec_pushf(&args, "--diff-algorithm=%s", s->s.interactive_diff_algorithm);
if (s->cfg.context != -1)
strvec_pushf(&args, "--unified=%i", s->cfg.context);
if (s->cfg.interhunkcontext != -1)
strvec_pushf(&args, "--inter-hunk-context=%i", s->cfg.interhunkcontext);
if (s->cfg.interactive_diff_algorithm)
strvec_pushf(&args, "--diff-algorithm=%s", s->cfg.interactive_diff_algorithm);
if (s->revision) {
struct object_id oid;
strvec_push(&args,
@@ -457,9 +580,9 @@ static int parse_diff(struct add_p_state *s, const struct pathspec *ps)
}
strbuf_complete_line(plain);
if (want_color_fd(1, s->s.use_color_diff)) {
if (want_color_fd(1, s->cfg.use_color_diff)) {
struct child_process colored_cp = CHILD_PROCESS_INIT;
const char *diff_filter = s->s.interactive_diff_filter;
const char *diff_filter = s->cfg.interactive_diff_filter;
setup_child_process(s, &colored_cp, NULL);
xsnprintf((char *)args.v[color_arg_index], 8, "--color");
@@ -692,7 +815,7 @@ static void render_hunk(struct add_p_state *s, struct hunk *hunk,
hunk->colored_end - hunk->colored_start);
return;
} else {
strbuf_addstr(out, s->s.fraginfo_color);
strbuf_addstr(out, s->cfg.fraginfo_color);
p = s->colored.buf + header->colored_extra_start;
len = header->colored_extra_end
- header->colored_extra_start;
@@ -714,7 +837,7 @@ static void render_hunk(struct add_p_state *s, struct hunk *hunk,
if (len)
strbuf_add(out, p, len);
else if (colored)
strbuf_addf(out, "%s\n", s->s.reset_color_diff);
strbuf_addf(out, "%s\n", s->cfg.reset_color_diff);
else
strbuf_addch(out, '\n');
}
@@ -1103,12 +1226,12 @@ static void recolor_hunk(struct add_p_state *s, struct hunk *hunk)
strbuf_addstr(&s->colored,
plain[current] == '-' ?
s->s.file_old_color :
s->cfg.file_old_color :
plain[current] == '+' ?
s->s.file_new_color :
s->s.context_color);
s->cfg.file_new_color :
s->cfg.context_color);
strbuf_add(&s->colored, plain + current, eol - current);
strbuf_addstr(&s->colored, s->s.reset_color_diff);
strbuf_addstr(&s->colored, s->cfg.reset_color_diff);
if (next > eol)
strbuf_add(&s->colored, plain + eol, next - eol);
current = next;
@@ -1237,7 +1360,7 @@ static int run_apply_check(struct add_p_state *s,
static int read_single_character(struct add_p_state *s)
{
if (s->s.use_single_key) {
if (s->cfg.use_single_key) {
int res = read_key_without_echo(&s->answer);
printf("%s\n", res == EOF ? "" : s->answer.buf);
return res;
@@ -1251,7 +1374,7 @@ static int read_single_character(struct add_p_state *s)
static int prompt_yesno(struct add_p_state *s, const char *prompt)
{
for (;;) {
color_fprintf(stdout, s->s.prompt_color, "%s", _(prompt));
color_fprintf(stdout, s->cfg.prompt_color, "%s", _(prompt));
fflush(stdout);
if (read_single_character(s) == EOF)
return -1;
@@ -1442,7 +1565,8 @@ static bool get_first_undecided(const struct file_diff *file_diff, size_t *idx)
}
static int patch_update_file(struct add_p_state *s,
struct file_diff *file_diff)
struct file_diff *file_diff,
unsigned flags)
{
size_t hunk_index = 0;
ssize_t i, undecided_previous, undecided_next, rendered_hunk_index = -1;
@@ -1543,7 +1667,8 @@ static int patch_update_file(struct add_p_state *s,
permitted |= ALLOW_SPLIT;
strbuf_addstr(&s->buf, ",s");
}
if (hunk_index + 1 > file_diff->mode_change &&
if (!(flags & ADD_P_DISALLOW_EDIT) &&
hunk_index + 1 > file_diff->mode_change &&
!file_diff->deleted) {
permitted |= ALLOW_EDIT;
strbuf_addstr(&s->buf, ",e");
@@ -1559,15 +1684,15 @@ static int patch_update_file(struct add_p_state *s,
else
prompt_mode_type = PROMPT_HUNK;
printf("%s(%"PRIuMAX"/%"PRIuMAX") ", s->s.prompt_color,
printf("%s(%"PRIuMAX"/%"PRIuMAX") ", s->cfg.prompt_color,
(uintmax_t)hunk_index + 1,
(uintmax_t)(file_diff->hunk_nr
? file_diff->hunk_nr
: 1));
printf(_(s->mode->prompt_mode[prompt_mode_type]),
s->buf.buf);
if (*s->s.reset_color_interactive)
fputs(s->s.reset_color_interactive, stdout);
if (*s->cfg.reset_color_interactive)
fputs(s->cfg.reset_color_interactive, stdout);
fflush(stdout);
if (read_single_character(s) == EOF) {
quit = 1;
@@ -1730,7 +1855,7 @@ soft_increment:
err(s, _("Sorry, cannot split this hunk"));
} else if (!split_hunk(s, file_diff,
hunk - file_diff->hunk)) {
color_fprintf_ln(stdout, s->s.header_color,
color_fprintf_ln(stdout, s->cfg.header_color,
_("Split into %d hunks."),
(int)splittable_into);
rendered_hunk_index = -1;
@@ -1748,7 +1873,7 @@ soft_increment:
} else if (s->answer.buf[0] == '?') {
const char *p = _(help_patch_remainder), *eol = p;
color_fprintf(stdout, s->s.help_color, "%s",
color_fprintf(stdout, s->cfg.help_color, "%s",
_(s->mode->help_patch_text));
/*
@@ -1766,7 +1891,7 @@ soft_increment:
if (*p != '?' && !strchr(s->buf.buf, *p))
continue;
color_fprintf_ln(stdout, s->s.help_color,
color_fprintf_ln(stdout, s->cfg.help_color,
"%.*s", (int)(eol - p), p);
}
} else {
@@ -1786,7 +1911,7 @@ soft_increment:
strbuf_reset(&s->buf);
reassemble_patch(s, file_diff, 0, &s->buf);
discard_index(s->s.r->index);
discard_index(s->index);
if (s->mode->apply_for_checkout)
apply_for_checkout(s, &s->buf,
s->mode->is_reverse);
@@ -1797,25 +1922,58 @@ soft_increment:
NULL, 0, NULL, 0))
error(_("'git apply' failed"));
}
if (repo_read_index(s->s.r) >= 0)
repo_refresh_and_write_index(s->s.r, REFRESH_QUIET, 0,
if (read_index_from(s->index, s->index_file, s->r->gitdir) >= 0 &&
s->index == s->r->index) {
repo_refresh_and_write_index(s->r, REFRESH_QUIET, 0,
1, NULL, NULL, NULL);
}
}
putchar('\n');
return quit;
}
static int run_add_p_common(struct add_p_state *state,
const struct pathspec *ps,
unsigned flags)
{
size_t binary_count = 0;
if (parse_diff(state, ps) < 0)
return -1;
for (size_t i = 0; i < state->file_diff_nr; i++) {
if (state->file_diff[i].binary && !state->file_diff[i].hunk_nr)
binary_count++;
else if (patch_update_file(state, state->file_diff + i, flags))
break;
}
if (state->file_diff_nr == 0)
err(state, _("No changes."));
else if (binary_count == state->file_diff_nr)
err(state, _("Only binary files changed."));
return 0;
}
int run_add_p(struct repository *r, enum add_p_mode mode,
struct add_p_opt *o, const char *revision,
const struct pathspec *ps)
struct interactive_options *opts, const char *revision,
const struct pathspec *ps,
unsigned flags)
{
struct add_p_state s = {
{ r }, STRBUF_INIT, STRBUF_INIT, STRBUF_INIT, STRBUF_INIT
.r = r,
.index = r->index,
.index_file = r->index_file,
.answer = STRBUF_INIT,
.buf = STRBUF_INIT,
.plain = STRBUF_INIT,
.colored = STRBUF_INIT,
};
size_t i, binary_count = 0;
int ret;
init_add_i_state(&s.s, r, o);
interactive_config_init(&s.cfg, r, opts);
if (mode == ADD_P_STASH)
s.mode = &patch_mode_stash;
@@ -1846,23 +2004,94 @@ int run_add_p(struct repository *r, enum add_p_mode mode,
if (repo_read_index(r) < 0 ||
(!s.mode->index_only &&
repo_refresh_and_write_index(r, REFRESH_QUIET, 0, 1,
NULL, NULL, NULL) < 0) ||
parse_diff(&s, ps) < 0) {
add_p_state_clear(&s);
return -1;
NULL, NULL, NULL) < 0)) {
ret = -1;
goto out;
}
for (i = 0; i < s.file_diff_nr; i++)
if (s.file_diff[i].binary && !s.file_diff[i].hunk_nr)
binary_count++;
else if (patch_update_file(&s, s.file_diff + i))
break;
ret = run_add_p_common(&s, ps, flags);
if (ret < 0)
goto out;
if (s.file_diff_nr == 0)
err(&s, _("No changes."));
else if (binary_count == s.file_diff_nr)
err(&s, _("Only binary files changed."));
ret = 0;
out:
add_p_state_clear(&s);
return 0;
return ret;
}
int run_add_p_index(struct repository *r,
struct index_state *index,
const char *index_file,
struct interactive_options *opts,
const char *revision,
const struct pathspec *ps,
unsigned flags)
{
struct patch_mode mode = {
.apply_args = { "--cached", NULL },
.apply_check_args = { "--cached", NULL },
.prompt_mode = {
N_("Stage mode change [y,n,q,a,d%s,?]? "),
N_("Stage deletion [y,n,q,a,d%s,?]? "),
N_("Stage addition [y,n,q,a,d%s,?]? "),
N_("Stage this hunk [y,n,q,a,d%s,?]? ")
},
.edit_hunk_hint = N_("If the patch applies cleanly, the edited hunk "
"will immediately be marked for staging."),
.help_patch_text =
N_("y - stage this hunk\n"
"n - do not stage this hunk\n"
"q - quit; do not stage this hunk or any of the remaining "
"ones\n"
"a - stage this hunk and all later hunks in the file\n"
"d - do not stage this hunk or any of the later hunks in "
"the file\n"),
.index_only = 1,
};
struct add_p_state s = {
.r = r,
.index = index,
.index_file = index_file,
.answer = STRBUF_INIT,
.buf = STRBUF_INIT,
.plain = STRBUF_INIT,
.colored = STRBUF_INIT,
.mode = &mode,
.revision = revision,
};
struct strbuf parent_revision = STRBUF_INIT;
char parent_tree_oid[GIT_MAX_HEXSZ + 1];
struct commit *commit;
int ret;
commit = lookup_commit_reference_by_name(revision);
if (!commit) {
err(&s, _("Revision does not refer to a commit"));
ret = -1;
goto out;
}
if (commit->parents)
oid_to_hex_r(parent_tree_oid, get_commit_tree_oid(commit->parents->item));
else
oid_to_hex_r(parent_tree_oid, r->hash_algo->empty_tree);
strbuf_addf(&parent_revision, "%s~", revision);
mode.diff_cmd[0] = "diff-tree";
mode.diff_cmd[1] = "-r";
mode.diff_cmd[2] = parent_tree_oid;
interactive_config_init(&s.cfg, r, opts);
ret = run_add_p_common(&s, ps, flags);
if (ret < 0)
goto out;
ret = 0;
out:
strbuf_release(&parent_revision);
add_p_state_clear(&s);
return ret;
}

71
add-patch.h Normal file
View File

@@ -0,0 +1,71 @@
#ifndef ADD_PATCH_H
#define ADD_PATCH_H
#include "color.h"
struct index_state;
struct pathspec;
struct repository;
struct interactive_options {
int context;
int interhunkcontext;
};
#define INTERACTIVE_OPTIONS_INIT { \
.context = -1, \
.interhunkcontext = -1, \
}
struct interactive_config {
enum git_colorbool use_color_interactive;
enum git_colorbool use_color_diff;
char header_color[COLOR_MAXLEN];
char help_color[COLOR_MAXLEN];
char prompt_color[COLOR_MAXLEN];
char error_color[COLOR_MAXLEN];
char reset_color_interactive[COLOR_MAXLEN];
char fraginfo_color[COLOR_MAXLEN];
char context_color[COLOR_MAXLEN];
char file_old_color[COLOR_MAXLEN];
char file_new_color[COLOR_MAXLEN];
char reset_color_diff[COLOR_MAXLEN];
int use_single_key;
char *interactive_diff_filter, *interactive_diff_algorithm;
int context, interhunkcontext;
};
void interactive_config_init(struct interactive_config *cfg,
struct repository *r,
struct interactive_options *opts);
void interactive_config_clear(struct interactive_config *cfg);
enum add_p_mode {
ADD_P_ADD,
ADD_P_STASH,
ADD_P_RESET,
ADD_P_CHECKOUT,
ADD_P_WORKTREE,
};
enum add_p_flags {
/* Disallow "editing" hunks. */
ADD_P_DISALLOW_EDIT = (1 << 0),
};
int run_add_p(struct repository *r, enum add_p_mode mode,
struct interactive_options *opts, const char *revision,
const struct pathspec *ps,
unsigned flags);
int run_add_p_index(struct repository *r,
struct index_state *index,
const char *index_file,
struct interactive_options *opts,
const char *revision,
const struct pathspec *ps,
unsigned flags);
#endif

1
builtin.h
View File

@@ -172,6 +172,7 @@ int cmd_get_tar_commit_id(int argc, const char **argv, const char *prefix, struc
int cmd_grep(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_hash_object(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_help(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_history(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_hook(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_index_pack(int argc, const char **argv, const char *prefix, struct repository *repo);
int cmd_init_db(int argc, const char **argv, const char *prefix, struct repository *repo);

22
builtin/add.c
View File

@@ -31,7 +31,7 @@ static const char * const builtin_add_usage[] = {
NULL
};
static int patch_interactive, add_interactive, edit_interactive;
static struct add_p_opt add_p_opt = ADD_P_OPT_INIT;
static struct interactive_options interactive_opts = INTERACTIVE_OPTIONS_INIT;
static int take_worktree_changes;
static int add_renormalize;
static int pathspec_file_nul;
@@ -160,7 +160,7 @@ static int refresh(struct repository *repo, int verbose, const struct pathspec *
int interactive_add(struct repository *repo,
const char **argv,
const char *prefix,
int patch, struct add_p_opt *add_p_opt)
int patch, struct interactive_options *interactive_opts)
{
struct pathspec pathspec;
int ret;
@@ -172,9 +172,9 @@ int interactive_add(struct repository *repo,
prefix, argv);
if (patch)
ret = !!run_add_p(repo, ADD_P_ADD, add_p_opt, NULL, &pathspec);
ret = !!run_add_p(repo, ADD_P_ADD, interactive_opts, NULL, &pathspec, 0);
else
ret = !!run_add_i(repo, &pathspec, add_p_opt);
ret = !!run_add_i(repo, &pathspec, interactive_opts);
clear_pathspec(&pathspec);
return ret;
@@ -256,8 +256,8 @@ static struct option builtin_add_options[] = {
OPT_GROUP(""),
OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
OPT_DIFF_UNIFIED(&add_p_opt.context),
OPT_DIFF_INTERHUNK_CONTEXT(&add_p_opt.interhunkcontext),
OPT_DIFF_UNIFIED(&interactive_opts.context),
OPT_DIFF_INTERHUNK_CONTEXT(&interactive_opts.interhunkcontext),
OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files"), 0),
OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
@@ -400,9 +400,9 @@ int cmd_add(int argc,
prepare_repo_settings(repo);
repo->settings.command_requires_full_index = 0;
if (add_p_opt.context < -1)
if (interactive_opts.context < -1)
die(_("'%s' cannot be negative"), "--unified");
if (add_p_opt.interhunkcontext < -1)
if (interactive_opts.interhunkcontext < -1)
die(_("'%s' cannot be negative"), "--inter-hunk-context");
if (patch_interactive)
@@ -412,11 +412,11 @@ int cmd_add(int argc,
die(_("options '%s' and '%s' cannot be used together"), "--dry-run", "--interactive/--patch");
if (pathspec_from_file)
die(_("options '%s' and '%s' cannot be used together"), "--pathspec-from-file", "--interactive/--patch");
exit(interactive_add(repo, argv + 1, prefix, patch_interactive, &add_p_opt));
exit(interactive_add(repo, argv + 1, prefix, patch_interactive, &interactive_opts));
} else {
if (add_p_opt.context != -1)
if (interactive_opts.context != -1)
die(_("the option '%s' requires '%s'"), "--unified", "--interactive/--patch");
if (add_p_opt.interhunkcontext != -1)
if (interactive_opts.interhunkcontext != -1)
die(_("the option '%s' requires '%s'"), "--inter-hunk-context", "--interactive/--patch");
}

9
builtin/checkout.c
View File

@@ -546,7 +546,7 @@ static int checkout_paths(const struct checkout_opts *opts,
if (opts->patch_mode) {
enum add_p_mode patch_mode;
struct add_p_opt add_p_opt = {
struct interactive_options interactive_opts = {
.context = opts->patch_context,
.interhunkcontext = opts->patch_interhunk_context,
};
@@ -575,8 +575,8 @@ static int checkout_paths(const struct checkout_opts *opts,
else
BUG("either flag must have been set, worktree=%d, index=%d",
opts->checkout_worktree, opts->checkout_index);
return !!run_add_p(the_repository, patch_mode, &add_p_opt,
rev, &opts->pathspec);
return !!run_add_p(the_repository, patch_mode, &interactive_opts,
rev, &opts->pathspec, 0);
}
repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
@@ -902,7 +902,8 @@ static int merge_working_tree(const struct checkout_opts *opts,
0);
init_ui_merge_options(&o, the_repository);
o.verbosity = 0;
work = write_in_core_index_as_tree(the_repository);
work = write_in_core_index_as_tree(the_repository,
the_repository->index);
ret = reset_tree(new_tree,
opts, 1,

16
builtin/commit.c
View File

@@ -123,7 +123,7 @@ static const char *edit_message, *use_message;
static char *fixup_message, *fixup_commit, *squash_message;
static const char *fixup_prefix;
static int all, also, interactive, patch_interactive, only, amend, signoff;
static struct add_p_opt add_p_opt = ADD_P_OPT_INIT;
static struct interactive_options interactive_opts = INTERACTIVE_OPTIONS_INIT;
static int edit_flag = -1; /* unspecified */
static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
static int config_commit_verbose = -1; /* unspecified */
@@ -356,9 +356,9 @@ static const char *prepare_index(const char **argv, const char *prefix,
const char *ret;
char *path = NULL;
if (add_p_opt.context < -1)
if (interactive_opts.context < -1)
die(_("'%s' cannot be negative"), "--unified");
if (add_p_opt.interhunkcontext < -1)
if (interactive_opts.interhunkcontext < -1)
die(_("'%s' cannot be negative"), "--inter-hunk-context");
if (is_status)
@@ -407,7 +407,7 @@ static const char *prepare_index(const char **argv, const char *prefix,
old_index_env = xstrdup_or_null(getenv(INDEX_ENVIRONMENT));
setenv(INDEX_ENVIRONMENT, the_repository->index_file, 1);
if (interactive_add(the_repository, argv, prefix, patch_interactive, &add_p_opt) != 0)
if (interactive_add(the_repository, argv, prefix, patch_interactive, &interactive_opts) != 0)
die(_("interactive add failed"));
the_repository->index_file = old_repo_index_file;
@@ -432,9 +432,9 @@ static const char *prepare_index(const char **argv, const char *prefix,
ret = get_lock_file_path(&index_lock);
goto out;
} else {
if (add_p_opt.context != -1)
if (interactive_opts.context != -1)
die(_("the option '%s' requires '%s'"), "--unified", "--interactive/--patch");
if (add_p_opt.interhunkcontext != -1)
if (interactive_opts.interhunkcontext != -1)
die(_("the option '%s' requires '%s'"), "--inter-hunk-context", "--interactive/--patch");
}
@@ -1742,8 +1742,8 @@ int cmd_commit(int argc,
OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
OPT_DIFF_UNIFIED(&add_p_opt.context),
OPT_DIFF_INTERHUNK_CONTEXT(&add_p_opt.interhunkcontext),
OPT_DIFF_UNIFIED(&interactive_opts.context),
OPT_DIFF_INTERHUNK_CONTEXT(&interactive_opts.interhunkcontext),
OPT_BOOL('o', "only", &only, N_("commit only specified files")),
OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit and commit-msg hooks")),
OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),

558
builtin/history.c Normal file
View File

@@ -0,0 +1,558 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "builtin.h"
#include "cache-tree.h"
#include "commit-reach.h"
#include "commit.h"
#include "config.h"
#include "editor.h"
#include "environment.h"
#include "gettext.h"
#include "hex.h"
#include "oidmap.h"
#include "parse-options.h"
#include "path.h"
#include "read-cache.h"
#include "refs.h"
#include "replay.h"
#include "reset.h"
#include "revision.h"
#include "run-command.h"
#include "sequencer.h"
#include "strvec.h"
#include "tree.h"
#include "wt-status.h"
#define GIT_HISTORY_REWORD_USAGE N_("git history reword <commit>")
#define GIT_HISTORY_SPLIT_USAGE N_("git history split <commit> [--] [<pathspec>...]")
static int collect_commits(struct repository *repo,
struct commit *old_commit,
struct commit *new_commit,
struct strvec *out)
{
struct setup_revision_opt revision_opts = {
.assume_dashdash = 1,
};
struct strvec revisions = STRVEC_INIT;
struct commit *child;
struct rev_info rev = { 0 };
int ret;
repo_init_revisions(repo, &rev, NULL);
rev.reverse = 1;
strvec_push(&revisions, "");
strvec_push(&revisions, oid_to_hex(&new_commit->object.oid));
if (old_commit) {
strvec_pushf(&revisions, "^%s", oid_to_hex(&old_commit->object.oid));
strvec_pushf(&revisions, "--ancestry-path=%s", oid_to_hex(&old_commit->object.oid));
}
setup_revisions_from_strvec(&revisions, &rev, &revision_opts);
if (revisions.nr != 1 || prepare_revision_walk(&rev)) {
ret = error(_("revision walk setup failed"));
goto out;
}
while ((child = get_revision(&rev))) {
if (old_commit && !child->parents)
BUG("revision walk did not find child commit");
if (child->parents && child->parents->next) {
ret = error(_("cannot rearrange commit history with merges"));
goto out;
}
strvec_push(out, oid_to_hex(&child->object.oid));
}
ret = 0;
out:
strvec_clear(&revisions);
release_revisions(&rev);
reset_revision_walk();
return ret;
}
static int gather_commits_between_head_and_revision(struct repository *repo,
const char *revision,
struct commit **original_commit,
struct commit **parent_commit,
struct commit **head,
struct strvec *commits)
{
struct commit_list *from_list = NULL;
int ret;
*original_commit = lookup_commit_reference_by_name(revision);
if (!*original_commit) {
ret = error(_("commit cannot be found: %s"), revision);
goto out;
}
*parent_commit = (*original_commit)->parents ? (*original_commit)->parents->item : NULL;
if (*parent_commit && repo_parse_commit(repo, *parent_commit)) {
ret = error(_("unable to parse commit %s"),
oid_to_hex(&(*parent_commit)->object.oid));
goto out;
}
*head = lookup_commit_reference_by_name("HEAD");
if (!(*head)) {
ret = error(_("could not resolve HEAD to a commit"));
goto out;
}
commit_list_append(*original_commit, &from_list);
if (!repo_is_descendant_of(repo, *head, from_list)) {
ret = error(_("commit must be reachable from current HEAD commit"));
goto out;
}
/*
* Collect the list of commits that we'll have to reapply now already.
* This ensures that we'll abort early on in case the range of commits
* contains merges, which we do not yet handle.
*/
ret = collect_commits(repo, *parent_commit, *head, commits);
if (ret < 0)
goto out;
out:
free_commit_list(from_list);
return ret;
}
static void replace_commits(struct strvec *commits,
const struct object_id *commit_to_replace,
const struct object_id *replacements,
size_t replacements_nr)
{
char commit_to_replace_oid[GIT_MAX_HEXSZ + 1];
struct strvec replacement_oids = STRVEC_INIT;
bool found = false;
oid_to_hex_r(commit_to_replace_oid, commit_to_replace);
for (size_t i = 0; i < replacements_nr; i++)
strvec_push(&replacement_oids, oid_to_hex(&replacements[i]));
for (size_t i = 0; i < commits->nr; i++) {
if (strcmp(commits->v[i], commit_to_replace_oid))
continue;
strvec_splice(commits, i, 1, replacement_oids.v, replacement_oids.nr);
found = true;
break;
}
if (!found)
BUG("could not find commit to replace");
strvec_clear(&replacement_oids);
}
static int apply_commits(struct repository *repo,
const struct strvec *commits,
struct commit *onto,
struct commit *orig_head,
const char *action)
{
struct reset_head_opts reset_opts = { 0 };
struct strbuf buf = STRBUF_INIT;
int ret;
for (size_t i = 0; i < commits->nr; i++) {
struct object_id commit_id;
struct commit *commit;
const char *end;
if (parse_oid_hex_algop(commits->v[i], &commit_id, &end,
repo->hash_algo)) {
ret = error(_("invalid object ID: %s"), commits->v[i]);
goto out;
}
commit = lookup_commit(repo, &commit_id);
if (!commit || repo_parse_commit(repo, commit)) {
ret = error(_("failed to look up commit: %s"), oid_to_hex(&commit_id));
goto out;
}
if (!onto) {
onto = commit;
} else {
struct tree *tree = repo_get_commit_tree(repo, commit);
onto = replay_create_commit(repo, tree, commit, onto);
if (!onto) {
ret = -1;
goto out;
}
}
}
reset_opts.oid = &onto->object.oid;
strbuf_addf(&buf, "%s: switch to rewritten %s", action, oid_to_hex(reset_opts.oid));
reset_opts.flags = RESET_HEAD_REFS_ONLY | RESET_ORIG_HEAD;
reset_opts.orig_head = &orig_head->object.oid;
reset_opts.default_reflog_action = action;
if (reset_head(repo, &reset_opts) < 0) {
ret = error(_("could not switch to %s"), oid_to_hex(reset_opts.oid));
goto out;
}
ret = 0;
out:
strbuf_release(&buf);
return ret;
}
static void change_data_free(void *util, const char *str UNUSED)
{
struct wt_status_change_data *d = util;
free(d->rename_source);
free(d);
}
static int fill_commit_message(struct repository *repo,
const struct object_id *old_tree,
const struct object_id *new_tree,
const char *default_message,
const char *action,
struct strbuf *out)
{
const char *path = git_path_commit_editmsg();
const char *hint =
_("Please enter the commit message for the %s changes."
" Lines starting\nwith '%s' will be ignored, and an"
" empty message aborts the commit.\n");
struct wt_status s;
strbuf_addstr(out, default_message);
strbuf_addch(out, '\n');
strbuf_commented_addf(out, comment_line_str, hint, action, comment_line_str);
write_file_buf(path, out->buf, out->len);
wt_status_prepare(repo, &s);
FREE_AND_NULL(s.branch);
s.ahead_behind_flags = AHEAD_BEHIND_QUICK;
s.commit_template = 1;
s.colopts = 0;
s.display_comment_prefix = 1;
s.hints = 0;
s.use_color = 0;
s.whence = FROM_COMMIT;
s.committable = 1;
s.fp = fopen(git_path_commit_editmsg(), "a");
if (!s.fp)
return error_errno(_("could not open '%s'"), git_path_commit_editmsg());
wt_status_collect_changes_trees(&s, old_tree, new_tree);
wt_status_print(&s);
wt_status_collect_free_buffers(&s);
string_list_clear_func(&s.change, change_data_free);
strbuf_reset(out);
if (launch_editor(path, out, NULL)) {
fprintf(stderr, _("Aborting commit as launching the editor failed.\n"));
return -1;
}
strbuf_stripspace(out, comment_line_str);
cleanup_message(out, COMMIT_MSG_CLEANUP_ALL, 0);
if (!out->len) {
fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
return -1;
}
return 0;
}
static int commit_tree_with_edited_message(struct repository *repo,
const char *action,
struct commit *original_commit,
const struct object_id *new_tree_oid,
const struct commit_list *parents,
const struct object_id *parent_tree_oid,
struct object_id *out)
{
const char *exclude_gpgsig[] = { "gpgsig", "gpgsig-sha256", NULL };
const char *original_message, *original_body, *ptr;
struct commit_extra_header *original_extra_headers = NULL;
struct strbuf commit_message = STRBUF_INIT;
char *original_author = NULL;
size_t len;
int ret;
/* We retain authorship of the original commit. */
original_message = repo_logmsg_reencode(repo, original_commit, NULL, NULL);
ptr = find_commit_header(original_message, "author", &len);
if (ptr)
original_author = xmemdupz(ptr, len);
find_commit_subject(original_message, &original_body);
ret = fill_commit_message(repo, parent_tree_oid, new_tree_oid,
original_body, action, &commit_message);
if (ret < 0)
goto out;
original_extra_headers = read_commit_extra_headers(original_commit, exclude_gpgsig);
ret = commit_tree_extended(commit_message.buf, commit_message.len, new_tree_oid,
parents, out, original_author, NULL, NULL,
original_extra_headers);
if (ret < 0)
goto out;
out:
free_commit_extra_headers(original_extra_headers);
strbuf_release(&commit_message);
free(original_author);
return ret;
}
static int cmd_history_reword(int argc,
const char **argv,
const char *prefix,
struct repository *repo)
{
const char * const usage[] = {
GIT_HISTORY_REWORD_USAGE,
NULL,
};
struct option options[] = {
OPT_END(),
};
struct commit *original_commit, *parent, *head;
struct strvec commits = STRVEC_INIT;
struct object_id parent_tree_oid, original_commit_tree_oid;
struct object_id rewritten_commit;
int ret;
argc = parse_options(argc, argv, prefix, options, usage, 0);
if (argc != 1) {
ret = error(_("command expects a single revision"));
goto out;
}
repo_config(repo, git_default_config, NULL);
ret = gather_commits_between_head_and_revision(repo, argv[0], &original_commit,
&parent, &head, &commits);
if (ret < 0)
goto out;
original_commit_tree_oid = repo_get_commit_tree(repo, original_commit)->object.oid;
if (parent)
parent_tree_oid = repo_get_commit_tree(repo, parent)->object.oid;
else
oidcpy(&parent_tree_oid, repo->hash_algo->empty_tree);
/* We retain authorship of the original commit. */
ret = commit_tree_with_edited_message(repo, "reworded", original_commit,
&original_commit_tree_oid,
original_commit->parents, &parent_tree_oid,
&rewritten_commit);
if (ret < 0) {
ret = error(_("failed writing reworded commit"));
goto out;
}
replace_commits(&commits, &original_commit->object.oid, &rewritten_commit, 1);
ret = apply_commits(repo, &commits, parent, head, "reword");
if (ret < 0)
goto out;
ret = 0;
out:
strvec_clear(&commits);
return ret;
}
static int split_commit(struct repository *repo,
struct commit *original_commit,
struct pathspec *pathspec,
struct object_id *out)
{
struct interactive_options interactive_opts = INTERACTIVE_OPTIONS_INIT;
struct strbuf index_file = STRBUF_INIT;
struct child_process read_tree_cmd = CHILD_PROCESS_INIT;
struct index_state index = INDEX_STATE_INIT(repo);
struct object_id original_commit_tree_oid, parent_tree_oid;
char original_commit_oid[GIT_MAX_HEXSZ + 1];
struct commit_list *parents = NULL;
struct commit *first_commit;
struct tree *split_tree;
int ret;
if (original_commit->parents)
parent_tree_oid = *get_commit_tree_oid(original_commit->parents->item);
else
oidcpy(&parent_tree_oid, repo->hash_algo->empty_tree);
original_commit_tree_oid = *get_commit_tree_oid(original_commit);
/*
* Construct the first commit. This is done by taking the original
* commit parent's tree and selectively patching changes from the diff
* between that parent and its child.
*/
repo_git_path_replace(repo, &index_file, "%s", "history-split.index");
read_tree_cmd.git_cmd = 1;
strvec_pushf(&read_tree_cmd.env, "GIT_INDEX_FILE=%s", index_file.buf);
strvec_push(&read_tree_cmd.args, "read-tree");
strvec_push(&read_tree_cmd.args, oid_to_hex(&parent_tree_oid));
ret = run_command(&read_tree_cmd);
if (ret < 0)
goto out;
ret = read_index_from(&index, index_file.buf, repo->gitdir);
if (ret < 0) {
ret = error(_("failed reading temporary index"));
goto out;
}
oid_to_hex_r(original_commit_oid, &original_commit->object.oid);
ret = run_add_p_index(repo, &index, index_file.buf, &interactive_opts,
original_commit_oid, pathspec, ADD_P_DISALLOW_EDIT);
if (ret < 0)
goto out;
split_tree = write_in_core_index_as_tree(repo, &index);
if (!split_tree) {
ret = error(_("failed split tree"));
goto out;
}
unlink(index_file.buf);
/*
* We disallow the cases where either the split-out commit or the
* original commit would become empty. Consequently, if we see that the
* new tree ID matches either of those trees we abort.
*/
if (oideq(&split_tree->object.oid, &parent_tree_oid)) {
ret = error(_("split commit is empty"));
goto out;
} else if (oideq(&split_tree->object.oid, &original_commit_tree_oid)) {
ret = error(_("split commit tree matches original commit"));
goto out;
}
/*
* The first commit is constructed from the split-out tree. The base
* that shall be diffed against is the parent of the original commit.
*/
ret = commit_tree_with_edited_message(repo, "split-out", original_commit,
&split_tree->object.oid,
original_commit->parents, &parent_tree_oid, &out[0]);
if (ret < 0) {
ret = error(_("failed writing split-out commit"));
goto out;
}
/*
* The second commit is constructed from the original tree. The base to
* diff against and the parent in this case is the first split-out
* commit.
*/
first_commit = lookup_commit_reference(repo, &out[0]);
commit_list_append(first_commit, &parents);
ret = commit_tree_with_edited_message(repo, "split-out", original_commit,
&original_commit_tree_oid,
parents, get_commit_tree_oid(first_commit), &out[1]);
if (ret < 0) {
ret = error(_("failed writing split-out commit"));
goto out;
}
ret = 0;
out:
if (index_file.len)
unlink(index_file.buf);
strbuf_release(&index_file);
free_commit_list(parents);
release_index(&index);
return ret;
}
static int cmd_history_split(int argc,
const char **argv,
const char *prefix,
struct repository *repo)
{
const char * const usage[] = {
GIT_HISTORY_SPLIT_USAGE,
NULL,
};
struct option options[] = {
OPT_END(),
};
struct commit *original_commit, *parent, *head;
struct strvec commits = STRVEC_INIT;
struct object_id split_commits[2];
struct pathspec pathspec = { 0 };
int ret;
argc = parse_options(argc, argv, prefix, options, usage, 0);
if (argc < 1) {
ret = error(_("command expects a revision"));
goto out;
}
repo_config(repo, git_default_config, NULL);
parse_pathspec(&pathspec, 0,
PATHSPEC_PREFER_FULL | PATHSPEC_SYMLINK_LEADING_PATH | PATHSPEC_PREFIX_ORIGIN,
prefix, argv + 1);
ret = gather_commits_between_head_and_revision(repo, argv[0], &original_commit,
&parent, &head, &commits);
if (ret < 0)
goto out;
/*
* Then we split up the commit and replace the original commit with the
* new ones.
*/
ret = split_commit(repo, original_commit, &pathspec, split_commits);
if (ret < 0)
goto out;
replace_commits(&commits, &original_commit->object.oid,
split_commits, ARRAY_SIZE(split_commits));
ret = apply_commits(repo, &commits, parent, head, "split");
if (ret < 0)
goto out;
ret = 0;
out:
clear_pathspec(&pathspec);
strvec_clear(&commits);
return ret;
}
int cmd_history(int argc,
const char **argv,
const char *prefix,
struct repository *repo)
{
const char * const usage[] = {
GIT_HISTORY_REWORD_USAGE,
GIT_HISTORY_SPLIT_USAGE,
NULL,
};
parse_opt_subcommand_fn *fn = NULL;
struct option options[] = {
OPT_SUBCOMMAND("reword", &fn, cmd_history_reword),
OPT_SUBCOMMAND("split", &fn, cmd_history_split),
OPT_END(),
};
argc = parse_options(argc, argv, prefix, options, usage, 0);
return fn(argc, argv, prefix, repo);
}

110
builtin/replay.c
View File

@@ -2,7 +2,6 @@
* "git replay" builtin command
*/
#define USE_THE_REPOSITORY_VARIABLE
#define DISABLE_SIGN_COMPARE_WARNINGS
#include "git-compat-util.h"
@@ -16,6 +15,7 @@
#include "object-name.h"
#include "parse-options.h"
#include "refs.h"
#include "replay.h"
#include "revision.h"
#include "strmap.h"
#include <oidset.h>
@@ -26,13 +26,6 @@ enum ref_action_mode {
REF_ACTION_PRINT,
};
static const char *short_commit_name(struct repository *repo,
struct commit *commit)
{
return repo_find_unique_abbrev(repo, &commit->object.oid,
DEFAULT_ABBREV);
}
static struct commit *peel_committish(struct repository *repo, const char *name)
{
struct object *obj;
@@ -45,59 +38,6 @@ static struct commit *peel_committish(struct repository *repo, const char *name)
OBJ_COMMIT);
}
static char *get_author(const char *message)
{
size_t len;
const char *a;
a = find_commit_header(message, "author", &len);
if (a)
return xmemdupz(a, len);
return NULL;
}
static struct commit *create_commit(struct repository *repo,
struct tree *tree,
struct commit *based_on,
struct commit *parent)
{
struct object_id ret;
struct object *obj = NULL;
struct commit_list *parents = NULL;
char *author;
char *sign_commit = NULL; /* FIXME: cli users might want to sign again */
struct commit_extra_header *extra = NULL;
struct strbuf msg = STRBUF_INIT;
const char *out_enc = get_commit_output_encoding();
const char *message = repo_logmsg_reencode(repo, based_on,
NULL, out_enc);
const char *orig_message = NULL;
const char *exclude_gpgsig[] = { "gpgsig", "gpgsig-sha256", NULL };
commit_list_insert(parent, &parents);
extra = read_commit_extra_headers(based_on, exclude_gpgsig);
find_commit_subject(message, &orig_message);
strbuf_addstr(&msg, orig_message);
author = get_author(message);
reset_ident_date();
if (commit_tree_extended(msg.buf, msg.len, &tree->object.oid, parents,
&ret, author, NULL, sign_commit, extra)) {
error(_("failed to write commit object"));
goto out;
}
obj = parse_object(repo, &ret);
out:
repo_unuse_commit_buffer(the_repository, based_on, message);
free_commit_extra_headers(extra);
free_commit_list(parents);
strbuf_release(&msg);
free(author);
return (struct commit *)obj;
}
struct ref_info {
struct commit *onto;
struct strset positive_refs;
@@ -246,50 +186,6 @@ static void determine_replay_mode(struct repository *repo,
strset_clear(&rinfo.positive_refs);
}
static struct commit *mapped_commit(kh_oid_map_t *replayed_commits,
struct commit *commit,
struct commit *fallback)
{
khint_t pos = kh_get_oid_map(replayed_commits, commit->object.oid);
if (pos == kh_end(replayed_commits))
return fallback;
return kh_value(replayed_commits, pos);
}
static struct commit *pick_regular_commit(struct repository *repo,
struct commit *pickme,
kh_oid_map_t *replayed_commits,
struct commit *onto,
struct merge_options *merge_opt,
struct merge_result *result)
{
struct commit *base, *replayed_base;
struct tree *pickme_tree, *base_tree;
base = pickme->parents->item;
replayed_base = mapped_commit(replayed_commits, base, onto);
result->tree = repo_get_commit_tree(repo, replayed_base);
pickme_tree = repo_get_commit_tree(repo, pickme);
base_tree = repo_get_commit_tree(repo, base);
merge_opt->branch1 = short_commit_name(repo, replayed_base);
merge_opt->branch2 = short_commit_name(repo, pickme);
merge_opt->ancestor = xstrfmt("parent of %s", merge_opt->branch2);
merge_incore_nonrecursive(merge_opt,
base_tree,
result->tree,
pickme_tree,
result);
free((char*)merge_opt->ancestor);
merge_opt->ancestor = NULL;
if (!result->clean)
return NULL;
return create_commit(repo, result->tree, pickme, replayed_base);
}
static enum ref_action_mode parse_ref_action_mode(const char *ref_action, const char *source)
{
if (!ref_action || !strcmp(ref_action, "update"))
@@ -495,8 +391,8 @@ int cmd_replay(int argc,
if (commit->parents->next)
die(_("replaying merge commits is not supported yet!"));
last_commit = pick_regular_commit(repo, commit, replayed_commits,
onto, &merge_opt, &result);
last_commit = replay_pick_regular_commit(repo, commit, replayed_commits,
onto, &merge_opt, &result);
if (!last_commit)
break;

16
builtin/reset.c
View File

@@ -346,7 +346,7 @@ int cmd_reset(int argc,
struct object_id oid;
struct pathspec pathspec;
int intent_to_add = 0;
struct add_p_opt add_p_opt = ADD_P_OPT_INIT;
struct interactive_options interactive_opts = INTERACTIVE_OPTIONS_INIT;
const struct option options[] = {
OPT__QUIET(&quiet, N_("be quiet, only report errors")),
OPT_BOOL(0, "no-refresh", &no_refresh,
@@ -371,8 +371,8 @@ int cmd_reset(int argc,
PARSE_OPT_OPTARG,
option_parse_recurse_submodules_worktree_updater),
OPT_BOOL('p', "patch", &patch_mode, N_("select hunks interactively")),
OPT_DIFF_UNIFIED(&add_p_opt.context),
OPT_DIFF_INTERHUNK_CONTEXT(&add_p_opt.interhunkcontext),
OPT_DIFF_UNIFIED(&interactive_opts.context),
OPT_DIFF_INTERHUNK_CONTEXT(&interactive_opts.interhunkcontext),
OPT_BOOL('N', "intent-to-add", &intent_to_add,
N_("record only the fact that removed paths will be added later")),
OPT_PATHSPEC_FROM_FILE(&pathspec_from_file),
@@ -423,9 +423,9 @@ int cmd_reset(int argc,
oidcpy(&oid, &tree->object.oid);
}
if (add_p_opt.context < -1)
if (interactive_opts.context < -1)
die(_("'%s' cannot be negative"), "--unified");
if (add_p_opt.interhunkcontext < -1)
if (interactive_opts.interhunkcontext < -1)
die(_("'%s' cannot be negative"), "--inter-hunk-context");
prepare_repo_settings(the_repository);
@@ -436,12 +436,12 @@ int cmd_reset(int argc,
die(_("options '%s' and '%s' cannot be used together"), "--patch", "--{hard,mixed,soft}");
trace2_cmd_mode("patch-interactive");
update_ref_status = !!run_add_p(the_repository, ADD_P_RESET,
&add_p_opt, rev, &pathspec);
&interactive_opts, rev, &pathspec, 0);
goto cleanup;
} else {
if (add_p_opt.context != -1)
if (interactive_opts.context != -1)
die(_("the option '%s' requires '%s'"), "--unified", "--patch");
if (add_p_opt.interhunkcontext != -1)
if (interactive_opts.interhunkcontext != -1)
die(_("the option '%s' requires '%s'"), "--inter-hunk-context", "--patch");
}

46
builtin/stash.c
View File

@@ -1306,7 +1306,7 @@ done:
static int stash_patch(struct stash_info *info, const struct pathspec *ps,
struct strbuf *out_patch, int quiet,
struct add_p_opt *add_p_opt)
struct interactive_options *interactive_opts)
{
int ret = 0;
struct child_process cp_read_tree = CHILD_PROCESS_INIT;
@@ -1331,7 +1331,7 @@ static int stash_patch(struct stash_info *info, const struct pathspec *ps,
old_index_env = xstrdup_or_null(getenv(INDEX_ENVIRONMENT));
setenv(INDEX_ENVIRONMENT, the_repository->index_file, 1);
ret = !!run_add_p(the_repository, ADD_P_STASH, add_p_opt, NULL, ps);
ret = !!run_add_p(the_repository, ADD_P_STASH, interactive_opts, NULL, ps, 0);
the_repository->index_file = old_repo_index_file;
if (old_index_env && *old_index_env)
@@ -1427,7 +1427,8 @@ done:
}
static int do_create_stash(const struct pathspec *ps, struct strbuf *stash_msg_buf,
int include_untracked, int patch_mode, struct add_p_opt *add_p_opt,
int include_untracked, int patch_mode,
struct interactive_options *interactive_opts,
int only_staged, struct stash_info *info, struct strbuf *patch,
int quiet)
{
@@ -1509,7 +1510,7 @@ static int do_create_stash(const struct pathspec *ps, struct strbuf *stash_msg_b
untracked_commit_option = 1;
}
if (patch_mode) {
ret = stash_patch(info, ps, patch, quiet, add_p_opt);
ret = stash_patch(info, ps, patch, quiet, interactive_opts);
if (ret < 0) {
if (!quiet)
fprintf_ln(stderr, _("Cannot save the current "
@@ -1595,7 +1596,8 @@ static int create_stash(int argc, const char **argv, const char *prefix UNUSED,
}
static int do_push_stash(const struct pathspec *ps, const char *stash_msg, int quiet,
int keep_index, int patch_mode, struct add_p_opt *add_p_opt,
int keep_index, int patch_mode,
struct interactive_options *interactive_opts,
int include_untracked, int only_staged)
{
int ret = 0;
@@ -1667,7 +1669,7 @@ static int do_push_stash(const struct pathspec *ps, const char *stash_msg, int q
if (stash_msg)
strbuf_addstr(&stash_msg_buf, stash_msg);
if (do_create_stash(ps, &stash_msg_buf, include_untracked, patch_mode,
add_p_opt, only_staged, &info, &patch, quiet)) {
interactive_opts, only_staged, &info, &patch, quiet)) {
ret = -1;
goto done;
}
@@ -1841,7 +1843,7 @@ static int push_stash(int argc, const char **argv, const char *prefix,
const char *stash_msg = NULL;
char *pathspec_from_file = NULL;
struct pathspec ps;
struct add_p_opt add_p_opt = ADD_P_OPT_INIT;
struct interactive_options interactive_opts = INTERACTIVE_OPTIONS_INIT;
struct option options[] = {
OPT_BOOL('k', "keep-index", &keep_index,
N_("keep index")),
@@ -1849,8 +1851,8 @@ static int push_stash(int argc, const char **argv, const char *prefix,
N_("stash staged changes only")),
OPT_BOOL('p', "patch", &patch_mode,
N_("stash in patch mode")),
OPT_DIFF_UNIFIED(&add_p_opt.context),
OPT_DIFF_INTERHUNK_CONTEXT(&add_p_opt.interhunkcontext),
OPT_DIFF_UNIFIED(&interactive_opts.context),
OPT_DIFF_INTERHUNK_CONTEXT(&interactive_opts.interhunkcontext),
OPT__QUIET(&quiet, N_("quiet mode")),
OPT_BOOL('u', "include-untracked", &include_untracked,
N_("include untracked files in stash")),
@@ -1907,19 +1909,19 @@ static int push_stash(int argc, const char **argv, const char *prefix,
}
if (!patch_mode) {
if (add_p_opt.context != -1)
if (interactive_opts.context != -1)
die(_("the option '%s' requires '%s'"), "--unified", "--patch");
if (add_p_opt.interhunkcontext != -1)
if (interactive_opts.interhunkcontext != -1)
die(_("the option '%s' requires '%s'"), "--inter-hunk-context", "--patch");
}
if (add_p_opt.context < -1)
if (interactive_opts.context < -1)
die(_("'%s' cannot be negative"), "--unified");
if (add_p_opt.interhunkcontext < -1)
if (interactive_opts.interhunkcontext < -1)
die(_("'%s' cannot be negative"), "--inter-hunk-context");
ret = do_push_stash(&ps, stash_msg, quiet, keep_index, patch_mode,
&add_p_opt, include_untracked, only_staged);
&interactive_opts, include_untracked, only_staged);
clear_pathspec(&ps);
free(pathspec_from_file);
@@ -1944,7 +1946,7 @@ static int save_stash(int argc, const char **argv, const char *prefix,
const char *stash_msg = NULL;
struct pathspec ps;
struct strbuf stash_msg_buf = STRBUF_INIT;
struct add_p_opt add_p_opt = ADD_P_OPT_INIT;
struct interactive_options interactive_opts = INTERACTIVE_OPTIONS_INIT;
struct option options[] = {
OPT_BOOL('k', "keep-index", &keep_index,
N_("keep index")),
@@ -1952,8 +1954,8 @@ static int save_stash(int argc, const char **argv, const char *prefix,
N_("stash staged changes only")),
OPT_BOOL('p', "patch", &patch_mode,
N_("stash in patch mode")),
OPT_DIFF_UNIFIED(&add_p_opt.context),
OPT_DIFF_INTERHUNK_CONTEXT(&add_p_opt.interhunkcontext),
OPT_DIFF_UNIFIED(&interactive_opts.context),
OPT_DIFF_INTERHUNK_CONTEXT(&interactive_opts.interhunkcontext),
OPT__QUIET(&quiet, N_("quiet mode")),
OPT_BOOL('u', "include-untracked", &include_untracked,
N_("include untracked files in stash")),
@@ -1973,20 +1975,20 @@ static int save_stash(int argc, const char **argv, const char *prefix,
memset(&ps, 0, sizeof(ps));
if (add_p_opt.context < -1)
if (interactive_opts.context < -1)
die(_("'%s' cannot be negative"), "--unified");
if (add_p_opt.interhunkcontext < -1)
if (interactive_opts.interhunkcontext < -1)
die(_("'%s' cannot be negative"), "--inter-hunk-context");
if (!patch_mode) {
if (add_p_opt.context != -1)
if (interactive_opts.context != -1)
die(_("the option '%s' requires '%s'"), "--unified", "--patch");
if (add_p_opt.interhunkcontext != -1)
if (interactive_opts.interhunkcontext != -1)
die(_("the option '%s' requires '%s'"), "--inter-hunk-context", "--patch");
}
ret = do_push_stash(&ps, stash_msg, quiet, keep_index,
patch_mode, &add_p_opt, include_untracked,
patch_mode, &interactive_opts, include_untracked,
only_staged);
strbuf_release(&stash_msg_buf);

4
cache-tree.c
View File

@@ -705,11 +705,11 @@ static int write_index_as_tree_internal(struct object_id *oid,
return 0;
}
struct tree* write_in_core_index_as_tree(struct repository *repo) {
struct tree *write_in_core_index_as_tree(struct repository *repo,
struct index_state *index_state) {
struct object_id o;
int was_valid, ret;
struct index_state *index_state = repo->index;
was_valid = index_state->cache_tree &&
cache_tree_fully_valid(index_state->cache_tree);

3
cache-tree.h
View File

@@ -47,7 +47,8 @@ int cache_tree_verify(struct repository *, struct index_state *);
#define WRITE_TREE_UNMERGED_INDEX (-2)
#define WRITE_TREE_PREFIX_ERROR (-3)
struct tree* write_in_core_index_as_tree(struct repository *repo);
struct tree *write_in_core_index_as_tree(struct repository *repo,
struct index_state *index_state);
int write_index_as_tree(struct object_id *oid, struct index_state *index_state, const char *index_path, int flags, const char *prefix);
void prime_cache_tree(struct repository *, struct index_state *, struct tree *);

1
command-list.txt
View File

@@ -115,6 +115,7 @@ git-grep mainporcelain info
git-gui mainporcelain
git-hash-object plumbingmanipulators
git-help ancillaryinterrogators complete
git-history mainporcelain history
git-hook purehelpers
git-http-backend synchingrepositories
git-http-fetch synchelpers

2
commit.h
View File

@@ -258,7 +258,7 @@ int for_each_commit_graft(each_commit_graft_fn, void *);
int interactive_add(struct repository *repo,
const char **argv,
const char *prefix,
int patch, struct add_p_opt *add_p_opt);
int patch, struct interactive_options *opts);
struct commit_extra_header {
struct commit_extra_header *next;

1
git.c
View File

@@ -586,6 +586,7 @@ static struct cmd_struct commands[] = {
{ "grep", cmd_grep, RUN_SETUP_GENTLY },
{ "hash-object", cmd_hash_object },
{ "help", cmd_help },
{ "history", cmd_history, RUN_SETUP },
{ "hook", cmd_hook, RUN_SETUP },
{ "index-pack", cmd_index_pack, RUN_SETUP_GENTLY | NO_PARSEOPT },
{ "init", cmd_init_db },

2
meson.build
View File

@@ -471,6 +471,7 @@ libgit_sources = [
'repack-midx.c',
'repack-promisor.c',
'replace-object.c',
'replay.c',
'repo-settings.c',
'repository.c',
'rerere.c',
@@ -609,6 +610,7 @@ builtin_sources = [
'builtin/grep.c',
'builtin/hash-object.c',
'builtin/help.c',
'builtin/history.c',
'builtin/hook.c',
'builtin/index-pack.c',
'builtin/init-db.c',

115
replay.c Normal file
View File

@@ -0,0 +1,115 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "commit.h"
#include "environment.h"
#include "gettext.h"
#include "ident.h"
#include "object.h"
#include "object-name.h"
#include "replay.h"
#include "tree.h"
static const char *short_commit_name(struct repository *repo,
struct commit *commit)
{
return repo_find_unique_abbrev(repo, &commit->object.oid,
DEFAULT_ABBREV);
}
static char *get_author(const char *message)
{
size_t len;
const char *a;
a = find_commit_header(message, "author", &len);
if (a)
return xmemdupz(a, len);
return NULL;
}
struct commit *replay_create_commit(struct repository *repo,
struct tree *tree,
struct commit *based_on,
struct commit *parent)
{
struct object_id ret;
struct object *obj = NULL;
struct commit_list *parents = NULL;
char *author;
char *sign_commit = NULL; /* FIXME: cli users might want to sign again */
struct commit_extra_header *extra = NULL;
struct strbuf msg = STRBUF_INIT;
const char *out_enc = get_commit_output_encoding();
const char *message = repo_logmsg_reencode(repo, based_on,
NULL, out_enc);
const char *orig_message = NULL;
const char *exclude_gpgsig[] = { "gpgsig", "gpgsig-sha256", NULL };
commit_list_insert(parent, &parents);
extra = read_commit_extra_headers(based_on, exclude_gpgsig);
find_commit_subject(message, &orig_message);
strbuf_addstr(&msg, orig_message);
author = get_author(message);
reset_ident_date();
if (commit_tree_extended(msg.buf, msg.len, &tree->object.oid, parents,
&ret, author, NULL, sign_commit, extra)) {
error(_("failed to write commit object"));
goto out;
}
obj = parse_object(repo, &ret);
out:
repo_unuse_commit_buffer(repo, based_on, message);
free_commit_extra_headers(extra);
free_commit_list(parents);
strbuf_release(&msg);
free(author);
return (struct commit *)obj;
}
static struct commit *mapped_commit(kh_oid_map_t *replayed_commits,
struct commit *commit,
struct commit *fallback)
{
khint_t pos = kh_get_oid_map(replayed_commits, commit->object.oid);
if (pos == kh_end(replayed_commits))
return fallback;
return kh_value(replayed_commits, pos);
}
struct commit *replay_pick_regular_commit(struct repository *repo,
struct commit *pickme,
kh_oid_map_t *replayed_commits,
struct commit *onto,
struct merge_options *merge_opt,
struct merge_result *result)
{
struct commit *base, *replayed_base;
struct tree *pickme_tree, *base_tree;
base = pickme->parents->item;
replayed_base = mapped_commit(replayed_commits, base, onto);
result->tree = repo_get_commit_tree(repo, replayed_base);
pickme_tree = repo_get_commit_tree(repo, pickme);
base_tree = repo_get_commit_tree(repo, base);
merge_opt->branch1 = short_commit_name(repo, replayed_base);
merge_opt->branch2 = short_commit_name(repo, pickme);
merge_opt->ancestor = xstrfmt("parent of %s", merge_opt->branch2);
merge_incore_nonrecursive(merge_opt,
base_tree,
result->tree,
pickme_tree,
result);
free((char*)merge_opt->ancestor);
merge_opt->ancestor = NULL;
if (!result->clean)
return NULL;
return replay_create_commit(repo, result->tree, pickme, replayed_base);
}

23
replay.h Normal file
View File

@@ -0,0 +1,23 @@
#ifndef REPLAY_H
#define REPLAY_H
#include "khash.h"
#include "merge-ort.h"
#include "repository.h"
struct commit;
struct tree;
struct commit *replay_create_commit(struct repository *repo,
struct tree *tree,
struct commit *based_on,
struct commit *parent);
struct commit *replay_pick_regular_commit(struct repository *repo,
struct commit *pickme,
kh_oid_map_t *replayed_commits,
struct commit *onto,
struct merge_options *merge_opt,
struct merge_result *result);
#endif

3
t/meson.build
View File

@@ -389,6 +389,9 @@ integration_tests = [
't3436-rebase-more-options.sh',
't3437-rebase-fixup-options.sh',
't3438-rebase-broken-files.sh',
't3450-history.sh',
't3451-history-reword.sh',
't3452-history-split.sh',
't3500-cherry.sh',
't3501-revert-cherry-pick.sh',
't3502-cherry-pick-merge.sh',

17
t/t3450-history.sh Executable file
View File

@@ -0,0 +1,17 @@
#!/bin/sh
test_description='tests for git-history command'
. ./test-lib.sh
test_expect_success 'does nothing without any arguments' '
test_must_fail git history 2>err &&
test_grep "need a subcommand" err
'
test_expect_success 'raises an error with unknown argument' '
test_must_fail git history garbage 2>err &&
test_grep "unknown subcommand: .garbage." err
'
test_done

236
t/t3451-history-reword.sh Executable file
View File

@@ -0,0 +1,236 @@
#!/bin/sh
test_description='tests for git-history reword subcommand'
. ./test-lib.sh
reword_with_message () {
cat >message &&
write_script fake-editor.sh <<-\EOF &&
cp message "$1"
EOF
test_set_editor "$(pwd)"/fake-editor.sh &&
git history reword "$@" &&
rm fake-editor.sh message
}
test_expect_success 'refuses to work with merge commits' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit base &&
git branch branch &&
test_commit ours &&
git switch branch &&
test_commit theirs &&
git switch - &&
git merge theirs &&
test_must_fail git history reword HEAD~ 2>err &&
test_grep "cannot rearrange commit history with merges" err &&
test_must_fail git history reword HEAD 2>err &&
test_grep "cannot rearrange commit history with merges" err
)
'
test_expect_success 'refuses to work with unrelated commits' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit base &&
git branch branch &&
test_commit ours &&
git switch branch &&
test_commit theirs &&
test_must_fail git history reword ours 2>err &&
test_grep "commit must be reachable from current HEAD commit" err
)
'
test_expect_success 'can reword tip of a branch' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit first &&
test_commit second &&
test_commit third &&
git symbolic-ref HEAD >expect &&
reword_with_message HEAD <<-EOF &&
third reworded
EOF
git symbolic-ref HEAD >actual &&
test_cmp expect actual &&
cat >expect <<-EOF &&
third reworded
second
first
EOF
git log --format=%s >actual &&
test_cmp expect actual &&
git reflog >reflog &&
test_grep "reword: updating HEAD" reflog
)
'
test_expect_success 'can reword commit in the middle' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit first &&
test_commit second &&
test_commit third &&
git symbolic-ref HEAD >expect &&
reword_with_message HEAD~ <<-EOF &&
second reworded
EOF
git symbolic-ref HEAD >actual &&
test_cmp expect actual &&
cat >expect <<-EOF &&
third
second reworded
first
EOF
git log --format=%s >actual &&
test_cmp expect actual
)
'
test_expect_success 'can reword root commit' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit first &&
test_commit second &&
test_commit third &&
reword_with_message HEAD~2 <<-EOF &&
first reworded
EOF
cat >expect <<-EOF &&
third
second
first reworded
EOF
git log --format=%s >actual &&
test_cmp expect actual
)
'
test_expect_success 'editor shows proper status' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit first &&
write_script fake-editor.sh <<-\EOF &&
cp "$1" . &&
printf "\namend a comment\n" >>"$1"
EOF
test_set_editor "$(pwd)"/fake-editor.sh &&
git history reword HEAD &&
cat >expect <<-EOF &&
first
# Please enter the commit message for the reworded changes. Lines starting
# with ${SQ}#${SQ} will be ignored, and an empty message aborts the commit.
# Changes to be committed:
# new file: first.t
#
EOF
test_cmp expect COMMIT_EDITMSG &&
test_commit_message HEAD <<-\EOF
first
amend a comment
EOF
)
'
# For now, git-history(1) does not yet execute any hooks. This is subject to
# change in the future, and if it does this test here is expected to start
# failing. In other words, this test is not an endorsement of the current
# status quo.
test_expect_success 'hooks are not executed for rewritten commits' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit first &&
test_commit second &&
test_commit third &&
ORIG_PATH="$(pwd)" &&
export ORIG_PATH &&
for hook in prepare-commit-msg pre-commit post-commit post-rewrite commit-msg
do
write_script .git/hooks/$hook <<-\EOF || exit 1
touch "$ORIG_PATH/hooks.log
EOF
done &&
reword_with_message HEAD~ <<-EOF &&
second reworded
EOF
cat >expect <<-EOF &&
third
second reworded
first
EOF
git log --format=%s >actual &&
test_cmp expect actual &&
test_path_is_missing hooks.log
)
'
test_expect_success 'aborts with empty commit message' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit first &&
! reword_with_message HEAD 2>err </dev/null &&
test_grep "Aborting commit due to empty commit message." err
)
'
test_expect_success 'retains changes in the worktree and index' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
touch a b &&
git add . &&
git commit -m "initial commit" &&
echo foo >a &&
echo bar >b &&
git add b &&
reword_with_message HEAD <<-EOF &&
message
EOF
cat >expect <<-\EOF &&
M a
M b
?? actual
?? expect
EOF
git status --porcelain >actual &&
test_cmp expect actual
)
'
test_done

452
t/t3452-history-split.sh Executable file
View File

@@ -0,0 +1,452 @@
#!/bin/sh
test_description='tests for git-history split subcommand'
. ./test-lib.sh
# The fake editor takes multiple arguments, each of which represents a commit
# message. Subsequent invocations of the editor will then yield those messages
# in order.
#
set_fake_editor () {
printf "%s\n" "$@" >fake-input &&
write_script fake-editor.sh <<-\EOF &&
head -n1 fake-input >"$1"
sed 1d fake-input >fake-input.trimmed &&
mv fake-input.trimmed fake-input
EOF
test_set_editor "$(pwd)"/fake-editor.sh
}
expect_log () {
git log --format="%s" >actual &&
cat >expect &&
test_cmp expect actual
}
expect_tree_entries () {
git ls-tree --name-only "$1" >actual &&
cat >expect &&
test_cmp expect actual
}
test_expect_success 'refuses to work with merge commits' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit base &&
git branch branch &&
test_commit ours &&
git switch branch &&
test_commit theirs &&
git switch - &&
git merge theirs &&
test_must_fail git history split HEAD 2>err &&
test_grep "cannot rearrange commit history with merges" err &&
test_must_fail git history split HEAD~ 2>err &&
test_grep "cannot rearrange commit history with merges" err
)
'
test_expect_success 'refuses to work with unrelated commits' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit base &&
git branch branch &&
test_commit ours &&
git switch branch &&
test_commit theirs &&
test_must_fail git history split ours 2>err &&
test_grep "commit must be reachable from current HEAD commit" err
)
'
test_expect_success 'can split up tip commit' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit initial &&
touch bar foo &&
git add . &&
git commit -m split-me &&
git symbolic-ref HEAD >expect &&
set_fake_editor "first" "second" &&
git history split HEAD <<-EOF &&
y
n
EOF
git symbolic-ref HEAD >actual &&
test_cmp expect actual &&
expect_log <<-EOF &&
second
first
initial
EOF
expect_tree_entries HEAD~ <<-EOF &&
bar
initial.t
EOF
expect_tree_entries HEAD <<-EOF &&
bar
foo
initial.t
EOF
git reflog >reflog &&
test_grep "split: updating HEAD" reflog
)
'
test_expect_success 'can split up root commit' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
touch bar foo &&
git add . &&
git commit -m root &&
test_commit tip &&
set_fake_editor "first" "second" &&
git history split HEAD~ <<-EOF &&
y
n
EOF
expect_log <<-EOF &&
tip
second
first
EOF
expect_tree_entries HEAD~2 <<-EOF &&
bar
EOF
expect_tree_entries HEAD~ <<-EOF &&
bar
foo
EOF
expect_tree_entries HEAD <<-EOF
bar
foo
tip.t
EOF
)
'
test_expect_success 'can split up in-between commit' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit initial &&
touch bar foo &&
git add . &&
git commit -m split-me &&
test_commit tip &&
set_fake_editor "first" "second" &&
git history split HEAD~ <<-EOF &&
y
n
EOF
expect_log <<-EOF &&
tip
second
first
initial
EOF
expect_tree_entries HEAD~2 <<-EOF &&
bar
initial.t
EOF
expect_tree_entries HEAD~ <<-EOF &&
bar
foo
initial.t
EOF
expect_tree_entries HEAD <<-EOF
bar
foo
initial.t
tip.t
EOF
)
'
test_expect_success 'can pick multiple hunks' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
touch bar baz foo qux &&
git add . &&
git commit -m split-me &&
set_fake_editor "first" "second" &&
git history split HEAD <<-EOF &&
y
n
y
n
EOF
expect_tree_entries HEAD~ <<-EOF &&
bar
foo
EOF
expect_tree_entries HEAD <<-EOF
bar
baz
foo
qux
EOF
)
'
test_expect_success 'can use only last hunk' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
touch bar foo &&
git add . &&
git commit -m split-me &&
set_fake_editor "first" "second" &&
git history split HEAD <<-EOF &&
n
y
EOF
expect_log <<-EOF &&
second
first
EOF
expect_tree_entries HEAD~ <<-EOF &&
foo
EOF
expect_tree_entries HEAD <<-EOF
bar
foo
EOF
)
'
test_expect_success 'aborts with empty commit message' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
touch bar foo &&
git add . &&
git commit -m split-me &&
set_fake_editor "" &&
test_must_fail git history split HEAD <<-EOF 2>err &&
y
n
EOF
test_grep "Aborting commit due to empty commit message." err
)
'
test_expect_success 'commit message editor sees split-out changes' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
touch bar foo &&
git add . &&
git commit -m split-me &&
write_script fake-editor.sh <<-\EOF &&
cat "$1" >>MESSAGES &&
echo "some commit message" >"$1"
EOF
test_set_editor "$(pwd)"/fake-editor.sh &&
git history split HEAD <<-EOF &&
y
n
EOF
# Note that we expect to see the messages twice, once for each
# of the commits. The committed files are different though.
cat >expect <<-EOF &&
split-me
# Please enter the commit message for the split-out changes. Lines starting
# with ${SQ}#${SQ} will be ignored, and an empty message aborts the commit.
# Changes to be committed:
# new file: bar
#
split-me
# Please enter the commit message for the split-out changes. Lines starting
# with ${SQ}#${SQ} will be ignored, and an empty message aborts the commit.
# Changes to be committed:
# new file: foo
#
EOF
test_cmp expect MESSAGES &&
expect_log <<-EOF
some commit message
some commit message
EOF
)
'
test_expect_success 'can use pathspec to limit what gets split' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
touch bar foo &&
git add . &&
git commit -m split-me &&
set_fake_editor "first" "second" &&
git history split HEAD -- foo <<-EOF &&
y
EOF
expect_tree_entries HEAD~ <<-EOF &&
foo
EOF
expect_tree_entries HEAD <<-EOF
bar
foo
EOF
)
'
test_expect_success 'refuses to create empty split-out commit' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
test_commit base &&
touch bar foo &&
git add . &&
git commit -m split-me &&
test_must_fail git history split HEAD 2>err <<-EOF &&
n
n
EOF
test_grep "split commit is empty" err
)
'
test_expect_success 'hooks are not executed for rewritten commits' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
touch bar foo &&
git add . &&
git commit -m split-me &&
old_head=$(git rev-parse HEAD) &&
ORIG_PATH="$(pwd)" &&
export ORIG_PATH &&
for hook in prepare-commit-msg pre-commit post-commit post-rewrite commit-msg
do
write_script .git/hooks/$hook <<-\EOF || exit 1
touch "$ORIG_PATH/hooks.log
EOF
done &&
set_fake_editor "first" "second" &&
git history split HEAD <<-EOF &&
y
n
EOF
expect_log <<-EOF &&
second
first
EOF
test_path_is_missing hooks.log
)
'
test_expect_success 'refuses to create empty original commit' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
touch bar foo &&
git add . &&
git commit -m split-me &&
test_must_fail git history split HEAD 2>err <<-EOF &&
y
y
EOF
test_grep "split commit tree matches original commit" err
)
'
test_expect_success 'retains changes in the worktree and index' '
test_when_finished "rm -rf repo" &&
git init repo &&
(
cd repo &&
echo a >a &&
echo b >b &&
git add . &&
git commit -m "initial commit" &&
echo a-modified >a &&
echo b-modified >b &&
git add b &&
set_fake_editor "a-only" "remainder" &&
git history split HEAD <<-EOF &&
y
n
EOF
expect_tree_entries HEAD~ <<-EOF &&
a
EOF
expect_tree_entries HEAD <<-EOF &&
a
b
EOF
cat >expect <<-\EOF &&
M a
M b
?? actual
?? expect
?? fake-editor.sh
?? fake-input
EOF
git status --porcelain >actual &&
test_cmp expect actual
)
'
test_done

24
wt-status.c
View File

@@ -612,6 +612,30 @@ static void wt_status_collect_updated_cb(struct diff_queue_struct *q,
}
}
void wt_status_collect_changes_trees(struct wt_status *s,
const struct object_id *old_treeish,
const struct object_id *new_treeish)
{
struct diff_options opts = { 0 };
repo_diff_setup(s->repo, &opts);
opts.output_format = DIFF_FORMAT_CALLBACK;
opts.format_callback = wt_status_collect_updated_cb;
opts.format_callback_data = s;
opts.detect_rename = s->detect_rename >= 0 ? s->detect_rename : opts.detect_rename;
opts.rename_limit = s->rename_limit >= 0 ? s->rename_limit : opts.rename_limit;
opts.rename_score = s->rename_score >= 0 ? s->rename_score : opts.rename_score;
opts.flags.recursive = 1;
diff_setup_done(&opts);
diff_tree_oid(old_treeish, new_treeish, "", &opts);
diffcore_std(&opts);
diff_flush(&opts);
wt_status_get_state(s->repo, &s->state, 0);
diff_free(&opts);
}
static void wt_status_collect_changes_worktree(struct wt_status *s)
{
struct rev_info rev;

9
wt-status.h
View File

@@ -153,6 +153,15 @@ void wt_status_add_cut_line(struct wt_status *s);
void wt_status_prepare(struct repository *r, struct wt_status *s);
void wt_status_print(struct wt_status *s);
void wt_status_collect(struct wt_status *s);
/*
* Collect all changes between the two trees. Changes will be displayed as if
* they were staged into the index.
*/
void wt_status_collect_changes_trees(struct wt_status *s,
const struct object_id *old_treeish,
const struct object_id *new_treeish);
/*
* Frees the buffers allocated by wt_status_collect.
*/