File Coverage

git-autofixup

Criterion	Covered	Total	%
statement	231	290	79.6
branch	84	136	61.7
condition	24	33	72.7
subroutine	21	24	87.5
pod			n/a
total	360	483	74.5

#!/usr/bin/perl
package main;
use 5.008004;
use strict;
use warnings FATAL => 'all';

use Carp qw(croak);
use Pod::Usage;
use Getopt::Long qw(:config bundling);

our $VERSION = 0.002006; # X.YYYZZZ

my $verbose;

# Strictness levels.
my ($CONTEXT, $ADJACENT, $SURROUNDED) = (0..10);

my $usage =<<'END';
usage: git-autofixup []

-h                 show usage
--help             show manpage
--version          show version
-v, --verbose      increase verbosity (use up to 2 times)
-c N, --context N  set number of diff context lines (default 3)
-s N, --strict N   set strictness (default 0)
    Assign hunk to topic branch commit if:
    0: exactly one topic branch commit is blamed in hunk context or
       changed lines are adjacent to exactly one topic branch commit
    1: changed lines are adjacent to exactly one topic branch commit
    2: changed lines are surrounded by exactly one topic branch commit
END

# Parse hunks out of `git diff` output. Return an array of hunk hashrefs.
sub parse_hunks {
    my $fh = shift;
    my ($file_a, $file_b);
    my @hunks;
    my $line;
    while ($line = <$fh>) {
        if ($line =~ /^--- (.*)/) {
            $file_a = $1;
        } elsif ($line =~ /^\+\+\+ (.*)/) {
            $file_b = $1;
        } elsif ($line =~ /^@@ -(\d+)(?:,(\d+))? \+\d+(?:,\d+)? @@/) {
            my $header = $line;

            for ($file_a, $file_b) {
                s#^[ab]/##;
            }

            next if $file_a ne $file_b; # Ignore creations and deletions.

            my $lines = [];
            while (1) {
                $line = <$fh>;
                if (!defined($line) || $line =~ /^[^ +-\\]/) {
                    last;
                }
                push @{$lines}, $line;
            }

            push(@hunks, {
                file => $file_a,
                start => $1,
                count => defined($2) ? $2 : 1,
                header => $header,
                lines => $lines,
            });
            # The next line after a hunk could be a header for the next commit
            # or hunk.
            redo if defined $line;
        }
    }
    return @hunks;
}

sub get_summary_for_commits {
    my $rev = shift;
    my %commits;
    for (qx(git log --no-merges --format=%H:%s $rev..)) {
        chomp;
        my ($sha, $msg) = split ':', $_, 2;
        $commits{$sha} = $msg;
    }
    return \%commits;
}

# Return targets of fixup!/squash! commits.
sub get_sha_aliases {
    my $summary_for = shift;
    my %aliases;
    my @targets = keys(%{$summary_for});
    for my $sha (@targets) {
        my $summary = $summary_for->{$sha};
        next if $summary !~ /^(?:fixup|squash)! (.*)/;
        my $prefix = $1;
        if ($prefix =~ /^(?:(?:fixup|squash)! ){2}/) {
            die "fixup commits for fixup commits aren't supported: $sha";
        }
        my @matches = grep {startswith($summary_for->{$_}, $prefix)} @targets;
        if (@matches > 1) {
            die "ambiguous fixup commit target: multiple commit summaries start with: $prefix\n";
        } elsif (@matches == 0) {
            die "no fixup target: $sha";
        } elsif (@matches == 1) {
            $aliases{$sha} = $matches[0];
        }
    }
    return \%aliases;
}

