rpatch 0.0.1 → 0.0.2

data/lib/rpatch/patch.rb

@@ -2,9 +2,13 @@
 #
 
 require 'rpatch/error'
+require 'rpatch/utils'
 require 'rpatch/entry'
 
 module Rpatch
+
+  REGEXP_VALID_HUNK_PREFIX = /^(@@| |-|\+|RE: |RE:-|\/ |\/-|<$|>$|\?( |-|\+|\/ |\/-|\/\+))/
+
   class Patch
     attr_reader :name, :level, :patch_entries
 
@@ -27,7 +31,7 @@ module Rpatch
         end
         patch_status
       rescue Exception => e
-        STDERR.puts "Error: #{e.message}"
+        Tty.error e.message
         patch_status = false
       end
     end
@@ -55,7 +59,7 @@ module Rpatch
             patch_entry.patch_on_file(input, output) || patch_status = false
           end
         rescue Exception => e
-          STDERR.puts "Error: #{e.message}"
+          Tty.error e.message
           patch_status = false
         end
       end
@@ -83,7 +87,7 @@ module Rpatch
                 level = $2
               end
               unless filename.start_with? '#'
-                apply_one(path, filename, level) || patch_status = false
+                apply_one(path, File.join(quilt_dir, filename), level) || patch_status = false
               end
             end
           end
@@ -101,19 +105,19 @@ module Rpatch
         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]
+          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:-)/
+          if lines[i] =~ REGEXP_VALID_HUNK_PREFIX
             @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}"
+            raise PatchFormatError, "Line #{i} of patch \"#{name}\" is invalid.\n=> #{lines[i].inspect}"
           end
         end
 
@@ -132,22 +136,27 @@ module Rpatch
     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
+      lines = lines.dup
+      while lines.first
+        case lines.first
+        when /^--- (.+?)([\s]+[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}.*)?$/
+          old = $1
+        when /^\+\+\+ (.+?)([\s]+[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}.*)?$/
+          new = $1
+        when REGEXP_VALID_HUNK_PREFIX
+          break
+        when /^(diff |new file mode|index )/
+            # Ignore GNU/Git diff header
+        when /^(Index:|=+)/
+            # Ignore quilt patch header
+        else
+            # Ignore comments in the header
+        end
+        lines.shift
       end
-      if line =~ /^@@ / and old and new
+
+      if lines.first =~ /^@@/ and old and new
         [old, new]
       else
         nil

data/lib/rpatch/runner.rb

@@ -1,6 +1,7 @@
 require 'optparse'
-require 'rpatch/patch'
+require 'rpatch/utils'
 require 'rpatch/version'
+require 'rpatch/patch'
 
 module Rpatch
   class Runner
@@ -13,10 +14,12 @@ module Rpatch
           OptionParser.new do |opts|
             opts.banner = "Usage: rpatch [options] [originalfile [patchfile]]"
             opts.on("-p", "--strip num", "Patch level") {|v| patch_level = v.to_i}
-            opts.on("-v", "--version", "Show version") do
+            opts.on("-V", "--version", "Show version") do
               puts "Version #{Rpatch::VERSION}"
               exit 0
             end
+            opts.on("-v", "--verbose", "More verbose") {Tty.options[:verbose] += 1}
+            opts.on("-q", "--quiet", "Less verbose") {Tty.options[:verbose] -= 1}
             opts.on_tail("-h", "--help", "Show this message") do
               puts opts
               exit 0

data/lib/rpatch/utils.rb

