use strict;

use Git;

binmode(STDOUT, ":raw");

my $repo = Git->repository();

my $menu_use_color = $repo->get_colorbool('color.interactive');

my ($prompt_color, $header_color, $help_color) =

$menu_use_color ? (

$repo->get_color('color.interactive.prompt', 'bold blue'),

$repo->get_color('color.interactive.header', 'bold'),

$repo->get_color('color.interactive.help', 'red bold'),

) : ();

my $error_color = ();

if ($menu_use_color) {

my $help_color_spec = ($repo->config('color.interactive.help') or

'red bold');

$error_color = $repo->get_color('color.interactive.error',

$help_color_spec);

}

my $diff_use_color = $repo->get_colorbool('color.diff');

my ($fraginfo_color) =

$diff_use_color ? (

$repo->get_color('color.diff.frag', 'cyan'),

) : ();

my ($diff_plain_color) =

$diff_use_color ? (

$repo->get_color('color.diff.plain', ''),

) : ();

my ($diff_old_color) =

$diff_use_color ? (

$repo->get_color('color.diff.old', 'red'),

) : ();

my ($diff_new_color) =

$diff_use_color ? (

$repo->get_color('color.diff.new', 'green'),

) : ();

my $normal_color = $repo->get_color("", "reset");

my $use_readkey = 0;

sub ReadMode;

sub ReadKey;

if ($repo->config_bool("interactive.singlekey")) {

eval {

require Term::ReadKey;

Term::ReadKey->import;

$use_readkey = 1;

};

}

sub colored {

my $color = shift;

my $string = join("", @_);

if (defined $color) {

# Put a color code at the beginning of each line, a reset at the end

# color after newlines that are not at the end of the string

$string =~ s/(\n+)(.)/$1$color$2/g;

# reset before newlines

$string =~ s/(\n+)/$normal_color$1/g;

# codes at beginning and end (if necessary):

$string =~ s/^/$color/;

$string =~ s/$/$normal_color/ unless $string =~ /\n$/;

}

return $string;

}

my $patch_mode;

my $patch_mode_revision;

sub apply_patch;

sub apply_patch_for_checkout_commit;

sub apply_patch_for_stash;

my %patch_modes = (

'stage' => {

DIFF => 'diff-files -p',

APPLY => sub { apply_patch 'apply --cached', @_; },

APPLY_CHECK => 'apply --cached',

VERB => 'Stage',

TARGET => '',

PARTICIPLE => 'staging',

FILTER => 'file-only',

},

'stash' => {

DIFF => 'diff-index -p HEAD',

APPLY => sub { apply_patch 'apply --cached', @_; },

APPLY_CHECK => 'apply --cached',

VERB => 'Stash',

TARGET => '',

PARTICIPLE => 'stashing',

FILTER => undef,

},

'reset_head' => {

DIFF => 'diff-index -p --cached',

APPLY => sub { apply_patch 'apply -R --cached', @_; },

APPLY_CHECK => 'apply -R --cached',

VERB => 'Unstage',

TARGET => '',

PARTICIPLE => 'unstaging',

FILTER => 'index-only',

},

'reset_nothead' => {

DIFF => 'diff-index -R -p --cached',

APPLY => sub { apply_patch 'apply --cached', @_; },

APPLY_CHECK => 'apply --cached',

VERB => 'Apply',

TARGET => ' to index',

PARTICIPLE => 'applying',

FILTER => 'index-only',

},

'checkout_index' => {

DIFF => 'diff-files -p',

APPLY => sub { apply_patch 'apply -R', @_; },

APPLY_CHECK => 'apply -R',

VERB => 'Discard',

TARGET => ' from worktree',

PARTICIPLE => 'discarding',

FILTER => 'file-only',

},

'checkout_head' => {

DIFF => 'diff-index -p',

APPLY => sub { apply_patch_for_checkout_commit '-R', @_ },

APPLY_CHECK => 'apply -R',

VERB => 'Discard',

TARGET => ' from index and worktree',

PARTICIPLE => 'discarding',

FILTER => undef,

},

'checkout_nothead' => {

DIFF => 'diff-index -R -p',

APPLY => sub { apply_patch_for_checkout_commit '', @_ },

APPLY_CHECK => 'apply',

VERB => 'Apply',

TARGET => ' to index and worktree',

PARTICIPLE => 'applying',

FILTER => undef,

},

);

