manpages: insert two missing [verse] markers for multi-line SYNOPSIS
[gitweb.git] / git-svnimport.perl
index 20a85724cb1660a3411fa34717cd5f1e98ebd731..639aa41861a734aab225479be7524c972191da70 100755 (executable)
 # The head revision is on branch "origin" by default.
 # You can change that with the '-o' option.
 
-require v5.8.0; # for shell-safe open("-|",LIST)
 use strict;
 use warnings;
 use Getopt::Std;
+use File::Copy;
 use File::Spec;
 use File::Temp qw(tempfile);
 use File::Path qw(mkpath);
 use SVN::Core;
 use SVN::Ra;
 
-die "Need CVN:Core 1.2.1 or better" if $SVN::Core::VERSION lt "1.2.1";
+die "Need SVN:Core 1.2.1 or better" if $SVN::Core::VERSION lt "1.2.1";
 
 $SIG{'PIPE'}="IGNORE";
 $ENV{'TZ'}="UTC";
 
-our($opt_h,$opt_o,$opt_v,$opt_u,$opt_C,$opt_i,$opt_m,$opt_M,$opt_t,$opt_T,$opt_b,$opt_s,$opt_l,$opt_d,$opt_D);
+our($opt_h,$opt_o,$opt_v,$opt_u,$opt_C,$opt_i,$opt_m,$opt_M,$opt_t,$opt_T,
+    $opt_b,$opt_r,$opt_I,$opt_A,$opt_s,$opt_l,$opt_d,$opt_D);
 
 sub usage() {
        print STDERR <<END;
-Usage: ${\basename $0}     # fetch/update GIT from CVS
-       [-o branch-for-HEAD] [-h] [-v] [-l max_num_changes]
+Usage: ${\basename $0}     # fetch/update GIT from SVN
+       [-o branch-for-HEAD] [-h] [-v] [-l max_rev]
        [-C GIT_repository] [-t tagname] [-T trunkname] [-b branchname]
-       [-d|-D] [-i] [-u] [-s start_chg] [-m] [-M regex] [SVN_URL]
+       [-d|-D] [-i] [-u] [-r] [-I ignorefilename] [-s start_chg]
+       [-m] [-M regex] [-A author_file] [SVN_URL]
 END
        exit(1);
 }
 
-getopts("b:C:dDhil:mM:o:s:t:T:uv") or usage();
+getopts("A:b:C:dDhiI:l:mM:o:rs:t:T:uv") or usage();
 usage if $opt_h;
 
 my $tag_name = $opt_t || "tags";
@@ -53,7 +55,6 @@ END
 
 $opt_o ||= "origin";
 $opt_s ||= 1;
-$opt_l = 100 unless defined $opt_l;
 my $git_tree = $opt_C;
 $git_tree ||= ".";
 
@@ -68,6 +69,25 @@ END
        push (@mergerx, qr/$opt_M/);
 }
 
+# Absolutize filename now, since we will have chdir'ed by the time we
+# get around to opening it.
+$opt_A = File::Spec->rel2abs($opt_A) if $opt_A;
+
+our %users = ();
+our $users_file = undef;
+sub read_users($) {
+       $users_file = File::Spec->rel2abs(@_);
+       die "Cannot open $users_file\n" unless -f $users_file;
+       open(my $authors,$users_file);
+       while(<$authors>) {
+               chomp;
+               next unless /^(\S+?)\s*=\s*(.+?)\s*<(.+)>\s*$/;
+               (my $user,my $name,my $email) = ($1,$2,$3);
+               $users{$user} = [$name,$email];
+       }
+       close($authors);
+}
+
 select(STDERR); $|=1; select(STDOUT);
 
 
