cxf-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Glynn, Eoghan" <eoghan.gl...@iona.com>
Subject RE: Creating/Applying patch with renamed files
Date Thu, 22 Feb 2007 16:34:21 GMT


Seumas,

I'll apply this patch and give the tests a whirl on Linux ... then
commit if all green.

Cheers,
Eoghan 

> -----Original Message-----
> From: Soltysik, Seumas [mailto:Seumas.Soltysik@iona.com] 
> Sent: 22 February 2007 16:21
> To: cxf-dev@incubator.apache.org
> Subject: RE: Creating/Applying patch with renamed files
> 
> Any volunteers for this task? 
> 
> As stated, to apply this patch you will need the svn-apply 
> perl script that was embedded in a previous email. If needed 
> I can send it as an attachment directly to whom ever applies 
> the  patch.
> Regards,
> Seumas
> 
> -----Original Message-----
> From: Soltysik, Seumas [mailto:Seumas.Soltysik@iona.com]
> Sent: Tuesday, February 20, 2007 2:30 PM
> To: cxf-dev@incubator.apache.org
> Subject: RE: Creating/Applying patch with renamed files
> 
> 
> Ok, thanks to Eoghan, I have created a new patch using the 
> svn-create-patch script and uploaded it. The name of the 
> patch is cxf_427_patchfile_3. If someone could apply the 
> patch using the svn-apply tool, I would appreciate it.
> Regards,
> Seumas
> 
> -----Original Message-----
> From: Glynn, Eoghan [mailto:eoghan.glynn@iona.com]
> Sent: Saturday, February 17, 2007 4:03 AM
> To: cxf-dev@incubator.apache.org
> Subject: RE: Creating/Applying patch with renamed files
> 
> 
> 
> > -----Original Message-----
> > From: Soltysik, Seumas [mailto:Seumas.Soltysik@iona.com]
> > Sent: 17 February 2007 00:59
> > To: cxf-dev@incubator.apache.org
> > Subject: RE: Creating/Applying patch with renamed files
> > 
> > When I run this script  "script < patchfile" it still fails 
> on the 3 
> > file that I performed an "svn mv" on. This is the output I get:
> > 
> > can't find file to patch at input line 5 Perhaps you used 
> the wrong -p 
> > or --strip option?
> > The text leading up to this was:
> > --------------------------
> > |Index: 
> > |rt/management/src/main/java/org/apache/cxf/management/jmx/Ins
> > trumentati
> > |onManagerImpl.java
> > |===================================================================
> > |---
> > rt/management/src/main/java/org/apache/cxf/management/jmx/Inst
> > rumentationManagerImpl.java	(revision 506528)
> > |+++ 
> > rt/management/src/main/java/org/apache/cxf/management/jmx/Inst
> > rumentationManagerImpl.java	(working copy)
> > --------------------------
> > File to patch: 
> 
> 
> Hi Seumas,
> 
> See the following comment in the svn-apply script:
> 
> #   Handles copied and moved files (requires patches made by
> svn-create-patch).
> 
> So you'll need the svn-create-patch script too (copied below 
> and attached to a separate mail). Just go back to your 
> original working copy and re-create the patch file.
> 
> /Eoghan
> 
> 
> #!/usr/bin/perl -w 
>  
> # Copyright (C) 2005, 2006 Apple Computer, Inc.  All rights reserved. 
> #
> # Redistribution and use in source and binary forms, with or 
> without # modification, are permitted provided that the 
> following conditions # are met: 
> #
> # 1.  Redistributions of source code must retain the above copyright 
> #     notice, this list of conditions and the following disclaimer.  
> # 2.  Redistributions in binary form must reproduce the above 
> copyright 
> #     notice, this list of conditions and the following disclaimer in
> the 
> #     documentation and/or other materials provided with the
> distribution.  
> # 3.  Neither the name of Apple Computer, Inc. ("Apple") nor 
> the names of 
> #     its contributors may be used to endorse or promote products
> derived 
> #     from this software without specific prior written permission.  
> #
> # THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS 
> IS" AND ANY # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT 
> NOT LIMITED TO, THE IMPLIED # WARRANTIES OF MERCHANTABILITY 
> AND FITNESS FOR A PARTICULAR PURPOSE ARE
> 
> # DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE 
> LIABLE FOR ANY # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
> EXEMPLARY, OR CONSEQUENTIAL DAMAGES # (INCLUDING, BUT NOT 
> LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; # 
> LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
> HOWEVER CAUSED AND # ON ANY THEORY OF LIABILITY, WHETHER IN 
> CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE 
> OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF # THIS 
> SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
>  
> # Extended "svn diff" script for WebKit Open Source Project, 
> used to make patches. 
>  
> # Differences from standard "svn diff": 
> # 
> #   Uses the real diff, not svn's built-in diff. 
> #   Always passes "-p" to diff so it will try to include 
> function names.
> 
> #   Handles binary files (encoded as a base64 chunk of text). 
> #   Sorts the diffs alphabetically by text files, then binary files. 
> #   Handles copied and moved files. 
> #
> # Missing features: 
> # 
> #   Handle copied and moved directories. 
>  
> use strict;
> use warnings; 
>  
> use Config;
> use Cwd;
> use File::Basename;
> use File::Spec;
> use File::stat;
> use Getopt::Long;
> use MIME::Base64;
> use POSIX qw(:errno_h);
> use Time::gmtime; 
>  
> sub canonicalizePath($);
> sub findMimeType($);
> sub findModificationType($);
> sub findSourceFileAndRevision($);
> sub fixChangeLogPatch($);
> sub generateDiff($$$);
> sub generateFileList($\%\%);
> sub isBinaryMimeType($);
> sub manufacturePatchForAdditionWithHistory($$);
> sub numericcmp($$);
> sub outputBinaryContent($);
> sub pathcmp($$);
> sub processPaths(\@);
> sub splitpath($); 
>  
> my $showHelp;
> if (!GetOptions("help" => \$showHelp) || $showHelp) { 
>     print STDERR basename($0) . " [-h|--help] [svndir1 
> [svndir2 ...]]\n"; 
>     exit 1;
> } 
>  
> my %paths = processPaths(@ARGV); 
>  
> # Generate a list of files requiring diffs my %textFiles; my 
> %binaryFiles; for my $path (keys %paths) { 
>     generateFileList($path, %textFiles, %binaryFiles); } 
>  
> # Generate the diff for text files, then binary files, for 
> easy reviewing for my $file (sort pathcmp keys %textFiles) { 
>     generateDiff($file, $textFiles{$file}, 0); } for my $file 
> (sort pathcmp keys %binaryFiles) { 
>     generateDiff($file, $binaryFiles{$file}, 1); } 
>  
> exit 0; 
>  
>  
> sub canonicalizePath($)
> { 
>     my ($file) = @_; 
>  
>     # Remove extra slashes and '.' directories in path 
>     $file = File::Spec->canonpath($file); 
>  
>     # Remove '..' directories in path 
>     my @dirs = (); 
>     foreach my $dir (File::Spec->splitdir($file)) { 
>         if ($dir eq '..' && $#dirs >= 0 && $dirs[$#dirs] ne '..')
{ 
>             pop(@dirs); 
>         } else { 
>             push(@dirs, $dir); 
>         } 
>     } 
>     return ($#dirs >= 0) ? File::Spec->catdir(@dirs) : "."; } 
>  
> sub findMimeType($)
> { 
>     my ($file) = @_; 
>     open PROPGET, "svn propget svn:mime-type '$file' |" or die; 
>     my $mimeType = <PROPGET>; 
>     close PROPGET; 
>     chomp $mimeType if $mimeType; 
>     return $mimeType;
> } 
>  
> sub findModificationType($)
> { 
>     my ($stat) = @_; 
>     my $fileStat = substr($stat, 0, 1); 
>     my $propertyStat = substr($stat, 1, 1); 
>     if ($fileStat eq "A") { 
>         my $additionWithHistory = substr($stat, 3, 1); 
>         return $additionWithHistory eq "+" ? "additionWithHistory" :
> "addition"; 
>     } 
>     return "modification" if ($fileStat eq "M" || 
> $propertyStat eq "M");
> 
>     return "deletion" if ($fileStat eq "D"); 
>     return undef;
> } 
>  
> sub findSourceFileAndRevision($)
> { 
>     my ($file) = @_; 
>     my $baseUrl; 
>     open INFO, "svn info . |" or die; 
>     while (<INFO>) { 
>         if (/^URL: (.+)/) { 
>             $baseUrl = $1; 
>             last; 
>         } 
>     } 
>     close INFO; 
>     my $sourceFile; 
>     my $sourceRevision; 
>     open INFO, "svn info '$file' |" or die; 
>     while (<INFO>) { 
>         if (/^Copied From URL: (.+)/) { 
>             $sourceFile = File::Spec->abs2rel($1, $baseUrl); 
>         } elsif (/^Copied From Rev: ([0-9]+)/) { 
>             $sourceRevision = $1; 
>         } 
>     } 
>     close INFO; 
>     return ($sourceFile, $sourceRevision); } 
>  
> sub fixChangeLogPatch($)
> { 
>     my $patch = shift; 
>     my $contextLineCount = 3; 
>  
>     return $patch if $patch !~ /\n@@ -1,(\d+) \+1,(\d+) @@\n( 
> .*\n)+(\+.*\n)+( .*\n){$contextLineCount}$/m; 
>     my ($oldLineCount, $newLineCount) = ($1, $2); 
>     return $patch if $oldLineCount <= $contextLineCount; 
>  
>     # The diff(1) command is greedy when matching lines, so a 
> new ChangeLog entry will 
>     # have lines of context at the top of a patch when the 
> existing entry has the same 
>     # date and author as the new entry.  This nifty loop 
> alters a ChangeLog patch so 
>     # that the added lines ("+") in the patch always start at 
> the beginning of the 
>     # patch and there are no initial lines of context. 
>     my $newPatch; 
>     my $lineCountInState = 0; 
>     my $oldContentLineCountReduction = $oldLineCount - 
> $contextLineCount; 
>     my $newContentLineCountWithoutContext = $newLineCount - 
> $oldLineCount - $oldContentLineCountReduction; 
>     my ($stateHeader, $statePreContext, $stateNewChanges,
> $statePostContext) = (1..4); 
>     my $state = $stateHeader; 
>     foreach my $line (split(/\n/, $patch)) { 
>         $lineCountInState++; 
>         if ($state == $stateHeader && $line =~ /^@@ 
> -1,$oldLineCount \+1,$newLineCount @\@$/) { 
>             $line = "@@ -1,$contextLineCount +1," . ($newLineCount -
> $oldContentLineCountReduction) . " @@"; 
>             $lineCountInState = 0; 
>             $state = $statePreContext; 
>         } elsif ($state == $statePreContext && substr($line, 
> 0, 1) eq "
> ") { 
>             $line = "+" . substr($line, 1); 
>             if ($lineCountInState == $oldContentLineCountReduction) { 
>                 $lineCountInState = 0; 
>                 $state = $stateNewChanges; 
>             } 
>         } elsif ($state == $stateNewChanges && substr($line, 0, 1) eq
> "+") { 
>             # No changes to these lines 
>             if ($lineCountInState == 
> $newContentLineCountWithoutContext)
> { 
>                 $lineCountInState = 0; 
>                 $state = $statePostContext; 
>             } 
>         } elsif ($state == $statePostContext) { 
>             if (substr($line, 0, 1) eq "+" && $lineCountInState <=
> $oldContentLineCountReduction) { 
>                 $line = " " . substr($line, 1); 
>             } elsif ($lineCountInState > $contextLineCount && 
> substr($line, 0, 1) eq " ") { 
>                 next; # Discard 
>             } 
>         } 
>         $newPatch .= $line . "\n"; 
>     } 
>  
>     return $newPatch;
> } 
>  
> sub generateDiff($$$)
> { 
>     my ($file, $modificationType, $isBinary) = @_; 
>     my $patch; 
>     if ($modificationType eq "additionWithHistory") { 
>         manufacturePatchForAdditionWithHistory($file, $isBinary); 
>     } 
>     open DIFF, "svn diff --diff-cmd diff -x -uNp '$file' |" or die; 
>     while (<DIFF>) { 
>         $patch .= $_; 
>     } 
>     close DIFF; 
>     $patch = fixChangeLogPatch($patch) if basename($file) eq 
> "ChangeLog"; 
>     print $patch if $patch; 
>     if ($isBinary) { 
>         print "\n" if ($patch && $patch =~ m/\n\S+$/m); 
>         outputBinaryContent($file); 
>     }
> } 
>  
> sub generateFileList($\%\%)
> { 
>     my ($statPath, $textFiles, $binaryFiles) = @_; 
>     open STAT, "svn stat '$statPath' |" or die; 
>     while (my $line = <STAT>) { 
>         chomp $line; 
>         my $stat = substr($line, 0, 7); 
>         my $path = substr($line, 7); 
>         next if -d $path; 
>         my $modificationType = findModificationType($stat); 
>         if ($modificationType) { 
>             if (isBinaryMimeType($path)) { 
>                 $binaryFiles->{$path} = $modificationType; 
>             } else { 
>                 $textFiles->{$path} = $modificationType; 
>             } 
>         } else { 
>             print STDERR $line, "\n"; 
>         } 
>     } 
>     close STAT;
> } 
>  
> sub isBinaryMimeType($)
> { 
>     my ($file) = @_; 
>     my $mimeType = findMimeType($file); 
>     return 0 if (!$mimeType || substr($mimeType, 0, 5) eq "text/"); 
>     return 1;
> } 
>  
> sub manufacturePatchForAdditionWithHistory($$)
> { 
>     my ($file, $isBinary) = @_; 
>     print "Index: ${file}\n"; 
>     print "=" x 67, "\n"; 
>     my ($sourceFile, $sourceRevision) =
> findSourceFileAndRevision($file); 
>     print "--- ${file}\t(revision ${sourceRevision})\t(from 
> ${sourceFile}:${sourceRevision})\n"; 
>     print "+++ ${file}\t(working copy)\n"; 
>     if ($isBinary) { 
>         print "\nCannot display: file marked as a binary type.\n"; 
>         my $mimeType = findMimeType($file); 
>         print "svn:mime-type = ${mimeType}\n\n"; 
>     } else { 
>         print `svn cat ${sourceFile} | diff -u /dev/null - | 
> tail +3`; 
>     }
> } 
>  
> # Sort numeric parts of strings as numbers, other parts as strings. 
> # Makes 1.33 come after 1.3, which is cool. 
> sub numericcmp($$)
> { 
>     my ($aa, $bb) = @_; 
>  
>     my @a = split /(\d+)/, $aa; 
>     my @b = split /(\d+)/, $bb; 
>  
>     # Compare one chunk at a time. 
>     # Each chunk is either all numeric digits, or all not 
> numeric digits. 
>     while (@a && @b) { 
>         my $a = shift @a; 
>         my $b = shift @b; 
>          
>         # Use numeric comparison if chunks are non-equal numbers. 
>         return $a <=> $b if $a =~ /^\d/ && $b =~ /^\d/ && $a !=
$b; 
>  
>         # Use string comparison if chunks are any other kind 
> of non-equal string. 
>         return $a cmp $b if $a ne $b; 
>     } 
>      
>     # One of the two is now empty; compare lengths for result 
> in this case. 
>     return @a <=> @b;
> } 
>  
> sub outputBinaryContent($)
> { 
>     my ($path) = @_; 
>     # Deletion 
>     return if (! -e $path); 
>     # Addition or Modification 
>     my $buffer; 
>     open BINARY, $path  or die; 
>     while (read(BINARY, $buffer, 60*57)) { 
>         print encode_base64($buffer); 
>     } 
>     close BINARY; 
>     print "\n";
> } 
>  
> # Sort first by directory, then by file, so all paths in one 
> directory are grouped # rather than being interspersed with 
> items from subdirectories. 
> # Use numericcmp to sort directory and filenames to make 
> order logical. 
> sub pathcmp($$)
> { 
>     my ($patha, $pathb) = @_; 
>  
>     my ($dira, $namea) = splitpath($patha); 
>     my ($dirb, $nameb) = splitpath($pathb); 
>  
>     return numericcmp($dira, $dirb) if $dira ne $dirb; 
>     return numericcmp($namea, $nameb);
> } 
>  
> sub processPaths(\@)
> { 
>     my ($paths) = @_; 
>     return ("." => 1) if (!@{$paths}); 
>  
>     my %result = (); 
>  
>     for my $file (@{$paths}) { 
>         die "can't handle absolute paths like \"$file\"\n" if 
> File::Spec->file_name_is_absolute($file); 
>         die "can't handle empty string path\n" if $file eq ""; 
>         die "can't handle path with single quote in the name 
> like \"$file\"\n" if $file =~ /'/; # ' (keep Xcode syntax 
> highlighting happy)
> 
>  
>         my $untouchedFile = $file; 
>  
>         $file = canonicalizePath($file); 
>  
>         die "can't handle paths with .. like 
> \"$untouchedFile\"\n" if $file =~ m|/\.\./|; 
>  
>         $result{$file} = 1; 
>     } 
>  
>     return ("." => 1) if ($result{"."}); 
>  
>     # Remove any paths that also have a parent listed. 
>     for my $path (keys %result) { 
>         for (my $parent = dirname($path); $parent ne '.'; $parent =
> dirname($parent)) { 
>             if ($result{$parent}) { 
>                 delete $result{$path}; 
>                 last; 
>             } 
>         } 
>     } 
>  
>     return %result;
> } 
>  
> # Break up a path into the directory (with slash) and base name. 
> sub splitpath($)
> { 
>     my ($path) = @_; 
>  
>     my $pathSeparator = "/"; 
>     my $dirname = dirname($path) . $pathSeparator; 
>     $dirname = "" if $dirname eq "." . $pathSeparator; 
>  
>     return ($dirname, basename($path)); } 
> 

Mime
View raw message