Make "index_name_exists()" return the cache_entry it found
[git/dscho.git] / git-add--interactive.perl
blob903953e68e98535e754b5a5dd6ba22eb6074ef20
1 #!/usr/bin/perl -w
3 use strict;
4 use Git;
6 my $repo = Git->repository();
8 my $menu_use_color = $repo->get_colorbool('color.interactive');
9 my ($prompt_color, $header_color, $help_color) =
10 $menu_use_color ? (
11 $repo->get_color('color.interactive.prompt', 'bold blue'),
12 $repo->get_color('color.interactive.header', 'bold'),
13 $repo->get_color('color.interactive.help', 'red bold'),
14 ) : ();
16 my $diff_use_color = $repo->get_colorbool('color.diff');
17 my ($fraginfo_color) =
18 $diff_use_color ? (
19 $repo->get_color('color.diff.frag', 'cyan'),
20 ) : ();
22 my $normal_color = $repo->get_color("", "reset");
24 sub colored {
25 my $color = shift;
26 my $string = join("", @_);
28 if (defined $color) {
29 # Put a color code at the beginning of each line, a reset at the end
30 # color after newlines that are not at the end of the string
31 $string =~ s/(\n+)(.)/$1$color$2/g;
32 # reset before newlines
33 $string =~ s/(\n+)/$normal_color$1/g;
34 # codes at beginning and end (if necessary):
35 $string =~ s/^/$color/;
36 $string =~ s/$/$normal_color/ unless $string =~ /\n$/;
38 return $string;
41 # command line options
42 my $patch_mode;
44 sub run_cmd_pipe {
45 if ($^O eq 'MSWin32') {
46 my @invalid = grep {m/[":*]/} @_;
47 die "$^O does not support: @invalid\n" if @invalid;
48 my @args = map { m/ /o ? "\"$_\"": $_ } @_;
49 return qx{@args};
50 } else {
51 my $fh = undef;
52 open($fh, '-|', @_) or die;
53 return <$fh>;
57 my ($GIT_DIR) = run_cmd_pipe(qw(git rev-parse --git-dir));
59 if (!defined $GIT_DIR) {
60 exit(1); # rev-parse would have already said "not a git repo"
62 chomp($GIT_DIR);
64 sub refresh {
65 my $fh;
66 open $fh, 'git update-index --refresh |'
67 or die;
68 while (<$fh>) {
69 ;# ignore 'needs update'
71 close $fh;
74 sub list_untracked {
75 map {
76 chomp $_;
77 $_;
79 run_cmd_pipe(qw(git ls-files --others --exclude-standard --), @ARGV);
82 my $status_fmt = '%12s %12s %s';
83 my $status_head = sprintf($status_fmt, 'staged', 'unstaged', 'path');
86 my $initial;
87 sub is_initial_commit {
88 $initial = system('git rev-parse HEAD -- >/dev/null 2>&1') != 0
89 unless defined $initial;
90 return $initial;
94 sub get_empty_tree {
95 return '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
98 # Returns list of hashes, contents of each of which are:
99 # VALUE: pathname
100 # BINARY: is a binary path
101 # INDEX: is index different from HEAD?
102 # FILE: is file different from index?
103 # INDEX_ADDDEL: is it add/delete between HEAD and index?
104 # FILE_ADDDEL: is it add/delete between index and file?
106 sub list_modified {
107 my ($only) = @_;
108 my (%data, @return);
109 my ($add, $del, $adddel, $file);
110 my @tracked = ();
112 if (@ARGV) {
113 @tracked = map {
114 chomp $_; $_;
115 } run_cmd_pipe(qw(git ls-files --exclude-standard --), @ARGV);
116 return if (!@tracked);
119 my $reference = is_initial_commit() ? get_empty_tree() : 'HEAD';
120 for (run_cmd_pipe(qw(git diff-index --cached
121 --numstat --summary), $reference,
122 '--', @tracked)) {
123 if (($add, $del, $file) =
124 /^([-\d]+) ([-\d]+) (.*)/) {
125 my ($change, $bin);
126 if ($add eq '-' && $del eq '-') {
127 $change = 'binary';
128 $bin = 1;
130 else {
131 $change = "+$add/-$del";
133 $data{$file} = {
134 INDEX => $change,
135 BINARY => $bin,
136 FILE => 'nothing',
139 elsif (($adddel, $file) =
140 /^ (create|delete) mode [0-7]+ (.*)$/) {
141 $data{$file}{INDEX_ADDDEL} = $adddel;
145 for (run_cmd_pipe(qw(git diff-files --numstat --summary --), @tracked)) {
146 if (($add, $del, $file) =
147 /^([-\d]+) ([-\d]+) (.*)/) {
148 if (!exists $data{$file}) {
149 $data{$file} = +{
150 INDEX => 'unchanged',
151 BINARY => 0,
154 my ($change, $bin);
155 if ($add eq '-' && $del eq '-') {
156 $change = 'binary';
157 $bin = 1;
159 else {
160 $change = "+$add/-$del";
162 $data{$file}{FILE} = $change;
163 if ($bin) {
164 $data{$file}{BINARY} = 1;
167 elsif (($adddel, $file) =
168 /^ (create|delete) mode [0-7]+ (.*)$/) {
169 $data{$file}{FILE_ADDDEL} = $adddel;
173 for (sort keys %data) {
174 my $it = $data{$_};
176 if ($only) {
177 if ($only eq 'index-only') {
178 next if ($it->{INDEX} eq 'unchanged');
180 if ($only eq 'file-only') {
181 next if ($it->{FILE} eq 'nothing');
184 push @return, +{
185 VALUE => $_,
186 %$it,
189 return @return;
192 sub find_unique {
193 my ($string, @stuff) = @_;
194 my $found = undef;
195 for (my $i = 0; $i < @stuff; $i++) {
196 my $it = $stuff[$i];
197 my $hit = undef;
198 if (ref $it) {
199 if ((ref $it) eq 'ARRAY') {
200 $it = $it->[0];
202 else {
203 $it = $it->{VALUE};
206 eval {
207 if ($it =~ /^$string/) {
208 $hit = 1;
211 if (defined $hit && defined $found) {
212 return undef;
214 if ($hit) {
215 $found = $i + 1;
218 return $found;
221 # inserts string into trie and updates count for each character
222 sub update_trie {
223 my ($trie, $string) = @_;
224 foreach (split //, $string) {
225 $trie = $trie->{$_} ||= {COUNT => 0};
226 $trie->{COUNT}++;
230 # returns an array of tuples (prefix, remainder)
231 sub find_unique_prefixes {
232 my @stuff = @_;
233 my @return = ();
235 # any single prefix exceeding the soft limit is omitted
236 # if any prefix exceeds the hard limit all are omitted
237 # 0 indicates no limit
238 my $soft_limit = 0;
239 my $hard_limit = 3;
241 # build a trie modelling all possible options
242 my %trie;
243 foreach my $print (@stuff) {
244 if ((ref $print) eq 'ARRAY') {
245 $print = $print->[0];
247 elsif ((ref $print) eq 'HASH') {
248 $print = $print->{VALUE};
250 update_trie(\%trie, $print);
251 push @return, $print;
254 # use the trie to find the unique prefixes
255 for (my $i = 0; $i < @return; $i++) {
256 my $ret = $return[$i];
257 my @letters = split //, $ret;
258 my %search = %trie;
259 my ($prefix, $remainder);
260 my $j;
261 for ($j = 0; $j < @letters; $j++) {
262 my $letter = $letters[$j];
263 if ($search{$letter}{COUNT} == 1) {
264 $prefix = substr $ret, 0, $j + 1;
265 $remainder = substr $ret, $j + 1;
266 last;
268 else {
269 my $prefix = substr $ret, 0, $j;
270 return ()
271 if ($hard_limit && $j + 1 > $hard_limit);
273 %search = %{$search{$letter}};
275 if ($soft_limit && $j + 1 > $soft_limit) {
276 $prefix = undef;
277 $remainder = $ret;
279 $return[$i] = [$prefix, $remainder];
281 return @return;
284 # filters out prefixes which have special meaning to list_and_choose()
285 sub is_valid_prefix {
286 my $prefix = shift;
287 return (defined $prefix) &&
288 !($prefix =~ /[\s,]/) && # separators
289 !($prefix =~ /^-/) && # deselection
290 !($prefix =~ /^\d+/) && # selection
291 ($prefix ne '*') && # "all" wildcard
292 ($prefix ne '?'); # prompt help
295 # given a prefix/remainder tuple return a string with the prefix highlighted
296 # for now use square brackets; later might use ANSI colors (underline, bold)
297 sub highlight_prefix {
298 my $prefix = shift;
299 my $remainder = shift;
301 if (!defined $prefix) {
302 return $remainder;
305 if (!is_valid_prefix($prefix)) {
306 return "$prefix$remainder";
309 if (!$menu_use_color) {
310 return "[$prefix]$remainder";
313 return "$prompt_color$prefix$normal_color$remainder";
316 sub list_and_choose {
317 my ($opts, @stuff) = @_;
318 my (@chosen, @return);
319 my $i;
320 my @prefixes = find_unique_prefixes(@stuff) unless $opts->{LIST_ONLY};
322 TOPLOOP:
323 while (1) {
324 my $last_lf = 0;
326 if ($opts->{HEADER}) {
327 if (!$opts->{LIST_FLAT}) {
328 print " ";
330 print colored $header_color, "$opts->{HEADER}\n";
332 for ($i = 0; $i < @stuff; $i++) {
333 my $chosen = $chosen[$i] ? '*' : ' ';
334 my $print = $stuff[$i];
335 my $ref = ref $print;
336 my $highlighted = highlight_prefix(@{$prefixes[$i]})
337 if @prefixes;
338 if ($ref eq 'ARRAY') {
339 $print = $highlighted || $print->[0];
341 elsif ($ref eq 'HASH') {
342 my $value = $highlighted || $print->{VALUE};
343 $print = sprintf($status_fmt,
344 $print->{INDEX},
345 $print->{FILE},
346 $value);
348 else {
349 $print = $highlighted || $print;
351 printf("%s%2d: %s", $chosen, $i+1, $print);
352 if (($opts->{LIST_FLAT}) &&
353 (($i + 1) % ($opts->{LIST_FLAT}))) {
354 print "\t";
355 $last_lf = 0;
357 else {
358 print "\n";
359 $last_lf = 1;
362 if (!$last_lf) {
363 print "\n";
366 return if ($opts->{LIST_ONLY});
368 print colored $prompt_color, $opts->{PROMPT};
369 if ($opts->{SINGLETON}) {
370 print "> ";
372 else {
373 print ">> ";
375 my $line = <STDIN>;
376 if (!$line) {
377 print "\n";
378 $opts->{ON_EOF}->() if $opts->{ON_EOF};
379 last;
381 chomp $line;
382 last if $line eq '';
383 if ($line eq '?') {
384 $opts->{SINGLETON} ?
385 singleton_prompt_help_cmd() :
386 prompt_help_cmd();
387 next TOPLOOP;
389 for my $choice (split(/[\s,]+/, $line)) {
390 my $choose = 1;
391 my ($bottom, $top);
393 # Input that begins with '-'; unchoose
394 if ($choice =~ s/^-//) {
395 $choose = 0;
397 # A range can be specified like 5-7
398 if ($choice =~ /^(\d+)-(\d+)$/) {
399 ($bottom, $top) = ($1, $2);
401 elsif ($choice =~ /^\d+$/) {
402 $bottom = $top = $choice;
404 elsif ($choice eq '*') {
405 $bottom = 1;
406 $top = 1 + @stuff;
408 else {
409 $bottom = $top = find_unique($choice, @stuff);
410 if (!defined $bottom) {
411 print "Huh ($choice)?\n";
412 next TOPLOOP;
415 if ($opts->{SINGLETON} && $bottom != $top) {
416 print "Huh ($choice)?\n";
417 next TOPLOOP;
419 for ($i = $bottom-1; $i <= $top-1; $i++) {
420 next if (@stuff <= $i || $i < 0);
421 $chosen[$i] = $choose;
424 last if ($opts->{IMMEDIATE} || $line eq '*');
426 for ($i = 0; $i < @stuff; $i++) {
427 if ($chosen[$i]) {
428 push @return, $stuff[$i];
431 return @return;
434 sub singleton_prompt_help_cmd {
435 print colored $help_color, <<\EOF ;
436 Prompt help:
437 1 - select a numbered item
438 foo - select item based on unique prefix
439 - (empty) select nothing
443 sub prompt_help_cmd {
444 print colored $help_color, <<\EOF ;
445 Prompt help:
446 1 - select a single item
447 3-5 - select a range of items
448 2-3,6-9 - select multiple ranges
449 foo - select item based on unique prefix
450 -... - unselect specified items
451 * - choose all items
452 - (empty) finish selecting
456 sub status_cmd {
457 list_and_choose({ LIST_ONLY => 1, HEADER => $status_head },
458 list_modified());
459 print "\n";
462 sub say_n_paths {
463 my $did = shift @_;
464 my $cnt = scalar @_;
465 print "$did ";
466 if (1 < $cnt) {
467 print "$cnt paths\n";
469 else {
470 print "one path\n";
474 sub update_cmd {
475 my @mods = list_modified('file-only');
476 return if (!@mods);
478 my @update = list_and_choose({ PROMPT => 'Update',
479 HEADER => $status_head, },
480 @mods);
481 if (@update) {
482 system(qw(git update-index --add --remove --),
483 map { $_->{VALUE} } @update);
484 say_n_paths('updated', @update);
486 print "\n";
489 sub revert_cmd {
490 my @update = list_and_choose({ PROMPT => 'Revert',
491 HEADER => $status_head, },
492 list_modified());
493 if (@update) {
494 if (is_initial_commit()) {
495 system(qw(git rm --cached),
496 map { $_->{VALUE} } @update);
498 else {
499 my @lines = run_cmd_pipe(qw(git ls-tree HEAD --),
500 map { $_->{VALUE} } @update);
501 my $fh;
502 open $fh, '| git update-index --index-info'
503 or die;
504 for (@lines) {
505 print $fh $_;
507 close($fh);
508 for (@update) {
509 if ($_->{INDEX_ADDDEL} &&
510 $_->{INDEX_ADDDEL} eq 'create') {
511 system(qw(git update-index --force-remove --),
512 $_->{VALUE});
513 print "note: $_->{VALUE} is untracked now.\n";
517 refresh();
518 say_n_paths('reverted', @update);
520 print "\n";
523 sub add_untracked_cmd {
524 my @add = list_and_choose({ PROMPT => 'Add untracked' },
525 list_untracked());
526 if (@add) {
527 system(qw(git update-index --add --), @add);
528 say_n_paths('added', @add);
530 print "\n";
533 sub parse_diff {
534 my ($path) = @_;
535 my @diff = run_cmd_pipe(qw(git diff-files -p --), $path);
536 my @colored = ();
537 if ($diff_use_color) {
538 @colored = run_cmd_pipe(qw(git diff-files -p --color --), $path);
540 my (@hunk) = { TEXT => [], DISPLAY => [] };
542 for (my $i = 0; $i < @diff; $i++) {
543 if ($diff[$i] =~ /^@@ /) {
544 push @hunk, { TEXT => [], DISPLAY => [] };
546 push @{$hunk[-1]{TEXT}}, $diff[$i];
547 push @{$hunk[-1]{DISPLAY}},
548 ($diff_use_color ? $colored[$i] : $diff[$i]);
550 return @hunk;
553 sub parse_diff_header {
554 my $src = shift;
556 my $head = { TEXT => [], DISPLAY => [] };
557 my $mode = { TEXT => [], DISPLAY => [] };
559 for (my $i = 0; $i < @{$src->{TEXT}}; $i++) {
560 my $dest = $src->{TEXT}->[$i] =~ /^(old|new) mode (\d+)$/ ?
561 $mode : $head;
562 push @{$dest->{TEXT}}, $src->{TEXT}->[$i];
563 push @{$dest->{DISPLAY}}, $src->{DISPLAY}->[$i];
565 return ($head, $mode);
568 sub hunk_splittable {
569 my ($text) = @_;
571 my @s = split_hunk($text);
572 return (1 < @s);
575 sub parse_hunk_header {
576 my ($line) = @_;
577 my ($o_ofs, $o_cnt, $n_ofs, $n_cnt) =
578 $line =~ /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
579 $o_cnt = 1 unless defined $o_cnt;
580 $n_cnt = 1 unless defined $n_cnt;
581 return ($o_ofs, $o_cnt, $n_ofs, $n_cnt);
584 sub split_hunk {
585 my ($text, $display) = @_;
586 my @split = ();
587 if (!defined $display) {
588 $display = $text;
590 # If there are context lines in the middle of a hunk,
591 # it can be split, but we would need to take care of
592 # overlaps later.
594 my ($o_ofs, undef, $n_ofs) = parse_hunk_header($text->[0]);
595 my $hunk_start = 1;
597 OUTER:
598 while (1) {
599 my $next_hunk_start = undef;
600 my $i = $hunk_start - 1;
601 my $this = +{
602 TEXT => [],
603 DISPLAY => [],
604 OLD => $o_ofs,
605 NEW => $n_ofs,
606 OCNT => 0,
607 NCNT => 0,
608 ADDDEL => 0,
609 POSTCTX => 0,
610 USE => undef,
613 while (++$i < @$text) {
614 my $line = $text->[$i];
615 my $display = $display->[$i];
616 if ($line =~ /^ /) {
617 if ($this->{ADDDEL} &&
618 !defined $next_hunk_start) {
619 # We have seen leading context and
620 # adds/dels and then here is another
621 # context, which is trailing for this
622 # split hunk and leading for the next
623 # one.
624 $next_hunk_start = $i;
626 push @{$this->{TEXT}}, $line;
627 push @{$this->{DISPLAY}}, $display;
628 $this->{OCNT}++;
629 $this->{NCNT}++;
630 if (defined $next_hunk_start) {
631 $this->{POSTCTX}++;
633 next;
636 # add/del
637 if (defined $next_hunk_start) {
638 # We are done with the current hunk and
639 # this is the first real change for the
640 # next split one.
641 $hunk_start = $next_hunk_start;
642 $o_ofs = $this->{OLD} + $this->{OCNT};
643 $n_ofs = $this->{NEW} + $this->{NCNT};
644 $o_ofs -= $this->{POSTCTX};
645 $n_ofs -= $this->{POSTCTX};
646 push @split, $this;
647 redo OUTER;
649 push @{$this->{TEXT}}, $line;
650 push @{$this->{DISPLAY}}, $display;
651 $this->{ADDDEL}++;
652 if ($line =~ /^-/) {
653 $this->{OCNT}++;
655 else {
656 $this->{NCNT}++;
660 push @split, $this;
661 last;
664 for my $hunk (@split) {
665 $o_ofs = $hunk->{OLD};
666 $n_ofs = $hunk->{NEW};
667 my $o_cnt = $hunk->{OCNT};
668 my $n_cnt = $hunk->{NCNT};
670 my $head = ("@@ -$o_ofs" .
671 (($o_cnt != 1) ? ",$o_cnt" : '') .
672 " +$n_ofs" .
673 (($n_cnt != 1) ? ",$n_cnt" : '') .
674 " @@\n");
675 my $display_head = $head;
676 unshift @{$hunk->{TEXT}}, $head;
677 if ($diff_use_color) {
678 $display_head = colored($fraginfo_color, $head);
680 unshift @{$hunk->{DISPLAY}}, $display_head;
682 return @split;
685 sub find_last_o_ctx {
686 my ($it) = @_;
687 my $text = $it->{TEXT};
688 my ($o_ofs, $o_cnt) = parse_hunk_header($text->[0]);
689 my $i = @{$text};
690 my $last_o_ctx = $o_ofs + $o_cnt;
691 while (0 < --$i) {
692 my $line = $text->[$i];
693 if ($line =~ /^ /) {
694 $last_o_ctx--;
695 next;
697 last;
699 return $last_o_ctx;
702 sub merge_hunk {
703 my ($prev, $this) = @_;
704 my ($o0_ofs, $o0_cnt, $n0_ofs, $n0_cnt) =
705 parse_hunk_header($prev->{TEXT}[0]);
706 my ($o1_ofs, $o1_cnt, $n1_ofs, $n1_cnt) =
707 parse_hunk_header($this->{TEXT}[0]);
709 my (@line, $i, $ofs, $o_cnt, $n_cnt);
710 $ofs = $o0_ofs;
711 $o_cnt = $n_cnt = 0;
712 for ($i = 1; $i < @{$prev->{TEXT}}; $i++) {
713 my $line = $prev->{TEXT}[$i];
714 if ($line =~ /^\+/) {
715 $n_cnt++;
716 push @line, $line;
717 next;
720 last if ($o1_ofs <= $ofs);
722 $o_cnt++;
723 $ofs++;
724 if ($line =~ /^ /) {
725 $n_cnt++;
727 push @line, $line;
730 for ($i = 1; $i < @{$this->{TEXT}}; $i++) {
731 my $line = $this->{TEXT}[$i];
732 if ($line =~ /^\+/) {
733 $n_cnt++;
734 push @line, $line;
735 next;
737 $ofs++;
738 $o_cnt++;
739 if ($line =~ /^ /) {
740 $n_cnt++;
742 push @line, $line;
744 my $head = ("@@ -$o0_ofs" .
745 (($o_cnt != 1) ? ",$o_cnt" : '') .
746 " +$n0_ofs" .
747 (($n_cnt != 1) ? ",$n_cnt" : '') .
748 " @@\n");
749 @{$prev->{TEXT}} = ($head, @line);
752 sub coalesce_overlapping_hunks {
753 my (@in) = @_;
754 my @out = ();
756 my ($last_o_ctx);
758 for (grep { $_->{USE} } @in) {
759 my $text = $_->{TEXT};
760 my ($o_ofs) = parse_hunk_header($text->[0]);
761 if (defined $last_o_ctx &&
762 $o_ofs <= $last_o_ctx) {
763 merge_hunk($out[-1], $_);
765 else {
766 push @out, $_;
768 $last_o_ctx = find_last_o_ctx($out[-1]);
770 return @out;
773 sub help_patch_cmd {
774 print colored $help_color, <<\EOF ;
775 y - stage this hunk
776 n - do not stage this hunk
777 a - stage this and all the remaining hunks in the file
778 d - do not stage this hunk nor any of the remaining hunks in the file
779 j - leave this hunk undecided, see next undecided hunk
780 J - leave this hunk undecided, see next hunk
781 k - leave this hunk undecided, see previous undecided hunk
782 K - leave this hunk undecided, see previous hunk
783 s - split the current hunk into smaller hunks
784 ? - print help
788 sub patch_update_cmd {
789 my @mods = grep { !($_->{BINARY}) } list_modified('file-only');
790 my @them;
792 if (!@mods) {
793 print STDERR "No changes.\n";
794 return 0;
796 if ($patch_mode) {
797 @them = @mods;
799 else {
800 @them = list_and_choose({ PROMPT => 'Patch update',
801 HEADER => $status_head, },
802 @mods);
804 for (@them) {
805 patch_update_file($_->{VALUE});
809 sub patch_update_file {
810 my ($ix, $num);
811 my $path = shift;
812 my ($head, @hunk) = parse_diff($path);
813 ($head, my $mode) = parse_diff_header($head);
814 for (@{$head->{DISPLAY}}) {
815 print;
818 if (@{$mode->{TEXT}}) {
819 while (1) {
820 print @{$mode->{DISPLAY}};
821 print colored $prompt_color,
822 "Stage mode change [y/n/a/d/?]? ";
823 my $line = <STDIN>;
824 if ($line =~ /^y/i) {
825 $mode->{USE} = 1;
826 last;
828 elsif ($line =~ /^n/i) {
829 $mode->{USE} = 0;
830 last;
832 elsif ($line =~ /^a/i) {
833 $_->{USE} = 1 foreach ($mode, @hunk);
834 last;
836 elsif ($line =~ /^d/i) {
837 $_->{USE} = 0 foreach ($mode, @hunk);
838 last;
840 else {
841 help_patch_cmd('');
842 next;
847 $num = scalar @hunk;
848 $ix = 0;
850 while (1) {
851 my ($prev, $next, $other, $undecided, $i);
852 $other = '';
854 if ($num <= $ix) {
855 $ix = 0;
857 for ($i = 0; $i < $ix; $i++) {
858 if (!defined $hunk[$i]{USE}) {
859 $prev = 1;
860 $other .= '/k';
861 last;
864 if ($ix) {
865 $other .= '/K';
867 for ($i = $ix + 1; $i < $num; $i++) {
868 if (!defined $hunk[$i]{USE}) {
869 $next = 1;
870 $other .= '/j';
871 last;
874 if ($ix < $num - 1) {
875 $other .= '/J';
877 for ($i = 0; $i < $num; $i++) {
878 if (!defined $hunk[$i]{USE}) {
879 $undecided = 1;
880 last;
883 last if (!$undecided);
885 if (hunk_splittable($hunk[$ix]{TEXT})) {
886 $other .= '/s';
888 for (@{$hunk[$ix]{DISPLAY}}) {
889 print;
891 print colored $prompt_color, "Stage this hunk [y/n/a/d$other/?]? ";
892 my $line = <STDIN>;
893 if ($line) {
894 if ($line =~ /^y/i) {
895 $hunk[$ix]{USE} = 1;
897 elsif ($line =~ /^n/i) {
898 $hunk[$ix]{USE} = 0;
900 elsif ($line =~ /^a/i) {
901 while ($ix < $num) {
902 if (!defined $hunk[$ix]{USE}) {
903 $hunk[$ix]{USE} = 1;
905 $ix++;
907 next;
909 elsif ($line =~ /^d/i) {
910 while ($ix < $num) {
911 if (!defined $hunk[$ix]{USE}) {
912 $hunk[$ix]{USE} = 0;
914 $ix++;
916 next;
918 elsif ($other =~ /K/ && $line =~ /^K/) {
919 $ix--;
920 next;
922 elsif ($other =~ /J/ && $line =~ /^J/) {
923 $ix++;
924 next;
926 elsif ($other =~ /k/ && $line =~ /^k/) {
927 while (1) {
928 $ix--;
929 last if (!$ix ||
930 !defined $hunk[$ix]{USE});
932 next;
934 elsif ($other =~ /j/ && $line =~ /^j/) {
935 while (1) {
936 $ix++;
937 last if ($ix >= $num ||
938 !defined $hunk[$ix]{USE});
940 next;
942 elsif ($other =~ /s/ && $line =~ /^s/) {
943 my @split = split_hunk($hunk[$ix]{TEXT}, $hunk[$ix]{DISPLAY});
944 if (1 < @split) {
945 print colored $header_color, "Split into ",
946 scalar(@split), " hunks.\n";
948 splice (@hunk, $ix, 1, @split);
949 $num = scalar @hunk;
950 next;
952 else {
953 help_patch_cmd($other);
954 next;
956 # soft increment
957 while (1) {
958 $ix++;
959 last if ($ix >= $num ||
960 !defined $hunk[$ix]{USE});
965 @hunk = coalesce_overlapping_hunks(@hunk);
967 my $n_lofs = 0;
968 my @result = ();
969 if ($mode->{USE}) {
970 push @result, @{$mode->{TEXT}};
972 for (@hunk) {
973 my $text = $_->{TEXT};
974 my ($o_ofs, $o_cnt, $n_ofs, $n_cnt) =
975 parse_hunk_header($text->[0]);
977 if (!$_->{USE}) {
978 # We would have added ($n_cnt - $o_cnt) lines
979 # to the postimage if we were to use this hunk,
980 # but we didn't. So the line number that the next
981 # hunk starts at would be shifted by that much.
982 $n_lofs -= ($n_cnt - $o_cnt);
983 next;
985 else {
986 if ($n_lofs) {
987 $n_ofs += $n_lofs;
988 $text->[0] = ("@@ -$o_ofs" .
989 (($o_cnt != 1)
990 ? ",$o_cnt" : '') .
991 " +$n_ofs" .
992 (($n_cnt != 1)
993 ? ",$n_cnt" : '') .
994 " @@\n");
996 for (@$text) {
997 push @result, $_;
1002 if (@result) {
1003 my $fh;
1005 open $fh, '| git apply --cached';
1006 for (@{$head->{TEXT}}, @result) {
1007 print $fh $_;
1009 if (!close $fh) {
1010 for (@{$head->{TEXT}}, @result) {
1011 print STDERR $_;
1014 refresh();
1017 print "\n";
1020 sub diff_cmd {
1021 my @mods = list_modified('index-only');
1022 @mods = grep { !($_->{BINARY}) } @mods;
1023 return if (!@mods);
1024 my (@them) = list_and_choose({ PROMPT => 'Review diff',
1025 IMMEDIATE => 1,
1026 HEADER => $status_head, },
1027 @mods);
1028 return if (!@them);
1029 my $reference = is_initial_commit() ? get_empty_tree() : 'HEAD';
1030 system(qw(git diff -p --cached), $reference, '--',
1031 map { $_->{VALUE} } @them);
1034 sub quit_cmd {
1035 print "Bye.\n";
1036 exit(0);
1039 sub help_cmd {
1040 print colored $help_color, <<\EOF ;
1041 status - show paths with changes
1042 update - add working tree state to the staged set of changes
1043 revert - revert staged set of changes back to the HEAD version
1044 patch - pick hunks and update selectively
1045 diff - view diff between HEAD and index
1046 add untracked - add contents of untracked files to the staged set of changes
1050 sub process_args {
1051 return unless @ARGV;
1052 my $arg = shift @ARGV;
1053 if ($arg eq "--patch") {
1054 $patch_mode = 1;
1055 $arg = shift @ARGV or die "missing --";
1056 die "invalid argument $arg, expecting --"
1057 unless $arg eq "--";
1059 elsif ($arg ne "--") {
1060 die "invalid argument $arg, expecting --";
1064 sub main_loop {
1065 my @cmd = ([ 'status', \&status_cmd, ],
1066 [ 'update', \&update_cmd, ],
1067 [ 'revert', \&revert_cmd, ],
1068 [ 'add untracked', \&add_untracked_cmd, ],
1069 [ 'patch', \&patch_update_cmd, ],
1070 [ 'diff', \&diff_cmd, ],
1071 [ 'quit', \&quit_cmd, ],
1072 [ 'help', \&help_cmd, ],
1074 while (1) {
1075 my ($it) = list_and_choose({ PROMPT => 'What now',
1076 SINGLETON => 1,
1077 LIST_FLAT => 4,
1078 HEADER => '*** Commands ***',
1079 ON_EOF => \&quit_cmd,
1080 IMMEDIATE => 1 }, @cmd);
1081 if ($it) {
1082 eval {
1083 $it->[1]->();
1085 if ($@) {
1086 print "$@";
1092 process_args();
1093 refresh();
1094 if ($patch_mode) {
1095 patch_update_cmd();
1097 else {
1098 status_cmd();
1099 main_loop();