@@ -0,0 +1,121 @@
+require 'rpatch/error'
+
+module Rpatch
+
+  class Tty
+    class << self
+      def options
+        @options ||= {:verbose => 0}
+      end
+      def blue; bold 34; end
+      def white; bold 39; end
+      def red; underline 31; end
+      def yellow; underline 33 ; end
+      def reset; escape 0; end
+      def em; underline 39; end
+      def green; color 92 end
+      def gray; bold 30 end
+
+      def width
+        @width = begin
+          w = %x{stty size 2>/dev/null}.chomp.split.last.to_i.nonzero?
+          w ||= %x{tput cols 2>/dev/null}.to_i
+          w < 1 ? 80 : w
+        end
+      end
+
+      def die(*messages)
+        error messages
+        exit 1
+      end
+
+      def tty_puts(*args)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+
+        case (opts[:type] || :notice).to_s.downcase.to_sym
+        when :error
+          # always show errors
+        when :warning
+          return if verbose < -1
+        when :notice
+          return if verbose < 0
+        when :info
+          return if verbose < 1
+        when :debug
+          return if verbose < 2
+        end
+
+        lines = args.map{|m| m.to_s.split($/)}.flatten
+        prompt = opts[:type] ? "#{opts[:type].to_s.upcase}: " : ""
+        if opts[:type]
+          if STDERR.tty?
+            STDERR.write "#{Tty.red}#{prompt}#{Tty.reset}"
+          else
+            STDERR.write "#{prompt}"
+          end
+        end
+        if STDERR.tty? and opts[:color] and Tty.respond_to? opts[:color]
+          STDERR.puts "#{Tty.send(opts[:color])}#{lines.shift}#{Tty.reset}"
+        else
+          STDERR.puts lines.shift
+        end
+        spaces = " " * prompt.size
+        lines.each do |line|
+          STDERR.write spaces
+          if STDERR.tty? and opts[:color] and Tty.respond_to? opts[:color]
+            STDERR.puts "#{Tty.send(opts[:color])}#{line}#{Tty.reset}"
+          else
+            STDERR.puts line
+          end
+        end
+      end
+
+      def error(*messages)
+        tty_puts(*messages << {:type => :error, :color => :red})
+      end
+
+      def warning(*messages)
+        tty_puts(*messages << {:type => :warning, :color => :yellow})
+      end
+
+      def notice(*messages)
+        tty_puts(*messages << {:type => nil})
+      end
+
+      def info(*messages)
+        tty_puts(*messages << {:type => :info, :color => :green})
+      end
+
+      def debug(*messages)
+        tty_puts(*messages << {:type => :debug, :color => :blue})
+      end
+
+      private
+
+      def verbose
+        options[:verbose]
+      end
+
+      def color n
+        escape "0;#{n}"
+      end
+      def bold n
+        escape "1;#{n}"
+      end
+      def underline n
+        escape "4;#{n}"
+      end
+      def escape n
+        "\033[#{n}m" if $stdout.tty?
+      end
+
+    end
+  end
+end
+
+class String
+  def charat(n)
+    result = self.send "[]", n
+    RUBY_VERSION < "1.9" ?  result.chr : result
+  end
+end

data/lib/rpatch/version.rb

@@ -1,3 +1,3 @@
 module Rpatch
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/patch_file_regexp_spec.rb

@@ -5,23 +5,24 @@ require 'spec_helper'
 require 'stringio'
 
 describe Rpatch::Patch do
-    let(:diff) do
-      <<-EOF
+
+  it "regexp patterns test" do
+    diff = <<-EOF
 diff -ru before/readme.txt after/readme.txt
 --- a/readme.txt   2013-11-03 22:17:02.000000000 +0800
 +++ b/readme.txt    2013-11-03 21:10:46.000000000 +0800
 @@ remove two leading lines
 -I have a script to patch text files, it's more like
-RE:-.* Why not (patch|GNU patch)?
+/-.* Why not (patch|GNU patch)?
  When I hack files using GNU patch,
-RE: sometimes fail because .*
+/ sometimes fail because .*
 @@ add copyright
 +/*
 + * Copyright (c) 2013 Jiang Xin
 + */
 +
  When I hack files using GNU patch,
-RE: sometimes fail because .*
+/ sometimes fail because .*
 @@ add notes
 +If patch can ignore blank lines, support regex patterns
 +in patch, it will be nice.
@@ -32,9 +33,7 @@ RE: sometimes fail because .*
 +--
 +jiangxin
     EOF
-  end
 
-  it "patch on file" do
     before = <<-EOF
 I have a script to patch text files, it's more like
 "grep" and "seed -s". Why not GNU patch?
@@ -69,5 +68,4 @@ jiangxin
     patch.apply_to(inputfile, outputfile)
     output.should == after
   end
-
 end

data/spec/patch_file_spec.rb

