git.oblomov.eu Git - git/blob - git-add--interactive.perl

   1 #!/usr/bin/perl
   2
   3 use 5.008;
   4 use strict;
   5 use warnings;
   6 use Git qw(unquote_path);
   7 use Git::I18N;
   8
   9 binmode(STDOUT, ":raw");
  10
  11 my $repo = Git->repository();
  12
  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);
  26 }
  27
  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         ) : ();
  45
  46 my $normal_color = $repo->get_color("", "reset");
  47
  48 my $diff_algorithm = $repo->config('diff.algorithm');
  49 my $diff_filter = $repo->config('interactive.difffilter');
  50
  51 my $use_readkey = 0;
  52 my $use_termcap = 0;
  53 my %term_escapes;
  54
  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;
  62         };
  63         if (!$use_readkey) {
  64                 print STDERR "missing Term::ReadKey, disabling interactive.singlekey\n";
  65         }
  66         eval {
  67                 require Term::Cap;
  68                 my $termcap = Term::Cap->Tgetent;
  69                 foreach (values %$termcap) {
  70                         $term_escapes{$_} = 1 if /^\e/;
  71                 }
  72                 $use_termcap = 1;
  73         };
  74 }
  75
  76 sub colored {
  77         my $color = shift;
  78         my $string = join("", @_);
  79
  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$/;
  89         }
  90         return $string;
  91 }
  92
  93 # command line options
  94 my $patch_mode_only;
  95 my $patch_mode;
  96 my $patch_mode_revision;
  97
  98 sub apply_patch;
  99 sub apply_patch_for_checkout_commit;
 100 sub apply_patch_for_stash;
 101
 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,
 109         },
 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,
 116         },
 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,
 123         },
 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,
 130         },
 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,
 137         },
 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,
 144         },
 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,
 151         },
 152 );
 153
 154 $patch_mode = 'stage';
 155 my %patch_mode_flavour = %{$patch_modes{$patch_mode}};
 156
 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>;
 167         }
 168 }
 169
 170 my ($GIT_DIR) = run_cmd_pipe(qw(git rev-parse --git-dir));
 171
 172 if (!defined $GIT_DIR) {
 173         exit(1); # rev-parse would have already said "not a git repo"
 174 }
 175 chomp($GIT_DIR);
 176
 177 sub refresh {
 178         my $fh;
 179         open $fh, 'git update-index --refresh |'
 180             or die;
 181         while (<$fh>) {
 182                 ;# ignore 'needs update'
 183         }
 184         close $fh;
 185 }
 186
 187 sub list_untracked {
 188         map {
 189                 chomp $_;
 190                 unquote_path($_);
 191         }
 192         run_cmd_pipe(qw(git ls-files --others --exclude-standard --), @ARGV);
 193 }
 194
 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'));
 198
 199 {
 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;
 205         }
 206 }
 207
 208 sub get_empty_tree {
 209         return '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
 210 }
 211
 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';
 220         }
 221 }
 222
 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
 231
 232 sub list_modified {
 233         my ($only) = @_;
 234         my (%data, @return);
 235         my ($add, $del, $adddel, $file);
 236
 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;
 248                         }
 249                         else {
 250                                 $change = "+$add/-$del";
 251                         }
 252                         $data{$file} = {
 253                                 INDEX => $change,
 254                                 BINARY => $bin,
 255                                 FILE => __('nothing'),
 256                         }
 257                 }
 258                 elsif (($adddel, $file) =
 259                        /^ (create|delete) mode [0-7]+ (.*)$/) {
 260                         $file = unquote_path($file);
 261                         $data{$file}{INDEX_ADDDEL} = $adddel;
 262                 }
 263         }
 264
 265         for (run_cmd_pipe(qw(git diff-files --ignore-submodules=dirty --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;
 273                         }
 274                         else {
 275                                 $change = "+$add/-$del";
 276                         }
 277                         $data{$file}{FILE} = $change;
 278                         if ($bin) {
 279                                 $data{$file}{BINARY} = 1;
 280                         }
 281                 }
 282                 elsif (($adddel, $file) =
 283                        /^ (create|delete) mode [0-7]+ (.*)$/) {
 284                         $file = unquote_path($file);
 285                         $data{$file}{FILE_ADDDEL} = $adddel;
 286                 }
 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,
 293                                 };
 294                         }
 295                         if ($1 eq 'U') {
 296                                 $data{$file}{UNMERGED} = 1;
 297                         }
 298                 }
 299         }
 300
 301         for (sort keys %data) {
 302                 my $it = $data{$_};
 303
 304                 if ($only) {
 305                         if ($only eq 'index-only') {
 306                                 next if ($it->{INDEX} eq __('unchanged'));
 307                         }
 308                         if ($only eq 'file-only') {
 309                                 next if ($it->{FILE} eq __('nothing'));
 310                         }
 311                 }
 312                 push @return, +{
 313                         VALUE => $_,
 314                         %$it,
 315                 };
 316         }
 317         return @return;
 318 }
 319
 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];
 329                         }
 330                         else {
 331                                 $it = $it->{VALUE};
 332                         }
 333                 }
 334                 eval {
 335                         if ($it =~ /^$string/) {
 336                                 $hit = 1;
 337                         };
 338                 };
 339                 if (defined $hit && defined $found) {
 340                         return undef;
 341                 }
 342                 if ($hit) {
 343                         $found = $i + 1;
 344                 }
 345         }
 346         return $found;
 347 }
 348
 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}++;
 355         }
 356 }
 357
 358 # returns an array of tuples (prefix, remainder)
 359 sub find_unique_prefixes {
 360         my @stuff = @_;
 361         my @return = ();
 362
 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;
 368
 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];
 374                 }
 375                 elsif ((ref $print) eq 'HASH') {
 376                         $print = $print->{VALUE};
 377                 }
 378                 update_trie(\%trie, $print);
 379                 push @return, $print;
 380         }
 381
 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;
 395                         }
 396                         else {
 397                                 my $prefix = substr $ret, 0, $j;
 398                                 return ()
 399                                     if ($hard_limit && $j + 1 > $hard_limit);
 400                         }
 401                         %search = %{$search{$letter}};
 402                 }
 403                 if (ord($letters[0]) > 127 ||
 404                     ($soft_limit && $j + 1 > $soft_limit)) {
 405                         $prefix = undef;
 406                         $remainder = $ret;
 407                 }
 408                 $return[$i] = [$prefix, $remainder];
 409         }
 410         return @return;
 411 }
 412
 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
 422 }
 423
 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;
 429
 430         if (!defined $prefix) {
 431                 return $remainder;
 432         }
 433
 434         if (!is_valid_prefix($prefix)) {
 435                 return "$prefix$remainder";
 436         }
 437
 438         if (!$menu_use_color) {
 439                 return "[$prefix]$remainder";
 440         }
 441
 442         return "$prompt_color$prefix$normal_color$remainder";
 443 }
 444
 445 sub error_msg {
 446         print STDERR colored $error_color, @_;
 447 }
 448
 449 sub list_and_choose {
 450         my ($opts, @stuff) = @_;
 451         my (@chosen, @return);
 452         if (!@stuff) {
 453             return @return;
 454         }
 455         my $i;
 456         my @prefixes = find_unique_prefixes(@stuff) unless $opts->{LIST_ONLY};
 457
 458       TOPLOOP:
 459         while (1) {
 460                 my $last_lf = 0;
 461
 462                 if ($opts->{HEADER}) {
 463                         if (!$opts->{LIST_FLAT}) {
 464                                 print "     ";
 465                         }
 466                         print colored $header_color, "$opts->{HEADER}\n";
 467                 }
 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];
 476                         }
 477                         elsif ($ref eq 'HASH') {
 478                                 my $value = $highlighted || $print->{VALUE};
 479                                 $print = sprintf($status_fmt,
 480                                     $print->{INDEX},
 481                                     $print->{FILE},
 482                                     $value);
 483                         }
 484                         else {
 485                                 $print = $highlighted || $print;
 486                         }
 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;
 492                         }
 493                         else {
 494                                 print "\n";
 495                                 $last_lf = 1;
 496                         }
 497                 }
 498                 if (!$last_lf) {
 499                         print "\n";
 500                 }
 501
 502                 return if ($opts->{LIST_ONLY});
 503
 504                 print colored $prompt_color, $opts->{PROMPT};
 505                 if ($opts->{SINGLETON}) {
 506                         print "> ";
 507                 }
 508                 else {
 509                         print ">> ";
 510                 }
 511                 my $line = <STDIN>;
 512                 if (!$line) {
 513                         print "\n";
 514                         $opts->{ON_EOF}->() if $opts->{ON_EOF};
 515                         last;
 516                 }
 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;
 524                 }
 525                 for my $choice (split(/[\s,]+/, $line)) {
 526                         my $choose = 1;
 527                         my ($bottom, $top);
 528
 529                         # Input that begins with '-'; unchoose
 530                         if ($choice =~ s/^-//) {
 531                                 $choose = 0;
 532                         }
 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);
 536                         }
 537                         elsif ($choice =~ /^\d+$/) {
 538                                 $bottom = $top = $choice;
 539                         }
 540                         elsif ($choice eq '*') {
 541                                 $bottom = 1;
 542                                 $top = 1 + @stuff;
 543                         }
 544                         else {
 545                                 $bottom = $top = find_unique($choice, @stuff);
 546                                 if (!defined $bottom) {
 547                                         error_msg sprintf(__("Huh (%s)?\n"), $choice);
 548                                         next TOPLOOP;
 549                                 }
 550                         }
 551                         if ($opts->{SINGLETON} && $bottom != $top) {
 552                                 error_msg sprintf(__("Huh (%s)?\n"), $choice);
 553                                 next TOPLOOP;
 554                         }
 555                         for ($i = $bottom-1; $i <= $top-1; $i++) {
 556                                 next if (@stuff <= $i || $i < 0);
 557                                 $chosen[$i] = $choose;
 558                         }
 559                 }
 560                 last if ($opts->{IMMEDIATE} || $line eq '*');
 561         }
 562         for ($i = 0; $i < @stuff; $i++) {
 563                 if ($chosen[$i]) {
 564                         push @return, $stuff[$i];
 565                 }
 566         }
 567         return @return;
 568 }
 569
 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
 576 EOF
 577 }
 578
 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
 589 EOF
 590 }
 591
 592 sub status_cmd {
 593         list_and_choose({ LIST_ONLY => 1, HEADER => $status_head },
 594                         list_modified());
 595         print "\n";
 596 }
 597
 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);
 613         }
 614 }
 615
 616 sub update_cmd {
 617         my @mods = list_modified('file-only');
 618         return if (!@mods);
 619
 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);
 627         }
 628         print "\n";
 629 }
 630
 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);
 639                 }
 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 $_;
 648                         }
 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});
 656                                 }
 657                         }
 658                 }
 659                 refresh();
 660                 say_n_paths('reverted', @update);
 661         }
 662         print "\n";
 663 }
 664
 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");
 673         }
 674         print "\n";
 675 }
 676
 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;
 683 }
 684
 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}";
 690         }
 691         if (defined $patch_mode_revision) {
 692                 push @diff_cmd, get_diff_reference($patch_mode_revision);
 693         }
 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");
 702                 }
 703
 704                 @colored = run_cmd_pipe(@display_cmd);
 705         }
 706         my (@hunk) = { TEXT => [], DISPLAY => [], TYPE => 'header' };
 707
 708         for (my $i = 0; $i < @diff; $i++) {
 709                 if ($diff[$i] =~ /^@@ /) {
 710                         push @hunk, { TEXT => [], DISPLAY => [],
 711                                 TYPE => 'hunk' };
 712                 }
 713                 push @{$hunk[-1]{TEXT}}, $diff[$i];
 714                 push @{$hunk[-1]{DISPLAY}},
 715                         (@colored ? $colored[$i] : $diff[$i]);
 716         }
 717         return @hunk;
 718 }
 719
 720 sub parse_diff_header {
 721         my $src = shift;
 722
 723         my $head = { TEXT => [], DISPLAY => [], TYPE => 'header' };
 724         my $mode = { TEXT => [], DISPLAY => [], TYPE => 'mode' };
 725         my $deletion = { TEXT => [], DISPLAY => [], TYPE => 'deletion' };
 726
 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];
 734         }
 735         return ($head, $mode, $deletion);
 736 }
 737
 738 sub hunk_splittable {
 739         my ($text) = @_;
 740
 741         my @s = split_hunk($text);
 742         return (1 < @s);
 743 }
 744
 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);
 752 }
 753
 754 sub split_hunk {
 755         my ($text, $display) = @_;
 756         my @split = ();
 757         if (!defined $display) {
 758                 $display = $text;
 759         }
 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.
 763
 764         my ($o_ofs, undef, $n_ofs) = parse_hunk_header($text->[0]);
 765         my $hunk_start = 1;
 766
 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,
 782                 };
 783
 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;
 796                                 }
 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}++;
 803                                 }
 804                                 next;
 805                         }
 806
 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;
 819                         }
 820                         push @{$this->{TEXT}}, $line;
 821                         push @{$this->{DISPLAY}}, $display;
 822                         $this->{ADDDEL}++;
 823                         if ($line =~ /^-/) {
 824                                 $this->{OCNT}++;
 825                         }
 826                         else {
 827                                 $this->{NCNT}++;
 828                         }
 829                 }
 830
 831                 push @split, $this;
 832                 last;
 833         }
 834
 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};
 840
 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);
 850                 }
 851                 unshift @{$hunk->{DISPLAY}}, $display_head;
 852         }
 853         return @split;
 854 }
 855
 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;
 867                 }
 868                 last;
 869         }
 870         return $last_o_ctx;
 871 }
 872
 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]);
 879
 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;
 889                 }
 890
 891                 last if ($o1_ofs <= $ofs);
 892
 893                 $o_cnt++;
 894                 $ofs++;
 895                 if ($line =~ /^ /) {
 896                         $n_cnt++;
 897                 }
 898                 push @line, $line;
 899         }
 900
 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;
 907                 }
 908                 $ofs++;
 909                 $o_cnt++;
 910                 if ($line =~ /^ /) {
 911                         $n_cnt++;
 912                 }
 913                 push @line, $line;
 914         }
 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);
 921 }
 922
 923 sub coalesce_overlapping_hunks {
 924         my (@in) = @_;
 925         my @out = ();
 926
 927         my ($last_o_ctx, $last_was_dirty);
 928
 929         for (grep { $_->{USE} } @in) {
 930                 if ($_->{TYPE} ne 'hunk') {
 931                         push @out, $_;
 932                         next;
 933                 }
 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], $_);
 941                 }
 942                 else {
 943                         push @out, $_;
 944                 }
 945                 $last_o_ctx = find_last_o_ctx($out[-1]);
 946                 $last_was_dirty = $_->{DIRTY};
 947         }
 948         return @out;
 949 }
 950
 951 sub reassemble_patch {
 952         my $head = shift;
 953         my @patch;
 954
 955         # Include everything in the header except the beginning of the diff.
 956         push @patch, (grep { !/^[-+]{3}/ } @$head);
 957
 958         # Then include any headers from the hunk lines, which must
 959         # come before any actual hunk.
 960         while (@_ && $_[0] !~ /^@/) {
 961                 push @patch, shift;
 962         }
 963
 964         # Then begin the diff.
 965         push @patch, grep { /^[-+]{3}/ } @$head;
 966
 967         # And then the actual hunks.
 968         push @patch, @_;
 969
 970         return @patch;
 971 }
 972
 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         } @_;
 981 }
 982
 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."),
