Merge branch 'mg/gpg-interface-using-status'
[git] / contrib / examples / git-rerere.perl
1 #!/usr/bin/perl
2 #
3 # REuse REcorded REsolve.  This tool records a conflicted automerge
4 # result and its hand resolution, and helps to resolve future
5 # automerge that results in the same conflict.
6 #
7 # To enable this feature, create a directory 'rr-cache' under your
8 # .git/ directory.
9
10 use Digest;
11 use File::Path;
12 use File::Copy;
13
14 my $git_dir = $::ENV{GIT_DIR} || ".git";
15 my $rr_dir = "$git_dir/rr-cache";
16 my $merge_rr = "$git_dir/rr-cache/MERGE_RR";
17
18 my %merge_rr = ();
19
20 sub read_rr {
21         if (!-f $merge_rr) {
22                 %merge_rr = ();
23                 return;
24         }
25         my $in;
26         local $/ = "\0";
27         open $in, "<$merge_rr" or die "$!: $merge_rr";
28         while (<$in>) {
29                 chomp;
30                 my ($name, $path) = /^([0-9a-f]{40})\t(.*)$/s;
31                 $merge_rr{$path} = $name;
32         }
33         close $in;
34 }
35
36 sub write_rr {
37         my $out;
38         open $out, ">$merge_rr" or die "$!: $merge_rr";
39         for my $path (sort keys %merge_rr) {
40                 my $name = $merge_rr{$path};
41                 print $out "$name\t$path\0";
42         }
43         close $out;
44 }
45
46 sub compute_conflict_name {
47         my ($path) = @_;
48         my @side = ();
49         my $in;
50         open $in, "<$path"  or die "$!: $path";
51
52         my $sha1 = Digest->new("SHA-1");
53         my $hunk = 0;
54         while (<$in>) {
55                 if (/^<<<<<<< .*/) {
56                         $hunk++;
57                         @side = ([], undef);
58                 }
59                 elsif (/^=======$/) {
60                         $side[1] = [];
61                 }
62                 elsif (/^>>>>>>> .*/) {
63                         my ($one, $two);
64                         $one = join('', @{$side[0]});
65                         $two = join('', @{$side[1]});
66                         if ($two le $one) {
67                                 ($one, $two) = ($two, $one);
68                         }
69                         $sha1->add($one);
70                         $sha1->add("\0");
71                         $sha1->add($two);
72                         $sha1->add("\0");
73                         @side = ();
74                 }
75                 elsif (@side == 0) {
76                         next;
77                 }
78                 elsif (defined $side[1]) {
79                         push @{$side[1]}, $_;
80                 }
81                 else {
82                         push @{$side[0]}, $_;
83                 }
84         }
85         close $in;
86         return ($sha1->hexdigest, $hunk);
87 }
88
89 sub record_preimage {
90         my ($path, $name) = @_;
91         my @side = ();
92         my ($in, $out);
93         open $in, "<$path"  or die "$!: $path";
94         open $out, ">$name" or die "$!: $name";
95
96         while (<$in>) {
97                 if (/^<<<<<<< .*/) {
98                         @side = ([], undef);
99                 }
100                 elsif (/^=======$/) {
101                         $side[1] = [];
102                 }
103                 elsif (/^>>>>>>> .*/) {
104                         my ($one, $two);
105                         $one = join('', @{$side[0]});
106                         $two = join('', @{$side[1]});
107                         if ($two le $one) {
108                                 ($one, $two) = ($two, $one);
109                         }
110                         print $out "<<<<<<<\n";
111                         print $out $one;
112                         print $out "=======\n";
113                         print $out $two;
114                         print $out ">>>>>>>\n";
115                         @side = ();
116                 }
117                 elsif (@side == 0) {
118                         print $out $_;
119                 }
120                 elsif (defined $side[1]) {
121                         push @{$side[1]}, $_;
122                 }
123                 else {
124                         push @{$side[0]}, $_;
125                 }
126         }
127         close $out;
128         close $in;
129 }
130
131 sub find_conflict {
132         my $in;
133         local $/ = "\0";
134         my $pid = open($in, '-|');
135         die "$!" unless defined $pid;
136         if (!$pid) {
137                 exec(qw(git ls-files -z -u)) or die "$!: ls-files";
138         }
139         my %path = ();
140         my @path = ();
141         while (<$in>) {
142                 chomp;
143                 my ($mode, $sha1, $stage, $path) =
144                     /^([0-7]+) ([0-9a-f]{40}) ([123])\t(.*)$/s;
145                 $path{$path} |= (1 << $stage);
146         }
147         close $in;
148         while (my ($path, $status) = each %path) {
149                 if ($status == 14) { push @path, $path; }
150         }
151         return @path;
152 }
153
154 sub merge {
155         my ($name, $path) = @_;
156         record_preimage($path, "$rr_dir/$name/thisimage");
157         unless (system('git', 'merge-file', map { "$rr_dir/$name/${_}image" }
158                        qw(this pre post))) {
159                 my $in;
160                 open $in, "<$rr_dir/$name/thisimage" or
161                     die "$!: $name/thisimage";
162                 my $out;
163                 open $out, ">$path" or die "$!: $path";
164                 while (<$in>) { print $out $_; }
165                 close $in;
166                 close $out;
167                 return 1;
168         }
169         return 0;
170 }
171
172 sub garbage_collect_rerere {
173         # We should allow specifying these from the command line and
174         # that is why the caller gives @ARGV to us, but I am lazy.
175
176         my $cutoff_noresolve = 15; # two weeks
177         my $cutoff_resolve = 60; # two months
178         my @to_remove;
179         while (<$rr_dir/*/preimage>) {
180                 my ($dir) = /^(.*)\/preimage$/;
181                 my $cutoff = ((-f "$dir/postimage")
182                               ? $cutoff_resolve
183                               : $cutoff_noresolve);
184                 my $age = -M "$_";
185                 if ($cutoff <= $age) {
186                         push @to_remove, $dir;
187                 }
188         }
189         if (@to_remove) {
190                 rmtree(\@to_remove);
191         }
192 }
193
194 -d "$rr_dir" || exit(0);
195
196 read_rr();
197
198 if (@ARGV) {
199         my $arg = shift @ARGV;
200         if ($arg eq 'clear') {
201                 for my $path (keys %merge_rr) {
202                         my $name = $merge_rr{$path};
203                         if (-d "$rr_dir/$name" &&
204                             ! -f "$rr_dir/$name/postimage") {
205                                 rmtree(["$rr_dir/$name"]);
206                         }
207                 }
208                 unlink $merge_rr;
209         }
210         elsif ($arg eq 'status') {
211                 for my $path (keys %merge_rr) {
212                         print $path, "\n";
213                 }
214         }
215         elsif ($arg eq 'diff') {
216                 for my $path (keys %merge_rr) {
217                         my $name = $merge_rr{$path};
218                         system('diff', ((@ARGV == 0) ? ('-u') : @ARGV),
219                                 '-L', "a/$path", '-L', "b/$path",
220                                 "$rr_dir/$name/preimage", $path);
221                 }
222         }
223         elsif ($arg eq 'gc') {
224                 garbage_collect_rerere(@ARGV);
225         }
226         else {
227                 die "$0 unknown command: $arg\n";
228         }
229         exit 0;
230 }
231
232 my %conflict = map { $_ => 1 } find_conflict();
233
234 # MERGE_RR records paths with conflicts immediately after merge
235 # failed.  Some of the conflicted paths might have been hand resolved
236 # in the working tree since then, but the initial run would catch all
237 # and register their preimages.
238
239 for my $path (keys %conflict) {
240         # This path has conflict.  If it is not recorded yet,
241         # record the pre-image.
242         if (!exists $merge_rr{$path}) {
243                 my ($name, $hunk) = compute_conflict_name($path);
244                 next unless ($hunk);
245                 $merge_rr{$path} = $name;
246                 if (! -d "$rr_dir/$name") {
247                         mkpath("$rr_dir/$name", 0, 0777);
248                         print STDERR "Recorded preimage for '$path'\n";
249                         record_preimage($path, "$rr_dir/$name/preimage");
250                 }
251         }
252 }
253
254 # Now some of the paths that had conflicts earlier might have been
255 # hand resolved.  Others may be similar to a conflict already that
256 # was resolved before.
257
258 for my $path (keys %merge_rr) {
259         my $name = $merge_rr{$path};
260
261         # We could resolve this automatically if we have images.
262         if (-f "$rr_dir/$name/preimage" &&
263             -f "$rr_dir/$name/postimage") {
264                 if (merge($name, $path)) {
265                         print STDERR "Resolved '$path' using previous resolution.\n";
266                         # Then we do not have to worry about this path
267                         # anymore.
268                         delete $merge_rr{$path};
269                         next;
270                 }
271         }
272
273         # Let's see if we have resolved it.
274         (undef, my $hunk) = compute_conflict_name($path);
275         next if ($hunk);
276
277         print STDERR "Recorded resolution for '$path'.\n";
278         copy($path, "$rr_dir/$name/postimage");
279         # And we do not have to worry about this path anymore.
280         delete $merge_rr{$path};
281 }
282
283 # Write out the rest.
284 write_rr();