Merge branch 'tr/notes-display'

* tr/notes-display:
  git-notes(1): add a section about the meaning of history
  notes: track whether notes_trees were changed at all
  notes: add shorthand --ref to override GIT_NOTES_REF
  commit --amend: copy notes to the new commit
  rebase: support automatic notes copying
  notes: implement helpers needed for note copying during rewrite
  notes: implement 'git notes copy --stdin'
  rebase -i: invoke post-rewrite hook
  rebase: invoke post-rewrite hook
  commit --amend: invoke post-rewrite hook
  Documentation: document post-rewrite hook
  Support showing notes from more than one notes tree
  test-lib: unset GIT_NOTES_REF to stop it from influencing tests

Conflicts:
	git-am.sh
	refs.c
This commit is contained in:
Junio C Hamano 2010-03-24 16:26:43 -07:00
commit a86ed83cce
25 changed files with 1366 additions and 33 deletions

View File

@ -519,10 +519,12 @@ check that makes sure that existing object files will not get overwritten.
core.notesRef::
When showing commit messages, also show notes which are stored in
the given ref. This ref is expected to contain files named
after the full SHA-1 of the commit they annotate.
after the full SHA-1 of the commit they annotate. The ref
must be fully qualified.
+
If such a file exists in the given ref, the referenced blob is read, and
appended to the commit message, separated by a "Notes:" line. If the
appended to the commit message, separated by a "Notes (<refname>):"
line (shortened to "Notes:" in the case of "refs/notes/commits"). If the
given ref itself does not exist, it is not an error, but means that no
notes should be printed.
+
@ -1334,6 +1336,53 @@ mergetool.keepTemporaries::
mergetool.prompt::
Prompt before each invocation of the merge resolution program.
notes.displayRef::
The (fully qualified) refname from which to show notes when
showing commit messages. The value of this variable can be set
to a glob, in which case notes from all matching refs will be
shown. You may also specify this configuration variable
several times. A warning will be issued for refs that do not
exist, but a glob that does not match any refs is silently
ignored.
+
This setting can be overridden with the `GIT_NOTES_DISPLAY_REF`
environment variable, which must be a colon separated list of refs or
globs.
+
The effective value of "core.notesRef" (possibly overridden by
GIT_NOTES_REF) is also implicitly added to the list of refs to be
displayed.
notes.rewrite.<command>::
When rewriting commits with <command> (currently `amend` or
`rebase`) and this variable is set to `true`, git
automatically copies your notes from the original to the
rewritten commit. Defaults to `true`, but see
"notes.rewriteRef" below.
+
This setting can be overridden with the `GIT_NOTES_REWRITE_REF`
environment variable, which must be a colon separated list of refs or
globs.
notes.rewriteMode::
When copying notes during a rewrite (see the
"notes.rewrite.<command>" option), determines what to do if
the target commit already has a note. Must be one of
`overwrite`, `concatenate`, or `ignore`. Defaults to
`concatenate`.
+
This setting can be overridden with the `GIT_NOTES_REWRITE_MODE`
environment variable.
notes.rewriteRef::
When copying notes during a rewrite, specifies the (fully
qualified) ref whose notes should be copied. The ref may be a
glob, in which case notes in all matching refs will be copied.
You may also specify this configuration several times.
+
Does not have a default value; you must configure this variable to
enable note rewriting.
pack.window::
The size of the window used by linkgit:git-pack-objects[1] when no
window size is given on the command line. Defaults to 10.

View File

@ -10,7 +10,7 @@ SYNOPSIS
[verse]
'git notes' [list [<object>]]
'git notes' add [-f] [-F <file> | -m <msg> | (-c | -C) <object>] [<object>]
'git notes' copy [-f] <from-object> <to-object>
'git notes' copy [-f] ( --stdin | <from-object> <to-object> )
'git notes' append [-F <file> | -m <msg> | (-c | -C) <object>] [<object>]
'git notes' edit [<object>]
'git notes' show [<object>]
@ -27,12 +27,17 @@ A typical use of notes is to extend a commit message without having
to change the commit itself. Such commit notes can be shown by `git log`
along with the original commit message. To discern these notes from the
message stored in the commit object, the notes are indented like the
message, after an unindented line saying "Notes:".
message, after an unindented line saying "Notes (<refname>):" (or
"Notes:" for the default setting).
To disable notes, you have to set the config variable core.notesRef to
the empty string. Alternatively, you can set it to a different ref,
something like "refs/notes/bugzilla". This setting can be overridden
by the environment variable "GIT_NOTES_REF".
This command always manipulates the notes specified in "core.notesRef"
(see linkgit:git-config[1]), which can be overridden by GIT_NOTES_REF.
To change which notes are shown by 'git-log', see the
"notes.displayRef" configuration.
See the description of "notes.rewrite.<command>" in
linkgit:git-config[1] for a way of carrying your notes across commands
that rewrite commits.
SUBCOMMANDS
@ -55,6 +60,16 @@ copy::
object has none (use -f to overwrite existing notes to the
second object). This subcommand is equivalent to:
`git notes add [-f] -C $(git notes list <from-object>) <to-object>`
+
In `\--stdin` mode, take lines in the format
+
----------
<from-object> SP <to-object> [ SP <rest> ] LF
----------
+
on standard input, and copy the notes from each <from-object> to its
corresponding <to-object>. (The optional `<rest>` is ignored so that
the command can read the input given to the `post-rewrite` hook.)
append::
Append to the notes of an existing object (defaults to HEAD).
@ -101,6 +116,25 @@ OPTIONS
Like '-C', but with '-c' the editor is invoked, so that
the user can further edit the note message.
--ref <ref>::
Manipulate the notes tree in <ref>. This overrides both
GIT_NOTES_REF and the "core.notesRef" configuration. The ref
is taken to be in `refs/notes/` if it is not qualified.
NOTES
-----
Every notes change creates a new commit at the specified notes ref.
You can therefore inspect the history of the notes by invoking, e.g.,
`git log -p notes/commits`.
Currently the commit message only records which operation triggered
the update, and the commit authorship is determined according to the
usual rules (see linkgit:git-commit[1]). These details may change in
the future.
Author
------
Written by Johannes Schindelin <johannes.schindelin@gmx.de> and

View File

@ -317,6 +317,44 @@ This hook is invoked by 'git gc --auto'. It takes no parameter, and
exiting with non-zero status from this script causes the 'git gc --auto'
to abort.
post-rewrite
~~~~~~~~~~~~
This hook is invoked by commands that rewrite commits (`git commit
--amend`, 'git-rebase'; currently 'git-filter-branch' does 'not' call
it!). Its first argument denotes the command it was invoked by:
currently one of `amend` or `rebase`. Further command-dependent
arguments may be passed in the future.
The hook receives a list of the rewritten commits on stdin, in the
format
<old-sha1> SP <new-sha1> [ SP <extra-info> ] LF
The 'extra-info' is again command-dependent. If it is empty, the
preceding SP is also omitted. Currently, no commands pass any
'extra-info'.
The hook always runs after the automatic note copying (see
"notes.rewrite.<command>" in linkgit:git-config.txt) has happened, and
thus has access to these notes.
The following command-specific comments apply:
rebase::
For the 'squash' and 'fixup' operation, all commits that were
squashed are listed as being rewritten to the squashed commit.
This means that there will be several lines sharing the same
'new-sha1'.
+
The commits are guaranteed to be listed in the order that they were
processed by rebase.
There is no default 'post-rewrite' hook, but see the
`post-receive-copy-notes` script in `contrib/hooks` for an example
that copies your git-notes to the rewritten commits.
GIT
---
Part of the linkgit:git[1] suite

View File

@ -30,9 +30,18 @@ people using 80-column terminals.
defaults to UTF-8.
--no-notes::
--show-notes::
--show-notes[=<ref>]::
Show the notes (see linkgit:git-notes[1]) that annotate the
commit, when showing the commit log message. This is the default
for `git log`, `git show` and `git whatchanged` commands when
there is no `--pretty`, `--format` nor `--oneline` option is
given on the command line.
+
With an optional argument, add this ref to the list of notes. The ref
is taken to be in `refs/notes/` if it is not qualified.
--[no-]standard-notes::
Enable or disable populating the notes ref list from the
'core.notesRef' and 'notes.displayRef' variables (or
corresponding environment overrides). Enabled by default.
See linkgit:git-config[1].

