rupat 0.0.1

data/lib/version.rb

@@ -0,0 +1,6 @@
+class Rupat
+    VERSION = "0.0.1"
+    def Rupat.version
+        Rupat::VERSION
+    end
+end

data/test/input/diff_test1.txt

@@ -0,0 +1,10 @@
+foo
+bar dii
+duu
+dapadaa
+sii
+duu
+jaa guu
+dapadii
+per
+saukko

data/test/input/diff_test2.txt

@@ -0,0 +1,13 @@
+foo
+duu
+sii
+dapadaa
+duu
+jaa guu
+sii
+fii
+fuu
+daa
+dapadii
+jaska
+aukko

data/test/input/test_file1.txt

@@ -0,0 +1,10 @@
+Line 0
+Line 1
+Line 2
+Line 3
+Line 4
+Line 5
+Line 6
+Line 7
+Line 8
+Line 9

data/test/test_rupat.rb

@@ -0,0 +1,213 @@
+require 'test/unit'
+require 'rupat'
+require 'fileutils'
+
+
+class RupatTest < Test::Unit::TestCase
+
+    # Test all editing features.
+    def test_editing
+
+        test_file = 'test/input/test_file1.txt'
+
+        # Open file.
+        r = Rupat.update( test_file ).useAlias
+
+        # Should be at file beginning.
+        assert_equal( r.l, 0 )
+
+        # ------------------------------------------------------------
+        # Test diff jumping commands and their return values:
+        r.n;        assert_equal( r.l, 1 )
+        r.p;        assert_equal( r.l, 0 )
+        true;       assert_equal( r.n.l, 1 )
+        true;       assert_equal( r.p.l, 0 )
+        r.j( 5 );   assert_equal( r.l, 5 )
+        true;       assert_equal( r.j.l, 0 )
+        r.j1( 11 ); assert_equal( r.l, 10 )
+        r.jl;       assert_equal( r.l, 9 )
+        r.jl;       assert_equal( r.l, 9 )
+        r.je;       assert_equal( r.l, 10 )
+
+
+        # ------------------------------------------------------------
+        # Test invalid lines:
+        err = false
+        begin
+            r.j( 11 )
+        rescue RupatMod::RupatInvalidLineError
+            err = true
+        end
+        assert_equal( err, true )
+        assert_equal( r.l, 10 )
+
+
+        # ------------------------------------------------------------
+        # Test excursion:
+        l = r.excursion do
+            r.j( 2 ).l
+        end
+        assert_equal( r.l, 10 )
+        assert_equal( l, 2 )
+
+
+        # ------------------------------------------------------------
+        # Test searching:
+        assert_equal( r.j(0).f( /Line 0/ ).l, 0 )
+        assert_equal( r.f( /Line 1/ ).l, 1 )
+        assert_equal( r.f( /ne 8/ ).l, 8 )
+        l = r.excursion do
+            r.f( /Line 9/ ).l
+        end
+        assert_equal( r.l, 8 )
+        assert_equal( l, 9 )
+
+        err = false
+        begin
+            r.findForward( /Line 1/ )
+        rescue RupatMod::RupatSearchError
+            err = true
+        end
+        assert_equal( err, true )
+
+        err = false
+        begin
+            r.findBackward( /Line 1/ )
+        rescue RupatMod::RupatSearchError
+            err = true
+        end
+        assert_equal( err, false )
+        assert_equal( r.l, 1 )
+
+        err = false
+        begin
+            r.findBackward( /Line 9/ )
+        rescue RupatMod::RupatSearchError
+            err = true
+        end
+        assert_equal( err, true )
+        assert_equal( r.l, 1 )
+
+        b = r.findBlock( /Line 7/, /Line 8/ )
+        assert_equal( b, [7,8] )
+        assert_equal( r[ Range.new( *b ) ], ["Line 7", "Line 8"] )
+
+
+        # ------------------------------------------------------------
+        # Test content queries:
+        assert_equal( r.j.g, "Line 0" )
+        assert_equal( r.g( 9 ), "Line 9" )
+        assert_equal( r.g( 10 ), nil )
+        assert_equal( r.l, 0 )
+        assert_equal( r.gm( 0, 1 ), ["Line 0", "Line 1"] )
+        assert_equal( r.gm( 1 ), ["Line 0", "Line 1"] )
+        assert_equal( r.cp( 1 ).copybuf, ["Line 0", "Line 1"] )
+
+
+        # ------------------------------------------------------------
+        # Test content manipulation:
+        l = r.g
+        r.s( "foobar" )
+        assert_equal( r.g, "foobar" )
+        r.s( l )
+        assert_equal( r.length, 10 )
+
+
+        r.replace do |c|
+            c.gsub( /ne/, 'en' )
+        end
+        assert_equal( r.g, "Lien 0" )
+        r.s( l )
+
+        r.i( 'Line -1' )
+        assert_equal( r.length, 11 )
+        assert_equal( r.g, "Line -1" )
+        r.d
+        assert_equal( r.length, 10 )
+        assert_equal( r.g, "Line 0" )
+
+        c = ["foo", "bar" ]
+        r.im( c )
+        assert_equal( r.length, 12 )
+        assert_equal( r.gm( 1 ), c )
+        assert_equal( r.cp(1).pt.gm(1), c )
+        assert_equal( r.length, 14 )
+        assert_equal( r.dm(4).length, 10 )
+
+        assert_equal( r.jl.a( 'foo' ).g, 'foo' )
+        assert_equal( r.a( 'bar' ).g, 'bar' )
+        assert_equal( r.length, 12 )
+        assert_equal( r.gm(10,11), c )
+        assert_equal( r.l, r.length-1 )
+        assert_equal( r.am( "foo\nbar" ).length, 14 )
+        assert_equal( r.gm(-1), c )
+        assert_equal( r.ct( 10, 13 ).copybuf, c+c )
+
+        len = r.length
+        assert_equal( r.j.ifi( test_file ).length, 2*len )
+        assert_equal( r.je.ifi( test_file ).length, 3*len )
+
+        r.replaceAll( /Line/, 'foobar' )
+        assert_equal( r.gm(5,6), [ 'foobar 5', 'foobar 6' ] )
+        r.replaceWithin( /foobar/, 'Line', 10, 19 )
+
+
+        # ------------------------------------------------------------
+        # Test file saving:
+
+        # Add lines to file and check for updates.
+        r = Rupat.update( test_file ).useAlias
+        ref = r.lines.dup
+        r.ifi( test_file )
+        r.save
+        r = Rupat.open( test_file ).useAlias
+        assert_equal( r.lines, ref+ref  )
+
+        # File save with nil.
+        r = Rupat.open( test_file ).useAlias
+        r.ct( 10, r.last )
+        err = false
+        begin
+            r.save
+        rescue RupatMod::RupatTypeError
+            err = true
+        end
+        assert_equal( err, true )
+
+        # Save the file (with original content).
+        r.save( test_file )
+
+        # Edit and save to backup file.
+        r = Rupat.edit( test_file ).useAlias
+        bu = r.close
+        assert_equal( File.exist?( bu ), true )
+        FileUtils.rm_f( bu )
+
+        # Create a new file with ".create".
+        bu = test_file+'.dup'
+        r = Rupat.create( test_file, bu ).useAlias
+        r.close
+        assert_equal( File.exist?( bu ), true )
+        FileUtils.rm_f( bu )
+
+        # Create file from lines.
+        bu = test_file+'.dup'
+        content = Rupat.open( test_file ).lines
+        r = Rupat.lines( content )
+        r.save( bu )
+        assert_equal( File.exist?( bu ), true )
+        assert_equal( r.length, 10 )
+        FileUtils.rm_f( bu )
+
+        # File-handle based concatenation.
+        fh = File.open( bu, 'w' )
+        r = Rupat.open( test_file )
+        r.save( fh )
+        r.save( fh )
+        fh.close
+        assert_equal( Rupat.open( bu ).length, 20 )
+        FileUtils.rm_f( bu )
+
+    end
+
+end