sub get_fixup_sha {
    my $args = shift;
    my $hunk = $args->{hunk};
    my $blame = $args->{blame};
    my $summary_for = $args->{summary_for};
    my $strict = $args->{strict};
    if (grep {!defined} ($hunk, $blame, $summary_for, $strict)) {
        croak 'missing argument';
    }

    my @targets;
    if ($args->{strict} == $CONTEXT) {
        @targets = get_fixup_targets_from_all_context($args);
        my @topic_targets = grep {defined $summary_for->{$_}} @targets;
        if (@topic_targets > 1) {
            # The context assignment is ambiguous, but an adjacency assignment
            # might not be.
            @targets = get_fixup_targets_from_adjacent_context($args);
        }
    } else {
        @targets = get_fixup_targets_from_adjacent_context($args);
    }

    my $upstream_is_blamed = grep {!defined $summary_for->{$_}} @targets;
    my @topic_targets = grep {defined $summary_for->{$_}} @targets;
    if ($strict && $upstream_is_blamed) {
        $verbose && print hunk_desc($hunk), " changes lines blamed on upstream\n";
        return;
    } elsif (@topic_targets > 1) {
        $verbose && print hunk_desc($hunk), " has multiple targets\n";
        return;
    } elsif (@topic_targets == 0) {
        $verbose && print hunk_desc($hunk), " has no targets\n";
        return;
    }
    if ($verbose) {
        printf "%s fixes %s %s\n",
            hunk_desc($hunk),
            substr($topic_targets[0], 0, 8),
            $summary_for->{$topic_targets[0]};
    }
    return $topic_targets[0];
}

sub hunk_desc {
    my $hunk = shift;
    return join " ", (
        $hunk->{file},
        $hunk->{header} =~ /(@@[^@]*@@)/,
    );
}

sub get_fixup_targets_from_all_context {
    my $args = shift;
    my ($hunk, $blame, $summary_for) = @{$args}{qw(hunk blame summary_for)};
    croak 'missing argument' if grep {!defined} ($hunk, $blame, $summary_for);

    my @targets = uniq(map {$_->{sha}} values(%{$blame}));
    return wantarray ? @targets : \@targets;
}

sub uniq {
    my %seen;
    return grep {!$seen{$_}++} @_;
}

sub get_fixup_targets_from_adjacent_context {
    my $args = shift;
    my $hunk = $args->{hunk};
    my $blame = $args->{blame};
    my $summary_for = $args->{summary_for};
    my $strict = $args->{strict};
    if (grep {!defined} ($hunk, $blame, $summary_for, $strict)) {
        croak 'missing argument';
    }

    my $blame_indexes = get_blame_indexes($hunk);

    my %blamed;
    my $diff = $hunk->{lines};
    for (my $di = 0; $di < @{$diff}; $di++) { # diff index
        my $bi = $blame_indexes->[$di];
        my $line = $diff->[$di];
        if (startswith($line, '-')) {
            my $sha = $blame->{$bi}{sha};
            $blamed{$sha} = 1;
        } elsif (startswith($line, '+')) {
            my @lines;
            if ($di > 0 && defined $blame->{$bi-1}) {
                push @lines, $bi-1;
            }
            if (defined $blame->{$bi}) {
                push @lines, $bi;
            }
            my @adjacent_shas = uniq(map {$_->{sha}} @{$blame}{@lines});
            my @target_shas = grep {defined $summary_for->{$_}} @adjacent_shas;
            # Note that lines at the beginning or end of a file can be
            # "surrounded" by a single line.
            my $is_surrounded = @target_shas > 0
                && @target_shas == @adjacent_shas
                && $target_shas[0] eq $target_shas[-1];
            my $is_adjacent = @target_shas == 1;
            if ($is_surrounded || ($strict < $SURROUNDED && $is_adjacent)) {
                $blamed{$target_shas[0]} = 1;
            }
            while ($di < @$diff-1 && startswith($diff->[$di+1], '+')) {
                $di++;
            }
        }
    }
    my @targets = keys %blamed;
    return wantarray ? @targets : \@targets;
}

sub startswith {
    my ($haystack, $needle) = @_;
    return index($haystack, $needle, 0) == 0;
}