View File

@ -20,6 +20,23 @@ extern int commit_tree(const char *msg, unsigned char *tree,
struct commit_list *parents, unsigned char *ret,
const char *author);
extern int commit_notes(struct notes_tree *t, const char *msg);
struct notes_rewrite_cfg {
struct notes_tree **trees;
const char *cmd;
int enabled;
combine_notes_fn *combine;
struct string_list *refs;
int refs_from_env;
int mode_from_env;
};
combine_notes_fn *parse_combine_notes_fn(const char *v);
struct notes_rewrite_cfg *init_copy_notes_for_rewrite(const char *cmd);
int copy_note_for_rewrite(struct notes_rewrite_cfg *c,
const unsigned char *from_obj, const unsigned char *to_obj);
void finish_copy_notes_for_rewrite(struct notes_rewrite_cfg *c);
extern int check_pager_config(const char *cmd);
extern int cmd_add(int argc, const char **argv, const char *prefix);

View File

@ -66,6 +66,7 @@ static char *edit_message, *use_message;
static char *author_name, *author_email, *author_date;
static int all, edit_flag, also, interactive, only, amend, signoff;
static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
static int no_post_rewrite;
static char *untracked_files_arg, *force_date;
/*
* The default commit message cleanup mode will remove the lines
@ -137,6 +138,7 @@ static struct option builtin_commit_options[] = {
OPT_BOOLEAN('z', "null", &null_termination,
"terminate entries with NUL"),
OPT_BOOLEAN(0, "amend", &amend, "amend previous commit"),
OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, "bypass post-rewrite hook"),
{ OPTION_STRING, 'u', "untracked-files", &untracked_files_arg, "mode", "show untracked files, optional modes: all, normal, no. (Default: all)", PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
OPT_BOOLEAN(0, "allow-empty", &allow_empty, "ok to record an empty change"),
/* end commit contents options */
@ -1160,6 +1162,40 @@ static int git_commit_config(const char *k, const char *v, void *cb)
return git_status_config(k, v, s);
}
static const char post_rewrite_hook[] = "hooks/post-rewrite";
static int run_rewrite_hook(const unsigned char *oldsha1,
const unsigned char *newsha1)
{
/* oldsha1 SP newsha1 LF NUL */
static char buf[2*40 + 3];
struct child_process proc;
const char *argv[3];
int code;
size_t n;
if (access(git_path(post_rewrite_hook), X_OK) < 0)
return 0;
argv[0] = git_path(post_rewrite_hook);
argv[1] = "amend";
argv[2] = NULL;
memset(&proc, 0, sizeof(proc));
proc.argv = argv;
proc.in = -1;
proc.stdout_to_stderr = 1;
code = start_command(&proc);
if (code)
return code;
n = snprintf(buf, sizeof(buf), "%s %s\n",
sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
write_in_full(proc.in, buf, n);
close(proc.in);
return finish_command(&proc);
}
int cmd_commit(int argc, const char **argv, const char *prefix)
{
struct strbuf sb = STRBUF_INIT;
@ -1303,6 +1339,15 @@ int cmd_commit(int argc, const char **argv, const char *prefix)
rerere(0);
run_hook(get_index_file(), "post-commit", NULL);
if (amend && !no_post_rewrite) {
struct notes_rewrite_cfg *cfg;
cfg = init_copy_notes_for_rewrite("amend");
if (cfg) {
copy_note_for_rewrite(cfg, head_sha1, commit_sha1);
finish_copy_notes_for_rewrite(cfg);
}
run_rewrite_hook(head_sha1, commit_sha1);
}
if (!quiet)
print_summary(prefix, commit_sha1);

View File

@ -60,6 +60,8 @@ static void cmd_log_init(int argc, const char **argv, const char *prefix,
if (!rev->show_notes_given && !rev->pretty_given)
rev->show_notes = 1;
if (rev->show_notes)
init_display_notes(&rev->notes_opt);
if (rev->diffopt.pickaxe || rev->diffopt.filter)
rev->always_show_header = 0;
@ -1105,6 +1107,9 @@ int cmd_format_patch(int argc, const char **argv, const char *prefix)
if (!DIFF_OPT_TST(&rev.diffopt, TEXT) && !no_binary_diff)
DIFF_OPT_SET(&rev.diffopt, BINARY);
if (rev.show_notes)
init_display_notes(&rev.notes_opt);
if (!use_stdout)
output_directory = set_outdir(prefix, output_directory);

View File

@ -16,6 +16,7 @@
#include "exec_cmd.h"
#include "run-command.h"
#include "parse-options.h"
#include "string-list.h"
static const char * const git_notes_usage[] = {
"git notes [list [<object>]]",
@ -239,6 +240,8 @@ int commit_notes(struct notes_tree *t, const char *msg)
t = &default_notes_tree;
if (!t->initialized || !t->ref || !*t->ref)
die("Cannot commit uninitialized/unreferenced notes tree");
if (!t->dirty)
return 0; /* don't have to commit an unchanged tree */
/* Prepare commit message and reflog message */
strbuf_addstr(&buf, "notes: "); /* commit message starts at index 7 */
@ -269,6 +272,161 @@ int commit_notes(struct notes_tree *t, const char *msg)
return 0;
}
combine_notes_fn *parse_combine_notes_fn(const char *v)
{
if (!strcasecmp(v, "overwrite"))
return combine_notes_overwrite;
else if (!strcasecmp(v, "ignore"))
return combine_notes_ignore;
else if (!strcasecmp(v, "concatenate"))
return combine_notes_concatenate;
else
return NULL;
}
static int notes_rewrite_config(const char *k, const char *v, void *cb)
{
struct notes_rewrite_cfg *c = cb;
if (!prefixcmp(k, "notes.rewrite.") && !strcmp(k+14, c->cmd)) {
c->enabled = git_config_bool(k, v);
return 0;
} else if (!c->mode_from_env && !strcmp(k, "notes.rewritemode")) {
if (!v)
config_error_nonbool(k);
c->combine = parse_combine_notes_fn(v);
if (!c->combine) {
error("Bad notes.rewriteMode value: '%s'", v);
return 1;
}
return 0;
} else if (!c->refs_from_env && !strcmp(k, "notes.rewriteref")) {
/* note that a refs/ prefix is implied in the
* underlying for_each_glob_ref */
if (!prefixcmp(v, "refs/notes/"))
string_list_add_refs_by_glob(c->refs, v);
else
warning("Refusing to rewrite notes in %s"
" (outside of refs/notes/)", v);
return 0;
}
return 0;
}
struct notes_rewrite_cfg *init_copy_notes_for_rewrite(const char *cmd)
{
struct notes_rewrite_cfg *c = xmalloc(sizeof(struct notes_rewrite_cfg));
const char *rewrite_mode_env = getenv(GIT_NOTES_REWRITE_MODE_ENVIRONMENT);
const char *rewrite_refs_env = getenv(GIT_NOTES_REWRITE_REF_ENVIRONMENT);
c->cmd = cmd;
c->enabled = 1;
c->combine = combine_notes_concatenate;
c->refs = xcalloc(1, sizeof(struct string_list));
c->refs->strdup_strings = 1;
c->refs_from_env = 0;
c->mode_from_env = 0;
if (rewrite_mode_env) {
c->mode_from_env = 1;
c->combine = parse_combine_notes_fn(rewrite_mode_env);
if (!c->combine)
error("Bad " GIT_NOTES_REWRITE_MODE_ENVIRONMENT
" value: '%s'", rewrite_mode_env);
}
if (rewrite_refs_env) {
c->refs_from_env = 1;
string_list_add_refs_from_colon_sep(c->refs, rewrite_refs_env);
}
git_config(notes_rewrite_config, c);
if (!c->enabled || !c->refs->nr) {
string_list_clear(c->refs, 0);
free(c->refs);
free(c);
return NULL;
}
c->trees = load_notes_trees(c->refs);
string_list_clear(c->refs, 0);
free(c->refs);
return c;
}
int copy_note_for_rewrite(struct notes_rewrite_cfg *c,
const unsigned char *from_obj, const unsigned char *to_obj)
{
int ret = 0;
int i;
for (i = 0; c->trees[i]; i++)
ret = copy_note(c->trees[i], from_obj, to_obj, 1, c->combine) || ret;
return ret;
}
void finish_copy_notes_for_rewrite(struct notes_rewrite_cfg *c)
{
int i;
for (i = 0; c->trees[i]; i++) {
commit_notes(c->trees[i], "Notes added by 'git notes copy'");
free_notes(c->trees[i]);
}
free(c->trees);
free(c);
}
int notes_copy_from_stdin(int force, const char *rewrite_cmd)
{
struct strbuf buf = STRBUF_INIT;
struct notes_rewrite_cfg *c = NULL;
struct notes_tree *t;
int ret = 0;
if (rewrite_cmd) {
c = init_copy_notes_for_rewrite(rewrite_cmd);
if (!c)
return 0;
} else {
init_notes(NULL, NULL, NULL, 0);
t = &default_notes_tree;
}
while (strbuf_getline(&buf, stdin, '\n') != EOF) {
unsigned char from_obj[20], to_obj[20];
struct strbuf **split;
int err;
split = strbuf_split(&buf, ' ');
if (!split[0] || !split[1])
die("Malformed input line: '%s'.", buf.buf);
strbuf_rtrim(split[0]);
strbuf_rtrim(split[1]);
if (get_sha1(split[0]->buf, from_obj))
die("Failed to resolve '%s' as a valid ref.", split[0]->buf);
if (get_sha1(split[1]->buf, to_obj))
die("Failed to resolve '%s' as a valid ref.", split[1]->buf);
if (rewrite_cmd)
err = copy_note_for_rewrite(c, from_obj, to_obj);
else
err = copy_note(t, from_obj, to_obj, force,
combine_notes_overwrite);
if (err) {
error("Failed to copy notes from '%s' to '%s'",
split[0]->buf, split[1]->buf);
ret = 1;
}
strbuf_list_free(split);
}
if (!rewrite_cmd) {
commit_notes(t, "Notes added by 'git notes copy'");
free_notes(t);
} else {
finish_copy_notes_for_rewrite(c);
}
return ret;
}
int cmd_notes(int argc, const char **argv, const char *prefix)
{
struct notes_tree *t;
@ -278,9 +436,11 @@ int cmd_notes(int argc, const char **argv, const char *prefix)
char logmsg[100];
int list = 0, add = 0, copy = 0, append = 0, edit = 0, show = 0,
remove = 0, prune = 0, force = 0;
remove = 0, prune = 0, force = 0, from_stdin = 0;
int given_object = 0, i = 1, retval = 0;
struct msg_arg msg = { 0, 0, STRBUF_INIT };
const char *rewrite_cmd = NULL;
const char *override_notes_ref = NULL;
struct option options[] = {
OPT_GROUP("Notes contents options"),
{ OPTION_CALLBACK, 'm', "message", &msg, "MSG",
@ -297,6 +457,11 @@ int cmd_notes(int argc, const char **argv, const char *prefix)
parse_reuse_arg},
OPT_GROUP("Other options"),
OPT_BOOLEAN('f', "force", &force, "replace existing notes"),
OPT_BOOLEAN(0, "stdin", &from_stdin, "read objects from stdin"),
OPT_STRING(0, "ref", &override_notes_ref, "notes_ref",
"use notes from <notes_ref>"),
OPT_STRING(0, "for-rewrite", &rewrite_cmd, "command",
"load rewriting config for <command> (implies --stdin)"),
OPT_END()
};
@ -304,6 +469,19 @@ int cmd_notes(int argc, const char **argv, const char *prefix)
argc = parse_options(argc, argv, prefix, options, git_notes_usage, 0);
if (override_notes_ref) {
struct strbuf sb = STRBUF_INIT;
if (!prefixcmp(override_notes_ref, "refs/notes/"))
/* we're happy */;
else if (!prefixcmp(override_notes_ref, "notes/"))
strbuf_addstr(&sb, "refs/");
else
strbuf_addstr(&sb, "refs/notes/");
strbuf_addstr(&sb, override_notes_ref);
setenv("GIT_NOTES_REF", sb.buf, 1);
strbuf_release(&sb);
}
if (argc && !strcmp(argv[0], "list"))
list = 1;
else if (argc && !strcmp(argv[0], "add"))
@ -345,8 +523,25 @@ int cmd_notes(int argc, const char **argv, const char *prefix)
usage_with_options(git_notes_usage, options);
}
if (!copy && rewrite_cmd) {
error("cannot use --for-rewrite with %s subcommand.", argv[0]);
usage_with_options(git_notes_usage, options);
}
if (!copy && from_stdin) {
error("cannot use --stdin with %s subcommand.", argv[0]);
usage_with_options(git_notes_usage, options);
}
if (copy) {
const char *from_ref;
if (from_stdin || rewrite_cmd) {
if (argc > 1) {
error("too many parameters");
usage_with_options(git_notes_usage, options);
} else {
return notes_copy_from_stdin(force, rewrite_cmd);
}
}
if (argc < 3) {
error("too few parameters");
usage_with_options(git_notes_usage, options);

View File

@ -387,6 +387,9 @@ static inline enum object_type object_type(unsigned int mode)
#define ATTRIBUTE_MACRO_PREFIX "[attr]"
#define GIT_NOTES_REF_ENVIRONMENT "GIT_NOTES_REF"
#define GIT_NOTES_DEFAULT_REF "refs/notes/commits"
#define GIT_NOTES_DISPLAY_REF_ENVIRONMENT "GIT_NOTES_DISPLAY_REF"
#define GIT_NOTES_REWRITE_REF_ENVIRONMENT "GIT_NOTES_REWRITE_REF"
#define GIT_NOTES_REWRITE_MODE_ENVIRONMENT "GIT_NOTES_REWRITE_MODE"
/*
* Repository-local GIT_* environment variables

View File

@ -593,6 +593,7 @@ do
echo "Patch is empty. Was it split wrong?"
stop_here $this
}
rm -f "$dotest/original-commit"
if test -f "$dotest/rebasing" &&
commit=$(sed -e 's/^From \([0-9a-f]*\) .*/\1/' \
-e q "$dotest/$msgnum") &&
@ -600,6 +601,7 @@ do
then
git cat-file commit "$commit" |
sed -e '1,/^$/d' >"$dotest/msg-clean"
echo "$commit" > "$dotest/original-commit"
else
{
sed -n '/^Subject/ s/Subject: //p' "$dotest/info"
@ -783,6 +785,10 @@ do
git update-ref -m "$GIT_REFLOG_ACTION: $FIRSTLINE" HEAD $commit $parent ||
stop_here $this
if test -f "$dotest/original-commit"; then
echo "$(cat "$dotest/original-commit") $commit" >> "$dotest/rewritten"
fi
if test -x "$GIT_DIR"/hooks/post-applypatch
then
"$GIT_DIR"/hooks/post-applypatch
@ -791,5 +797,12 @@ do
go_next
done
if test -s "$dotest"/rewritten; then
git notes copy --for-rewrite=rebase < "$dotest"/rewritten
if test -x "$GIT_DIR"/hooks/post-rewrite; then
"$GIT_DIR"/hooks/post-rewrite rebase < "$dotest"/rewritten
fi
fi
rm -fr "$dotest"
git gc --auto

View File

@ -96,6 +96,13 @@ AUTHOR_SCRIPT="$DOTEST"/author-script
# command is processed, this file is deleted.
AMEND="$DOTEST"/amend
# For the post-rewrite hook, we make a list of rewritten commits and
# their new sha1s. The rewritten-pending list keeps the sha1s of
# commits that have been processed, but not committed yet,
# e.g. because they are waiting for a 'squash' command.
REWRITTEN_LIST="$DOTEST"/rewritten-list
REWRITTEN_PENDING="$DOTEST"/rewritten-pending
PRESERVE_MERGES=
STRATEGY=
ONTO=
@ -198,6 +205,7 @@ make_patch () {
}
die_with_patch () {
echo "$1" > "$DOTEST"/stopped-sha
make_patch "$1"
git rerere
die "$2"
@ -348,6 +356,7 @@ pick_one_preserving_merges () {
printf "%s\n" "$msg" > "$GIT_DIR"/MERGE_MSG
die_with_patch $sha1 "Error redoing merge $sha1"
fi
echo "$sha1 $(git rev-parse HEAD^0)" >> "$REWRITTEN_LIST"
;;
*)
output git cherry-pick "$@" ||
@ -425,6 +434,26 @@ die_failed_squash() {
die_with_patch $1 ""
}
flush_rewritten_pending() {
test -s "$REWRITTEN_PENDING" || return
newsha1="$(git rev-parse HEAD^0)"
sed "s/$/ $newsha1/" < "$REWRITTEN_PENDING" >> "$REWRITTEN_LIST"
rm -f "$REWRITTEN_PENDING"
}
record_in_rewritten() {
oldsha1="$(git rev-parse $1)"
echo "$oldsha1" >> "$REWRITTEN_PENDING"
case "$(peek_next_command)" in
squash|s|fixup|f)
;;
*)
flush_rewritten_pending
;;
esac
}
do_next () {
rm -f "$MSG" "$AUTHOR_SCRIPT" "$AMEND" || exit
read command sha1 rest < "$TODO"
@ -438,6 +467,7 @@ do_next () {
mark_action_done
pick_one $sha1 ||
die_with_patch $sha1 "Could not apply $sha1... $rest"
record_in_rewritten $sha1
;;
reword|r)
comment_for_reflog reword
@ -445,7 +475,8 @@ do_next () {
mark_action_done
pick_one $sha1 ||
die_with_patch $sha1 "Could not apply $sha1... $rest"
git commit --amend
git commit --amend --no-post-rewrite
record_in_rewritten $sha1
;;
edit|e)
comment_for_reflog edit
@ -453,6 +484,7 @@ do_next () {
mark_action_done
pick_one $sha1 ||
die_with_patch $sha1 "Could not apply $sha1... $rest"
echo "$1" > "$DOTEST"/stopped-sha
make_patch $sha1
git rev-parse --verify HEAD > "$AMEND"
warn "Stopped at $sha1... $rest"
@ -509,6 +541,7 @@ do_next () {
rm -f "$SQUASH_MSG" "$FIXUP_MSG"
;;
esac
record_in_rewritten $sha1
;;
*)
warn "Unknown command: $command $sha1 $rest"
@ -537,6 +570,15 @@ do_next () {
test ! -f "$DOTEST"/verbose ||
git diff-tree --stat $(cat "$DOTEST"/head)..HEAD
} &&
{
git notes copy --for-rewrite=rebase < "$REWRITTEN_LIST" ||
true # we don't care if this copying failed
} &&
if test -x "$GIT_DIR"/hooks/post-rewrite &&
test -s "$REWRITTEN_LIST"; then
"$GIT_DIR"/hooks/post-rewrite rebase < "$REWRITTEN_LIST"
true # we don't care if this hook failed
fi &&
rm -rf "$DOTEST" &&
git gc --auto &&
warn "Successfully rebased and updated $HEADNAME."
@ -571,7 +613,12 @@ skip_unnecessary_picks () {
esac
echo "$command${sha1:+ }$sha1${rest:+ }$rest" >&$fd
done <"$TODO" >"$TODO.new" 3>>"$DONE" &&
mv -f "$TODO".new "$TODO" ||
mv -f "$TODO".new "$TODO" &&
case "$(peek_next_command)" in
squash|s|fixup|f)
record_in_rewritten "$ONTO"
;;
esac ||
die "Could not skip unnecessary pick commands"
}
@ -685,6 +732,7 @@ first and then run 'git rebase --continue' again."
test -n "$amend" && git reset --soft $amend
die "Could not commit staged changes."
}
record_in_rewritten "$(cat "$DOTEST"/stopped-sha)"
fi
require_clean_work_tree

View File

@ -79,6 +79,7 @@ continue_merge () {
then
printf "Committed: %0${prec}d " $msgnum
fi
echo "$cmt $(git rev-parse HEAD^0)" >> "$dotest/rewritten"
else
if test -z "$GIT_QUIET"
then
@ -151,6 +152,11 @@ move_to_original_branch () {
finish_rb_merge () {
move_to_original_branch
git notes copy --for-rewrite=rebase < "$dotest"/rewritten
if test -x "$GIT_DIR"/hooks/post-rewrite &&
test -s "$dotest"/rewritten; then
"$GIT_DIR"/hooks/post-rewrite rebase < "$dotest"/rewritten
fi
rm -r "$dotest"
say All done.
}

188
notes.c
View File

@ -5,6 +5,8 @@
#include "utf8.h"
#include "strbuf.h"
#include "tree-walk.h"
#include "string-list.h"
#include "refs.h"
/*
* Use a non-balancing simple 16-tree structure with struct int_node as
@ -68,6 +70,9 @@ struct non_note {
struct notes_tree default_notes_tree;
static struct string_list display_notes_refs;
static struct notes_tree **display_notes_trees;
static void load_subtree(struct notes_tree *t, struct leaf_node *subtree,
struct int_node *node, unsigned int n);
@ -828,6 +833,83 @@ int combine_notes_ignore(unsigned char *cur_sha1,
return 0;
}
static int string_list_add_one_ref(const char *path, const unsigned char *sha1,
int flag, void *cb)
{
struct string_list *refs = cb;
if (!unsorted_string_list_has_string(refs, path))
string_list_append(path, refs);
return 0;
}
void string_list_add_refs_by_glob(struct string_list *list, const char *glob)
{
if (has_glob_specials(glob)) {
for_each_glob_ref(string_list_add_one_ref, glob, list);
} else {
unsigned char sha1[20];
if (get_sha1(glob, sha1))
warning("notes ref %s is invalid", glob);
if (!unsorted_string_list_has_string(list, glob))
string_list_append(glob, list);
}
}
void string_list_add_refs_from_colon_sep(struct string_list *list,
const char *globs)
{
struct strbuf globbuf = STRBUF_INIT;
struct strbuf **split;
int i;
strbuf_addstr(&globbuf, globs);
split = strbuf_split(&globbuf, ':');
for (i = 0; split[i]; i++) {
if (!split[i]->len)
continue;
if (split[i]->buf[split[i]->len-1] == ':')
strbuf_setlen(split[i], split[i]->len-1);
string_list_add_refs_by_glob(list, split[i]->buf);
}
strbuf_list_free(split);
strbuf_release(&globbuf);
}
static int string_list_add_refs_from_list(struct string_list_item *item,
void *cb)
{
struct string_list *list = cb;
string_list_add_refs_by_glob(list, item->string);
return 0;
}
static int notes_display_config(const char *k, const char *v, void *cb)
{
int *load_refs = cb;
if (*load_refs && !strcmp(k, "notes.displayref")) {
if (!v)
config_error_nonbool(k);
string_list_add_refs_by_glob(&display_notes_refs, v);
}
return 0;
}
static const char *default_notes_ref(void)
{
const char *notes_ref = NULL;
if (!notes_ref)
notes_ref = getenv(GIT_NOTES_REF_ENVIRONMENT);
if (!notes_ref)
notes_ref = notes_ref_name; /* value of core.notesRef config */
if (!notes_ref)
notes_ref = GIT_NOTES_DEFAULT_REF;
return notes_ref;
}
void init_notes(struct notes_tree *t, const char *notes_ref,
combine_notes_fn combine_notes, int flags)
{
@ -840,11 +922,7 @@ void init_notes(struct notes_tree *t, const char *notes_ref,
assert(!t->initialized);
if (!notes_ref)
notes_ref = getenv(GIT_NOTES_REF_ENVIRONMENT);
if (!notes_ref)
notes_ref = notes_ref_name; /* value of core.notesRef config */
if (!notes_ref)
notes_ref = GIT_NOTES_DEFAULT_REF;
notes_ref = default_notes_ref();
if (!combine_notes)
combine_notes = combine_notes_concatenate;
@ -855,6 +933,7 @@ void init_notes(struct notes_tree *t, const char *notes_ref,
t->ref = notes_ref ? xstrdup(notes_ref) : NULL;
t->combine_notes = combine_notes;
t->initialized = 1;
t->dirty = 0;
if (flags & NOTES_INIT_EMPTY || !notes_ref ||
read_ref(notes_ref, object_sha1))
@ -868,6 +947,63 @@ void init_notes(struct notes_tree *t, const char *notes_ref,
load_subtree(t, &root_tree, t->root, 0);
}
struct load_notes_cb_data {
int counter;
struct notes_tree **trees;
};
static int load_one_display_note_ref(struct string_list_item *item,
void *cb_data)
{
struct load_notes_cb_data *c = cb_data;
struct notes_tree *t = xcalloc(1, sizeof(struct notes_tree));
init_notes(t, item->string, combine_notes_ignore, 0);
c->trees[c->counter++] = t;
return 0;
}
struct notes_tree **load_notes_trees(struct string_list *refs)
{
struct notes_tree **trees;
struct load_notes_cb_data cb_data;
trees = xmalloc((refs->nr+1) * sizeof(struct notes_tree *));
cb_data.counter = 0;
cb_data.trees = trees;
for_each_string_list(load_one_display_note_ref, refs, &cb_data);
trees[cb_data.counter] = NULL;
return trees;
}
void init_display_notes(struct display_notes_opt *opt)
{
char *display_ref_env;
int load_config_refs = 0;
display_notes_refs.strdup_strings = 1;
assert(!display_notes_trees);
if (!opt || !opt->suppress_default_notes) {
string_list_append(default_notes_ref(), &display_notes_refs);
display_ref_env = getenv(GIT_NOTES_DISPLAY_REF_ENVIRONMENT);
if (display_ref_env) {
string_list_add_refs_from_colon_sep(&display_notes_refs,
display_ref_env);
load_config_refs = 0;
} else
load_config_refs = 1;
}
git_config(notes_display_config, &load_config_refs);
if (opt && opt->extra_notes_refs)
for_each_string_list(string_list_add_refs_from_list,
opt->extra_notes_refs,
&display_notes_refs);
display_notes_trees = load_notes_trees(&display_notes_refs);
string_list_clear(&display_notes_refs, 0);
}
void add_note(struct notes_tree *t, const unsigned char *object_sha1,
const unsigned char *note_sha1, combine_notes_fn combine_notes)
{
@ -876,6 +1012,7 @@ void add_note(struct notes_tree *t, const unsigned char *object_sha1,
if (!t)
t = &default_notes_tree;
assert(t->initialized);
t->dirty = 1;
if (!combine_notes)
combine_notes = t->combine_notes;
l = (struct leaf_node *) xmalloc(sizeof(struct leaf_node));
@ -891,6 +1028,7 @@ void remove_note(struct notes_tree *t, const unsigned char *object_sha1)
if (!t)
t = &default_notes_tree;
assert(t->initialized);
t->dirty = 1;
hashcpy(l.key_sha1, object_sha1);
hashclr(l.val_sha1);
note_tree_remove(t, t->root, 0, &l);
@ -1016,8 +1154,18 @@ void format_note(struct notes_tree *t, const unsigned char *object_sha1,
if (msglen && msg[msglen - 1] == '\n')
msglen--;
if (flags & NOTES_SHOW_HEADER)
if (flags & NOTES_SHOW_HEADER) {
const char *ref = t->ref;
if (!ref || !strcmp(ref, GIT_NOTES_DEFAULT_REF)) {
strbuf_addstr(sb, "\nNotes:\n");
} else {
if (!prefixcmp(ref, "refs/"))
ref += 5;
if (!prefixcmp(ref, "notes/"))
ref += 6;
strbuf_addf(sb, "\nNotes (%s):\n", ref);
}
}
for (msg_p = msg; msg_p < msg + msglen; msg_p += linelen + 1) {
linelen = strchrnul(msg_p, '\n') - msg_p;
@ -1030,3 +1178,31 @@ void format_note(struct notes_tree *t, const unsigned char *object_sha1,
free(msg);
}
void format_display_notes(const unsigned char *object_sha1,
struct strbuf *sb, const char *output_encoding, int flags)
{
int i;
assert(display_notes_trees);
for (i = 0; display_notes_trees[i]; i++)
format_note(display_notes_trees[i], object_sha1, sb,
output_encoding, flags);
}
int copy_note(struct notes_tree *t,
const unsigned char *from_obj, const unsigned char *to_obj,
int force, combine_notes_fn combine_fn)
{
const unsigned char *note = get_note(t, from_obj);
const unsigned char *existing_note = get_note(t, to_obj);
if (!force && existing_note)
return 1;
if (note)
add_note(t, to_obj, note, combine_fn);
else if (existing_note)
add_note(t, to_obj, null_sha1, combine_fn);
return 0;
}

65
notes.h
View File

@ -40,6 +40,7 @@ extern struct notes_tree {
char *ref;
combine_notes_fn *combine_notes;
int initialized;
int dirty;
} default_notes_tree;
/*
@ -99,6 +100,15 @@ void remove_note(struct notes_tree *t, const unsigned char *object_sha1);
const unsigned char *get_note(struct notes_tree *t,
const unsigned char *object_sha1);
/*
* Copy a note from one object to another in the given notes_tree.
*
* Fails if the to_obj already has a note unless 'force' is true.
*/
int copy_note(struct notes_tree *t,
const unsigned char *from_obj, const unsigned char *to_obj,
int force, combine_notes_fn combine_fn);
/*
* Flags controlling behaviour of for_each_note()
*
@ -198,4 +208,59 @@ void free_notes(struct notes_tree *t);
void format_note(struct notes_tree *t, const unsigned char *object_sha1,
struct strbuf *sb, const char *output_encoding, int flags);
struct string_list;
struct display_notes_opt {
int suppress_default_notes:1;
struct string_list *extra_notes_refs;
};
/*
* Load the notes machinery for displaying several notes trees.
*
* If 'opt' is not NULL, then it specifies additional settings for the
* displaying:
*
* - suppress_default_notes indicates that the notes from
* core.notesRef and notes.displayRef should not be loaded.
*
* - extra_notes_refs may contain a list of globs (in the same style
* as notes.displayRef) where notes should be loaded from.
*/
void init_display_notes(struct display_notes_opt *opt);
/*
* Append notes for the given 'object_sha1' from all trees set up by
* init_display_notes() to 'sb'. The 'flags' are a bitwise
* combination of
*
* - NOTES_SHOW_HEADER: add a 'Notes (refname):' header
*
* - NOTES_INDENT: indent the notes by 4 places
*
* You *must* call init_display_notes() before using this function.
*/
void format_display_notes(const unsigned char *object_sha1,
struct strbuf *sb, const char *output_encoding, int flags);
/*
* Load the notes tree from each ref listed in 'refs'. The output is
* an array of notes_tree*, terminated by a NULL.
*/
struct notes_tree **load_notes_trees(struct string_list *refs);
/*
* Add all refs that match 'glob' to the 'list'.
*/
void string_list_add_refs_by_glob(struct string_list *list, const char *glob);
/*
* Add all refs from a colon-separated glob list 'globs' to the end of
* 'list'. Empty components are ignored. This helper is used to
* parse GIT_NOTES_DISPLAY_REF style environment variables.
*/
void string_list_add_refs_from_colon_sep(struct string_list *list,
const char *globs);
#endif

View File

@ -775,7 +775,7 @@ static size_t format_commit_one(struct strbuf *sb, const char *placeholder,
}
return 0; /* unknown %g placeholder */
case 'N':
format_note(NULL, commit->object.sha1, sb,
format_display_notes(commit->object.sha1, sb,
git_log_output_encoding ? git_log_output_encoding
: git_commit_encoding, 0);
return 1;
@ -1096,7 +1096,7 @@ void pretty_print_commit(enum cmit_fmt fmt, const struct commit *commit,
strbuf_addch(sb, '\n');
if (context->show_notes)
format_note(NULL, commit->object.sha1, sb, encoding,
format_display_notes(commit->object.sha1, sb, encoding,
NOTES_SHOW_HEADER | NOTES_INDENT);
free(reencoded);

4
refs.c
View File

@ -698,7 +698,6 @@ int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
{
struct strbuf real_pattern = STRBUF_INIT;
struct ref_filter filter;
const char *has_glob_specials;
int ret;
if (!prefix && prefixcmp(pattern, "refs/"))
@ -707,8 +706,7 @@ int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
strbuf_addstr(&real_pattern, prefix);
strbuf_addstr(&real_pattern, pattern);
has_glob_specials = strpbrk(pattern, "?*[");
if (!has_glob_specials) {
if (!has_glob_specials(pattern)) {
/* Append implied '/' '*' if not present. */
if (real_pattern.buf[real_pattern.len - 1] != '/')
strbuf_addch(&real_pattern, '/');

5
refs.h
View File

@ -28,6 +28,11 @@ extern int for_each_replace_ref(each_ref_fn, void *);
extern int for_each_glob_ref(each_ref_fn, const char *pattern, void *);
extern int for_each_glob_ref_in(each_ref_fn, const char *pattern, const char* prefix, void *);
static inline const char *has_glob_specials(const char *pattern)
{
return strpbrk(pattern, "?*[");
}
/* can be used to learn about broken ref and symref */
extern int for_each_rawref(each_ref_fn, void *);

View File

@ -12,6 +12,7 @@
#include "patch-ids.h"
#include "decorate.h"
#include "log-tree.h"
#include "string-list.h"
volatile show_early_output_fn_t show_early_output;
@ -1191,9 +1192,29 @@ static int handle_revision_opt(struct rev_info *revs, int argc, const char **arg
} else if (!strcmp(arg, "--show-notes")) {
revs->show_notes = 1;
revs->show_notes_given = 1;
} else if (!prefixcmp(arg, "--show-notes=")) {
struct strbuf buf = STRBUF_INIT;
revs->show_notes = 1;
revs->show_notes_given = 1;
if (!revs->notes_opt.extra_notes_refs)
revs->notes_opt.extra_notes_refs = xcalloc(1, sizeof(struct string_list));
if (!prefixcmp(arg+13, "refs/"))
/* happy */;
else if (!prefixcmp(arg+13, "notes/"))
strbuf_addstr(&buf, "refs/");
else
strbuf_addstr(&buf, "refs/notes/");
strbuf_addstr(&buf, arg+13);
string_list_append(strbuf_detach(&buf, NULL),
revs->notes_opt.extra_notes_refs);
} else if (!strcmp(arg, "--no-notes")) {
revs->show_notes = 0;
revs->show_notes_given = 1;
} else if (!strcmp(arg, "--standard-notes")) {
revs->show_notes_given = 1;
revs->notes_opt.suppress_default_notes = 0;
} else if (!strcmp(arg, "--no-standard-notes")) {
revs->notes_opt.suppress_default_notes = 1;
} else if (!strcmp(arg, "--oneline")) {
revs->verbose_header = 1;
get_commit_format("oneline", revs);

View File

@ -3,6 +3,7 @@
#include "parse-options.h"
#include "grep.h"
#include "notes.h"
#define SEEN (1u<<0)
#define UNINTERESTING (1u<<1)
@ -20,6 +21,7 @@
struct rev_info;
struct log_info;
struct string_list;
struct rev_info {
/* Starting list */
@ -126,6 +128,9 @@ struct rev_info {
struct reflog_walk_info *reflog_info;
struct decoration children;
struct decoration merge_simplification;
/* notes-specific options: which refs to show */
struct display_notes_opt notes_opt;
};
#define REV_TREE_SAME 0

View File

@ -416,7 +416,7 @@ Date: Thu Apr 7 15:18:13 2005 -0700
6th
Notes:
Notes (other):
other note
EOF
@ -449,7 +449,139 @@ test_expect_success 'Do not show note when core.notesRef is overridden' '
test_cmp expect-not-other output
'
cat > expect-both << EOF
commit 387a89921c73d7ed72cd94d179c1c7048ca47756
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:18:13 2005 -0700
6th
Notes:
order test
Notes (other):
other note
commit bd1753200303d0a0344be813e504253b3d98e74d
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:17:13 2005 -0700
5th
Notes:
replacement for deleted note
EOF
test_expect_success 'Show all notes when notes.displayRef=refs/notes/*' '
GIT_NOTES_REF=refs/notes/commits git notes add \
-m"replacement for deleted note" HEAD^ &&
GIT_NOTES_REF=refs/notes/commits git notes add -m"order test" &&
git config --unset core.notesRef &&
git config notes.displayRef "refs/notes/*" &&
git log -2 > output &&
test_cmp expect-both output
'
test_expect_success 'core.notesRef is implicitly in notes.displayRef' '
git config core.notesRef refs/notes/commits &&
git config notes.displayRef refs/notes/other &&
git log -2 > output &&
test_cmp expect-both output
'
test_expect_success 'notes.displayRef can be given more than once' '
git config --unset core.notesRef &&
git config notes.displayRef refs/notes/commits &&
git config --add notes.displayRef refs/notes/other &&
git log -2 > output &&
test_cmp expect-both output
'
cat > expect-both-reversed << EOF
commit 387a89921c73d7ed72cd94d179c1c7048ca47756
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:18:13 2005 -0700
6th
Notes (other):
other note
Notes:
order test
EOF
test_expect_success 'notes.displayRef respects order' '
git config core.notesRef refs/notes/other &&
git config --unset-all notes.displayRef &&
git config notes.displayRef refs/notes/commits &&
git log -1 > output &&
test_cmp expect-both-reversed output
'
test_expect_success 'GIT_NOTES_DISPLAY_REF works' '
git config --unset-all core.notesRef &&
git config --unset-all notes.displayRef &&
GIT_NOTES_DISPLAY_REF=refs/notes/commits:refs/notes/other \
git log -2 > output &&
test_cmp expect-both output
'
cat > expect-none << EOF
commit 387a89921c73d7ed72cd94d179c1c7048ca47756
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:18:13 2005 -0700
6th
commit bd1753200303d0a0344be813e504253b3d98e74d
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:17:13 2005 -0700
5th
EOF
test_expect_success 'GIT_NOTES_DISPLAY_REF overrides config' '
git config notes.displayRef "refs/notes/*" &&
GIT_NOTES_REF= GIT_NOTES_DISPLAY_REF= git log -2 > output &&
test_cmp expect-none output
'
test_expect_success '--show-notes=* adds to GIT_NOTES_DISPLAY_REF' '
GIT_NOTES_REF= GIT_NOTES_DISPLAY_REF= git log --show-notes=* -2 > output &&
test_cmp expect-both output
'
cat > expect-commits << EOF
commit 387a89921c73d7ed72cd94d179c1c7048ca47756
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:18:13 2005 -0700
6th
Notes:
order test
EOF
test_expect_success '--no-standard-notes' '
git log --no-standard-notes --show-notes=commits -1 > output &&
test_cmp expect-commits output
'
test_expect_success '--standard-notes' '
git log --no-standard-notes --show-notes=commits \
--standard-notes -2 > output &&
test_cmp expect-both output
'
test_expect_success '--show-notes=ref accumulates' '
git log --show-notes=other --show-notes=commits \
--no-standard-notes -1 > output &&
test_cmp expect-both-reversed output
'
test_expect_success 'Allow notes on non-commits (trees, blobs, tags)' '
git config core.notesRef refs/notes/other &&
echo "Note on a tree" > expect
git notes add -m "Note on a tree" HEAD: &&
git notes show HEAD: > actual &&
@ -473,7 +605,7 @@ Date: Thu Apr 7 15:19:13 2005 -0700
7th
Notes:
Notes (other):
other note
EOF
@ -504,7 +636,7 @@ Date: Thu Apr 7 15:21:13 2005 -0700
9th
Notes:
Notes (other):
yet another note
EOF
@ -534,7 +666,7 @@ Date: Thu Apr 7 15:21:13 2005 -0700
9th
Notes:
Notes (other):
yet another note
$whitespace
yet another note
@ -553,7 +685,7 @@ Date: Thu Apr 7 15:22:13 2005 -0700
10th
Notes:
Notes (other):
other note
EOF
@ -570,7 +702,7 @@ Date: Thu Apr 7 15:22:13 2005 -0700
10th
Notes:
Notes (other):
other note
$whitespace
yet another note
@ -589,7 +721,7 @@ Date: Thu Apr 7 15:23:13 2005 -0700
11th
Notes:
Notes (other):
other note
$whitespace
yet another note
@ -620,7 +752,7 @@ Date: Thu Apr 7 15:23:13 2005 -0700
11th
Notes:
Notes (other):
yet another note
$whitespace
yet another note
@ -645,4 +777,233 @@ test_expect_success 'cannot copy note from object without notes' '
test_must_fail git notes copy HEAD^ HEAD
'
cat > expect << EOF
commit e5d4fb5698d564ab8c73551538ecaf2b0c666185
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:25:13 2005 -0700
13th
Notes (other):
yet another note
$whitespace
yet another note
commit 7038787dfe22a14c3867ce816dbba39845359719
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:24:13 2005 -0700
12th
Notes (other):
other note
$whitespace
yet another note
EOF
test_expect_success 'git notes copy --stdin' '
(echo $(git rev-parse HEAD~3) $(git rev-parse HEAD^); \
echo $(git rev-parse HEAD~2) $(git rev-parse HEAD)) |
git notes copy --stdin &&
git log -2 > output &&
test_cmp expect output &&
test "$(git notes list HEAD)" = "$(git notes list HEAD~2)" &&
test "$(git notes list HEAD^)" = "$(git notes list HEAD~3)"
'
cat > expect << EOF
commit 37a0d4cba38afef96ba54a3ea567e6dac575700b
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:27:13 2005 -0700
15th
commit be28d8b4d9951ad940d229ee3b0b9ee3b1ec273d
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:26:13 2005 -0700
14th
EOF
test_expect_success 'git notes copy --for-rewrite (unconfigured)' '
test_commit 14th &&
test_commit 15th &&
(echo $(git rev-parse HEAD~3) $(git rev-parse HEAD^); \
echo $(git rev-parse HEAD~2) $(git rev-parse HEAD)) |
git notes copy --for-rewrite=foo &&
git log -2 > output &&
test_cmp expect output
'
cat > expect << EOF
commit 37a0d4cba38afef96ba54a3ea567e6dac575700b
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:27:13 2005 -0700
15th
Notes (other):
yet another note
$whitespace
yet another note
commit be28d8b4d9951ad940d229ee3b0b9ee3b1ec273d
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:26:13 2005 -0700
14th
Notes (other):
other note
$whitespace
yet another note
EOF
test_expect_success 'git notes copy --for-rewrite (enabled)' '
git config notes.rewriteMode overwrite &&
git config notes.rewriteRef "refs/notes/*" &&
(echo $(git rev-parse HEAD~3) $(git rev-parse HEAD^); \
echo $(git rev-parse HEAD~2) $(git rev-parse HEAD)) |
git notes copy --for-rewrite=foo &&
git log -2 > output &&
test_cmp expect output
'
test_expect_success 'git notes copy --for-rewrite (disabled)' '
git config notes.rewrite.bar false &&
echo $(git rev-parse HEAD~3) $(git rev-parse HEAD) |
git notes copy --for-rewrite=bar &&
git log -2 > output &&
test_cmp expect output
'
cat > expect << EOF
commit 37a0d4cba38afef96ba54a3ea567e6dac575700b
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:27:13 2005 -0700
15th
Notes (other):
a fresh note
EOF
test_expect_success 'git notes copy --for-rewrite (overwrite)' '
git notes add -f -m"a fresh note" HEAD^ &&
echo $(git rev-parse HEAD^) $(git rev-parse HEAD) |
git notes copy --for-rewrite=foo &&
git log -1 > output &&
test_cmp expect output
'
test_expect_success 'git notes copy --for-rewrite (ignore)' '
git config notes.rewriteMode ignore &&
echo $(git rev-parse HEAD^) $(git rev-parse HEAD) |
git notes copy --for-rewrite=foo &&
git log -1 > output &&
test_cmp expect output
'
cat > expect << EOF
commit 37a0d4cba38afef96ba54a3ea567e6dac575700b
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:27:13 2005 -0700
15th
Notes (other):
a fresh note
another fresh note
EOF
test_expect_success 'git notes copy --for-rewrite (append)' '
git notes add -f -m"another fresh note" HEAD^ &&
git config notes.rewriteMode concatenate &&
echo $(git rev-parse HEAD^) $(git rev-parse HEAD) |
git notes copy --for-rewrite=foo &&
git log -1 > output &&
test_cmp expect output
'
cat > expect << EOF
commit 37a0d4cba38afef96ba54a3ea567e6dac575700b
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:27:13 2005 -0700
15th
Notes (other):
a fresh note
another fresh note
append 1
append 2
EOF
test_expect_success 'git notes copy --for-rewrite (append two to one)' '
git notes add -f -m"append 1" HEAD^ &&
git notes add -f -m"append 2" HEAD^^ &&
(echo $(git rev-parse HEAD^) $(git rev-parse HEAD);
echo $(git rev-parse HEAD^^) $(git rev-parse HEAD)) |
git notes copy --for-rewrite=foo &&
git log -1 > output &&
test_cmp expect output
'
test_expect_success 'git notes copy --for-rewrite (append empty)' '
git notes remove HEAD^ &&
echo $(git rev-parse HEAD^) $(git rev-parse HEAD) |
git notes copy --for-rewrite=foo &&
git log -1 > output &&
test_cmp expect output
'
cat > expect << EOF
commit 37a0d4cba38afef96ba54a3ea567e6dac575700b
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:27:13 2005 -0700
15th
Notes (other):
replacement note 1
EOF
test_expect_success 'GIT_NOTES_REWRITE_MODE works' '
git notes add -f -m"replacement note 1" HEAD^ &&
echo $(git rev-parse HEAD^) $(git rev-parse HEAD) |
GIT_NOTES_REWRITE_MODE=overwrite git notes copy --for-rewrite=foo &&
git log -1 > output &&
test_cmp expect output
'
cat > expect << EOF
commit 37a0d4cba38afef96ba54a3ea567e6dac575700b
Author: A U Thor <author@example.com>
Date: Thu Apr 7 15:27:13 2005 -0700
15th
Notes (other):
replacement note 2
EOF
test_expect_success 'GIT_NOTES_REWRITE_REF works' '
git config notes.rewriteMode overwrite &&
git notes add -f -m"replacement note 2" HEAD^ &&
git config --unset-all notes.rewriteRef &&
echo $(git rev-parse HEAD^) $(git rev-parse HEAD) |
GIT_NOTES_REWRITE_REF=refs/notes/commits:refs/notes/other \
git notes copy --for-rewrite=foo &&
git log -1 > output &&
test_cmp expect output
'
test_expect_success 'GIT_NOTES_REWRITE_REF overrides config' '
git config notes.rewriteRef refs/notes/other &&
git notes add -f -m"replacement note 3" HEAD^ &&
echo $(git rev-parse HEAD^) $(git rev-parse HEAD) |
GIT_NOTES_REWRITE_REF= git notes copy --for-rewrite=foo &&
git log -1 > output &&
test_cmp expect output
'
test_done

View File

@ -151,4 +151,21 @@ test_expect_success 'Rebase a commit that sprinkles CRs in' '
git diff --exit-code file-with-cr:CR HEAD:CR
'
test_expect_success 'rebase can copy notes' '
git config notes.rewrite.rebase true &&
git config notes.rewriteRef "refs/notes/*" &&
test_commit n1 &&
test_commit n2 &&
test_commit n3 &&
git notes add -m"a note" n3 &&
git rebase --onto n1 n2 &&
test "a note" = "$(git notes show HEAD)"
'
test_expect_success 'rebase -m can copy notes' '
git reset --hard n3 &&
git rebase -m --onto n1 n2 &&
test "a note" = "$(git notes show HEAD)"
'
test_done

View File

@ -553,4 +553,28 @@ test_expect_success 'reword' '
git show HEAD~2 | grep "C changed"
'
test_expect_success 'rebase -i can copy notes' '
git config notes.rewrite.rebase true &&
git config notes.rewriteRef "refs/notes/*" &&
test_commit n1 &&
test_commit n2 &&
test_commit n3 &&
git notes add -m"a note" n3 &&
git rebase --onto n1 n2 &&
test "a note" = "$(git notes show HEAD)"
'
cat >expect <<EOF
an earlier note
a note
EOF
test_expect_success 'rebase -i can copy notes over a fixup' '
git reset --hard n3 &&
git notes add -m"an earlier note" n2 &&
GIT_NOTES_REWRITE_MODE=concatenate FAKE_LINES="1 fixup 2" git rebase -i n1 &&
git notes show > output &&
test_cmp expect output
'
test_done

183
t/t5407-post-rewrite-hook.sh Executable file
View File

@ -0,0 +1,183 @@
#!/bin/sh
#
# Copyright (c) 2010 Thomas Rast
#
test_description='Test the post-rewrite hook.'
. ./test-lib.sh
test_expect_success 'setup' '
test_commit A foo A &&
test_commit B foo B &&
test_commit C foo C &&
test_commit D foo D
'
mkdir .git/hooks
cat >.git/hooks/post-rewrite <<EOF
#!/bin/sh
echo \$@ > "$TRASH_DIRECTORY"/post-rewrite.args
cat > "$TRASH_DIRECTORY"/post-rewrite.data
EOF
chmod u+x .git/hooks/post-rewrite
clear_hook_input () {
rm -f post-rewrite.args post-rewrite.data
}
verify_hook_input () {
test_cmp "$TRASH_DIRECTORY"/post-rewrite.args expected.args &&
test_cmp "$TRASH_DIRECTORY"/post-rewrite.data expected.data
}
test_expect_success 'git commit --amend' '
clear_hook_input &&
echo "D new message" > newmsg &&
oldsha=$(git rev-parse HEAD^0) &&
git commit -Fnewmsg --amend &&
echo amend > expected.args &&
echo $oldsha $(git rev-parse HEAD^0) > expected.data &&
verify_hook_input
'
test_expect_success 'git commit --amend --no-post-rewrite' '
clear_hook_input &&
echo "D new message again" > newmsg &&
git commit --no-post-rewrite -Fnewmsg --amend &&
test ! -f post-rewrite.args &&
test ! -f post-rewrite.data
'
test_expect_success 'git rebase' '
git reset --hard D &&
clear_hook_input &&
test_must_fail git rebase --onto A B &&
echo C > foo &&
git add foo &&
git rebase --continue &&
echo rebase >expected.args &&
cat >expected.data <<EOF &&
$(git rev-parse C) $(git rev-parse HEAD^)
$(git rev-parse D) $(git rev-parse HEAD)
EOF
verify_hook_input
'
test_expect_success 'git rebase --skip' '
git reset --hard D &&
clear_hook_input &&
test_must_fail git rebase --onto A B &&
test_must_fail git rebase --skip &&
echo D > foo &&
git add foo &&
git rebase --continue &&
echo rebase >expected.args &&
cat >expected.data <<EOF &&
$(git rev-parse D) $(git rev-parse HEAD)
EOF
verify_hook_input
'
test_expect_success 'git rebase -m' '
git reset --hard D &&
clear_hook_input &&
test_must_fail git rebase -m --onto A B &&
echo C > foo &&
git add foo &&
git rebase --continue &&
echo rebase >expected.args &&
cat >expected.data <<EOF &&
$(git rev-parse C) $(git rev-parse HEAD^)
$(git rev-parse D) $(git rev-parse HEAD)
EOF
verify_hook_input
'
test_expect_success 'git rebase -m --skip' '
git reset --hard D &&
clear_hook_input &&
test_must_fail git rebase --onto A B &&
test_must_fail git rebase --skip &&
echo D > foo &&
git add foo &&
git rebase --continue &&
echo rebase >expected.args &&
cat >expected.data <<EOF &&
$(git rev-parse D) $(git rev-parse HEAD)
EOF
verify_hook_input
'
. "$TEST_DIRECTORY"/lib-rebase.sh
set_fake_editor
# Helper to work around the lack of one-shot exporting for
# test_must_fail (as it is a shell function)
test_fail_interactive_rebase () {
(
FAKE_LINES="$1" &&
shift &&
export FAKE_LINES &&
test_must_fail git rebase -i "$@"
)
}
test_expect_success 'git rebase -i (unchanged)' '
git reset --hard D &&
clear_hook_input &&
test_fail_interactive_rebase "1 2" --onto A B &&
echo C > foo &&
git add foo &&
git rebase --continue &&
echo rebase >expected.args &&
cat >expected.data <<EOF &&
$(git rev-parse C) $(git rev-parse HEAD^)
$(git rev-parse D) $(git rev-parse HEAD)
EOF
verify_hook_input
'
test_expect_success 'git rebase -i (skip)' '
git reset --hard D &&
clear_hook_input &&
test_fail_interactive_rebase "2" --onto A B &&
echo D > foo &&
git add foo &&
git rebase --continue &&
echo rebase >expected.args &&
cat >expected.data <<EOF &&
$(git rev-parse D) $(git rev-parse HEAD)
EOF
verify_hook_input
'
test_expect_success 'git rebase -i (squash)' '
git reset --hard D &&
clear_hook_input &&
test_fail_interactive_rebase "1 squash 2" --onto A B &&
echo C > foo &&
git add foo &&
git rebase --continue &&
echo rebase >expected.args &&
cat >expected.data <<EOF &&
$(git rev-parse C) $(git rev-parse HEAD)
$(git rev-parse D) $(git rev-parse HEAD)
EOF
verify_hook_input
'
test_expect_success 'git rebase -i (fixup without conflict)' '
git reset --hard D &&
clear_hook_input &&
FAKE_LINES="1 fixup 2" git rebase -i B &&
echo rebase >expected.args &&
cat >expected.data <<EOF &&
$(git rev-parse C) $(git rev-parse HEAD)
$(git rev-parse D) $(git rev-parse HEAD)
EOF
verify_hook_input
'
test_done

View File

@ -425,4 +425,16 @@ test_expect_success 'amend using the message from a commit named with tag' '
'
test_expect_success 'amend can copy notes' '
git config notes.rewrite.amend true &&
git config notes.rewriteRef "refs/notes/*" &&
test_commit foo &&
git notes add -m"a note" &&
test_tick &&
git commit --amend -m"new foo" &&
test "$(git notes show)" = "a note"
'
test_done

View File

@ -54,6 +54,10 @@ unset GIT_OBJECT_DIRECTORY
unset GIT_CEILING_DIRECTORIES
unset SHA1_FILE_DIRECTORIES
unset SHA1_FILE_DIRECTORY
unset GIT_NOTES_REF
unset GIT_NOTES_DISPLAY_REF
unset GIT_NOTES_REWRITE_REF
unset GIT_NOTES_REWRITE_MODE
GIT_MERGE_VERBOSITY=5
export GIT_MERGE_VERBOSITY
export GIT_AUTHOR_EMAIL GIT_AUTHOR_NAME