data/test/test_rupat_bin.rb

@@ -0,0 +1,27 @@
+require 'test/unit'
+require 'rupat'
+require 'fileutils'
+
+class RupatBinTest < Test::Unit::TestCase
+
+
+    # Test patch generation.
+    def test_patch
+
+        test_dir = 'test/input'
+        diff1 = "#{test_dir}/diff_test1.txt"
+        diff2 = "#{test_dir}/diff_test2.txt"
+        patcher = 'test/patcher.rb'
+        patched_diff = "#{test_dir}/patched.txt"
+
+        system( "bin/rupat -p #{diff1} #{diff2} -o #{patcher}" )
+        system( "#{patcher} > #{patched_diff}" )
+
+        assert_equal( system( "diff #{patched_diff} #{diff2} " ), true )
+
+        FileUtils.rm_f( patcher )
+        FileUtils.rm_f( patched_diff )
+
+    end
+
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: rupat
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tero Isannainen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: como
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+description: Rupat is a Ruby Patching utility. It can be used to patch files or for
+  extracting information from files. Rupat comes with a library for general use and
+  simple executable for patching files.
+email: tero.isannainen@gmail.com
+executables:
+- rupat
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- CHANGELOG.rdoc
+- LICENSE
+- README.rdoc
+- bin/rupat
+- doc/Rupat.html
+- doc/RupatAlias.html
+- doc/RupatMod.html
+- doc/RupatMod/RupatError.html
+- doc/RupatMod/RupatInvalidLineError.html
+- doc/RupatMod/RupatPasteError.html
+- doc/RupatMod/RupatSearchError.html
+- doc/RupatMod/RupatTypeError.html
+- doc/_index.html
+- doc/class_list.html
+- doc/css/common.css
+- doc/css/full_list.css
+- doc/css/style.css
+- doc/file.CHANGELOG.html
+- doc/file.README.html
+- doc/file_list.html
+- doc/frames.html
+- doc/index.html
+- doc/js/app.js
+- doc/js/full_list.js
+- doc/js/jquery.js
+- doc/method_list.html
+- doc/top-level-namespace.html
+- lib/rupat.rb
+- lib/version.rb
+- test/input/diff_test1.txt
+- test/input/diff_test2.txt
+- test/input/test_file1.txt
+- test/test_rupat.rb
+- test/test_rupat_bin.rb
+homepage: 
+licenses:
+- Ruby
+metadata: {}
+post_install_message: Check README...
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Rupat is used to patch text files.
+test_files: []
+has_rdoc: