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 {
 209         my $empty_tree;
 210         sub get_empty_tree {
 211                 return $empty_tree if defined $empty_tree;
 212
 213                 $empty_tree = run_cmd_pipe(qw(git hash-object -t tree /dev/null));
 214                 chomp $empty_tree;
 215                 return $empty_tree;
 216         }
 217 }
 218
 219 sub get_diff_reference {
 220         my $ref = shift;
 221         if (defined $ref and $ref ne 'HEAD') {
 222                 return $ref;
 223         } elsif (is_initial_commit()) {
 224                 return get_empty_tree();
 225         } else {
 226                 return 'HEAD';
 227         }
 228 }
 229
 230 # Returns list of hashes, contents of each of which are:
 231 # VALUE:        pathname
 232 # BINARY:       is a binary path
 233 # INDEX:        is index different from HEAD?
 234 # FILE:         is file different from index?
 235 # INDEX_ADDDEL: is it add/delete between HEAD and index?
 236 # FILE_ADDDEL:  is it add/delete between index and file?
 237 # UNMERGED:     is the path unmerged
 238
 239 sub list_modified {
 240         my ($only) = @_;
 241         my (%data, @return);
 242         my ($add, $del, $adddel, $file);
 243
 244         my $reference = get_diff_reference($patch_mode_revision);
 245         for (run_cmd_pipe(qw(git diff-index --cached
 246                              --numstat --summary), $reference,
 247                              '--', @ARGV)) {
 248                 if (($add, $del, $file) =
 249                     /^([-\d]+)  ([-\d]+)        (.*)/) {
 250                         my ($change, $bin);
 251                         $file = unquote_path($file);
 252                         if ($add eq '-' && $del eq '-') {
 253                                 $change = __('binary');
 254                                 $bin = 1;
 255                         }
 256                         else {
 257                                 $change = "+$add/-$del";
 258                         }
 259                         $data{$file} = {
 260                                 INDEX => $change,
 261                                 BINARY => $bin,
 262                                 FILE => __('nothing'),
 263                         }
 264                 }
 265                 elsif (($adddel, $file) =
 266                        /^ (create|delete) mode [0-7]+ (.*)$/) {
 267                         $file = unquote_path($file);
 268                         $data{$file}{INDEX_ADDDEL} = $adddel;
 269                 }
 270         }
 271
 272         for (run_cmd_pipe(qw(git diff-files --ignore-submodules=dirty --numstat --summary --raw --), @ARGV)) {
 273                 if (($add, $del, $file) =
 274                     /^([-\d]+)  ([-\d]+)        (.*)/) {
 275                         $file = unquote_path($file);
 276                         my ($change, $bin);
 277                         if ($add eq '-' && $del eq '-') {
 278                                 $change = __('binary');
 279                                 $bin = 1;
 280                         }
 281                         else {
 282                                 $change = "+$add/-$del";
 283                         }
 284                         $data{$file}{FILE} = $change;
 285                         if ($bin) {
 286                                 $data{$file}{BINARY} = 1;
 287                         }
 288                 }
 289                 elsif (($adddel, $file) =
 290                        /^ (create|delete) mode [0-7]+ (.*)$/) {
 291                         $file = unquote_path($file);
 292                         $data{$file}{FILE_ADDDEL} = $adddel;
 293                 }
 294                 elsif (/^:[0-7]+ [0-7]+ [0-9a-f]+ [0-9a-f]+ (.) (.*)$/) {
 295                         $file = unquote_path($2);
 296                         if (!exists $data{$file}) {
 297                                 $data{$file} = +{
 298                                         INDEX => __('unchanged'),
 299                                         BINARY => 0,
 300                                 };
 301                         }
 302                         if ($1 eq 'U') {
 303                                 $data{$file}{UNMERGED} = 1;
 304                         }
 305                 }
 306         }
 307
 308         for (sort keys %data) {
 309                 my $it = $data{$_};
 310
 311                 if ($only) {
 312                         if ($only eq 'index-only') {
 313                                 next if ($it->{INDEX} eq __('unchanged'));
 314                         }
 315                         if ($only eq 'file-only') {
 316                                 next if ($it->{FILE} eq __('nothing'));
 317                         }
 318                 }
 319                 push @return, +{
 320                         VALUE => $_,
 321                         %$it,
 322                 };
 323         }
 324         return @return;
 325 }
 326
 327 sub find_unique {
 328         my ($string, @stuff) = @_;
 329         my $found = undef;
 330         for (my $i = 0; $i < @stuff; $i++) {
 331                 my $it = $stuff[$i];
 332                 my $hit = undef;
 333                 if (ref $it) {
 334                         if ((ref $it) eq 'ARRAY') {
 335                                 $it = $it->[0];
 336                         }
 337                         else {
 338                                 $it = $it->{VALUE};
 339                         }
 340                 }
 341                 eval {
 342                         if ($it =~ /^$string/) {
 343                                 $hit = 1;
 344                         };
 345                 };
 346                 if (defined $hit && defined $found) {
 347                         return undef;
 348                 }
 349                 if ($hit) {
 350                         $found = $i + 1;
 351                 }
 352         }
 353         return $found;
 354 }
 355
 356 # inserts string into trie and updates count for each character
 357 sub update_trie {
 358         my ($trie, $string) = @_;
 359         foreach (split //, $string) {
 360                 $trie = $trie->{$_} ||= {COUNT => 0};
 361                 $trie->{COUNT}++;
 362         }
 363 }
 364
 365 # returns an array of tuples (prefix, remainder)
 366 sub find_unique_prefixes {
 367         my @stuff = @_;
 368         my @return = ();
 369
 370         # any single prefix exceeding the soft limit is omitted
 371         # if any prefix exceeds the hard limit all are omitted
 372         # 0 indicates no limit
 373         my $soft_limit = 0;
 374         my $hard_limit = 3;
 375
 376         # build a trie modelling all possible options
 377         my %trie;
 378         foreach my $print (@stuff) {
 379                 if ((ref $print) eq 'ARRAY') {
 380                         $print = $print->[0];
 381                 }
 382                 elsif ((ref $print) eq 'HASH') {
 383                         $print = $print->{VALUE};
 384                 }
 385                 update_trie(\%trie, $print);
 386                 push @return, $print;
 387         }
 388
 389         # use the trie to find the unique prefixes
 390         for (my $i = 0; $i < @return; $i++) {
 391                 my $ret = $return[$i];
 392                 my @letters = split //, $ret;
 393                 my %search = %trie;
 394                 my ($prefix, $remainder);
 395                 my $j;
 396                 for ($j = 0; $j < @letters; $j++) {
 397                         my $letter = $letters[$j];
 398                         if ($search{$letter}{COUNT} == 1) {
 399                                 $prefix = substr $ret, 0, $j + 1;
 400                                 $remainder = substr $ret, $j + 1;
 401                                 last;
 402                         }
 403                         else {
 404                                 my $prefix = substr $ret, 0, $j;
 405                                 return ()
 406                                     if ($hard_limit && $j + 1 > $hard_limit);
 407                         }
 408                         %search = %{$search{$letter}};
 409                 }
 410                 if (ord($letters[0]) > 127 ||
 411                     ($soft_limit && $j + 1 > $soft_limit)) {
 412                         $prefix = undef;
 413                         $remainder = $ret;
 414                 }
 415                 $return[$i] = [$prefix, $remainder];
 416         }
 417         return @return;
 418 }
 419
 420 # filters out prefixes which have special meaning to list_and_choose()
 421 sub is_valid_prefix {
 422         my $prefix = shift;
 423         return (defined $prefix) &&
 424             !($prefix =~ /[\s,]/) && # separators
 425             !($prefix =~ /^-/) &&    # deselection
 426             !($prefix =~ /^\d+/) &&  # selection
 427             ($prefix ne '*') &&      # "all" wildcard
 428             ($prefix ne '?');        # prompt help
 429 }
 430
 431 # given a prefix/remainder tuple return a string with the prefix highlighted
 432 # for now use square brackets; later might use ANSI colors (underline, bold)
 433 sub highlight_prefix {
 434         my $prefix = shift;
 435         my $remainder = shift;
 436
 437         if (!defined $prefix) {
 438                 return $remainder;
 439         }
 440
 441         if (!is_valid_prefix($prefix)) {
 442                 return "$prefix$remainder";
 443         }
 444
 445         if (!$menu_use_color) {
 446                 return "[$prefix]$remainder";
 447         }
 448
 449         return "$prompt_color$prefix$normal_color$remainder";
 450 }
 451
 452 sub error_msg {
 453         print STDERR colored $error_color, @_;
 454 }
 455
 456 sub list_and_choose {
 457         my ($opts, @stuff) = @_;
 458         my (@chosen, @return);
 459         if (!@stuff) {
 460             return @return;
 461         }
 462         my $i;
 463         my @prefixes = find_unique_prefixes(@stuff) unless $opts->{LIST_ONLY};
 464
 465       TOPLOOP:
 466         while (1) {
 467                 my $last_lf = 0;
 468
 469                 if ($opts->{HEADER}) {
 470                         if (!$opts->{LIST_FLAT}) {
 471                                 print "     ";
 472                         }
 473                         print colored $header_color, "$opts->{HEADER}\n";
 474                 }
 475                 for ($i = 0; $i < @stuff; $i++) {
 476                         my $chosen = $chosen[$i] ? '*' : ' ';
 477                         my $print = $stuff[$i];
 478                         my $ref = ref $print;
 479                         my $highlighted = highlight_prefix(@{$prefixes[$i]})
 480                             if @prefixes;
 481                         if ($ref eq 'ARRAY') {
 482                                 $print = $highlighted || $print->[0];
 483                         }
 484                         elsif ($ref eq 'HASH') {
 485                                 my $value = $highlighted || $print->{VALUE};
 486                                 $print = sprintf($status_fmt,
 487                                     $print->{INDEX},
 488                                     $print->{FILE},
 489                                     $value);
 490                         }
 491                         else {
 492                                 $print = $highlighted || $print;
 493                         }
 494                         printf("%s%2d: %s", $chosen, $i+1, $print);
 495                         if (($opts->{LIST_FLAT}) &&
 496                             (($i + 1) % ($opts->{LIST_FLAT}))) {
 497                                 print "\t";
 498                                 $last_lf = 0;
 499                         }
 500                         else {
 501                                 print "\n";
 502                                 $last_lf = 1;
 503                         }
 504                 }
 505                 if (!$last_lf) {
 506                         print "\n";
 507                 }
 508
 509                 return if ($opts->{LIST_ONLY});
 510
 511                 print colored $prompt_color, $opts->{PROMPT};
 512                 if ($opts->{SINGLETON}) {
 513                         print "> ";
 514                 }
 515                 else {
 516                         print ">> ";
 517                 }
 518                 my $line = <STDIN>;
 519                 if (!$line) {
 520                         print "\n";
 521                         $opts->{ON_EOF}->() if $opts->{ON_EOF};
 522                         last;
 523                 }
 524                 chomp $line;
 525                 last if $line eq '';
 526                 if ($line eq '?') {
 527                         $opts->{SINGLETON} ?
 528                             singleton_prompt_help_cmd() :
 529                             prompt_help_cmd();
 530                         next TOPLOOP;
 531                 }
 532                 for my $choice (split(/[\s,]+/, $line)) {
 533                         my $choose = 1;
 534                         my ($bottom, $top);
 535
 536                         # Input that begins with '-'; unchoose
 537                         if ($choice =~ s/^-//) {
 538                                 $choose = 0;
 539                         }
 540                         # A range can be specified like 5-7 or 5-.
 541                         if ($choice =~ /^(\d+)-(\d*)$/) {
 542                                 ($bottom, $top) = ($1, length($2) ? $2 : 1 + @stuff);
 543                         }
 544                         elsif ($choice =~ /^\d+$/) {
 545                                 $bottom = $top = $choice;
 546                         }
 547                         elsif ($choice eq '*') {
 548                                 $bottom = 1;
 549                                 $top = 1 + @stuff;
 550                         }
 551                         else {
 552                                 $bottom = $top = find_unique($choice, @stuff);
 553                                 if (!defined $bottom) {
 554                                         error_msg sprintf(__("Huh (%s)?\n"), $choice);
 555                                         next TOPLOOP;
 556                                 }
 557                         }
 558                         if ($opts->{SINGLETON} && $bottom != $top) {
 559                                 error_msg sprintf(__("Huh (%s)?\n"), $choice);
 560                                 next TOPLOOP;
 561                         }
 562                         for ($i = $bottom-1; $i <= $top-1; $i++) {
 563                                 next if (@stuff <= $i || $i < 0);
 564                                 $chosen[$i] = $choose;
 565                         }
 566                 }
 567                 last if ($opts->{IMMEDIATE} || $line eq '*');
 568         }
 569         for ($i = 0; $i < @stuff; $i++) {
 570                 if ($chosen[$i]) {
 571                         push @return, $stuff[$i];
 572                 }
 573         }
 574         return @return;
 575 }
 576
 577 sub singleton_prompt_help_cmd {
 578         print colored $help_color, __ <<'EOF' ;
 579 Prompt help:
 580 1          - select a numbered item
 581 foo        - select item based on unique prefix
 582            - (empty) select nothing
 583 EOF
 584 }
 585
 586 sub prompt_help_cmd {
 587         print colored $help_color, __ <<'EOF' ;
 588 Prompt help:
 589 1          - select a single item
 590 3-5        - select a range of items
 591 2-3,6-9    - select multiple ranges
 592 foo        - select item based on unique prefix
 593 -...       - unselect specified items
 594 *          - choose all items
 595            - (empty) finish selecting
 596 EOF
 597 }
 598
 599 sub status_cmd {
 600         list_and_choose({ LIST_ONLY => 1, HEADER => $status_head },
 601                         list_modified());
 602         print "\n";
 603 }
 604
 605 sub say_n_paths {
 606         my $did = shift @_;
 607         my $cnt = scalar @_;
 608         if ($did eq 'added') {
 609                 printf(__n("added %d path\n", "added %d paths\n",
 610                            $cnt), $cnt);
 611         } elsif ($did eq 'updated') {
 612                 printf(__n("updated %d path\n", "updated %d paths\n",
 613                            $cnt), $cnt);
 614         } elsif ($did eq 'reverted') {
 615                 printf(__n("reverted %d path\n", "reverted %d paths\n",
 616                            $cnt), $cnt);
 617         } else {
 618                 printf(__n("touched %d path\n", "touched %d paths\n",
 619                            $cnt), $cnt);
 620         }
 621 }
 622
 623 sub update_cmd {
 624         my @mods = list_modified('file-only');
 625         return if (!@mods);
 626
 627         my @update = list_and_choose({ PROMPT => __('Update'),
 628                                        HEADER => $status_head, },
 629                                      @mods);
 630         if (@update) {
 631                 system(qw(git update-index --add --remove --),
 632                        map { $_->{VALUE} } @update);
 633                 say_n_paths('updated', @update);
 634         }
 635         print "\n";
 636 }
 637
 638 sub revert_cmd {
 639         my @update = list_and_choose({ PROMPT => __('Revert'),
 640                                        HEADER => $status_head, },
 641                                      list_modified());
 642         if (@update) {
 643                 if (is_initial_commit()) {
 644                         system(qw(git rm --cached),
 645                                 map { $_->{VALUE} } @update);
 646                 }
 647                 else {
 648                         my @lines = run_cmd_pipe(qw(git ls-tree HEAD --),
 649                                                  map { $_->{VALUE} } @update);
 650                         my $fh;
 651                         open $fh, '| git update-index --index-info'
 652                             or die;
 653                         for (@lines) {
 654                                 print $fh $_;
 655                         }
 656                         close($fh);
 657                         for (@update) {
 658                                 if ($_->{INDEX_ADDDEL} &&
 659                                     $_->{INDEX_ADDDEL} eq 'create') {
 660                                         system(qw(git update-index --force-remove --),
 661                                                $_->{VALUE});
 662                                         printf(__("note: %s is untracked now.\n"), $_->{VALUE});
 663                                 }
 664                         }
 665                 }
 666                 refresh();
 667                 say_n_paths('reverted', @update);
 668         }
 669         print "\n";
 670 }
 671
 672 sub add_untracked_cmd {
 673         my @add = list_and_choose({ PROMPT => __('Add untracked') },
 674                                   list_untracked());
 675         if (@add) {
 676                 system(qw(git update-index --add --), @add);
 677                 say_n_paths('added', @add);
 678         } else {
 679                 print __("No untracked files.\n");
 680         }
 681         print "\n";
 682 }
 683
 684 sub run_git_apply {
 685         my $cmd = shift;
 686         my $fh;
 687         open $fh, '| git ' . $cmd . " --allow-overlap";
 688         print $fh @_;
 689         return close $fh;
 690 }
 691
 692 sub parse_diff {
 693         my ($path) = @_;
 694         my @diff_cmd = split(" ", $patch_mode_flavour{DIFF});
 695         if (defined $diff_algorithm) {
 696                 splice @diff_cmd, 1, 0, "--diff-algorithm=${diff_algorithm}";
 697         }
 698         if (defined $patch_mode_revision) {
 699                 push @diff_cmd, get_diff_reference($patch_mode_revision);
 700         }
 701         my @diff = run_cmd_pipe("git", @diff_cmd, "--", $path);
 702         my @colored = ();
 703         if ($diff_use_color) {
 704                 my @display_cmd = ("git", @diff_cmd, qw(--color --), $path);
 705                 if (defined $diff_filter) {
 706                         # quotemeta is overkill, but sufficient for shell-quoting
 707                         my $diff = join(' ', map { quotemeta } @display_cmd);
 708                         @display_cmd = ("$diff | $diff_filter");
 709                 }
 710
 711                 @colored = run_cmd_pipe(@display_cmd);
 712         }
 713         my (@hunk) = { TEXT => [], DISPLAY => [], TYPE => 'header' };
 714
 715         if (@colored && @colored != @diff) {
 716                 print STDERR
 717                   "fatal: mismatched output from interactive.diffFilter\n",
 718                   "hint: Your filter must maintain a one-to-one correspondence\n",
 719                   "hint: between its input and output lines.\n";
 720                 exit 1;
 721         }
 722
 723         for (my $i = 0; $i < @diff; $i++) {
 724                 if ($diff[$i] =~ /^@@ /) {
 725                         push @hunk, { TEXT => [], DISPLAY => [],
 726                                 TYPE => 'hunk' };
 727                 }
 728                 push @{$hunk[-1]{TEXT}}, $diff[$i];
 729                 push @{$hunk[-1]{DISPLAY}},
 730                         (@colored ? $colored[$i] : $diff[$i]);
 731         }
 732         return @hunk;
 733 }
 734
 735 sub parse_diff_header {
 736         my $src = shift;
 737
 738         my $head = { TEXT => [], DISPLAY => [], TYPE => 'header' };
 739         my $mode = { TEXT => [], DISPLAY => [], TYPE => 'mode' };
 740         my $deletion = { TEXT => [], DISPLAY => [], TYPE => 'deletion' };
 741
 742         for (my $i = 0; $i < @{$src->{TEXT}}; $i++) {
 743                 my $dest =
 744                    $src->{TEXT}->[$i] =~ /^(old|new) mode (\d+)$/ ? $mode :
 745                    $src->{TEXT}->[$i] =~ /^deleted file/ ? $deletion :
 746                    $head;
 747                 push @{$dest->{TEXT}}, $src->{TEXT}->[$i];
 748                 push @{$dest->{DISPLAY}}, $src->{DISPLAY}->[$i];
 749         }
 750         return ($head, $mode, $deletion);
 751 }
 752
 753 sub hunk_splittable {
 754         my ($text) = @_;
 755
 756         my @s = split_hunk($text);
 757         return (1 < @s);
 758 }
 759
 760 sub parse_hunk_header {
 761         my ($line) = @_;
 762         my ($o_ofs, $o_cnt, $n_ofs, $n_cnt) =
 763             $line =~ /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
 764         $o_cnt = 1 unless defined $o_cnt;
 765         $n_cnt = 1 unless defined $n_cnt;
 766         return ($o_ofs, $o_cnt, $n_ofs, $n_cnt);
 767 }
 768
 769 sub format_hunk_header {
 770         my ($o_ofs, $o_cnt, $n_ofs, $n_cnt) = @_;
 771         return ("@@ -$o_ofs" .
 772                 (($o_cnt != 1) ? ",$o_cnt" : '') .
 773                 " +$n_ofs" .
 774                 (($n_cnt != 1) ? ",$n_cnt" : '') .
 775                 " @@\n");
 776 }
 777
 778 sub split_hunk {
 779         my ($text, $display) = @_;
 780         my @split = ();
 781         if (!defined $display) {
 782                 $display = $text;
 783         }
 784         # If there are context lines in the middle of a hunk,
 785         # it can be split, but we would need to take care of
 786         # overlaps later.
 787
 788         my ($o_ofs, undef, $n_ofs) = parse_hunk_header($text->[0]);
 789         my $hunk_start = 1;
 790
 791       OUTER:
 792         while (1) {
 793                 my $next_hunk_start = undef;
 794                 my $i = $hunk_start - 1;
 795                 my $this = +{
 796                         TEXT => [],
 797                         DISPLAY => [],
 798                         TYPE => 'hunk',
 799                         OLD => $o_ofs,
 800                         NEW => $n_ofs,
 801                         OCNT => 0,
 802                         NCNT => 0,
 803                         ADDDEL => 0,
 804                         POSTCTX => 0,
 805                         USE => undef,
 806                 };
 807
 808                 while (++$i < @$text) {
 809                         my $line = $text->[$i];
 810                         my $display = $display->[$i];
 811                         if ($line =~ /^\\/) {
 812                                 push @{$this->{TEXT}}, $line;
 813                                 push @{$this->{DISPLAY}}, $display;
 814                                 next;
 815                         }
 816                         if ($line =~ /^ /) {
 817                                 if ($this->{ADDDEL} &&
 818                                     !defined $next_hunk_start) {
 819                                         # We have seen leading context and
 820                                         # adds/dels and then here is another
 821                                         # context, which is trailing for this
 822                                         # split hunk and leading for the next
 823                                         # one.
 824                                         $next_hunk_start = $i;
 825                                 }
 826                                 push @{$this->{TEXT}}, $line;
 827                                 push @{$this->{DISPLAY}}, $display;
 828                                 $this->{OCNT}++;
 829                                 $this->{NCNT}++;
 830                                 if (defined $next_hunk_start) {
 831                                         $this->{POSTCTX}++;
 832                                 }
 833                                 next;
 834                         }
 835
 836                         # add/del
 837                         if (defined $next_hunk_start) {
 838                                 # We are done with the current hunk and
 839                                 # this is the first real change for the
 840                                 # next split one.
 841                                 $hunk_start = $next_hunk_start;
 842                                 $o_ofs = $this->{OLD} + $this->{OCNT};
 843                                 $n_ofs = $this->{NEW} + $this->{NCNT};
 844                                 $o_ofs -= $this->{POSTCTX};
 845                                 $n_ofs -= $this->{POSTCTX};
 846                                 push @split, $this;
 847                                 redo OUTER;
 848                         }
 849                         push @{$this->{TEXT}}, $line;
 850                         push @{$this->{DISPLAY}}, $display;
 851                         $this->{ADDDEL}++;
 852                         if ($line =~ /^-/) {
 853                                 $this->{OCNT}++;
 854                         }
 855                         else {
 856                                 $this->{NCNT}++;
 857                         }
 858                 }
 859
 860                 push @split, $this;
 861                 last;
 862         }
 863
 864         for my $hunk (@split) {
 865                 $o_ofs = $hunk->{OLD};
 866                 $n_ofs = $hunk->{NEW};
 867                 my $o_cnt = $hunk->{OCNT};
 868                 my $n_cnt = $hunk->{NCNT};
 869
 870                 my $head = format_hunk_header($o_ofs, $o_cnt, $n_ofs, $n_cnt);
 871                 my $display_head = $head;
 872                 unshift @{$hunk->{TEXT}}, $head;
 873                 if ($diff_use_color) {
 874                         $display_head = colored($fraginfo_color, $head);
 875                 }
 876                 unshift @{$hunk->{DISPLAY}}, $display_head;
 877         }
 878         return @split;
 879 }
 880
 881 sub find_last_o_ctx {
 882         my ($it) = @_;
 883         my $text = $it->{TEXT};
 884         my ($o_ofs, $o_cnt) = parse_hunk_header($text->[0]);
 885         my $i = @{$text};
 886         my $last_o_ctx = $o_ofs + $o_cnt;
 887         while (0 < --$i) {
 888                 my $line = $text->[$i];
 889                 if ($line =~ /^ /) {
 890                         $last_o_ctx--;
 891                         next;
 892                 }
 893                 last;
 894         }
 895         return $last_o_ctx;
 896 }
 897
 898 sub merge_hunk {
 899         my ($prev, $this) = @_;
 900         my ($o0_ofs, $o0_cnt, $n0_ofs, $n0_cnt) =
 901             parse_hunk_header($prev->{TEXT}[0]);
 902         my ($o1_ofs, $o1_cnt, $n1_ofs, $n1_cnt) =
 903             parse_hunk_header($this->{TEXT}[0]);
 904
 905         my (@line, $i, $ofs, $o_cnt, $n_cnt);
 906         $ofs = $o0_ofs;
 907         $o_cnt = $n_cnt = 0;
 908         for ($i = 1; $i < @{$prev->{TEXT}}; $i++) {
 909                 my $line = $prev->{TEXT}[$i];
 910                 if ($line =~ /^\+/) {
 911                         $n_cnt++;
 912                         push @line, $line;
 913                         next;
 914                 } elsif ($line =~ /^\\/) {
 915                         push @line, $line;
 916                         next;
 917                 }
 918
 919                 last if ($o1_ofs <= $ofs);
 920
 921                 $o_cnt++;
 922                 $ofs++;
 923                 if ($line =~ /^ /) {
 924                         $n_cnt++;
 925                 }
 926                 push @line, $line;
 927         }
 928
 929         for ($i = 1; $i < @{$this->{TEXT}}; $i++) {
 930                 my $line = $this->{TEXT}[$i];
 931                 if ($line =~ /^\+/) {
 932                         $n_cnt++;
 933                         push @line, $line;
 934                         next;
 935                 } elsif ($line =~ /^\\/) {
 936                         push @line, $line;
 937                         next;
 938                 }
 939                 $ofs++;
 940                 $o_cnt++;
 941                 if ($line =~ /^ /) {
 942                         $n_cnt++;
 943                 }
 944                 push @line, $line;
 945         }
 946         my $head = format_hunk_header($o0_ofs, $o_cnt, $n0_ofs, $n_cnt);
 947         @{$prev->{TEXT}} = ($head, @line);
 948 }
 949
 950 sub coalesce_overlapping_hunks {
 951         my (@in) = @_;
 952         my @out = ();
 953
 954         my ($last_o_ctx, $last_was_dirty);
 955         my $ofs_delta = 0;
 956
 957         for (@in) {
 958                 if ($_->{TYPE} ne 'hunk') {
 959                         push @out, $_;
 960                         next;
 961                 }
 962                 my $text = $_->{TEXT};
 963                 my ($o_ofs, $o_cnt, $n_ofs, $n_cnt) =
 964                                                 parse_hunk_header($text->[0]);
 965                 unless ($_->{USE}) {
 966                         $ofs_delta += $o_cnt - $n_cnt;
 967                         # If this hunk has been edited then subtract
 968                         # the delta that is due to the edit.
 969                         if ($_->{OFS_DELTA}) {
 970                                 $ofs_delta -= $_->{OFS_DELTA};
 971                         }
 972                         next;
 973                 }
 974                 if ($ofs_delta) {
 975                         if ($patch_mode_flavour{IS_REVERSE}) {
 976                                 $o_ofs -= $ofs_delta;
 977                         } else {
 978                                 $n_ofs += $ofs_delta;
 979                         }
 980                         $_->{TEXT}->[0] = format_hunk_header($o_ofs, $o_cnt,
 981                                                              $n_ofs, $n_cnt);
 982                 }
 983                 # If this hunk was edited then adjust the offset delta
 984                 # to reflect the edit.
 985                 if ($_->{OFS_DELTA}) {
 986                         $ofs_delta += $_->{OFS_DELTA};
 987                 }
 988                 if (defined $last_o_ctx &&
 989                     $o_ofs <= $last_o_ctx &&
 990                     !$_->{DIRTY} &&
 991                     !$last_was_dirty) {
 992                         merge_hunk($out[-1], $_);
 993                 }
 994                 else {
 995                         push @out, $_;
 996                 }
 997                 $last_o_ctx = find_last_o_ctx($out[-1]);
 998                 $last_was_dirty = $_->{DIRTY};
 999         }
1000         return @out;
1001 }
1002
1003 sub reassemble_patch {
1004         my $head = shift;
1005         my @patch;
1006
1007         # Include everything in the header except the beginning of the diff.
1008         push @patch, (grep { !/^[-+]{3}/ } @$head);
1009
1010         # Then include any headers from the hunk lines, which must
1011         # come before any actual hunk.
1012         while (@_ && $_[0] !~ /^@/) {
1013                 push @patch, shift;
1014         }
1015
1016         # Then begin the diff.
1017         push @patch, grep { /^[-+]{3}/ } @$head;
1018
1019         # And then the actual hunks.
1020         push @patch, @_;
1021
1022         return @patch;
1023 }
1024
1025 sub color_diff {
1026         return map {
1027                 colored((/^@/  ? $fraginfo_color :
1028                          /^\+/ ? $diff_new_color :
1029                          /^-/  ? $diff_old_color :
1030                          $diff_plain_color),
1031                         $_);
1032         } @_;
1033 }
1034
1035 my %edit_hunk_manually_modes = (
1036         stage => N__(
1037 "If the patch applies cleanly, the edited hunk will immediately be
1038 marked for staging."),
1039         stash => N__(
1040 "If the patch applies cleanly, the edited hunk will immediately be
1041 marked for stashing."),
1042         reset_head => N__(
1043 "If the patch applies cleanly, the edited hunk will immediately be
1044 marked for unstaging."),
1045         reset_nothead => N__(
1046 "If the patch applies cleanly, the edited hunk will immediately be
1047 marked for applying."),
1048         checkout_index => N__(
1049 "If the patch applies cleanly, the edited hunk will immediately be
1050 marked for discarding."),
1051         checkout_head => N__(
1052 "If the patch applies cleanly, the edited hunk will immediately be
1053 marked for discarding."),
1054         checkout_nothead => N__(
1055 "If the patch applies cleanly, the edited hunk will immediately be
1056 marked for applying."),
1057 );
1058
1059 sub recount_edited_hunk {
1060         local $_;
1061         my ($oldtext, $newtext) = @_;
1062         my ($o_cnt, $n_cnt) = (0, 0);
1063         for (@{$newtext}[1..$#{$newtext}]) {
1064                 my $mode = substr($_, 0, 1);
1065                 if ($mode eq '-') {
1066                         $o_cnt++;
1067                 } elsif ($mode eq '+') {
1068                         $n_cnt++;
1069                 } elsif ($mode eq ' ' or $mode eq "\n") {
1070                         $o_cnt++;
1071                         $n_cnt++;
1072                 }
1073         }
1074         my ($o_ofs, undef, $n_ofs, undef) =
1075                                         parse_hunk_header($newtext->[0]);
1076         $newtext->[0] = format_hunk_header($o_ofs, $o_cnt, $n_ofs, $n_cnt);
1077         my (undef, $orig_o_cnt, undef, $orig_n_cnt) =
1078                                         parse_hunk_header($oldtext->[0]);
1079         # Return the change in the number of lines inserted by this hunk
1080         return $orig_o_cnt - $orig_n_cnt - $o_cnt + $n_cnt;
1081 }
1082
1083 sub edit_hunk_manually {
1084         my ($oldtext) = @_;
1085
1086         my $hunkfile = $repo->repo_path . "/addp-hunk-edit.diff";
1087         my $fh;
1088         open $fh, '>', $hunkfile
1089                 or die sprintf(__("failed to open hunk edit file for writing: %s"), $!);
1090         print $fh Git::comment_lines __("Manual hunk edit mode -- see bottom for a quick guide.\n");
1091         print $fh @$oldtext;
1092         my $is_reverse = $patch_mode_flavour{IS_REVERSE};
1093         my ($remove_plus, $remove_minus) = $is_reverse ? ('-', '+') : ('+', '-');
1094         my $comment_line_char = Git::get_comment_line_char;
1095         print $fh Git::comment_lines sprintf(__ <<EOF, $remove_minus, $remove_plus, $comment_line_char),
1096 ---
1097 To remove '%s' lines, make them ' ' lines (context).
1098 To remove '%s' lines, delete them.
1099 Lines starting with %s will be removed.
1100 EOF
1101 __($edit_hunk_manually_modes{$patch_mode}),
1102 # TRANSLATORS: 'it' refers to the patch mentioned in the previous messages.
1103 __ <<EOF2 ;
1104 If it does not apply cleanly, you will be given an opportunity to
1105 edit again.  If all lines of the hunk are removed, then the edit is
1106 aborted and the hunk is left unchanged.
1107 EOF2
1108         close $fh;
1109
1110         chomp(my $editor = run_cmd_pipe(qw(git var GIT_EDITOR)));
1111         system('sh', '-c', $editor.' "$@"', $editor, $hunkfile);
1112
1113         if ($? != 0) {
1114                 return undef;
1115         }
1116
1117         open $fh, '<', $hunkfile
1118                 or die sprintf(__("failed to open hunk edit file for reading: %s"), $!);
1119         my @newtext = grep { !/^\Q$comment_line_char\E/ } <$fh>;
1120         close $fh;
1121         unlink $hunkfile;
1122
1123         # Abort if nothing remains
1124         if (!grep { /\S/ } @newtext) {
1125                 return undef;
1126         }
1127
1128         # Reinsert the first hunk header if the user accidentally deleted it
1129         if ($newtext[0] !~ /^@/) {
1130                 unshift @newtext, $oldtext->[0];
1131         }
1132         return \@newtext;
1133 }
1134
1135 sub diff_applies {
1136         return run_git_apply($patch_mode_flavour{APPLY_CHECK} . ' --check',
1137                              map { @{$_->{TEXT}} } @_);
1138 }
1139
1140 sub _restore_terminal_and_die {
1141         ReadMode 'restore';
1142         print "\n";
1143         exit 1;
1144 }
1145
1146 sub prompt_single_character {
1147         if ($use_readkey) {
1148                 local $SIG{TERM} = \&_restore_terminal_and_die;
1149                 local $SIG{INT} = \&_restore_terminal_and_die;
1150                 ReadMode 'cbreak';
1151                 my $key = ReadKey 0;
1152                 ReadMode 'restore';
1153                 if ($use_termcap and $key eq "\e") {
1154                         while (!defined $term_escapes{$key}) {
1155                                 my $next = ReadKey 0.5;
1156                                 last if (!defined $next);
1157                                 $key .= $next;
1158                         }
1159                         $key =~ s/\e/^[/;
1160                 }
1161                 print "$key" if defined $key;
1162                 print "\n";
1163                 return $key;
1164         } else {
1165                 return <STDIN>;
1166         }
1167 }
1168
1169 sub prompt_yesno {
1170         my ($prompt) = @_;
1171         while (1) {
1172                 print colored $prompt_color, $prompt;
1173                 my $line = prompt_single_character;
1174                 return undef unless defined $line;
1175                 return 0 if $line =~ /^n/i;
1176                 return 1 if $line =~ /^y/i;
1177         }
1178 }
1179
1180 sub edit_hunk_loop {
1181         my ($head, $hunks, $ix) = @_;
1182         my $hunk = $hunks->[$ix];
1183         my $text = $hunk->{TEXT};
1184
1185         while (1) {
1186                 my $newtext = edit_hunk_manually($text);
1187                 if (!defined $newtext) {
1188                         return undef;
1189                 }
1190                 my $newhunk = {
1191                         TEXT => $newtext,
1192                         TYPE => $hunk->{TYPE},
1193                         USE => 1,
1194                         DIRTY => 1,
1195                 };
1196                 $newhunk->{OFS_DELTA} = recount_edited_hunk($text, $newtext);
1197                 # If this hunk has already been edited then add the
1198                 # offset delta of the previous edit to get the real
1199                 # delta from the original unedited hunk.
1200                 $hunk->{OFS_DELTA} and
1201                                 $newhunk->{OFS_DELTA} += $hunk->{OFS_DELTA};
1202                 if (diff_applies($head,
1203                                  @{$hunks}[0..$ix-1],
1204                                  $newhunk,
1205                                  @{$hunks}[$ix+1..$#{$hunks}])) {
1206                         $newhunk->{DISPLAY} = [color_diff(@{$newtext})];
1207                         return $newhunk;
1208                 }
1209                 else {
1210                         prompt_yesno(
1211                                 # TRANSLATORS: do not translate [y/n]
1212                                 # The program will only accept that input
1213                                 # at this point.
1214                                 # Consider translating (saying "no" discards!) as
1215                                 # (saying "n" for "no" discards!) if the translation
1216                                 # of the word "no" does not start with n.
1217                                 __('Your edited hunk does not apply. Edit again '
1218                                    . '(saying "no" discards!) [y/n]? ')
1219                                 ) or return undef;
1220                 }
1221         }
1222 }
1223
1224 my %help_patch_modes = (
1225         stage => N__(
1226 "y - stage this hunk
1227 n - do not stage this hunk
1228 q - quit; do not stage this hunk or any of the remaining ones
1229 a - stage this hunk and all later hunks in the file
1230 d - do not stage this hunk or any of the later hunks in the file"),
1231         stash => N__(
1232 "y - stash this hunk
1233 n - do not stash this hunk
1234 q - quit; do not stash this hunk or any of the remaining ones
1235 a - stash this hunk and all later hunks in the file
1236 d - do not stash this hunk or any of the later hunks in the file"),
1237         reset_head => N__(
1238 "y - unstage this hunk
1239 n - do not unstage this hunk
1240 q - quit; do not unstage this hunk or any of the remaining ones
1241 a - unstage this hunk and all later hunks in the file
1242 d - do not unstage this hunk or any of the later hunks in the file"),
1243         reset_nothead => N__(
1244 "y - apply this hunk to index
1245 n - do not apply this hunk to index
1246 q - quit; do not apply this hunk or any of the remaining ones
1247 a - apply this hunk and all later hunks in the file
1248 d - do not apply this hunk or any of the later hunks in the file"),
1249         checkout_index => N__(
1250 "y - discard this hunk from worktree
1251 n - do not discard this hunk from worktree
1252 q - quit; do not discard this hunk or any of the remaining ones
1253 a - discard this hunk and all later hunks in the file
1254 d - do not discard this hunk or any of the later hunks in the file"),
1255         checkout_head => N__(
1256 "y - discard this hunk from index and worktree
1257 n - do not discard this hunk from index and worktree
1258 q - quit; do not discard this hunk or any of the remaining ones
1259 a - discard this hunk and all later hunks in the file
1260 d - do not discard this hunk or any of the later hunks in the file"),
1261         checkout_nothead => N__(
1262 "y - apply this hunk to index and worktree
1263 n - do not apply this hunk to index and worktree
1264 q - quit; do not apply this hunk or any of the remaining ones
1265 a - apply this hunk and all later hunks in the file
1266 d - do not apply this hunk or any of the later hunks in the file"),
1267 );
1268
1269 sub help_patch_cmd {
1270         local $_;
1271         my $other = $_[0] . ",?";
1272         print colored $help_color, __($help_patch_modes{$patch_mode}), "\n",
1273                 map { "$_\n" } grep {
1274                         my $c = quotemeta(substr($_, 0, 1));
1275                         $other =~ /,$c/
1276                 } split "\n", __ <<EOF ;
1277 g - select a hunk to go to
1278 / - search for a hunk matching the given regex
1279 j - leave this hunk undecided, see next undecided hunk
1280 J - leave this hunk undecided, see next hunk
1281 k - leave this hunk undecided, see previous undecided hunk
1282 K - leave this hunk undecided, see previous hunk
1283 s - split the current hunk into smaller hunks
1284 e - manually edit the current hunk
1285 ? - print help
1286 EOF
1287 }
1288
1289 sub apply_patch {
1290         my $cmd = shift;
1291         my $ret = run_git_apply $cmd, @_;
1292         if (!$ret) {
1293                 print STDERR @_;
1294         }
1295         return $ret;
1296 }
1297
1298 sub apply_patch_for_checkout_commit {
1299         my $reverse = shift;
1300         my $applies_index = run_git_apply 'apply '.$reverse.' --cached --check', @_;
1301         my $applies_worktree = run_git_apply 'apply '.$reverse.' --check', @_;
1302
1303         if ($applies_worktree && $applies_index) {
1304                 run_git_apply 'apply '.$reverse.' --cached', @_;
1305                 run_git_apply 'apply '.$reverse, @_;
1306                 return 1;
1307         } elsif (!$applies_index) {
1308                 print colored $error_color, __("The selected hunks do not apply to the index!\n");
1309                 if (prompt_yesno __("Apply them to the worktree anyway? ")) {
1310                         return run_git_apply 'apply '.$reverse, @_;
1311                 } else {
1312                         print colored $error_color, __("Nothing was applied.\n");
1313                         return 0;
1314                 }
1315         } else {
1316                 print STDERR @_;
1317                 return 0;
1318         }
1319 }
1320
1321 sub patch_update_cmd {
1322         my @all_mods = list_modified($patch_mode_flavour{FILTER});
1323         error_msg sprintf(__("ignoring unmerged: %s\n"), $_->{VALUE})
1324                 for grep { $_->{UNMERGED} } @all_mods;
1325         @all_mods = grep { !$_->{UNMERGED} } @all_mods;
1326
1327         my @mods = grep { !($_->{BINARY}) } @all_mods;
1328         my @them;
1329
1330         if (!@mods) {
1331                 if (@all_mods) {
1332                         print STDERR __("Only binary files changed.\n");
1333                 } else {
1334                         print STDERR __("No changes.\n");
1335                 }
1336                 return 0;
1337         }
1338         if ($patch_mode_only) {
1339                 @them = @mods;
1340         }
1341         else {
1342                 @them = list_and_choose({ PROMPT => __('Patch update'),
1343                                           HEADER => $status_head, },
1344                                         @mods);
1345         }
1346         for (@them) {
1347                 return 0 if patch_update_file($_->{VALUE});
1348         }
1349 }
1350
1351 # Generate a one line summary of a hunk.
1352 sub summarize_hunk {
1353         my $rhunk = shift;
1354         my $summary = $rhunk->{TEXT}[0];
1355
1356         # Keep the line numbers, discard extra context.
1357         $summary =~ s/@@(.*?)@@.*/$1 /s;
1358         $summary .= " " x (20 - length $summary);
1359
1360         # Add some user context.
1361         for my $line (@{$rhunk->{TEXT}}) {
1362                 if ($line =~ m/^[+-].*\w/) {
1363                         $summary .= $line;
1364                         last;
1365                 }
1366         }
1367
1368         chomp $summary;
1369         return substr($summary, 0, 80) . "\n";
1370 }
1371
1372
1373 # Print a one-line summary of each hunk in the array ref in
1374 # the first argument, starting with the index in the 2nd.
1375 sub display_hunks {
1376         my ($hunks, $i) = @_;
1377         my $ctr = 0;
1378         $i ||= 0;
1379         for (; $i < @$hunks && $ctr < 20; $i++, $ctr++) {
1380                 my $status = " ";
1381                 if (defined $hunks->[$i]{USE}) {
1382                         $status = $hunks->[$i]{USE} ? "+" : "-";
1383                 }
1384                 printf "%s%2d: %s",
1385                         $status,
1386                         $i + 1,
1387                         summarize_hunk($hunks->[$i]);
1388         }
1389         return $i;
1390 }
1391
1392 my %patch_update_prompt_modes = (
1393         stage => {
1394                 mode => N__("Stage mode change [y,n,q,a,d%s,?]? "),
1395                 deletion => N__("Stage deletion [y,n,q,a,d%s,?]? "),
1396                 hunk => N__("Stage this hunk [y,n,q,a,d%s,?]? "),
1397         },
1398         stash => {
1399                 mode => N__("Stash mode change [y,n,q,a,d%s,?]? "),
1400                 deletion => N__("Stash deletion [y,n,q,a,d%s,?]? "),
1401                 hunk => N__("Stash this hunk [y,n,q,a,d%s,?]? "),
1402         },
1403         reset_head => {
1404                 mode => N__("Unstage mode change [y,n,q,a,d%s,?]? "),
1405                 deletion => N__("Unstage deletion [y,n,q,a,d%s,?]? "),
1406                 hunk => N__("Unstage this hunk [y,n,q,a,d%s,?]? "),
1407         },
1408         reset_nothead => {
1409                 mode => N__("Apply mode change to index [y,n,q,a,d%s,?]? "),
1410                 deletion => N__("Apply deletion to index [y,n,q,a,d%s,?]? "),
1411                 hunk => N__("Apply this hunk to index [y,n,q,a,d%s,?]? "),
1412         },
1413         checkout_index => {
1414                 mode => N__("Discard mode change from worktree [y,n,q,a,d%s,?]? "),
1415                 deletion => N__("Discard deletion from worktree [y,n,q,a,d%s,?]? "),
1416                 hunk => N__("Discard this hunk from worktree [y,n,q,a,d%s,?]? "),
1417         },
1418         checkout_head => {
1419                 mode => N__("Discard mode change from index and worktree [y,n,q,a,d%s,?]? "),
1420                 deletion => N__("Discard deletion from index and worktree [y,n,q,a,d%s,?]? "),
1421                 hunk => N__("Discard this hunk from index and worktree [y,n,q,a,d%s,?]? "),
1422         },
1423         checkout_nothead => {
1424                 mode => N__("Apply mode change to index and worktree [y,n,q,a,d%s,?]? "),
1425                 deletion => N__("Apply deletion to index and worktree [y,n,q,a,d%s,?]? "),
1426                 hunk => N__("Apply this hunk to index and worktree [y,n,q,a,d%s,?]? "),
1427         },
1428 );
1429
1430 sub patch_update_file {
1431         my $quit = 0;
1432         my ($ix, $num);
1433         my $path = shift;
1434         my ($head, @hunk) = parse_diff($path);
1435         ($head, my $mode, my $deletion) = parse_diff_header($head);
1436         for (@{$head->{DISPLAY}}) {
1437                 print;
1438         }
1439
1440         if (@{$mode->{TEXT}}) {
1441                 unshift @hunk, $mode;
1442         }
1443         if (@{$deletion->{TEXT}}) {
1444                 foreach my $hunk (@hunk) {
1445                         push @{$deletion->{TEXT}}, @{$hunk->{TEXT}};
1446                         push @{$deletion->{DISPLAY}}, @{$hunk->{DISPLAY}};
1447                 }
1448                 @hunk = ($deletion);
1449         }
1450
1451         $num = scalar @hunk;
1452         $ix = 0;
1453
1454         while (1) {
1455                 my ($prev, $next, $other, $undecided, $i);
1456                 $other = '';
1457
1458                 if ($num <= $ix) {
1459                         $ix = 0;
1460                 }
1461                 for ($i = 0; $i < $ix; $i++) {
1462                         if (!defined $hunk[$i]{USE}) {
1463                                 $prev = 1;
1464                                 $other .= ',k';
1465                                 last;
1466                         }
1467                 }
1468                 if ($ix) {
1469                         $other .= ',K';
1470                 }
1471                 for ($i = $ix + 1; $i < $num; $i++) {
1472                         if (!defined $hunk[$i]{USE}) {
1473                                 $next = 1;
1474                                 $other .= ',j';
1475                                 last;
1476                         }
1477                 }
1478                 if ($ix < $num - 1) {
1479                         $other .= ',J';
1480                 }
1481                 if ($num > 1) {
1482                         $other .= ',g,/';
1483                 }
1484                 for ($i = 0; $i < $num; $i++) {
1485                         if (!defined $hunk[$i]{USE}) {
1486                                 $undecided = 1;
1487                                 last;
1488                         }
1489                 }
1490                 last if (!$undecided);
1491
1492                 if ($hunk[$ix]{TYPE} eq 'hunk' &&
1493                     hunk_splittable($hunk[$ix]{TEXT})) {
1494                         $other .= ',s';
1495                 }
1496                 if ($hunk[$ix]{TYPE} eq 'hunk') {
1497                         $other .= ',e';
1498                 }
1499                 for (@{$hunk[$ix]{DISPLAY}}) {
1500                         print;
1501                 }
1502                 print colored $prompt_color,
1503                         sprintf(__($patch_update_prompt_modes{$patch_mode}{$hunk[$ix]{TYPE}}), $other);
1504
1505                 my $line = prompt_single_character;
1506                 last unless defined $line;
1507                 if ($line) {
1508                         if ($line =~ /^y/i) {
1509                                 $hunk[$ix]{USE} = 1;
1510                         }
1511                         elsif ($line =~ /^n/i) {
1512                                 $hunk[$ix]{USE} = 0;
1513                         }
1514                         elsif ($line =~ /^a/i) {
1515                                 while ($ix < $num) {
1516                                         if (!defined $hunk[$ix]{USE}) {
1517                                                 $hunk[$ix]{USE} = 1;
1518                                         }
1519                                         $ix++;
1520                                 }
1521                                 next;
1522                         }
1523                         elsif ($line =~ /^g(.*)/) {
1524                                 my $response = $1;
1525                                 unless ($other =~ /g/) {
1526                                         error_msg __("No other hunks to goto\n");
1527                                         next;
1528                                 }
1529                                 my $no = $ix > 10 ? $ix - 10 : 0;
1530                                 while ($response eq '') {
1531                                         $no = display_hunks(\@hunk, $no);
1532                                         if ($no < $num) {
1533                                                 print __("go to which hunk (<ret> to see more)? ");
1534                                         } else {
1535                                                 print __("go to which hunk? ");
1536                                         }
1537                                         $response = <STDIN>;
1538                                         if (!defined $response) {
1539                                                 $response = '';
1540                                         }
1541                                         chomp $response;
1542                                 }
1543                                 if ($response !~ /^\s*\d+\s*$/) {
1544                                         error_msg sprintf(__("Invalid number: '%s'\n"),
1545                                                              $response);
1546                                 } elsif (0 < $response && $response <= $num) {
1547                                         $ix = $response - 1;
1548                                 } else {
1549                                         error_msg sprintf(__n("Sorry, only %d hunk available.\n",
1550                                                               "Sorry, only %d hunks available.\n", $num), $num);
1551                                 }
1552                                 next;
1553                         }
1554                         elsif ($line =~ /^d/i) {
1555                                 while ($ix < $num) {
1556                                         if (!defined $hunk[$ix]{USE}) {
1557                                                 $hunk[$ix]{USE} = 0;
1558                                         }
1559                                         $ix++;
1560                                 }
1561                                 next;
1562                         }
1563                         elsif ($line =~ /^q/i) {
1564                                 for ($i = 0; $i < $num; $i++) {
1565                                         if (!defined $hunk[$i]{USE}) {
1566                                                 $hunk[$i]{USE} = 0;
1567                                         }
1568                                 }
1569                                 $quit = 1;
1570                                 last;
1571                         }
1572                         elsif ($line =~ m|^/(.*)|) {
1573                                 my $regex = $1;
1574                                 unless ($other =~ m|/|) {
1575                                         error_msg __("No other hunks to search\n");
1576                                         next;
1577                                 }
1578                                 if ($regex eq "") {
1579                                         print colored $prompt_color, __("search for regex? ");
1580                                         $regex = <STDIN>;
1581                                         if (defined $regex) {
1582                                                 chomp $regex;
1583                                         }
1584                                 }
1585                                 my $search_string;
1586                                 eval {
1587                                         $search_string = qr{$regex}m;
1588                                 };
1589                                 if ($@) {
1590                                         my ($err,$exp) = ($@, $1);
1591                                         $err =~ s/ at .*git-add--interactive line \d+, <STDIN> line \d+.*$//;
1592                                         error_msg sprintf(__("Malformed search regexp %s: %s\n"), $exp, $err);
1593                                         next;
1594                                 }
1595                                 my $iy = $ix;
1596                                 while (1) {
1597                                         my $text = join ("", @{$hunk[$iy]{TEXT}});
1598                                         last if ($text =~ $search_string);
1599                                         $iy++;
1600                                         $iy = 0 if ($iy >= $num);
1601                                         if ($ix == $iy) {
1602                                                 error_msg __("No hunk matches the given pattern\n");
1603                                                 last;
1604                                         }
1605                                 }
1606                                 $ix = $iy;
1607                                 next;
1608                         }
1609                         elsif ($line =~ /^K/) {
1610                                 if ($other =~ /K/) {
1611                                         $ix--;
1612                                 }
1613                                 else {
1614                                         error_msg __("No previous hunk\n");
1615                                 }
1616                                 next;
1617                         }
1618                         elsif ($line =~ /^J/) {
1619                                 if ($other =~ /J/) {
1620                                         $ix++;
1621                                 }
1622                                 else {
1623                                         error_msg __("No next hunk\n");
1624                                 }
1625                                 next;
1626                         }
1627                         elsif ($line =~ /^k/) {
1628                                 if ($other =~ /k/) {
1629                                         while (1) {
1630                                                 $ix--;
1631                                                 last if (!$ix ||
1632                                                          !defined $hunk[$ix]{USE});
1633                                         }
1634                                 }
1635                                 else {
1636                                         error_msg __("No previous hunk\n");
1637                                 }
1638                                 next;
1639                         }
1640                         elsif ($line =~ /^j/) {
1641                                 if ($other !~ /j/) {
1642                                         error_msg __("No next hunk\n");
1643                                         next;
1644                                 }
1645                         }
1646                         elsif ($line =~ /^s/) {
1647                                 unless ($other =~ /s/) {
1648                                         error_msg __("Sorry, cannot split this hunk\n");
1649                                         next;
1650                                 }
1651                                 my @split = split_hunk($hunk[$ix]{TEXT}, $hunk[$ix]{DISPLAY});
1652                                 if (1 < @split) {
1653                                         print colored $header_color, sprintf(
1654                                                 __n("Split into %d hunk.\n",
1655                                                     "Split into %d hunks.\n",
1656                                                     scalar(@split)), scalar(@split));
1657                                 }
1658                                 splice (@hunk, $ix, 1, @split);
1659                                 $num = scalar @hunk;
1660                                 next;
1661                         }
1662                         elsif ($line =~ /^e/) {
1663                                 unless ($other =~ /e/) {
1664                                         error_msg __("Sorry, cannot edit this hunk\n");
1665                                         next;
1666                                 }
1667                                 my $newhunk = edit_hunk_loop($head, \@hunk, $ix);
1668                                 if (defined $newhunk) {
1669                                         splice @hunk, $ix, 1, $newhunk;
1670                                 }
1671                         }
1672                         else {
1673                                 help_patch_cmd($other);
1674                                 next;
1675                         }
1676                         # soft increment
1677                         while (1) {
1678                                 $ix++;
1679                                 last if ($ix >= $num ||
1680                                          !defined $hunk[$ix]{USE});
1681                         }
1682                 }
1683         }
1684
1685         @hunk = coalesce_overlapping_hunks(@hunk);
1686
1687         my $n_lofs = 0;
1688         my @result = ();
1689         for (@hunk) {
1690                 if ($_->{USE}) {
1691                         push @result, @{$_->{TEXT}};
1692                 }
1693         }
1694
1695         if (@result) {
1696                 my @patch = reassemble_patch($head->{TEXT}, @result);
1697                 my $apply_routine = $patch_mode_flavour{APPLY};
1698                 &$apply_routine(@patch);
1699                 refresh();
1700         }
1701
1702         print "\n";
1703         return $quit;
1704 }
1705
1706 sub diff_cmd {
1707         my @mods = list_modified('index-only');
1708         @mods = grep { !($_->{BINARY}) } @mods;
1709         return if (!@mods);
1710         my (@them) = list_and_choose({ PROMPT => __('Review diff'),
1711                                      IMMEDIATE => 1,
1712                                      HEADER => $status_head, },
1713                                    @mods);
1714         return if (!@them);
1715         my $reference = (is_initial_commit()) ? get_empty_tree() : 'HEAD';
1716         system(qw(git diff -p --cached), $reference, '--',
1717                 map { $_->{VALUE} } @them);
1718 }
1719
1720 sub quit_cmd {
1721         print __("Bye.\n");
1722         exit(0);
1723 }
1724
1725 sub help_cmd {
1726 # TRANSLATORS: please do not translate the command names
1727 # 'status', 'update', 'revert', etc.
1728         print colored $help_color, __ <<'EOF' ;
1729 status        - show paths with changes
1730 update        - add working tree state to the staged set of changes
1731 revert        - revert staged set of changes back to the HEAD version
1732 patch         - pick hunks and update selectively
1733 diff          - view diff between HEAD and index
1734 add untracked - add contents of untracked files to the staged set of changes
1735 EOF
1736 }
1737
1738 sub process_args {
1739         return unless @ARGV;
1740         my $arg = shift @ARGV;
1741         if ($arg =~ /--patch(?:=(.*))?/) {
1742                 if (defined $1) {
1743                         if ($1 eq 'reset') {
1744                                 $patch_mode = 'reset_head';
1745                                 $patch_mode_revision = 'HEAD';
1746                                 $arg = shift @ARGV or die __("missing --");
1747                                 if ($arg ne '--') {
1748                                         $patch_mode_revision = $arg;
1749                                         $patch_mode = ($arg eq 'HEAD' ?
1750                                                        'reset_head' : 'reset_nothead');
1751                                         $arg = shift @ARGV or die __("missing --");
1752                                 }
1753                         } elsif ($1 eq 'checkout') {
1754                                 $arg = shift @ARGV or die __("missing --");
1755                                 if ($arg eq '--') {
1756                                         $patch_mode = 'checkout_index';
1757                                 } else {
1758                                         $patch_mode_revision = $arg;
1759                                         $patch_mode = ($arg eq 'HEAD' ?
1760                                                        'checkout_head' : 'checkout_nothead');
1761                                         $arg = shift @ARGV or die __("missing --");
1762                                 }
1763                         } elsif ($1 eq 'stage' or $1 eq 'stash') {
1764                                 $patch_mode = $1;
1765                                 $arg = shift @ARGV or die __("missing --");
1766                         } else {
1767                                 die sprintf(__("unknown --patch mode: %s"), $1);
1768                         }
1769                 } else {
1770                         $patch_mode = 'stage';
1771                         $arg = shift @ARGV or die __("missing --");
1772                 }
1773                 die sprintf(__("invalid argument %s, expecting --"),
1774                                $arg) unless $arg eq "--";
1775                 %patch_mode_flavour = %{$patch_modes{$patch_mode}};
1776                 $patch_mode_only = 1;
1777         }
1778         elsif ($arg ne "--") {
1779                 die sprintf(__("invalid argument %s, expecting --"), $arg);
1780         }
1781 }
1782
1783 sub main_loop {
1784         my @cmd = ([ 'status', \&status_cmd, ],
1785                    [ 'update', \&update_cmd, ],
1786                    [ 'revert', \&revert_cmd, ],
1787                    [ 'add untracked', \&add_untracked_cmd, ],
1788                    [ 'patch', \&patch_update_cmd, ],
1789                    [ 'diff', \&diff_cmd, ],
1790                    [ 'quit', \&quit_cmd, ],
1791                    [ 'help', \&help_cmd, ],
1792         );
1793         while (1) {
1794                 my ($it) = list_and_choose({ PROMPT => __('What now'),
1795                                              SINGLETON => 1,
1796                                              LIST_FLAT => 4,
1797                                              HEADER => __('*** Commands ***'),
1798                                              ON_EOF => \&quit_cmd,
1799                                              IMMEDIATE => 1 }, @cmd);
1800                 if ($it) {
1801                         eval {
1802                                 $it->[1]->();
1803                         };
1804                         if ($@) {
1805                                 print "$@";
1806                         }
1807                 }
1808         }
1809 }
1810
1811 process_args();
1812 refresh();
1813 if ($patch_mode_only) {
1814         patch_update_cmd();
1815 }
1816 else {
1817         status_cmd();
1818         main_loop();
1819 }