cursor 0.6 → 0.8

data/cursor/circular/position.rb

@@ -0,0 +1,105 @@
+# $Id: position.rb,v 1.2 2005/07/18 14:46:28 eric_mahurin Exp $
+
+require 'cursor/circular'
+
+class Cursor
+class Circular
+class Position < Cursor::Position # :nodoc:
+    def initialize(parent,reverse=false)
+        @parent = parent
+        @anchor_after = reverse
+        @pos = @parent.__send__(:_pos)
+        if @anchor_after
+            if @pos==@parent.size
+                if @pos.zero?
+                    @anchor_after = false
+                else
+                    @pos = 0
+                end
+            end
+        else
+            @pos = @parent.size if @pos.zero?
+        end
+        prop(nil,@parent.prop)
+    end
+    def position=(p)
+        self._pos = p.__send__(:_pos,nil)
+        self.prop(nil,p.prop)
+        nil
+    end
+    def pos(reverse=false)
+        reverse ? -0.0 : 0
+    end
+    def pos=(p)
+        skip(p)
+        p
+    end
+    protected
+    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
+            if @pos.zero?
+                @anchor_after = false if @parent.size.zero?
+            else
+                @pos += @parent.size
+            end
+        else
+            @anchor_after = false
+            @pos = p.nonzero? || @parent.size
+        end
+        p
+    end
+    def _deletion(pos,len=1,reverse=false,size=nil)
+        if @pos==pos
+            @anchor_after = false
+            @pos = (size ||= @parent.size) if @pos.zero?
+        elsif @pos>pos
+            @pos -= len
+            if @pos<pos
+                @pos = pos
+                if @anchor_after==reverse
+                    @anchor_after = !reverse
+                    if @anchor_after
+                        if @pos==(size ||= @parent.size)
+                            if @pos.zero?
+                                @anchor_after = false
+                            else
+                                @pos = 0
+                            end
+                        end
+                    else
+                        @pos = (size ||= @parent.size) if @pos.zero?
+                    end
+                end
+            elsif @pos==pos && !@anchor_after
+                @anchor_after = true
+                if @pos==(size ||= @parent.size)
+                    if @pos.zero?
+                        @anchor_after = false
+                    else
+                        @pos = 0
+                    end
+                end
+            end
+        end
+        size
+    end
+    def _insertion(pos,len=1,dummy=nil)
+        if @pos>=pos+((@anchor_after||@pos.zero?) ? 0 : 1)
+            @pos += len
+        end
+        nil
+    end
+end
+end
+end
+
+

data/cursor/circular/shifting.rb

@@ -0,0 +1,48 @@
+# $Id: shifting.rb,v 1.4 2005/07/21 15:15:38 eric_mahurin Exp $
+
+require 'cursor/circular'
+require 'cursor/usedeleteinsert'
+
+class Cursor
+class Circular
+# 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 < Circular
+    include UseDeleteInsert
+    def initialize(data=[],pos0=0)
+        @data = data
+        @pos0 = pos0
+    end
+    # :stopdoc:
+    def new_data
+        @data.class.new
+    end
+    protected
+    def _delete1after?
+        @pos0 = (@data.size.nonzero?||return) if @pos0.zero?
+        @pos0 -= 1
+        @data.slice!(0)
+    end
+    def _delete1before?
+        @pos0 = 0 if @pos0==@data.size
+        @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
+    def _pos(reverse=false)
+        reverse ? -(@pos0.nonzero?||0.0) : @data.size-@pos0
+    end
+    # :startdoc:
+end
+end
+end
+
+

data/cursor/circular/split.rb

