rpatch 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  data.tar.gz: 99bef45fa909f75a0680dbd94b5bc7fd2bb29b56
+  metadata.gz: 27d3cc372f56d16a39e4cde00e50cda8e890b191
+SHA512: 
+  data.tar.gz: 9fe2efe77726f1226e3fc72d353b789b50584c435fddb0f9bb2a8f074223c79b8051a0d5fd0183cb5dd965fe1150e1dd5964f71d9b2c700d6e28c058b593c8e6
+  metadata.gz: bf804d1fbcff8dac5c7877b3adfd3ffef762947eafe6d33366efd77627a8fcdd98b873253d8701f1ff36ca2050535ec6673ede954362a145a5b5b2db1b2b2d1a

data/README.md

@@ -4,12 +4,21 @@ rpatch: a patch utility support regexp in patchfile.
 
 Rpatch is a patch utility, more tolerant than GNU patch. It will ignore
 changes of blank lines and white spaces, and what's more you can write
-regexp ("RE: " and "RE:-") in patch file to match lines.
+regexp ("/ " and "/-") in patch file to match lines.
 
- * Use "RE: " with a regexp to match unchanged line.
- * Use "RE:-" with a regexp to match removed line.
- * Use "@@" to starts a new patch hunk only and use it's text as
-   description for the hunk only.
+Three typical diff formats:
+
+ * Start with " ": exist in both original and target. (context)
+ * Start with "-": only in original file, not in target. (removed)
+ * Start with "+": not in original file, but in target. (added)
+
+Additional diff formats that rpatch support:
+
+ * Start with "/ ": regexp which match both original and target.
+ * Start with "/-": regexp which match only original file.
+ * Start with "? ": in original file, but may not in target.
+ * Start with "?+": not in original file, but may or may not in target.
+ * Start with "?/ ": regexp which match original, but may not have in target.
 
 For example:
 
@@ -31,8 +40,8 @@ For example:
         +# Copyright (c) 2013 Jiang Xin
         +
          When I hack files using GNU patch,
-        RE: sometimes fail because .*
-        RE:-(blah\s*){3}
+        / [sS]ometimes fail because .*
+        /-(blah\s*){3}
         @@ add notes
         +If patch can ignore blank lines, support regex patterns
         +in patch, it will be nice.

data/lib/rpatch/entry.rb

@@ -2,7 +2,9 @@
 #
 
 require 'stringio'
+require 'fileutils'
 require 'rpatch/error'
+require 'rpatch/utils'
 require 'rpatch/hunk'
 
 module Rpatch
@@ -49,7 +51,7 @@ module Rpatch
         ''
       end
     rescue Exception => e
-      STDERR.puts "Error: #{e.message}"
+      Tty.error e.message
     end
 
     def patch_on_file(input, output=nil)
@@ -59,6 +61,9 @@ module Rpatch
       	filename = "<#{newfile}>"
       else
       	filename = output
+        unless File.exist?(File.dirname(output))
+          FileUtils.mkdir_p File.dirname(output)
+        end
       end
 
       if input.is_a? IO or input.is_a? StringIO
@@ -76,9 +81,9 @@ module Rpatch
         begin
           hunk.patch(lines)
         rescue AlreadyPatchedError => e
-          STDERR.puts "#{filename}: #{e.message}"
+          Tty.info "#{filename}: #{e.message}"
         rescue Exception => e
-          STDERR.puts "ERROR: #{filename}: #{e.message}"
+          Tty.error "#{filename}: #{e.message}"
           patch_status = false
         else
           patch_applied = true
@@ -88,7 +93,7 @@ module Rpatch
       if output.is_a? IO or output.is_a? StringIO
         output.write lines * "\n" + "\n"
       elsif not patch_applied
-        STDERR.puts "#{filename}: nothing changed"
+        Tty.notice "#{filename}: nothing changed"
         if input != output
           File.open(output, "w") do |io|
             io.write lines * "\n" + "\n"
@@ -96,31 +101,32 @@ module Rpatch
         end
       else
         unless patch_status
-          STDERR.puts "Warning: saved orignal file as \"#{output}.orig\"."
+          Tty.warning "saved orignal file as \"#{output}.orig\"."
           File.open("#{output}.orig", "w") do |io|
             io.write lines_dup * "\n" + "\n"
           end
         end
         if lines.size > 0
