2010-11-09 21:49:46 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "refs.h"
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
#include "diff.h"
|
|
|
|
#include "diffcore.h"
|
2010-11-09 21:49:51 +00:00
|
|
|
#include "xdiff-interface.h"
|
|
|
|
#include "ll-merge.h"
|
|
|
|
#include "dir.h"
|
2010-11-09 21:49:47 +00:00
|
|
|
#include "notes.h"
|
2010-11-09 21:49:46 +00:00
|
|
|
#include "notes-merge.h"
|
2010-11-09 21:49:53 +00:00
|
|
|
#include "strbuf.h"
|
2013-06-12 00:13:01 +00:00
|
|
|
#include "notes-utils.h"
|
2010-11-09 21:49:46 +00:00
|
|
|
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
struct notes_merge_pair {
|
|
|
|
unsigned char obj[20], base[20], local[20], remote[20];
|
|
|
|
};
|
|
|
|
|
2010-11-09 21:49:46 +00:00
|
|
|
void init_notes_merge_options(struct notes_merge_options *o)
|
|
|
|
{
|
|
|
|
memset(o, 0, sizeof(struct notes_merge_options));
|
2010-11-09 21:49:53 +00:00
|
|
|
strbuf_init(&(o->commit_msg), 0);
|
2010-11-09 21:49:46 +00:00
|
|
|
o->verbosity = NOTES_MERGE_VERBOSITY_DEFAULT;
|
|
|
|
}
|
|
|
|
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
static int path_to_sha1(const char *path, unsigned char *sha1)
|
|
|
|
{
|
|
|
|
char hex_sha1[40];
|
|
|
|
int i = 0;
|
|
|
|
while (*path && i < 40) {
|
|
|
|
if (*path != '/')
|
|
|
|
hex_sha1[i++] = *path;
|
|
|
|
path++;
|
|
|
|
}
|
|
|
|
if (*path || i != 40)
|
|
|
|
return -1;
|
|
|
|
return get_sha1_hex(hex_sha1, sha1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int verify_notes_filepair(struct diff_filepair *p, unsigned char *sha1)
|
|
|
|
{
|
|
|
|
switch (p->status) {
|
|
|
|
case DIFF_STATUS_MODIFIED:
|
|
|
|
assert(p->one->mode == p->two->mode);
|
|
|
|
assert(!is_null_sha1(p->one->sha1));
|
|
|
|
assert(!is_null_sha1(p->two->sha1));
|
|
|
|
break;
|
|
|
|
case DIFF_STATUS_ADDED:
|
|
|
|
assert(is_null_sha1(p->one->sha1));
|
|
|
|
break;
|
|
|
|
case DIFF_STATUS_DELETED:
|
|
|
|
assert(is_null_sha1(p->two->sha1));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
assert(!strcmp(p->one->path, p->two->path));
|
|
|
|
return path_to_sha1(p->one->path, sha1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notes_merge_pair *find_notes_merge_pair_pos(
|
|
|
|
struct notes_merge_pair *list, int len, unsigned char *obj,
|
|
|
|
int insert_new, int *occupied)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Both diff_tree_remote() and diff_tree_local() tend to process
|
|
|
|
* merge_pairs in ascending order. Therefore, cache last returned
|
|
|
|
* index, and search sequentially from there until the appropriate
|
|
|
|
* position is found.
|
|
|
|
*
|
|
|
|
* Since inserts only happen from diff_tree_remote() (which mainly
|
|
|
|
* _appends_), we don't care that inserting into the middle of the
|
|
|
|
* list is expensive (using memmove()).
|
|
|
|
*/
|
|
|
|
static int last_index;
|
|
|
|
int i = last_index < len ? last_index : len - 1;
|
|
|
|
int prev_cmp = 0, cmp = -1;
|
|
|
|
while (i >= 0 && i < len) {
|
|
|
|
cmp = hashcmp(obj, list[i].obj);
|
|
|
|
if (!cmp) /* obj belongs @ i */
|
|
|
|
break;
|
|
|
|
else if (cmp < 0 && prev_cmp <= 0) /* obj belongs < i */
|
|
|
|
i--;
|
|
|
|
else if (cmp < 0) /* obj belongs between i-1 and i */
|
|
|
|
break;
|
|
|
|
else if (cmp > 0 && prev_cmp >= 0) /* obj belongs > i */
|
|
|
|
i++;
|
|
|
|
else /* if (cmp > 0) */ { /* obj belongs between i and i+1 */
|
|
|
|
i++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
prev_cmp = cmp;
|
|
|
|
}
|
|
|
|
if (i < 0)
|
|
|
|
i = 0;
|
|
|
|
/* obj belongs at, or immediately preceding, index i (0 <= i <= len) */
|
|
|
|
|
|
|
|
if (!cmp)
|
|
|
|
*occupied = 1;
|
|
|
|
else {
|
|
|
|
*occupied = 0;
|
|
|
|
if (insert_new && i < len) {
|
|
|
|
memmove(list + i + 1, list + i,
|
|
|
|
(len - i) * sizeof(struct notes_merge_pair));
|
|
|
|
memset(list + i, 0, sizeof(struct notes_merge_pair));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
last_index = i;
|
|
|
|
return list + i;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned char uninitialized[20] =
|
|
|
|
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" \
|
|
|
|
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
|
|
|
|
|
|
|
|
static struct notes_merge_pair *diff_tree_remote(struct notes_merge_options *o,
|
|
|
|
const unsigned char *base,
|
|
|
|
const unsigned char *remote,
|
|
|
|
int *num_changes)
|
|
|
|
{
|
|
|
|
struct diff_options opt;
|
|
|
|
struct notes_merge_pair *changes;
|
|
|
|
int i, len = 0;
|
|
|
|
|
|
|
|
trace_printf("\tdiff_tree_remote(base = %.7s, remote = %.7s)\n",
|
|
|
|
sha1_to_hex(base), sha1_to_hex(remote));
|
|
|
|
|
|
|
|
diff_setup(&opt);
|
|
|
|
DIFF_OPT_SET(&opt, RECURSIVE);
|
|
|
|
opt.output_format = DIFF_FORMAT_NO_OUTPUT;
|
2012-08-03 12:16:24 +00:00
|
|
|
diff_setup_done(&opt);
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
diff_tree_sha1(base, remote, "", &opt);
|
|
|
|
diffcore_std(&opt);
|
|
|
|
|
|
|
|
changes = xcalloc(diff_queued_diff.nr, sizeof(struct notes_merge_pair));
|
|
|
|
|
|
|
|
for (i = 0; i < diff_queued_diff.nr; i++) {
|
|
|
|
struct diff_filepair *p = diff_queued_diff.queue[i];
|
|
|
|
struct notes_merge_pair *mp;
|
|
|
|
int occupied;
|
|
|
|
unsigned char obj[20];
|
|
|
|
|
|
|
|
if (verify_notes_filepair(p, obj)) {
|
|
|
|
trace_printf("\t\tCannot merge entry '%s' (%c): "
|
|
|
|
"%.7s -> %.7s. Skipping!\n", p->one->path,
|
|
|
|
p->status, sha1_to_hex(p->one->sha1),
|
|
|
|
sha1_to_hex(p->two->sha1));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
mp = find_notes_merge_pair_pos(changes, len, obj, 1, &occupied);
|
|
|
|
if (occupied) {
|
|
|
|
/* We've found an addition/deletion pair */
|
|
|
|
assert(!hashcmp(mp->obj, obj));
|
|
|
|
if (is_null_sha1(p->one->sha1)) { /* addition */
|
|
|
|
assert(is_null_sha1(mp->remote));
|
|
|
|
hashcpy(mp->remote, p->two->sha1);
|
|
|
|
} else if (is_null_sha1(p->two->sha1)) { /* deletion */
|
|
|
|
assert(is_null_sha1(mp->base));
|
|
|
|
hashcpy(mp->base, p->one->sha1);
|
|
|
|
} else
|
|
|
|
assert(!"Invalid existing change recorded");
|
|
|
|
} else {
|
|
|
|
hashcpy(mp->obj, obj);
|
|
|
|
hashcpy(mp->base, p->one->sha1);
|
|
|
|
hashcpy(mp->local, uninitialized);
|
|
|
|
hashcpy(mp->remote, p->two->sha1);
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
trace_printf("\t\tStored remote change for %s: %.7s -> %.7s\n",
|
|
|
|
sha1_to_hex(mp->obj), sha1_to_hex(mp->base),
|
|
|
|
sha1_to_hex(mp->remote));
|
|
|
|
}
|
|
|
|
diff_flush(&opt);
|
2013-07-14 08:35:58 +00:00
|
|
|
free_pathspec(&opt.pathspec);
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
|
|
|
|
*num_changes = len;
|
|
|
|
return changes;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void diff_tree_local(struct notes_merge_options *o,
|
|
|
|
struct notes_merge_pair *changes, int len,
|
|
|
|
const unsigned char *base,
|
|
|
|
const unsigned char *local)
|
|
|
|
{
|
|
|
|
struct diff_options opt;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
trace_printf("\tdiff_tree_local(len = %i, base = %.7s, local = %.7s)\n",
|
|
|
|
len, sha1_to_hex(base), sha1_to_hex(local));
|
|
|
|
|
|
|
|
diff_setup(&opt);
|
|
|
|
DIFF_OPT_SET(&opt, RECURSIVE);
|
|
|
|
opt.output_format = DIFF_FORMAT_NO_OUTPUT;
|
2012-08-03 12:16:24 +00:00
|
|
|
diff_setup_done(&opt);
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
diff_tree_sha1(base, local, "", &opt);
|
|
|
|
diffcore_std(&opt);
|
|
|
|
|
|
|
|
for (i = 0; i < diff_queued_diff.nr; i++) {
|
|
|
|
struct diff_filepair *p = diff_queued_diff.queue[i];
|
|
|
|
struct notes_merge_pair *mp;
|
|
|
|
int match;
|
|
|
|
unsigned char obj[20];
|
|
|
|
|
|
|
|
if (verify_notes_filepair(p, obj)) {
|
|
|
|
trace_printf("\t\tCannot merge entry '%s' (%c): "
|
|
|
|
"%.7s -> %.7s. Skipping!\n", p->one->path,
|
|
|
|
p->status, sha1_to_hex(p->one->sha1),
|
|
|
|
sha1_to_hex(p->two->sha1));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
mp = find_notes_merge_pair_pos(changes, len, obj, 0, &match);
|
|
|
|
if (!match) {
|
|
|
|
trace_printf("\t\tIgnoring local-only change for %s: "
|
|
|
|
"%.7s -> %.7s\n", sha1_to_hex(obj),
|
|
|
|
sha1_to_hex(p->one->sha1),
|
|
|
|
sha1_to_hex(p->two->sha1));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(!hashcmp(mp->obj, obj));
|
|
|
|
if (is_null_sha1(p->two->sha1)) { /* deletion */
|
|
|
|
/*
|
|
|
|
* Either this is a true deletion (1), or it is part
|
|
|
|
* of an A/D pair (2), or D/A pair (3):
|
|
|
|
*
|
|
|
|
* (1) mp->local is uninitialized; set it to null_sha1
|
|
|
|
* (2) mp->local is not uninitialized; don't touch it
|
|
|
|
* (3) mp->local is uninitialized; set it to null_sha1
|
|
|
|
* (will be overwritten by following addition)
|
|
|
|
*/
|
|
|
|
if (!hashcmp(mp->local, uninitialized))
|
|
|
|
hashclr(mp->local);
|
|
|
|
} else if (is_null_sha1(p->one->sha1)) { /* addition */
|
|
|
|
/*
|
|
|
|
* Either this is a true addition (1), or it is part
|
|
|
|
* of an A/D pair (2), or D/A pair (3):
|
|
|
|
*
|
|
|
|
* (1) mp->local is uninitialized; set to p->two->sha1
|
|
|
|
* (2) mp->local is uninitialized; set to p->two->sha1
|
|
|
|
* (3) mp->local is null_sha1; set to p->two->sha1
|
|
|
|
*/
|
|
|
|
assert(is_null_sha1(mp->local) ||
|
|
|
|
!hashcmp(mp->local, uninitialized));
|
|
|
|
hashcpy(mp->local, p->two->sha1);
|
|
|
|
} else { /* modification */
|
|
|
|
/*
|
|
|
|
* This is a true modification. p->one->sha1 shall
|
|
|
|
* match mp->base, and mp->local shall be uninitialized.
|
|
|
|
* Set mp->local to p->two->sha1.
|
|
|
|
*/
|
|
|
|
assert(!hashcmp(p->one->sha1, mp->base));
|
|
|
|
assert(!hashcmp(mp->local, uninitialized));
|
|
|
|
hashcpy(mp->local, p->two->sha1);
|
|
|
|
}
|
|
|
|
trace_printf("\t\tStored local change for %s: %.7s -> %.7s\n",
|
|
|
|
sha1_to_hex(mp->obj), sha1_to_hex(mp->base),
|
|
|
|
sha1_to_hex(mp->local));
|
|
|
|
}
|
|
|
|
diff_flush(&opt);
|
2013-07-14 08:35:58 +00:00
|
|
|
free_pathspec(&opt.pathspec);
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
}
|
|
|
|
|
2010-11-09 21:49:51 +00:00
|
|
|
static void check_notes_merge_worktree(struct notes_merge_options *o)
|
|
|
|
{
|
|
|
|
if (!o->has_worktree) {
|
|
|
|
/*
|
|
|
|
* Must establish NOTES_MERGE_WORKTREE.
|
|
|
|
* Abort if NOTES_MERGE_WORKTREE already exists
|
|
|
|
*/
|
notes-merge: Don't remove .git/NOTES_MERGE_WORKTREE; it may be the user's cwd
When a manual notes merge is committed or aborted, we need to remove the
temporary worktree at .git/NOTES_MERGE_WORKTREE. However, removing the
entire directory is not good if the user ran the 'git notes merge
--commit/--abort' from within that directory. On Windows, the directory
removal would simply fail, while on POSIX systems, users would suddenly
find themselves in an invalid current directory.
Therefore, instead of deleting the entire directory, we delete everything
_within_ the directory, and leave the (empty) directory in place.
This would cause a subsequent notes merge to abort, complaining about a
previous - unfinished - notes merge (due to the presence of
.git/NOTES_MERGE_WORKTREE), so we also need to adjust this check to only
trigger when .git/NOTES_MERGE_WORKTREE is non-empty.
Finally, adjust the t3310 manual notes merge testcases to correctly handle
the existence of an empty .git/NOTES_MERGE_WORKTREE directory.
Inspired-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-03-15 14:58:56 +00:00
|
|
|
if (file_exists(git_path(NOTES_MERGE_WORKTREE)) &&
|
|
|
|
!is_empty_dir(git_path(NOTES_MERGE_WORKTREE))) {
|
2010-11-09 21:49:51 +00:00
|
|
|
if (advice_resolve_conflict)
|
|
|
|
die("You have not concluded your previous "
|
|
|
|
"notes merge (%s exists).\nPlease, use "
|
|
|
|
"'git notes merge --commit' or 'git notes "
|
git notes merge: Manual conflict resolution, part 2/2
When the notes merge conflicts in .git/NOTES_MERGE_WORKTREE have been
resolved, we need to record a new notes commit on the appropriate notes
ref with the resolved notes.
This patch implements 'git notes merge --commit' which the user should
run after resolving conflicts in the notes merge worktree. This command
finalizes the notes merge by recombining the partial notes tree from
part 1 with the now-resolved conflicts in the notes merge worktree in a
merge commit, and updating the appropriate ref to this merge commit.
In order to correctly finalize the merge, we need to keep track of three
things:
- The partial merge result from part 1, containing the auto-merged notes.
This is now stored into a ref called .git/NOTES_MERGE_PARTIAL.
- The unmerged notes. These are already stored in
.git/NOTES_MERGE_WORKTREE, thanks to part 1.
- The notes ref to be updated by the finalized merge result. This is now
stored in a symref called .git/NOTES_MERGE_REF.
In addition to "git notes merge --commit", which uses the above details
to create the finalized notes merge commit, this patch also implements
"git notes merge --reset", which aborts the ongoing notes merge by simply
removing the files/directory described above.
FTR, "git notes merge --commit" reuses "git notes merge --reset" to remove
the information described above (.git/NOTES_MERGE_*) after the notes merge
have been successfully finalized.
The patch also contains documentation and testcases for the two new options.
This patch has been improved by the following contributions:
- Ævar Arnfjörð Bjarmason: Fix nonsense sentence in --commit description
- Sverre Rabbelier: Rename --reset to --abort
Thanks-to: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Thanks-to: Sverre Rabbelier <srabbelier@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-09 21:49:52 +00:00
|
|
|
"merge --abort' to commit/abort the "
|
2010-11-09 21:49:51 +00:00
|
|
|
"previous merge before you start a new "
|
|
|
|
"notes merge.", git_path("NOTES_MERGE_*"));
|
|
|
|
else
|
|
|
|
die("You have not concluded your notes merge "
|
|
|
|
"(%s exists).", git_path("NOTES_MERGE_*"));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (safe_create_leading_directories(git_path(
|
|
|
|
NOTES_MERGE_WORKTREE "/.test")))
|
|
|
|
die_errno("unable to create directory %s",
|
|
|
|
git_path(NOTES_MERGE_WORKTREE));
|
|
|
|
o->has_worktree = 1;
|
|
|
|
} else if (!file_exists(git_path(NOTES_MERGE_WORKTREE)))
|
|
|
|
/* NOTES_MERGE_WORKTREE should already be established */
|
|
|
|
die("missing '%s'. This should not happen",
|
|
|
|
git_path(NOTES_MERGE_WORKTREE));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void write_buf_to_worktree(const unsigned char *obj,
|
|
|
|
const char *buf, unsigned long size)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
char *path = git_path(NOTES_MERGE_WORKTREE "/%s", sha1_to_hex(obj));
|
|
|
|
if (safe_create_leading_directories(path))
|
|
|
|
die_errno("unable to create directory for '%s'", path);
|
|
|
|
if (file_exists(path))
|
|
|
|
die("found existing file at '%s'", path);
|
|
|
|
|
|
|
|
fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, 0666);
|
|
|
|
if (fd < 0)
|
|
|
|
die_errno("failed to open '%s'", path);
|
|
|
|
|
|
|
|
while (size > 0) {
|
|
|
|
long ret = write_in_full(fd, buf, size);
|
|
|
|
if (ret < 0) {
|
|
|
|
/* Ignore epipe */
|
|
|
|
if (errno == EPIPE)
|
|
|
|
break;
|
|
|
|
die_errno("notes-merge");
|
|
|
|
} else if (!ret) {
|
|
|
|
die("notes-merge: disk full?");
|
|
|
|
}
|
|
|
|
size -= ret;
|
|
|
|
buf += ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
close(fd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void write_note_to_worktree(const unsigned char *obj,
|
|
|
|
const unsigned char *note)
|
|
|
|
{
|
|
|
|
enum object_type type;
|
|
|
|
unsigned long size;
|
|
|
|
void *buf = read_sha1_file(note, &type, &size);
|
|
|
|
|
|
|
|
if (!buf)
|
|
|
|
die("cannot read note %s for object %s",
|
|
|
|
sha1_to_hex(note), sha1_to_hex(obj));
|
|
|
|
if (type != OBJ_BLOB)
|
|
|
|
die("blob expected in note %s for object %s",
|
|
|
|
sha1_to_hex(note), sha1_to_hex(obj));
|
|
|
|
write_buf_to_worktree(obj, buf, size);
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ll_merge_in_worktree(struct notes_merge_options *o,
|
|
|
|
struct notes_merge_pair *p)
|
|
|
|
{
|
|
|
|
mmbuffer_t result_buf;
|
|
|
|
mmfile_t base, local, remote;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
read_mmblob(&base, p->base);
|
|
|
|
read_mmblob(&local, p->local);
|
|
|
|
read_mmblob(&remote, p->remote);
|
|
|
|
|
|
|
|
status = ll_merge(&result_buf, sha1_to_hex(p->obj), &base, NULL,
|
Fix sparse warnings
Fix warnings from 'make check'.
- These files don't include 'builtin.h' causing sparse to complain that
cmd_* isn't declared:
builtin/clone.c:364, builtin/fetch-pack.c:797,
builtin/fmt-merge-msg.c:34, builtin/hash-object.c:78,
builtin/merge-index.c:69, builtin/merge-recursive.c:22
builtin/merge-tree.c:341, builtin/mktag.c:156, builtin/notes.c:426
builtin/notes.c:822, builtin/pack-redundant.c:596,
builtin/pack-refs.c:10, builtin/patch-id.c:60, builtin/patch-id.c:149,
builtin/remote.c:1512, builtin/remote-ext.c:240,
builtin/remote-fd.c:53, builtin/reset.c:236, builtin/send-pack.c:384,
builtin/unpack-file.c:25, builtin/var.c:75
- These files have symbols which should be marked static since they're
only file scope:
submodule.c:12, diff.c:631, replace_object.c:92, submodule.c:13,
submodule.c:14, trace.c:78, transport.c:195, transport-helper.c:79,
unpack-trees.c:19, url.c:3, url.c:18, url.c:104, url.c:117, url.c:123,
url.c:129, url.c:136, thread-utils.c:21, thread-utils.c:48
- These files redeclare symbols to be different types:
builtin/index-pack.c:210, parse-options.c:564, parse-options.c:571,
usage.c:49, usage.c:58, usage.c:63, usage.c:72
- These files use a literal integer 0 when they really should use a NULL
pointer:
daemon.c:663, fast-import.c:2942, imap-send.c:1072, notes-merge.c:362
While we're in the area, clean up some unused #includes in builtin files
(mostly exec_cmd.h).
Signed-off-by: Stephen Boyd <bebarino@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-03-22 07:51:05 +00:00
|
|
|
&local, o->local_ref, &remote, o->remote_ref, NULL);
|
2010-11-09 21:49:51 +00:00
|
|
|
|
|
|
|
free(base.ptr);
|
|
|
|
free(local.ptr);
|
|
|
|
free(remote.ptr);
|
|
|
|
|
|
|
|
if ((status < 0) || !result_buf.ptr)
|
|
|
|
die("Failed to execute internal merge");
|
|
|
|
|
|
|
|
write_buf_to_worktree(p->obj, result_buf.ptr, result_buf.size);
|
|
|
|
free(result_buf.ptr);
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int merge_one_change_manual(struct notes_merge_options *o,
|
|
|
|
struct notes_merge_pair *p,
|
|
|
|
struct notes_tree *t)
|
|
|
|
{
|
|
|
|
const char *lref = o->local_ref ? o->local_ref : "local version";
|
|
|
|
const char *rref = o->remote_ref ? o->remote_ref : "remote version";
|
|
|
|
|
|
|
|
trace_printf("\t\t\tmerge_one_change_manual(obj = %.7s, base = %.7s, "
|
|
|
|
"local = %.7s, remote = %.7s)\n",
|
|
|
|
sha1_to_hex(p->obj), sha1_to_hex(p->base),
|
|
|
|
sha1_to_hex(p->local), sha1_to_hex(p->remote));
|
|
|
|
|
2010-11-09 21:49:53 +00:00
|
|
|
/* add "Conflicts:" section to commit message first time through */
|
|
|
|
if (!o->has_worktree)
|
|
|
|
strbuf_addstr(&(o->commit_msg), "\n\nConflicts:\n");
|
|
|
|
|
|
|
|
strbuf_addf(&(o->commit_msg), "\t%s\n", sha1_to_hex(p->obj));
|
|
|
|
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 2)
|
|
|
|
printf("Auto-merging notes for %s\n", sha1_to_hex(p->obj));
|
2010-11-09 21:49:51 +00:00
|
|
|
check_notes_merge_worktree(o);
|
|
|
|
if (is_null_sha1(p->local)) {
|
|
|
|
/* D/F conflict, checkout p->remote */
|
|
|
|
assert(!is_null_sha1(p->remote));
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 1)
|
|
|
|
printf("CONFLICT (delete/modify): Notes for object %s "
|
|
|
|
"deleted in %s and modified in %s. Version from %s "
|
|
|
|
"left in tree.\n",
|
|
|
|
sha1_to_hex(p->obj), lref, rref, rref);
|
2010-11-09 21:49:51 +00:00
|
|
|
write_note_to_worktree(p->obj, p->remote);
|
|
|
|
} else if (is_null_sha1(p->remote)) {
|
|
|
|
/* D/F conflict, checkout p->local */
|
|
|
|
assert(!is_null_sha1(p->local));
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 1)
|
|
|
|
printf("CONFLICT (delete/modify): Notes for object %s "
|
|
|
|
"deleted in %s and modified in %s. Version from %s "
|
|
|
|
"left in tree.\n",
|
|
|
|
sha1_to_hex(p->obj), rref, lref, lref);
|
2010-11-09 21:49:51 +00:00
|
|
|
write_note_to_worktree(p->obj, p->local);
|
|
|
|
} else {
|
|
|
|
/* "regular" conflict, checkout result of ll_merge() */
|
|
|
|
const char *reason = "content";
|
|
|
|
if (is_null_sha1(p->base))
|
|
|
|
reason = "add/add";
|
|
|
|
assert(!is_null_sha1(p->local));
|
|
|
|
assert(!is_null_sha1(p->remote));
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 1)
|
|
|
|
printf("CONFLICT (%s): Merge conflict in notes for "
|
|
|
|
"object %s\n", reason, sha1_to_hex(p->obj));
|
2010-11-09 21:49:51 +00:00
|
|
|
ll_merge_in_worktree(o, p);
|
|
|
|
}
|
|
|
|
|
|
|
|
trace_printf("\t\t\tremoving from partial merge result\n");
|
|
|
|
remove_note(t, p->obj);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2010-11-14 23:55:12 +00:00
|
|
|
static int merge_one_change(struct notes_merge_options *o,
|
|
|
|
struct notes_merge_pair *p, struct notes_tree *t)
|
|
|
|
{
|
|
|
|
/*
|
2010-11-09 21:49:51 +00:00
|
|
|
* Return 0 if change is successfully resolved (stored in notes_tree).
|
|
|
|
* Return 1 is change results in a conflict (NOT stored in notes_tree,
|
|
|
|
* but instead written to NOTES_MERGE_WORKTREE with conflict markers).
|
2010-11-14 23:55:12 +00:00
|
|
|
*/
|
|
|
|
switch (o->strategy) {
|
|
|
|
case NOTES_MERGE_RESOLVE_MANUAL:
|
2010-11-09 21:49:51 +00:00
|
|
|
return merge_one_change_manual(o, p, t);
|
2010-11-14 23:55:12 +00:00
|
|
|
case NOTES_MERGE_RESOLVE_OURS:
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 2)
|
|
|
|
printf("Using local notes for %s\n",
|
|
|
|
sha1_to_hex(p->obj));
|
2010-11-14 23:55:12 +00:00
|
|
|
/* nothing to do */
|
|
|
|
return 0;
|
|
|
|
case NOTES_MERGE_RESOLVE_THEIRS:
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 2)
|
|
|
|
printf("Using remote notes for %s\n",
|
|
|
|
sha1_to_hex(p->obj));
|
2010-11-14 23:55:12 +00:00
|
|
|
if (add_note(t, p->obj, p->remote, combine_notes_overwrite))
|
|
|
|
die("BUG: combine_notes_overwrite failed");
|
|
|
|
return 0;
|
|
|
|
case NOTES_MERGE_RESOLVE_UNION:
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 2)
|
|
|
|
printf("Concatenating local and remote notes for %s\n",
|
|
|
|
sha1_to_hex(p->obj));
|
2010-11-14 23:55:12 +00:00
|
|
|
if (add_note(t, p->obj, p->remote, combine_notes_concatenate))
|
|
|
|
die("failed to concatenate notes "
|
|
|
|
"(combine_notes_concatenate)");
|
|
|
|
return 0;
|
2010-11-14 23:57:17 +00:00
|
|
|
case NOTES_MERGE_RESOLVE_CAT_SORT_UNIQ:
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 2)
|
|
|
|
printf("Concatenating unique lines in local and remote "
|
|
|
|
"notes for %s\n", sha1_to_hex(p->obj));
|
2010-11-14 23:57:17 +00:00
|
|
|
if (add_note(t, p->obj, p->remote, combine_notes_cat_sort_uniq))
|
|
|
|
die("failed to concatenate notes "
|
|
|
|
"(combine_notes_cat_sort_uniq)");
|
|
|
|
return 0;
|
2010-11-14 23:55:12 +00:00
|
|
|
}
|
|
|
|
die("Unknown strategy (%i).", o->strategy);
|
|
|
|
}
|
|
|
|
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
static int merge_changes(struct notes_merge_options *o,
|
|
|
|
struct notes_merge_pair *changes, int *num_changes,
|
|
|
|
struct notes_tree *t)
|
|
|
|
{
|
|
|
|
int i, conflicts = 0;
|
|
|
|
|
|
|
|
trace_printf("\tmerge_changes(num_changes = %i)\n", *num_changes);
|
|
|
|
for (i = 0; i < *num_changes; i++) {
|
|
|
|
struct notes_merge_pair *p = changes + i;
|
|
|
|
trace_printf("\t\t%.7s: %.7s -> %.7s/%.7s\n",
|
|
|
|
sha1_to_hex(p->obj), sha1_to_hex(p->base),
|
|
|
|
sha1_to_hex(p->local), sha1_to_hex(p->remote));
|
|
|
|
|
|
|
|
if (!hashcmp(p->base, p->remote)) {
|
|
|
|
/* no remote change; nothing to do */
|
|
|
|
trace_printf("\t\t\tskipping (no remote change)\n");
|
|
|
|
} else if (!hashcmp(p->local, p->remote)) {
|
|
|
|
/* same change in local and remote; nothing to do */
|
|
|
|
trace_printf("\t\t\tskipping (local == remote)\n");
|
|
|
|
} else if (!hashcmp(p->local, uninitialized) ||
|
|
|
|
!hashcmp(p->local, p->base)) {
|
|
|
|
/* no local change; adopt remote change */
|
|
|
|
trace_printf("\t\t\tno local change, adopted remote\n");
|
|
|
|
if (add_note(t, p->obj, p->remote,
|
|
|
|
combine_notes_overwrite))
|
|
|
|
die("BUG: combine_notes_overwrite failed");
|
|
|
|
} else {
|
|
|
|
/* need file-level merge between local and remote */
|
|
|
|
trace_printf("\t\t\tneed content-level merge\n");
|
2010-11-14 23:55:12 +00:00
|
|
|
conflicts += merge_one_change(o, p, t);
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return conflicts;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int merge_from_diffs(struct notes_merge_options *o,
|
|
|
|
const unsigned char *base,
|
|
|
|
const unsigned char *local,
|
|
|
|
const unsigned char *remote, struct notes_tree *t)
|
|
|
|
{
|
|
|
|
struct notes_merge_pair *changes;
|
|
|
|
int num_changes, conflicts;
|
|
|
|
|
|
|
|
trace_printf("\tmerge_from_diffs(base = %.7s, local = %.7s, "
|
|
|
|
"remote = %.7s)\n", sha1_to_hex(base), sha1_to_hex(local),
|
|
|
|
sha1_to_hex(remote));
|
|
|
|
|
|
|
|
changes = diff_tree_remote(o, base, remote, &num_changes);
|
|
|
|
diff_tree_local(o, changes, num_changes, base, local);
|
|
|
|
|
|
|
|
conflicts = merge_changes(o, changes, &num_changes, t);
|
|
|
|
free(changes);
|
|
|
|
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 4)
|
2012-06-07 12:05:13 +00:00
|
|
|
printf(t->dirty ?
|
|
|
|
"Merge result: %i unmerged notes and a dirty notes tree\n" :
|
|
|
|
"Merge result: %i unmerged notes and a clean notes tree\n",
|
|
|
|
conflicts);
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
|
|
|
|
return conflicts ? -1 : 1;
|
|
|
|
}
|
|
|
|
|
2010-11-09 21:49:46 +00:00
|
|
|
int notes_merge(struct notes_merge_options *o,
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
struct notes_tree *local_tree,
|
2010-11-09 21:49:46 +00:00
|
|
|
unsigned char *result_sha1)
|
|
|
|
{
|
|
|
|
unsigned char local_sha1[20], remote_sha1[20];
|
|
|
|
struct commit *local, *remote;
|
|
|
|
struct commit_list *bases = NULL;
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
const unsigned char *base_sha1, *base_tree_sha1;
|
2010-11-09 21:49:46 +00:00
|
|
|
int result = 0;
|
|
|
|
|
|
|
|
assert(o->local_ref && o->remote_ref);
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
assert(!strcmp(o->local_ref, local_tree->ref));
|
2010-11-09 21:49:46 +00:00
|
|
|
hashclr(result_sha1);
|
|
|
|
|
|
|
|
trace_printf("notes_merge(o->local_ref = %s, o->remote_ref = %s)\n",
|
|
|
|
o->local_ref, o->remote_ref);
|
|
|
|
|
|
|
|
/* Dereference o->local_ref into local_sha1 */
|
2011-11-13 10:22:14 +00:00
|
|
|
if (read_ref_full(o->local_ref, local_sha1, 0, NULL))
|
2010-11-09 21:49:46 +00:00
|
|
|
die("Failed to resolve local notes ref '%s'", o->local_ref);
|
2011-09-15 21:10:25 +00:00
|
|
|
else if (!check_refname_format(o->local_ref, 0) &&
|
|
|
|
is_null_sha1(local_sha1))
|
2010-11-09 21:49:46 +00:00
|
|
|
local = NULL; /* local_sha1 == null_sha1 indicates unborn ref */
|
|
|
|
else if (!(local = lookup_commit_reference(local_sha1)))
|
|
|
|
die("Could not parse local commit %s (%s)",
|
|
|
|
sha1_to_hex(local_sha1), o->local_ref);
|
|
|
|
trace_printf("\tlocal commit: %.7s\n", sha1_to_hex(local_sha1));
|
|
|
|
|
|
|
|
/* Dereference o->remote_ref into remote_sha1 */
|
|
|
|
if (get_sha1(o->remote_ref, remote_sha1)) {
|
|
|
|
/*
|
|
|
|
* Failed to get remote_sha1. If o->remote_ref looks like an
|
|
|
|
* unborn ref, perform the merge using an empty notes tree.
|
|
|
|
*/
|
2011-09-15 21:10:25 +00:00
|
|
|
if (!check_refname_format(o->remote_ref, 0)) {
|
2010-11-09 21:49:46 +00:00
|
|
|
hashclr(remote_sha1);
|
|
|
|
remote = NULL;
|
|
|
|
} else {
|
|
|
|
die("Failed to resolve remote notes ref '%s'",
|
|
|
|
o->remote_ref);
|
|
|
|
}
|
|
|
|
} else if (!(remote = lookup_commit_reference(remote_sha1))) {
|
|
|
|
die("Could not parse remote commit %s (%s)",
|
|
|
|
sha1_to_hex(remote_sha1), o->remote_ref);
|
|
|
|
}
|
|
|
|
trace_printf("\tremote commit: %.7s\n", sha1_to_hex(remote_sha1));
|
|
|
|
|
|
|
|
if (!local && !remote)
|
|
|
|
die("Cannot merge empty notes ref (%s) into empty notes ref "
|
|
|
|
"(%s)", o->remote_ref, o->local_ref);
|
|
|
|
if (!local) {
|
|
|
|
/* result == remote commit */
|
|
|
|
hashcpy(result_sha1, remote_sha1);
|
|
|
|
goto found_result;
|
|
|
|
}
|
|
|
|
if (!remote) {
|
|
|
|
/* result == local commit */
|
|
|
|
hashcpy(result_sha1, local_sha1);
|
|
|
|
goto found_result;
|
|
|
|
}
|
|
|
|
assert(local && remote);
|
|
|
|
|
|
|
|
/* Find merge bases */
|
2014-10-30 19:20:44 +00:00
|
|
|
bases = get_merge_bases(local, remote);
|
2010-11-09 21:49:46 +00:00
|
|
|
if (!bases) {
|
|
|
|
base_sha1 = null_sha1;
|
2011-02-07 08:17:27 +00:00
|
|
|
base_tree_sha1 = EMPTY_TREE_SHA1_BIN;
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 4)
|
|
|
|
printf("No merge base found; doing history-less merge\n");
|
2010-11-09 21:49:46 +00:00
|
|
|
} else if (!bases->next) {
|
|
|
|
base_sha1 = bases->item->object.sha1;
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
base_tree_sha1 = bases->item->tree->object.sha1;
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 4)
|
|
|
|
printf("One merge base found (%.7s)\n",
|
|
|
|
sha1_to_hex(base_sha1));
|
2010-11-09 21:49:46 +00:00
|
|
|
} else {
|
|
|
|
/* TODO: How to handle multiple merge-bases? */
|
|
|
|
base_sha1 = bases->item->object.sha1;
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
base_tree_sha1 = bases->item->tree->object.sha1;
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 3)
|
|
|
|
printf("Multiple merge bases found. Using the first "
|
|
|
|
"(%.7s)\n", sha1_to_hex(base_sha1));
|
2010-11-09 21:49:46 +00:00
|
|
|
}
|
|
|
|
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 4)
|
|
|
|
printf("Merging remote commit %.7s into local commit %.7s with "
|
|
|
|
"merge-base %.7s\n", sha1_to_hex(remote->object.sha1),
|
|
|
|
sha1_to_hex(local->object.sha1),
|
|
|
|
sha1_to_hex(base_sha1));
|
2010-11-09 21:49:46 +00:00
|
|
|
|
|
|
|
if (!hashcmp(remote->object.sha1, base_sha1)) {
|
|
|
|
/* Already merged; result == local commit */
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 2)
|
|
|
|
printf("Already up-to-date!\n");
|
2010-11-09 21:49:46 +00:00
|
|
|
hashcpy(result_sha1, local->object.sha1);
|
|
|
|
goto found_result;
|
|
|
|
}
|
|
|
|
if (!hashcmp(local->object.sha1, base_sha1)) {
|
|
|
|
/* Fast-forward; result == remote commit */
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 2)
|
|
|
|
printf("Fast-forward\n");
|
2010-11-09 21:49:46 +00:00
|
|
|
hashcpy(result_sha1, remote->object.sha1);
|
|
|
|
goto found_result;
|
|
|
|
}
|
|
|
|
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
result = merge_from_diffs(o, base_tree_sha1, local->tree->object.sha1,
|
|
|
|
remote->tree->object.sha1, local_tree);
|
|
|
|
|
2010-11-09 21:49:51 +00:00
|
|
|
if (result != 0) { /* non-trivial merge (with or without conflicts) */
|
|
|
|
/* Commit (partial) result */
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
struct commit_list *parents = NULL;
|
|
|
|
commit_list_insert(remote, &parents); /* LIFO order */
|
|
|
|
commit_list_insert(local, &parents);
|
2014-06-10 21:36:52 +00:00
|
|
|
create_notes_commit(local_tree, parents,
|
|
|
|
o->commit_msg.buf, o->commit_msg.len,
|
git notes merge: Handle real, non-conflicting notes merges
This continuation of the 'git notes merge' implementation teaches notes-merge
to properly do real merges between notes trees: Two diffs are performed, one
from $base to $remote, and another from $base to $local. The paths in each
diff are normalized to SHA1 object names. The two diffs are then consolidated
into a single list of change pairs to be evaluated. Each change pair consist
of:
- The annotated object's SHA1
- The $base SHA1 (i.e. the common ancestor notes for this object)
- The $local SHA1 (i.e. the current notes for this object)
- The $remote SHA1 (i.e. the to-be-merged notes for this object)
From the pair ($base -> $local, $base -> $remote), we can determine the merge
result using regular 3-way rules. If conflicts are encountered in this
process, we fail loudly and exit (conflict handling to be added in a future
patch), If we can complete the merge without conflicts, the resulting
notes tree is committed, and the current notes ref updated.
The patch includes added testcases verifying that we can successfully do real
conflict-less merges.
This patch has been improved by the following contributions:
- Jonathan Nieder: Future-proof by always checking add_note() return value
- Stephen Boyd: Use test_commit
- Jonathan Nieder: Use trace_printf(...) instead of OUTPUT(o, 5, ...)
- Junio C Hamano: fixup minor style issues
Thanks-to: Jonathan Nieder <jrnieder@gmail.com>
Thanks-to: Stephen Boyd <bebarino@gmail.com>
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-14 23:54:11 +00:00
|
|
|
result_sha1);
|
|
|
|
}
|
2010-11-09 21:49:46 +00:00
|
|
|
|
|
|
|
found_result:
|
|
|
|
free_commit_list(bases);
|
2010-11-09 21:49:53 +00:00
|
|
|
strbuf_release(&(o->commit_msg));
|
2010-11-09 21:49:46 +00:00
|
|
|
trace_printf("notes_merge(): result = %i, result_sha1 = %.7s\n",
|
|
|
|
result, sha1_to_hex(result_sha1));
|
|
|
|
return result;
|
|
|
|
}
|
git notes merge: Manual conflict resolution, part 2/2
When the notes merge conflicts in .git/NOTES_MERGE_WORKTREE have been
resolved, we need to record a new notes commit on the appropriate notes
ref with the resolved notes.
This patch implements 'git notes merge --commit' which the user should
run after resolving conflicts in the notes merge worktree. This command
finalizes the notes merge by recombining the partial notes tree from
part 1 with the now-resolved conflicts in the notes merge worktree in a
merge commit, and updating the appropriate ref to this merge commit.
In order to correctly finalize the merge, we need to keep track of three
things:
- The partial merge result from part 1, containing the auto-merged notes.
This is now stored into a ref called .git/NOTES_MERGE_PARTIAL.
- The unmerged notes. These are already stored in
.git/NOTES_MERGE_WORKTREE, thanks to part 1.
- The notes ref to be updated by the finalized merge result. This is now
stored in a symref called .git/NOTES_MERGE_REF.
In addition to "git notes merge --commit", which uses the above details
to create the finalized notes merge commit, this patch also implements
"git notes merge --reset", which aborts the ongoing notes merge by simply
removing the files/directory described above.
FTR, "git notes merge --commit" reuses "git notes merge --reset" to remove
the information described above (.git/NOTES_MERGE_*) after the notes merge
have been successfully finalized.
The patch also contains documentation and testcases for the two new options.
This patch has been improved by the following contributions:
- Ævar Arnfjörð Bjarmason: Fix nonsense sentence in --commit description
- Sverre Rabbelier: Rename --reset to --abort
Thanks-to: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Thanks-to: Sverre Rabbelier <srabbelier@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-09 21:49:52 +00:00
|
|
|
|
|
|
|
int notes_merge_commit(struct notes_merge_options *o,
|
|
|
|
struct notes_tree *partial_tree,
|
|
|
|
struct commit *partial_commit,
|
|
|
|
unsigned char *result_sha1)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Iterate through files in .git/NOTES_MERGE_WORKTREE and add all
|
2012-03-12 14:57:13 +00:00
|
|
|
* found notes to 'partial_tree'. Write the updated notes tree to
|
git notes merge: Manual conflict resolution, part 2/2
When the notes merge conflicts in .git/NOTES_MERGE_WORKTREE have been
resolved, we need to record a new notes commit on the appropriate notes
ref with the resolved notes.
This patch implements 'git notes merge --commit' which the user should
run after resolving conflicts in the notes merge worktree. This command
finalizes the notes merge by recombining the partial notes tree from
part 1 with the now-resolved conflicts in the notes merge worktree in a
merge commit, and updating the appropriate ref to this merge commit.
In order to correctly finalize the merge, we need to keep track of three
things:
- The partial merge result from part 1, containing the auto-merged notes.
This is now stored into a ref called .git/NOTES_MERGE_PARTIAL.
- The unmerged notes. These are already stored in
.git/NOTES_MERGE_WORKTREE, thanks to part 1.
- The notes ref to be updated by the finalized merge result. This is now
stored in a symref called .git/NOTES_MERGE_REF.
In addition to "git notes merge --commit", which uses the above details
to create the finalized notes merge commit, this patch also implements
"git notes merge --reset", which aborts the ongoing notes merge by simply
removing the files/directory described above.
FTR, "git notes merge --commit" reuses "git notes merge --reset" to remove
the information described above (.git/NOTES_MERGE_*) after the notes merge
have been successfully finalized.
The patch also contains documentation and testcases for the two new options.
This patch has been improved by the following contributions:
- Ævar Arnfjörð Bjarmason: Fix nonsense sentence in --commit description
- Sverre Rabbelier: Rename --reset to --abort
Thanks-to: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Thanks-to: Sverre Rabbelier <srabbelier@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-09 21:49:52 +00:00
|
|
|
* the DB, and commit the resulting tree object while reusing the
|
|
|
|
* commit message and parents from 'partial_commit'.
|
|
|
|
* Finally store the new commit object SHA1 into 'result_sha1'.
|
|
|
|
*/
|
2012-03-12 14:57:13 +00:00
|
|
|
DIR *dir;
|
|
|
|
struct dirent *e;
|
|
|
|
struct strbuf path = STRBUF_INIT;
|
2014-06-10 21:44:13 +00:00
|
|
|
const char *buffer = get_commit_buffer(partial_commit, NULL);
|
2014-06-10 21:41:51 +00:00
|
|
|
const char *msg = strstr(buffer, "\n\n");
|
2012-03-12 14:57:13 +00:00
|
|
|
int baselen;
|
git notes merge: Manual conflict resolution, part 2/2
When the notes merge conflicts in .git/NOTES_MERGE_WORKTREE have been
resolved, we need to record a new notes commit on the appropriate notes
ref with the resolved notes.
This patch implements 'git notes merge --commit' which the user should
run after resolving conflicts in the notes merge worktree. This command
finalizes the notes merge by recombining the partial notes tree from
part 1 with the now-resolved conflicts in the notes merge worktree in a
merge commit, and updating the appropriate ref to this merge commit.
In order to correctly finalize the merge, we need to keep track of three
things:
- The partial merge result from part 1, containing the auto-merged notes.
This is now stored into a ref called .git/NOTES_MERGE_PARTIAL.
- The unmerged notes. These are already stored in
.git/NOTES_MERGE_WORKTREE, thanks to part 1.
- The notes ref to be updated by the finalized merge result. This is now
stored in a symref called .git/NOTES_MERGE_REF.
In addition to "git notes merge --commit", which uses the above details
to create the finalized notes merge commit, this patch also implements
"git notes merge --reset", which aborts the ongoing notes merge by simply
removing the files/directory described above.
FTR, "git notes merge --commit" reuses "git notes merge --reset" to remove
the information described above (.git/NOTES_MERGE_*) after the notes merge
have been successfully finalized.
The patch also contains documentation and testcases for the two new options.
This patch has been improved by the following contributions:
- Ævar Arnfjörð Bjarmason: Fix nonsense sentence in --commit description
- Sverre Rabbelier: Rename --reset to --abort
Thanks-to: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Thanks-to: Sverre Rabbelier <srabbelier@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-09 21:49:52 +00:00
|
|
|
|
2012-03-12 14:57:13 +00:00
|
|
|
strbuf_addstr(&path, git_path(NOTES_MERGE_WORKTREE));
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 3)
|
2012-03-12 14:57:13 +00:00
|
|
|
printf("Committing notes in notes merge worktree at %s\n",
|
|
|
|
path.buf);
|
git notes merge: Manual conflict resolution, part 2/2
When the notes merge conflicts in .git/NOTES_MERGE_WORKTREE have been
resolved, we need to record a new notes commit on the appropriate notes
ref with the resolved notes.
This patch implements 'git notes merge --commit' which the user should
run after resolving conflicts in the notes merge worktree. This command
finalizes the notes merge by recombining the partial notes tree from
part 1 with the now-resolved conflicts in the notes merge worktree in a
merge commit, and updating the appropriate ref to this merge commit.
In order to correctly finalize the merge, we need to keep track of three
things:
- The partial merge result from part 1, containing the auto-merged notes.
This is now stored into a ref called .git/NOTES_MERGE_PARTIAL.
- The unmerged notes. These are already stored in
.git/NOTES_MERGE_WORKTREE, thanks to part 1.
- The notes ref to be updated by the finalized merge result. This is now
stored in a symref called .git/NOTES_MERGE_REF.
In addition to "git notes merge --commit", which uses the above details
to create the finalized notes merge commit, this patch also implements
"git notes merge --reset", which aborts the ongoing notes merge by simply
removing the files/directory described above.
FTR, "git notes merge --commit" reuses "git notes merge --reset" to remove
the information described above (.git/NOTES_MERGE_*) after the notes merge
have been successfully finalized.
The patch also contains documentation and testcases for the two new options.
This patch has been improved by the following contributions:
- Ævar Arnfjörð Bjarmason: Fix nonsense sentence in --commit description
- Sverre Rabbelier: Rename --reset to --abort
Thanks-to: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Thanks-to: Sverre Rabbelier <srabbelier@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-09 21:49:52 +00:00
|
|
|
|
|
|
|
if (!msg || msg[2] == '\0')
|
|
|
|
die("partial notes commit has empty message");
|
|
|
|
msg += 2;
|
|
|
|
|
2012-03-12 14:57:13 +00:00
|
|
|
dir = opendir(path.buf);
|
|
|
|
if (!dir)
|
|
|
|
die_errno("could not open %s", path.buf);
|
|
|
|
|
|
|
|
strbuf_addch(&path, '/');
|
|
|
|
baselen = path.len;
|
|
|
|
while ((e = readdir(dir)) != NULL) {
|
git notes merge: Manual conflict resolution, part 2/2
When the notes merge conflicts in .git/NOTES_MERGE_WORKTREE have been
resolved, we need to record a new notes commit on the appropriate notes
ref with the resolved notes.
This patch implements 'git notes merge --commit' which the user should
run after resolving conflicts in the notes merge worktree. This command
finalizes the notes merge by recombining the partial notes tree from
part 1 with the now-resolved conflicts in the notes merge worktree in a
merge commit, and updating the appropriate ref to this merge commit.
In order to correctly finalize the merge, we need to keep track of three
things:
- The partial merge result from part 1, containing the auto-merged notes.
This is now stored into a ref called .git/NOTES_MERGE_PARTIAL.
- The unmerged notes. These are already stored in
.git/NOTES_MERGE_WORKTREE, thanks to part 1.
- The notes ref to be updated by the finalized merge result. This is now
stored in a symref called .git/NOTES_MERGE_REF.
In addition to "git notes merge --commit", which uses the above details
to create the finalized notes merge commit, this patch also implements
"git notes merge --reset", which aborts the ongoing notes merge by simply
removing the files/directory described above.
FTR, "git notes merge --commit" reuses "git notes merge --reset" to remove
the information described above (.git/NOTES_MERGE_*) after the notes merge
have been successfully finalized.
The patch also contains documentation and testcases for the two new options.
This patch has been improved by the following contributions:
- Ævar Arnfjörð Bjarmason: Fix nonsense sentence in --commit description
- Sverre Rabbelier: Rename --reset to --abort
Thanks-to: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Thanks-to: Sverre Rabbelier <srabbelier@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-09 21:49:52 +00:00
|
|
|
struct stat st;
|
|
|
|
unsigned char obj_sha1[20], blob_sha1[20];
|
|
|
|
|
2012-03-12 14:57:13 +00:00
|
|
|
if (is_dot_or_dotdot(e->d_name))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (strlen(e->d_name) != 40 || get_sha1_hex(e->d_name, obj_sha1)) {
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 3)
|
2012-03-12 14:57:13 +00:00
|
|
|
printf("Skipping non-SHA1 entry '%s%s'\n",
|
|
|
|
path.buf, e->d_name);
|
git notes merge: Manual conflict resolution, part 2/2
When the notes merge conflicts in .git/NOTES_MERGE_WORKTREE have been
resolved, we need to record a new notes commit on the appropriate notes
ref with the resolved notes.
This patch implements 'git notes merge --commit' which the user should
run after resolving conflicts in the notes merge worktree. This command
finalizes the notes merge by recombining the partial notes tree from
part 1 with the now-resolved conflicts in the notes merge worktree in a
merge commit, and updating the appropriate ref to this merge commit.
In order to correctly finalize the merge, we need to keep track of three
things:
- The partial merge result from part 1, containing the auto-merged notes.
This is now stored into a ref called .git/NOTES_MERGE_PARTIAL.
- The unmerged notes. These are already stored in
.git/NOTES_MERGE_WORKTREE, thanks to part 1.
- The notes ref to be updated by the finalized merge result. This is now
stored in a symref called .git/NOTES_MERGE_REF.
In addition to "git notes merge --commit", which uses the above details
to create the finalized notes merge commit, this patch also implements
"git notes merge --reset", which aborts the ongoing notes merge by simply
removing the files/directory described above.
FTR, "git notes merge --commit" reuses "git notes merge --reset" to remove
the information described above (.git/NOTES_MERGE_*) after the notes merge
have been successfully finalized.
The patch also contains documentation and testcases for the two new options.
This patch has been improved by the following contributions:
- Ævar Arnfjörð Bjarmason: Fix nonsense sentence in --commit description
- Sverre Rabbelier: Rename --reset to --abort
Thanks-to: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Thanks-to: Sverre Rabbelier <srabbelier@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-09 21:49:52 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-03-12 14:57:13 +00:00
|
|
|
strbuf_addstr(&path, e->d_name);
|
git notes merge: Manual conflict resolution, part 2/2
When the notes merge conflicts in .git/NOTES_MERGE_WORKTREE have been
resolved, we need to record a new notes commit on the appropriate notes
ref with the resolved notes.
This patch implements 'git notes merge --commit' which the user should
run after resolving conflicts in the notes merge worktree. This command
finalizes the notes merge by recombining the partial notes tree from
part 1 with the now-resolved conflicts in the notes merge worktree in a
merge commit, and updating the appropriate ref to this merge commit.
In order to correctly finalize the merge, we need to keep track of three
things:
- The partial merge result from part 1, containing the auto-merged notes.
This is now stored into a ref called .git/NOTES_MERGE_PARTIAL.
- The unmerged notes. These are already stored in
.git/NOTES_MERGE_WORKTREE, thanks to part 1.
- The notes ref to be updated by the finalized merge result. This is now
stored in a symref called .git/NOTES_MERGE_REF.
In addition to "git notes merge --commit", which uses the above details
to create the finalized notes merge commit, this patch also implements
"git notes merge --reset", which aborts the ongoing notes merge by simply
removing the files/directory described above.
FTR, "git notes merge --commit" reuses "git notes merge --reset" to remove
the information described above (.git/NOTES_MERGE_*) after the notes merge
have been successfully finalized.
The patch also contains documentation and testcases for the two new options.
This patch has been improved by the following contributions:
- Ævar Arnfjörð Bjarmason: Fix nonsense sentence in --commit description
- Sverre Rabbelier: Rename --reset to --abort
Thanks-to: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Thanks-to: Sverre Rabbelier <srabbelier@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-09 21:49:52 +00:00
|
|
|
/* write file as blob, and add to partial_tree */
|
2012-03-12 14:57:13 +00:00
|
|
|
if (stat(path.buf, &st))
|
|
|
|
die_errno("Failed to stat '%s'", path.buf);
|
|
|
|
if (index_path(blob_sha1, path.buf, &st, HASH_WRITE_OBJECT))
|
|
|
|
die("Failed to write blob object from '%s'", path.buf);
|
git notes merge: Manual conflict resolution, part 2/2
When the notes merge conflicts in .git/NOTES_MERGE_WORKTREE have been
resolved, we need to record a new notes commit on the appropriate notes
ref with the resolved notes.
This patch implements 'git notes merge --commit' which the user should
run after resolving conflicts in the notes merge worktree. This command
finalizes the notes merge by recombining the partial notes tree from
part 1 with the now-resolved conflicts in the notes merge worktree in a
merge commit, and updating the appropriate ref to this merge commit.
In order to correctly finalize the merge, we need to keep track of three
things:
- The partial merge result from part 1, containing the auto-merged notes.
This is now stored into a ref called .git/NOTES_MERGE_PARTIAL.
- The unmerged notes. These are already stored in
.git/NOTES_MERGE_WORKTREE, thanks to part 1.
- The notes ref to be updated by the finalized merge result. This is now
stored in a symref called .git/NOTES_MERGE_REF.
In addition to "git notes merge --commit", which uses the above details
to create the finalized notes merge commit, this patch also implements
"git notes merge --reset", which aborts the ongoing notes merge by simply
removing the files/directory described above.
FTR, "git notes merge --commit" reuses "git notes merge --reset" to remove
the information described above (.git/NOTES_MERGE_*) after the notes merge
have been successfully finalized.
The patch also contains documentation and testcases for the two new options.
This patch has been improved by the following contributions:
- Ævar Arnfjörð Bjarmason: Fix nonsense sentence in --commit description
- Sverre Rabbelier: Rename --reset to --abort
Thanks-to: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Thanks-to: Sverre Rabbelier <srabbelier@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-09 21:49:52 +00:00
|
|
|
if (add_note(partial_tree, obj_sha1, blob_sha1, NULL))
|
|
|
|
die("Failed to add resolved note '%s' to notes tree",
|
2012-03-12 14:57:13 +00:00
|
|
|
path.buf);
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 4)
|
|
|
|
printf("Added resolved note for object %s: %s\n",
|
|
|
|
sha1_to_hex(obj_sha1), sha1_to_hex(blob_sha1));
|
2012-03-12 14:57:13 +00:00
|
|
|
strbuf_setlen(&path, baselen);
|
git notes merge: Manual conflict resolution, part 2/2
When the notes merge conflicts in .git/NOTES_MERGE_WORKTREE have been
resolved, we need to record a new notes commit on the appropriate notes
ref with the resolved notes.
This patch implements 'git notes merge --commit' which the user should
run after resolving conflicts in the notes merge worktree. This command
finalizes the notes merge by recombining the partial notes tree from
part 1 with the now-resolved conflicts in the notes merge worktree in a
merge commit, and updating the appropriate ref to this merge commit.
In order to correctly finalize the merge, we need to keep track of three
things:
- The partial merge result from part 1, containing the auto-merged notes.
This is now stored into a ref called .git/NOTES_MERGE_PARTIAL.
- The unmerged notes. These are already stored in
.git/NOTES_MERGE_WORKTREE, thanks to part 1.
- The notes ref to be updated by the finalized merge result. This is now
stored in a symref called .git/NOTES_MERGE_REF.
In addition to "git notes merge --commit", which uses the above details
to create the finalized notes merge commit, this patch also implements
"git notes merge --reset", which aborts the ongoing notes merge by simply
removing the files/directory described above.
FTR, "git notes merge --commit" reuses "git notes merge --reset" to remove
the information described above (.git/NOTES_MERGE_*) after the notes merge
have been successfully finalized.
The patch also contains documentation and testcases for the two new options.
This patch has been improved by the following contributions:
- Ævar Arnfjörð Bjarmason: Fix nonsense sentence in --commit description
- Sverre Rabbelier: Rename --reset to --abort
Thanks-to: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Thanks-to: Sverre Rabbelier <srabbelier@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-09 21:49:52 +00:00
|
|
|
}
|
|
|
|
|
2014-06-10 21:36:52 +00:00
|
|
|
create_notes_commit(partial_tree, partial_commit->parents,
|
2014-06-10 21:38:38 +00:00
|
|
|
msg, strlen(msg), result_sha1);
|
2014-06-10 21:41:51 +00:00
|
|
|
unuse_commit_buffer(partial_commit, buffer);
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 4)
|
|
|
|
printf("Finalized notes merge commit: %s\n",
|
|
|
|
sha1_to_hex(result_sha1));
|
2012-03-12 14:57:13 +00:00
|
|
|
strbuf_release(&path);
|
|
|
|
closedir(dir);
|
git notes merge: Manual conflict resolution, part 2/2
When the notes merge conflicts in .git/NOTES_MERGE_WORKTREE have been
resolved, we need to record a new notes commit on the appropriate notes
ref with the resolved notes.
This patch implements 'git notes merge --commit' which the user should
run after resolving conflicts in the notes merge worktree. This command
finalizes the notes merge by recombining the partial notes tree from
part 1 with the now-resolved conflicts in the notes merge worktree in a
merge commit, and updating the appropriate ref to this merge commit.
In order to correctly finalize the merge, we need to keep track of three
things:
- The partial merge result from part 1, containing the auto-merged notes.
This is now stored into a ref called .git/NOTES_MERGE_PARTIAL.
- The unmerged notes. These are already stored in
.git/NOTES_MERGE_WORKTREE, thanks to part 1.
- The notes ref to be updated by the finalized merge result. This is now
stored in a symref called .git/NOTES_MERGE_REF.
In addition to "git notes merge --commit", which uses the above details
to create the finalized notes merge commit, this patch also implements
"git notes merge --reset", which aborts the ongoing notes merge by simply
removing the files/directory described above.
FTR, "git notes merge --commit" reuses "git notes merge --reset" to remove
the information described above (.git/NOTES_MERGE_*) after the notes merge
have been successfully finalized.
The patch also contains documentation and testcases for the two new options.
This patch has been improved by the following contributions:
- Ævar Arnfjörð Bjarmason: Fix nonsense sentence in --commit description
- Sverre Rabbelier: Rename --reset to --abort
Thanks-to: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Thanks-to: Sverre Rabbelier <srabbelier@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-09 21:49:52 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int notes_merge_abort(struct notes_merge_options *o)
|
|
|
|
{
|
notes-merge: Don't remove .git/NOTES_MERGE_WORKTREE; it may be the user's cwd
When a manual notes merge is committed or aborted, we need to remove the
temporary worktree at .git/NOTES_MERGE_WORKTREE. However, removing the
entire directory is not good if the user ran the 'git notes merge
--commit/--abort' from within that directory. On Windows, the directory
removal would simply fail, while on POSIX systems, users would suddenly
find themselves in an invalid current directory.
Therefore, instead of deleting the entire directory, we delete everything
_within_ the directory, and leave the (empty) directory in place.
This would cause a subsequent notes merge to abort, complaining about a
previous - unfinished - notes merge (due to the presence of
.git/NOTES_MERGE_WORKTREE), so we also need to adjust this check to only
trigger when .git/NOTES_MERGE_WORKTREE is non-empty.
Finally, adjust the t3310 manual notes merge testcases to correctly handle
the existence of an empty .git/NOTES_MERGE_WORKTREE directory.
Inspired-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-03-15 14:58:56 +00:00
|
|
|
/*
|
|
|
|
* Remove all files within .git/NOTES_MERGE_WORKTREE. We do not remove
|
|
|
|
* the .git/NOTES_MERGE_WORKTREE directory itself, since it might be
|
|
|
|
* the current working directory of the user.
|
|
|
|
*/
|
git notes merge: Manual conflict resolution, part 2/2
When the notes merge conflicts in .git/NOTES_MERGE_WORKTREE have been
resolved, we need to record a new notes commit on the appropriate notes
ref with the resolved notes.
This patch implements 'git notes merge --commit' which the user should
run after resolving conflicts in the notes merge worktree. This command
finalizes the notes merge by recombining the partial notes tree from
part 1 with the now-resolved conflicts in the notes merge worktree in a
merge commit, and updating the appropriate ref to this merge commit.
In order to correctly finalize the merge, we need to keep track of three
things:
- The partial merge result from part 1, containing the auto-merged notes.
This is now stored into a ref called .git/NOTES_MERGE_PARTIAL.
- The unmerged notes. These are already stored in
.git/NOTES_MERGE_WORKTREE, thanks to part 1.
- The notes ref to be updated by the finalized merge result. This is now
stored in a symref called .git/NOTES_MERGE_REF.
In addition to "git notes merge --commit", which uses the above details
to create the finalized notes merge commit, this patch also implements
"git notes merge --reset", which aborts the ongoing notes merge by simply
removing the files/directory described above.
FTR, "git notes merge --commit" reuses "git notes merge --reset" to remove
the information described above (.git/NOTES_MERGE_*) after the notes merge
have been successfully finalized.
The patch also contains documentation and testcases for the two new options.
This patch has been improved by the following contributions:
- Ævar Arnfjörð Bjarmason: Fix nonsense sentence in --commit description
- Sverre Rabbelier: Rename --reset to --abort
Thanks-to: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Thanks-to: Sverre Rabbelier <srabbelier@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-09 21:49:52 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
strbuf_addstr(&buf, git_path(NOTES_MERGE_WORKTREE));
|
2011-11-18 01:27:46 +00:00
|
|
|
if (o->verbosity >= 3)
|
notes-merge: Don't remove .git/NOTES_MERGE_WORKTREE; it may be the user's cwd
When a manual notes merge is committed or aborted, we need to remove the
temporary worktree at .git/NOTES_MERGE_WORKTREE. However, removing the
entire directory is not good if the user ran the 'git notes merge
--commit/--abort' from within that directory. On Windows, the directory
removal would simply fail, while on POSIX systems, users would suddenly
find themselves in an invalid current directory.
Therefore, instead of deleting the entire directory, we delete everything
_within_ the directory, and leave the (empty) directory in place.
This would cause a subsequent notes merge to abort, complaining about a
previous - unfinished - notes merge (due to the presence of
.git/NOTES_MERGE_WORKTREE), so we also need to adjust this check to only
trigger when .git/NOTES_MERGE_WORKTREE is non-empty.
Finally, adjust the t3310 manual notes merge testcases to correctly handle
the existence of an empty .git/NOTES_MERGE_WORKTREE directory.
Inspired-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-03-15 14:58:56 +00:00
|
|
|
printf("Removing notes merge worktree at %s/*\n", buf.buf);
|
|
|
|
ret = remove_dir_recursively(&buf, REMOVE_DIR_KEEP_TOPLEVEL);
|
git notes merge: Manual conflict resolution, part 2/2
When the notes merge conflicts in .git/NOTES_MERGE_WORKTREE have been
resolved, we need to record a new notes commit on the appropriate notes
ref with the resolved notes.
This patch implements 'git notes merge --commit' which the user should
run after resolving conflicts in the notes merge worktree. This command
finalizes the notes merge by recombining the partial notes tree from
part 1 with the now-resolved conflicts in the notes merge worktree in a
merge commit, and updating the appropriate ref to this merge commit.
In order to correctly finalize the merge, we need to keep track of three
things:
- The partial merge result from part 1, containing the auto-merged notes.
This is now stored into a ref called .git/NOTES_MERGE_PARTIAL.
- The unmerged notes. These are already stored in
.git/NOTES_MERGE_WORKTREE, thanks to part 1.
- The notes ref to be updated by the finalized merge result. This is now
stored in a symref called .git/NOTES_MERGE_REF.
In addition to "git notes merge --commit", which uses the above details
to create the finalized notes merge commit, this patch also implements
"git notes merge --reset", which aborts the ongoing notes merge by simply
removing the files/directory described above.
FTR, "git notes merge --commit" reuses "git notes merge --reset" to remove
the information described above (.git/NOTES_MERGE_*) after the notes merge
have been successfully finalized.
The patch also contains documentation and testcases for the two new options.
This patch has been improved by the following contributions:
- Ævar Arnfjörð Bjarmason: Fix nonsense sentence in --commit description
- Sverre Rabbelier: Rename --reset to --abort
Thanks-to: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Thanks-to: Sverre Rabbelier <srabbelier@gmail.com>
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2010-11-09 21:49:52 +00:00
|
|
|
strbuf_release(&buf);
|
|
|
|
return ret;
|
|
|
|
}
|