rpatch 0.0.1

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jiang Xin
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+# Rpatch
+
+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.
+
+ * 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.
+
+For example:
+
+ * Origninal file:
+
+        When    I    hack    files    using    GNU    patch,
+        sometimes fail because of the change of upstream files.
+        blah blah blah...
+        So    comes    rpatch.
+    
+        Happy hacking.
+
+ * Patch file:
+
+        diff -ru a/README b/README
+        --- a/readme.txt	2013-11-03 22:17:02.000000000 +0800
+        +++ b/readme.txt	2013-11-03 21:10:46.000000000 +0800
+        @@ add copyright at the beginning
+        +# Copyright (c) 2013 Jiang Xin
+        +
+         When I hack files using GNU patch,
+        RE: sometimes fail because .*
+        RE:-(blah\s*){3}
+        @@ add notes
+        +If patch can ignore blank lines, support regex patterns
+        +in patch, it will be nice.
+         So comes rpatch.
+        @@ add signature
+         Happy hacking.
+        +--
+        +jiangxin
+
+ * And the result would be:
+
+        # Copyright (c) 2013 Jiang Xin
+
+        When    I    hack    files    using    GNU    patch,
+        sometimes fail because of the change of upstream files.
+        If patch can ignore blank lines, support regex patterns
+        in patch, it will be nice.
+        So    comes    rpatch.
+
+        Happy hacking.
+        --
+        jiangxin
+
+## Installation
+
+Install using rubygems:
+
+    $ gem install rpatch
+
+Or install from source:
+
+    $ rake build
+    $ rake install
+
+## Usage
+
+Rpatch is a GNU patch likely utilty, patch original file using patch file like this:
+
+    $ patch originalfile patchfile
+
+Or patch files under the current directory, and read patchfile from STDIN:
+
+    $ patch -p1 < patchfile
+
+Rpatch can also read a series patches in quilt format.
+
+    $ patch -p1 . patches
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/bin/rpatch

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+#
+
+begin
+  require 'rpatch/runner'
+  Rpatch::Runner.runner
+rescue LoadError
+  $stderr.puts <<-EOS
+#{'*'*50}
+  Could not require 'rpatch/patch'
+
+  This may happen if you're using rubygems as your package manager, but it is not
+  being required through some mechanism before executing the rpatch command.
+
+  You may need to do one of the following in your shell:
+
+    # for bash/zsh
+    export RUBYOPT=rubygems
+
+    # for csh, etc.
+    set RUBYOPT=rubygems
+
+  For background, please see http://gist.github.com/54177.
+#{'*'*50}
+  EOS
+  exit(1)
+end

data/lib/rpatch/entry.rb

