cxf-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Soltysik, Seumas" <Seumas.Solty...@iona.com>
Subject RE: Creating/Applying patch with renamed files
Date Thu, 22 Feb 2007 16:21:25 GMT
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