Merge tag 'v2.14.1'
[git/raj.git] / git-add--interactive.perl
blob28b325d75481b74e8f7b16485e1fc18ad854161c
1 #!/usr/bin/perl
3 use 5.008;
4 use strict;
5 use warnings;
6 use Git qw(unquote_path);
7 use Git::I18N;
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) =
15 $menu_use_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'),
19 ) : ();
20 my $error_color = ();
21 if ($menu_use_color) {
22 my $help_color_spec = ($repo->config('color.interactive.help') or
23 'red bold');
24 $error_color = $repo->get_color('color.interactive.error',
25 $help_color_spec);
28 my $diff_use_color = $repo->get_colorbool('color.diff');
29 my ($fraginfo_color) =
30 $diff_use_color ? (
31 $repo->get_color('color.diff.frag', 'cyan'),
32 ) : ();
33 my ($diff_plain_color) =
34 $diff_use_color ? (
35 $repo->get_color('color.diff.plain', ''),
36 ) : ();
37 my ($diff_old_color) =
38 $diff_use_color ? (
39 $repo->get_color('color.diff.old', 'red'),
40 ) : ();
41 my ($diff_new_color) =
42 $diff_use_color ? (
43 $repo->get_color('color.diff.new', 'green'),
44 ) : ();
46 my $normal_color = $repo->get_color("", "reset");
48 my $diff_algorithm = $repo->config('diff.algorithm');
49 my $diff_filter = $repo->config('interactive.difffilter');
51 my $use_readkey = 0;
52 my $use_termcap = 0;
53 my %term_escapes;
55 sub ReadMode;
56 sub ReadKey;
57 if ($repo->config_bool("interactive.singlekey")) {
58 eval {
59 require Term::ReadKey;
60 Term::ReadKey->import;
61 $use_readkey = 1;
63 if (!$use_readkey) {
64 print STDERR "missing Term::ReadKey, disabling interactive.singlekey\n";
66 eval {
67 require Term::Cap;
68 my $termcap = Term::Cap->Tgetent;
69 foreach (values %$termcap) {
70 $term_escapes{$_} = 1 if /^\e/;
72 $use_termcap = 1;
76 sub colored {
77 my $color = shift;
78 my $string = join("", @_);
80 if (defined $color) {
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$/;
90 return $string;
93 # command line options
94 my $patch_mode_only;
95 my $patch_mode;
96 my $patch_mode_revision;
98 sub apply_patch;
99 sub apply_patch_for_checkout_commit;
100 sub apply_patch_for_stash;
102 my %patch_modes = (
103 'stage' => {
104 DIFF => 'diff-files -p',
105 APPLY => sub { apply_patch 'apply --cached', @_; },
106 APPLY_CHECK => 'apply --cached',
107 FILTER => 'file-only',
108 IS_REVERSE => 0,
110 'stash' => {
111 DIFF => 'diff-index -p HEAD',
112 APPLY => sub { apply_patch 'apply --cached', @_; },
113 APPLY_CHECK => 'apply --cached',
114 FILTER => undef,
115 IS_REVERSE => 0,
117 'reset_head' => {
118 DIFF => 'diff-index -p --cached',
119 APPLY => sub { apply_patch 'apply -R --cached', @_; },
120 APPLY_CHECK => 'apply -R --cached',
121 FILTER => 'index-only',
122 IS_REVERSE => 1,
124 'reset_nothead' => {
125 DIFF => 'diff-index -R -p --cached',
126 APPLY => sub { apply_patch 'apply --cached', @_; },
127 APPLY_CHECK => 'apply --cached',
128 FILTER => 'index-only',
129 IS_REVERSE => 0,
131 'checkout_index' => {
132 DIFF => 'diff-files -p',
133 APPLY => sub { apply_patch 'apply -R', @_; },
134 APPLY_CHECK => 'apply -R',
135 FILTER => 'file-only',
136 IS_REVERSE => 1,
138 'checkout_head' => {
139 DIFF => 'diff-index -p',
140 APPLY => sub { apply_patch_for_checkout_commit '-R', @_ },
141 APPLY_CHECK => 'apply -R',
142 FILTER => undef,
143 IS_REVERSE => 1,
145 'checkout_nothead' => {
146 DIFF => 'diff-index -R -p',
147 APPLY => sub { apply_patch_for_checkout_commit '', @_ },
148 APPLY_CHECK => 'apply',
149 FILTER => undef,
150 IS_REVERSE => 0,
154 $patch_mode = 'stage';
155 my %patch_mode_flavour = %{$patch_modes{$patch_mode}};
157 sub run_cmd_pipe {
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 ? "\"$_\"": $_ } @_;
162 return qx{@args};
163 } else {
164 my $fh = undef;
165 open($fh, '-|', @_) or die;
166 return <$fh>;
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"
175 chomp($GIT_DIR);
177 sub refresh {
178 my $fh;
179 open $fh, 'git update-index --refresh |'
180 or die;
181 while (<$fh>) {
182 ;# ignore 'needs update'
184 close $fh;
187 sub list_untracked {
188 map {
189 chomp $_;
190 unquote_path($_);
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'));
200 my $initial;
201 sub is_initial_commit {
202 $initial = system('git rev-parse HEAD -- >/dev/null 2>&1') != 0
203 unless defined $initial;
204 return $initial;
208 sub get_empty_tree {
209 return '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
212 sub get_diff_reference {
213 my $ref = shift;
214 if (defined $ref and $ref ne 'HEAD') {
215 return $ref;
216 } elsif (is_initial_commit()) {
217 return get_empty_tree();
218 } else {
219 return 'HEAD';
223 # Returns list of hashes, contents of each of which are:
224 # VALUE: pathname
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
232 sub list_modified {
233 my ($only) = @_;
234 my (%data, @return);
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,
240 '--', @ARGV)) {
241 if (($add, $del, $file) =
242 /^([-\d]+) ([-\d]+) (.*)/) {
243 my ($change, $bin);
244 $file = unquote_path($file);
245 if ($add eq '-' && $del eq '-') {
246 $change = __('binary');
247 $bin = 1;
249 else {
250 $change = "+$add/-$del";
252 $data{$file} = {
253 INDEX => $change,
254 BINARY => $bin,
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);
269 my ($change, $bin);
270 if ($add eq '-' && $del eq '-') {
271 $change = __('binary');
272 $bin = 1;
274 else {
275 $change = "+$add/-$del";
277 $data{$file}{FILE} = $change;
278 if ($bin) {
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}) {
290 $data{$file} = +{
291 INDEX => __('unchanged'),
292 BINARY => 0,
295 if ($1 eq 'U') {
296 $data{$file}{UNMERGED} = 1;
301 for (sort keys %data) {
302 my $it = $data{$_};
304 if ($only) {
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'));
312 push @return, +{
313 VALUE => $_,
314 %$it,
317 return @return;
320 sub find_unique {
321 my ($string, @stuff) = @_;
322 my $found = undef;
323 for (my $i = 0; $i < @stuff; $i++) {
324 my $it = $stuff[$i];
325 my $hit = undef;
326 if (ref $it) {
327 if ((ref $it) eq 'ARRAY') {
328 $it = $it->[0];
330 else {
331 $it = $it->{VALUE};
334 eval {
335 if ($it =~ /^$string/) {
336 $hit = 1;
339 if (defined $hit && defined $found) {
340 return undef;
342 if ($hit) {
343 $found = $i + 1;
346 return $found;
349 # inserts string into trie and updates count for each character
350 sub update_trie {
351 my ($trie, $string) = @_;
352 foreach (split //, $string) {
353 $trie = $trie->{$_} ||= {COUNT => 0};
354 $trie->{COUNT}++;
358 # returns an array of tuples (prefix, remainder)
359 sub find_unique_prefixes {
360 my @stuff = @_;
361 my @return = ();
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
366 my $soft_limit = 0;
367 my $hard_limit = 3;
369 # build a trie modelling all possible options
370 my %trie;
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;
386 my %search = %trie;
387 my ($prefix, $remainder);
388 my $j;
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;
394 last;
396 else {
397 my $prefix = substr $ret, 0, $j;
398 return ()
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)) {
405 $prefix = undef;
406 $remainder = $ret;
408 $return[$i] = [$prefix, $remainder];
410 return @return;
413 # filters out prefixes which have special meaning to list_and_choose()
414 sub is_valid_prefix {
415 my $prefix = shift;
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 {
427 my $prefix = shift;
428 my $remainder = shift;
430 if (!defined $prefix) {
431 return $remainder;
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";
445 sub error_msg {
446 print STDERR colored $error_color, @_;
449 sub list_and_choose {
450 my ($opts, @stuff) = @_;
451 my (@chosen, @return);
452 if (!@stuff) {
453 return @return;
455 my $i;
456 my @prefixes = find_unique_prefixes(@stuff) unless $opts->{LIST_ONLY};
458 TOPLOOP:
459 while (1) {
460 my $last_lf = 0;
462 if ($opts->{HEADER}) {
463 if (!$opts->{LIST_FLAT}) {
464 print " ";
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]})
473 if @prefixes;
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,
480 $print->{INDEX},
481 $print->{FILE},
482 $value);
484 else {
485 $print = $highlighted || $print;
487 printf("%s%2d: %s", $chosen, $i+1, $print);
488 if (($opts->{LIST_FLAT}) &&
489 (($i + 1) % ($opts->{LIST_FLAT}))) {
490 print "\t";
491 $last_lf = 0;
493 else {
494 print "\n";
495 $last_lf = 1;
498 if (!$last_lf) {
499 print "\n";
502 return if ($opts->{LIST_ONLY});
504 print colored $prompt_color, $opts->{PROMPT};
505 if ($opts->{SINGLETON}) {
506 print "> ";
508 else {
509 print ">> ";
511 my $line = <STDIN>;
512 if (!$line) {
513 print "\n";
514 $opts->{ON_EOF}->() if $opts->{ON_EOF};
515 last;
517 chomp $line;
518 last if $line eq '';
519 if ($line eq '?') {
520 $opts->{SINGLETON} ?
521 singleton_prompt_help_cmd() :
522 prompt_help_cmd();
523 next TOPLOOP;
525 for my $choice (split(/[\s,]+/, $line)) {
526 my $choose = 1;
527 my ($bottom, $top);
529 # Input that begins with '-'; unchoose
530 if ($choice =~ s/^-//) {
531 $choose = 0;
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 '*') {
541 $bottom = 1;
542 $top = 1 + @stuff;
544 else {
545 $bottom = $top = find_unique($choice, @stuff);
546 if (!defined $bottom) {
547 error_msg sprintf(__("Huh (%s)?\n"), $choice);
548 next TOPLOOP;
551 if ($opts->{SINGLETON} && $bottom != $top) {
552 error_msg sprintf(__("Huh (%s)?\n"), $choice);
553 next TOPLOOP;
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++) {
563 if ($chosen[$i]) {
564 push @return, $stuff[$i];
567 return @return;
570 sub singleton_prompt_help_cmd {
571 print colored $help_color, __ <<'EOF' ;
572 Prompt help:
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' ;
581 Prompt help:
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
587 * - choose all items
588 - (empty) finish selecting
592 sub status_cmd {
593 list_and_choose({ LIST_ONLY => 1, HEADER => $status_head },
594 list_modified());
595 print "\n";
598 sub say_n_paths {
599 my $did = shift @_;
600 my $cnt = scalar @_;
601 if ($did eq 'added') {
602 printf(__n("added %d path\n", "added %d paths\n",
603 $cnt), $cnt);
604 } elsif ($did eq 'updated') {
605 printf(__n("updated %d path\n", "updated %d paths\n",
606 $cnt), $cnt);
607 } elsif ($did eq 'reverted') {
608 printf(__n("reverted %d path\n", "reverted %d paths\n",
609 $cnt), $cnt);
610 } else {
611 printf(__n("touched %d path\n", "touched %d paths\n",
612 $cnt), $cnt);
616 sub update_cmd {
617 my @mods = list_modified('file-only');
618 return if (!@mods);
620 my @update = list_and_choose({ PROMPT => __('Update'),
621 HEADER => $status_head, },
622 @mods);
623 if (@update) {
624 system(qw(git update-index --add --remove --),
625 map { $_->{VALUE} } @update);
626 say_n_paths('updated', @update);
628 print "\n";
631 sub revert_cmd {
632 my @update = list_and_choose({ PROMPT => __('Revert'),
633 HEADER => $status_head, },
634 list_modified());
635 if (@update) {
636 if (is_initial_commit()) {
637 system(qw(git rm --cached),
638 map { $_->{VALUE} } @update);
640 else {
641 my @lines = run_cmd_pipe(qw(git ls-tree HEAD --),
642 map { $_->{VALUE} } @update);
643 my $fh;
644 open $fh, '| git update-index --index-info'
645 or die;
646 for (@lines) {
647 print $fh $_;
649 close($fh);
650 for (@update) {
651 if ($_->{INDEX_ADDDEL} &&
652 $_->{INDEX_ADDDEL} eq 'create') {
653 system(qw(git update-index --force-remove --),
654 $_->{VALUE});
655 printf(__("note: %s is untracked now.\n"), $_->{VALUE});
659 refresh();
660 say_n_paths('reverted', @update);
662 print "\n";
665 sub add_untracked_cmd {
666 my @add = list_and_choose({ PROMPT => __('Add untracked') },
667 list_untracked());
668 if (@add) {
669 system(qw(git update-index --add --), @add);
670 say_n_paths('added', @add);
671 } else {
672 print __("No untracked files.\n");
674 print "\n";
677 sub run_git_apply {
678 my $cmd = shift;
679 my $fh;
680 open $fh, '| git ' . $cmd . " --recount --allow-overlap";
681 print $fh @_;
682 return close $fh;
685 sub parse_diff {
686 my ($path) = @_;
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);
695 my @colored = ();
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 => [],
711 TYPE => 'hunk' };
713 push @{$hunk[-1]{TEXT}}, $diff[$i];
714 push @{$hunk[-1]{DISPLAY}},
715 (@colored ? $colored[$i] : $diff[$i]);
717 return @hunk;
720 sub parse_diff_header {
721 my $src = shift;
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++) {
728 my $dest =
729 $src->{TEXT}->[$i] =~ /^(old|new) mode (\d+)$/ ? $mode :
730 $src->{TEXT}->[$i] =~ /^deleted file/ ? $deletion :
731 $head;
732 push @{$dest->{TEXT}}, $src->{TEXT}->[$i];
733 push @{$dest->{DISPLAY}}, $src->{DISPLAY}->[$i];
735 return ($head, $mode, $deletion);
738 sub hunk_splittable {
739 my ($text) = @_;
741 my @s = split_hunk($text);
742 return (1 < @s);
745 sub parse_hunk_header {
746 my ($line) = @_;
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 split_hunk {
755 my ($text, $display) = @_;
756 my @split = ();
757 if (!defined $display) {
758 $display = $text;
760 # If there are context lines in the middle of a hunk,
761 # it can be split, but we would need to take care of
762 # overlaps later.
764 my ($o_ofs, undef, $n_ofs) = parse_hunk_header($text->[0]);
765 my $hunk_start = 1;
767 OUTER:
768 while (1) {
769 my $next_hunk_start = undef;
770 my $i = $hunk_start - 1;
771 my $this = +{
772 TEXT => [],
773 DISPLAY => [],
774 TYPE => 'hunk',
775 OLD => $o_ofs,
776 NEW => $n_ofs,
777 OCNT => 0,
778 NCNT => 0,
779 ADDDEL => 0,
780 POSTCTX => 0,
781 USE => undef,
784 while (++$i < @$text) {
785 my $line = $text->[$i];
786 my $display = $display->[$i];
787 if ($line =~ /^ /) {
788 if ($this->{ADDDEL} &&
789 !defined $next_hunk_start) {
790 # We have seen leading context and
791 # adds/dels and then here is another
792 # context, which is trailing for this
793 # split hunk and leading for the next
794 # one.
795 $next_hunk_start = $i;
797 push @{$this->{TEXT}}, $line;
798 push @{$this->{DISPLAY}}, $display;
799 $this->{OCNT}++;
800 $this->{NCNT}++;
801 if (defined $next_hunk_start) {
802 $this->{POSTCTX}++;
804 next;
807 # add/del
808 if (defined $next_hunk_start) {
809 # We are done with the current hunk and
810 # this is the first real change for the
811 # next split one.
812 $hunk_start = $next_hunk_start;
813 $o_ofs = $this->{OLD} + $this->{OCNT};
814 $n_ofs = $this->{NEW} + $this->{NCNT};
815 $o_ofs -= $this->{POSTCTX};
816 $n_ofs -= $this->{POSTCTX};
817 push @split, $this;
818 redo OUTER;
820 push @{$this->{TEXT}}, $line;
821 push @{$this->{DISPLAY}}, $display;
822 $this->{ADDDEL}++;
823 if ($line =~ /^-/) {
824 $this->{OCNT}++;
826 else {
827 $this->{NCNT}++;
831 push @split, $this;
832 last;
835 for my $hunk (@split) {
836 $o_ofs = $hunk->{OLD};
837 $n_ofs = $hunk->{NEW};
838 my $o_cnt = $hunk->{OCNT};
839 my $n_cnt = $hunk->{NCNT};
841 my $head = ("@@ -$o_ofs" .
842 (($o_cnt != 1) ? ",$o_cnt" : '') .
843 " +$n_ofs" .
844 (($n_cnt != 1) ? ",$n_cnt" : '') .
845 " @@\n");
846 my $display_head = $head;
847 unshift @{$hunk->{TEXT}}, $head;
848 if ($diff_use_color) {
849 $display_head = colored($fraginfo_color, $head);
851 unshift @{$hunk->{DISPLAY}}, $display_head;
853 return @split;
856 sub find_last_o_ctx {
857 my ($it) = @_;
858 my $text = $it->{TEXT};
859 my ($o_ofs, $o_cnt) = parse_hunk_header($text->[0]);
860 my $i = @{$text};
861 my $last_o_ctx = $o_ofs + $o_cnt;
862 while (0 < --$i) {
863 my $line = $text->[$i];
864 if ($line =~ /^ /) {
865 $last_o_ctx--;
866 next;
868 last;
870 return $last_o_ctx;
873 sub merge_hunk {
874 my ($prev, $this) = @_;
875 my ($o0_ofs, $o0_cnt, $n0_ofs, $n0_cnt) =
876 parse_hunk_header($prev->{TEXT}[0]);
877 my ($o1_ofs, $o1_cnt, $n1_ofs, $n1_cnt) =
878 parse_hunk_header($this->{TEXT}[0]);
880 my (@line, $i, $ofs, $o_cnt, $n_cnt);
881 $ofs = $o0_ofs;
882 $o_cnt = $n_cnt = 0;
883 for ($i = 1; $i < @{$prev->{TEXT}}; $i++) {
884 my $line = $prev->{TEXT}[$i];
885 if ($line =~ /^\+/) {
886 $n_cnt++;
887 push @line, $line;
888 next;
891 last if ($o1_ofs <= $ofs);
893 $o_cnt++;
894 $ofs++;
895 if ($line =~ /^ /) {
896 $n_cnt++;
898 push @line, $line;
901 for ($i = 1; $i < @{$this->{TEXT}}; $i++) {
902 my $line = $this->{TEXT}[$i];
903 if ($line =~ /^\+/) {
904 $n_cnt++;
905 push @line, $line;
906 next;
908 $ofs++;
909 $o_cnt++;
910 if ($line =~ /^ /) {
911 $n_cnt++;
913 push @line, $line;
915 my $head = ("@@ -$o0_ofs" .
916 (($o_cnt != 1) ? ",$o_cnt" : '') .
917 " +$n0_ofs" .
918 (($n_cnt != 1) ? ",$n_cnt" : '') .
919 " @@\n");
920 @{$prev->{TEXT}} = ($head, @line);
923 sub coalesce_overlapping_hunks {
924 my (@in) = @_;
925 my @out = ();
927 my ($last_o_ctx, $last_was_dirty);
929 for (grep { $_->{USE} } @in) {
930 if ($_->{TYPE} ne 'hunk') {
931 push @out, $_;
932 next;
934 my $text = $_->{TEXT};
935 my ($o_ofs) = parse_hunk_header($text->[0]);
936 if (defined $last_o_ctx &&
937 $o_ofs <= $last_o_ctx &&
938 !$_->{DIRTY} &&
939 !$last_was_dirty) {
940 merge_hunk($out[-1], $_);
942 else {
943 push @out, $_;
945 $last_o_ctx = find_last_o_ctx($out[-1]);
946 $last_was_dirty = $_->{DIRTY};
948 return @out;
951 sub reassemble_patch {
952 my $head = shift;
953 my @patch;
955 # Include everything in the header except the beginning of the diff.
956 push @patch, (grep { !/^[-+]{3}/ } @$head);
958 # Then include any headers from the hunk lines, which must
959 # come before any actual hunk.
960 while (@_ && $_[0] !~ /^@/) {
961 push @patch, shift;
964 # Then begin the diff.
965 push @patch, grep { /^[-+]{3}/ } @$head;
967 # And then the actual hunks.
968 push @patch, @_;
970 return @patch;
973 sub color_diff {
974 return map {
975 colored((/^@/ ? $fraginfo_color :
976 /^\+/ ? $diff_new_color :
977 /^-/ ? $diff_old_color :
978 $diff_plain_color),
979 $_);
980 } @_;
983 my %edit_hunk_manually_modes = (
984 stage => N__(
985 "If the patch applies cleanly, the edited hunk will immediately be
986 marked for staging."),
987 stash => N__(
988 "If the patch applies cleanly, the edited hunk will immediately be
989 marked for stashing."),
990 reset_head => N__(
991 "If the patch applies cleanly, the edited hunk will immediately be
992 marked for unstaging."),
993 reset_nothead => N__(
994 "If the patch applies cleanly, the edited hunk will immediately be
995 marked for applying."),
996 checkout_index => N__(
997 "If the patch applies cleanly, the edited hunk will immediately be
998 marked for discarding."),
999 checkout_head => N__(
1000 "If the patch applies cleanly, the edited hunk will immediately be
1001 marked for discarding."),
1002 checkout_nothead => N__(
1003 "If the patch applies cleanly, the edited hunk will immediately be
1004 marked for applying."),
1007 sub edit_hunk_manually {
1008 my ($oldtext) = @_;
1010 my $hunkfile = $repo->repo_path . "/addp-hunk-edit.diff";
1011 my $fh;
1012 open $fh, '>', $hunkfile
1013 or die sprintf(__("failed to open hunk edit file for writing: %s"), $!);
1014 print $fh Git::comment_lines __("Manual hunk edit mode -- see bottom for a quick guide.\n");
1015 print $fh @$oldtext;
1016 my $is_reverse = $patch_mode_flavour{IS_REVERSE};
1017 my ($remove_plus, $remove_minus) = $is_reverse ? ('-', '+') : ('+', '-');
1018 my $comment_line_char = Git::get_comment_line_char;
1019 print $fh Git::comment_lines sprintf(__ <<EOF, $remove_minus, $remove_plus, $comment_line_char),
1021 To remove '%s' lines, make them ' ' lines (context).
1022 To remove '%s' lines, delete them.
1023 Lines starting with %s will be removed.
1025 __($edit_hunk_manually_modes{$patch_mode}),
1026 # TRANSLATORS: 'it' refers to the patch mentioned in the previous messages.
1027 __ <<EOF2 ;
1028 If it does not apply cleanly, you will be given an opportunity to
1029 edit again. If all lines of the hunk are removed, then the edit is
1030 aborted and the hunk is left unchanged.
1031 EOF2
1032 close $fh;
1034 chomp(my $editor = run_cmd_pipe(qw(git var GIT_EDITOR)));
1035 system('sh', '-c', $editor.' "$@"', $editor, $hunkfile);
1037 if ($? != 0) {
1038 return undef;
1041 open $fh, '<', $hunkfile
1042 or die sprintf(__("failed to open hunk edit file for reading: %s"), $!);
1043 my @newtext = grep { !/^\Q$comment_line_char\E/ } <$fh>;
1044 close $fh;
1045 unlink $hunkfile;
1047 # Abort if nothing remains
1048 if (!grep { /\S/ } @newtext) {
1049 return undef;
1052 # Reinsert the first hunk header if the user accidentally deleted it
1053 if ($newtext[0] !~ /^@/) {
1054 unshift @newtext, $oldtext->[0];
1056 return \@newtext;
1059 sub diff_applies {
1060 return run_git_apply($patch_mode_flavour{APPLY_CHECK} . ' --check',
1061 map { @{$_->{TEXT}} } @_);
1064 sub _restore_terminal_and_die {
1065 ReadMode 'restore';
1066 print "\n";
1067 exit 1;
1070 sub prompt_single_character {
1071 if ($use_readkey) {
1072 local $SIG{TERM} = \&_restore_terminal_and_die;
1073 local $SIG{INT} = \&_restore_terminal_and_die;
1074 ReadMode 'cbreak';
1075 my $key = ReadKey 0;
1076 ReadMode 'restore';
1077 if ($use_termcap and $key eq "\e") {
1078 while (!defined $term_escapes{$key}) {
1079 my $next = ReadKey 0.5;
1080 last if (!defined $next);
1081 $key .= $next;
1083 $key =~ s/\e/^[/;
1085 print "$key" if defined $key;
1086 print "\n";
1087 return $key;
1088 } else {
1089 return <STDIN>;
1093 sub prompt_yesno {
1094 my ($prompt) = @_;
1095 while (1) {
1096 print colored $prompt_color, $prompt;
1097 my $line = prompt_single_character;
1098 return undef unless defined $line;
1099 return 0 if $line =~ /^n/i;
1100 return 1 if $line =~ /^y/i;
1104 sub edit_hunk_loop {
1105 my ($head, $hunk, $ix) = @_;
1106 my $text = $hunk->[$ix]->{TEXT};
1108 while (1) {
1109 $text = edit_hunk_manually($text);
1110 if (!defined $text) {
1111 return undef;
1113 my $newhunk = {
1114 TEXT => $text,
1115 TYPE => $hunk->[$ix]->{TYPE},
1116 USE => 1,
1117 DIRTY => 1,
1119 if (diff_applies($head,
1120 @{$hunk}[0..$ix-1],
1121 $newhunk,
1122 @{$hunk}[$ix+1..$#{$hunk}])) {
1123 $newhunk->{DISPLAY} = [color_diff(@{$text})];
1124 return $newhunk;
1126 else {
1127 prompt_yesno(
1128 # TRANSLATORS: do not translate [y/n]
1129 # The program will only accept that input
1130 # at this point.
1131 # Consider translating (saying "no" discards!) as
1132 # (saying "n" for "no" discards!) if the translation
1133 # of the word "no" does not start with n.
1134 __('Your edited hunk does not apply. Edit again '
1135 . '(saying "no" discards!) [y/n]? ')
1136 ) or return undef;
1141 my %help_patch_modes = (
1142 stage => N__(
1143 "y - stage this hunk
1144 n - do not stage this hunk
1145 q - quit; do not stage this hunk or any of the remaining ones
1146 a - stage this hunk and all later hunks in the file
1147 d - do not stage this hunk or any of the later hunks in the file"),
1148 stash => N__(
1149 "y - stash this hunk
1150 n - do not stash this hunk
1151 q - quit; do not stash this hunk or any of the remaining ones
1152 a - stash this hunk and all later hunks in the file
1153 d - do not stash this hunk or any of the later hunks in the file"),
1154 reset_head => N__(
1155 "y - unstage this hunk
1156 n - do not unstage this hunk
1157 q - quit; do not unstage this hunk or any of the remaining ones
1158 a - unstage this hunk and all later hunks in the file
1159 d - do not unstage this hunk or any of the later hunks in the file"),
1160 reset_nothead => N__(
1161 "y - apply this hunk to index
1162 n - do not apply this hunk to index
1163 q - quit; do not apply this hunk or any of the remaining ones
1164 a - apply this hunk and all later hunks in the file
1165 d - do not apply this hunk or any of the later hunks in the file"),
1166 checkout_index => N__(
1167 "y - discard this hunk from worktree
1168 n - do not discard this hunk from worktree
1169 q - quit; do not discard this hunk or any of the remaining ones
1170 a - discard this hunk and all later hunks in the file
1171 d - do not discard this hunk or any of the later hunks in the file"),
1172 checkout_head => N__(
1173 "y - discard this hunk from index and worktree
1174 n - do not discard this hunk from index and worktree
1175 q - quit; do not discard this hunk or any of the remaining ones
1176 a - discard this hunk and all later hunks in the file
1177 d - do not discard this hunk or any of the later hunks in the file"),
1178 checkout_nothead => N__(
1179 "y - apply this hunk to index and worktree
1180 n - do not apply this hunk to index and worktree
1181 q - quit; do not apply this hunk or any of the remaining ones
1182 a - apply this hunk and all later hunks in the file
1183 d - do not apply this hunk or any of the later hunks in the file"),
1186 sub help_patch_cmd {
1187 print colored $help_color, __($help_patch_modes{$patch_mode}), "\n", __ <<EOF ;
1188 g - select a hunk to go to
1189 / - search for a hunk matching the given regex
1190 j - leave this hunk undecided, see next undecided hunk
1191 J - leave this hunk undecided, see next hunk
1192 k - leave this hunk undecided, see previous undecided hunk
1193 K - leave this hunk undecided, see previous hunk
1194 s - split the current hunk into smaller hunks
1195 e - manually edit the current hunk
1196 ? - print help
1200 sub apply_patch {
1201 my $cmd = shift;
1202 my $ret = run_git_apply $cmd, @_;
1203 if (!$ret) {
1204 print STDERR @_;
1206 return $ret;
1209 sub apply_patch_for_checkout_commit {
1210 my $reverse = shift;
1211 my $applies_index = run_git_apply 'apply '.$reverse.' --cached --check', @_;
1212 my $applies_worktree = run_git_apply 'apply '.$reverse.' --check', @_;
1214 if ($applies_worktree && $applies_index) {
1215 run_git_apply 'apply '.$reverse.' --cached', @_;
1216 run_git_apply 'apply '.$reverse, @_;
1217 return 1;
1218 } elsif (!$applies_index) {
1219 print colored $error_color, __("The selected hunks do not apply to the index!\n");
1220 if (prompt_yesno __("Apply them to the worktree anyway? ")) {
1221 return run_git_apply 'apply '.$reverse, @_;
1222 } else {
1223 print colored $error_color, __("Nothing was applied.\n");
1224 return 0;
1226 } else {
1227 print STDERR @_;
1228 return 0;
1232 sub patch_update_cmd {
1233 my @all_mods = list_modified($patch_mode_flavour{FILTER});
1234 error_msg sprintf(__("ignoring unmerged: %s\n"), $_->{VALUE})
1235 for grep { $_->{UNMERGED} } @all_mods;
1236 @all_mods = grep { !$_->{UNMERGED} } @all_mods;
1238 my @mods = grep { !($_->{BINARY}) } @all_mods;
1239 my @them;
1241 if (!@mods) {
1242 if (@all_mods) {
1243 print STDERR __("Only binary files changed.\n");
1244 } else {
1245 print STDERR __("No changes.\n");
1247 return 0;
1249 if ($patch_mode_only) {
1250 @them = @mods;
1252 else {
1253 @them = list_and_choose({ PROMPT => __('Patch update'),
1254 HEADER => $status_head, },
1255 @mods);
1257 for (@them) {
1258 return 0 if patch_update_file($_->{VALUE});
1262 # Generate a one line summary of a hunk.
1263 sub summarize_hunk {
1264 my $rhunk = shift;
1265 my $summary = $rhunk->{TEXT}[0];
1267 # Keep the line numbers, discard extra context.
1268 $summary =~ s/@@(.*?)@@.*/$1 /s;
1269 $summary .= " " x (20 - length $summary);
1271 # Add some user context.
1272 for my $line (@{$rhunk->{TEXT}}) {
1273 if ($line =~ m/^[+-].*\w/) {
1274 $summary .= $line;
1275 last;
1279 chomp $summary;
1280 return substr($summary, 0, 80) . "\n";
1284 # Print a one-line summary of each hunk in the array ref in
1285 # the first argument, starting with the index in the 2nd.
1286 sub display_hunks {
1287 my ($hunks, $i) = @_;
1288 my $ctr = 0;
1289 $i ||= 0;
1290 for (; $i < @$hunks && $ctr < 20; $i++, $ctr++) {
1291 my $status = " ";
1292 if (defined $hunks->[$i]{USE}) {
1293 $status = $hunks->[$i]{USE} ? "+" : "-";
1295 printf "%s%2d: %s",
1296 $status,
1297 $i + 1,
1298 summarize_hunk($hunks->[$i]);
1300 return $i;
1303 my %patch_update_prompt_modes = (
1304 stage => {
1305 mode => N__("Stage mode change [y,n,q,a,d,/%s,?]? "),
1306 deletion => N__("Stage deletion [y,n,q,a,d,/%s,?]? "),
1307 hunk => N__("Stage this hunk [y,n,q,a,d,/%s,?]? "),
1309 stash => {
1310 mode => N__("Stash mode change [y,n,q,a,d,/%s,?]? "),
1311 deletion => N__("Stash deletion [y,n,q,a,d,/%s,?]? "),
1312 hunk => N__("Stash this hunk [y,n,q,a,d,/%s,?]? "),
1314 reset_head => {
1315 mode => N__("Unstage mode change [y,n,q,a,d,/%s,?]? "),
1316 deletion => N__("Unstage deletion [y,n,q,a,d,/%s,?]? "),
1317 hunk => N__("Unstage this hunk [y,n,q,a,d,/%s,?]? "),
1319 reset_nothead => {
1320 mode => N__("Apply mode change to index [y,n,q,a,d,/%s,?]? "),
1321 deletion => N__("Apply deletion to index [y,n,q,a,d,/%s,?]? "),
1322 hunk => N__("Apply this hunk to index [y,n,q,a,d,/%s,?]? "),
1324 checkout_index => {
1325 mode => N__("Discard mode change from worktree [y,n,q,a,d,/%s,?]? "),
1326 deletion => N__("Discard deletion from worktree [y,n,q,a,d,/%s,?]? "),
1327 hunk => N__("Discard this hunk from worktree [y,n,q,a,d,/%s,?]? "),
1329 checkout_head => {
1330 mode => N__("Discard mode change from index and worktree [y,n,q,a,d,/%s,?]? "),
1331 deletion => N__("Discard deletion from index and worktree [y,n,q,a,d,/%s,?]? "),
1332 hunk => N__("Discard this hunk from index and worktree [y,n,q,a,d,/%s,?]? "),
1334 checkout_nothead => {
1335 mode => N__("Apply mode change to index and worktree [y,n,q,a,d,/%s,?]? "),
1336 deletion => N__("Apply deletion to index and worktree [y,n,q,a,d,/%s,?]? "),
1337 hunk => N__("Apply this hunk to index and worktree [y,n,q,a,d,/%s,?]? "),
1341 sub patch_update_file {
1342 my $quit = 0;
1343 my ($ix, $num);
1344 my $path = shift;
1345 my ($head, @hunk) = parse_diff($path);
1346 ($head, my $mode, my $deletion) = parse_diff_header($head);
1347 for (@{$head->{DISPLAY}}) {
1348 print;
1351 if (@{$mode->{TEXT}}) {
1352 unshift @hunk, $mode;
1354 if (@{$deletion->{TEXT}}) {
1355 foreach my $hunk (@hunk) {
1356 push @{$deletion->{TEXT}}, @{$hunk->{TEXT}};
1357 push @{$deletion->{DISPLAY}}, @{$hunk->{DISPLAY}};
1359 @hunk = ($deletion);
1362 $num = scalar @hunk;
1363 $ix = 0;
1365 while (1) {
1366 my ($prev, $next, $other, $undecided, $i);
1367 $other = '';
1369 if ($num <= $ix) {
1370 $ix = 0;
1372 for ($i = 0; $i < $ix; $i++) {
1373 if (!defined $hunk[$i]{USE}) {
1374 $prev = 1;
1375 $other .= ',k';
1376 last;
1379 if ($ix) {
1380 $other .= ',K';
1382 for ($i = $ix + 1; $i < $num; $i++) {
1383 if (!defined $hunk[$i]{USE}) {
1384 $next = 1;
1385 $other .= ',j';
1386 last;
1389 if ($ix < $num - 1) {
1390 $other .= ',J';
1392 if ($num > 1) {
1393 $other .= ',g';
1395 for ($i = 0; $i < $num; $i++) {
1396 if (!defined $hunk[$i]{USE}) {
1397 $undecided = 1;
1398 last;
1401 last if (!$undecided);
1403 if ($hunk[$ix]{TYPE} eq 'hunk' &&
1404 hunk_splittable($hunk[$ix]{TEXT})) {
1405 $other .= ',s';
1407 if ($hunk[$ix]{TYPE} eq 'hunk') {
1408 $other .= ',e';
1410 for (@{$hunk[$ix]{DISPLAY}}) {
1411 print;
1413 print colored $prompt_color,
1414 sprintf(__($patch_update_prompt_modes{$patch_mode}{$hunk[$ix]{TYPE}}), $other);
1416 my $line = prompt_single_character;
1417 last unless defined $line;
1418 if ($line) {
1419 if ($line =~ /^y/i) {
1420 $hunk[$ix]{USE} = 1;
1422 elsif ($line =~ /^n/i) {
1423 $hunk[$ix]{USE} = 0;
1425 elsif ($line =~ /^a/i) {
1426 while ($ix < $num) {
1427 if (!defined $hunk[$ix]{USE}) {
1428 $hunk[$ix]{USE} = 1;
1430 $ix++;
1432 next;
1434 elsif ($other =~ /g/ && $line =~ /^g(.*)/) {
1435 my $response = $1;
1436 my $no = $ix > 10 ? $ix - 10 : 0;
1437 while ($response eq '') {
1438 $no = display_hunks(\@hunk, $no);
1439 if ($no < $num) {
1440 print __("go to which hunk (<ret> to see more)? ");
1441 } else {
1442 print __("go to which hunk? ");
1444 $response = <STDIN>;
1445 if (!defined $response) {
1446 $response = '';
1448 chomp $response;
1450 if ($response !~ /^\s*\d+\s*$/) {
1451 error_msg sprintf(__("Invalid number: '%s'\n"),
1452 $response);
1453 } elsif (0 < $response && $response <= $num) {
1454 $ix = $response - 1;
1455 } else {
1456 error_msg sprintf(__n("Sorry, only %d hunk available.\n",
1457 "Sorry, only %d hunks available.\n", $num), $num);
1459 next;
1461 elsif ($line =~ /^d/i) {
1462 while ($ix < $num) {
1463 if (!defined $hunk[$ix]{USE}) {
1464 $hunk[$ix]{USE} = 0;
1466 $ix++;
1468 next;
1470 elsif ($line =~ /^q/i) {
1471 for ($i = 0; $i < $num; $i++) {
1472 if (!defined $hunk[$i]{USE}) {
1473 $hunk[$i]{USE} = 0;
1476 $quit = 1;
1477 last;
1479 elsif ($line =~ m|^/(.*)|) {
1480 my $regex = $1;
1481 if ($1 eq "") {
1482 print colored $prompt_color, __("search for regex? ");
1483 $regex = <STDIN>;
1484 if (defined $regex) {
1485 chomp $regex;
1488 my $search_string;
1489 eval {
1490 $search_string = qr{$regex}m;
1492 if ($@) {
1493 my ($err,$exp) = ($@, $1);
1494 $err =~ s/ at .*git-add--interactive line \d+, <STDIN> line \d+.*$//;
1495 error_msg sprintf(__("Malformed search regexp %s: %s\n"), $exp, $err);
1496 next;
1498 my $iy = $ix;
1499 while (1) {
1500 my $text = join ("", @{$hunk[$iy]{TEXT}});
1501 last if ($text =~ $search_string);
1502 $iy++;
1503 $iy = 0 if ($iy >= $num);
1504 if ($ix == $iy) {
1505 error_msg __("No hunk matches the given pattern\n");
1506 last;
1509 $ix = $iy;
1510 next;
1512 elsif ($line =~ /^K/) {
1513 if ($other =~ /K/) {
1514 $ix--;
1516 else {
1517 error_msg __("No previous hunk\n");
1519 next;
1521 elsif ($line =~ /^J/) {
1522 if ($other =~ /J/) {
1523 $ix++;
1525 else {
1526 error_msg __("No next hunk\n");
1528 next;
1530 elsif ($line =~ /^k/) {
1531 if ($other =~ /k/) {
1532 while (1) {
1533 $ix--;
1534 last if (!$ix ||
1535 !defined $hunk[$ix]{USE});
1538 else {
1539 error_msg __("No previous hunk\n");
1541 next;
1543 elsif ($line =~ /^j/) {
1544 if ($other !~ /j/) {
1545 error_msg __("No next hunk\n");
1546 next;
1549 elsif ($other =~ /s/ && $line =~ /^s/) {
1550 my @split = split_hunk($hunk[$ix]{TEXT}, $hunk[$ix]{DISPLAY});
1551 if (1 < @split) {
1552 print colored $header_color, sprintf(
1553 __n("Split into %d hunk.\n",
1554 "Split into %d hunks.\n",
1555 scalar(@split)), scalar(@split));
1557 splice (@hunk, $ix, 1, @split);
1558 $num = scalar @hunk;
1559 next;
1561 elsif ($other =~ /e/ && $line =~ /^e/) {
1562 my $newhunk = edit_hunk_loop($head, \@hunk, $ix);
1563 if (defined $newhunk) {
1564 splice @hunk, $ix, 1, $newhunk;
1567 else {
1568 help_patch_cmd($other);
1569 next;
1571 # soft increment
1572 while (1) {
1573 $ix++;
1574 last if ($ix >= $num ||
1575 !defined $hunk[$ix]{USE});
1580 @hunk = coalesce_overlapping_hunks(@hunk);
1582 my $n_lofs = 0;
1583 my @result = ();
1584 for (@hunk) {
1585 if ($_->{USE}) {
1586 push @result, @{$_->{TEXT}};
1590 if (@result) {
1591 my @patch = reassemble_patch($head->{TEXT}, @result);
1592 my $apply_routine = $patch_mode_flavour{APPLY};
1593 &$apply_routine(@patch);
1594 refresh();
1597 print "\n";
1598 return $quit;
1601 sub diff_cmd {
1602 my @mods = list_modified('index-only');
1603 @mods = grep { !($_->{BINARY}) } @mods;
1604 return if (!@mods);
1605 my (@them) = list_and_choose({ PROMPT => __('Review diff'),
1606 IMMEDIATE => 1,
1607 HEADER => $status_head, },
1608 @mods);
1609 return if (!@them);
1610 my $reference = (is_initial_commit()) ? get_empty_tree() : 'HEAD';
1611 system(qw(git diff -p --cached), $reference, '--',
1612 map { $_->{VALUE} } @them);
1615 sub quit_cmd {
1616 print __("Bye.\n");
1617 exit(0);
1620 sub help_cmd {
1621 # TRANSLATORS: please do not translate the command names
1622 # 'status', 'update', 'revert', etc.
1623 print colored $help_color, __ <<'EOF' ;
1624 status - show paths with changes
1625 update - add working tree state to the staged set of changes
1626 revert - revert staged set of changes back to the HEAD version
1627 patch - pick hunks and update selectively
1628 diff - view diff between HEAD and index
1629 add untracked - add contents of untracked files to the staged set of changes
1633 sub process_args {
1634 return unless @ARGV;
1635 my $arg = shift @ARGV;
1636 if ($arg =~ /--patch(?:=(.*))?/) {
1637 if (defined $1) {
1638 if ($1 eq 'reset') {
1639 $patch_mode = 'reset_head';
1640 $patch_mode_revision = 'HEAD';
1641 $arg = shift @ARGV or die __("missing --");
1642 if ($arg ne '--') {
1643 $patch_mode_revision = $arg;
1644 $patch_mode = ($arg eq 'HEAD' ?
1645 'reset_head' : 'reset_nothead');
1646 $arg = shift @ARGV or die __("missing --");
1648 } elsif ($1 eq 'checkout') {
1649 $arg = shift @ARGV or die __("missing --");
1650 if ($arg eq '--') {
1651 $patch_mode = 'checkout_index';
1652 } else {
1653 $patch_mode_revision = $arg;
1654 $patch_mode = ($arg eq 'HEAD' ?
1655 'checkout_head' : 'checkout_nothead');
1656 $arg = shift @ARGV or die __("missing --");
1658 } elsif ($1 eq 'stage' or $1 eq 'stash') {
1659 $patch_mode = $1;
1660 $arg = shift @ARGV or die __("missing --");
1661 } else {
1662 die sprintf(__("unknown --patch mode: %s"), $1);
1664 } else {
1665 $patch_mode = 'stage';
1666 $arg = shift @ARGV or die __("missing --");
1668 die sprintf(__("invalid argument %s, expecting --"),
1669 $arg) unless $arg eq "--";
1670 %patch_mode_flavour = %{$patch_modes{$patch_mode}};
1671 $patch_mode_only = 1;
1673 elsif ($arg ne "--") {
1674 die sprintf(__("invalid argument %s, expecting --"), $arg);
1678 sub main_loop {
1679 my @cmd = ([ 'status', \&status_cmd, ],
1680 [ 'update', \&update_cmd, ],
1681 [ 'revert', \&revert_cmd, ],
1682 [ 'add untracked', \&add_untracked_cmd, ],
1683 [ 'patch', \&patch_update_cmd, ],
1684 [ 'diff', \&diff_cmd, ],
1685 [ 'quit', \&quit_cmd, ],
1686 [ 'help', \&help_cmd, ],
1688 while (1) {
1689 my ($it) = list_and_choose({ PROMPT => __('What now'),
1690 SINGLETON => 1,
1691 LIST_FLAT => 4,
1692 HEADER => __('*** Commands ***'),
1693 ON_EOF => \&quit_cmd,
1694 IMMEDIATE => 1 }, @cmd);
1695 if ($it) {
1696 eval {
1697 $it->[1]->();
1699 if ($@) {
1700 print "$@";
1706 process_args();
1707 refresh();
1708 if ($patch_mode_only) {
1709 patch_update_cmd();
1711 else {
1712 status_cmd();
1713 main_loop();