-          STDERR.puts "Patched \"#{output}\"."
           File.open(output, "w") do |io|
             io.write lines * "\n" + "\n"
           end
+          Tty.notice "Patched \"#{output}\"."
         else
-          STDERR.puts "Remove \"#{output}\"."
           File.unlink output
+          Tty.notice "Remove \"#{output}\"."
         end
       end
       return patch_status
     end
 
     def patch_on_directory(inputdir, outputdir=nil)
-      outputdir ||=inputdir
-      input = oldfile.start_with?('/') ? oldfile : File.join(inputdir, oldfile)
-      output = outputdir
-      if File.directory? outputdir
-        output = newfile.start_with?('/') ? newfile : File.join(outputdir, newfile)
+      outputdir ||= inputdir
+      if oldfile == '/dev/null'
+        input = newfile.start_with?('/') ? newfile : File.join(inputdir, newfile)
+      else
+        input = oldfile.start_with?('/') ? oldfile : File.join(inputdir, oldfile)
       end
+      output = newfile.start_with?('/') ? newfile : File.join(outputdir, newfile)
       patch_on_file(input, output)
     end
 

data/lib/rpatch/hunk.rb

@@ -1,6 +1,88 @@
 require 'rpatch/error'
 
 module Rpatch
+
+  class Pattern
+    attr_reader :text
+
+    def initialize(line)
+      @text = line.chomp
+    end
+
+    def is_in_before?
+      @is_in_before ||= begin
+        @text =~ /^( |-|\/ |\/-|\? |\?-|\?\/ |\?\/-)/
+      end
+    end
+
+    def is_in_after?
+      @is_in_after ||= begin
+        @text =~ /^( |\+|\/ |\/\+)/
+      end
+    end
+
+    def is_add?
+      @is_add ||= begin
+        @text =~ /^\+/
+      end
+    end
+
+    def is_pattern?
+      @is_pattern ||= pattern.is_a?(Regexp)
+    end
+
+    def pattern
+      @pattern ||= begin
+        if text =~ /^\/( |-|\+)/
+          Regexp.new(text[2..-1].strip)
+        elsif text =~ /^\?\/( |-|\+)/
+          Regexp.new(text[3..-1].strip)
+        elsif text =~ /^( |-|\+)/
+          pattern = text[1..-1].strip.gsub(/\s+/, ' ')
+        elsif text =~ /^\?( |-|\+)/
+          pattern = text[2..-1].strip.gsub(/\s+/, ' ')
+        else
+          raise PatchFormatError.new("-0---Unknown pattern in diffs: #{text.inspect}")
+        end
+      end
+    end
+
+    def match(message)
+      return nil unless message
+      message = message.chomp
+      match = nil
+      while true
+        if is_pattern?
+          # When match with regexp, do not twick message
+          if pattern.match(message)
+            match = 1
+          end
+        else
+          message = message.strip.gsub(/\s+/, ' ')
+          if pattern == message
+            match = 1
+          end
+        end
+
+        if match
+          break
+        elsif message.empty?
+          match = 0
+          break
+        # compare without leading "#"
+        elsif message.start_with? "#"
+          while message.start_with? "#"
+            message = message[1..-1]
+            message = message.strip unless is_pattern?
+          end
+        else
+          break
+        end
+      end
+      match
+    end
+  end
+
   class PatchHunk
     attr_reader :title, :diffs, :num
 
@@ -11,7 +93,21 @@ module Rpatch
     end
 
     def feed_line(line)
-      diffs << line.chomp
+      @diffs << line.chomp
+    end
+
+    def head?
+      not tail?
+    end
+
+    def tail?
+      diffs.first == ">"
+    end
+
+    def has_add?
+      @has_add ||= begin
+        patterns.select{|p| p.is_add?}.any?
+      end
     end
 
     # Patch lines in place.
@@ -19,20 +115,14 @@ module Rpatch
       matched_before = match_before_patch lines
       matched_after = match_after_patch lines
 
-      if patterns_before_patch.size > patterns_after_patch.size
+      if matched_after
         if not matched_before
-          if matched_after
-            raise AlreadyPatchedError.new("Hunk #{num} (#{title}) is already patched.")
-          else
-            raise PatchHunkError, "Hunk #{num} (#{title}) FAILED to apply. Match failed."
-          end
-        end
-      else
-        if matched_after
           raise AlreadyPatchedError.new("Hunk #{num} (#{title}) is already patched.")