@@ -0,0 +1,106 @@
+# $Id: split.rb,v 1.3 2005/07/18 14:46:28 eric_mahurin Exp $
+
+require 'cursor/circular'
+require 'cursor/usedeleteinsert'
+
+class Cursor
+class Circular
+# 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 < Circular
+    include UseDeleteInsert
+    def initialize(before=[],after=before.class.new)
+        @before = before
+        @after = after
+        @middle = before.class.new
+        @middle_start = nil
+        @middle_before = false
+        @size = @before.size+@after.size
+        @pos0 = @after.size
+    end
+    # :stopdoc:
+    def new_data
+        @before.class.new
+    end
+    protected
+    def _delete1after?
+        @pos0 = (@size.nonzero?||return) if @pos0.zero?
+        @pos0 -= 1
+        @size -= 1
+        v = @after.slice!(-1)
+        if v.nil?
+            if !@middle_start
+                @before,@middle = @middle,@before
+                @middle_before = true
+                @middle_start = 0
+            end
+            if @middle_before
+                v = @middle[@middle_start]
+                @middle_start += 1
+            else
+                v = @middle.slice!(-1)
+            end
+            if @middle_start>=@middle.size
+                @middle.replace(@middle.class.new)
+                @middle_start = nil
+            end
+        end
+        v
+    end
+    def _delete1before?
+        if @pos0==@size
+            return if @size.zero?
+            @pos0 = 0
+        end
+        @size -= 1
+        v = @before.slice!(-1)
+        if v.nil?
+            if !@middle_start
+                @after,@middle = @middle,@after
+                @middle_before = false
+                @middle_start = 0
+            end
+            if !@middle_before
+                v = @middle[@middle_start]
+                @middle_start += 1
+            else
+                v = @middle.slice!(-1)
+            end
+            if @middle_start>=@middle.size
+                @middle.replace(@middle.class.new)
+                @middle_start = nil
+            end
+        end
+        v
+    end
+    def _insert1before(v)
+        @size += 1
+        if !@middle_before and @middle_start and @middle_start.nonzero?
+            @middle[@middle_start -= 1] = v
+        else
+            @before << v
+        end
+        true
+    end
+    def _insert1after(v)
+        @pos0 += 1
+        @size += 1
+        if @middle_before and @middle_start and @middle_start.nonzero?
+            @middle[@middle_start -= 1] = v
+        else
+            @after << v
+        end
+        true
+    end
+    def _pos(reverse=false)
+        reverse ? -(@pos0.nonzero?||0.0) : @size-@pos0
+    end
+    # :startdoc:
+end
+end
+end
+
+

data/cursor/indexed.rb

@@ -0,0 +1,52 @@
+# $Id: indexed.rb,v 1.7 2005/07/21 15:15:38 eric_mahurin Exp $
+
+require 'cursor'
+require 'cursor/usedeleteinsert'
+
+class Cursor
+# This class puts a cursor on an Array or String.
+class Indexed < Cursor
+    include UseDeleteInsert
+    def initialize(data=[],pos=0)
+        @data = data
+        @pos = pos
+    end
+    # :stopdoc:
+    def new_data
+        @data.class.new
+    end
+    protected
+    def _delete1after?
+        @data.slice!(@pos)
+    end
+    def _delete1before?
+        @pos==0 ? nil : @data.slice!(@pos-=1)
+    end
+    def _insert1before(v)
+        @data[@pos,0] = (new_data << v)
+        @pos += 1
+        true
+    end
+    def _insert1after(v)
+        @data[@pos,0] = (new_data << v)
+        true
+    end
+    # :startdoc:
+end
+end
+
+class Array
+    # convert an array to a cursor starting at +pos+
+    def to_cursor(pos=0)
+        Cursor::Indexed.new(self,pos)
+    end
+end
+
+class String
+    # convert a string to a cursor starting at +pos+
+    def to_cursor(pos=0)
+        Cursor::Indexed.new(self,pos)
+    end
+end
+
+

data/cursor/io.rb

