Skip to content

Commit

Permalink
annotate: Correct most merge following to annotate correctly.
Browse files Browse the repository at this point in the history 
There is still a bug involving octopus merges, somewhere, but this gets normal
merges correct, so it's still an improvement over the existing version.

Signed-off-by: Ryan Anderson <ryan@michonline.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>
  • Loading branch information
Ryan Anderson authored and Junio C Hamano committed Jul 4, 2006
1 parent f560069 commit 3f492ba
Showing 1 changed file with 139 additions and 58 deletions.
197 changes: 139 additions & 58 deletions git-annotate.perl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -102,10 +102,10 @@ ()
push @revqueue, $head;
init_claim( defined $starting_rev ? $head : 'dirty');
unless (defined $starting_rev) {
my $diff = open_pipe("git","diff","-R", "HEAD", "--",$filename)
my $diff = open_pipe("git","diff","HEAD", "--",$filename)
or die "Failed to call git diff to check for dirty state: $!";

_git_diff_parse($diff, $head, "dirty", (
_git_diff_parse($diff, [$head], "dirty", (
'author' => gitvar_name("GIT_AUTHOR_IDENT"),
'author_date' => sprintf("%s +0000",time()),
)
Expand Down Expand Up @@ -154,14 +154,13 @@ sub handle_rev {

my %revinfo = git_commit_info($rev);

foreach my $p (@{$revs{$rev}{'parents'}}) {

git_diff_parse($p, $rev, %revinfo);
push @revqueue, $p;
}
if (exists $revs{$rev}{parents} &&
scalar @{$revs{$rev}{parents}} != 0) {

git_diff_parse($revs{$rev}{'parents'}, $rev, %revinfo);
push @revqueue, @{$revs{$rev}{'parents'}};

if (scalar @{$revs{$rev}{parents}} == 0) {
} else {
# We must be at the initial rev here, so claim everything that is left.
for (my $i = 0; $i < @{$revs{$rev}{lines}}; $i++) {
if (ref ${$revs{$rev}{lines}}[$i] eq '' || ${$revs{$rev}{lines}}[$i][1] eq '') {
Expand Down Expand Up @@ -252,89 +251,171 @@ sub git_find_parent {
# Get a diff between the current revision and a parent.
# Record the commit information that results.
sub git_diff_parse {
my ($parent, $rev, %revinfo) = @_;
my ($parents, $rev, %revinfo) = @_;

my $diff = open_pipe("git-diff-tree","-M","-p",$rev,$parent,"--",
$revs{$rev}{'filename'}, $revs{$parent}{'filename'})
my @filenames = ( $revs{$rev}{'filename'} );
foreach my $parent (@$parents) {
push @filenames, $revs{$parent}{'filename'};
}

my $diff = open_pipe("git-diff-tree","-M","-p","-c",$rev,"--",
@filenames )
or die "Failed to call git-diff for annotation: $!";

_git_diff_parse($diff, $parent, $rev, %revinfo);
_git_diff_parse($diff, $parents, $rev, %revinfo);

close($diff);
}

sub _git_diff_parse {
my ($diff, $parent, $rev, %revinfo) = @_;
my ($diff, $parents, $rev, %revinfo) = @_;

my $ri = 0;

my ($ri, $pi) = (0,0);
my $slines = $revs{$rev}{'lines'};
my @plines;
my (%plines, %pi);

my $gotheader = 0;
my ($remstart);
my ($hunk_start, $hunk_index);
my $parent_count = @$parents;

my $diff_header_regexp = "^@";
$diff_header_regexp .= "@" x @$parents;
$diff_header_regexp .= ' -\d+,\d+' x @$parents;
$diff_header_regexp .= ' \+(\d+),\d+';

my %claim_regexps;
my $allparentplus = '^' . '\\+' x @$parents . '(.*)$';

{
my $i = 0;
foreach my $parent (@$parents) {

$pi{$parent} = 0;
my $r = '^' . '.' x @$parents . '(.*)$';
my $p = $r;
substr($p,$i+1, 1) = '\\+';

my $m = $r;
substr($m,$i+1, 1) = '-';

$claim_regexps{$parent}{plus} = $p;
$claim_regexps{$parent}{minus} = $m;

$plines{$parent} = [];

$i++;
}
}

DIFF:
while(<$diff>) {
chomp;
if (m/^@@ -(\d+),(\d+) \+(\d+),(\d+)/) {
$remstart = $1;
# Adjust for 0-based arrays
$remstart--;
# Reinit hunk tracking.
$hunk_start = $remstart;
$hunk_index = 0;
if (m/$diff_header_regexp/) {
$remstart = $1 - 1;
# (0-based arrays)

$gotheader = 1;

for (my $i = $ri; $i < $remstart; $i++) {
$plines[$pi++] = $slines->[$i];
$ri++;
printf("Copying from %d to %d\n", $ri, $remstart);
foreach my $parent (@$parents) {
for (my $i = $ri; $i < $remstart; $i++) {
$plines{$parent}[$pi{$parent}++] = $slines->[$i];
}
}
next;
} elsif (!$gotheader) {
next;
}
$ri = $remstart;

if (m/^\+(.*)$/) {
my $line = $1;
$plines[$pi++] = [ $line, '', '', '', 0 ];
next;
next DIFF;

} elsif (m/^-(.*)$/) {
my $line = $1;
if (get_line($slines, $ri) eq $line) {
# Found a match, claim
claim_line($ri, $rev, $slines, %revinfo);
} else {
die sprintf("Sync error: %d/%d\n|%s\n|%s\n%s => %s\n",
$ri, $hunk_start + $hunk_index,
$line,
get_line($slines, $ri),
$rev, $parent);
}
$ri++;
} elsif (!$gotheader) {
# Skip over the leadin.
next DIFF;
}

} elsif (m/^\\/) {
if (m/^\\/) {
;
# Skip \No newline at end of file.
# But this can be internationalized, so only look
# for an initial \

} else {
if (substr($_,1) ne get_line($slines,$ri) ) {
die sprintf("Line %d (%d) does not match:\n|%s\n|%s\n%s => %s\n",
$hunk_start + $hunk_index, $ri,
substr($_,1),
get_line($slines,$ri),
$rev, $parent);
my %claims = ();
my $negclaim = 0;
my $allclaimed = 0;
my $line;

if (m/$allparentplus/) {
claim_line($ri, $rev, $slines, %revinfo);
$allclaimed = 1;

}

PARENT:
foreach my $parent (keys %claim_regexps) {
my $m = $claim_regexps{$parent}{minus};
my $p = $claim_regexps{$parent}{plus};

if (m/$m/) {
$line = $1;
$plines{$parent}[$pi{$parent}++] = [ $line, '', '', '', 0 ];
$negclaim++;

} elsif (m/$p/) {
$line = $1;
if (get_line($slines, $ri) eq $line) {
# Found a match, claim
$claims{$parent}++;

} else {
die sprintf("Sync error: %d\n|%s\n|%s\n%s => %s\n",
$ri, $line,
get_line($slines, $ri),
$rev, $parent);
}
}
}

if (%claims) {
foreach my $parent (@$parents) {
next if $claims{$parent} || $allclaimed;
$plines{$parent}[$pi{$parent}++] = $slines->[$ri];
#[ $line, '', '', '', 0 ];
}
$ri++;

} elsif ($negclaim) {
next DIFF;

} else {
if (substr($_,scalar @$parents) ne get_line($slines,$ri) ) {
foreach my $parent (@$parents) {
printf("parent %s is on line %d\n", $parent, $pi{$parent});
}

die sprintf("Line %d, does not match:\n|%s|\n|%s|\n%s\n",
$ri,
substr($_,scalar @$parents),
get_line($slines,$ri), $rev);
}
foreach my $parent (@$parents) {
$plines{$parent}[$pi{$parent}++] = $slines->[$ri];
}
$ri++;
}
$plines[$pi++] = $slines->[$ri++];
}
$hunk_index++;
}

for (my $i = $ri; $i < @{$slines} ; $i++) {
push @plines, $slines->[$ri++];
foreach my $parent (@$parents) {
push @{$plines{$parent}}, $slines->[$ri];
}
$ri++;
}

foreach my $parent (@$parents) {
$revs{$parent}{lines} = $plines{$parent};
}

$revs{$parent}{lines} = \@plines;
return;
}

Expand Down

0 comments on commit 3f492ba

Please sign in to comment.