@@ -171,9 +171,16 @@ jiangxin
     before = ''
 
     diff = <<-EOF
-diff -ru before/readme.txt after/readme.txt
---- a/readme.txt   2013-11-03 22:17:02.000000000 +0800
-+++ b/readme.txt    2013-11-03 21:10:46.000000000 +0800
+Test for patching for new file
+
+ * note 1
+ * note 2
+ * note 3
+
+Index: a/readme.txt
+===================================================================
+--- /dev/null	2013-11-03 22:17:02.000000000 +0800
++++ b/readme.txt	2013-11-03 21:10:46.000000000 +0800
 @@ initial
 +hello
 +world

data/spec/patch_hunk_with_location_spec.rb

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby
+#
+
+require 'spec_helper'
+
+describe Rpatch::PatchHunk do
+
+  it "patch has default location direction" do
+    diff = <<-EOF
++foo
++bar
+    EOF
+
+    before = <<-EOF
+hello
+world
+    EOF
+
+    after = <<-EOF
+foo
+bar
+hello
+world
+    EOF
+
+    hunk = Rpatch::PatchHunk.new('@@ description')
+    diff.split($/).each {|line| hunk.feed_line line.chomp}
+
+    hunk.match_after_patch(before.split($/)).should eq nil
+    hunk.match_before_patch(before.split($/)).should eq [0, 0]
+    result = hunk.patch(before.split($/))
+    (result * "\n" + "\n").should eq after
+  end
+
+  it "patch has head location direction" do
+    diff = <<-EOF
+<
++foo
++bar
+    EOF
+
+    before = <<-EOF
+hello
+world
+    EOF
+
+    after = <<-EOF
+foo
+bar
+hello
+world
+    EOF
+
+    hunk = Rpatch::PatchHunk.new('@@ description')
+    diff.split($/).each {|line| hunk.feed_line line.chomp}
+
+    hunk.match_after_patch(before.split($/)).should eq nil
+    hunk.match_before_patch(before.split($/)).should eq [0, 0]
+    result = hunk.patch(before.split($/))
+    (result * "\n" + "\n").should eq after
+  end
+
+  it "patch has tail location direction" do
+    diff = <<-EOF
+>
++foo
++bar
+    EOF
+
+    before = <<-EOF
+hello
+world
+    EOF
+
+    after = <<-EOF
+hello
+world
+foo
+bar
+    EOF
+
+    hunk = Rpatch::PatchHunk.new('@@ description')
+    diff.split($/).each {|line| hunk.feed_line line.chomp}
+
+    hunk.match_after_patch(before.split($/)).should eq nil
+    hunk.match_before_patch(before.split($/)).should eq [2, 0]
+    result = hunk.patch(before.split($/))
+    (result * "\n" + "\n").should eq after
+  end
+
+  it "patch has head location direction (2)" do
+    diff = <<-EOF
+<
+ hello
++foo
++bar
+    EOF
+
+    before = <<-EOF
+hello
+hello
+    EOF
+
+    after = <<-EOF
+hello
+foo
+bar
+hello
+    EOF
+
+    hunk = Rpatch::PatchHunk.new('@@ description')
+    diff.split($/).each {|line| hunk.feed_line line.chomp}
+
+    hunk.match_after_patch(before.split($/)).should eq nil
+    hunk.match_before_patch(before.split($/)).should eq [0, 1]
+    result = hunk.patch(before.split($/))
+    (result * "\n" + "\n").should eq after
+  end
+
+  it "patch has tail location direction (2)" do
+    diff = <<-EOF
+>
+ hello
++foo
++bar
+    EOF
+
+    before = <<-EOF
+hello
+hello
+    EOF
+
+    after = <<-EOF
+hello
+hello
+foo
+bar
+    EOF
+
+    hunk = Rpatch::PatchHunk.new('@@ description')
+    diff.split($/).each {|line| hunk.feed_line line.chomp}
+
+    hunk.match_after_patch(before.split($/)).should eq nil
+    hunk.match_before_patch(before.split($/)).should eq [1, 1]
+    result = hunk.patch(before.split($/))
+    (result * "\n" + "\n").should eq after
+  end
+
+end