6 use Git
qw(unquote_path);
9 binmode(STDOUT
, ":raw");
11 my $repo = Git
->repository();
13 my $menu_use_color = $repo->get_colorbool('color.interactive');
14 my ($prompt_color, $header_color, $help_color) =
16 $repo->get_color('color.interactive.prompt', 'bold blue'),
17 $repo->get_color('color.interactive.header', 'bold'),
18 $repo->get_color('color.interactive.help', 'red bold'),
21 if ($menu_use_color) {
22 my $help_color_spec = ($repo->config('color.interactive.help') or
24 $error_color = $repo->get_color('color.interactive.error',
28 my $diff_use_color = $repo->get_colorbool('color.diff');
29 my ($fraginfo_color) =
31 $repo->get_color('color.diff.frag', 'cyan'),
33 my ($diff_plain_color) =
35 $repo->get_color('color.diff.plain', ''),
37 my ($diff_old_color) =
39 $repo->get_color('color.diff.old', 'red'),
41 my ($diff_new_color) =
43 $repo->get_color('color.diff.new', 'green'),
46 my $normal_color = $repo->get_color("", "reset");
48 my $diff_algorithm = $repo->config('diff.algorithm');
49 my $diff_filter = $repo->config('interactive.difffilter');
57 if ($repo->config_bool("interactive.singlekey")) {
59 require Term
::ReadKey
;
60 Term
::ReadKey
->import;
64 print STDERR
"missing Term::ReadKey, disabling interactive.singlekey\n";
68 my $termcap = Term
::Cap
->Tgetent;
69 foreach (values %$termcap) {
70 $term_escapes{$_} = 1 if /^\e/;
78 my $string = join("", @_);
81 # Put a color code at the beginning of each line, a reset at the end
82 # color after newlines that are not at the end of the string
83 $string =~ s/(\n+)(.)/$1$color$2/g;
84 # reset before newlines
85 $string =~ s/(\n+)/$normal_color$1/g;
86 # codes at beginning and end (if necessary):
87 $string =~ s/^/$color/;
88 $string =~ s/$/$normal_color/ unless $string =~ /\n$/;
93 # command line options
96 my $patch_mode_revision;
99 sub apply_patch_for_checkout_commit
;
100 sub apply_patch_for_stash
;
104 DIFF
=> 'diff-files -p',
105 APPLY
=> sub { apply_patch
'apply --cached', @_; },
106 APPLY_CHECK
=> 'apply --cached',
107 FILTER
=> 'file-only',
111 DIFF
=> 'diff-index -p HEAD',
112 APPLY
=> sub { apply_patch
'apply --cached', @_; },
113 APPLY_CHECK
=> 'apply --cached',
118 DIFF
=> 'diff-index -p --cached',
119 APPLY
=> sub { apply_patch
'apply -R --cached', @_; },
120 APPLY_CHECK
=> 'apply -R --cached',
121 FILTER
=> 'index-only',
125 DIFF
=> 'diff-index -R -p --cached',
126 APPLY
=> sub { apply_patch
'apply --cached', @_; },
127 APPLY_CHECK
=> 'apply --cached',
128 FILTER
=> 'index-only',
131 'checkout_index' => {
132 DIFF
=> 'diff-files -p',
133 APPLY
=> sub { apply_patch
'apply -R', @_; },
134 APPLY_CHECK
=> 'apply -R',
135 FILTER
=> 'file-only',
139 DIFF
=> 'diff-index -p',
140 APPLY
=> sub { apply_patch_for_checkout_commit
'-R', @_ },
141 APPLY_CHECK
=> 'apply -R',
145 'checkout_nothead' => {
146 DIFF
=> 'diff-index -R -p',
147 APPLY
=> sub { apply_patch_for_checkout_commit
'', @_ },
148 APPLY_CHECK
=> 'apply',
154 $patch_mode = 'stage';
155 my %patch_mode_flavour = %{$patch_modes{$patch_mode}};
158 if ($^O
eq 'MSWin32') {
159 my @invalid = grep {m/[":*]/} @_;
160 die "$^O does not support: @invalid\n" if @invalid;
161 my @args = map { m/ /o ?
"\"$_\"": $_ } @_;
165 open($fh, '-|', @_) or die;
170 my ($GIT_DIR) = run_cmd_pipe
(qw(git rev-parse --git-dir));
172 if (!defined $GIT_DIR) {
173 exit(1); # rev-parse would have already said "not a git repo"
179 open $fh, 'git update-index --refresh |'
182 ;# ignore 'needs update'
192 run_cmd_pipe
(qw(git ls-files --others --exclude-standard --), @ARGV);
195 # TRANSLATORS: you can adjust this to align "git add -i" status menu
196 my $status_fmt = __
('%12s %12s %s');
197 my $status_head = sprintf($status_fmt, __
('staged'), __
('unstaged'), __
('path'));
201 sub is_initial_commit
{
202 $initial = system('git rev-parse HEAD -- >/dev/null 2>&1') != 0
203 unless defined $initial;
209 return '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
212 sub get_diff_reference
{
214 if (defined $ref and $ref ne 'HEAD') {
216 } elsif (is_initial_commit
()) {
217 return get_empty_tree
();
223 # Returns list of hashes, contents of each of which are:
225 # BINARY: is a binary path
226 # INDEX: is index different from HEAD?
227 # FILE: is file different from index?
228 # INDEX_ADDDEL: is it add/delete between HEAD and index?
229 # FILE_ADDDEL: is it add/delete between index and file?
230 # UNMERGED: is the path unmerged
235 my ($add, $del, $adddel, $file);
237 my $reference = get_diff_reference
($patch_mode_revision);
238 for (run_cmd_pipe
(qw(git diff-index --cached
239 --numstat --summary), $reference,
241 if (($add, $del, $file) =
242 /^([-\d]+) ([-\d]+) (.*)/) {
244 $file = unquote_path
($file);
245 if ($add eq '-' && $del eq '-') {
246 $change = __
('binary');
250 $change = "+$add/-$del";
255 FILE
=> __
('nothing'),
258 elsif (($adddel, $file) =
259 /^ (create|delete) mode [0-7]+ (.*)$/) {
260 $file = unquote_path
($file);
261 $data{$file}{INDEX_ADDDEL
} = $adddel;
265 for (run_cmd_pipe
(qw(git diff-files --numstat --summary --raw --), @ARGV)) {
266 if (($add, $del, $file) =
267 /^([-\d]+) ([-\d]+) (.*)/) {
268 $file = unquote_path
($file);
270 if ($add eq '-' && $del eq '-') {
271 $change = __
('binary');
275 $change = "+$add/-$del";
277 $data{$file}{FILE
} = $change;
279 $data{$file}{BINARY
} = 1;
282 elsif (($adddel, $file) =
283 /^ (create|delete) mode [0-7]+ (.*)$/) {
284 $file = unquote_path
($file);
285 $data{$file}{FILE_ADDDEL
} = $adddel;
287 elsif (/^:[0-7]+ [0-7]+ [0-9a-f]+ [0-9a-f]+ (.) (.*)$/) {
288 $file = unquote_path
($2);
289 if (!exists $data{$file}) {
291 INDEX
=> __
('unchanged'),
296 $data{$file}{UNMERGED
} = 1;
301 for (sort keys %data) {
305 if ($only eq 'index-only') {
306 next if ($it->{INDEX
} eq __
('unchanged'));
308 if ($only eq 'file-only') {
309 next if ($it->{FILE
} eq __
('nothing'));
321 my ($string, @stuff) = @_;
323 for (my $i = 0; $i < @stuff; $i++) {
327 if ((ref $it) eq 'ARRAY') {
335 if ($it =~ /^$string/) {
339 if (defined $hit && defined $found) {
349 # inserts string into trie and updates count for each character
351 my ($trie, $string) = @_;
352 foreach (split //, $string) {
353 $trie = $trie->{$_} ||= {COUNT
=> 0};
358 # returns an array of tuples (prefix, remainder)
359 sub find_unique_prefixes
{
363 # any single prefix exceeding the soft limit is omitted
364 # if any prefix exceeds the hard limit all are omitted
365 # 0 indicates no limit
369 # build a trie modelling all possible options
371 foreach my $print (@stuff) {
372 if ((ref $print) eq 'ARRAY') {
373 $print = $print->[0];
375 elsif ((ref $print) eq 'HASH') {
376 $print = $print->{VALUE
};
378 update_trie
(\
%trie, $print);
379 push @return, $print;
382 # use the trie to find the unique prefixes
383 for (my $i = 0; $i < @return; $i++) {
384 my $ret = $return[$i];
385 my @letters = split //, $ret;
387 my ($prefix, $remainder);
389 for ($j = 0; $j < @letters; $j++) {
390 my $letter = $letters[$j];
391 if ($search{$letter}{COUNT
} == 1) {
392 $prefix = substr $ret, 0, $j + 1;
393 $remainder = substr $ret, $j + 1;
397 my $prefix = substr $ret, 0, $j;
399 if ($hard_limit && $j + 1 > $hard_limit);
401 %search = %{$search{$letter}};
403 if (ord($letters[0]) > 127 ||
404 ($soft_limit && $j + 1 > $soft_limit)) {
408 $return[$i] = [$prefix, $remainder];
413 # filters out prefixes which have special meaning to list_and_choose()
414 sub is_valid_prefix
{
416 return (defined $prefix) &&
417 !($prefix =~ /[\s,]/) && # separators
418 !($prefix =~ /^-/) && # deselection
419 !($prefix =~ /^\d+/) && # selection
420 ($prefix ne '*') && # "all" wildcard
421 ($prefix ne '?'); # prompt help
424 # given a prefix/remainder tuple return a string with the prefix highlighted
425 # for now use square brackets; later might use ANSI colors (underline, bold)
426 sub highlight_prefix
{
428 my $remainder = shift;
430 if (!defined $prefix) {
434 if (!is_valid_prefix
($prefix)) {
435 return "$prefix$remainder";
438 if (!$menu_use_color) {
439 return "[$prefix]$remainder";
442 return "$prompt_color$prefix$normal_color$remainder";
446 print STDERR colored
$error_color, @_;
449 sub list_and_choose
{
450 my ($opts, @stuff) = @_;
451 my (@chosen, @return);
456 my @prefixes = find_unique_prefixes
(@stuff) unless $opts->{LIST_ONLY
};
462 if ($opts->{HEADER
}) {
463 if (!$opts->{LIST_FLAT
}) {
466 print colored
$header_color, "$opts->{HEADER}\n";
468 for ($i = 0; $i < @stuff; $i++) {
469 my $chosen = $chosen[$i] ?
'*' : ' ';
470 my $print = $stuff[$i];
471 my $ref = ref $print;
472 my $highlighted = highlight_prefix
(@
{$prefixes[$i]})
474 if ($ref eq 'ARRAY') {
475 $print = $highlighted || $print->[0];
477 elsif ($ref eq 'HASH') {
478 my $value = $highlighted || $print->{VALUE
};
479 $print = sprintf($status_fmt,
485 $print = $highlighted || $print;
487 printf("%s%2d: %s", $chosen, $i+1, $print);
488 if (($opts->{LIST_FLAT
}) &&
489 (($i + 1) % ($opts->{LIST_FLAT
}))) {
502 return if ($opts->{LIST_ONLY
});
504 print colored
$prompt_color, $opts->{PROMPT
};
505 if ($opts->{SINGLETON
}) {
514 $opts->{ON_EOF
}->() if $opts->{ON_EOF
};
521 singleton_prompt_help_cmd
() :
525 for my $choice (split(/[\s,]+/, $line)) {
529 # Input that begins with '-'; unchoose
530 if ($choice =~ s/^-//) {
533 # A range can be specified like 5-7 or 5-.
534 if ($choice =~ /^(\d+)-(\d*)$/) {
535 ($bottom, $top) = ($1, length($2) ?
$2 : 1 + @stuff);
537 elsif ($choice =~ /^\d+$/) {
538 $bottom = $top = $choice;
540 elsif ($choice eq '*') {
545 $bottom = $top = find_unique
($choice, @stuff);
546 if (!defined $bottom) {
547 error_msg
sprintf(__
("Huh (%s)?\n"), $choice);
551 if ($opts->{SINGLETON
} && $bottom != $top) {
552 error_msg
sprintf(__
("Huh (%s)?\n"), $choice);
555 for ($i = $bottom-1; $i <= $top-1; $i++) {
556 next if (@stuff <= $i || $i < 0);
557 $chosen[$i] = $choose;
560 last if ($opts->{IMMEDIATE
} || $line eq '*');
562 for ($i = 0; $i < @stuff; $i++) {
564 push @return, $stuff[$i];
570 sub singleton_prompt_help_cmd
{
571 print colored
$help_color, __
<<'EOF' ;
573 1 - select a numbered item
574 foo - select item based on unique prefix
575 - (empty) select nothing
579 sub prompt_help_cmd
{
580 print colored
$help_color, __
<<'EOF' ;
582 1 - select a single item
583 3-5 - select a range of items
584 2-3,6-9 - select multiple ranges
585 foo - select item based on unique prefix
586 -... - unselect specified items
588 - (empty) finish selecting
593 list_and_choose
({ LIST_ONLY
=> 1, HEADER
=> $status_head },
601 if ($did eq 'added') {
602 printf(__n
("added %d path\n", "added %d paths\n",
604 } elsif ($did eq 'updated') {
605 printf(__n
("updated %d path\n", "updated %d paths\n",
607 } elsif ($did eq 'reverted') {
608 printf(__n
("reverted %d path\n", "reverted %d paths\n",
611 printf(__n
("touched %d path\n", "touched %d paths\n",
617 my @mods = list_modified
('file-only');
620 my @update = list_and_choose
({ PROMPT
=> __
('Update'),
621 HEADER
=> $status_head, },
624 system(qw(git update-index --add --remove --),
625 map { $_->{VALUE
} } @update);
626 say_n_paths
('updated', @update);
632 my @update = list_and_choose
({ PROMPT
=> __
('Revert'),
633 HEADER
=> $status_head, },
636 if (is_initial_commit
()) {
637 system(qw(git rm --cached),
638 map { $_->{VALUE
} } @update);
641 my @lines = run_cmd_pipe
(qw(git ls-tree HEAD --),
642 map { $_->{VALUE
} } @update);
644 open $fh, '| git update-index --index-info'
651 if ($_->{INDEX_ADDDEL
} &&
652 $_->{INDEX_ADDDEL
} eq 'create') {
653 system(qw(git update-index --force-remove --),
655 printf(__
("note: %s is untracked now.\n"), $_->{VALUE
});
660 say_n_paths
('reverted', @update);
665 sub add_untracked_cmd
{
666 my @add = list_and_choose
({ PROMPT
=> __
('Add untracked') },
669 system(qw(git update-index --add --), @add);
670 say_n_paths
('added', @add);
672 print __
("No untracked files.\n");
680 open $fh, '| git ' . $cmd . " --recount --allow-overlap";
687 my @diff_cmd = split(" ", $patch_mode_flavour{DIFF
});
688 if (defined $diff_algorithm) {
689 splice @diff_cmd, 1, 0, "--diff-algorithm=${diff_algorithm}";
691 if (defined $patch_mode_revision) {
692 push @diff_cmd, get_diff_reference
($patch_mode_revision);
694 my @diff = run_cmd_pipe
("git", @diff_cmd, "--", $path);
696 if ($diff_use_color) {
697 my @display_cmd = ("git", @diff_cmd, qw(--color --), $path);
698 if (defined $diff_filter) {
699 # quotemeta is overkill, but sufficient for shell-quoting
700 my $diff = join(' ', map { quotemeta } @display_cmd);
701 @display_cmd = ("$diff | $diff_filter");
704 @colored = run_cmd_pipe
(@display_cmd);
706 my (@hunk) = { TEXT
=> [], DISPLAY
=> [], TYPE
=> 'header' };
708 for (my $i = 0; $i < @diff; $i++) {
709 if ($diff[$i] =~ /^@@ /) {
710 push @hunk, { TEXT
=> [], DISPLAY
=> [],
713 push @
{$hunk[-1]{TEXT
}}, $diff[$i];
714 push @
{$hunk[-1]{DISPLAY
}},
715 (@colored ?
$colored[$i] : $diff[$i]);
720 sub parse_diff_header
{
723 my $head = { TEXT
=> [], DISPLAY
=> [], TYPE
=> 'header' };
724 my $mode = { TEXT
=> [], DISPLAY
=> [], TYPE
=> 'mode' };
725 my $deletion = { TEXT
=> [], DISPLAY
=> [], TYPE
=> 'deletion' };
727 for (my $i = 0; $i < @
{$src->{TEXT
}}; $i++) {
729 $src->{TEXT
}->[$i] =~ /^(old|new) mode (\d+)$/ ?
$mode :
730 $src->{TEXT
}->[$i] =~ /^deleted file/ ?
$deletion :
732 push @
{$dest->{TEXT
}}, $src->{TEXT
}->[$i];
733 push @
{$dest->{DISPLAY
}}, $src->{DISPLAY
}->[$i];
735 return ($head, $mode, $deletion);
738 sub hunk_splittable
{
741 my @s = split_hunk
($text);
745 sub parse_hunk_header
{
747 my ($o_ofs, $o_cnt, $n_ofs, $n_cnt) =
748 $line =~ /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
749 $o_cnt = 1 unless defined $o_cnt;
750 $n_cnt = 1 unless defined $n_cnt;
751 return ($o_ofs, $o_cnt, $n_ofs, $n_cnt);
754 sub format_hunk_header
{
755 my ($o_ofs, $o_cnt, $n_ofs, $n_cnt) = @_;
756 return ("@@ -$o_ofs" .
757 (($o_cnt != 1) ?
",$o_cnt" : '') .
759 (($n_cnt != 1) ?
",$n_cnt" : '') .
764 my ($text, $display) = @_;
766 if (!defined $display) {
769 # If there are context lines in the middle of a hunk,
770 # it can be split, but we would need to take care of
773 my ($o_ofs, undef, $n_ofs) = parse_hunk_header
($text->[0]);
778 my $next_hunk_start = undef;
779 my $i = $hunk_start - 1;
793 while (++$i < @
$text) {
794 my $line = $text->[$i];
795 my $display = $display->[$i];
797 if ($this->{ADDDEL
} &&
798 !defined $next_hunk_start) {
799 # We have seen leading context and
800 # adds/dels and then here is another
801 # context, which is trailing for this
802 # split hunk and leading for the next
804 $next_hunk_start = $i;
806 push @
{$this->{TEXT
}}, $line;
807 push @
{$this->{DISPLAY
}}, $display;
810 if (defined $next_hunk_start) {
817 if (defined $next_hunk_start) {
818 # We are done with the current hunk and
819 # this is the first real change for the
821 $hunk_start = $next_hunk_start;
822 $o_ofs = $this->{OLD
} + $this->{OCNT
};
823 $n_ofs = $this->{NEW
} + $this->{NCNT
};
824 $o_ofs -= $this->{POSTCTX
};
825 $n_ofs -= $this->{POSTCTX
};
829 push @
{$this->{TEXT
}}, $line;
830 push @
{$this->{DISPLAY
}}, $display;
844 for my $hunk (@split) {
845 $o_ofs = $hunk->{OLD
};
846 $n_ofs = $hunk->{NEW
};
847 my $o_cnt = $hunk->{OCNT
};
848 my $n_cnt = $hunk->{NCNT
};
850 my $head = format_hunk_header
($o_ofs, $o_cnt, $n_ofs, $n_cnt);
851 my $display_head = $head;
852 unshift @
{$hunk->{TEXT
}}, $head;
853 if ($diff_use_color) {
854 $display_head = colored
($fraginfo_color, $head);
856 unshift @
{$hunk->{DISPLAY
}}, $display_head;
861 sub find_last_o_ctx
{
863 my $text = $it->{TEXT
};
864 my ($o_ofs, $o_cnt) = parse_hunk_header
($text->[0]);
866 my $last_o_ctx = $o_ofs + $o_cnt;
868 my $line = $text->[$i];
879 my ($prev, $this) = @_;
880 my ($o0_ofs, $o0_cnt, $n0_ofs, $n0_cnt) =
881 parse_hunk_header
($prev->{TEXT
}[0]);
882 my ($o1_ofs, $o1_cnt, $n1_ofs, $n1_cnt) =
883 parse_hunk_header
($this->{TEXT
}[0]);
885 my (@line, $i, $ofs, $o_cnt, $n_cnt);
888 for ($i = 1; $i < @
{$prev->{TEXT
}}; $i++) {
889 my $line = $prev->{TEXT
}[$i];
890 if ($line =~ /^\+/) {
896 last if ($o1_ofs <= $ofs);
906 for ($i = 1; $i < @
{$this->{TEXT
}}; $i++) {
907 my $line = $this->{TEXT
}[$i];
908 if ($line =~ /^\+/) {
920 my $head = format_hunk_header
($o0_ofs, $o_cnt, $n0_ofs, $n_cnt);
921 @
{$prev->{TEXT
}} = ($head, @line);
924 sub coalesce_overlapping_hunks
{
928 my ($last_o_ctx, $last_was_dirty);
930 for (grep { $_->{USE
} } @in) {
931 if ($_->{TYPE
} ne 'hunk') {
935 my $text = $_->{TEXT
};
936 my ($o_ofs) = parse_hunk_header
($text->[0]);
937 if (defined $last_o_ctx &&
938 $o_ofs <= $last_o_ctx &&
941 merge_hunk
($out[-1], $_);
946 $last_o_ctx = find_last_o_ctx
($out[-1]);
947 $last_was_dirty = $_->{DIRTY
};
952 sub reassemble_patch
{
956 # Include everything in the header except the beginning of the diff.
957 push @patch, (grep { !/^[-+]{3}/ } @
$head);
959 # Then include any headers from the hunk lines, which must
960 # come before any actual hunk.
961 while (@_ && $_[0] !~ /^@/) {
965 # Then begin the diff.
966 push @patch, grep { /^[-+]{3}/ } @
$head;
968 # And then the actual hunks.
976 colored
((/^@/ ?
$fraginfo_color :
977 /^\+/ ?
$diff_new_color :
978 /^-/ ?
$diff_old_color :
984 my %edit_hunk_manually_modes = (
986 "If the patch applies cleanly, the edited hunk will immediately be
987 marked for staging."),
989 "If the patch applies cleanly, the edited hunk will immediately be
990 marked for stashing."),
992 "If the patch applies cleanly, the edited hunk will immediately be
993 marked for unstaging."),
994 reset_nothead
=> N__
(
995 "If the patch applies cleanly, the edited hunk will immediately be
996 marked for applying."),
997 checkout_index
=> N__
(
998 "If the patch applies cleanly, the edited hunk will immediately be
999 marked for discarding."),
1000 checkout_head
=> N__
(
1001 "If the patch applies cleanly, the edited hunk will immediately be
1002 marked for discarding."),
1003 checkout_nothead
=> N__
(
1004 "If the patch applies cleanly, the edited hunk will immediately be
1005 marked for applying."),
1008 sub edit_hunk_manually
{
1011 my $hunkfile = $repo->repo_path . "/addp-hunk-edit.diff";
1013 open $fh, '>', $hunkfile
1014 or die sprintf(__
("failed to open hunk edit file for writing: %s"), $!);
1015 print $fh Git
::comment_lines __
("Manual hunk edit mode -- see bottom for a quick guide.\n");
1016 print $fh @
$oldtext;
1017 my $is_reverse = $patch_mode_flavour{IS_REVERSE
};
1018 my ($remove_plus, $remove_minus) = $is_reverse ?
('-', '+') : ('+', '-');
1019 my $comment_line_char = Git
::get_comment_line_char
;
1020 print $fh Git
::comment_lines
sprintf(__
<<EOF, $remove_minus, $remove_plus, $comment_line_char),
1022 To remove '%s' lines, make them ' ' lines (context).
1023 To remove '%s' lines, delete them.
1024 Lines starting with %s will be removed.
1026 __
($edit_hunk_manually_modes{$patch_mode}),
1027 # TRANSLATORS: 'it' refers to the patch mentioned in the previous messages.
1029 If it does not apply cleanly, you will be given an opportunity to
1030 edit again. If all lines of the hunk are removed, then the edit is
1031 aborted and the hunk is left unchanged.
1035 chomp(my $editor = run_cmd_pipe(qw(git var GIT_EDITOR)));
1036 system('sh', '-c', $editor.' "$@"', $editor, $hunkfile);
1042 open $fh, '<', $hunkfile
1043 or die sprintf(__
("failed to open hunk edit file for reading: %s"), $!);
1044 my @newtext = grep { !/^\Q$comment_line_char\E/ } <$fh>;
1048 # Abort if nothing remains
1049 if (!grep { /\S/ } @newtext) {
1053 # Reinsert the first hunk header if the user accidentally deleted it
1054 if ($newtext[0] !~ /^@/) {
1055 unshift @newtext, $oldtext->[0];
1061 return run_git_apply
($patch_mode_flavour{APPLY_CHECK
} . ' --check',
1062 map { @
{$_->{TEXT
}} } @_);
1065 sub _restore_terminal_and_die
{
1071 sub prompt_single_character
{
1073 local $SIG{TERM
} = \
&_restore_terminal_and_die
;
1074 local $SIG{INT
} = \
&_restore_terminal_and_die
;
1076 my $key = ReadKey
0;
1078 if ($use_termcap and $key eq "\e") {
1079 while (!defined $term_escapes{$key}) {
1080 my $next = ReadKey
0.5;
1081 last if (!defined $next);
1086 print "$key" if defined $key;
1097 print colored
$prompt_color, $prompt;
1098 my $line = prompt_single_character
;
1099 return undef unless defined $line;
1100 return 0 if $line =~ /^n/i;
1101 return 1 if $line =~ /^y/i;
1105 sub edit_hunk_loop
{
1106 my ($head, $hunk, $ix) = @_;
1107 my $text = $hunk->[$ix]->{TEXT
};
1110 $text = edit_hunk_manually
($text);
1111 if (!defined $text) {
1116 TYPE
=> $hunk->[$ix]->{TYPE
},
1120 if (diff_applies
($head,
1123 @
{$hunk}[$ix+1..$#{$hunk}])) {
1124 $newhunk->{DISPLAY
} = [color_diff
(@
{$text})];
1129 # TRANSLATORS: do not translate [y/n]
1130 # The program will only accept that input
1132 # Consider translating (saying "no" discards!) as
1133 # (saying "n" for "no" discards!) if the translation
1134 # of the word "no" does not start with n.
1135 __
('Your edited hunk does not apply. Edit again '
1136 . '(saying "no" discards!) [y/n]? ')
1142 my %help_patch_modes = (
1144 "y - stage this hunk
1145 n - do not stage this hunk
1146 q - quit; do not stage this hunk or any of the remaining ones
1147 a - stage this hunk and all later hunks in the file
1148 d - do not stage this hunk or any of the later hunks in the file"),
1150 "y - stash this hunk
1151 n - do not stash this hunk
1152 q - quit; do not stash this hunk or any of the remaining ones
1153 a - stash this hunk and all later hunks in the file
1154 d - do not stash this hunk or any of the later hunks in the file"),
1156 "y - unstage this hunk
1157 n - do not unstage this hunk
1158 q - quit; do not unstage this hunk or any of the remaining ones
1159 a - unstage this hunk and all later hunks in the file
1160 d - do not unstage this hunk or any of the later hunks in the file"),
1161 reset_nothead
=> N__
(
1162 "y - apply this hunk to index
1163 n - do not apply this hunk to index
1164 q - quit; do not apply this hunk or any of the remaining ones
1165 a - apply this hunk and all later hunks in the file
1166 d - do not apply this hunk or any of the later hunks in the file"),
1167 checkout_index
=> N__
(
1168 "y - discard this hunk from worktree
1169 n - do not discard this hunk from worktree
1170 q - quit; do not discard this hunk or any of the remaining ones
1171 a - discard this hunk and all later hunks in the file
1172 d - do not discard this hunk or any of the later hunks in the file"),
1173 checkout_head
=> N__
(
1174 "y - discard this hunk from index and worktree
1175 n - do not discard this hunk from index and worktree
1176 q - quit; do not discard this hunk or any of the remaining ones
1177 a - discard this hunk and all later hunks in the file
1178 d - do not discard this hunk or any of the later hunks in the file"),
1179 checkout_nothead
=> N__
(
1180 "y - apply this hunk to index and worktree
1181 n - do not apply this hunk to index and worktree
1182 q - quit; do not apply this hunk or any of the remaining ones
1183 a - apply this hunk and all later hunks in the file
1184 d - do not apply this hunk or any of the later hunks in the file"),
1187 sub help_patch_cmd
{
1188 print colored
$help_color, __
($help_patch_modes{$patch_mode}), "\n", __
<<EOF ;
1189 g - select a hunk to go to
1190 / - search for a hunk matching the given regex
1191 j - leave this hunk undecided, see next undecided hunk
1192 J - leave this hunk undecided, see next hunk
1193 k - leave this hunk undecided, see previous undecided hunk
1194 K - leave this hunk undecided, see previous hunk
1195 s - split the current hunk into smaller hunks
1196 e - manually edit the current hunk
1203 my $ret = run_git_apply
$cmd, @_;
1210 sub apply_patch_for_checkout_commit
{
1211 my $reverse = shift;
1212 my $applies_index = run_git_apply
'apply '.$reverse.' --cached --check', @_;
1213 my $applies_worktree = run_git_apply
'apply '.$reverse.' --check', @_;
1215 if ($applies_worktree && $applies_index) {
1216 run_git_apply
'apply '.$reverse.' --cached', @_;
1217 run_git_apply
'apply '.$reverse, @_;
1219 } elsif (!$applies_index) {
1220 print colored
$error_color, __
("The selected hunks do not apply to the index!\n");
1221 if (prompt_yesno __
("Apply them to the worktree anyway? ")) {
1222 return run_git_apply
'apply '.$reverse, @_;
1224 print colored
$error_color, __
("Nothing was applied.\n");
1233 sub patch_update_cmd
{
1234 my @all_mods = list_modified
($patch_mode_flavour{FILTER
});
1235 error_msg
sprintf(__
("ignoring unmerged: %s\n"), $_->{VALUE
})
1236 for grep { $_->{UNMERGED
} } @all_mods;
1237 @all_mods = grep { !$_->{UNMERGED
} } @all_mods;
1239 my @mods = grep { !($_->{BINARY
}) } @all_mods;
1244 print STDERR __
("Only binary files changed.\n");
1246 print STDERR __
("No changes.\n");
1250 if ($patch_mode_only) {
1254 @them = list_and_choose
({ PROMPT
=> __
('Patch update'),
1255 HEADER
=> $status_head, },
1259 return 0 if patch_update_file
($_->{VALUE
});
1263 # Generate a one line summary of a hunk.
1264 sub summarize_hunk
{
1266 my $summary = $rhunk->{TEXT
}[0];
1268 # Keep the line numbers, discard extra context.
1269 $summary =~ s/@@(.*?)@@.*/$1 /s;
1270 $summary .= " " x
(20 - length $summary);
1272 # Add some user context.
1273 for my $line (@
{$rhunk->{TEXT
}}) {
1274 if ($line =~ m/^[+-].*\w/) {
1281 return substr($summary, 0, 80) . "\n";
1285 # Print a one-line summary of each hunk in the array ref in
1286 # the first argument, starting with the index in the 2nd.
1288 my ($hunks, $i) = @_;
1291 for (; $i < @
$hunks && $ctr < 20; $i++, $ctr++) {
1293 if (defined $hunks->[$i]{USE
}) {
1294 $status = $hunks->[$i]{USE
} ?
"+" : "-";
1299 summarize_hunk
($hunks->[$i]);
1304 my %patch_update_prompt_modes = (
1306 mode
=> N__
("Stage mode change [y,n,q,a,d,/%s,?]? "),
1307 deletion
=> N__
("Stage deletion [y,n,q,a,d,/%s,?]? "),
1308 hunk
=> N__
("Stage this hunk [y,n,q,a,d,/%s,?]? "),
1311 mode
=> N__
("Stash mode change [y,n,q,a,d,/%s,?]? "),
1312 deletion
=> N__
("Stash deletion [y,n,q,a,d,/%s,?]? "),
1313 hunk
=> N__
("Stash this hunk [y,n,q,a,d,/%s,?]? "),
1316 mode
=> N__
("Unstage mode change [y,n,q,a,d,/%s,?]? "),
1317 deletion
=> N__
("Unstage deletion [y,n,q,a,d,/%s,?]? "),
1318 hunk
=> N__
("Unstage this hunk [y,n,q,a,d,/%s,?]? "),
1321 mode
=> N__
("Apply mode change to index [y,n,q,a,d,/%s,?]? "),
1322 deletion
=> N__
("Apply deletion to index [y,n,q,a,d,/%s,?]? "),
1323 hunk
=> N__
("Apply this hunk to index [y,n,q,a,d,/%s,?]? "),
1326 mode
=> N__
("Discard mode change from worktree [y,n,q,a,d,/%s,?]? "),
1327 deletion
=> N__
("Discard deletion from worktree [y,n,q,a,d,/%s,?]? "),
1328 hunk
=> N__
("Discard this hunk from worktree [y,n,q,a,d,/%s,?]? "),
1331 mode
=> N__
("Discard mode change from index and worktree [y,n,q,a,d,/%s,?]? "),
1332 deletion
=> N__
("Discard deletion from index and worktree [y,n,q,a,d,/%s,?]? "),
1333 hunk
=> N__
("Discard this hunk from index and worktree [y,n,q,a,d,/%s,?]? "),
1335 checkout_nothead
=> {
1336 mode
=> N__
("Apply mode change to index and worktree [y,n,q,a,d,/%s,?]? "),
1337 deletion
=> N__
("Apply deletion to index and worktree [y,n,q,a,d,/%s,?]? "),
1338 hunk
=> N__
("Apply this hunk to index and worktree [y,n,q,a,d,/%s,?]? "),
1342 sub patch_update_file
{
1346 my ($head, @hunk) = parse_diff
($path);
1347 ($head, my $mode, my $deletion) = parse_diff_header
($head);
1348 for (@
{$head->{DISPLAY
}}) {
1352 if (@
{$mode->{TEXT
}}) {
1353 unshift @hunk, $mode;
1355 if (@
{$deletion->{TEXT
}}) {
1356 foreach my $hunk (@hunk) {
1357 push @
{$deletion->{TEXT
}}, @
{$hunk->{TEXT
}};
1358 push @
{$deletion->{DISPLAY
}}, @
{$hunk->{DISPLAY
}};
1360 @hunk = ($deletion);
1363 $num = scalar @hunk;
1367 my ($prev, $next, $other, $undecided, $i);
1373 for ($i = 0; $i < $ix; $i++) {
1374 if (!defined $hunk[$i]{USE
}) {
1383 for ($i = $ix + 1; $i < $num; $i++) {
1384 if (!defined $hunk[$i]{USE
}) {
1390 if ($ix < $num - 1) {
1396 for ($i = 0; $i < $num; $i++) {
1397 if (!defined $hunk[$i]{USE
}) {
1402 last if (!$undecided);
1404 if ($hunk[$ix]{TYPE
} eq 'hunk' &&
1405 hunk_splittable
($hunk[$ix]{TEXT
})) {
1408 if ($hunk[$ix]{TYPE
} eq 'hunk') {
1411 for (@
{$hunk[$ix]{DISPLAY
}}) {
1414 print colored
$prompt_color,
1415 sprintf(__
($patch_update_prompt_modes{$patch_mode}{$hunk[$ix]{TYPE
}}), $other);
1417 my $line = prompt_single_character
;
1418 last unless defined $line;
1420 if ($line =~ /^y/i) {
1421 $hunk[$ix]{USE
} = 1;
1423 elsif ($line =~ /^n/i) {
1424 $hunk[$ix]{USE
} = 0;
1426 elsif ($line =~ /^a/i) {
1427 while ($ix < $num) {
1428 if (!defined $hunk[$ix]{USE
}) {
1429 $hunk[$ix]{USE
} = 1;
1435 elsif ($other =~ /g/ && $line =~ /^g(.*)/) {
1437 my $no = $ix > 10 ?
$ix - 10 : 0;
1438 while ($response eq '') {
1439 $no = display_hunks
(\
@hunk, $no);
1441 print __
("go to which hunk (<ret> to see more)? ");
1443 print __
("go to which hunk? ");
1445 $response = <STDIN
>;
1446 if (!defined $response) {
1451 if ($response !~ /^\s*\d+\s*$/) {
1452 error_msg
sprintf(__
("Invalid number: '%s'\n"),
1454 } elsif (0 < $response && $response <= $num) {
1455 $ix = $response - 1;
1457 error_msg
sprintf(__n
("Sorry, only %d hunk available.\n",
1458 "Sorry, only %d hunks available.\n", $num), $num);
1462 elsif ($line =~ /^d/i) {
1463 while ($ix < $num) {
1464 if (!defined $hunk[$ix]{USE
}) {
1465 $hunk[$ix]{USE
} = 0;
1471 elsif ($line =~ /^q/i) {
1472 for ($i = 0; $i < $num; $i++) {
1473 if (!defined $hunk[$i]{USE
}) {
1480 elsif ($line =~ m
|^/(.*)|) {
1483 print colored
$prompt_color, __
("search for regex? ");
1485 if (defined $regex) {
1491 $search_string = qr{$regex}m;
1494 my ($err,$exp) = ($@
, $1);
1495 $err =~ s/ at .*git-add--interactive line \d+, <STDIN> line \d+.*$//;
1496 error_msg
sprintf(__
("Malformed search regexp %s: %s\n"), $exp, $err);
1501 my $text = join ("", @
{$hunk[$iy]{TEXT
}});
1502 last if ($text =~ $search_string);
1504 $iy = 0 if ($iy >= $num);
1506 error_msg __
("No hunk matches the given pattern\n");
1513 elsif ($line =~ /^K/) {
1514 if ($other =~ /K/) {
1518 error_msg __
("No previous hunk\n");
1522 elsif ($line =~ /^J/) {
1523 if ($other =~ /J/) {
1527 error_msg __
("No next hunk\n");
1531 elsif ($line =~ /^k/) {
1532 if ($other =~ /k/) {
1536 !defined $hunk[$ix]{USE
});
1540 error_msg __
("No previous hunk\n");
1544 elsif ($line =~ /^j/) {
1545 if ($other !~ /j/) {
1546 error_msg __
("No next hunk\n");
1550 elsif ($other =~ /s/ && $line =~ /^s/) {
1551 my @split = split_hunk
($hunk[$ix]{TEXT
}, $hunk[$ix]{DISPLAY
});
1553 print colored
$header_color, sprintf(
1554 __n
("Split into %d hunk.\n",
1555 "Split into %d hunks.\n",
1556 scalar(@split)), scalar(@split));
1558 splice (@hunk, $ix, 1, @split);
1559 $num = scalar @hunk;
1562 elsif ($other =~ /e/ && $line =~ /^e/) {
1563 my $newhunk = edit_hunk_loop
($head, \
@hunk, $ix);
1564 if (defined $newhunk) {
1565 splice @hunk, $ix, 1, $newhunk;
1569 help_patch_cmd
($other);
1575 last if ($ix >= $num ||
1576 !defined $hunk[$ix]{USE
});
1581 @hunk = coalesce_overlapping_hunks
(@hunk);
1587 push @result, @
{$_->{TEXT
}};
1592 my @patch = reassemble_patch
($head->{TEXT
}, @result);
1593 my $apply_routine = $patch_mode_flavour{APPLY
};
1594 &$apply_routine(@patch);
1603 my @mods = list_modified
('index-only');
1604 @mods = grep { !($_->{BINARY
}) } @mods;
1606 my (@them) = list_and_choose
({ PROMPT
=> __
('Review diff'),
1608 HEADER
=> $status_head, },
1611 my $reference = (is_initial_commit
()) ? get_empty_tree
() : 'HEAD';
1612 system(qw(git diff -p --cached), $reference, '--',
1613 map { $_->{VALUE
} } @them);
1622 # TRANSLATORS: please do not translate the command names
1623 # 'status', 'update', 'revert', etc.
1624 print colored
$help_color, __
<<'EOF' ;
1625 status - show paths with changes
1626 update - add working tree state to the staged set of changes
1627 revert - revert staged set of changes back to the HEAD version
1628 patch - pick hunks and update selectively
1629 diff - view diff between HEAD and index
1630 add untracked - add contents of untracked files to the staged set of changes
1635 return unless @ARGV;
1636 my $arg = shift @ARGV;
1637 if ($arg =~ /--patch(?:=(.*))?/) {
1639 if ($1 eq 'reset') {
1640 $patch_mode = 'reset_head';
1641 $patch_mode_revision = 'HEAD';
1642 $arg = shift @ARGV or die __
("missing --");
1644 $patch_mode_revision = $arg;
1645 $patch_mode = ($arg eq 'HEAD' ?
1646 'reset_head' : 'reset_nothead');
1647 $arg = shift @ARGV or die __
("missing --");
1649 } elsif ($1 eq 'checkout') {
1650 $arg = shift @ARGV or die __
("missing --");
1652 $patch_mode = 'checkout_index';
1654 $patch_mode_revision = $arg;
1655 $patch_mode = ($arg eq 'HEAD' ?
1656 'checkout_head' : 'checkout_nothead');
1657 $arg = shift @ARGV or die __
("missing --");
1659 } elsif ($1 eq 'stage' or $1 eq 'stash') {
1661 $arg = shift @ARGV or die __
("missing --");
1663 die sprintf(__
("unknown --patch mode: %s"), $1);
1666 $patch_mode = 'stage';
1667 $arg = shift @ARGV or die __
("missing --");
1669 die sprintf(__
("invalid argument %s, expecting --"),
1670 $arg) unless $arg eq "--";
1671 %patch_mode_flavour = %{$patch_modes{$patch_mode}};
1672 $patch_mode_only = 1;
1674 elsif ($arg ne "--") {
1675 die sprintf(__
("invalid argument %s, expecting --"), $arg);
1680 my @cmd = ([ 'status', \
&status_cmd
, ],
1681 [ 'update', \
&update_cmd
, ],
1682 [ 'revert', \
&revert_cmd
, ],
1683 [ 'add untracked', \
&add_untracked_cmd
, ],
1684 [ 'patch', \
&patch_update_cmd
, ],
1685 [ 'diff', \
&diff_cmd
, ],
1686 [ 'quit', \
&quit_cmd
, ],
1687 [ 'help', \
&help_cmd
, ],
1690 my ($it) = list_and_choose
({ PROMPT
=> __
('What now'),
1693 HEADER
=> __
('*** Commands ***'),
1694 ON_EOF
=> \
&quit_cmd
,
1695 IMMEDIATE
=> 1 }, @cmd);
1709 if ($patch_mode_only) {