rpatch 0.0.1

data/lib/rpatch/runner.rb

@@ -0,0 +1,44 @@
+require 'optparse'
+require 'rpatch/patch'
+require 'rpatch/version'
+
+module Rpatch
+  class Runner
+      class <<self
+        def runner
+          path = "."
+          patches = []
+          patch_level = 1
+
+          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
+              puts "Version #{Rpatch::VERSION}"
+              exit 0
+            end
+            opts.on_tail("-h", "--help", "Show this message") do
+              puts opts
+              exit 0
+            end
+          end.parse!
+
+          case ARGV.size
+          when 0
+            patches << STDIN
+          when 1
+            path = ARGV.shift
+            patches << STDIN
+          else
+            path = ARGV.shift
+            until ARGV.empty? do
+              patches << ARGV.shift
+            end
+          end
+
+          result = Patch::apply(path, patches, patch_level)
+          exit 1 unless result
+      end
+    end
+  end
+end

data/lib/rpatch/version.rb

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

data/spec/patch_entry_spec.rb

@@ -0,0 +1,234 @@
+#!/usr/bin/env ruby
+#
+
+require 'spec_helper'
+
+describe Rpatch::PatchEntry do
+
+  it "filename and patch level (1)" do
+    old = "a/foo/bar/src/file.c"
+    new = "b/foo/bar/src/file.c"
+    entry = Rpatch::PatchEntry.new(old, new, 0)
+    entry.oldfile.should be == "a/foo/bar/src/file.c"
+    entry.newfile.should be == "b/foo/bar/src/file.c"
+    entry = Rpatch::PatchEntry.new(old, new, 1)
+    entry.oldfile.should be == "foo/bar/src/file.c"
+    entry.newfile.should be == "foo/bar/src/file.c"
+    entry = Rpatch::PatchEntry.new(old, new, 3)
+    entry.oldfile.should be == "src/file.c"
+    entry.newfile.should be == "src/file.c"
+  end
+
+  it "filename and patch level (2)" do
+    old = "/dev/null"
+    new = "b/foo/bar/src/file.c"
+    entry = Rpatch::PatchEntry.new(old, new, 1)
+    entry.oldfile.should eq "/dev/null"
+    entry.newfile.should eq "foo/bar/src/file.c"
+    old = "a/foo/bar/src/file.c"
+    new = "/dev/null"
+    entry = Rpatch::PatchEntry.new(old, new, 1)
+    entry.oldfile.should eq "foo/bar/src/file.c"
+    entry.newfile.should eq "/dev/null"
+  end
+
+  it "patch on file (1)" do
+    before = <<-EOF
+When I hack files using GNU patch,
+sometimes fail because of the change of upstream files.
+So comes rpatch.
+
+Happy hacking.
+    EOF
+
+    diff = <<-EOF
+@@ add copyright
++/*
++ * Copyright (c) 2013 Jiang Xin
++ */
++
+ When I hack files using GNU patch,
+ sometimes fail because of the change of upstream files.
+@@ 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
+    EOF
+
+    after = <<-EOF
+/*
+ * 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
+    EOF
+
+    old = "a/foo/bar/src/file.c"
+    new = "b/foo/bar/src/file.c"
+    entry = Rpatch::PatchEntry.new(old, new, 1)
+    diff.lines.each do |line|
+      entry.feed_line line
+    end
+    entry.patch_on_message(before).should == after
+  end
+
+  it "patch on file (2)" do
+    before = <<-EOF
+Subject: about rpatch
+
+When I hack files using GNU patch,
+sometimes fail because of the change of upstream files.
+So comes rpatch.
+
+Happy hacking.
+    EOF
+
+    diff = <<-EOF
+@@ add copyright
++/*
++ * Copyright (c) 2013 Jiang Xin
++ */
++
+ When I hack files using GNU patch,
+ sometimes fail because of the change of upstream files.
+@@ 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
+    EOF
+
+    after = <<-EOF
+Subject: about rpatch
+
+/*
+ * 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
+    EOF
+
+    old = "a/foo/bar/src/file.c"
+    new = "b/foo/bar/src/file.c"
+    entry = Rpatch::PatchEntry.new(old, new, 1)
+    diff.lines.each do |line|
+      entry.feed_line line
+    end
+    entry.patch_on_message(before).should == after
+  end
+
+  it "patch on file (3)" do
+    before = ''
+
+    diff = <<-EOF
+@@ initial
++/*
++ * 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
+    EOF
+
+    after = <<-EOF
+/*
+ * 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
+    EOF
+
+    old = "a/foo/bar/src/file.c"
+    new = "b/foo/bar/src/file.c"
+    entry = Rpatch::PatchEntry.new(old, new, 1)
+    diff.lines.each do |line|
+      entry.feed_line line
+    end
+    entry.patch_on_message(before).should == after
+  end
+
+  it "patch on file (4)" do
+    before = <<-EOF
+/*
+ * 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
+    EOF
+
+    diff = <<-EOF
+@@ remove all
+-/*
+- * 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
+    EOF
+
+    after = ''
+
+    old = "a/foo/bar/src/file.c"
+    new = "b/foo/bar/src/file.c"
+    entry = Rpatch::PatchEntry.new(old, new, 1)
+    diff.lines.each do |line|
+      entry.feed_line line
+    end
+    entry.patch_on_message(before).should == after
+  end
+end

data/spec/patch_file_regexp_spec.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+#
+
+require 'spec_helper'
+require 'stringio'
+
+describe Rpatch::Patch do
+    let(:diff) do
+      <<-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)?
+ When I hack files using GNU patch,
+RE: sometimes fail because .*
+@@ add copyright
++/*
++ * Copyright (c) 2013 Jiang Xin
++ */
++
+ When I hack files using GNU patch,
+RE: sometimes fail because .*
+@@ 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
+    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?
+When I hack files using GNU patch,
+sometimes fail because of the change of upstream files.
+So comes rpatch.
+
+Happy hacking.
+    EOF
+
+    after = <<-EOF
+/*
+ * 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
+    EOF
+
+    inputfile = StringIO.new(before, "r")
+    patchfile = StringIO.new(diff, "r")
+    output = ''
+    outputfile = StringIO.new(output, "w")
+    patch = Rpatch::Patch.new(patchfile, 1)
+    patch.apply_to(inputfile, outputfile)
+    output.should == after
+  end
+
+end

data/spec/patch_file_spec.rb

@@ -0,0 +1,267 @@
+#!/usr/bin/env ruby
+#
+
+require 'spec_helper'
+require 'stringio'
+
+describe Rpatch::Patch do
+    let(:diff) do
+      <<-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
+@@ add copyright
++/*
++ * Copyright (c) 2013 Jiang Xin
++ */
++
+ When I hack files using GNU patch,
+ sometimes fail because of the change of upstream files.
+@@ 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
+    EOF
+  end
+
+  it "patch on file (1): normal patch" do
+    before = <<-EOF
+When I hack files using GNU patch,
+sometimes fail because of the change of upstream files.
+So comes rpatch.
+
+Happy hacking.
+    EOF
+
+    after = <<-EOF
+/*
+ * 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
+    EOF
+
+    inputfile = StringIO.new(before, "r")
+    patchfile = StringIO.new(diff, "r")
+    output = ''
+    outputfile = StringIO.new(output, "w")
+    patch = Rpatch::Patch.new(patchfile, 1)
+    patch.apply_to(inputfile, outputfile)
+    output.should == after
+  end
+
+  it "patch on file (2): partial patched" do
+    before = <<-EOF
+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.
+    EOF
+
+    after = <<-EOF
+/*
+ * 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
+    EOF
+
+    inputfile = StringIO.new(before, "r")
+    patchfile = StringIO.new(diff, "r")
+    output = ''
+    outputfile = StringIO.new(output, "w")
+    patch = Rpatch::Patch.new(patchfile, 1)
+    patch.apply_to(inputfile, outputfile)
+    output.should == after
+  end
+
+  it "patch on file (3): already patched" do
+    after = <<-EOF
+/*
+ * 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
+    EOF
+
+    before = after.dup
+
+    inputfile = StringIO.new(before, "r")
+    patchfile = StringIO.new(diff, "r")
+    output = ''
+    outputfile = StringIO.new(output, "w")
+    patch = Rpatch::Patch.new(patchfile, 1)
+    patch.apply_to(inputfile, outputfile)
+    output.should == after
+  end
+
+  it "patch on file (4): blank lines and white spaces" do
+    before = <<-EOF
+    When I hack files using GNU             patch,
+
+    sometimes fail because of the change of upstream files.
+
+So comes rpatch.
+
+Happy hacking.
+
+    EOF
+
+    after = <<-EOF
+/*
+ * 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
+
+    EOF
+
+    inputfile = StringIO.new(before, "r")
+    patchfile = StringIO.new(diff, "r")
+    output = ''
+    outputfile = StringIO.new(output, "w")
+    patch = Rpatch::Patch.new(patchfile, 1)
+    patch.apply_to(inputfile, outputfile)
+    output.should == after
+  end
+
+  it "patch on file (5): patch on blank files" do
+    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
+@@ initial
++hello
++world
+    EOF
+
+    after = <<-EOF
+hello
+world
+    EOF
+
+
+    inputfile = StringIO.new(before, "r")
+    patchfile = StringIO.new(diff, "r")
+    output = ''
+    outputfile = StringIO.new(output, "w")
+    patch = Rpatch::Patch.new(patchfile, 1)
+    patch.apply_to(inputfile, outputfile)
+    output.should == after
+  end
+
+  it "bad patch header, so nothing patched (1)" do
+    before = ''
+
+    diff = <<-EOF
+diff -ru before/readme.txt after/readme.txt
+@@ initial
++hello
++world
+    EOF
+
+    after = <<-EOF
+    EOF
+
+
+    inputfile = StringIO.new(before, "r")
+    patchfile = StringIO.new(diff, "r")
+    output = ''
+    outputfile = StringIO.new(output, "w")
+    patch = Rpatch::Patch.new(patchfile, 1)
+    patch.apply_to(inputfile, outputfile)
+    output.should == after
+  end
+
+  it "patch failed (1): patch format error" 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
+@@ initial
+ lines of a patch must start with
+ space
++plus
+-minus
+RE: regexp match
+RE:-regexp match
+ others are bad.
+BAD PATCH SYNTAX.
+    EOF
+
+    patchfile = StringIO.new(diff, "r")
+    expect {
+      Rpatch::Patch.new(patchfile, 1)
+    }.to raise_exception Rpatch::PatchFormatError, /BAD PATCH SYNTAX./
+
+  end
+
+  it "patch failed (2): apply_to return false" do
+    before = <<-EOF
+bad
+    EOF
+
+    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
+@@ initial
+ hello
++world
+    EOF
+
+    inputfile = StringIO.new(before, "r")
+    patchfile = StringIO.new(diff, "r")
+    output = ''
+    outputfile = StringIO.new(output, "w")
+
+    patch = Rpatch::Patch.new(patchfile, 1)
+    patch.apply_to(inputfile, outputfile).should be == false
+    output.should be == before
+  end
+
+end