@@ -97,8 +117,10 @@ sub new {
 sub conn {
        my $self = shift;
        my $repo = $self->{'fullrep'};
-       my $s = SVN::Ra->new($repo);
-
+       my $auth = SVN::Core::auth_open ([SVN::Client::get_simple_provider,
+                         SVN::Client::get_ssl_server_trust_file_provider,
+                         SVN::Client::get_username_provider]);
+       my $s = SVN::Ra->new(url => $repo, auth => $auth);
        die "SVN connection to $repo: $!\n" unless defined $s;
        $self->{'svn'} = $s;
        $self->{'repo'} = $repo;
@@ -112,21 +134,48 @@ sub file {
                    DIR => File::Spec->tmpdir(), UNLINK => 1);
 
        print "... $rev $path ...\n" if $opt_v;
-       eval { $self->{'svn'}->get_file($path,$rev,$fh); };
+       my (undef, $properties);
+       eval { (undef, $properties)
+                  = $self->{'svn'}->get_file($path,$rev,$fh); };
        if($@) {
                return undef if $@ =~ /Attempted to get checksum/;
                die $@;
        }
+       my $mode;
+       if (exists $properties->{'svn:executable'}) {
+               $mode = '0755';
+       } else {
+               $mode = '0644';
+       }
        close ($fh);
 
-       return $name;
+       return ($name, $mode);
+}
+
+sub ignore {
+       my($self,$path,$rev) = @_;
+
+       print "... $rev $path ...\n" if $opt_v;
+       my (undef,undef,$properties)
+           = $self->{'svn'}->get_dir($path,$rev,undef);
+       if (exists $properties->{'svn:ignore'}) {
+               my ($fh, $name) = tempfile('gitsvn.XXXXXX',
+                                          DIR => File::Spec->tmpdir(),
+                                          UNLINK => 1);
+               print $fh $properties->{'svn:ignore'};
+               close($fh);
+               return $name;
+       } else {
+               return undef;
+       }
 }
 
 package main;
 use URI;
 
-my $svn = $svn_url;
+our $svn = $svn_url;
 $svn .= "/$svn_dir" if defined $svn_dir;
+my $svn2 = SVNconn->new($svn);
 $svn = SVNconn->new($svn);
 
 my $lwp_ua;
@@ -197,7 +246,7 @@ ($$)
 my $maxnum = 0;
 my $last_rev = "";
 my $last_branch;
-my $current_rev = $opt_s-1;
+my $current_rev = $opt_s || 1;
 unless(-d $git_dir) {
        system("git-init-db");
        die "Cannot init the GIT db at $git_tree: $?\n" if $?;
@@ -215,7 +264,11 @@ ($$)
        -f "$git_dir/svn2git"
                or die "'$git_dir/svn2git' does not exist.\n".
                       "You need that file for incremental imports.\n";
-       $last_branch = basename(readlink("$git_dir/HEAD"));
+       open(F, "git-symbolic-ref HEAD |") or
+               die "Cannot run git-symbolic-ref: $!\n";
+       chomp ($last_branch = <F>);
+       $last_branch = basename($last_branch);
+       close(F);
        unless($last_branch) {
                warn "Cannot read the last branch name: $! -- assuming 'master'\n";
                $last_branch = "master";
@@ -249,19 +302,34 @@ ($$)
                my($num,$branch,$ref) = split;
                $branches{$branch}{$num} = $ref;
                $branches{$branch}{"LAST"} = $ref;
-               $current_rev = $num if $current_rev < $num;
+               $current_rev = $num+1 if $current_rev <= $num;
        }
        close($B);
 }
 -d $git_dir
        or die "Could not create git subdir ($git_dir).\n";
 
+my $default_authors = "$git_dir/svn-authors";
+if ($opt_A) {
+       read_users($opt_A);
+       copy($opt_A,$default_authors) or die "Copy failed: $!";
+} else {
+       read_users($default_authors) if -f $default_authors;
+}
+
 open BRANCHES,">>", "$git_dir/svn2git";
 
-sub get_file($$$) {
-       my($rev,$branch,$path) = @_;
+sub node_kind($$$) {
+       my ($branch, $path, $revision) = @_;
+       my $pool=SVN::Pool->new;
+       my $kind = $svn->{'svn'}->check_path(revert_split_path($branch,$path),$revision,$pool);
+       $pool->clear;
+       return $kind;
+}
+
+sub revert_split_path($$) {
+       my($branch,$path) = @_;
 
-       # revert split_path(), below
        my $svnpath;
        $path = "" if $path eq "/"; # this should not happen, but ...
        if($branch eq "/") {
@@ -272,8 +340,17 @@ ($$$)
                $svnpath = "$branch_name/$branch/$path";
        }
 
+       $svnpath =~ s#/+$##;
+       return $svnpath;
+}
+
+sub get_file($$$) {
+       my($rev,$branch,$path) = @_;
+
+       my $svnpath = revert_split_path($branch,$path);
+
        # now get it
-       my $name;
+       my ($name,$mode);
        if($opt_d) {
                my($req,$res);
 
@@ -293,21 +370,53 @@ ($$$)
                        return undef if $res->code == 301; # directory?
                        die $res->status_line." at $url\n";
                }
+               $mode = '0644'; # can't obtain mode via direct http request?
        } else {
-               $name = $svn->file("/$svnpath",$rev);
+               ($name,$mode) = $svn->file("$svnpath",$rev);
                return undef unless defined $name;
        }
 
-       open my $F, '-|', "git-hash-object", "-w", $name
+       my $pid = open(my $F, '-|');
+       die $! unless defined $pid;
+       if (!$pid) {
+           exec("git-hash-object", "-w", $name)
                or die "Cannot create object: $!\n";
+       }
        my $sha = <$F>;
        chomp $sha;
        close $F;
        unlink $name;
-       my $mode = "0644"; # SV does not seem to store any file modes
        return [$mode, $sha, $path];
 }
 
+sub get_ignore($$$$$) {
+       my($new,$old,$rev,$branch,$path) = @_;
+
+       return unless $opt_I;
+       my $svnpath = revert_split_path($branch,$path);
+       my $name = $svn->ignore("$svnpath",$rev);
+       if ($path eq '/') {
+               $path = $opt_I;
+       } else {
+               $path = File::Spec->catfile($path,$opt_I);
+       }
+       if (defined $name) {
+               my $pid = open(my $F, '-|');
+               die $! unless defined $pid;
+               if (!$pid) {
+                       exec("git-hash-object", "-w", $name)
+                           or die "Cannot create object: $!\n";
+               }
+               my $sha = <$F>;
+               chomp $sha;
+               close $F;
+               unlink $name;
+               push(@$new,['0644',$sha,$path]);
+       } else {
+               push(@$old,$path);
+       }
+}
+
 sub split_path($$) {
        my($rev,$path) = @_;
        my $branch;
@@ -319,38 +428,79 @@ ($$)
        } elsif($path =~ s#^/\Q$branch_name\E/([^/]+)/?##) {
                $branch = $1;
        } else {
-               print STDERR "$rev: Unrecognized path: $path\n";
+               my %no_error = (
+                       "/" => 1,
+                       "/$tag_name" => 1,
+                       "/$branch_name" => 1
+               );
+               print STDERR "$rev: Unrecognized path: $path\n" unless (defined $no_error{$path});
                return ()
        }
        $path = "/" if $path eq "";
        return ($branch,$path);
 }
 