my %patch_mode_flavour = %{$patch_modes{stage}};

sub run_cmd_pipe {

if ($^O eq 'MSWin32' || $^O eq 'msys') {

my @invalid = grep {m/[":*]/} @_;

die "$^O does not support: @invalid\n" if @invalid;

my @args = map { m/ /o ? "\"$_\"": $_ } @_;

return qx{@args};

} else {

my $fh = undef;

open($fh, '-|', @_) or die;

return <$fh>;

}

}

my ($GIT_DIR) = run_cmd_pipe(qw(git rev-parse --git-dir));

if (!defined $GIT_DIR) {

exit(1); # rev-parse would have already said "not a git repo"

}

chomp($GIT_DIR);

my %cquote_map = (

"b" => chr(8),

"t" => chr(9),

"n" => chr(10),

"v" => chr(11),

"f" => chr(12),

"r" => chr(13),

"\\" => "\\",

"\042" => "\042",

);

sub unquote_path {

local ($_) = @_;

my ($retval, $remainder);

if (!/^\042(.*)\042$/) {

return $_;

}

($_, $retval) = ($1, "");

while (/^([^\\]*)\\(.*)$/) {

$remainder = $2;

$retval .= $1;

for ($remainder) {

if (/^([0-3][0-7][0-7])(.*)$/) {

$retval .= chr(oct($1));

$_ = $2;

last;

}

if (/^([\\\042btnvfr])(.*)$/) {

$retval .= $cquote_map{$1};

$_ = $2;

last;

}

# This is malformed -- just return it as-is for now.

return $_[0];

}

$_ = $remainder;

}

$retval .= $_;

return $retval;

}

sub refresh {

my $fh;

open $fh, 'git update-index --refresh |'

or die;

while (<$fh>) {

;# ignore 'needs update'

}

close $fh;

}

sub list_untracked {

map {

chomp $_;

unquote_path($_);

}

run_cmd_pipe(qw(git ls-files --others --exclude-standard --), @ARGV);

}

my $status_fmt = '%12s %12s %s';

my $status_head = sprintf($status_fmt, 'staged', 'unstaged', 'path');

{

my $initial;

sub is_initial_commit {

$initial = system('git rev-parse HEAD -- >/dev/null 2>&1') != 0

unless defined $initial;

return $initial;

}

}

sub get_empty_tree {

return '4b825dc642cb6eb9a060e54bf8d69288fbee4904';

}

sub list_modified {

my ($only) = @_;

my (%data, @return);

my ($add, $del, $adddel, $file);

my @tracked = ();

if (@ARGV) {

@tracked = map {

chomp $_;

unquote_path($_);

} run_cmd_pipe(qw(git ls-files --), @ARGV);

return if (!@tracked);

}

my $reference;

if (defined $patch_mode_revision and $patch_mode_revision ne 'HEAD') {

$reference = $patch_mode_revision;

} elsif (is_initial_commit()) {

$reference = get_empty_tree();

} else {

$reference = 'HEAD';

}

for (run_cmd_pipe(qw(git diff-index --cached

--numstat --summary), $reference,

'--', @tracked)) {

if (($add, $del, $file) =

/^([-\d]+) ([-\d]+) (.*)/) {

my ($change, $bin);

$file = unquote_path($file);

if ($add eq '-' && $del eq '-') {

$change = 'binary';

$bin = 1;

}

else {

$change = "+$add/-$del";

}

$data{$file} = {

INDEX => $change,

BINARY => $bin,

FILE => 'nothing',

}

}

elsif (($adddel, $file) =

/^ (create|delete) mode [0-7]+ (.*)$/) {

$file = unquote_path($file);

$data{$file}{INDEX_ADDDEL} = $adddel;

}

}

for (run_cmd_pipe(qw(git diff-files --numstat --summary --), @tracked)) {

if (($add, $del, $file) =

/^([-\d]+) ([-\d]+) (.*)/) {

$file = unquote_path($file);

if (!exists $data{$file}) {

$data{$file} = +{

INDEX => 'unchanged',

BINARY => 0,

};

}

my ($change, $bin);

if ($add eq '-' && $del eq '-') {

$change = 'binary';

$bin = 1;

}

else {

$change = "+$add/-$del";

}

$data{$file}{FILE} = $change;

if ($bin) {

$data{$file}{BINARY} = 1;

}

}

elsif (($adddel, $file) =

/^ (create|delete) mode [0-7]+ (.*)$/) {

$file = unquote_path($file);

$data{$file}{FILE_ADDDEL} = $adddel;

}

}

for (sort keys %data) {

my $it = $data{$_};

if ($only) {

if ($only eq 'index-only') {

next if ($it->{INDEX} eq 'unchanged');

}

if ($only eq 'file-only') {

next if ($it->{FILE} eq 'nothing');

}

}

push @return, +{

VALUE => $_,

%$it,

};

}

return @return;

}

sub find_unique {

my ($string, @stuff) = @_;

my $found = undef;

for (my $i = 0; $i < @stuff; $i++) {

my $it = $stuff[$i];

my $hit = undef;

if (ref $it) {

if ((ref $it) eq 'ARRAY') {

$it = $it->[0];

}

else {

$it = $it->{VALUE};

}

}

eval {

if ($it =~ /^$string/) {

$hit = 1;

};

};

if (defined $hit && defined $found) {

return undef;

}

if ($hit) {

$found = $i + 1;

}

}

return $found;

}

sub update_trie {

my ($trie, $string) = @_;

foreach (split //, $string) {

$trie = $trie->{$_} ||= {COUNT => 0};

$trie->{COUNT}++;

}

}

sub find_unique_prefixes {

my @stuff = @_;

my @return = ();

# any single prefix exceeding the soft limit is omitted

# if any prefix exceeds the hard limit all are omitted

# 0 indicates no limit

my $soft_limit = 0;

my $hard_limit = 3;

# build a trie modelling all possible options

my %trie;

foreach my $print (@stuff) {

if ((ref $print) eq 'ARRAY') {

$print = $print->[0];

}

elsif ((ref $print) eq 'HASH') {

$print = $print->{VALUE};

}

update_trie(\%trie, $print);

push @return, $print;

}

# use the trie to find the unique prefixes

for (my $i = 0; $i < @return; $i++) {

my $ret = $return[$i];

my @letters = split //, $ret;

my %search = %trie;

my ($prefix, $remainder);

my $j;

for ($j = 0; $j < @letters; $j++) {

my $letter = $letters[$j];

if ($search{$letter}{COUNT} == 1) {

$prefix = substr $ret, 0, $j + 1;

$remainder = substr $ret, $j + 1;

last;

}

else {

my $prefix = substr $ret, 0, $j;

return ()

if ($hard_limit && $j + 1 > $hard_limit);

}

%search = %{$search{$letter}};

}

if (ord($letters[0]) > 127 ||

($soft_limit && $j + 1 > $soft_limit)) {

$prefix = undef;

$remainder = $ret;

}

$return[$i] = [$prefix, $remainder];

}

return @return;

}

sub is_valid_prefix {

my $prefix = shift;

return (defined $prefix) &&

!($prefix =~ /[\s,]/) && # separators

!($prefix =~ /^-/) && # deselection

!($prefix =~ /^\d+/) && # selection

($prefix ne '*') && # "all" wildcard

($prefix ne '?'); # prompt help

}

sub highlight_prefix {

my $prefix = shift;

my $remainder = shift;

if (!defined $prefix) {

return $remainder;

}

if (!is_valid_prefix($prefix)) {

return "$prefix$remainder";

}

if (!$menu_use_color) {

return "[$prefix]$remainder";

}

return "$prompt_color$prefix$normal_color$remainder";

}

sub error_msg {

print STDERR colored $error_color, @_;

}

sub list_and_choose {

my ($opts, @stuff) = @_;

my (@chosen, @return);

my $i;

my @prefixes = find_unique_prefixes(@stuff) unless $opts->{LIST_ONLY};

TOPLOOP:

while (1) {

my $last_lf = 0;

if ($opts->{HEADER}) {

if (!$opts->{LIST_FLAT}) {

print " ";

}

print colored $header_color, "$opts->{HEADER}\n";

}

for ($i = 0; $i < @stuff; $i++) {

my $chosen = $chosen[$i] ? '*' : ' ';

my $print = $stuff[$i];

my $ref = ref $print;

my $highlighted = highlight_prefix(@{$prefixes[$i]})

if @prefixes;

if ($ref eq 'ARRAY') {

$print = $highlighted || $print->[0];

}

elsif ($ref eq 'HASH') {

my $value = $highlighted || $print->{VALUE};

$print = sprintf($status_fmt,

$print->{INDEX},

$print->{FILE},

$value);

}

else {

$print = $highlighted || $print;

}

printf("%s%2d: %s", $chosen, $i+1, $print);

if (($opts->{LIST_FLAT}) &&

(($i + 1) % ($opts->{LIST_FLAT}))) {

print "\t";

$last_lf = 0;

}

else {

print "\n";

$last_lf = 1;

}

}

if (!$last_lf) {

print "\n";

}

return if ($opts->{LIST_ONLY});

print colored $prompt_color, $opts->{PROMPT};

if ($opts->{SINGLETON}) {

print "> ";

}

else {

print ">> ";

}

my $line = <STDIN>;

if (!$line) {

print "\n";

$opts->{ON_EOF}->() if $opts->{ON_EOF};

last;

}

chomp $line;

last if $line eq '';

if ($line eq '?') {

$opts->{SINGLETON} ?

singleton_prompt_help_cmd() :

prompt_help_cmd();

next TOPLOOP;

}

for my $choice (split(/[\s,]+/, $line)) {

my $choose = 1;

my ($bottom, $top);

# Input that begins with '-'; unchoose

if ($choice =~ s/^-//) {

$choose = 0;

}

# A range can be specified like 5-7 or 5-.

if ($choice =~ /^(\d+)-(\d*)$/) {

($bottom, $top) = ($1, length($2) ? $2 : 1 + @stuff);

}

elsif ($choice =~ /^\d+$/) {

$bottom = $top = $choice;

}

elsif ($choice eq '*') {

$bottom = 1;

$top = 1 + @stuff;

}

else {

$bottom = $top = find_unique($choice, @stuff);

if (!defined $bottom) {

error_msg "Huh ($choice)?\n";

next TOPLOOP;

}

}

if ($opts->{SINGLETON} && $bottom != $top) {

error_msg "Huh ($choice)?\n";

next TOPLOOP;

}

for ($i = $bottom-1; $i <= $top-1; $i++) {

next if (@stuff <= $i || $i < 0);

$chosen[$i] = $choose;

}

}

last if ($opts->{IMMEDIATE} || $line eq '*');

}

for ($i = 0; $i < @stuff; $i++) {

if ($chosen[$i]) {

push @return, $stuff[$i];

}

}

return @return;

}

sub singleton_prompt_help_cmd {

print colored $help_color, <<\EOF ;

}

sub prompt_help_cmd {

print colored $help_color, <<\EOF ;

}

sub status_cmd {

list_and_choose({ LIST_ONLY => 1, HEADER => $status_head },

list_modified());

print "\n";

}

sub say_n_paths {

my $did = shift @_;

my $cnt = scalar @_;

print "$did ";

if (1 < $cnt) {

print "$cnt paths\n";

}

else {

print "one path\n";

}

}

sub update_cmd {

my @mods = list_modified('file-only');

return if (!@mods);

my @update = list_and_choose({ PROMPT => 'Update',

HEADER => $status_head, },

@mods);

if (@update) {

system(qw(git update-index --add --remove --),

map { $_->{VALUE} } @update);

say_n_paths('updated', @update);

}

print "\n";

}

sub revert_cmd {

my @update = list_and_choose({ PROMPT => 'Revert',

HEADER => $status_head, },

list_modified());

if (@update) {

if (is_initial_commit()) {

system(qw(git rm --cached),

map { $_->{VALUE} } @update);

}

else {

my @lines = run_cmd_pipe(qw(git ls-tree HEAD --),

map { $_->{VALUE} } @update);

my $fh;

open $fh, '| git update-index --index-info'

or die;

for (@lines) {

print $fh $_;

}

close($fh);

for (@update) {

if ($_->{INDEX_ADDDEL} &&

$_->{INDEX_ADDDEL} eq 'create') {

system(qw(git update-index --force-remove --),

$_->{VALUE});

print "note: $_->{VALUE} is untracked now.\n";

}

}

}

refresh();

say_n_paths('reverted', @update);

}

print "\n";

}

sub add_untracked_cmd {

my @add = list_and_choose({ PROMPT => 'Add untracked' },

list_untracked());

if (@add) {

system(qw(git update-index --add --), @add);

say_n_paths('added', @add);

}

print "\n";

}

sub run_git_apply {

my $cmd = shift;

my $fh;

open $fh, '| git ' . $cmd;

print $fh @_;

return close $fh;

}

sub parse_diff {

my ($path) = @_;

my @diff_cmd = split(" ", $patch_mode_flavour{DIFF});

if (defined $patch_mode_revision) {

push @diff_cmd, $patch_mode_revision;

}

my @diff = run_cmd_pipe("git", @diff_cmd, "--", $path);

my @colored = ();

if ($diff_use_color) {

@colored = run_cmd_pipe("git", @diff_cmd, qw(--color --), $path);

}

my (@hunk) = { TEXT => [], DISPLAY => [], TYPE => 'header' };

for (my $i = 0; $i < @diff; $i++) {

if ($diff[$i] =~ /^@@ /) {

push @hunk, { TEXT => [], DISPLAY => [],

TYPE => 'hunk' };

}

push @{$hunk[-1]{TEXT}}, $diff[$i];

push @{$hunk[-1]{DISPLAY}},

($diff_use_color ? $colored[$i] : $diff[$i]);

}

return @hunk;

}

sub parse_diff_header {

my $src = shift;

my $head = { TEXT => [], DISPLAY => [], TYPE => 'header' };

my $mode = { TEXT => [], DISPLAY => [], TYPE => 'mode' };

my $deletion = { TEXT => [], DISPLAY => [], TYPE => 'deletion' };

for (my $i = 0; $i < @{$src->{TEXT}}; $i++) {

my $dest =

$src->{TEXT}->[$i] =~ /^(old|new) mode (\d+)$/ ? $mode :

$src->{TEXT}->[$i] =~ /^deleted file/ ? $deletion :

$head;

push @{$dest->{TEXT}}, $src->{TEXT}->[$i];

push @{$dest->{DISPLAY}}, $src->{DISPLAY}->[$i];

}

return ($head, $mode, $deletion);

}

sub hunk_splittable {

my ($text) = @_;

my @s = split_hunk($text);

return (1 < @s);

}

sub parse_hunk_header {

my ($line) = @_;

my ($o_ofs, $o_cnt, $n_ofs, $n_cnt) =

$line =~ /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;

$o_cnt = 1 unless defined $o_cnt;

$n_cnt = 1 unless defined $n_cnt;

return ($o_ofs, $o_cnt, $n_ofs, $n_cnt);

}

sub split_hunk {

my ($text, $display) = @_;

my @split = ();

if (!defined $display) {

$display = $text;

}

# If there are context lines in the middle of a hunk,

# it can be split, but we would need to take care of

# overlaps later.

my ($o_ofs, undef, $n_ofs) = parse_hunk_header($text->[0]);

my $hunk_start = 1;

OUTER:

while (1) {

my $next_hunk_start = undef;

my $i = $hunk_start - 1;

my $this = +{

TEXT => [],

DISPLAY => [],

TYPE => 'hunk',

OLD => $o_ofs,

NEW => $n_ofs,

OCNT => 0,

NCNT => 0,

ADDDEL => 0,

POSTCTX => 0,

USE => undef,

};

while (++$i < @$text) {

my $line = $text->[$i];

my $display = $display->[$i];

if ($line =~ /^ /) {

if ($this->{ADDDEL} &&

!defined $next_hunk_start) {

# We have seen leading context and

# adds/dels and then here is another

# context, which is trailing for this

# split hunk and leading for the next

# one.

$next_hunk_start = $i;

}

push @{$this->{TEXT}}, $line;

push @{$this->{DISPLAY}}, $display;

$this->{OCNT}++;

$this->{NCNT}++;

if (defined $next_hunk_start) {

$this->{POSTCTX}++;

}

next;

}

# add/del

if (defined $next_hunk_start) {

# We are done with the current hunk and

# this is the first real change for the

# next split one.

$hunk_start = $next_hunk_start;

$o_ofs = $this->{OLD} + $this->{OCNT};

$n_ofs = $this->{NEW} + $this->{NCNT};

$o_ofs -= $this->{POSTCTX};

$n_ofs -= $this->{POSTCTX};

push @split, $this;

redo OUTER;

}

push @{$this->{TEXT}}, $line;

push @{$this->{DISPLAY}}, $display;

$this->{ADDDEL}++;

if ($line =~ /^-/) {

$this->{OCNT}++;

}

else {

$this->{NCNT}++;

}

}

push @split, $this;

last;

}

for my $hunk (@split) {

$o_ofs = $hunk->{OLD};

$n_ofs = $hunk->{NEW};

my $o_cnt = $hunk->{OCNT};

my $n_cnt = $hunk->{NCNT};

my $head = ("@@ -$o_ofs" .

(($o_cnt != 1) ? ",$o_cnt" : '') .

" +$n_ofs" .

(($n_cnt != 1) ? ",$n_cnt" : '') .

" @@\n");

my $display_head = $head;

unshift @{$hunk->{TEXT}}, $head;

if ($diff_use_color) {

$display_head = colored($fraginfo_color, $head);

}

unshift @{$hunk->{DISPLAY}}, $display_head;

}

return @split;

}

sub find_last_o_ctx {

my ($it) = @_;

my $text = $it->{TEXT};

my ($o_ofs, $o_cnt) = parse_hunk_header($text->[0]);

my $i = @{$text};

my $last_o_ctx = $o_ofs + $o_cnt;

while (0 < --$i) {

my $line = $text->[$i];

if ($line =~ /^ /) {

$last_o_ctx--;

next;

}

last;

}

return $last_o_ctx;

}

sub merge_hunk {

my ($prev, $this) = @_;

my ($o0_ofs, $o0_cnt, $n0_ofs, $n0_cnt) =

parse_hunk_header($prev->{TEXT}[0]);

my ($o1_ofs, $o1_cnt, $n1_ofs, $n1_cnt) =

parse_hunk_header($this->{TEXT}[0]);

my (@line, $i, $ofs, $o_cnt, $n_cnt);

$ofs = $o0_ofs;

$o_cnt = $n_cnt = 0;

for ($i = 1; $i < @{$prev->{TEXT}}; $i++) {

my $line = $prev->{TEXT}[$i];

if ($line =~ /^\+/) {

$n_cnt++;

push @line, $line;

next;

}

last if ($o1_ofs <= $ofs);

$o_cnt++;

$ofs++;

if ($line =~ /^ /) {

$n_cnt++;

}

push @line, $line;

}

for ($i = 1; $i < @{$this->{TEXT}}; $i++) {

my $line = $this->{TEXT}[$i];

if ($line =~ /^\+/) {

$n_cnt++;

push @line, $line;

next;

}

$ofs++;

$o_cnt++;

if ($line =~ /^ /) {

$n_cnt++;

}

push @line, $line;

}

my $head = ("@@ -$o0_ofs" .

(($o_cnt != 1) ? ",$o_cnt" : '') .

" +$n0_ofs" .

(($n_cnt != 1) ? ",$n_cnt" : '') .

" @@\n");

@{$prev->{TEXT}} = ($head, @line);

}

sub coalesce_overlapping_hunks {

my (@in) = @_;

my @out = ();

my ($last_o_ctx, $last_was_dirty);

for (grep { $_->{USE} } @in) {

if ($_->{TYPE} ne 'hunk') {

push @out, $_;

next;

}

my $text = $_->{TEXT};

my ($o_ofs) = parse_hunk_header($text->[0]);

if (defined $last_o_ctx &&

$o_ofs <= $last_o_ctx &&

!$_->{DIRTY} &&

!$last_was_dirty) {

merge_hunk($out[-1], $_);

}

else {

push @out, $_;

}

$last_o_ctx = find_last_o_ctx($out[-1]);

$last_was_dirty = $_->{DIRTY};

}

return @out;

}

sub reassemble_patch {

my $head = shift;

my @patch;

# Include everything in the header except the beginning of the diff.

push @patch, (grep { !/^[-+]{3}/ } @$head);

# Then include any headers from the hunk lines, which must

# come before any actual hunk.

while (@_ && $_[0] !~ /^@/) {

push @patch, shift;

}

# Then begin the diff.

push @patch, grep { /^[-+]{3}/ } @$head;

# And then the actual hunks.

push @patch, @_;

return @patch;

}

sub color_diff {

return map {

colored((/^@/ ? $fraginfo_color :

/^\+/ ? $diff_new_color :

/^-/ ? $diff_old_color :

$diff_plain_color),

$_);

} @_;

}

sub edit_hunk_manually {

my ($oldtext) = @_;

my $hunkfile = $repo->repo_path . "/addp-hunk-edit.diff";

my $fh;

open $fh, '>', $hunkfile

or die "failed to open hunk edit file for writing: " . $!;

print $fh "# Manual hunk edit mode -- see bottom for a quick guide\n";

print $fh @$oldtext;