@@ -0,0 +1,137 @@
+#!/usr/bin/env ruby
+#
+
+require 'stringio'
+require 'rpatch/error'
+require 'rpatch/hunk'
+
+module Rpatch
+  class PatchEntry
+    attr_reader :level
+
+    def initialize(old, new, level)
+      @entry_old = old
+      @entry_new = new
+      @level = level
+      @hunks = []
+    end
+
+    def oldfile
+      @oldfile ||= path_strip_prefix(@entry_old, @level)
+    end
+
+    def newfile
+      @newfile ||= path_strip_prefix(@entry_new, @level)
+    end
+
+    def feed_line(line)
+      if line =~ /^@@/
+        hunk = PatchHunk.new line, @hunks.size + 1
+        @hunks << hunk
+      elsif @hunks.any?
+        @hunks[-1].feed_line line
+      else
+        raise PatchFormatError, "Feed lines must start with @@, not: #{line}"
+      end
+    end
+
+    # Used in test cases.
+    def patch_on_message(text)
+      lines = text.split("\n").map{|line| line.chomp}
+
+      @hunks.each do |hunk|
+        hunk.patch(lines)
+      end
+
+      if lines.size > 0
+        lines * "\n" + "\n"
+      else
+        ''
+      end
+    rescue Exception => e
+      STDERR.puts "Error: #{e.message}"
+    end
+
+    def patch_on_file(input, output=nil)
+      lines = []
+      output ||= input
+      if output.is_a? IO or output.is_a? StringIO
+      	filename = "<#{newfile}>"
+      else
+      	filename = output
+      end
+
+      if input.is_a? IO or input.is_a? StringIO
+        lines = input.readlines.map{|line| line.chomp}
+      elsif File.file? input
+        File.open(input) do |io|
+          lines = io.readlines.map{|line| line.chomp}
+        end
+      end
+      lines_dup = lines.dup
+
+      patch_applied = false
+      patch_status = true
+      @hunks.each do |hunk|
+        begin
+          hunk.patch(lines)
+        rescue AlreadyPatchedError => e
+          STDERR.puts "#{filename}: #{e.message}"
+        rescue Exception => e
+          STDERR.puts "ERROR: #{filename}: #{e.message}"
+          patch_status = false
+        else
+          patch_applied = true
+        end
+      end
+
+      if output.is_a? IO or output.is_a? StringIO
+        output.write lines * "\n" + "\n"
+      elsif not patch_applied
+        STDERR.puts "#{filename}: nothing changed"
+        if input != output
+          File.open(output, "w") do |io|
+            io.write lines * "\n" + "\n"
+          end
+        end
+      else
+        unless patch_status
+          STDERR.puts "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
+        else
+          STDERR.puts "Remove \"#{output}\"."
+          File.unlink 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)
+      end
+      patch_on_file(input, output)
+    end
+
+  private
+
+    def path_strip_prefix(name, level)
+      filename = name.dup
+      unless filename.start_with? '/'
+        level.times {filename.sub!(/^[^\/]+\//, '')}
+      end
+      filename
+    end
+  end
+end

data/lib/rpatch/error.rb

@@ -0,0 +1,8 @@
+module Rpatch
+  class AlreadyPatchedError < Exception; end
+  class PatchHunkError < Exception; end
+  class PatchFormatError < Exception; end
+  class FileNotExistError < Exception; end
+  class PatchFailNotify < Exception; end
+  class PatchOneWithManyError < Exception; end
+end

data/lib/rpatch/hunk.rb

@@ -0,0 +1,271 @@
+require 'rpatch/error'
+
+module Rpatch
+  class PatchHunk
+    attr_reader :title, :diffs, :num
+
+    def initialize(text, num=nil)
+      @title = text.chomp.sub(/^@@/, '').strip
+      @num = num || "#"
+      @diffs = []
+    end
+
+    def feed_line(line)
+      diffs << line.chomp
+    end
+
+    # Patch lines in place.
+    def patch(lines)
+      matched_before = match_before_patch lines
+      matched_after = match_after_patch lines
+
+      if patterns_before_patch.size > patterns_after_patch.size
+        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."
+        end
+      end
+
+      n, size = matched_before
+      lines[n...(n+size)] = convert lines[n...(n+size)]
+      lines
+    end
+
+    # Apply patch on lines.
+    # Return array of strings contain result of applying patch.
+    def convert(lines)
+      lines_dup = lines.dup
+      result = []
+      i = 0
+      while i < @diffs.size
+        case @diffs[i]
+        when /^( |RE: )/
+          while true
+            match =  match_line lines_dup.first, patterns[i]
+            if not match
+              raise PatchFormatError.new("Hunk #{num} (#{title}) FAILED to apply. No match \"#{patterns[i]}\" with #{lines_dup.first.inspect}.")
+            elsif match > 0
+              result << lines_dup.shift
+              break
+            elsif match == 0
+              result << lines_dup.shift
+            end
+          end
+        when /^(-|RE:-)/
+          while true
+            match =  match_line lines_dup.first, patterns[i]
+            if not match
+              raise PatchFormatError.new("Hunk #{num} (#{title}) FAILED to apply. No match pattern \"#{patterns[i]}\" against #{lines_dup.first.inspect}.")
+            elsif match > 0
+              lines_dup.shift
+              break
+            elsif match == 0
+              lines_dup.shift
+            end
+          end
+        when /^\+/
+          result << @diffs[i][1..-1]
+        else
+          raise PatchFormatError.new("Hunk #{num} (#{title}) FAILED to apply. Unknow syntax in hunk: #{@diffs[i]}")
+        end
+        i += 1
+      end
+      result
+    end
+
+    # Return [location, +num_of_lines], which seems already patched, and
+    # 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]
+      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
+        end
+      end
+      nil
+    end
+
+    # Return [location, +num_of_lines], which could apply patch at
+    # at location, and +num lines would be replaced.
+    # Return nil, if nothing matched.
+    def match_before_patch(lines)
+      i = 0
+      if patterns_before_patch.size == 0
+        return [0, 0]
+      end
+
+      loop_n = lines.size
+      loop_n = loop_n - patterns_before_patch.size + 1 if patterns_before_patch.size > 0
+
+      while i < loop_n
+        matched_size = match_beginning(lines[i..-1], patterns_before_patch)
+        if matched_size
+          return [i, matched_size]
+        else
+          i += 1
+        end
+      end
+      nil
+    end
+
+    # 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)
+      i = 0
+      found = true
+      patterns.each do |pattern|
+        unless lines[i]
+          found = false
+          break
+        end
+
+        while true
+          match = match_line lines[i], pattern
+          if not match
+            found = false
+            break
+          # Match precisely for the first line of pattern (i==0),
+          # Not pass blank lines.
+          elsif match == 0 and i == 0
+            found = false
+            break
+          # Matched.
+          elsif match > 0
+            break
+          # Match next line if this line is blank.
+          elsif match == 0
+            i += 1
+            unless lines[i]
+              found = false
+              break
+            end
+          # Never comes here.
+          else
+            found = false
+            break
+          end
+        end
+
+        break unless found
+        i += 1
+      end
+
+      if found
+        i
+      else
+        nil
+      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
+      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
+      end
+    end
+
+    def patterns
+      @patterns ||= 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)
+          else
+            raise PatchFormatError.new("Unknown pattern in diffs: #{line}")
+          end
+        end
+        result
+      end
+    end
+
+  end
+end

data/lib/rpatch/patch.rb

@@ -0,0 +1,158 @@
+#!/usr/bin/env ruby
+#
+
+require 'rpatch/error'
+require 'rpatch/entry'
+
+module Rpatch
+  class Patch
+    attr_reader :name, :level, :patch_entries
+
+    class <<self
+      def apply(path, patches, patch_level)
+        unless File.exist? path
+          raise FileNotExistError, "File or directory \"#{path}\" does not exist"
+        end
+        patch_status = true
+        patches.each do |patch_file|
+          if patch_file.is_a? IO or patch_file.is_a? StringIO
+            apply_one(path, patch_file, patch_level) || patch_status = false
+          elsif File.file? patch_file
+            apply_one(path, patch_file, patch_level) || patch_status = false
+          elsif File.directory? patch_file
+            apply_quilt(path, patch_file, patch_level) || patch_status = false
+          else
+            raise FileNotExistError, "Can not find patch file: #{patch_file}"
+          end
+        end
+        patch_status
+      rescue Exception => e
+        STDERR.puts "Error: #{e.message}"
+        patch_status = false
+      end
+    end
+
+    def initialize(file, level)
+      @name = file.is_a?(String) ? file : "<#{file.class.to_s}>"
+      @patch = file
+      @level = level
+      @patch_entries = []
+      load_patch
+    end
+
+    def apply_to(input, output=nil)
+      patch_status = true
+      patch_entries.each do |patch_entry|
+        begin
+          # input maybe a IO, StringIO, directory, file, or in-exist file.
+          if input.is_a? String and File.directory? input
+            patch_entry.patch_on_directory(input, output) || patch_status = false
+          else
+            if patch_entries.size > 1
+              raise PatchOneWithManyError, "Multiple patch entries (#{patch_entries.size}) have been found in patch #{name}"
+            end
+            # a IO, StringIO, file, or inexist file.
+            patch_entry.patch_on_file(input, output) || patch_status = false
+          end
+        rescue Exception => e
+          STDERR.puts "Error: #{e.message}"
+          patch_status = false
+        end
+      end
+      patch_status
+    end
+
+  private
+
+    class <<self
+      def apply_one(path, patch_file, patch_level)
+        patch = Patch.new(patch_file, patch_level)
+        patch.apply_to(path)
+      end
+
+      def apply_quilt(path, quilt_dir, patch_level)
+        patch_status = true
+        if File.exist?("#{quilt_dir}/series")
+          File.open("#{quilt_dir}/series") do |io|
+            io.readlines.each do |line|
+              line.strip!
+              filename = line
+              level = patch_level
+              if line =~ /^(.*?)[\s]+-p([0-9]*)$/
+                filename = $1
+                level = $2
+              end
+              unless filename.start_with? '#'
+                apply_one(path, filename, level) || patch_status = false
+              end
+            end
+          end
+        else
+          raise FileNotExistError, "Can not find (quilt) patchs in dir: #{quilt_dir}"
+        end
+        patch_status
+      end
+    end
+
+    def load_patch
+      i=0
+      lines = get_patch
+      while i < lines.size
+        entry_names = find_new_entry(lines[i..i+6])
+        if entry_names
+          @patch_entries << PatchEntry.new(entry_names[0], entry_names[1], @level)
+          while not lines[i] =~ /^@@ / and lines[i]
+            i += 1
+          end
+          break unless i < lines.size
+        end
+
+        if @patch_entries.any?
+          if lines[i] =~ /^(@@| |-|\+|RE: |RE:-)/
+            @patch_entries.last.feed_line lines[i]
+          elsif lines[i] =~ /^(Binary files |Only in)/
+            # ignore
+          else
+            raise PatchFormatError, "Line #{i} of patch \"#{name}\" is invalid.\n\t=> #{lines[i].inspect}"
+          end
+        end
+
+        i += 1
+      end
+    end
+
+    def get_patch
+      if @patch.is_a? IO or @patch.is_a? StringIO
+        @patch.readlines.map {|line| line.chomp}
+      else
+        File.open(@patch) do |io|
+          io.readlines.map {|line| line.chomp}
+        end
+      end
+    end
+
+    def find_new_entry(lines)
+      return nil if lines[0] =~ /^(@@| |-|\+|RE: |RE:-)/
+      old = new = nil
+      lines_dup = lines.dup
+      line = lines_dup.shift
+      line = lines_dup.shift if line =~ /^diff /
+      line = lines_dup.shift if line =~ /^new file mode/
+      line = lines_dup.shift if line =~ /^index /
+      if line =~ /^--- (.+?)([\s]+[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}.*)?$/
+        old = $1
+        line = lines_dup.shift
+      end
+      if line =~ /^\+\+\+ (.+?)([\s]+[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}.*)?$/
+        new = $1
+        line = lines_dup.shift
+      end
+      if line =~ /^@@ / and old and new
+        [old, new]
+      else
+        nil
+      end
+    end
+  end
+
+end