RubyGems - patman - Versions diffs - 0.0.1 - Mend

patman 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

checksums.yaml +7 -0
data/CHANGELOG.rdoc +3 -0
data/LICENSE +20 -0
data/README.rdoc +14 -0
data/doc/Patman/PatmanError.html +138 -0
data/doc/Patman/PatmanFileError.html +142 -0
data/doc/Patman/PatmanSearchError.html +142 -0
data/doc/Patman.html +3313 -0
data/doc/_index.html +134 -0
data/doc/class_list.html +58 -0
data/doc/css/common.css +1 -0
data/doc/css/full_list.css +57 -0
data/doc/css/style.css +339 -0
data/doc/file.CHANGELOG.html +79 -0
data/doc/file.README.html +87 -0
data/doc/file_list.html +63 -0
data/doc/frames.html +26 -0
data/doc/index.html +87 -0
data/doc/js/app.js +219 -0
data/doc/js/full_list.js +181 -0
data/doc/js/jquery.js +4 -0
data/doc/method_list.html +309 -0
data/doc/top-level-namespace.html +112 -0
data/lib/patman.rb +525 -0
data/lib/version.rb +6 -0
data/test/input/test_file1.txt +10 -0
data/test/test_patman.rb +175 -0
metadata +72 -0

data/doc/top-level-namespace.html ADDED Viewed

@@ -0,0 +1,112 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<title>
+  Top Level Namespace
+    &mdash; Documentation by YARD 0.8.7.6
+</title>
+  <link rel="stylesheet" href="css/style.css" type="text/css" charset="utf-8" />
+  <link rel="stylesheet" href="css/common.css" type="text/css" charset="utf-8" />
+<script type="text/javascript" charset="utf-8">
+  hasFrames = window.top.frames.main ? true : false;
+  relpath = '';
+  framesUrl = "frames.html#!top-level-namespace.html";
+</script>
+  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
+  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
+  </head>
+  <body>
+    <div id="header">
+      <div id="menu">
+    <a href="_index.html">Index</a> &raquo;
+    <span class="title">Top Level Namespace</span>
+  <div class="noframes"><span class="title">(</span><a href="." target="_top">no frames</a><span class="title">)</span></div>
+</div>
+      <div id="search">
+    <a class="full_list_link" id="class_list_link"
+        href="class_list.html">
+      Class List
+    </a>
+    <a class="full_list_link" id="method_list_link"
+        href="method_list.html">
+      Method List
+    </a>
+    <a class="full_list_link" id="file_list_link"
+        href="file_list.html">
+      File List
+    </a>
+</div>
+      <div class="clear"></div>
+    </div>
+    <iframe id="search_frame"></iframe>
+    <div id="content"><h1>Top Level Namespace
+</h1>
+<dl class="box">
+</dl>
+<div class="clear"></div>
+<h2>Defined Under Namespace</h2>
+<p class="children">
+      <strong class="classes">Classes:</strong> <span class='object_link'><a href="Patman.html" title="Patman (class)">Patman</a></span>
+</p>
+</div>
+    <div id="footer">
+  Generated on Sat Dec 16 23:10:27 2017 by
+  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
+  0.8.7.6 (ruby-2.3.3).
+</div>
+  </body>
+</html>

data/lib/patman.rb ADDED Viewed