-        elsif not matched_before
-          raise PatchHunkError, "Hunk #{num} (#{title}) FAILED to apply. Match failed."
+        elsif has_add?
+          raise AlreadyPatchedError.new("Hunk #{num} (#{title}) is already patched.")
         end
+      elsif not matched_before
+        raise PatchHunkError, "Hunk #{num} (#{title}) FAILED to apply. Match failed."
       end
 
       n, size = matched_before
@@ -43,41 +133,45 @@ module Rpatch
     # Apply patch on lines.
     # Return array of strings contain result of applying patch.
     def convert(lines)
-      lines_dup = lines.dup
+      lines = lines.dup
       result = []
-      i = 0
-      while i < @diffs.size
-        case @diffs[i]
-        when /^( |RE: )/
+      i = j = 0
+      while i < diffs.size
+        case diffs[i]
+        when /^\??\/? /
           while true
-            match =  match_line lines_dup.first, patterns[i]
+            match =  patterns[j].match lines.first
             if not match
-              raise PatchFormatError.new("Hunk #{num} (#{title}) FAILED to apply. No match \"#{patterns[i]}\" with #{lines_dup.first.inspect}.")
+              raise PatchFormatError.new("Hunk #{num} (#{title}) FAILED to apply. No match \"#{patterns[j]}\" with #{lines.first.inspect}.")
             elsif match > 0
-              result << lines_dup.shift
+              result << lines.shift
               break
             elsif match == 0
-              result << lines_dup.shift
+              result << lines.shift
             end
           end
-        when /^(-|RE:-)/
+        when /^\??\/?[-]/
           while true
-            match =  match_line lines_dup.first, patterns[i]
+            match =  patterns[j].match lines.first
             if not match
-              raise PatchFormatError.new("Hunk #{num} (#{title}) FAILED to apply. No match pattern \"#{patterns[i]}\" against #{lines_dup.first.inspect}.")
+              raise PatchFormatError.new("Hunk #{num} (#{title}) FAILED to apply. No match pattern \"#{patterns[j]}\" against #{lines.first.inspect}.")
             elsif match > 0
-              lines_dup.shift
+              lines.shift
               break
             elsif match == 0
-              lines_dup.shift
+              lines.shift
             end
           end
-        when /^\+/
-          result << @diffs[i][1..-1]
+        when /^(\??\/?\+)/
+          result << diffs[i][$1.size..-1]
+        when /^(<|>)$/
+          # patterns do not have locaiton direction
+          j -= 1
         else
-          raise PatchFormatError.new("Hunk #{num} (#{title}) FAILED to apply. Unknow syntax in hunk: #{@diffs[i]}")
+          raise PatchFormatError.new("Hunk #{num} (#{title}) FAILED to apply. Unknow syntax in hunk: #{diffs[i]}")
         end
         i += 1
+        j += 1
       end
       result
     end
@@ -86,19 +180,30 @@ module Rpatch
     # match start with location and +num lines are matched.
     # Return nil, if nothing matched.
     def match_after_patch(lines)
-      i = 0
       if patterns_after_patch.size == 0
-        return [0, 0]
+        return head? ? [0, 0] : [lines.size, 0]
       end
 
-      loop_n = lines.size
-      loop_n = loop_n - patterns_after_patch.size + 1 if patterns_after_patch.size > 0
-      while i < loop_n
-        matched_line_no = match_beginning(lines[i..-1], patterns_after_patch)
-        if matched_line_no
-          return [i, matched_line_no]
-        else
-          i += 1
+      if head?
+        i = 0
+        loop_n = lines.size - patterns_after_patch.size
+        while i <= loop_n
+          matched_size = get_matched_size(lines[i..-1], patterns_after_patch)
+          if matched_size
+            return [i, matched_size]
+          else
+            i += 1
+          end
+        end
+      else
+        i = lines.size - patterns_after_patch.size
+        while i >= 0
+          matched_size = get_matched_size(lines[i..-1], patterns_after_patch)
+          if matched_size
+            return [i, matched_size]
+          else
+            i -= 1
+          end
         end
       end
       nil
@@ -108,20 +213,38 @@ module Rpatch
     # at location, and +num lines would be replaced.
     # Return nil, if nothing matched.
     def match_before_patch(lines)