# Map lines in a hunk's diff to the corresponding `git blame HEAD` output.
sub get_blame_indexes {
    my $hunk = shift;
    my @indexes;
    my $bi = $hunk->{start};
    for (my $di = 0; $di < @{$hunk->{lines}}; $di++) {
        push @indexes, $bi;
        my $first = substr($hunk->{lines}[$di], 0, 1);
        if ($first eq '-' or $first eq ' ') {
            $bi++;
        }
        # Don't increment $bi for added lines.
    }
    return \@indexes;
}

sub print_hunk_blamediff {
    my $args = shift;
    my $fh = $args->{fh};
    my $hunk = $args->{hunk};
    my $summary_for = $args->{summary_for};
    my $blame = $args->{blame};
    my $blame_indexes = $args->{blame_indexes};
    if (grep {!defined} ($fh, $hunk, $summary_for, $blame, $blame_indexes)) {
        croak 'missing argument';
    }

    my $format = "%-8.8s|%4.4s|%-30.30s|%-30.30s\n";
    for (my $i = 0; $i < @{$hunk->{lines}}; $i++) {
        my $line_r = $hunk->{lines}[$i];
        my $bi = $blame_indexes->[$i];
        my $sha = defined $blame->{$bi} ? $blame->{$bi}{sha} : undef;

        my $display_sha = defined($sha) ? $sha : q{};
        my $display_bi = $bi;
        if (startswith($line_r, '+')) {
            $display_sha = q{}; # For added lines.
            $display_bi = q{};
        }
        if (defined($sha) && !defined($summary_for->{$sha})) {
            # For lines from before the given upstream revision.
            $display_sha = '^';
        }

        my $line_l = '';
        if (defined $blame->{$bi} && !startswith($line_r, '+')) {
            $line_l = $blame->{$bi}{text};
        }

        for ($line_l, $line_r) {
            # For the table to line up, tabs need to be converted to a string of fixed width.
            s/\t/^I/g;
            # Remove trailing newlines and carriage returns. If more trailing
            # whitespace is removed, that's fine.
            $_ = rtrim($_);
        }

        printf {$fh} $format, $display_sha, $display_bi, $line_l, $line_r;
    }
    print {$fh} "\n";
    return;
}

sub rtrim {
    my $s = shift;
    $s =~ s/\s+\z//;
    return $s;
}

sub blame {
    my ($hunk, $alias_for) = @_;
    if ($hunk->{count} == 0) {
        return {};
    }
    my @cmd = (
        'git', 'blame', '--porcelain',
        '-L' => "$hunk->{start},+$hunk->{count}",
        'HEAD', '--',
        "$hunk->{file}");
    my %blame;
    my ($sha, $line_num);
    open(my $fh, '-|', @cmd) or die "git blame: $!\n";
    while (my $line = <$fh>) {
        if ($line =~ /^([0-9a-f]{40}) \d+ (\d+)/) {
             ($sha, $line_num) = ($1, $2);
        }
        if (startswith($line, "\t")) {
            if (defined $alias_for->{$sha}) {
                $sha = $alias_for->{$sha};
            }
            $blame{$line_num} = {sha => $sha, text => substr($line, 1)};
        }
    }
    close($fh) or die "git blame: non-zero exit code";
    return \%blame;
}

sub get_diff_hunks {
    my $num_context_lines = shift;
    my @cmd = (qw(git diff --ignore-submodules), "-U$num_context_lines");
    open(my $fh, '-|', @cmd) or die $!;
    my @hunks = parse_hunks($fh, keep_lines => 1);
    close($fh) or die "git diff: non-zero exit code";
    return wantarray ? @hunks : \@hunks;
}