@@ -0,0 +1,342 @@
+# $Id: io.rb,v 1.15 2005/07/21 15:15:38 eric_mahurin Exp $
+
+require 'cursor'
+require 'cursor/usenext'
+
+class Cursor
+# This class treats an IO (or StringIO) as a Cursor.  An IO is already
+# like a Cursor, but doesn't have as robust an interface.  Keep in mind that deleting and
+# inserting is a slow/painful process.
+class IO < Cursor
+    include UseNext
+    def initialize(io)
+        @io = io
+    end
+    # :stopdoc:
+    def new_data
+        String.new
+    end
+    protected
+    def _delete1after?
+        ret = @io.getc or return(nil)
+        after = 0
+        while c = @io.getc
+            after += 1
+            @io.seek(-2,::IO::SEEK_CUR)
+            @io.putc(c)
+            @io.seek(+1,::IO::SEEK_CUR)
+        end
+        @io.seek(-1,::IO::SEEK_CUR)
+        @io.truncate(@io.pos)
+        @io.seek(-after,::IO::SEEK_CUR)
+        ret
+    end
+    def _insert1before(v)
+        after = 0
+        while c = @io.getc
+            after += 1
+            @io.seek(-1,::IO::SEEK_CUR)
+            @io.putc(v)
+            v = c
+        end
+        @io.putc(v)
+        @io.seek(-after,::IO::SEEK_CUR)
+        true
+    end
+    public
+    def read1next
+        @io.getc
+    end
+    def write1next(v)
+        @io.eof? ? nil : (@io.putc(v);true)
+    end
+    def write1next!(v)
+        @io.putc(v)
+        true
+    end
+    def skip1prev
+        @io.pos.nonzero? && (@io.seek(-1,::IO::SEEK_CUR);true)
+    end
+    def read1after
+        v0 = @io.getc
+        v0 && @io.ungetc(v0)
+        v0
+    end
+    def write1after!(v)
+        @io.putc(v)
+        @io.seek(-1,::IO::SEEK_CUR)
+        true
+    end
+    def skip1next
+        @io.getc ? true : nil
+    end
+    def skip1after
+        @io.eof? ? nil : true
+    end
+    def skip1before
+        @io.pos.zero? ? nil : true
+    end
+    def read(len,hold=false,buffer=nil)
+        len.nonzero? or return(buffer||"")
+        reverse = len<0
+        len = len.abs
+        if reverse                   
+            p0 = @io.pos
+            len = p0.nonzero? or return if (p0-len)<0
+            @io.seek(-len,::IO::SEEK_CUR)
+            buffer1 = @io.read(len)
+            if hold.nil?
+                buffer2 = @io.read(nil)
+                len2 = buffer2.size
+                @io.seek(-(len+len2),::IO::SEEK_CUR)
+                @io.write(buffer2)
+                @io.truncate(@io.pos)
+                @io.seek(-len2,::IO::SEEK_CUR)
+                @positions && _adjust_delete(len,reverse)
+            elsif !hold
+                @io.seek(-len,::IO::SEEK_CUR)
+            end
+            buffer1.reverse!
+        else
+            buffer1 = @io.read(len) or return
+            len = buffer1.size
+            if hold.nil?
+                buffer2 = @io.read(nil)
+                len2 = buffer2.size
+                @io.seek(-(len+len2),::IO::SEEK_CUR)
+                @io.write(buffer2)
+                @io.truncate(@io.pos)
+                @io.seek(-len2,::IO::SEEK_CUR)
+                @positions && _adjust_delete(len,reverse)
+            elsif hold
+                @io.seek(-len,::IO::SEEK_CUR)
+            end
+        end
+        if buffer
+            if String===buffer
+                buffer.concat(buffer1)
+            else
+                buffer1.each_byte { |c| buffer << c }
+            end
+        else
+            buffer = buffer1
+        end
+        buffer
+    end
+    def read!(reverse=false,hold=false,buffer=new_data)
+        if reverse                   
+            len = @io.pos.nonzero? or return
+            @io.seek(0,::IO::SEEK_SET)
+            #@io.pos = 0 # BUGGY in v1.8.2
+            buffer1 = @io.read(len) or return
+            if hold.nil?
+                buffer2 = @io.read(nil)
+                len2 = buffer2.size
+                @io.seek(-(len+len2),::IO::SEEK_CUR)
+                @io.write(buffer2)
+                @io.truncate(@io.pos)
+                @io.seek(-len2,::IO::SEEK_CUR)
+                @positions && _adjust_delete(len,reverse)
+            elsif !hold
+                @io.seek(-len,::IO::SEEK_CUR)
+            end
+            buffer1.reverse!
+        else
+            buffer1 = @io.read(nil)
+            len = buffer1.size.nonzero? or return
+            if hold.nil?
+                @io.seek(-len,::IO::SEEK_CUR)
+                @io.truncate(@io.pos)
+                @positions && _adjust_delete(len,reverse)
+            elsif hold
+                @io.seek(-len,::IO::SEEK_CUR)
+            end
+        end
+        if buffer
+            if String===buffer
+                buffer.concat(buffer1)
+            else
+                buffer1.each_byte { |c| buffer << c }
+            end
+        else
+            buffer = buffer1
+        end
+        buffer
+    end
+    def skip(len,hold=false)
+        len.nonzero? or return(0)
+        reverse = len<0
+        len = len.abs
+        if reverse
+            p0 = @io.pos
+            len = p0.nonzero? or return if (p0-len)<0
+            if hold.nil?
+                buffer2 = @io.read(nil)
+                len2 = buffer2.size
+                @io.seek(-(len+len2),::IO::SEEK_CUR)
+                @io.write(buffer2)
+                @io.truncate(@io.pos)
+                @io.seek(-len2,::IO::SEEK_CUR)
+                @positions && _adjust_delete(len,reverse)
+            elsif !hold
+                @io.seek(-len,::IO::SEEK_CUR)
+            end
+        else
+            @io.seek(len,::IO::SEEK_CUR)
+            if @io.eof?
+                p0 = @io.pos
+                @io.seek(0,::IO::SEEK_END)
+                len -= p0-@io.pos
+                len.nonzero? or return
+            end
+            if hold.nil?
+                buffer2 = @io.read(nil)
+                len2 = buffer2.size
+                @io.seek(-(len+len2),::IO::SEEK_CUR)
+                @io.write(buffer2)
+                @io.truncate(@io.pos)
+                @io.seek(-len2,::IO::SEEK_CUR)
+                @positions && _adjust_delete(len,reverse)
+            elsif hold
+                @io.seek(-len,::IO::SEEK_CUR)
+            end
+        end
+        len
+    end
+    def skip!(reverse=false,hold=false)
+        if reverse
+            len = @io.pos.nonzero? or return
+            if hold.nil?
+                buffer2 = @io.read(nil)
+                len2 = buffer2.size
+                @io.seek(-(len+len2),::IO::SEEK_CUR)
+                @io.write(buffer2)
+                @io.truncate(@io.pos)
+                @io.seek(-len2,::IO::SEEK_CUR)
+                @positions && _adjust_delete(len,reverse)
+            elsif !hold
+                @io.seek(0,::IO::SEEK_SET)
+            end
+        else
+            p0 = @io.pos
+            @io.seek(0,::IO::SEEK_END)
+            len = @io.pos-p0
+            len.nonzero? or return
+            @io.seek(-len,::IO::SEEK_CUR) if hold!=false
+            if hold.nil?
+                @io.truncate(@io.pos)
+                @positions && _adjust_delete(len,reverse)
+            end
+        end
+        len
+    end
+    def write(value,reverse=false,hold=false,overwrite_only=false)
+        if String===value
+            value1 = reverse ? value.reverse : value
+            len = value.size
+        else
+            value1 = ""
+            len = 0;
+            until (v = value[len]).nil?
+                value1 << v
+                len += 1
+            end
+            value1 = value1.reverse if reverse
+        end
+        if reverse
+            if hold.nil?
+                @positions && _adjust_insert(len)
+                buffer2 = @io.read(nil)
+                len2 = buffer2.size
+                @io.seek(-len2,::IO::SEEK_CUR)
+                @io.write(value1)
+                @io.write(buffer2)
+                @io.seek(-(len+len2),::IO::SEEK_CUR)
+            else
+                len_overwrite = @io.pos
+                len_insert = len-len_overwrite
+                if len_insert<=0
+                    @io.seek(-len,::IO::SEEK_CUR)
+                    @io.write(value1)
+                else
+                    @io.seek(-len_overwrite,::IO::SEEK_CUR)
+                    if overwrite_only
+                        len = len_overwrite.nonzero? or return
+                    else
+                        @positions && _adjust_insert(len_insert)
+                        buffer2 = @io.read(nil)
+                        len2 = buffer2.size
+                        @io.seek(-len2,::IO::SEEK_CUR)
+                        @io.write(value1[0,len_insert])
+                        @io.write(buffer2)
+                        @io.seek(-len2,::IO::SEEK_CUR)
+                    end
+                    @io.write(value1[len_insert,len_overwrite])
+                    
+                end
+                @io.seek(-len,::IO::SEEK_CUR) if !hold
+            end
+        else
+            if hold.nil?
+                @positions && _adjust_insert(len)
+                buffer2 = @io.read(nil)
+                len2 = buffer2.size
+                @io.seek(-len2,::IO::SEEK_CUR)
+                @io.write(value1)
+                @io.write(buffer2)
+                @io.seek(-len2,::IO::SEEK_CUR)
+            else
+                if overwrite_only
+                    len.nonzero? or return(0)
+                    @io.seek(len,::IO::SEEK_CUR)
+                    if @io.eof?
+                        p0 = @io.pos
+                        @io.seek(0,::IO::SEEK_END)
+                        len -= p0-@io.pos
+                        len.nonzero? or return
+                        value1 = value1[0,len]
+                    end
+                    @io.seek(-len,::IO::SEEK_CUR)
+                end
+                @io.write(value1)
+                @io.seek(-len,::IO::SEEK_CUR) if hold
+            end
+        end
+        len
+    end
+    def scan_until(value,reverse=false,hold=false,buffer=nil)
+        if String===value && !reverse && hold==false && !buffer && !value.empty?
+            @io.gets(value)
+        else
+            super(value,reverse,hold,buffer||value.class.new)
+        end
+    end
+    def pos=(p)
+        @io.seek(p,(p.nonzero?||1.0/p)<0 ? ::IO::SEEK_END : ::IO::SEEK_SET)
+        p
+    end
+    
+    public
+    def close
+        @io.close
+        super
+    end
+    # :startdoc:
+end
+end
+
+class IO
+    # convert an IO to a cursor
+    def to_cursor
+        Cursor::IO.new(self)
+    end
+end
+
+class StringIO
+    # convert an IO to a cursor
+    def to_cursor
+        Cursor::IO.new(self)
+    end
+end
+
+