907ffe1522
Depending on how your CVS->GIT conversion went you will have some unexpanded CVS keywords in your GIT repo. If any of your git commits touch these lines then the patch application will fail. This patch addresses that by adding an option that will revert and expanded CVS keywords to files in the working CVS directory that are affected by the commit being applied. Signed-off-by: Alex Bennée <alex@bennee.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
453 lines
12 KiB
Perl
Executable File
453 lines
12 KiB
Perl
Executable File
#!/usr/bin/perl -w
|
|
|
|
use strict;
|
|
use Getopt::Std;
|
|
use File::Temp qw(tempdir);
|
|
use Data::Dumper;
|
|
use File::Basename qw(basename dirname);
|
|
use File::Spec;
|
|
use Git;
|
|
|
|
our ($opt_h, $opt_P, $opt_p, $opt_v, $opt_c, $opt_f, $opt_a, $opt_m, $opt_d, $opt_u, $opt_w, $opt_W, $opt_k);
|
|
|
|
getopts('uhPpvcfkam:d:w:W');
|
|
|
|
$opt_h && usage();
|
|
|
|
die "Need at least one commit identifier!" unless @ARGV;
|
|
|
|
# Get git-config settings
|
|
my $repo = Git->repository();
|
|
$opt_w = $repo->config('cvsexportcommit.cvsdir') unless defined $opt_w;
|
|
|
|
if ($opt_w || $opt_W) {
|
|
# Remember where GIT_DIR is before changing to CVS checkout
|
|
unless ($ENV{GIT_DIR}) {
|
|
# No GIT_DIR set. Figure it out for ourselves
|
|
my $gd =`git-rev-parse --git-dir`;
|
|
chomp($gd);
|
|
$ENV{GIT_DIR} = $gd;
|
|
}
|
|
# Make sure GIT_DIR is absolute
|
|
$ENV{GIT_DIR} = File::Spec->rel2abs($ENV{GIT_DIR});
|
|
}
|
|
|
|
if ($opt_w) {
|
|
if (! -d $opt_w."/CVS" ) {
|
|
die "$opt_w is not a CVS checkout";
|
|
}
|
|
chdir $opt_w or die "Cannot change to CVS checkout at $opt_w";
|
|
}
|
|
unless ($ENV{GIT_DIR} && -r $ENV{GIT_DIR}){
|
|
die "GIT_DIR is not defined or is unreadable";
|
|
}
|
|
|
|
|
|
my @cvs;
|
|
if ($opt_d) {
|
|
@cvs = ('cvs', '-d', $opt_d);
|
|
} else {
|
|
@cvs = ('cvs');
|
|
}
|
|
|
|
# resolve target commit
|
|
my $commit;
|
|
$commit = pop @ARGV;
|
|
$commit = safe_pipe_capture('git-rev-parse', '--verify', "$commit^0");
|
|
chomp $commit;
|
|
if ($?) {
|
|
die "The commit reference $commit did not resolve!";
|
|
}
|
|
|
|
# resolve what parent we want
|
|
my $parent;
|
|
if (@ARGV) {
|
|
$parent = pop @ARGV;
|
|
$parent = safe_pipe_capture('git-rev-parse', '--verify', "$parent^0");
|
|
chomp $parent;
|
|
if ($?) {
|
|
die "The parent reference did not resolve!";
|
|
}
|
|
}
|
|
|
|
# find parents from the commit itself
|
|
my @commit = safe_pipe_capture('git-cat-file', 'commit', $commit);
|
|
my @parents;
|
|
my $committer;
|
|
my $author;
|
|
my $stage = 'headers'; # headers, msg
|
|
my $title;
|
|
my $msg = '';
|
|
|
|
foreach my $line (@commit) {
|
|
chomp $line;
|
|
if ($stage eq 'headers' && $line eq '') {
|
|
$stage = 'msg';
|
|
next;
|
|
}
|
|
|
|
if ($stage eq 'headers') {
|
|
if ($line =~ m/^parent (\w{40})$/) { # found a parent
|
|
push @parents, $1;
|
|
} elsif ($line =~ m/^author (.+) \d+ [-+]\d+$/) {
|
|
$author = $1;
|
|
} elsif ($line =~ m/^committer (.+) \d+ [-+]\d+$/) {
|
|
$committer = $1;
|
|
}
|
|
} else {
|
|
$msg .= $line . "\n";
|
|
unless ($title) {
|
|
$title = $line;
|
|
}
|
|
}
|
|
}
|
|
|
|
my $noparent = "0000000000000000000000000000000000000000";
|
|
if ($parent) {
|
|
my $found;
|
|
# double check that it's a valid parent
|
|
foreach my $p (@parents) {
|
|
if ($p eq $parent) {
|
|
$found = 1;
|
|
last;
|
|
}; # found it
|
|
}
|
|
die "Did not find $parent in the parents for this commit!" if !$found and !$opt_P;
|
|
} else { # we don't have a parent from the cmdline...
|
|
if (@parents == 1) { # it's safe to get it from the commit
|
|
$parent = $parents[0];
|
|
} elsif (@parents == 0) { # there is no parent
|
|
$parent = $noparent;
|
|
} else { # cannot choose automatically from multiple parents
|
|
die "This commit has more than one parent -- please name the parent you want to use explicitly";
|
|
}
|
|
}
|
|
|
|
my $go_back_to = 0;
|
|
|
|
if ($opt_W) {
|
|
$opt_v && print "Resetting to $parent\n";
|
|
$go_back_to = `git symbolic-ref HEAD 2> /dev/null ||
|
|
git rev-parse HEAD` || die "Could not determine current branch";
|
|
system("git checkout -q $parent^0") && die "Could not check out $parent^0";
|
|
}
|
|
|
|
$opt_v && print "Applying to CVS commit $commit from parent $parent\n";
|
|
|
|
# grab the commit message
|
|
open(MSG, ">.msg") or die "Cannot open .msg for writing";
|
|
if ($opt_m) {
|
|
print MSG $opt_m;
|
|
}
|
|
print MSG $msg;
|
|
if ($opt_a) {
|
|
print MSG "\n\nAuthor: $author\n";
|
|
if ($author ne $committer) {
|
|
print MSG "Committer: $committer\n";
|
|
}
|
|
}
|
|
close MSG;
|
|
|
|
if ($parent eq $noparent) {
|
|
`git-diff-tree --binary -p --root $commit >.cvsexportcommit.diff`;# || die "Cannot diff";
|
|
} else {
|
|
`git-diff-tree --binary -p $parent $commit >.cvsexportcommit.diff`;# || die "Cannot diff";
|
|
}
|
|
|
|
## apply non-binary changes
|
|
|
|
# In pedantic mode require all lines of context to match. In normal
|
|
# mode, be compatible with diff/patch: assume 3 lines of context and
|
|
# require at least one line match, i.e. ignore at most 2 lines of
|
|
# context, like diff/patch do by default.
|
|
my $context = $opt_p ? '' : '-C1';
|
|
|
|
print "Checking if patch will apply\n";
|
|
|
|
my @stat;
|
|
open APPLY, "GIT_DIR= git-apply $context --summary --numstat<.cvsexportcommit.diff|" || die "cannot patch";
|
|
@stat=<APPLY>;
|
|
close APPLY || die "Cannot patch";
|
|
my (@bfiles,@files,@afiles,@dfiles);
|
|
chomp @stat;
|
|
foreach (@stat) {
|
|
push (@bfiles,$1) if m/^-\t-\t(.*)$/;
|
|
push (@files, $1) if m/^-\t-\t(.*)$/;
|
|
push (@files, $1) if m/^\d+\t\d+\t(.*)$/;
|
|
push (@afiles,$1) if m/^ create mode [0-7]+ (.*)$/;
|
|
push (@dfiles,$1) if m/^ delete mode [0-7]+ (.*)$/;
|
|
}
|
|
map { s/^"(.*)"$/$1/g } @bfiles,@files;
|
|
map { s/\\([0-7]{3})/sprintf('%c',oct $1)/eg } @bfiles,@files;
|
|
|
|
# check that the files are clean and up to date according to cvs
|
|
my $dirty;
|
|
my @dirs;
|
|
foreach my $p (@afiles) {
|
|
my $path = dirname $p;
|
|
while (!-d $path and ! grep { $_ eq $path } @dirs) {
|
|
unshift @dirs, $path;
|
|
$path = dirname $path;
|
|
}
|
|
}
|
|
|
|
# ... check dirs,
|
|
foreach my $d (@dirs) {
|
|
if (-e $d) {
|
|
$dirty = 1;
|
|
warn "$d exists and is not a directory!\n";
|
|
}
|
|
}
|
|
|
|
# ... query status of all files that we have a directory for and parse output of 'cvs status' to %cvsstat.
|
|
my @canstatusfiles;
|
|
foreach my $f (@files) {
|
|
my $path = dirname $f;
|
|
next if (grep { $_ eq $path } @dirs);
|
|
push @canstatusfiles, $f;
|
|
}
|
|
|
|
my %cvsstat;
|
|
if (@canstatusfiles) {
|
|
if ($opt_u) {
|
|
my @updated = xargs_safe_pipe_capture([@cvs, 'update'], @canstatusfiles);
|
|
print @updated;
|
|
}
|
|
# "cvs status" reorders the parameters, notably when there are multiple
|
|
# arguments with the same basename. So be precise here.
|
|
|
|
my %added = map { $_ => 1 } @afiles;
|
|
my %todo = map { $_ => 1 } @canstatusfiles;
|
|
|
|
while (%todo) {
|
|
my @canstatusfiles2 = ();
|
|
my %fullname = ();
|
|
foreach my $name (keys %todo) {
|
|
my $basename = basename($name);
|
|
|
|
# CVS reports files that don't exist in the current revision as
|
|
# "no file $basename" in its "status" output, so we should
|
|
# anticipate that. Totally unknown files will have a status
|
|
# "Unknown". However, if they exist in the Attic, their status
|
|
# will be "Up-to-date" (this means they were added once but have
|
|
# been removed).
|
|
$basename = "no file $basename" if $added{$basename};
|
|
|
|
$basename =~ s/^\s+//;
|
|
$basename =~ s/\s+$//;
|
|
|
|
if (!exists($fullname{$basename})) {
|
|
$fullname{$basename} = $name;
|
|
push (@canstatusfiles2, $name);
|
|
delete($todo{$name});
|
|
}
|
|
}
|
|
my @cvsoutput;
|
|
@cvsoutput = xargs_safe_pipe_capture([@cvs, 'status'], @canstatusfiles2);
|
|
foreach my $l (@cvsoutput) {
|
|
chomp $l;
|
|
next unless
|
|
my ($file, $status) = $l =~ /^File:\s+(.*\S)\s+Status: (.*)$/;
|
|
|
|
my $fullname = $fullname{$file};
|
|
print STDERR "Huh? Status '$status' reported for unexpected file '$file'\n"
|
|
unless defined $fullname;
|
|
|
|
# This response means the file does not exist except in
|
|
# CVS's attic, so set the status accordingly
|
|
$status = "In-attic"
|
|
if $file =~ /^no file /
|
|
&& $status eq 'Up-to-date';
|
|
|
|
$cvsstat{$fullname{$file}} = $status;
|
|
}
|
|
}
|
|
}
|
|
|
|
# ... Validate that new files have the correct status
|
|
foreach my $f (@afiles) {
|
|
next unless defined(my $stat = $cvsstat{$f});
|
|
|
|
# This means the file has never been seen before
|
|
next if $stat eq 'Unknown';
|
|
|
|
# This means the file has been seen before but was removed
|
|
next if $stat eq 'In-attic';
|
|
|
|
$dirty = 1;
|
|
warn "File $f is already known in your CVS checkout -- perhaps it has been added by another user. Or this may indicate that it exists on a different branch. If this is the case, use -f to force the merge.\n";
|
|
warn "Status was: $cvsstat{$f}\n";
|
|
}
|
|
|
|
# ... validate known files.
|
|
foreach my $f (@files) {
|
|
next if grep { $_ eq $f } @afiles;
|
|
# TODO:we need to handle removed in cvs
|
|
unless (defined ($cvsstat{$f}) and $cvsstat{$f} eq "Up-to-date") {
|
|
$dirty = 1;
|
|
warn "File $f not up to date but has status '$cvsstat{$f}' in your CVS checkout!\n";
|
|
}
|
|
|
|
# Depending on how your GIT tree got imported from CVS you may
|
|
# have a conflict between expanded keywords in your CVS tree and
|
|
# unexpanded keywords in the patch about to be applied.
|
|
if ($opt_k) {
|
|
my $orig_file ="$f.orig";
|
|
rename $f, $orig_file;
|
|
open(FILTER_IN, "<$orig_file") or die "Cannot open $orig_file\n";
|
|
open(FILTER_OUT, ">$f") or die "Cannot open $f\n";
|
|
while (<FILTER_IN>)
|
|
{
|
|
my $line = $_;
|
|
$line =~ s/\$([A-Z][a-z]+):[^\$]+\$/\$\1\$/g;
|
|
print FILTER_OUT $line;
|
|
}
|
|
close FILTER_IN;
|
|
close FILTER_OUT;
|
|
}
|
|
}
|
|
|
|
if ($dirty) {
|
|
if ($opt_f) { warn "The tree is not clean -- forced merge\n";
|
|
$dirty = 0;
|
|
} else {
|
|
die "Exiting: your CVS tree is not clean for this merge.";
|
|
}
|
|
}
|
|
|
|
print "Applying\n";
|
|
if ($opt_W) {
|
|
system("git checkout -q $commit^0") && die "cannot patch";
|
|
} else {
|
|
`GIT_DIR= git-apply $context --summary --numstat --apply <.cvsexportcommit.diff` || die "cannot patch";
|
|
}
|
|
|
|
print "Patch applied successfully. Adding new files and directories to CVS\n";
|
|
my $dirtypatch = 0;
|
|
|
|
#
|
|
# We have to add the directories in order otherwise we will have
|
|
# problems when we try and add the sub-directory of a directory we
|
|
# have not added yet.
|
|
#
|
|
# Luckily this is easy to deal with by sorting the directories and
|
|
# dealing with the shortest ones first.
|
|
#
|
|
@dirs = sort { length $a <=> length $b} @dirs;
|
|
|
|
foreach my $d (@dirs) {
|
|
if (system(@cvs,'add',$d)) {
|
|
$dirtypatch = 1;
|
|
warn "Failed to cvs add directory $d -- you may need to do it manually";
|
|
}
|
|
}
|
|
|
|
foreach my $f (@afiles) {
|
|
if (grep { $_ eq $f } @bfiles) {
|
|
system(@cvs, 'add','-kb',$f);
|
|
} else {
|
|
system(@cvs, 'add', $f);
|
|
}
|
|
if ($?) {
|
|
$dirtypatch = 1;
|
|
warn "Failed to cvs add $f -- you may need to do it manually";
|
|
}
|
|
}
|
|
|
|
foreach my $f (@dfiles) {
|
|
system(@cvs, 'rm', '-f', $f);
|
|
if ($?) {
|
|
$dirtypatch = 1;
|
|
warn "Failed to cvs rm -f $f -- you may need to do it manually";
|
|
}
|
|
}
|
|
|
|
print "Commit to CVS\n";
|
|
print "Patch title (first comment line): $title\n";
|
|
my @commitfiles = map { unless (m/\s/) { '\''.$_.'\''; } else { $_; }; } (@files);
|
|
my $cmd = join(' ', @cvs)." commit -F .msg @commitfiles";
|
|
|
|
if ($dirtypatch) {
|
|
print "NOTE: One or more hunks failed to apply cleanly.\n";
|
|
print "You'll need to apply the patch in .cvsexportcommit.diff manually\n";
|
|
print "using a patch program. After applying the patch and resolving the\n";
|
|
print "problems you may commit using:";
|
|
print "\n cd \"$opt_w\"" if $opt_w;
|
|
print "\n $cmd\n";
|
|
print "\n git checkout $go_back_to\n" if $go_back_to;
|
|
print "\n";
|
|
exit(1);
|
|
}
|
|
|
|
if ($opt_c) {
|
|
print "Autocommit\n $cmd\n";
|
|
print xargs_safe_pipe_capture([@cvs, 'commit', '-F', '.msg'], @files);
|
|
if ($?) {
|
|
die "Exiting: The commit did not succeed";
|
|
}
|
|
print "Committed successfully to CVS\n";
|
|
# clean up
|
|
unlink(".msg");
|
|
} else {
|
|
print "Ready for you to commit, just run:\n\n $cmd\n";
|
|
}
|
|
|
|
# clean up
|
|
unlink(".cvsexportcommit.diff");
|
|
|
|
if ($opt_W) {
|
|
system("git checkout $go_back_to") && die "cannot move back to $go_back_to";
|
|
if (!($go_back_to =~ /^[0-9a-fA-F]{40}$/)) {
|
|
system("git symbolic-ref HEAD $go_back_to") &&
|
|
die "cannot move back to $go_back_to";
|
|
}
|
|
}
|
|
|
|
# CVS version 1.11.x and 1.12.x sleeps the wrong way to ensure the timestamp
|
|
# used by CVS and the one set by subsequence file modifications are different.
|
|
# If they are not different CVS will not detect changes.
|
|
sleep(1);
|
|
|
|
sub usage {
|
|
print STDERR <<END;
|
|
Usage: GIT_DIR=/path/to/.git git cvsexportcommit [-h] [-p] [-v] [-c] [-f] [-u] [-k] [-w cvsworkdir] [-m msgprefix] [ parent ] commit
|
|
END
|
|
exit(1);
|
|
}
|
|
|
|
# An alternative to `command` that allows input to be passed as an array
|
|
# to work around shell problems with weird characters in arguments
|
|
# if the exec returns non-zero we die
|
|
sub safe_pipe_capture {
|
|
my @output;
|
|
if (my $pid = open my $child, '-|') {
|
|
@output = (<$child>);
|
|
close $child or die join(' ',@_).": $! $?";
|
|
} else {
|
|
exec(@_) or die "$! $?"; # exec() can fail the executable can't be found
|
|
}
|
|
return wantarray ? @output : join('',@output);
|
|
}
|
|
|
|
sub xargs_safe_pipe_capture {
|
|
my $MAX_ARG_LENGTH = 65536;
|
|
my $cmd = shift;
|
|
my @output;
|
|
my $output;
|
|
while(@_) {
|
|
my @args;
|
|
my $length = 0;
|
|
while(@_ && $length < $MAX_ARG_LENGTH) {
|
|
push @args, shift;
|
|
$length += length($args[$#args]);
|
|
}
|
|
if (wantarray) {
|
|
push @output, safe_pipe_capture(@$cmd, @args);
|
|
}
|
|
else {
|
|
$output .= safe_pipe_capture(@$cmd, @args);
|
|
}
|
|
}
|
|
return wantarray ? @output : $output;
|
|
}
|