cursor 0.6 → 0.8

data/cursor/lined.rb

@@ -0,0 +1,49 @@
+# $Id: lined.rb,v 1.5 2005/07/01 22:06:45 eric_mahurin Exp $
+
+require 'cursor'
+require 'cursor/usedeleteinsert'
+
+class Cursor
+# This class tracks the current line and column.  Both line and column
+# start at 0.  When a newline is found, the line is incremented and the
+# column is reset.  With other characters, the column is incremented.
+# The line and column numbers are only tracked when reading forward, but
+# using #position (and friends) will hold the line and column.
+class Lined < Cursor
+    include UseDeleteInsert
+    # Create a new Cursor from another that tracks line and column.
+    # +newline+ can be any valid argument for String#index.  For example,
+    # +newline+=+/\n|\r(?!\n)/+ could be used for unix, mac, dos/cpm style
+    # newlines.
+    def initialize(cursor,newline=?\n)
+        @cursor = cursor
+        @newline = newline
+        prop(:line,0)
+        prop(:column,0)
+    end
+    # :stopdoc:
+    protected
+    def _delete1after?
+        @cursor.delete1after?
+    end
+    def _delete1before?
+        @cursor.delete1before?
+    end
+    def _insert1before(v)
+        if @newline==v
+            prop(:line,prop(:line)+1)
+            prop(:column,0)
+        else
+            prop(:column,prop(:column)+1)
+        end
+        @cursor.insert1before(v)
+    end
+    def _insert1after(v)
+        @cursor.insert1after(v)
+    end
+    public
+    # :startdoc:
+end
+end
+
+

data/cursor/linked.rb

@@ -0,0 +1,62 @@
+# $Id: linked.rb,v 1.3 2005/07/21 15:15:38 eric_mahurin Exp $
+
+require 'cursor'
+require 'cursor/usedeleteinsert'
+
+class Cursor
+# Double-linked list
+class Linked < Cursor
+    include UseDeleteInsert
+    def initialize(before=[],after=before.class.new)
+        @next = nil
+        @prev = nil  
+        @data_class = before.class
+        write(before,false,nil)
+        write(after,true,nil)
+    end
+    # :stopdoc:
+    def new_data
+        @data_class.new
+    end
+    protected
+    def _delete1after?
+        if @next
+            begin
+                @next[1]
+            ensure
+                @next = @next[2]
+                @next[0] = @prev if @next
+                @prev[2] = @next if @prev
+            end
+        end
+    end
+    def _delete1before?
+        if @prev
+            begin
+                @prev[1]
+            ensure
+                @prev = @prev[0]
+                @next[0] = @prev if @next
+                @prev[2] = @next if @prev
+            end
+        end
+    end
+    def _insert1before(v)
+        node = [@prev,v,@next]
+        @prev[2] = node if @prev
+        @next[0] = node if @next
+        @prev = node
+        true
+    end
+    def _insert1after(v)
+        node = [@prev,v,@next]
+        @prev[2] = node if @prev
+        @next[0] = node if @next
+        @next = node
+        true
+    end
+    # :startdoc:
+end
+end
+
+

data/cursor/position.rb