-      i = 0
+# puts "="*90
+# puts patterns_before_patch.inspect
+# puts patterns_before_patch.size
+# puts "-"*90
+# puts diffs.inspect
+#puts "-"*90
+#puts patterns.map{|p| [p.pattern.inspect, p.is_in_before?.inspect, p.is_in_after?.inspect]}.inspect
       if patterns_before_patch.size == 0
-        return [0, 0]
+        return head? ? [0, 0] : [lines.size, 0]
       end
 
-      loop_n = lines.size
-      loop_n = loop_n - patterns_before_patch.size + 1 if patterns_before_patch.size > 0
+      if head?
+        i = 0
+        loop_n = lines.size - patterns_before_patch.size
 
-      while i < loop_n
-        matched_size = match_beginning(lines[i..-1], patterns_before_patch)
-        if matched_size
-          return [i, matched_size]
-        else
-          i += 1
+        while i <= loop_n
+          matched_size = get_matched_size(lines[i..-1], patterns_before_patch)
+          if matched_size
+            return [i, matched_size]
+          else
+            i += 1
+          end
+        end
+      else
+        i = lines.size - patterns_before_patch.size
+        while i >= 0
+          matched_size = get_matched_size(lines[i..-1], patterns_before_patch)
+          if matched_size
+            return [i, matched_size]
+          else
+            i -= 1
+          end
         end
       end
       nil
@@ -130,7 +253,7 @@ module Rpatch
     # Test whether patterns match against the beginning of lines
     # Return nil if not match, or return number of lines matched
     # with patterns (would be replaced later).
-    def match_beginning(lines, patterns)
+    def get_matched_size(lines, patterns)
       i = 0
       found = true
       patterns.each do |pattern|
@@ -140,7 +263,7 @@ module Rpatch
         end
 
         while true
-          match = match_line lines[i], pattern
+          match = pattern.match lines[i]
           if not match
             found = false
             break
@@ -177,90 +300,29 @@ module Rpatch
       end
     end
 
-    def match_line(message , pattern)
-      return nil unless message
-      line = nil
-      match = nil
-      while true
-        if pattern.is_a? Regexp
-          # When match with regexp, do not twick message
-          line ||= message.dup
-          if pattern.match(line)
-            match = 1
-          end
-        else
-          line ||= message.strip.gsub(/\s+/, ' ')
-          if pattern == line
-            match = 1
-          end
-        end
-
-        if match
-          break
-        elsif line.empty?
-          match = 0
-          break
-        elsif line.start_with? "#"
-          while line.start_with? "#"
-            line = line[1..-1]
-            line = line.strip unless pattern.is_a? Regexp
-          end
-        else
-          break
-        end
-      end
-      match
-    end
-
     def patterns_before_patch
       @patterns_before_patch ||= begin
-        result = []
-        @diffs.each do |line|
-          case line
-          when /^( |-)/
-            result << line[1..-1].strip.gsub(/\s+/, ' ')
-          when /^(RE: |RE:-)/
-            result << Regexp.new(line[4..-1].strip)
-          when /^\+/
-            next
-          else
-            raise PatchFormatError.new("Unknown pattern in diffs: #{line}")
-          end
-        end
-        result
+        patterns.select{|p| p.is_in_before?}
       end
     end
 
     def patterns_after_patch
       @patterns_after_patch ||= begin
-        result = []
-        @diffs.each do |line|
-          case line
-          when /^( |\+)/
-            result << line[1..-1].strip.gsub(/\s+/, ' ')
-          when /^(RE: )/
-            result << Regexp.new(line[4..-1].strip)
-          when /^(-|RE:-)/
-            next
-          else
-            raise PatchFormatError.new("Unknown pattern in diffs: #{line}")
-          end
-        end
-        result
+        patterns.select{|p| p.is_in_after?}
       end
     end
 
     def patterns
       @patterns ||= begin
         result = []
-        @diffs.each do |line|
+        diffs.each do |line|
           case line
-          when /^( |\+|-)/
-            result << line[1..-1].strip.gsub(/\s+/, ' ')
           when /^(RE: |RE:-)/
-            result << Regexp.new(line[4..-1].strip)
+            raise PatchFormatError.new("Obsolete pattern, subsitude \"RE:\" with \"/\":\n=> #{line}")
+          when /^(<|>)$/
+            # ignore locaiton direction
           else
-            raise PatchFormatError.new("Unknown pattern in diffs: #{line}")
+            result << Pattern.new(line)
           end
         end
         result