Rename WebKitTools to Tools
[WebKit-https.git] / Tools / Scripts / svn-apply
1 #!/usr/bin/perl -w
2
3 # Copyright (C) 2005, 2006, 2007 Apple Inc.  All rights reserved.
4 # Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
5 # Copyright (C) 2010 Chris Jerdonek (chris.jerdonek@gmail.com)
6 #
7 # Redistribution and use in source and binary forms, with or without
8 # modification, are permitted provided that the following conditions
9 # are met:
10 #
11 # 1.  Redistributions of source code must retain the above copyright
12 #     notice, this list of conditions and the following disclaimer.
13 # 2.  Redistributions in binary form must reproduce the above copyright
14 #     notice, this list of conditions and the following disclaimer in the
15 #     documentation and/or other materials provided with the distribution. 
16 # 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
17 #     its contributors may be used to endorse or promote products derived
18 #     from this software without specific prior written permission.
19 #
20 # THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
21 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
22 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 # DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
24 # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25 # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27 # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31 # "patch" script for WebKit Open Source Project, used to apply patches.
32
33 # Differences from invoking "patch -p0":
34 #
35 #   Handles added files (does a svn add with logic to handle local changes).
36 #   Handles added directories (does a svn add).
37 #   Handles removed files (does a svn rm with logic to handle local changes).
38 #   Handles removed directories--those with no more files or directories left in them
39 #       (does a svn rm).
40 #   Has mode where it will roll back to svn version numbers in the patch file so svn
41 #       can do a 3-way merge.
42 #   Paths from Index: lines are used rather than the paths on the patch lines, which
43 #       makes patches generated by "cvs diff" work (increasingly unimportant since we
44 #       use Subversion now).
45 #   ChangeLog patches use --fuzz=3 to prevent rejects.
46 #   Handles binary files (requires patches made by svn-create-patch).
47 #   Handles copied and moved files (requires patches made by svn-create-patch).
48 #   Handles git-diff patches (without binary changes) created at the top-level directory
49 #
50 # Missing features:
51 #
52 #   Handle property changes.
53 #   Handle copied and moved directories (would require patches made by svn-create-patch).
54 #   When doing a removal, check that old file matches what's being removed.
55 #   Notice a patch that's being applied at the "wrong level" and make it work anyway.
56 #   Do a dry run on the whole patch and don't do anything if part of the patch is
57 #       going to fail (probably too strict unless we exclude ChangeLog).
58 #   Handle git-diff patches with binary delta
59
60 use strict;
61 use warnings;
62
63 use Digest::MD5;
64 use File::Basename;
65 use File::Spec;
66 use Getopt::Long;
67 use MIME::Base64;
68 use POSIX qw(strftime);
69
70 use FindBin;
71 use lib $FindBin::Bin;
72 use VCSUtils;
73
74 sub addDirectoriesIfNeeded($);
75 sub applyPatch($$;$);
76 sub checksum($);
77 sub handleBinaryChange($$);
78 sub handleGitBinaryChange($$);
79 sub isDirectoryEmptyForRemoval($);
80 sub patch($);
81 sub removeDirectoriesIfNeeded();
82
83 # These should be replaced by an scm class/module:
84 sub scmKnowsOfFile($);
85 sub scmCopy($$);
86 sub scmAdd($);
87 sub scmRemove($);
88
89 my $merge = 0;
90 my $showHelp = 0;
91 my $reviewer;
92 my $force = 0;
93
94 my $optionParseSuccess = GetOptions(
95     "merge!" => \$merge,
96     "help!" => \$showHelp,
97     "reviewer=s" => \$reviewer,
98     "force!" => \$force
99 );
100
101 if (!$optionParseSuccess || $showHelp) {
102     print STDERR basename($0) . " [-h|--help] [--force] [-m|--merge] [-r|--reviewer name] patch1 [patch2 ...]\n";
103     exit 1;
104 }
105
106 my %removeDirectoryIgnoreList = (
107     '.' => 1,
108     '..' => 1,
109     '.git' => 1,
110     '.svn' => 1,
111     '_svn' => 1,
112 );
113
114 my $epochTime = time(); # This is used to set the date in ChangeLog files.
115 my $globalExitStatus = 0;
116
117 my $repositoryRootPath = determineVCSRoot();
118
119 my %checkedDirectories;
120
121 # Need to use a typeglob to pass the file handle as a parameter,
122 # otherwise get a bareword error.
123 my @diffHashRefs = parsePatch(*ARGV);
124
125 print "Parsed " . @diffHashRefs . " diffs from patch file(s).\n";
126
127 my $preparedPatchHash = prepareParsedPatch($force, @diffHashRefs);
128
129 my @copyDiffHashRefs = @{$preparedPatchHash->{copyDiffHashRefs}};
130 my @nonCopyDiffHashRefs = @{$preparedPatchHash->{nonCopyDiffHashRefs}};
131 my %sourceRevisions = %{$preparedPatchHash->{sourceRevisionHash}};
132
133 if ($merge) {
134     die "--merge is currently only supported for SVN" unless isSVN();
135     # How do we handle Git patches applied to an SVN checkout here?
136     for my $file (sort keys %sourceRevisions) {
137         my $version = $sourceRevisions{$file};
138         print "Getting version $version of $file\n";
139         system("svn", "update", "-r", $version, $file) == 0 or die "Failed to run svn update -r $version $file.";
140     }
141 }
142
143 # Handle copied and moved files first since moved files may have their
144 # source deleted before the move.
145 for my $copyDiffHashRef (@copyDiffHashRefs) {
146     my $indexPath = $copyDiffHashRef->{indexPath};
147     my $copiedFromPath = $copyDiffHashRef->{copiedFromPath};
148
149     addDirectoriesIfNeeded(dirname($indexPath));
150     scmCopy($copiedFromPath, $indexPath);
151 }
152
153 for my $diffHashRef (@nonCopyDiffHashRefs) {
154     patch($diffHashRef);
155 }
156
157 removeDirectoriesIfNeeded();
158
159 exit $globalExitStatus;
160
161 sub addDirectoriesIfNeeded($)
162 {
163     my ($path) = @_;
164     my @dirs = File::Spec->splitdir($path);
165     my $dir = ".";
166     while (scalar @dirs) {
167         $dir = File::Spec->catdir($dir, shift @dirs);
168         next if exists $checkedDirectories{$dir};
169         if (! -e $dir) {
170             mkdir $dir or die "Failed to create required directory '$dir' for path '$path'\n";
171             scmAdd($dir);
172             $checkedDirectories{$dir} = 1;
173         }
174         elsif (-d $dir) {
175             # SVN prints "svn: warning: 'directory' is already under version control"
176             # if you try and add a directory which is already in the repository.
177             # Git will ignore the add, but re-adding large directories can be sloooow.
178             # So we check first to see if the directory is under version control first.
179             if (!scmKnowsOfFile($dir)) {
180                 scmAdd($dir);
181             }
182             $checkedDirectories{$dir} = 1;
183         }
184         else {
185             die "'$dir' exists, but is not a directory";
186         }
187     }
188 }
189
190 # Args:
191 #   $patch: a patch string.
192 #   $pathRelativeToRoot: the path of the file to be patched, relative to the
193 #                        repository root. This should normally be the path
194 #                        found in the patch's "Index:" line.
195 #   $options: a reference to an array of options to pass to the patch command.
196 sub applyPatch($$;$)
197 {
198     my ($patch, $pathRelativeToRoot, $options) = @_;
199
200     my $optionalArgs = {options => $options, ensureForce => $force};
201
202     my $exitStatus = runPatchCommand($patch, $repositoryRootPath, $pathRelativeToRoot, $optionalArgs);
203
204     if ($exitStatus) {
205         $globalExitStatus = $exitStatus;
206     }
207 }
208
209 sub checksum($)
210 {
211     my $file = shift;
212     open(FILE, $file) or die "Can't open '$file': $!";
213     binmode(FILE);
214     my $checksum = Digest::MD5->new->addfile(*FILE)->hexdigest();
215     close(FILE);
216     return $checksum;
217 }
218
219 sub handleBinaryChange($$)
220 {
221     my ($fullPath, $contents) = @_;
222     # [A-Za-z0-9+/] is the class of allowed base64 characters.
223     # One or more lines, at most 76 characters in length.
224     # The last line is allowed to have up to two '=' characters at the end (to signify padding).
225     if ($contents =~ m#((\n[A-Za-z0-9+/]{76})*\n[A-Za-z0-9+/]{2,74}?[A-Za-z0-9+/=]{2}\n)#) {
226         # Addition or Modification
227         open FILE, ">", $fullPath or die "Failed to open $fullPath.";
228         print FILE decode_base64($1);
229         close FILE;
230         if (!scmKnowsOfFile($fullPath)) {
231             # Addition
232             scmAdd($fullPath);
233         }
234     } else {
235         # Deletion
236         scmRemove($fullPath);
237     }
238 }
239
240 sub handleGitBinaryChange($$)
241 {
242     my ($fullPath, $diffHashRef) = @_;
243
244     my $contents = $diffHashRef->{svnConvertedText};
245
246     my ($binaryChunkType, $binaryChunk, $reverseBinaryChunkType, $reverseBinaryChunk) = decodeGitBinaryPatch($contents, $fullPath);
247     # FIXME: support "delta" type.
248     die "only literal type is supported now" if ($binaryChunkType ne "literal" || $reverseBinaryChunkType ne "literal");
249
250     my $isFileAddition = $diffHashRef->{isNew};
251     my $isFileDeletion = $diffHashRef->{isDeletion};
252
253     my $originalContents = "";
254     if (open FILE, $fullPath) {
255         die "$fullPath already exists" if $isFileAddition;
256
257         $originalContents = join("", <FILE>);
258         close FILE;
259     }
260     die "Original content of $fullPath mismatches" if $originalContents ne $reverseBinaryChunk;
261
262     if ($isFileDeletion) {
263         scmRemove($fullPath);
264     } else {
265         # Addition or Modification
266         open FILE, ">", $fullPath or die "Failed to open $fullPath.";
267         print FILE $binaryChunk;
268         close FILE;
269         if ($isFileAddition) {
270             scmAdd($fullPath);
271         }
272     }
273 }
274
275 sub isDirectoryEmptyForRemoval($)
276 {
277     my ($dir) = @_;
278     return 1 unless -d $dir;
279     my $directoryIsEmpty = 1;
280     opendir DIR, $dir or die "Could not open '$dir' to list files: $?";
281     for (my $item = readdir DIR; $item && $directoryIsEmpty; $item = readdir DIR) {
282         next if exists $removeDirectoryIgnoreList{$item};
283         if (-d File::Spec->catdir($dir, $item)) {
284             $directoryIsEmpty = 0;
285         } else {
286             next if (scmWillDeleteFile(File::Spec->catdir($dir, $item)));
287             $directoryIsEmpty = 0;
288         }
289     }
290     closedir DIR;
291     return $directoryIsEmpty;
292 }
293
294 # Args:
295 #   $diffHashRef: a diff hash reference of the type returned by parsePatch().
296 sub patch($)
297 {
298     my ($diffHashRef) = @_;
299
300     # Make sure $patch is initialized to some value.  A deletion can have no
301     # svnConvertedText property in the case of a deletion resulting from a
302     # Git rename.
303     my $patch = $diffHashRef->{svnConvertedText} || "";
304
305     my $fullPath = $diffHashRef->{indexPath};
306     my $isBinary = $diffHashRef->{isBinary};
307     my $isGit = $diffHashRef->{isGit};
308
309     my $deletion = 0;
310     my $addition = 0;
311
312     $addition = 1 if ($diffHashRef->{isNew} || $patch =~ /\n@@ -0,0 .* @@/);
313     $deletion = 1 if ($diffHashRef->{isDeletion} || $patch =~ /\n@@ .* \+0,0 @@/);
314
315     if (!$addition && !$deletion && !$isBinary) {
316         # Standard patch, patch tool can handle this.
317         if (basename($fullPath) eq "ChangeLog") {
318             my $changeLogDotOrigExisted = -f "${fullPath}.orig";
319             my $changeLogHash = fixChangeLogPatch($patch);
320             my $newPatch = setChangeLogDateAndReviewer($changeLogHash->{patch}, $reviewer, $epochTime);
321             applyPatch($newPatch, $fullPath, ["--fuzz=3"]);
322             unlink("${fullPath}.orig") if (! $changeLogDotOrigExisted);
323         } else {
324             applyPatch($patch, $fullPath) if $patch;
325         }
326     } else {
327         # Either a deletion, an addition or a binary change.
328
329         addDirectoriesIfNeeded(dirname($fullPath));
330
331         if ($isBinary) {
332             if ($isGit) {
333                 handleGitBinaryChange($fullPath, $diffHashRef);
334             } else {
335                 handleBinaryChange($fullPath, $patch) if $patch;
336             }
337         } elsif ($deletion) {
338             applyPatch($patch, $fullPath, ["--force"]) if $patch;
339             scmRemove($fullPath);
340         } else {
341             # Addition
342             rename($fullPath, "$fullPath.orig") if -e $fullPath;
343             applyPatch($patch, $fullPath) if $patch;
344             unlink("$fullPath.orig") if -e "$fullPath.orig" && checksum($fullPath) eq checksum("$fullPath.orig");
345             scmAdd($fullPath);
346             # What is this for?
347             system("svn", "stat", "$fullPath.orig") if isSVN() && -e "$fullPath.orig";
348         }
349     }
350
351     scmToggleExecutableBit($fullPath, $diffHashRef->{executableBitDelta}) if defined($diffHashRef->{executableBitDelta});
352 }
353
354 sub removeDirectoriesIfNeeded()
355 {
356     foreach my $dir (reverse sort keys %checkedDirectories) {
357         if (isDirectoryEmptyForRemoval($dir)) {
358             scmRemove($dir);
359         }
360     }
361 }
362
363 # This could be made into a more general "status" call, except svn and git
364 # have different ideas about "moving" files which might get confusing.
365 sub scmWillDeleteFile($)
366 {
367     my ($path) = @_;
368     if (isSVN()) {
369         my $svnOutput = svnStatus($path);
370         return 1 if $svnOutput && substr($svnOutput, 0, 1) eq "D";
371     } elsif (isGit()) {
372         my $gitOutput = `git diff-index --name-status HEAD -- $path`;
373         return 1 if $gitOutput && substr($gitOutput, 0, 1) eq "D";
374     }
375     return 0;
376 }
377
378 # Return whether the file at the given path is known to Git.
379 #
380 # This method outputs a message like the following to STDERR when
381 # returning false:
382 #
383 # "error: pathspec 'test.png' did not match any file(s) known to git.
384 #  Did you forget to 'git add'?"
385 sub gitKnowsOfFile($)
386 {
387     my $path = shift;
388
389     `git ls-files --error-unmatch -- $path`;
390     my $exitStatus = exitStatus($?);
391     return $exitStatus == 0;
392 }
393
394 sub scmKnowsOfFile($)
395 {
396     my ($path) = @_;
397     if (isSVN()) {
398         my $svnOutput = svnStatus($path);
399         # This will match more than intended.  ? might not be the first field in the status
400         if ($svnOutput && $svnOutput =~ m#\?\s+$path\n#) {
401             return 0;
402         }
403         # This does not handle errors well.
404         return 1;
405     } elsif (isGit()) {
406         my @result = callSilently(\&gitKnowsOfFile, $path);
407         return $result[0];
408     }
409 }
410
411 sub scmCopy($$)
412 {
413     my ($source, $destination) = @_;
414     if (isSVN()) {
415         system("svn", "copy", $source, $destination) == 0 or die "Failed to svn copy $source $destination.";
416     } elsif (isGit()) {
417         system("cp", $source, $destination) == 0 or die "Failed to copy $source $destination.";
418         system("git", "add", $destination) == 0 or die "Failed to git add $destination.";
419     }
420 }
421
422 sub scmAdd($)
423 {
424     my ($path) = @_;
425     if (isSVN()) {
426         system("svn", "add", $path) == 0 or die "Failed to svn add $path.";
427     } elsif (isGit()) {
428         system("git", "add", $path) == 0 or die "Failed to git add $path.";
429     }
430 }
431
432 sub scmRemove($)
433 {
434     my ($path) = @_;
435     if (isSVN()) {
436         # SVN is very verbose when removing directories.  Squelch all output except the last line.
437         my $svnOutput;
438         open SVN, "svn rm --force '$path' |" or die "svn rm --force '$path' failed!";
439         # Only print the last line.  Subversion outputs all changed statuses below $dir
440         while (<SVN>) {
441             $svnOutput = $_;
442         }
443         close SVN;
444         print $svnOutput if $svnOutput;
445     } elsif (isGit()) {
446         # Git removes a directory if it becomes empty when the last file it contains is
447         # removed by `git rm`. In svn-apply this can happen when a directory is being
448         # removed in a patch, and all of the files inside of the directory are removed
449         # before attemping to remove the directory itself. In this case, Git will have 
450         # already deleted the directory and `git rm` would exit with an error claiming
451         # there was no file. The --ignore-unmatch switch gracefully handles this case.
452         system("git", "rm", "--force", "--ignore-unmatch", $path) == 0 or die "Failed to git rm --force --ignore-unmatch $path.";
453     }
454 }