contrib/diff-highlight/DiffHighlight.pm

   1 package DiffHighlight;
   2
   3 use 5.008;
   4 use warnings FATAL => 'all';
   5 use strict;
   6
   7 # Highlight by reversing foreground and background. You could do
   8 # other things like bold or underline if you prefer.
   9 my @OLD_HIGHLIGHT = (
  10         color_config('color.diff-highlight.oldnormal'),
  11         color_config('color.diff-highlight.oldhighlight', "\x1b[7m"),
  12         color_config('color.diff-highlight.oldreset', "\x1b[27m")
  13 );
  14 my @NEW_HIGHLIGHT = (
  15         color_config('color.diff-highlight.newnormal', $OLD_HIGHLIGHT[0]),
  16         color_config('color.diff-highlight.newhighlight', $OLD_HIGHLIGHT[1]),
  17         color_config('color.diff-highlight.newreset', $OLD_HIGHLIGHT[2])
  18 );
  19
  20 my $RESET = "\x1b[m";
  21 my $COLOR = qr/\x1b\[[0-9;]*m/;
  22 my $BORING = qr/$COLOR|\s/;
  23
  24 my @removed;
  25 my @added;
  26 my $in_hunk;
  27 my $graph_indent = 0;
  28
  29 our $line_cb = sub { print @_ };
  30 our $flush_cb = sub { local $| = 1 };
  31
  32 # Count the visible width of a string, excluding any terminal color sequences.
  33 sub visible_width {
  34         local $_ = shift;
  35         my $ret = 0;
  36         while (length) {
  37                 if (s/^$COLOR//) {
  38                         # skip colors
  39                 } elsif (s/^.//) {
  40                         $ret++;
  41                 }
  42         }
  43         return $ret;
  44 }
  45
  46 # Return a substring of $str, omitting $len visible characters from the
  47 # beginning, where terminal color sequences do not count as visible.
  48 sub visible_substr {
  49         my ($str, $len) = @_;
  50         while ($len > 0) {
  51                 if ($str =~ s/^$COLOR//) {
  52                         next
  53                 }
  54                 $str =~ s/^.//;
  55                 $len--;
  56         }
  57         return $str;
  58 }
  59
  60 sub handle_line {
  61         my $orig = shift;
  62         local $_ = $orig;
  63
  64         # match a graph line that begins a commit
  65         if (/^(?:$COLOR?\|$COLOR?[ ])* # zero or more leading "|" with space
  66                  $COLOR?\*$COLOR?[ ]   # a "*" with its trailing space
  67               (?:$COLOR?\|$COLOR?[ ])* # zero or more trailing "|"
  68                                  [ ]*  # trailing whitespace for merges
  69             /x) {
  70                 my $graph_prefix = $&;
  71
  72                 # We must flush before setting graph indent, since the
  73                 # new commit may be indented differently from what we
  74                 # queued.
  75                 flush();
  76                 $graph_indent = visible_width($graph_prefix);
  77
  78         } elsif ($graph_indent) {
  79                 if (length($_) < $graph_indent) {
  80                         $graph_indent = 0;
  81                 } else {
  82                         $_ = visible_substr($_, $graph_indent);
  83                 }
  84         }
  85
  86         if (!$in_hunk) {
  87                 $line_cb->($orig);
  88                 $in_hunk = /^$COLOR*\@\@ /;
  89         }
  90         elsif (/^$COLOR*-/) {
  91                 push @removed, $orig;
  92         }
  93         elsif (/^$COLOR*\+/) {
  94                 push @added, $orig;
  95         }
  96         else {
  97                 flush();
  98                 $line_cb->($orig);
  99                 $in_hunk = /^$COLOR*[\@ ]/;
 100         }
 101
 102         # Most of the time there is enough output to keep things streaming,
 103         # but for something like "git log -Sfoo", you can get one early
 104         # commit and then many seconds of nothing. We want to show
 105         # that one commit as soon as possible.
 106         #
 107         # Since we can receive arbitrary input, there's no optimal
 108         # place to flush. Flushing on a blank line is a heuristic that
 109         # happens to match git-log output.
 110         if (!length) {
 111                 $flush_cb->();
 112         }
 113 }
 114
 115 sub flush {
 116         # Flush any queued hunk (this can happen when there is no trailing
 117         # context in the final diff of the input).
 118         show_hunk(\@removed, \@added);
 119         @removed = ();
 120         @added = ();
 121 }
 122
 123 sub highlight_stdin {
 124         while (<STDIN>) {
 125                 handle_line($_);
 126         }
 127         flush();
 128 }
 129
 130 # Ideally we would feed the default as a human-readable color to
 131 # git-config as the fallback value. But diff-highlight does
 132 # not otherwise depend on git at all, and there are reports
 133 # of it being used in other settings. Let's handle our own
 134 # fallback, which means we will work even if git can't be run.
 135 sub color_config {
 136         my ($key, $default) = @_;
 137         my $s = `git config --get-color $key 2>/dev/null`;
 138         return length($s) ? $s : $default;
 139 }
 140
 141 sub show_hunk {
 142         my ($a, $b) = @_;
 143
 144         # If one side is empty, then there is nothing to compare or highlight.
 145         if (!@$a || !@$b) {
 146                 $line_cb->(@$a, @$b);
 147                 return;
 148         }
 149
 150         # If we have mismatched numbers of lines on each side, we could try to
 151         # be clever and match up similar lines. But for now we are simple and
 152         # stupid, and only handle multi-line hunks that remove and add the same
 153         # number of lines.
 154         if (@$a != @$b) {
 155                 $line_cb->(@$a, @$b);
 156                 return;
 157         }
 158
 159         my @queue;
 160         for (my $i = 0; $i < @$a; $i++) {
 161                 my ($rm, $add) = highlight_pair($a->[$i], $b->[$i]);
 162                 $line_cb->($rm);
 163                 push @queue, $add;
 164         }
 165         $line_cb->(@queue);
 166 }
 167
 168 sub highlight_pair {
 169         my @a = split_line(shift);
 170         my @b = split_line(shift);
 171
 172         # Find common prefix, taking care to skip any ansi
 173         # color codes.
 174         my $seen_plusminus;
 175         my ($pa, $pb) = (0, 0);
 176         while ($pa < @a && $pb < @b) {
 177                 if ($a[$pa] =~ /$COLOR/) {
 178                         $pa++;
 179                 }
 180                 elsif ($b[$pb] =~ /$COLOR/) {
 181                         $pb++;
 182                 }
 183                 elsif ($a[$pa] eq $b[$pb]) {
 184                         $pa++;
 185                         $pb++;
 186                 }
 187                 elsif (!$seen_plusminus && $a[$pa] eq '-' && $b[$pb] eq '+') {
 188                         $seen_plusminus = 1;
 189                         $pa++;
 190                         $pb++;
 191                 }
 192                 else {
 193                         last;
 194                 }
 195         }
 196
 197         # Find common suffix, ignoring colors.
 198         my ($sa, $sb) = ($#a, $#b);
 199         while ($sa >= $pa && $sb >= $pb) {
 200                 if ($a[$sa] =~ /$COLOR/) {
 201                         $sa--;
 202                 }
 203                 elsif ($b[$sb] =~ /$COLOR/) {
 204                         $sb--;
 205                 }
 206                 elsif ($a[$sa] eq $b[$sb]) {
 207                         $sa--;
 208                         $sb--;
 209                 }
 210                 else {
 211                         last;
 212                 }
 213         }
 214
 215         if (is_pair_interesting(\@a, $pa, $sa, \@b, $pb, $sb)) {
 216                 return highlight_line(\@a, $pa, $sa, \@OLD_HIGHLIGHT),
 217                        highlight_line(\@b, $pb, $sb, \@NEW_HIGHLIGHT);
 218         }
 219         else {
 220                 return join('', @a),
 221                        join('', @b);
 222         }
 223 }
 224
 225 # we split either by $COLOR or by character. This has the side effect of
 226 # leaving in graph cruft. It works because the graph cruft does not contain "-"
 227 # or "+"
 228 sub split_line {
 229         local $_ = shift;
 230         return utf8::decode($_) ?
 231                 map { utf8::encode($_); $_ }
 232                         map { /$COLOR/ ? $_ : (split //) }
 233                         split /($COLOR+)/ :
 234                 map { /$COLOR/ ? $_ : (split //) }
 235                 split /($COLOR+)/;
 236 }
 237
 238 sub highlight_line {
 239         my ($line, $prefix, $suffix, $theme) = @_;
 240
 241         my $start = join('', @{$line}[0..($prefix-1)]);
 242         my $mid = join('', @{$line}[$prefix..$suffix]);
 243         my $end = join('', @{$line}[($suffix+1)..$#$line]);
 244
 245         # If we have a "normal" color specified, then take over the whole line.
 246         # Otherwise, we try to just manipulate the highlighted bits.
 247         if (defined $theme->[0]) {
 248                 s/$COLOR//g for ($start, $mid, $end);
 249                 chomp $end;
 250                 return join('',
 251                         $theme->[0], $start, $RESET,
 252                         $theme->[1], $mid, $RESET,
 253                         $theme->[0], $end, $RESET,
 254                         "\n"
 255                 );
 256         } else {
 257                 return join('',
 258                         $start,
 259                         $theme->[1], $mid, $theme->[2],
 260                         $end
 261                 );
 262         }
 263 }
 264
 265 # Pairs are interesting to highlight only if we are going to end up
 266 # highlighting a subset (i.e., not the whole line). Otherwise, the highlighting
 267 # is just useless noise. We can detect this by finding either a matching prefix
 268 # or suffix (disregarding boring bits like whitespace and colorization).
 269 sub is_pair_interesting {
 270         my ($a, $pa, $sa, $b, $pb, $sb) = @_;
 271         my $prefix_a = join('', @$a[0..($pa-1)]);
 272         my $prefix_b = join('', @$b[0..($pb-1)]);
 273         my $suffix_a = join('', @$a[($sa+1)..$#$a]);
 274         my $suffix_b = join('', @$b[($sb+1)..$#$b]);
 275
 276         return visible_substr($prefix_a, $graph_indent) !~ /^$COLOR*-$BORING*$/ ||
 277                visible_substr($prefix_b, $graph_indent) !~ /^$COLOR*\+$BORING*$/ ||
 278                $suffix_a !~ /^$BORING*$/ ||
 279                $suffix_b !~ /^$BORING*$/;
 280 }