Merge branch 'pd/completion-filenames-fix'
[git] / perl / Git / SVN / Editor.pm
1 package Git::SVN::Editor;
2 use vars qw/@ISA $_rmdir $_cp_similarity $_find_copies_harder $_rename_limit/;
3 use strict;
4 use warnings;
5 use SVN::Core;
6 use SVN::Delta;
7 use Carp qw/croak/;
8 use IO::File;
9 use Git qw/command command_oneline command_noisy command_output_pipe
10            command_input_pipe command_close_pipe
11            command_bidi_pipe command_close_bidi_pipe/;
12 BEGIN {
13         @ISA = qw(SVN::Delta::Editor);
14 }
15
16 sub new {
17         my ($class, $opts) = @_;
18         foreach (qw/svn_path r ra tree_a tree_b log editor_cb/) {
19                 die "$_ required!\n" unless (defined $opts->{$_});
20         }
21
22         my $pool = SVN::Pool->new;
23         my $mods = generate_diff($opts->{tree_a}, $opts->{tree_b});
24         my $types = check_diff_paths($opts->{ra}, $opts->{svn_path},
25                                      $opts->{r}, $mods);
26
27         # $opts->{ra} functions should not be used after this:
28         my @ce  = $opts->{ra}->get_commit_editor($opts->{log},
29                                                 $opts->{editor_cb}, $pool);
30         my $self = SVN::Delta::Editor->new(@ce, $pool);
31         bless $self, $class;
32         foreach (qw/svn_path r tree_a tree_b/) {
33                 $self->{$_} = $opts->{$_};
34         }
35         $self->{url} = $opts->{ra}->{url};
36         $self->{mods} = $mods;
37         $self->{types} = $types;
38         $self->{pool} = $pool;
39         $self->{bat} = { '' => $self->open_root($self->{r}, $self->{pool}) };
40         $self->{rm} = { };
41         $self->{path_prefix} = length $self->{svn_path} ?
42                                "$self->{svn_path}/" : '';
43         $self->{config} = $opts->{config};
44         $self->{mergeinfo} = $opts->{mergeinfo};
45         return $self;
46 }
47
48 sub generate_diff {
49         my ($tree_a, $tree_b) = @_;
50         my @diff_tree = qw(diff-tree -z -r);
51         if ($_cp_similarity) {
52                 push @diff_tree, "-C$_cp_similarity";
53         } else {
54                 push @diff_tree, '-C';
55         }
56         push @diff_tree, '--find-copies-harder' if $_find_copies_harder;
57         push @diff_tree, "-l$_rename_limit" if defined $_rename_limit;
58         push @diff_tree, $tree_a, $tree_b;
59         my ($diff_fh, $ctx) = command_output_pipe(@diff_tree);
60         local $/ = "\0";
61         my $state = 'meta';
62         my @mods;
63         while (<$diff_fh>) {
64                 chomp $_; # this gets rid of the trailing "\0"
65                 if ($state eq 'meta' && /^:(\d{6})\s(\d{6})\s
66                                         ($::sha1)\s($::sha1)\s
67                                         ([MTCRAD])\d*$/xo) {
68                         push @mods, {   mode_a => $1, mode_b => $2,
69                                         sha1_a => $3, sha1_b => $4,
70                                         chg => $5 };
71                         if ($5 =~ /^(?:C|R)$/) {
72                                 $state = 'file_a';
73                         } else {
74                                 $state = 'file_b';
75                         }
76                 } elsif ($state eq 'file_a') {
77                         my $x = $mods[$#mods] or croak "Empty array\n";
78                         if ($x->{chg} !~ /^(?:C|R)$/) {
79                                 croak "Error parsing $_, $x->{chg}\n";
80                         }
81                         $x->{file_a} = $_;
82                         $state = 'file_b';
83                 } elsif ($state eq 'file_b') {
84                         my $x = $mods[$#mods] or croak "Empty array\n";
85                         if (exists $x->{file_a} && $x->{chg} !~ /^(?:C|R)$/) {
86                                 croak "Error parsing $_, $x->{chg}\n";
87                         }
88                         if (!exists $x->{file_a} && $x->{chg} =~ /^(?:C|R)$/) {
89                                 croak "Error parsing $_, $x->{chg}\n";
90                         }
91                         $x->{file_b} = $_;
92                         $state = 'meta';
93                 } else {
94                         croak "Error parsing $_\n";
95                 }
96         }
97         command_close_pipe($diff_fh, $ctx);
98         \@mods;
99 }
100
101 sub check_diff_paths {
102         my ($ra, $pfx, $rev, $mods) = @_;
103         my %types;
104         $pfx .= '/' if length $pfx;
105
106         sub type_diff_paths {
107                 my ($ra, $types, $path, $rev) = @_;
108                 my @p = split m#/+#, $path;
109                 my $c = shift @p;
110                 unless (defined $types->{$c}) {
111                         $types->{$c} = $ra->check_path($c, $rev);
112                 }
113                 while (@p) {
114                         $c .= '/' . shift @p;
115                         next if defined $types->{$c};
116                         $types->{$c} = $ra->check_path($c, $rev);
117                 }
118         }
119
120         foreach my $m (@$mods) {
121                 foreach my $f (qw/file_a file_b/) {
122                         next unless defined $m->{$f};
123                         my ($dir) = ($m->{$f} =~ m#^(.*?)/?(?:[^/]+)$#);
124                         if (length $pfx.$dir && ! defined $types{$dir}) {
125                                 type_diff_paths($ra, \%types, $pfx.$dir, $rev);
126                         }
127                 }
128         }
129         \%types;
130 }
131
132 sub split_path {
133         return ($_[0] =~ m#^(.*?)/?([^/]+)$#);
134 }
135
136 sub repo_path {
137         my ($self, $path) = @_;
138         if (my $enc = $self->{pathnameencoding}) {
139                 require Encode;
140                 Encode::from_to($path, $enc, 'UTF-8');
141         }
142         $self->{path_prefix}.(defined $path ? $path : '');
143 }
144
145 sub url_path {
146         my ($self, $path) = @_;
147         if ($self->{url} =~ m#^https?://#) {
148                 # characters are taken from subversion/libsvn_subr/path.c
149                 $path =~ s#([^~a-zA-Z0-9_./!$&'()*+,-])#sprintf("%%%02X",ord($1))#eg;
150         }
151         $self->{url} . '/' . $self->repo_path($path);
152 }
153
154 sub rmdirs {
155         my ($self) = @_;
156         my $rm = $self->{rm};
157         delete $rm->{''}; # we never delete the url we're tracking
158         return unless %$rm;
159
160         foreach (keys %$rm) {
161                 my @d = split m#/#, $_;
162                 my $c = shift @d;
163                 $rm->{$c} = 1;
164                 while (@d) {
165                         $c .= '/' . shift @d;
166                         $rm->{$c} = 1;
167                 }
168         }
169         delete $rm->{$self->{svn_path}};
170         delete $rm->{''}; # we never delete the url we're tracking
171         return unless %$rm;
172
173         my ($fh, $ctx) = command_output_pipe(qw/ls-tree --name-only -r -z/,
174                                              $self->{tree_b});
175         local $/ = "\0";
176         while (<$fh>) {
177                 chomp;
178                 my @dn = split m#/#, $_;
179                 while (pop @dn) {
180                         delete $rm->{join '/', @dn};
181                 }
182                 unless (%$rm) {
183                         close $fh;
184                         return;
185                 }
186         }
187         command_close_pipe($fh, $ctx);
188
189         my ($r, $p, $bat) = ($self->{r}, $self->{pool}, $self->{bat});
190         foreach my $d (sort { $b =~ tr#/#/# <=> $a =~ tr#/#/# } keys %$rm) {
191                 $self->close_directory($bat->{$d}, $p);
192                 my ($dn) = ($d =~ m#^(.*?)/?(?:[^/]+)$#);
193                 print "\tD+\t$d/\n" unless $::_q;
194                 $self->SUPER::delete_entry($d, $r, $bat->{$dn}, $p);
195                 delete $bat->{$d};
196         }
197 }
198
199 sub open_or_add_dir {
200         my ($self, $full_path, $baton, $deletions) = @_;
201         my $t = $self->{types}->{$full_path};
202         if (!defined $t) {
203                 die "$full_path not known in r$self->{r} or we have a bug!\n";
204         }
205         {
206                 no warnings 'once';
207                 # SVN::Node::none and SVN::Node::file are used only once,
208                 # so we're shutting up Perl's warnings about them.
209                 if ($t == $SVN::Node::none || defined($deletions->{$full_path})) {
210                         return $self->add_directory($full_path, $baton,
211                             undef, -1, $self->{pool});
212                 } elsif ($t == $SVN::Node::dir) {
213                         return $self->open_directory($full_path, $baton,
214                             $self->{r}, $self->{pool});
215                 } # no warnings 'once'
216                 print STDERR "$full_path already exists in repository at ",
217                     "r$self->{r} and it is not a directory (",
218                     ($t == $SVN::Node::file ? 'file' : 'unknown'),"/$t)\n";
219         } # no warnings 'once'
220         exit 1;
221 }
222
223 sub ensure_path {
224         my ($self, $path, $deletions) = @_;
225         my $bat = $self->{bat};
226         my $repo_path = $self->repo_path($path);
227         return $bat->{''} unless (length $repo_path);
228
229         my @p = split m#/+#, $repo_path;
230         my $c = shift @p;
231         $bat->{$c} ||= $self->open_or_add_dir($c, $bat->{''}, $deletions);
232         while (@p) {
233                 my $c0 = $c;
234                 $c .= '/' . shift @p;
235                 $bat->{$c} ||= $self->open_or_add_dir($c, $bat->{$c0}, $deletions);
236         }
237         return $bat->{$c};
238 }
239
240 # Subroutine to convert a globbing pattern to a regular expression.
241 # From perl cookbook.
242 sub glob2pat {
243         my $globstr = shift;
244         my %patmap = ('*' => '.*', '?' => '.', '[' => '[', ']' => ']');
245         $globstr =~ s{(.)} { $patmap{$1} || "\Q$1" }ge;
246         return '^' . $globstr . '$';
247 }
248
249 sub check_autoprop {
250         my ($self, $pattern, $properties, $file, $fbat) = @_;
251         # Convert the globbing pattern to a regular expression.
252         my $regex = glob2pat($pattern);
253         # Check if the pattern matches the file name.
254         if($file =~ m/($regex)/) {
255                 # Parse the list of properties to set.
256                 my @props = split(/;/, $properties);
257                 foreach my $prop (@props) {
258                         # Parse 'name=value' syntax and set the property.
259                         if ($prop =~ /([^=]+)=(.*)/) {
260                                 my ($n,$v) = ($1,$2);
261                                 for ($n, $v) {
262                                         s/^\s+//; s/\s+$//;
263                                 }
264                                 $self->change_file_prop($fbat, $n, $v);
265                         }
266                 }
267         }
268 }
269
270 sub apply_autoprops {
271         my ($self, $file, $fbat) = @_;
272         my $conf_t = ${$self->{config}}{'config'};
273         no warnings 'once';
274         # Check [miscellany]/enable-auto-props in svn configuration.
275         if (SVN::_Core::svn_config_get_bool(
276                 $conf_t,
277                 $SVN::_Core::SVN_CONFIG_SECTION_MISCELLANY,
278                 $SVN::_Core::SVN_CONFIG_OPTION_ENABLE_AUTO_PROPS,
279                 0)) {
280                 # Auto-props are enabled.  Enumerate them to look for matches.
281                 my $callback = sub {
282                         $self->check_autoprop($_[0], $_[1], $file, $fbat);
283                 };
284                 SVN::_Core::svn_config_enumerate(
285                         $conf_t,
286                         $SVN::_Core::SVN_CONFIG_SECTION_AUTO_PROPS,
287                         $callback);
288         }
289 }
290
291 sub check_attr {
292         my ($attr,$path) = @_;
293         my $val = command_oneline("check-attr", $attr, "--", $path);
294         if ($val) { $val =~ s/^[^:]*:\s*[^:]*:\s*(.*)\s*$/$1/; }
295         return $val;
296 }
297
298 sub apply_manualprops {
299         my ($self, $file, $fbat) = @_;
300         my $pending_properties = check_attr( "svn-properties", $file );
301         if ($pending_properties eq "") { return; }
302         # Parse the list of properties to set.
303         my @props = split(/;/, $pending_properties);
304         # TODO: get existing properties to compare to
305         # - this fails for add so currently not done
306         # my $existing_props = ::get_svnprops($file);
307         my $existing_props = {};
308         # TODO: caching svn properties or storing them in .gitattributes
309         # would make that faster
310         foreach my $prop (@props) {
311                 # Parse 'name=value' syntax and set the property.
312                 if ($prop =~ /([^=]+)=(.*)/) {
313                         my ($n,$v) = ($1,$2);
314                         for ($n, $v) {
315                                 s/^\s+//; s/\s+$//;
316                         }
317                         my $existing = $existing_props->{$n};
318                         if (!defined($existing) || $existing ne $v) {
319                             $self->change_file_prop($fbat, $n, $v);
320                         }
321                 }
322         }
323 }
324
325 sub A {
326         my ($self, $m, $deletions) = @_;
327         my ($dir, $file) = split_path($m->{file_b});
328         my $pbat = $self->ensure_path($dir, $deletions);
329         my $fbat = $self->add_file($self->repo_path($m->{file_b}), $pbat,
330                                         undef, -1);
331         print "\tA\t$m->{file_b}\n" unless $::_q;
332         $self->apply_autoprops($file, $fbat);
333         $self->apply_manualprops($m->{file_b}, $fbat);
334         $self->chg_file($fbat, $m);
335         $self->close_file($fbat,undef,$self->{pool});
336 }
337
338 sub C {
339         my ($self, $m, $deletions) = @_;
340         my ($dir, $file) = split_path($m->{file_b});
341         my $pbat = $self->ensure_path($dir, $deletions);
342         # workaround for a bug in svn serf backend (v1.8.5 and below):
343         # store third argument to ->add_file() in a local variable, to make it
344         # have the same lifetime as $fbat
345         my $upa = $self->url_path($m->{file_a});
346         my $fbat = $self->add_file($self->repo_path($m->{file_b}), $pbat,
347                                 $upa, $self->{r});
348         print "\tC\t$m->{file_a} => $m->{file_b}\n" unless $::_q;
349         $self->apply_manualprops($m->{file_b}, $fbat);
350         $self->chg_file($fbat, $m);
351         $self->close_file($fbat,undef,$self->{pool});
352 }
353
354 sub delete_entry {
355         my ($self, $path, $pbat) = @_;
356         my $rpath = $self->repo_path($path);
357         my ($dir, $file) = split_path($rpath);
358         $self->{rm}->{$dir} = 1;
359         $self->SUPER::delete_entry($rpath, $self->{r}, $pbat, $self->{pool});
360 }
361
362 sub R {
363         my ($self, $m, $deletions) = @_;
364         my ($dir, $file) = split_path($m->{file_b});
365         my $pbat = $self->ensure_path($dir, $deletions);
366         # workaround for a bug in svn serf backend, see comment in C() above
367         my $upa = $self->url_path($m->{file_a});
368         my $fbat = $self->add_file($self->repo_path($m->{file_b}), $pbat,
369                                 $upa, $self->{r});
370         print "\tR\t$m->{file_a} => $m->{file_b}\n" unless $::_q;
371         $self->apply_autoprops($file, $fbat);
372         $self->apply_manualprops($m->{file_b}, $fbat);
373         $self->chg_file($fbat, $m);
374         $self->close_file($fbat,undef,$self->{pool});
375
376         ($dir, $file) = split_path($m->{file_a});
377         $pbat = $self->ensure_path($dir, $deletions);
378         $self->delete_entry($m->{file_a}, $pbat);
379 }
380
381 sub M {
382         my ($self, $m, $deletions) = @_;
383         my ($dir, $file) = split_path($m->{file_b});
384         my $pbat = $self->ensure_path($dir, $deletions);
385         my $fbat = $self->open_file($self->repo_path($m->{file_b}),
386                                 $pbat,$self->{r},$self->{pool});
387         print "\t$m->{chg}\t$m->{file_b}\n" unless $::_q;
388         $self->apply_manualprops($m->{file_b}, $fbat);
389         $self->chg_file($fbat, $m);
390         $self->close_file($fbat,undef,$self->{pool});
391 }
392
393 sub T {
394         my ($self, $m, $deletions) = @_;
395
396         # Work around subversion issue 4091: toggling the "is a
397         # symlink" property requires removing and re-adding a
398         # file or else "svn up" on affected clients trips an
399         # assertion and aborts.
400         if (($m->{mode_b} =~ /^120/ && $m->{mode_a} !~ /^120/) ||
401             ($m->{mode_b} !~ /^120/ && $m->{mode_a} =~ /^120/)) {
402                 $self->D({
403                         mode_a => $m->{mode_a}, mode_b => '000000',
404                         sha1_a => $m->{sha1_a}, sha1_b => '0' x 40,
405                         chg => 'D', file_b => $m->{file_b}
406                 }, $deletions);
407                 $self->A({
408                         mode_a => '000000', mode_b => $m->{mode_b},
409                         sha1_a => '0' x 40, sha1_b => $m->{sha1_b},
410                         chg => 'A', file_b => $m->{file_b}
411                 }, $deletions);
412                 return;
413         }
414
415         $self->M($m, $deletions);
416 }
417
418 sub change_file_prop {
419         my ($self, $fbat, $pname, $pval) = @_;
420         $self->SUPER::change_file_prop($fbat, $pname, $pval, $self->{pool});
421 }
422
423 sub change_dir_prop {
424         my ($self, $pbat, $pname, $pval) = @_;
425         $self->SUPER::change_dir_prop($pbat, $pname, $pval, $self->{pool});
426 }
427
428 sub _chg_file_get_blob ($$$$) {
429         my ($self, $fbat, $m, $which) = @_;
430         my $fh = $::_repository->temp_acquire("git_blob_$which");
431         if ($m->{"mode_$which"} =~ /^120/) {
432                 print $fh 'link ' or croak $!;
433                 $self->change_file_prop($fbat,'svn:special','*');
434         } elsif ($m->{mode_a} =~ /^120/ && $m->{"mode_$which"} !~ /^120/) {
435                 $self->change_file_prop($fbat,'svn:special',undef);
436         }
437         my $blob = $m->{"sha1_$which"};
438         return ($fh,) if ($blob =~ /^0{40}$/);
439         my $size = $::_repository->cat_blob($blob, $fh);
440         croak "Failed to read object $blob" if ($size < 0);
441         $fh->flush == 0 or croak $!;
442         seek $fh, 0, 0 or croak $!;
443
444         my $exp = ::md5sum($fh);
445         seek $fh, 0, 0 or croak $!;
446         return ($fh, $exp);
447 }
448
449 sub chg_file {
450         my ($self, $fbat, $m) = @_;
451         if ($m->{mode_b} =~ /755$/ && $m->{mode_a} !~ /755$/) {
452                 $self->change_file_prop($fbat,'svn:executable','*');
453         } elsif ($m->{mode_b} !~ /755$/ && $m->{mode_a} =~ /755$/) {
454                 $self->change_file_prop($fbat,'svn:executable',undef);
455         }
456         my ($fh_a, $exp_a) = _chg_file_get_blob $self, $fbat, $m, 'a';
457         my ($fh_b, $exp_b) = _chg_file_get_blob $self, $fbat, $m, 'b';
458         my $pool = SVN::Pool->new;
459         my $atd = $self->apply_textdelta($fbat, $exp_a, $pool);
460         if (-s $fh_a) {
461                 my $txstream = SVN::TxDelta::new ($fh_a, $fh_b, $pool);
462                 my $res = SVN::TxDelta::send_txstream($txstream, @$atd, $pool);
463                 if (defined $res) {
464                         die "Unexpected result from send_txstream: $res\n",
465                             "(SVN::Core::VERSION: $SVN::Core::VERSION)\n";
466                 }
467         } else {
468                 my $got = SVN::TxDelta::send_stream($fh_b, @$atd, $pool);
469                 die "Checksum mismatch\nexpected: $exp_b\ngot: $got\n"
470                     if ($got ne $exp_b);
471         }
472         Git::temp_release($fh_b, 1);
473         Git::temp_release($fh_a, 1);
474         $pool->clear;
475 }
476
477 sub D {
478         my ($self, $m, $deletions) = @_;
479         my ($dir, $file) = split_path($m->{file_b});
480         my $pbat = $self->ensure_path($dir, $deletions);
481         print "\tD\t$m->{file_b}\n" unless $::_q;
482         $self->delete_entry($m->{file_b}, $pbat);
483 }
484
485 sub close_edit {
486         my ($self) = @_;
487         my ($p,$bat) = ($self->{pool}, $self->{bat});
488         foreach (sort { $b =~ tr#/#/# <=> $a =~ tr#/#/# } keys %$bat) {
489                 next if $_ eq '';
490                 $self->close_directory($bat->{$_}, $p);
491         }
492         $self->close_directory($bat->{''}, $p);
493         $self->SUPER::close_edit($p);
494         $p->clear;
495 }
496
497 sub abort_edit {
498         my ($self) = @_;
499         $self->SUPER::abort_edit($self->{pool});
500 }
501
502 sub DESTROY {
503         my $self = shift;
504         $self->SUPER::DESTROY(@_);
505         $self->{pool}->clear;
506 }
507
508 # this drives the editor
509 sub apply_diff {
510         my ($self) = @_;
511         my $mods = $self->{mods};
512         my %o = ( D => 0, C => 1, R => 2, A => 3, M => 4, T => 5 );
513         my %deletions;
514
515         foreach my $m (@$mods) {
516                 if ($m->{chg} eq "D") {
517                         $deletions{$m->{file_b}} = 1;
518                 }
519         }
520
521         foreach my $m (sort { $o{$a->{chg}} <=> $o{$b->{chg}} } @$mods) {
522                 my $f = $m->{chg};
523                 if (defined $o{$f}) {
524                         $self->$f($m, \%deletions);
525                 } else {
526                         fatal("Invalid change type: $f");
527                 }
528         }
529
530         if (defined($self->{mergeinfo})) {
531                 $self->change_dir_prop($self->{bat}{''}, "svn:mergeinfo",
532                                        $self->{mergeinfo});
533         }
534         $self->rmdirs if $_rmdir;
535         if (@$mods == 0 && !defined($self->{mergeinfo})) {
536                 $self->abort_edit;
537         } else {
538                 $self->close_edit;
539         }
540         return scalar @$mods;
541 }
542
543 1;
544 __END__
545
546 =head1 NAME
547
548 Git::SVN::Editor - commit driver for "git svn set-tree" and dcommit
549
550 =head1 SYNOPSIS
551
552         use Git::SVN::Editor;
553         use Git::SVN::Ra;
554
555         my $ra = Git::SVN::Ra->new($url);
556         my %opts = (
557                 r => 19,
558                 log => "log message",
559                 ra => $ra,
560                 config => SVN::Core::config_get_config($svn_config_dir),
561                 tree_a => "$commit^",
562                 tree_b => "$commit",
563                 editor_cb => sub { print "Committed r$_[0]\n"; },
564                 mergeinfo => "/branches/foo:1-10",
565                 svn_path => "trunk"
566         );
567         Git::SVN::Editor->new(\%opts)->apply_diff or print "No changes\n";
568
569         my $re = Git::SVN::Editor::glob2pat("trunk/*");
570         if ($branchname =~ /$re/) {
571                 print "matched!\n";
572         }
573
574 =head1 DESCRIPTION
575
576 This module is an implementation detail of the "git svn" command.
577 Do not use it unless you are developing git-svn.
578
579 This module adapts the C<SVN::Delta::Editor> object returned by
580 C<SVN::Delta::get_commit_editor> and drives it to convey the
581 difference between two git tree objects to a remote Subversion
582 repository.
583
584 The interface will change as git-svn evolves.
585
586 =head1 DEPENDENCIES
587
588 Subversion perl bindings,
589 the core L<Carp> and L<IO::File> modules,
590 and git's L<Git> helper module.
591
592 C<Git::SVN::Editor> has not been tested using callers other than
593 B<git-svn> itself.
594
595 =head1 SEE ALSO
596
597 L<SVN::Delta>,
598 L<Git::SVN::Fetcher>.
599
600 =head1 INCOMPATIBILITIES
601
602 None reported.
603
604 =head1 BUGS
605
606 None.