contrib/diff-highlight/DiffHighlight.pm - jrn/git - Git at Google

 package DiffHighlight;

 use 5.008;
 use warnings FATAL => 'all';
 use strict;

 # Highlight by reversing foreground and background. You could do
 # other things like bold or underline if you prefer.
 my @OLD_HIGHLIGHT = (
 	color_config('color.diff-highlight.oldnormal'),
 	color_config('color.diff-highlight.oldhighlight', "\x1b[7m"),
 	color_config('color.diff-highlight.oldreset', "\x1b[27m")
 );
 my @NEW_HIGHLIGHT = (
 	color_config('color.diff-highlight.newnormal', $OLD_HIGHLIGHT[0]),
 	color_config('color.diff-highlight.newhighlight', $OLD_HIGHLIGHT[1]),
 	color_config('color.diff-highlight.newreset', $OLD_HIGHLIGHT[2])
 );

 my $RESET = "\x1b[m";
 my $COLOR = qr/\x1b\[[0-9;]*m/;
 my $BORING = qr/$COLOR|\s/;

 my @removed;
 my @added;
 my $in_hunk;
 my $graph_indent = 0;

 our $line_cb = sub { print @_ };
 our $flush_cb = sub { local $| = 1 };

 # Count the visible width of a string, excluding any terminal color sequences.
 sub visible_width {
 	local $_ = shift;
 	my $ret = 0;
 	while (length) {
 		if (s/^$COLOR//) {
 			# skip colors
 		} elsif (s/^.//) {
 			$ret++;
 		}
 	}
 	return $ret;
 }

 # Return a substring of $str, omitting $len visible characters from the
 # beginning, where terminal color sequences do not count as visible.
 sub visible_substr {
 	my ($str, $len) = @_;
 	while ($len > 0) {
 		if ($str =~ s/^$COLOR//) {
 			next
 		}
 		$str =~ s/^.//;
 		$len--;
 	}
 	return $str;
 }

 sub handle_line {
 	my $orig = shift;
 	local $_ = $orig;

 	# match a graph line that begins a commit
 	if (/^(?:$COLOR?\|$COLOR?[ ])* # zero or more leading "|" with space
 	         $COLOR?\*$COLOR?[ ]   # a "*" with its trailing space
 	      (?:$COLOR?\|$COLOR?[ ])* # zero or more trailing "|"
 	                         [ ]*  # trailing whitespace for merges
 	    /x) {
 	        my $graph_prefix = $&;

 		# We must flush before setting graph indent, since the
 		# new commit may be indented differently from what we
 		# queued.
 		flush();
 		$graph_indent = visible_width($graph_prefix);

 	} elsif ($graph_indent) {
 		if (length($_) < $graph_indent) {
 			$graph_indent = 0;
 		} else {
 			$_ = visible_substr($_, $graph_indent);
 		}
 	}

 	if (!$in_hunk) {
 		$line_cb->($orig);
 		$in_hunk = /^$COLOR*\@\@ /;
 	}
 	elsif (/^$COLOR*-/) {
 		push @removed, $orig;
 	}
 	elsif (/^$COLOR*\+/) {
 		push @added, $orig;
 	}
 	else {
 		flush();
 		$line_cb->($orig);
 		$in_hunk = /^$COLOR*[\@ ]/;
 	}

 	# Most of the time there is enough output to keep things streaming,
 	# but for something like "git log -Sfoo", you can get one early
 	# commit and then many seconds of nothing. We want to show
 	# that one commit as soon as possible.
 	#
 	# Since we can receive arbitrary input, there's no optimal
 	# place to flush. Flushing on a blank line is a heuristic that
 	# happens to match git-log output.
 	if (!length) {
 		$flush_cb->();
 	}
 }

 sub flush {
 	# Flush any queued hunk (this can happen when there is no trailing
 	# context in the final diff of the input).
 	show_hunk(\@removed, \@added);
 	@removed = ();
 	@added = ();
 }

 sub highlight_stdin {
 	while (<STDIN>) {
 		handle_line($_);
 	}
 	flush();
 }

 # Ideally we would feed the default as a human-readable color to
 # git-config as the fallback value. But diff-highlight does
 # not otherwise depend on git at all, and there are reports
 # of it being used in other settings. Let's handle our own
 # fallback, which means we will work even if git can't be run.
 sub color_config {
 	my ($key, $default) = @_;
 	my $s = `git config --get-color $key 2>/dev/null`;
 	return length($s) ? $s : $default;
 }

 sub show_hunk {
 	my ($a, $b) = @_;

 	# If one side is empty, then there is nothing to compare or highlight.
 	if (!@$a || !@$b) {
 		$line_cb->(@$a, @$b);
 		return;
 	}

 	# If we have mismatched numbers of lines on each side, we could try to
 	# be clever and match up similar lines. But for now we are simple and
 	# stupid, and only handle multi-line hunks that remove and add the same
 	# number of lines.
 	if (@$a != @$b) {
 		$line_cb->(@$a, @$b);
 		return;
 	}

 	my @queue;
 	for (my $i = 0; $i < @$a; $i++) {
 		my ($rm, $add) = highlight_pair($a->[$i], $b->[$i]);
 		$line_cb->($rm);
 		push @queue, $add;
 	}
 	$line_cb->(@queue);
 }

 sub highlight_pair {
 	my @a = split_line(shift);
 	my @b = split_line(shift);

 	# Find common prefix, taking care to skip any ansi
 	# color codes.
 	my $seen_plusminus;
 	my ($pa, $pb) = (0, 0);
 	while ($pa < @a && $pb < @b) {
 		if ($a[$pa] =~ /$COLOR/) {
 			$pa++;
 		}
 		elsif ($b[$pb] =~ /$COLOR/) {
 			$pb++;
 		}
 		elsif ($a[$pa] eq $b[$pb]) {
 			$pa++;
 			$pb++;
 		}
 		elsif (!$seen_plusminus && $a[$pa] eq '-' && $b[$pb] eq '+') {
 			$seen_plusminus = 1;
 			$pa++;
 			$pb++;
 		}
 		else {
 			last;
 		}
 	}

 	# Find common suffix, ignoring colors.
 	my ($sa, $sb) = ($#a, $#b);
 	while ($sa >= $pa && $sb >= $pb) {
 		if ($a[$sa] =~ /$COLOR/) {
 			$sa--;
 		}
 		elsif ($b[$sb] =~ /$COLOR/) {
 			$sb--;
 		}
 		elsif ($a[$sa] eq $b[$sb]) {
 			$sa--;
 			$sb--;
 		}
 		else {
 			last;
 		}
 	}

 	if (is_pair_interesting(\@a, $pa, $sa, \@b, $pb, $sb)) {
 		return highlight_line(\@a, $pa, $sa, \@OLD_HIGHLIGHT),
 		       highlight_line(\@b, $pb, $sb, \@NEW_HIGHLIGHT);
 	}
 	else {
 		return join('', @a),
 		       join('', @b);
 	}
 }

 # we split either by $COLOR or by character. This has the side effect of
 # leaving in graph cruft. It works because the graph cruft does not contain "-"
 # or "+"
 sub split_line {
 	local $_ = shift;
 	return utf8::decode($_) ?
 		map { utf8::encode($_); $_ }
 			map { /$COLOR/ ? $_ : (split //) }
 			split /($COLOR+)/ :
 		map { /$COLOR/ ? $_ : (split //) }
 		split /($COLOR+)/;
 }

 sub highlight_line {
 	my ($line, $prefix, $suffix, $theme) = @_;

 	my $start = join('', @{$line}[0..($prefix-1)]);
 	my $mid = join('', @{$line}[$prefix..$suffix]);
 	my $end = join('', @{$line}[($suffix+1)..$#$line]);

 	# If we have a "normal" color specified, then take over the whole line.
 	# Otherwise, we try to just manipulate the highlighted bits.
 	if (defined $theme->[0]) {
 		s/$COLOR//g for ($start, $mid, $end);
 		chomp $end;
 		return join('',
 			$theme->[0], $start, $RESET,
 			$theme->[1], $mid, $RESET,
 			$theme->[0], $end, $RESET,
 			"\n"
 		);
 	} else {
 		return join('',
 			$start,
 			$theme->[1], $mid, $theme->[2],
 			$end
 		);
 	}
 }

 # Pairs are interesting to highlight only if we are going to end up
 # highlighting a subset (i.e., not the whole line). Otherwise, the highlighting
 # is just useless noise. We can detect this by finding either a matching prefix
 # or suffix (disregarding boring bits like whitespace and colorization).
 sub is_pair_interesting {
 	my ($a, $pa, $sa, $b, $pb, $sb) = @_;
 	my $prefix_a = join('', @$a[0..($pa-1)]);
 	my $prefix_b = join('', @$b[0..($pb-1)]);
 	my $suffix_a = join('', @$a[($sa+1)..$#$a]);
 	my $suffix_b = join('', @$b[($sb+1)..$#$b]);

 	return visible_substr($prefix_a, $graph_indent) !~ /^$COLOR*-$BORING*$/ ||
 	       visible_substr($prefix_b, $graph_indent) !~ /^$COLOR*\+$BORING*$/ ||
 	       $suffix_a !~ /^$BORING*$/ ||
 	       $suffix_b !~ /^$BORING*$/;
 }
	package DiffHighlight;

	use 5.008;
	use warnings FATAL => 'all';
	use strict;

	# Highlight by reversing foreground and background. You could do
	# other things like bold or underline if you prefer.
	my @OLD_HIGHLIGHT = (
	color_config('color.diff-highlight.oldnormal'),
	color_config('color.diff-highlight.oldhighlight', "\x1b[7m"),
	color_config('color.diff-highlight.oldreset', "\x1b[27m")
	);
	my @NEW_HIGHLIGHT = (
	color_config('color.diff-highlight.newnormal', $OLD_HIGHLIGHT[0]),
	color_config('color.diff-highlight.newhighlight', $OLD_HIGHLIGHT[1]),
	color_config('color.diff-highlight.newreset', $OLD_HIGHLIGHT[2])
	);

	my $RESET = "\x1b[m";
	my $COLOR = qr/\x1b\[[0-9;]*m/;
	my $BORING = qr/$COLOR\|\s/;

	my @removed;
	my @added;
	my $in_hunk;
	my $graph_indent = 0;

	our $line_cb = sub { print @_ };
	our $flush_cb = sub { local $\| = 1 };

	# Count the visible width of a string, excluding any terminal color sequences.
	sub visible_width {
	local $_ = shift;
	my $ret = 0;
	while (length) {
	if (s/^$COLOR//) {
	# skip colors
	} elsif (s/^.//) {
	$ret++;
	}
	}
	return $ret;
	}

	# Return a substring of $str, omitting $len visible characters from the
	# beginning, where terminal color sequences do not count as visible.
	sub visible_substr {
	my ($str, $len) = @_;
	while ($len > 0) {
	if ($str =~ s/^$COLOR//) {
	next
	}
	$str =~ s/^.//;
	$len--;
	}
	return $str;
	}

	sub handle_line {
	my $orig = shift;
	local $_ = $orig;

	# match a graph line that begins a commit
	if (/^(?:$COLOR?\\|$COLOR?[ ])* # zero or more leading "\|" with space
	$COLOR?\$COLOR?[ ] # a "" with its trailing space
	(?:$COLOR?\\|$COLOR?[ ])* # zero or more trailing "\|"
	[ ]* # trailing whitespace for merges
	/x) {
	my $graph_prefix = $&;

	# We must flush before setting graph indent, since the
	# new commit may be indented differently from what we
	# queued.
	flush();
	$graph_indent = visible_width($graph_prefix);

	} elsif ($graph_indent) {
	if (length($_) < $graph_indent) {
	$graph_indent = 0;
	} else {
	$_ = visible_substr($_, $graph_indent);
	}
	}

	if (!$in_hunk) {
	$line_cb->($orig);
	$in_hunk = /^$COLOR*\@\@ /;
	}
	elsif (/^$COLOR*-/) {
	push @removed, $orig;
	}
	elsif (/^$COLOR*\+/) {
	push @added, $orig;
	}
	else {
	flush();
	$line_cb->($orig);
	$in_hunk = /^$COLOR*[\@ ]/;
	}

	# Most of the time there is enough output to keep things streaming,
	# but for something like "git log -Sfoo", you can get one early
	# commit and then many seconds of nothing. We want to show
	# that one commit as soon as possible.
	#
	# Since we can receive arbitrary input, there's no optimal
	# place to flush. Flushing on a blank line is a heuristic that
	# happens to match git-log output.
	if (!length) {
	$flush_cb->();
	}
	}

	sub flush {
	# Flush any queued hunk (this can happen when there is no trailing
	# context in the final diff of the input).
	show_hunk(\@removed, \@added);
	@removed = ();
	@added = ();
	}

	sub highlight_stdin {
	while (<STDIN>) {
	handle_line($_);
	}
	flush();
	}

	# Ideally we would feed the default as a human-readable color to
	# git-config as the fallback value. But diff-highlight does
	# not otherwise depend on git at all, and there are reports
	# of it being used in other settings. Let's handle our own
	# fallback, which means we will work even if git can't be run.
	sub color_config {
	my ($key, $default) = @_;
	my $s = `git config --get-color $key 2>/dev/null`;
	return length($s) ? $s : $default;
	}

	sub show_hunk {
	my ($a, $b) = @_;

	# If one side is empty, then there is nothing to compare or highlight.
	if (!@$a \|\| !@$b) {
	$line_cb->(@$a, @$b);
	return;
	}

	# If we have mismatched numbers of lines on each side, we could try to
	# be clever and match up similar lines. But for now we are simple and
	# stupid, and only handle multi-line hunks that remove and add the same
	# number of lines.
	if (@$a != @$b) {
	$line_cb->(@$a, @$b);
	return;
	}

	my @queue;
	for (my $i = 0; $i < @$a; $i++) {
	my ($rm, $add) = highlight_pair($a->[$i], $b->[$i]);
	$line_cb->($rm);
	push @queue, $add;
	}
	$line_cb->(@queue);
	}

	sub highlight_pair {
	my @a = split_line(shift);
	my @b = split_line(shift);

	# Find common prefix, taking care to skip any ansi
	# color codes.
	my $seen_plusminus;
	my ($pa, $pb) = (0, 0);
	while ($pa < @a && $pb < @b) {
	if ($a[$pa] =~ /$COLOR/) {
	$pa++;
	}
	elsif ($b[$pb] =~ /$COLOR/) {
	$pb++;
	}
	elsif ($a[$pa] eq $b[$pb]) {
	$pa++;
	$pb++;
	}
	elsif (!$seen_plusminus && $a[$pa] eq '-' && $b[$pb] eq '+') {
	$seen_plusminus = 1;
	$pa++;
	$pb++;
	}
	else {
	last;
	}
	}

	# Find common suffix, ignoring colors.
	my ($sa, $sb) = ($#a, $#b);
	while ($sa >= $pa && $sb >= $pb) {
	if ($a[$sa] =~ /$COLOR/) {
	$sa--;
	}
	elsif ($b[$sb] =~ /$COLOR/) {
	$sb--;
	}
	elsif ($a[$sa] eq $b[$sb]) {
	$sa--;
	$sb--;
	}
	else {
	last;
	}
	}

	if (is_pair_interesting(\@a, $pa, $sa, \@b, $pb, $sb)) {
	return highlight_line(\@a, $pa, $sa, \@OLD_HIGHLIGHT),
	highlight_line(\@b, $pb, $sb, \@NEW_HIGHLIGHT);
	}
	else {
	return join('', @a),
	join('', @b);
	}
	}

	# we split either by $COLOR or by character. This has the side effect of
	# leaving in graph cruft. It works because the graph cruft does not contain "-"
	# or "+"
	sub split_line {
	local $_ = shift;
	return utf8::decode($_) ?
	map { utf8::encode($_); $_ }
	map { /$COLOR/ ? $_ : (split //) }
	split /($COLOR+)/ :
	map { /$COLOR/ ? $_ : (split //) }
	split /($COLOR+)/;
	}

	sub highlight_line {
	my ($line, $prefix, $suffix, $theme) = @_;

	my $start = join('', @{$line}[0..($prefix-1)]);
	my $mid = join('', @{$line}[$prefix..$suffix]);
	my $end = join('', @{$line}[($suffix+1)..$#$line]);

	# If we have a "normal" color specified, then take over the whole line.
	# Otherwise, we try to just manipulate the highlighted bits.
	if (defined $theme->[0]) {
	s/$COLOR//g for ($start, $mid, $end);
	chomp $end;
	return join('',
	$theme->[0], $start, $RESET,
	$theme->[1], $mid, $RESET,
	$theme->[0], $end, $RESET,
	"\n"
	);
	} else {
	return join('',
	$start,
	$theme->[1], $mid, $theme->[2],
	$end
	);
	}
	}

	# Pairs are interesting to highlight only if we are going to end up
	# highlighting a subset (i.e., not the whole line). Otherwise, the highlighting
	# is just useless noise. We can detect this by finding either a matching prefix
	# or suffix (disregarding boring bits like whitespace and colorization).
	sub is_pair_interesting {
	my ($a, $pa, $sa, $b, $pb, $sb) = @_;
	my $prefix_a = join('', @$a[0..($pa-1)]);
	my $prefix_b = join('', @$b[0..($pb-1)]);
	my $suffix_a = join('', @$a[($sa+1)..$#$a]);
	my $suffix_b = join('', @$b[($sb+1)..$#$b]);

	return visible_substr($prefix_a, $graph_indent) !~ /^$COLOR-$BORING$/ \|\|
	visible_substr($prefix_b, $graph_indent) !~ /^$COLOR\+$BORING$/ \|\|
	$suffix_a !~ /^$BORING*$/ \|\|
	$suffix_b !~ /^$BORING*$/;
	}