sub commit_fixup {
    my ($sha, $hunks) = @_;
    open my $fh, '|-', 'git apply --unidiff-zero --cached -' or die "git apply: $!\n";
    for my $hunk (@{$hunks}) {
        print({$fh}
            "--- a/$hunk->{file}\n",
            "+++ b/$hunk->{file}\n",
            $hunk->{header},
            @{$hunk->{lines}},
        );
    }
    close $fh or die "git apply: non-zero exit code\n";
    system('git', 'commit', "--fixup=$sha") == 0 or die "git commit: $!\n";
    return;
}

sub is_index_dirty {
    open(my $fh, '-|', 'git status --porcelain') or die "git status: $!\n";
    my $dirty;
    while (my $line = <$fh>) {
        if ($line =~ /^[^?! ]/) {
            $dirty = 1;
            last;
        }
    }
    close $fh or die "git status: non-zero exit code\n";
    return $dirty;
}

sub get_fixup_hunks_by_sha {
    my $args = shift;
    my $hunks = $args->{hunks};
    my $blame_for = $args->{blame_for};
    my $summary_for = $args->{summary_for};
    my $strict = $args->{strict};
    if (grep {!defined} ($hunks, $blame_for, $summary_for, $strict)) {
        croak 'missing argument';
    }

    my %hunks_for;
    for my $hunk (@{$hunks}) {
        my $blame = $blame_for->{$hunk};
        my $sha = get_fixup_sha({
            hunk => $hunk,
            blame => $blame,
            summary_for => $summary_for,
            strict => $strict,
        });
        if ($verbose > 1) {
            print_hunk_blamediff({
                fh => *STDOUT,
                hunk => $hunk,
                summary_for => $summary_for,
                blame => $blame,
                blame_indexes => get_blame_indexes($hunk)
            });
        }
        next if !$sha;
        push @{$hunks_for{$sha}}, $hunk;
    }
    return \%hunks_for;
}

sub main {
    $verbose = 0;
    my $num_context_lines = 3;
    my $strict = $CONTEXT;
    my $man;

    my ($help, $show_version);
    GetOptions(
        'h' => \$help,
        'help' => \$man,
        'version' => \$show_version,
        'verbose|v+' => \$verbose,
        'strict|s=i' => \$strict,
        'context|c=i' => \$num_context_lines,
    ) or return 1;
    if ($help) {
        print $usage;
        return 0;
    }
    if ($show_version) {
        print "$VERSION\n";
        return 0;
    }
    if ($man) {
        pod2usage(-exitval => 0, -verbose => 2);
    }

    @ARGV == 1 or die "No upstream commit given.\n";
    my $upstream = shift @ARGV;
    qx(git rev-parse --verify ${upstream}^{commit});
    $? == 0 or die "Can't resolve given commit.\n";

    if ($num_context_lines < 0) {
        die "invalid number of context lines: $num_context_lines\n";
    }

    if ($strict < 0) {
        die "invalid strictness level: $strict\n";
    } elsif ($strict > 0 && $num_context_lines == 0) {
        die "strict hunk assignment requires context\n";
    }


    my $toplevel = qx(git rev-parse --show-toplevel);
    chomp $toplevel;
    $? == 0 or die "Can't get repo toplevel dir\n";
    chdir $toplevel or die $!;

    if (is_index_dirty()) {
        die "There are staged changes. Clean up the index and try again.\n";
    }

    my $hunks = get_diff_hunks($num_context_lines);
    my $summary_for = get_summary_for_commits($upstream);
    my $alias_for = get_sha_aliases($summary_for);
    my %blame_for = map {$_ => blame($_, $alias_for)} @{$hunks};
    my $hunks_for = get_fixup_hunks_by_sha({
        hunks => $hunks,
        blame_for => \%blame_for,
        summary_for => $summary_for,
        strict => $strict,
    });
    while (my ($sha, $fixup_hunks) = each %{$hunks_for}) {
        commit_fixup($sha, $fixup_hunks);
    }
    return 0;
}

if (!caller()) {
    exit main();
}
1;

__END__