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