@@ -0,0 +1,145 @@
+# $Id: position.rb,v 1.18 2005/07/18 14:46:28 eric_mahurin Exp $
+
+require 'cursor'
+
+class Cursor
+# Objects in this class are mainly used to simply mark/remember the location
+# of a parent cursor.  But, this class also has the fully functionality of the
+# parent.  When this child wants to do an operation, it uses the parent to
+# do it and returns the parent to where it was.
+class Position < Cursor # :nodoc:
+    def initialize(parent,reverse=false)
+        @parent = parent
+        @anchor_after = reverse
+        @pos = @parent.__send__(:pos)
+        prop(nil,@parent.prop)
+    end
+    def new_data
+        @parent.new_data
+    end
+    public
+    localMethods = %w(
+        prop pos pos= to_s to_i position position= position? position!
+        close closed? each collect! map!)
+    stableMethods = %w(
+        read1after read1before skip1after skip1before
+        write1after write1before write1after? write1before?
+        position pos to_i begin end begin? end? succ pred + - <=>
+    )
+    stableMethods = %w()
+    anywhereMethods = %w(
+        replace clear empty? size length begin end position! close closed?
+    )
+    anywhereMethods = %w()
+    selfMethods = %w(
+        >> << begin! end! succ! pred! replace
+    )
+    repositionMethods = Cursor.public_instance_methods(false)
+    repositionMethods -= anywhereMethods
+    repositionMethods -= localMethods
+    repositionMethods.each { |m|
+        and_self = selfMethods.include?(m) ? " and self" : ""
+        update = stableMethods.include?(m) ? "" : "
+                ensure
+                    self.position = @parent
+        "
+        eval("def #{m}(*args,&block)
+            @parent.position {
+                @parent.position = self
+                begin
+                    @parent.__send__(#{m.to_sym.inspect},*args,&block)
+                    #{update}
+                end
+            }#{and_self}
+        end")
+    }
+    anywhereMethods -= localMethods
+    anywhereMethods.each { |m|
+        and_self = selfMethods.include?(m) ? " and self" : ""
+        eval("def #{m}(*args,&block)
+            @parent.__send__(#{m.to_sym.inspect},*args,&block)#{and_self}
+        end")
+    }
+    
+    def pos(reverse=false)
+        if reverse.nil? ? @anchor_after : reverse
+            (@pos.to_i-@parent.size).nonzero? || -0.0
+        else
+            @pos
+        end
+    end
+    def pos=(p)
+        if (p.nonzero?||1.0/p)<0
+            @anchor_after = true
+            @pos = p.to_i+@parent.size
+            p
+        else
+            @anchor_after = false
+            @pos = p
+        end
+    end
+    def position(reverse=false,&code) # :yield:
+        p = @parent.position {
+            @parent.position = self
+            @parent.position(reverse)
+        }
+        if code
+            begin
+                code[]
+            ensure
+                begin
+                    self.position = p
+                ensure
+                    p.close
+                end
+            end
+        else
+            p
+        end
+    end
+    def position?(p=nil,&code) # :yield:
+        if code
+            super
+        elsif p
+            @parent.position?(p)
+        else
+            nil
+        end
+    end
+    def position!(p=nil)
+        if p
+            @parent.position!(p)
+            self
+        else
+            nil
+        end
+    end
+    def close
+        @parent.position!(self)
+        super
+    end
+    protected
+    def _deletion(pos,len=1,reverse=false,dummy=nil)
+        if @pos==pos
+            @anchor_after = false
+        elsif @pos>pos
+            @pos -= len
+            if @pos<pos
+                @pos = pos
+                @anchor_after = !reverse
+            elsif @pos==pos
+                @anchor_after = true
+            end
+        end
+        nil
+    end
+    def _insertion(pos,len=1,dummmy=nil)
+        if @pos>=pos+(@anchor_after ? 0 : 1)
+            @pos += len
+        end
+        nil
+    end
+end
+end
+
+

data/cursor/reversed.rb

@@ -0,0 +1,122 @@
+# $Id: reversed.rb,v 1.10 2005/07/21 15:15:38 eric_mahurin Exp $
+
+require 'cursor'
+
+class Cursor
+# This class can be used to reverse the direction of operations on a given
+# cursor.  It operates on the given cursor directly moving it around.
+class Reversed < Cursor
+    def initialize(cursor)
+        @cursor = cursor
+    end
+    # :stopdoc:
+    def new_data
+        @cursor.new_data
+    end
+    def read1next
+        @cursor.read1prev
+    end
+    def read1prev
+        @cursor.read1next
+    end
+    def read1after
+        @cursor.read1before
+    end
+    def read1before
+        @cursor.read1after
+    end
+    def skip1next
+        @cursor.skip1prev
+    end
+    def skip1prev
+        @cursor.skip1next
+    end
+    def skip1after
+        @cursor.skip1before
+    end
+    def skip1before
+        @cursor.skip1after
+    end
+    def delete1after
+        v0 = @cursor.delete1before
+        v0 && @positions && _adjust_delete
+        v0
+    end
+    def delete1before
+        v0 = @cursor.delete1after
+        v0 && @positions && _adjust_delete
+        v0
+    end
+    def delete1after?
+        v0 = @cursor.delete1before?
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def delete1before?
+        v0 = @cursor.delete1after?
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def write1next(v)
+        @cursor.write1prev(v)
+    end
+    def write1prev(v)
+        @cursor.write1next(v)
+    end
+    def write1after(v)
+        @cursor.write1before(v)
+    end
+    def write1before(v)
+        @cursor.write1after(v)
+    end
+    def write1next?(v)
+        @cursor.write1prev?(v)
+    end
+    def write1prev?(v)
+        @cursor.write1next?(v)
+    end
+    def write1after?(v)
+        @cursor.write1before?(v)
+    end
+    def write1before?(v)
+        @cursor.write1after?(v)
+    end
+    def insert1before(v)
+        @positions && _adjust_insert
+        @cursor.insert1after(v)
+    end
+    def insert1after(v)
+        @positions && _adjust_insert
+        @cursor.insert1before(v)
+    end
+    def scan1next(v)
+        @cursor.scan1prev(v)
+    end
+    def scan1prev(v)
+        @cursor.scan1next(v)
+    end
+    def modify1next(lookup)
+        @cursor.modify1prev(lookup)
+    end
+    def modify1prev(lookup)
+        @cursor.modify1next(lookup)
+    end
+    def pos(reverse=false) # :yield:
+        -(@cursor.pos(!reverse).nonzero? or return(reverse ? -0.0 : 0))
+    end
+    def pos=(p)
+        if p.zero?
+            @cursor.pos = ((1.0/p)<0) ? 0 : -0.0
+        else
+            @cursor.pos = -p
+        end
+        p
+    end
+    def closed?
+        super or @cursor.closed?
+    end
+    # :startdoc:
+end
+end
+
+

data/cursor/shifting.rb

@@ -0,0 +1,40 @@
+# $Id: shifting.rb,v 1.3 2005/07/21 15:15:38 eric_mahurin Exp $
+
+require 'cursor'
+require 'cursor/usedeleteinsert'
+
+class Cursor
+# This Cursor class puts a cursor at the ends of an Array/String (or something
+# like those).  Assuming insertions/deletions are efficient at both ends of that
+# structure, all insertions/deletions at the cursor will be also.
+class Shifting < Cursor
+    include UseDeleteInsert
+    def initialize(data=[],pos0=0)
+        @data = data
+        @pos0 = pos0
+    end
+    # :stopdoc:
+    def new_data
+        @data.class.new
+    end
+    protected
+    def _delete1after?
+        @pos0.nonzero? && (@pos0 -= 1) && @data.slice!(0)
+    end
+    def _delete1before?
+        @pos0==@data.size ? nil : @data.slice!(-1)
+    end
+    def _insert1before(v)
+        @data << v
+        true
+    end
+    def _insert1after(v)
+        @data[0,0] = (@data.class.new << v)
+        @pos0 += 1
+        true
+    end
+    # :startdoc:
+end
+end
+
+

data/cursor/split.rb

@@ -0,0 +1,45 @@
+# $Id: split.rb,v 1.3 2005/07/21 15:15:38 eric_mahurin Exp $
+
+require 'cursor'
+require 'cursor/usedeleteinsert'
+
+class Cursor
+# This Cursor class uses an Array/String for data before the cursor
+# and another one for data after the cursor.  The result of this is that
+# data is only deleted/inserted at the end of these 2.  Because of that
+# most operations have similar expense and are linear with respect to the
+# number of elements being moved, inserted, deleted, replaced, etc.
+class Split < Cursor
+    include UseDeleteInsert
+    def initialize(before=[],after=before.class.new)
+        @before = before
+        @after = after
+    end
+    # :stopdoc:
+    def new_data
+        @before.class.new
+    end
+    protected
+    def _delete1after?
+        @after.slice!(-1)
+    end
+    def _delete1before?
+        @before.slice!(-1)
+    end
+    def _insert1before(v)
+        @before << v
+        true
+    end
+    def _insert1after(v)
+        @after << v
+        true
+    end
+    public
+    def pos(reverse=false)
+        reverse ? -(@after.size.nonzero?||0.0) : @before.size
+    end
+    # :startdoc:
+end
+end
+
+