1005 );
1006
1007 sub edit_hunk_manually {
1008         my ($oldtext) = @_;
1009
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),
1020 ---
1021 To remove '%s' lines, make them ' ' lines (context).
1022 To remove '%s' lines, delete them.
1023 Lines starting with %s will be removed.
1024 EOF
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;
1033
1034         chomp(my $editor = run_cmd_pipe(qw(git var GIT_EDITOR)));
1035         system('sh', '-c', $editor.' "$@"', $editor, $hunkfile);
1036
1037         if ($? != 0) {
1038                 return undef;
1039         }
1040
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;
1046
1047         # Abort if nothing remains
1048         if (!grep { /\S/ } @newtext) {
1049                 return undef;
1050         }
1051
1052         # Reinsert the first hunk header if the user accidentally deleted it
1053         if ($newtext[0] !~ /^@/) {
1054                 unshift @newtext, $oldtext->[0];
1055         }
1056         return \@newtext;
1057 }
1058
1059 sub diff_applies {
1060         return run_git_apply($patch_mode_flavour{APPLY_CHECK} . ' --check',
1061                              map { @{$_->{TEXT}} } @_);
1062 }
1063
1064 sub _restore_terminal_and_die {
1065         ReadMode 'restore';
1066         print "\n";
1067         exit 1;
1068 }
1069
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;
1082                         }
1083                         $key =~ s/\e/^[/;
1084                 }
1085                 print "$key" if defined $key;
1086                 print "\n";
1087                 return $key;
1088         } else {
1089                 return <STDIN>;
1090         }
1091 }
1092
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;
1101         }
1102 }
1103
1104 sub edit_hunk_loop {
1105         my ($head, $hunk, $ix) = @_;
1106         my $text = $hunk->[$ix]->{TEXT};
1107
1108         while (1) {
1109                 $text = edit_hunk_manually($text);
1110                 if (!defined $text) {
1111                         return undef;
1112                 }
1113                 my $newhunk = {
1114                         TEXT => $text,
1115                         TYPE => $hunk->[$ix]->{TYPE},
1116                         USE => 1,
1117                         DIRTY => 1,
1118                 };
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;
1125                 }
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;
1137                 }
1138         }
1139 }
1140
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"),
1184 );
1185
1186 sub help_patch_cmd {
1187         local $_;
1188         my $other = $_[0] . ",?";
1189         print colored $help_color, __($help_patch_modes{$patch_mode}), "\n",
1190                 map { "$_\n" } grep {
1191                         my $c = quotemeta(substr($_, 0, 1));
1192                         $other =~ /,$c/
1193                 } split "\n", __ <<EOF ;
1194 g - select a hunk to go to
1195 / - search for a hunk matching the given regex
1196 j - leave this hunk undecided, see next undecided hunk
1197 J - leave this hunk undecided, see next hunk
1198 k - leave this hunk undecided, see previous undecided hunk
1199 K - leave this hunk undecided, see previous hunk
1200 s - split the current hunk into smaller hunks
1201 e - manually edit the current hunk
1202 ? - print help
1203 EOF
1204 }
1205
1206 sub apply_patch {
1207         my $cmd = shift;
1208         my $ret = run_git_apply $cmd, @_;
1209         if (!$ret) {
1210                 print STDERR @_;
1211         }
1212         return $ret;
1213 }
1214
1215 sub apply_patch_for_checkout_commit {
1216         my $reverse = shift;
1217         my $applies_index = run_git_apply 'apply '.$reverse.' --cached --check', @_;
1218         my $applies_worktree = run_git_apply 'apply '.$reverse.' --check', @_;
1219
1220         if ($applies_worktree && $applies_index) {
1221                 run_git_apply 'apply '.$reverse.' --cached', @_;
1222                 run_git_apply 'apply '.$reverse, @_;
1223                 return 1;
1224         } elsif (!$applies_index) {
1225                 print colored $error_color, __("The selected hunks do not apply to the index!\n");
1226                 if (prompt_yesno __("Apply them to the worktree anyway? ")) {
1227                         return run_git_apply 'apply '.$reverse, @_;
1228                 } else {
1229                         print colored $error_color, __("Nothing was applied.\n");
1230                         return 0;
1231                 }
1232         } else {
1233                 print STDERR @_;
1234                 return 0;
1235         }
1236 }
1237
1238 sub patch_update_cmd {
1239         my @all_mods = list_modified($patch_mode_flavour{FILTER});
1240         error_msg sprintf(__("ignoring unmerged: %s\n"), $_->{VALUE})
1241                 for grep { $_->{UNMERGED} } @all_mods;
1242         @all_mods = grep { !$_->{UNMERGED} } @all_mods;
1243
1244         my @mods = grep { !($_->{BINARY}) } @all_mods;
1245         my @them;
1246
1247         if (!@mods) {
1248                 if (@all_mods) {
1249                         print STDERR __("Only binary files changed.\n");
1250                 } else {
1251                         print STDERR __("No changes.\n");
1252                 }
1253                 return 0;
1254         }
1255         if ($patch_mode_only) {
1256                 @them = @mods;
1257         }
1258         else {
1259                 @them = list_and_choose({ PROMPT => __('Patch update'),
1260                                           HEADER => $status_head, },
1261                                         @mods);
1262         }
1263         for (@them) {
1264                 return 0 if patch_update_file($_->{VALUE});
1265         }
1266 }
1267
1268 # Generate a one line summary of a hunk.
1269 sub summarize_hunk {
1270         my $rhunk = shift;
1271         my $summary = $rhunk->{TEXT}[0];
1272
1273         # Keep the line numbers, discard extra context.
1274         $summary =~ s/@@(.*?)@@.*/$1 /s;
1275         $summary .= " " x (20 - length $summary);
1276
1277         # Add some user context.
1278         for my $line (@{$rhunk->{TEXT}}) {
1279                 if ($line =~ m/^[+-].*\w/) {
1280                         $summary .= $line;
1281                         last;
1282                 }
1283         }
1284
1285         chomp $summary;
1286         return substr($summary, 0, 80) . "\n";
1287 }
1288
1289
1290 # Print a one-line summary of each hunk in the array ref in
1291 # the first argument, starting with the index in the 2nd.
1292 sub display_hunks {
1293         my ($hunks, $i) = @_;
1294         my $ctr = 0;
1295         $i ||= 0;
1296         for (; $i < @$hunks && $ctr < 20; $i++, $ctr++) {
1297                 my $status = " ";
1298                 if (defined $hunks->[$i]{USE}) {
1299                         $status = $hunks->[$i]{USE} ? "+" : "-";
1300                 }
1301                 printf "%s%2d: %s",
1302                         $status,
1303                         $i + 1,
1304                         summarize_hunk($hunks->[$i]);
1305         }
1306         return $i;
1307 }
1308
1309 my %patch_update_prompt_modes = (
1310         stage => {
1311                 mode => N__("Stage mode change [y,n,q,a,d%s,?]? "),
1312                 deletion => N__("Stage deletion [y,n,q,a,d%s,?]? "),
1313                 hunk => N__("Stage this hunk [y,n,q,a,d%s,?]? "),
1314         },
1315         stash => {
1316                 mode => N__("Stash mode change [y,n,q,a,d%s,?]? "),
1317                 deletion => N__("Stash deletion [y,n,q,a,d%s,?]? "),
1318                 hunk => N__("Stash this hunk [y,n,q,a,d%s,?]? "),
1319         },
1320         reset_head => {
1321                 mode => N__("Unstage mode change [y,n,q,a,d%s,?]? "),
1322                 deletion => N__("Unstage deletion [y,n,q,a,d%s,?]? "),
1323                 hunk => N__("Unstage this hunk [y,n,q,a,d%s,?]? "),
1324         },
1325         reset_nothead => {
1326                 mode => N__("Apply mode change to index [y,n,q,a,d%s,?]? "),
1327                 deletion => N__("Apply deletion to index [y,n,q,a,d%s,?]? "),
1328                 hunk => N__("Apply this hunk to index [y,n,q,a,d%s,?]? "),
1329         },
1330         checkout_index => {
1331                 mode => N__("Discard mode change from worktree [y,n,q,a,d%s,?]? "),
1332                 deletion => N__("Discard deletion from worktree [y,n,q,a,d%s,?]? "),
1333                 hunk => N__("Discard this hunk from worktree [y,n,q,a,d%s,?]? "),
1334         },
1335         checkout_head => {
1336                 mode => N__("Discard mode change from index and worktree [y,n,q,a,d%s,?]? "),
1337                 deletion => N__("Discard deletion from index and worktree [y,n,q,a,d%s,?]? "),
1338                 hunk => N__("Discard this hunk from index and worktree [y,n,q,a,d%s,?]? "),
1339         },
1340         checkout_nothead => {
1341                 mode => N__("Apply mode change to index and worktree [y,n,q,a,d%s,?]? "),
1342                 deletion => N__("Apply deletion to index and worktree [y,n,q,a,d%s,?]? "),
1343                 hunk => N__("Apply this hunk to index and worktree [y,n,q,a,d%s,?]? "),
1344         },
1345 );
1346
1347 sub patch_update_file {
1348         my $quit = 0;
1349         my ($ix, $num);
1350         my $path = shift;
1351         my ($head, @hunk) = parse_diff($path);
1352         ($head, my $mode, my $deletion) = parse_diff_header($head);
1353         for (@{$head->{DISPLAY}}) {
1354                 print;
1355         }
1356
1357         if (@{$mode->{TEXT}}) {
1358                 unshift @hunk, $mode;
1359         }
1360         if (@{$deletion->{TEXT}}) {
1361                 foreach my $hunk (@hunk) {
1362                         push @{$deletion->{TEXT}}, @{$hunk->{TEXT}};
1363                         push @{$deletion->{DISPLAY}}, @{$hunk->{DISPLAY}};
1364                 }
1365                 @hunk = ($deletion);
1366         }
1367
1368         $num = scalar @hunk;
1369         $ix = 0;
1370
1371         while (1) {
1372                 my ($prev, $next, $other, $undecided, $i);
1373                 $other = '';
1374
1375                 if ($num <= $ix) {
1376                         $ix = 0;
1377                 }
1378                 for ($i = 0; $i < $ix; $i++) {
1379                         if (!defined $hunk[$i]{USE}) {
1380                                 $prev = 1;
1381                                 $other .= ',k';
1382                                 last;
1383                         }
1384                 }
1385                 if ($ix) {
1386                         $other .= ',K';
1387                 }
1388                 for ($i = $ix + 1; $i < $num; $i++) {
1389                         if (!defined $hunk[$i]{USE}) {
1390                                 $next = 1;
1391                                 $other .= ',j';
1392                                 last;
1393                         }
1394                 }
1395                 if ($ix < $num - 1) {
1396                         $other .= ',J';
1397                 }
1398                 if ($num > 1) {
1399                         $other .= ',g,/';
1400                 }
1401                 for ($i = 0; $i < $num; $i++) {
1402                         if (!defined $hunk[$i]{USE}) {
1403                                 $undecided = 1;
1404                                 last;
1405                         }
1406                 }
1407                 last if (!$undecided);
1408
1409                 if ($hunk[$ix]{TYPE} eq 'hunk' &&
1410                     hunk_splittable($hunk[$ix]{TEXT})) {
1411                         $other .= ',s';
1412                 }
1413                 if ($hunk[$ix]{TYPE} eq 'hunk') {
1414                         $other .= ',e';
1415                 }
1416                 for (@{$hunk[$ix]{DISPLAY}}) {
1417                         print;
1418                 }
1419                 print colored $prompt_color,
1420                         sprintf(__($patch_update_prompt_modes{$patch_mode}{$hunk[$ix]{TYPE}}), $other);
1421
1422                 my $line = prompt_single_character;
1423                 last unless defined $line;
1424                 if ($line) {
1425                         if ($line =~ /^y/i) {
1426                                 $hunk[$ix]{USE} = 1;
1427                         }
1428                         elsif ($line =~ /^n/i) {
1429                                 $hunk[$ix]{USE} = 0;
1430                         }
1431                         elsif ($line =~ /^a/i) {
1432                                 while ($ix < $num) {
1433                                         if (!defined $hunk[$ix]{USE}) {
1434                                                 $hunk[$ix]{USE} = 1;
1435                                         }
1436                                         $ix++;
1437                                 }
1438                                 next;
1439                         }
1440                         elsif ($line =~ /^g(.*)/) {
1441                                 my $response = $1;
1442                                 unless ($other =~ /g/) {
1443                                         error_msg __("No other hunks to goto\n");
1444                                         next;
1445                                 }
1446                                 my $no = $ix > 10 ? $ix - 10 : 0;
1447                                 while ($response eq '') {
1448                                         $no = display_hunks(\@hunk, $no);
1449                                         if ($no < $num) {
1450                                                 print __("go to which hunk (<ret> to see more)? ");
1451                                         } else {
1452                                                 print __("go to which hunk? ");
1453                                         }
1454                                         $response = <STDIN>;
1455                                         if (!defined $response) {
1456                                                 $response = '';
1457                                         }
1458                                         chomp $response;
1459                                 }
1460                                 if ($response !~ /^\s*\d+\s*$/) {
1461                                         error_msg sprintf(__("Invalid number: '%s'\n"),
1462                                                              $response);
1463                                 } elsif (0 < $response && $response <= $num) {
1464                                         $ix = $response - 1;
1465                                 } else {
1466                                         error_msg sprintf(__n("Sorry, only %d hunk available.\n",
1467                                                               "Sorry, only %d hunks available.\n", $num), $num);
1468                                 }
1469                                 next;
1470                         }
1471                         elsif ($line =~ /^d/i) {
1472                                 while ($ix < $num) {
1473                                         if (!defined $hunk[$ix]{USE}) {
1474                                                 $hunk[$ix]{USE} = 0;
1475                                         }
1476                                         $ix++;
1477                                 }
1478                                 next;
1479                         }
1480                         elsif ($line =~ /^q/i) {
1481                                 for ($i = 0; $i < $num; $i++) {
1482                                         if (!defined $hunk[$i]{USE}) {
1483                                                 $hunk[$i]{USE} = 0;
1484                                         }
1485                                 }
1486                                 $quit = 1;
1487                                 last;
1488                         }
1489                         elsif ($line =~ m|^/(.*)|) {
1490                                 my $regex = $1;
1491                                 unless ($other =~ m|/|) {
1492                                         error_msg __("No other hunks to search\n");
1493                                         next;
1494                                 }
1495                                 if ($1 eq "") {
1496                                         print colored $prompt_color, __("search for regex? ");
1497                                         $regex = <STDIN>;
1498                                         if (defined $regex) {
1499                                                 chomp $regex;
1500                                         }
1501                                 }
1502                                 my $search_string;
1503                                 eval {
1504                                         $search_string = qr{$regex}m;
1505                                 };
1506                                 if ($@) {
1507                                         my ($err,$exp) = ($@, $1);
1508                                         $err =~ s/ at .*git-add--interactive line \d+, <STDIN> line \d+.*$//;
1509                                         error_msg sprintf(__("Malformed search regexp %s: %s\n"), $exp, $err);
1510                                         next;
1511                                 }
1512                                 my $iy = $ix;
1513                                 while (1) {
1514                                         my $text = join ("", @{$hunk[$iy]{TEXT}});
1515                                         last if ($text =~ $search_string);
1516                                         $iy++;
1517                                         $iy = 0 if ($iy >= $num);
1518                                         if ($ix == $iy) {
1519                                                 error_msg __("No hunk matches the given pattern\n");
1520                                                 last;
1521                                         }
1522                                 }
1523                                 $ix = $iy;
1524                                 next;
1525                         }
1526                         elsif ($line =~ /^K/) {
1527                                 if ($other =~ /K/) {
1528                                         $ix--;
1529                                 }
1530                                 else {
1531                                         error_msg __("No previous hunk\n");
1532                                 }
1533                                 next;
1534                         }
1535                         elsif ($line =~ /^J/) {
1536                                 if ($other =~ /J/) {
1537                                         $ix++;
1538                                 }
1539                                 else {
1540                                         error_msg __("No next hunk\n");
1541                                 }
1542                                 next;
1543                         }
1544                         elsif ($line =~ /^k/) {
1545                                 if ($other =~ /k/) {
1546                                         while (1) {
1547                                                 $ix--;
1548                                                 last if (!$ix ||
1549                                                          !defined $hunk[$ix]{USE});
1550                                         }
1551                                 }
1552                                 else {
1553                                         error_msg __("No previous hunk\n");
1554                                 }
1555                                 next;
1556                         }
1557                         elsif ($line =~ /^j/) {
1558                                 if ($other !~ /j/) {
1559                                         error_msg __("No next hunk\n");
1560                                         next;
1561                                 }
1562                         }
1563                         elsif ($line =~ /^s/) {
1564                                 unless ($other =~ /s/) {
1565                                         error_msg __("Sorry, cannot split this hunk\n");
1566                                         next;
1567                                 }
1568                                 my @split = split_hunk($hunk[$ix]{TEXT}, $hunk[$ix]{DISPLAY});
1569                                 if (1 < @split) {
1570                                         print colored $header_color, sprintf(
1571                                                 __n("Split into %d hunk.\n",
1572                                                     "Split into %d hunks.\n",
1573                                                     scalar(@split)), scalar(@split));
1574                                 }
1575                                 splice (@hunk, $ix, 1, @split);
1576                                 $num = scalar @hunk;
1577                                 next;
1578                         }
1579                         elsif ($line =~ /^e/) {
1580                                 unless ($other =~ /e/) {
1581                                         error_msg __("Sorry, cannot edit this hunk\n");
1582                                         next;
1583                                 }
1584                                 my $newhunk = edit_hunk_loop($head, \@hunk, $ix);
1585                                 if (defined $newhunk) {
1586                                         splice @hunk, $ix, 1, $newhunk;
1587                                 }
1588                         }
1589                         else {
1590                                 help_patch_cmd($other);
1591                                 next;
1592                         }
1593                         # soft increment
1594                         while (1) {
1595                                 $ix++;
1596                                 last if ($ix >= $num ||
1597                                          !defined $hunk[$ix]{USE});
1598                         }
1599                 }
1600         }
1601
1602         @hunk = coalesce_overlapping_hunks(@hunk);
1603
1604         my $n_lofs = 0;
1605         my @result = ();
1606         for (@hunk) {
1607                 if ($_->{USE}) {
1608                         push @result, @{$_->{TEXT}};
1609                 }
1610         }
1611
1612         if (@result) {
1613                 my @patch = reassemble_patch($head->{TEXT}, @result);
1614                 my $apply_routine = $patch_mode_flavour{APPLY};
1615                 &$apply_routine(@patch);
1616                 refresh();
1617         }
1618
1619         print "\n";
1620         return $quit;
1621 }
1622
1623 sub diff_cmd {
1624         my @mods = list_modified('index-only');
1625         @mods = grep { !($_->{BINARY}) } @mods;
1626         return if (!@mods);
1627         my (@them) = list_and_choose({ PROMPT => __('Review diff'),
1628                                      IMMEDIATE => 1,
1629                                      HEADER => $status_head, },
1630                                    @mods);
1631         return if (!@them);
1632         my $reference = (is_initial_commit()) ? get_empty_tree() : 'HEAD';
1633         system(qw(git diff -p --cached), $reference, '--',
1634                 map { $_->{VALUE} } @them);
1635 }
1636
1637 sub quit_cmd {
1638         print __("Bye.\n");
1639         exit(0);
1640 }
1641
1642 sub help_cmd {
1643 # TRANSLATORS: please do not translate the command names
1644 # 'status', 'update', 'revert', etc.
1645         print colored $help_color, __ <<'EOF' ;
1646 status        - show paths with changes
1647 update        - add working tree state to the staged set of changes
1648 revert        - revert staged set of changes back to the HEAD version
1649 patch         - pick hunks and update selectively
1650 diff          - view diff between HEAD and index
1651 add untracked - add contents of untracked files to the staged set of changes
1652 EOF
1653 }
1654
1655 sub process_args {
1656         return unless @ARGV;
1657         my $arg = shift @ARGV;
1658         if ($arg =~ /--patch(?:=(.*))?/) {
1659                 if (defined $1) {
1660                         if ($1 eq 'reset') {
1661                                 $patch_mode = 'reset_head';
1662                                 $patch_mode_revision = 'HEAD';
1663                                 $arg = shift @ARGV or die __("missing --");
1664                                 if ($arg ne '--') {
1665                                         $patch_mode_revision = $arg;
1666                                         $patch_mode = ($arg eq 'HEAD' ?
1667                                                        'reset_head' : 'reset_nothead');
1668                                         $arg = shift @ARGV or die __("missing --");
1669                                 }
1670                         } elsif ($1 eq 'checkout') {
1671                                 $arg = shift @ARGV or die __("missing --");
1672                                 if ($arg eq '--') {
1673                                         $patch_mode = 'checkout_index';
1674                                 } else {
1675                                         $patch_mode_revision = $arg;
1676                                         $patch_mode = ($arg eq 'HEAD' ?
1677                                                        'checkout_head' : 'checkout_nothead');
1678                                         $arg = shift @ARGV or die __("missing --");
1679                                 }
1680                         } elsif ($1 eq 'stage' or $1 eq 'stash') {
1681                                 $patch_mode = $1;
1682                                 $arg = shift @ARGV or die __("missing --");
1683                         } else {
1684                                 die sprintf(__("unknown --patch mode: %s"), $1);
1685                         }
1686                 } else {
1687                         $patch_mode = 'stage';
1688                         $arg = shift @ARGV or die __("missing --");
1689                 }
1690                 die sprintf(__("invalid argument %s, expecting --"),
1691                                $arg) unless $arg eq "--";
1692                 %patch_mode_flavour = %{$patch_modes{$patch_mode}};
1693                 $patch_mode_only = 1;
1694         }
1695         elsif ($arg ne "--") {
1696                 die sprintf(__("invalid argument %s, expecting --"), $arg);
1697         }
1698 }
1699
1700 sub main_loop {
1701         my @cmd = ([ 'status', \&status_cmd, ],
1702                    [ 'update', \&update_cmd, ],
1703                    [ 'revert', \&revert_cmd, ],
1704                    [ 'add untracked', \&add_untracked_cmd, ],
1705                    [ 'patch', \&patch_update_cmd, ],
1706                    [ 'diff', \&diff_cmd, ],
1707                    [ 'quit', \&quit_cmd, ],
1708                    [ 'help', \&help_cmd, ],
1709         );
1710         while (1) {
1711                 my ($it) = list_and_choose({ PROMPT => __('What now'),
1712                                              SINGLETON => 1,
1713                                              LIST_FLAT => 4,
1714                                              HEADER => __('*** Commands ***'),
1715                                              ON_EOF => \&quit_cmd,
1716                                              IMMEDIATE => 1 }, @cmd);
1717                 if ($it) {
1718                         eval {
1719                                 $it->[1]->();
1720                         };
1721                         if ($@) {
1722                                 print "$@";
1723                         }
1724                 }
1725         }
1726 }
1727
1728 process_args();
1729 refresh();
1730 if ($patch_mode_only) {
1731         patch_update_cmd();
1732 }
1733 else {
1734         status_cmd();
1735         main_loop();
1736 }