-sub copy_subdir($$$$$$) {
+sub branch_rev($$) {
+
+       my ($srcbranch,$uptorev) = @_;
+
+       my $bbranches = $branches{$srcbranch};
+       my @revs = reverse sort { ($a eq 'LAST' ? 0 : $a) <=> ($b eq 'LAST' ? 0 : $b) } keys %$bbranches;
+       my $therev;
+       foreach my $arev(@revs) {
+               next if  ($arev eq 'LAST');
+               if ($arev <= $uptorev) {
+                       $therev = $arev;
+                       last;
+               }
+       }
+       return $therev;
+}
+
+sub copy_path($$$$$$$$) {
        # Somebody copied a whole subdirectory.
        # We need to find the index entries from the old version which the
        # SVN log entry points to, and add them to the new place.
 
-       my($newrev,$newbranch,$path,$oldpath,$rev,$new) = @_;
-       my($branch,$srcpath) = split_path($rev,$oldpath);
+       my($newrev,$newbranch,$path,$oldpath,$rev,$node_kind,$new,$parents) = @_;
 
-       my $gitrev = $branches{$branch}{$rev};
+       my($srcbranch,$srcpath) = split_path($rev,$oldpath);
+       unless(defined $srcbranch) {
+               print "Path not found when copying from $oldpath @ $rev\n";
+               return;
+       }
+       my $therev = branch_rev($srcbranch, $rev);
+       my $gitrev = $branches{$srcbranch}{$therev};
        unless($gitrev) {
                print STDERR "$newrev:$newbranch: could not find $oldpath \@ $rev\n";
                return;
        }
-       print "$newrev:$newbranch:$path: copying from $branch:$srcpath @ $rev\n" if $opt_v;
-       $srcpath =~ s#/*$#/#;
-       open my $f,"-|","git-ls-tree","-r","-z",$gitrev,$srcpath;
+       if ($srcbranch ne $newbranch) {
+               push(@$parents, $branches{$srcbranch}{'LAST'});
+       }
+       print "$newrev:$newbranch:$path: copying from $srcbranch:$srcpath @ $rev\n" if $opt_v;
+       if ($node_kind eq $SVN::Node::dir) {
+                       $srcpath =~ s#/*$#/#;
+       }
+       
+       my $pid = open my $f,'-|';
+       die $! unless defined $pid;
+       if (!$pid) {
+               exec("git-ls-tree","-r","-z",$gitrev,$srcpath)
+                       or die $!;
+       }
        local $/ = "\0";
        while(<$f>) {
                chomp;
                my($m,$p) = split(/\t/,$_,2);
                my($mode,$type,$sha1) = split(/ /,$m);
                next if $type ne "blob";
-               $p = substr($p,length($srcpath)-1);
-               print "... found $path$p ...\n" if $opt_v;
-               push(@$new,[$mode,$sha1,$path.$p]);
+               if ($node_kind eq $SVN::Node::dir) {
+                       $p = $path . substr($p,length($srcpath)-1);
+               } else {
+                       $p = $path;
+               }
+               push(@$new,[$mode,$sha1,$p]);   
        }
        close($f) or
                print STDERR "$newrev:$newbranch: could not list files in $oldpath \@ $rev\n";
@@ -359,10 +509,14 @@ ($$$$$$)
 sub commit {
        my($branch, $changed_paths, $revision, $author, $date, $message) = @_;
        my($author_name,$author_email,$dest);
-       my(@old,@new);
+       my(@old,@new,@parents);
 
        if (not defined $author) {
                $author_name = $author_email = "unknown";
+       } elsif (defined $users_file) {
+               die "User $author is not listed in $users_file\n"
+                   unless exists $users{$author};
+               ($author_name,$author_email) = @{$users{$author}};
        } elsif ($author =~ /^(.*?)\s+<(.*)>$/) {
                ($author_name, $author_email) = ($1, $2);
        } else {
@@ -446,6 +600,8 @@ sub commit {
                $last_rev = $rev;
        }
 
+       push (@parents, $rev) if defined $rev;
+
        my $cid;
        if($tag and not %$changed_paths) {
                $cid = $rev;
@@ -454,61 +610,70 @@ sub commit {
                foreach my $path(@paths) {
                        my $action = $changed_paths->{$path};
 
-                       if ($action->[0] eq "A") {
-                               my $f = get_file($revision,$branch,$path);
-                               if($f) {
-                                       push(@new,$f) if $f;
-                               } elsif($action->[1]) {
-                                       copy_subdir($revision,$branch,$path,$action->[1],$action->[2],\@new);
-                               } else {
-                                       my $opath = $action->[3];
-                                       print STDERR "$revision: $branch: could not fetch '$opath'\n";
+                       if ($action->[0] eq "R") {
+                               # refer to a file/tree in an earlier commit
+                               push(@old,$path); # remove any old stuff
+                       }
+                       if(($action->[0] eq "A") || ($action->[0] eq "R")) {
+                               my $node_kind = node_kind($branch,$path,$revision);
+                               if($action->[1]) {
+                                       copy_path($revision,$branch,$path,$action->[1],$action->[2],$node_kind,\@new,\@parents);
+                               } elsif ($node_kind eq $SVN::Node::file) {
+                                       my $f = get_file($revision,$branch,$path);
+                                       if ($f) {
+                                               push(@new,$f) if $f;
+                                       } else {
+                                               my $opath = $action->[3];
+                                               print STDERR "$revision: $branch: could not fetch '$opath'\n";
+                                       }
+                               } elsif ($node_kind eq $SVN::Node::dir) {
+                                       get_ignore(\@new, \@old, $revision,
+                                                  $branch,$path);
                                }
                        } elsif ($action->[0] eq "D") {
                                push(@old,$path);
                        } elsif ($action->[0] eq "M") {
-                               my $f = get_file($revision,$branch,$path);
-                               push(@new,$f) if $f;
-                       } elsif ($action->[0] eq "R") {
-                               # refer to a file/tree in an earlier commit
-                               push(@old,$path); # remove any old stuff
-
-                               # ... and add any new stuff
-                               my($b,$srcpath) = split_path($revision,$action->[1]);
-                               $srcpath =~ s#/*$#/#;
-                               open my $F,"-|","git-ls-tree","-r","-z", $branches{$b}{$action->[2]}, $srcpath;
-                               local $/ = "\0";
-                               while(<$F>) {
-                                       chomp;
-                                       my($m,$p) = split(/\t/,$_,2);
-                                       my($mode,$type,$sha1) = split(/ /,$m);
-                                       next if $type ne "blob";
-                                       $p = substr($p,length($srcpath)-1);
-                                       push(@new,[$mode,$sha1,$path.$p]);
+                               my $node_kind = node_kind($branch,$path,$revision);
+                               if ($node_kind eq $SVN::Node::file) {
+                                       my $f = get_file($revision,$branch,$path);
+                                       push(@new,$f) if $f;
+                               } elsif ($node_kind eq $SVN::Node::dir) {
+                                       get_ignore(\@new, \@old, $revision,
+                                                  $branch,$path);
                                }
-                               close($F);
                        } else {
                                die "$revision: unknown action '".$action->[0]."' for $path\n";
                        }
                }
 
-               if(@old) {
-                       open my $F, "-|", "git-ls-files", "-z", @old or die $!;
-                       @old = ();
+               while(@old) {
+                       my @o1;
+                       if(@old > 55) {
+                               @o1 = splice(@old,0,50);
+                       } else {
+                               @o1 = @old;
+                               @old = ();
+                       }
+                       my $pid = open my $F, "-|";
+                       die "$!" unless defined $pid;
+                       if (!$pid) {
+                               exec("git-ls-files", "-z", @o1) or die $!;
+                       }
+                       @o1 = ();
                        local $/ = "\0";
                        while(<$F>) {
                                chomp;
-                               push(@old,$_);
+                               push(@o1,$_);
                        }
                        close($F);
 
-                       while(@old) {
+                       while(@o1) {
                                my @o2;
-                               if(@old > 55) {
-                                       @o2 = splice(@old,0,50);
+                               if(@o1 > 55) {
+                                       @o2 = splice(@o1,0,50);
                                } else {
-                                       @o2 = @old;
-                                       @old = ();
+                                       @o2 = @o1;
+                                       @o1 = ();
                                }
                                system("git-update-index","--force-remove","--",@o2);
                                die "Cannot remove files: $?\n" if $?;
@@ -554,7 +719,6 @@ sub commit {
                        $pw->close();
 
                        my @par = ();
-                       @par = ("-p",$rev) if defined $rev;
 
                        # loose detection of merges
                        # based on the commit msg
@@ -564,11 +728,17 @@ sub commit {
                                        if ($mparent eq 'HEAD') { $mparent = $opt_o };
                                        if ( -e "$git_dir/refs/heads/$mparent") {
                                                $mparent = get_headref($mparent, $git_dir);
-                                               push @par, '-p', $mparent;
+                                               push (@parents, $mparent);
                                                print OUT "Merge parent branch: $mparent\n" if $opt_v;
                                        }
                                }
                        }
+                       my %seen_parents = ();
+                       my @unique_parents = grep { ! $seen_parents{$_} ++ } @parents;
+                       foreach my $bparent (@unique_parents) {
+                               push @par, '-p', $bparent;
+                               print OUT "Merge parent branch: $bparent\n" if $opt_v;
+                       }
 
                        exec("env",
                                "GIT_AUTHOR_NAME=$author_name",
@@ -584,6 +754,7 @@ sub commit {
                $pr->reader();
 
                $message =~ s/[\s\n]+\z//;
+               $message = "r$revision: $message" if $opt_r;
 
                print $pw "$message\n"
                        or die "Error writing to git-commit-tree: $!\n";
@@ -600,6 +771,10 @@ sub commit {
                die "Error running git-commit-tree: $?\n" if $?;
        }
 
+       if (not defined $cid) {
+               $cid = $branches{"/"}{"LAST"};
+       }
+
        if(not defined $dest) {
                print "... no known parent\n" if $opt_v;
        } elsif(not $tag) {
@@ -616,6 +791,7 @@ sub commit {
                # the tag was 'complex', i.e. did not refer to a "real" revision
 
                $dest =~ tr/_/\./ if $opt_u;
+               $branch = $dest;
 
                my $pid = open2($in, $out, 'git-mktag');
                print $out ("object $cid\n".
@@ -647,17 +823,17 @@ sub commit {
        print "DONE: $revision $dest $cid\n" if $opt_v;
 }
 
-my ($changed_paths, $revision, $author, $date, $message, $pool) = @_;
-sub _commit_all {
-       ($changed_paths, $revision, $author, $date, $message, $pool) = @_;
+sub commit_all {
+       # Recursive use of the SVN connection does not work
+       local $svn = $svn2;
+
+       my ($changed_paths, $revision, $author, $date, $message, $pool) = @_;
        my %p;
        while(my($path,$action) = each %$changed_paths) {
                $p{$path} = [ $action->action,$action->copyfrom_path, $action->copyfrom_rev, $path ];
        }
        $changed_paths = \%p;
-}
 
-sub commit_all {
        my %done;
        my @col;
        my $pref;
@@ -673,16 +849,20 @@ sub commit_all {
        }
 }
 
-while(++$current_rev <= $svn->{'maxrev'}) {
-       $svn->{'svn'}->get_log("/",$current_rev,$current_rev,$current_rev,1,1,\&_commit_all,"");
-       commit_all();
-       if($opt_l and not --$opt_l) {
-               print STDERR "Stopping, because there is a memory leak (in the SVN library).\n";
-               print STDERR "Please repeat this command; it will continue safely\n";
-               last;
-       }
+$opt_l = $svn->{'maxrev'} if not defined $opt_l or $opt_l > $svn->{'maxrev'};
+
+if ($svn->{'maxrev'} < $current_rev) {
+    print "Up to date: no new revisions to fetch!\n" if $opt_v;
+    unlink("$git_dir/SVN2GIT_HEAD");
+    exit;
 }
 
+print "Fetching from $current_rev to $opt_l ...\n" if $opt_v;
+
+my $pool=SVN::Pool->new;
+$svn->{'svn'}->get_log("/",$current_rev,$opt_l,0,1,1,\&commit_all,$pool);
+$pool->clear;
+
 
 unlink($git_index);
 
@@ -706,8 +886,7 @@ sub commit_all {
        print "DONE; creating $orig_branch branch\n" if $opt_v and (not defined $opt_l or $opt_l > 0);
        system("cp","$git_dir/refs/heads/$opt_o","$git_dir/refs/heads/master")
                unless -f "$git_dir/refs/heads/master";
-       unlink("$git_dir/HEAD");
-       symlink("refs/heads/$orig_branch","$git_dir/HEAD");
+       system('git-update-ref', 'HEAD', "$orig_branch");
        unless ($opt_i) {
                system('git checkout');
                die "checkout failed: $?\n" if $?;