@@ -0,0 +1,525 @@
+# = Patman
+#
+# == Introduction
+#
+# {Patman} (Patch Manipulator) is a library for text file patching. It
+# can also be used to extract information from files.
+#
+# Typical {Patman} script opens a file for editing. The file is read
+# into the library. User finds the place for editing either with
+# Regexp searches or with direct line numbers. The file content is
+# edited by adding, removing, or replacing lines. When all edits are
+# done, the updated file content is written to disk.
+#
+# All editing commands refer to the "current position". Current
+# position is returned by "line" method. Positions refer to lines that
+# have content. If user wants append to the end of file, then user
+# should jump to last line, with "lastline" method, and then issue
+# "append". It is also possible to jump to arbitrary lines, {Patman}
+# does not prevent this. The line positions are just used as an index
+# to Array. For example negative line number will refer from end
+# towards beginning in content.
+#
+# Position can be explicitly changed with "step", "firstline", or
+# "lastline" methods (commands). "find" changes position if the
+# pattern is found in selected direction. "append" changes position
+# implicitly with every call.
+#
+# Current line content is returned by "get" and it can be set with
+# "set" method. Current line content can be replaced with "sub".
+#
+# {Patman} includes many query commands: line, lines, [], get, find,
+# get_range, get_for. They all return the queried item. All other
+# methods return {Patman} object itself, hence many {Patman} methods
+# can be "chained".
+#
+# Block commands perform commands over a range of lines. Block
+# commands are: do_all, do_range, and do_for. These retain the
+# original position, but the final position is stored (actually one
+# after) and it can be activated by calling "blockline" method.
+#
+# Block commands take a pre-defined number of lines to process. Note
+# that, if user deletes lines in block action, the outcome is most
+# likely not what the user expects.
+#
+# Mark feature can be used if user wants to return back to original
+# position after changes. Mark features includes a "default mark" and
+# "named marks".
+#
+# For debugging purposes it is good to see line content. "view" and
+# "view_ln" can be used to view line content either without or with
+# line numbers respectively.
+#
+# No changes are stored to disk unless "write" is called. If user want
+# to create a "backup" of the edited file, the "copy" method can be
+# used before any editing commands have been applied.
+#
+# == Example session
+#
+#  # Open file for reading.
+#  r = Patman.read( "report.txt" )
+#
+#  # Backup file and find next line with "cpp", method chaining.
+#  r.copy( "report.txt.org" ).find( /cpp/ )
+#
+#  # Collect some lines.
+#  data = 4.times.collect do |i|
+#      r.ref( r.line + i )
+#  end
+#
+#  # Duplicate the lines collected.
+#  r.insert( data )
+#
+#  # Move to line 9.
+#  r.line 9
+#
+#  # Append " Hello" to the end of current line.
+#  r.set( r.get + " Hello" )
+#
+#  # Save changes.
+#  r.write
+#
+class Patman
+    # {Patman} exception base class.
+    class PatmanError < RuntimeError; end
+    # {Patman} searching error (for find functions).
+    class PatmanSearchError < PatmanError; end
+    # {Patman} file error.
+    class PatmanFileError < PatmanError; end
+    attr_accessor :marks
+    # Create editing session with file.
+    def Patman.read( file )
+        p = Patman.new( file )
+        p.read
+        p
+    end
+    # Create {Patman} object.
+    def initialize( file )
+        @file = file
+        @lines = []
+        @line = 0
+        @mark = nil
+        @marks = {}
+        @blockline = nil
+        @edited = false
+    end
+    # Read file in.
+    def read
+        if File.exist?( @file )
+            @lines = read_clean( @file )
+        else
+            raise PatmanFileError
+        end
+    end
+    # Write {Patman} content to disk.
+    def write( file = @file )
+        return unless @edited
+        fh = File.open( file, 'w' )
+        @lines.each do |line|
+            if line
+                fh.puts line
+            else
+                fh.puts ""
+            end
+        end
+        fh.close
+        @edited = false
+        self
+    end
+    # Copy {Patman} content to file.
+    def copy( file )
+        write( file )
+        self
+    end
+    # Return or set line.
+    def line( arg = nil )
+        if arg
+            @line = (arg-1)
+            self
+        else
+            @line+1
+        end
+    end
+    # Step forward or backward current position.
+    def step( dir = 1 )
+        @line = @line + dir
+        self
+    end
+    # Jump to first line.
+    def firstline
+        @line = 0
+        self
+    end
+    # Jump to last line.
+    def lastline
+        @line = @lines.length-1
+        self
+    end
+    # Jump to line after block.
+    def blockline
+        if @blockline
+            @line = @blockline
+        end
+        self
+    end
+    # Get or set all {Patman} content.
+    def lines( arg = nil )
+        if arg
+            @edited = true
+            @lines = arg
+        else
+            @lines
+        end
+    end
+    # Reference {Patman} content by range.
+    def []( range )
+        @lines[ range ]
+    end
+    # Get current line or lines by count.
+    def get( count = 1 )
+        if count == 1
+            @lines[ @line ]
+        else
+            @lines[ @line .. (@line+count-1) ]
+        end
+    end
+    # Get current line or any line.
+    def ref( line = nil )
+        if line
+            @lines[ line-1 ]
+        else
+            @lines[ @line ]
+        end
+    end
+    # Set current line.
+    def set( text )
+        @edited = true
+        @lines[ @line ] = text
+        self
+    end
+    # Substitution in current line.
+    def sub( from, to )
+        @edited = true
+        @lines[ @line ] = @lines[ @line ].sub( from, to )
+        self
+    end
+    # Update current line content (i.e. get&set) with the return value
+    # of the given block. Hence last stmt should include the new line
+    # content.
+    #
+    # @example
+    #   r.update do |c|
+    #      c.sub!( /foo/, 'bar' )
+    #      c
+    #   end
+    #
+    def update( &blk )
+        @edited = true
+        set( yield( get ) )
+        self
+    end
+    # Insert line or lines (Array) to current position.
+    def insert( text = nil )
+        @edited = true
+        if text.kind_of? Array
+            line = @line
+            step -1
+            text.each do |txt|
+                append( txt )
+            end
+            @line = line
+        else
+            @lines.insert( @line, text )
+        end
+        self
+    end
+    # Append after current position.
+    def append( text = nil )
+        @edited = true
+        if text.kind_of? Array
+            text.each do |txt|
+                append( txt )
+            end
+        else
+            step
+            @lines.insert( @line, text )
+        end
+        self
+    end
+    # Delete current line.
+    def delete( count = 1 )
+        @edited = true
+        count.times do |i|
+            @lines.delete_at( @line )
+        end
+        self
+    end
+    # Insert file to current position.
+    def insertfile( file )
+        @edited = true
+        step -1
+        read_clean( file ).each do |line|
+            append line
+        end
+        self
+    end
+    # Clear {Patman} content and reset current line.
+    def clear
+        @edited = true
+        @lines = []
+        @line = 0
+        self
+    end
+    # Find Regexp or literal string forwards or backwards. Return true
+    # on success.
+    def find( re_or_str, forward = true )
+        begin
+            @line = search_with_exception( re_or_str, forward )
+            true
+        rescue
+            false
+        end
+    end
+    # Search Regexp or literal string forwards or backwards. Fail with
+    # expection (PatmanSearchError) if not found.
+    def search( re_or_str, forward = true )
+        @line = search_with_exception( re_or_str, forward )
+        self
+    end
+    # Return line count of {Patman} content.
+    def length
+        @lines.length
+    end
+    # Return {Patman} file name.
+    def filename
+        @file
+    end
+    # Mark content modified (explicit).
+    def edit
+        @edited = true
+    end
+    # Return true if content is modified.
+    def edited?
+        @edited
+    end
+    # Execute block, retain current position, and return block value.
+    def excursion( &blk )
+        line = @line
+        ret = instance_eval( &blk )
+        @line = line
+        ret
+    end
+    # Mark (store) current position to default or to named mark.
+    def mark( tag = nil )
+        if tag
+            @marks[ tag ] = @line+1
+            self
+        else
+            @mark = @line+1
+            self
+        end
+    end
+    # Unmark (restore) current position from default or from named
+    # mark.
+    def unmark( tag = nil )
+        if tag && @marks[ tag ]
+            @line = @marks[ tag ]-1
+            self
+        elsif @mark
+            @line = @mark-1
+            @mark = nil
+            self
+        else
+            self
+        end
+    end
+    # Execute given block for all lines, i.e. all positions. Block
+    # parameter is {Patman}.
+    def do_all( &blk )
+        do_for( 1, length-1, &blk )
+    end
+    # Execute given block between start and stop positions, and update
+    # position.
+    def do_range( start, stop, &blk )
+        do_for( start, (stop-start+1), &blk )
+    end
+    # Execute given block starting from start by count, and update
+    # position.
+    def do_for( start, count, &blk )
+        line = @line
+        @line = start-1
+        count.times do
+            yield self
+            @line += 1
+        end
+        @blockline = @line
+        @line = line
+        self
+    end
+    # Get lines between start and stop positions inclusive.
+    def get_range( start, stop )
+        @lines[ (start-1) .. (stop-1) ]
+    end
+    # Get lines starting from start by count.
+    def get_for( start, count )
+        @lines[ (start-1) ... (start-1+count) ]
+    end
+    # View line content around current position (by count).
+    def peek( count = 0 )
+        view_range( @line-count, @line+count+1 )
+        nil
+    end
+    # View line content with line numbers around current position (by
+    # count).
+    def peek_ln( count = 0 )
+        view_range( @line-count, @line+count+1, true )
+        nil
+    end
+    # View line content.
+    #
+    # * no args:  view all
+    # * one arg:  view from current onwards by count
+    # * two args: view given range
+    def view( arg1 = nil, arg2 = nil )
+        if !arg1 && !arg2
+            view_range( 0, length )
+        elsif arg1 && !arg2
+            view_range( @line, @line+arg1 )
+        elsif arg1 && arg2
+            view_range( arg1-1, arg1-1+arg2 )
+        end
+        nil
+    end
+    # View line content with line numbers.
+    #
+    # * no args:  view all
+    # * one arg:  view from current onwards by count
+    # * two args: view given range
+    def view_ln( arg1 = nil, arg2 = nil )
+        if !arg1 && !arg2
+            view_range( 0, length, true )
+        elsif arg1 && !arg2
+            view_range( @line, @line+arg1, true )
+        elsif arg1 && arg2
+            view_range( arg1-1, arg1-1+arg2, true )
+        end
+        nil
+    end
+    private
+    def read_clean( file ) # :nodoc:
+        File.readlines( file ).map{|line| line.chomp}.map{|line| line.empty? ? nil : line}
+    end
+    def view_range( first, last, ln = false ) # :nodoc:
+        if ln
+            ln = first+1
+            @lines[first...last].each do |line|
+                puts format( "%-4s #{line}", "#{ln.to_s}:" )
+                ln += 1
+            end
+        else
+            @lines[first...last].each do |line|
+                puts line
+            end
+        end
+    end
+    def search_with_exception( re_or_str, forward ) # :nodoc:
+        line = @line
+        len = @lines.length
+        if re_or_str.kind_of? String
+            if forward
+                while line < len
+                    if @lines[line] && @lines[line].include?( re_or_str )
+                        return line
+                    end
+                    line += 1
+                end
+            else
+                while line >= 0
+                    if @lines[line] && @lines[line].include?( re_or_str )
+                        return line
+                    end
+                    line -= 1
+                end
+            end
+        else
+            if forward
+                while line < len
+                    if @lines[line] && re_or_str.match( @lines[line] )
+                        return line
+                    end
+                    line += 1
+                end
+            else
+                while line >= 0
+                    if @lines[line] && re_or_str.match( @lines[line] )
+                        return line
+                    end
+                    line -= 1
+                end
+            end
+        end
+        raise PatmanSearchError, "#{@file}: Could not find \"#{re_or_str}\"..."
+    end
+end
+require_relative 'version'

data/lib/version.rb ADDED Viewed

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

data/test/input/test_file1.txt ADDED Viewed

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