| OLD | NEW |
|---|
| (Empty) |
| 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, w
hich | |
| 43 # makes patches generated by "cvs diff" work (increasingly unimportant sin
ce 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 d
irectory | |
| 49 # | |
| 50 # Missing features: | |
| 51 # | |
| 52 # Handle property changes. | |
| 53 # Handle copied and moved directories (would require patches made by svn-creat
e-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 an
yway. | |
| 56 # Do a dry run on the whole patch and don't do anything if part of the patch i
s | |
| 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|--revie
wer 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 my $escapedFile = escapeSubversionPath($file); | |
| 140 system("svn", "update", "-r", $version, $escapedFile) == 0 or die "Faile
d to run svn update -r $version $escapedFile."; | |
| 141 } | |
| 142 } | |
| 143 | |
| 144 # Handle copied and moved files first since moved files may have their | |
| 145 # source deleted before the move. | |
| 146 for my $copyDiffHashRef (@copyDiffHashRefs) { | |
| 147 my $indexPath = $copyDiffHashRef->{indexPath}; | |
| 148 my $copiedFromPath = $copyDiffHashRef->{copiedFromPath}; | |
| 149 | |
| 150 addDirectoriesIfNeeded(dirname($indexPath)); | |
| 151 scmCopy($copiedFromPath, $indexPath); | |
| 152 } | |
| 153 | |
| 154 for my $diffHashRef (@nonCopyDiffHashRefs) { | |
| 155 patch($diffHashRef); | |
| 156 } | |
| 157 | |
| 158 removeDirectoriesIfNeeded(); | |
| 159 | |
| 160 exit $globalExitStatus; | |
| 161 | |
| 162 sub addDirectoriesIfNeeded($) | |
| 163 { | |
| 164 # Git removes a directory once the last file in it is removed. We need | |
| 165 # explicitly check for the existence of each directory along the path | |
| 166 # (and create it if it doesn't) so as to support patches that move all files
in | |
| 167 # directory A to A/B. That is, we cannot depend on %checkedDirectories. | |
| 168 my ($path) = @_; | |
| 169 my @dirs = File::Spec->splitdir($path); | |
| 170 my $dir = "."; | |
| 171 while (scalar @dirs) { | |
| 172 $dir = File::Spec->catdir($dir, shift @dirs); | |
| 173 next if !isGit() && exists $checkedDirectories{$dir}; | |
| 174 if (! -e $dir) { | |
| 175 mkdir $dir or die "Failed to create required directory '$dir' for pa
th '$path'\n"; | |
| 176 scmAdd($dir); | |
| 177 $checkedDirectories{$dir} = 1; | |
| 178 } | |
| 179 elsif (-d $dir) { | |
| 180 # SVN prints "svn: warning: 'directory' is already under version con
trol" | |
| 181 # if you try and add a directory which is already in the repository. | |
| 182 # Git will ignore the add, but re-adding large directories can be sl
oooow. | |
| 183 # So we check first to see if the directory is under version control
first. | |
| 184 if (!scmKnowsOfFile($dir)) { | |
| 185 scmAdd($dir); | |
| 186 } | |
| 187 $checkedDirectories{$dir} = 1; | |
| 188 } | |
| 189 else { | |
| 190 die "'$dir' exists, but is not a directory"; | |
| 191 } | |
| 192 } | |
| 193 } | |
| 194 | |
| 195 # Args: | |
| 196 # $patch: a patch string. | |
| 197 # $pathRelativeToRoot: the path of the file to be patched, relative to the | |
| 198 # repository root. This should normally be the path | |
| 199 # found in the patch's "Index:" line. | |
| 200 # $options: a reference to an array of options to pass to the patch command. | |
| 201 sub applyPatch($$;$) | |
| 202 { | |
| 203 my ($patch, $pathRelativeToRoot, $options) = @_; | |
| 204 | |
| 205 my $optionalArgs = {options => $options, ensureForce => $force}; | |
| 206 | |
| 207 my $exitStatus = runPatchCommand($patch, $repositoryRootPath, $pathRelativeT
oRoot, $optionalArgs); | |
| 208 | |
| 209 if ($exitStatus) { | |
| 210 $globalExitStatus = $exitStatus; | |
| 211 } | |
| 212 } | |
| 213 | |
| 214 sub checksum($) | |
| 215 { | |
| 216 my $file = shift; | |
| 217 open(FILE, $file) or die "Can't open '$file': $!"; | |
| 218 binmode(FILE); | |
| 219 my $checksum = Digest::MD5->new->addfile(*FILE)->hexdigest(); | |
| 220 close(FILE); | |
| 221 return $checksum; | |
| 222 } | |
| 223 | |
| 224 sub handleBinaryChange($$) | |
| 225 { | |
| 226 my ($fullPath, $contents) = @_; | |
| 227 # [A-Za-z0-9+/] is the class of allowed base64 characters. | |
| 228 # One or more lines, at most 76 characters in length. | |
| 229 # The last line is allowed to have up to two '=' characters at the end (to s
ignify padding). | |
| 230 if ($contents =~ m#((\n[A-Za-z0-9+/]{76})*\n[A-Za-z0-9+/]{2,74}?[A-Za-z0-9+/
=]{2}\n)#) { | |
| 231 # Addition or Modification | |
| 232 open FILE, ">", $fullPath or die "Failed to open $fullPath."; | |
| 233 print FILE decode_base64($1); | |
| 234 close FILE; | |
| 235 if (!scmKnowsOfFile($fullPath)) { | |
| 236 # Addition | |
| 237 scmAdd($fullPath); | |
| 238 } | |
| 239 } else { | |
| 240 # Deletion | |
| 241 scmRemove($fullPath); | |
| 242 } | |
| 243 } | |
| 244 | |
| 245 sub handleGitBinaryChange($$) | |
| 246 { | |
| 247 my ($fullPath, $diffHashRef) = @_; | |
| 248 | |
| 249 my $contents = $diffHashRef->{svnConvertedText}; | |
| 250 | |
| 251 my ($binaryChunkType, $binaryChunk, $reverseBinaryChunkType, $reverseBinaryC
hunk) = decodeGitBinaryPatch($contents, $fullPath); | |
| 252 | |
| 253 my $isFileAddition = $diffHashRef->{isNew}; | |
| 254 my $isFileDeletion = $diffHashRef->{isDeletion}; | |
| 255 | |
| 256 my $originalContents = ""; | |
| 257 if (open FILE, $fullPath) { | |
| 258 die "$fullPath already exists" if $isFileAddition; | |
| 259 | |
| 260 $originalContents = join("", <FILE>); | |
| 261 close FILE; | |
| 262 } | |
| 263 | |
| 264 if ($reverseBinaryChunkType eq "literal") { | |
| 265 die "Original content of $fullPath mismatches" if $originalContents ne $
reverseBinaryChunk; | |
| 266 } | |
| 267 | |
| 268 if ($isFileDeletion) { | |
| 269 scmRemove($fullPath); | |
| 270 } else { | |
| 271 # Addition or Modification | |
| 272 my $out = ""; | |
| 273 if ($binaryChunkType eq "delta") { | |
| 274 $out = applyGitBinaryPatchDelta($binaryChunk, $originalContents); | |
| 275 } else { | |
| 276 $out = $binaryChunk; | |
| 277 } | |
| 278 if ($reverseBinaryChunkType eq "delta") { | |
| 279 die "Original content of $fullPath mismatches" if $originalContents
ne applyGitBinaryPatchDelta($reverseBinaryChunk, $out); | |
| 280 } | |
| 281 open FILE, ">", $fullPath or die "Failed to open $fullPath."; | |
| 282 print FILE $out; | |
| 283 close FILE; | |
| 284 if ($isFileAddition) { | |
| 285 scmAdd($fullPath); | |
| 286 } | |
| 287 } | |
| 288 } | |
| 289 | |
| 290 sub isDirectoryEmptyForRemoval($) | |
| 291 { | |
| 292 my ($dir) = @_; | |
| 293 return 1 unless -d $dir; | |
| 294 my $directoryIsEmpty = 1; | |
| 295 opendir DIR, $dir or die "Could not open '$dir' to list files: $?"; | |
| 296 for (my $item = readdir DIR; $item && $directoryIsEmpty; $item = readdir DIR
) { | |
| 297 next if exists $removeDirectoryIgnoreList{$item}; | |
| 298 if (-d File::Spec->catdir($dir, $item)) { | |
| 299 $directoryIsEmpty = 0; | |
| 300 } else { | |
| 301 next if (scmWillDeleteFile(File::Spec->catdir($dir, $item))); | |
| 302 $directoryIsEmpty = 0; | |
| 303 } | |
| 304 } | |
| 305 closedir DIR; | |
| 306 return $directoryIsEmpty; | |
| 307 } | |
| 308 | |
| 309 # Args: | |
| 310 # $diffHashRef: a diff hash reference of the type returned by parsePatch(). | |
| 311 sub patch($) | |
| 312 { | |
| 313 my ($diffHashRef) = @_; | |
| 314 | |
| 315 # Make sure $patch is initialized to some value. A deletion can have no | |
| 316 # svnConvertedText property in the case of a deletion resulting from a | |
| 317 # Git rename. | |
| 318 my $patch = $diffHashRef->{svnConvertedText} || ""; | |
| 319 | |
| 320 my $fullPath = $diffHashRef->{indexPath}; | |
| 321 my $isBinary = $diffHashRef->{isBinary}; | |
| 322 my $isGit = $diffHashRef->{isGit}; | |
| 323 my $hasTextChunks = $patch && $diffHashRef->{numTextChunks}; | |
| 324 | |
| 325 my $deletion = 0; | |
| 326 my $addition = 0; | |
| 327 | |
| 328 $addition = 1 if ($diffHashRef->{isNew} || $patch =~ /\n@@ -0,0 .* @@/); | |
| 329 $deletion = 1 if ($diffHashRef->{isDeletion} || $patch =~ /\n@@ .* \+0,0 @@/
); | |
| 330 | |
| 331 if (!$addition && !$deletion && !$isBinary && $hasTextChunks) { | |
| 332 # Standard patch, patch tool can handle this. | |
| 333 if (basename($fullPath) eq "ChangeLog") { | |
| 334 my $changeLogDotOrigExisted = -f "${fullPath}.orig"; | |
| 335 my $changeLogHash = fixChangeLogPatch($patch); | |
| 336 my $newPatch = setChangeLogDateAndReviewer($changeLogHash->{patch},
$reviewer, $epochTime); | |
| 337 applyPatch($newPatch, $fullPath, ["--fuzz=3"]); | |
| 338 unlink("${fullPath}.orig") if (! $changeLogDotOrigExisted); | |
| 339 } else { | |
| 340 applyPatch($patch, $fullPath); | |
| 341 } | |
| 342 } else { | |
| 343 # Either a deletion, an addition or a binary change. | |
| 344 | |
| 345 addDirectoriesIfNeeded(dirname($fullPath)); | |
| 346 | |
| 347 if ($isBinary) { | |
| 348 if ($isGit) { | |
| 349 handleGitBinaryChange($fullPath, $diffHashRef); | |
| 350 } else { | |
| 351 handleBinaryChange($fullPath, $patch) if $patch; | |
| 352 } | |
| 353 } elsif ($deletion) { | |
| 354 applyPatch($patch, $fullPath, ["--force"]) if $patch; | |
| 355 scmRemove($fullPath); | |
| 356 } elsif ($addition) { | |
| 357 # Addition | |
| 358 rename($fullPath, "$fullPath.orig") if -e $fullPath; | |
| 359 applyPatch($patch, $fullPath) if $patch; | |
| 360 unlink("$fullPath.orig") if -e "$fullPath.orig" && checksum($fullPat
h) eq checksum("$fullPath.orig"); | |
| 361 scmAdd($fullPath); | |
| 362 my $escapedFullPath = escapeSubversionPath("$fullPath.orig"); | |
| 363 # What is this for? | |
| 364 system("svn", "stat", "$escapedFullPath") if isSVN() && -e "$fullPat
h.orig"; | |
| 365 } | |
| 366 } | |
| 367 | |
| 368 scmToggleExecutableBit($fullPath, $diffHashRef->{executableBitDelta}) if def
ined($diffHashRef->{executableBitDelta}); | |
| 369 } | |
| 370 | |
| 371 sub removeDirectoriesIfNeeded() | |
| 372 { | |
| 373 foreach my $dir (reverse sort keys %checkedDirectories) { | |
| 374 if (isDirectoryEmptyForRemoval($dir)) { | |
| 375 scmRemove($dir); | |
| 376 } | |
| 377 } | |
| 378 } | |
| 379 | |
| 380 # This could be made into a more general "status" call, except svn and git | |
| 381 # have different ideas about "moving" files which might get confusing. | |
| 382 sub scmWillDeleteFile($) | |
| 383 { | |
| 384 my ($path) = @_; | |
| 385 if (isSVN()) { | |
| 386 my $svnOutput = svnStatus($path); | |
| 387 return 1 if $svnOutput && substr($svnOutput, 0, 1) eq "D"; | |
| 388 } elsif (isGit()) { | |
| 389 my $command = runCommand("git", "diff-index", "--name-status", "HEAD", "
--", $path); | |
| 390 return 1 if $command->{stdout} && substr($command->{stdout}, 0, 1) eq "D
"; | |
| 391 } | |
| 392 return 0; | |
| 393 } | |
| 394 | |
| 395 # Return whether the file at the given path is known to Git. | |
| 396 # | |
| 397 # This method outputs a message like the following to STDERR when | |
| 398 # returning false: | |
| 399 # | |
| 400 # "error: pathspec 'test.png' did not match any file(s) known to git. | |
| 401 # Did you forget to 'git add'?" | |
| 402 sub gitKnowsOfFile($) | |
| 403 { | |
| 404 my $path = shift; | |
| 405 | |
| 406 `git ls-files --error-unmatch -- $path`; | |
| 407 my $exitStatus = exitStatus($?); | |
| 408 return $exitStatus == 0; | |
| 409 } | |
| 410 | |
| 411 sub scmKnowsOfFile($) | |
| 412 { | |
| 413 my ($path) = @_; | |
| 414 if (isSVN()) { | |
| 415 my $svnOutput = svnStatus($path); | |
| 416 # This will match more than intended. ? might not be the first field in
the status | |
| 417 if ($svnOutput && $svnOutput =~ m#\?\s+$path\n#) { | |
| 418 return 0; | |
| 419 } | |
| 420 # This does not handle errors well. | |
| 421 return 1; | |
| 422 } elsif (isGit()) { | |
| 423 my @result = callSilently(\&gitKnowsOfFile, $path); | |
| 424 return $result[0]; | |
| 425 } | |
| 426 } | |
| 427 | |
| 428 sub scmCopy($$) | |
| 429 { | |
| 430 my ($source, $destination) = @_; | |
| 431 if (isSVN()) { | |
| 432 my $escapedSource = escapeSubversionPath($source); | |
| 433 my $escapedDestination = escapeSubversionPath($destination); | |
| 434 system("svn", "copy", $escapedSource, $escapedDestination) == 0 or die "
Failed to svn copy $escapedSource $escapedDestination."; | |
| 435 } elsif (isGit()) { | |
| 436 system("cp", $source, $destination) == 0 or die "Failed to copy $source
$destination."; | |
| 437 system("git", "add", $destination) == 0 or die "Failed to git add $desti
nation."; | |
| 438 } | |
| 439 } | |
| 440 | |
| 441 sub scmAdd($) | |
| 442 { | |
| 443 my ($path) = @_; | |
| 444 if (isSVN()) { | |
| 445 my $escapedPath = escapeSubversionPath($path); | |
| 446 system("svn", "add", $escapedPath) == 0 or die "Failed to svn add $escap
edPath."; | |
| 447 } elsif (isGit()) { | |
| 448 system("git", "add", $path) == 0 or die "Failed to git add $path."; | |
| 449 } | |
| 450 } | |
| 451 | |
| 452 sub scmRemove($) | |
| 453 { | |
| 454 my ($path) = @_; | |
| 455 if (isSVN()) { | |
| 456 # SVN is very verbose when removing directories. Squelch all output exc
ept the last line. | |
| 457 my $svnOutput; | |
| 458 my $escapedPath = escapeSubversionPath($path); | |
| 459 open SVN, "svn rm --force '$escapedPath' |" or die "svn rm --force '$esc
apedPath' failed!"; | |
| 460 # Only print the last line. Subversion outputs all changed statuses bel
ow $dir | |
| 461 while (<SVN>) { | |
| 462 $svnOutput = $_; | |
| 463 } | |
| 464 close SVN; | |
| 465 print $svnOutput if $svnOutput; | |
| 466 } elsif (isGit()) { | |
| 467 # Git removes a directory if it becomes empty when the last file it cont
ains is | |
| 468 # removed by `git rm`. In svn-apply this can happen when a directory is
being | |
| 469 # removed in a patch, and all of the files inside of the directory are r
emoved | |
| 470 # before attemping to remove the directory itself. In this case, Git wil
l have | |
| 471 # already deleted the directory and `git rm` would exit with an error cl
aiming | |
| 472 # there was no file. The --ignore-unmatch switch gracefully handles this
case. | |
| 473 system("git", "rm", "--force", "--ignore-unmatch", $path) == 0 or die "F
ailed to git rm --force --ignore-unmatch $path."; | |
| 474 } | |
| 475 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1253013003:
Remove all perl scripts from Tools/Scripts (Closed)
Base URL: svn://svn.chromium.org/blink/trunk