cursor 0.8 → 0.9

data/cursor.rb

@@ -1,6 +1,6 @@
 #!/bin/env ruby
 # = cursor.rb - external iterators with capabilities like a text editor cursor
-# $Id: cursor.rb,v 1.53 2005/07/21 15:15:38 eric_mahurin Exp $
+# $Id: cursor.rb,v 1.58 2005/10/14 00:22:58 eric_mahurin Exp $
 # Author::  Eric Mahurin (Eric under Mahurin at yahoo dot com)
 # License:: Ruby license
 # Home::    http://rubyforge.org/projects/cursor
@@ -50,7 +50,8 @@ to #==).
 
 #read, #read!, #skip, #skip!,
 #write, #write?,
-#scan, #scan_until, #scan_partial,
+#scan, #scan_until
+#scan_pattern, #scan_pattern_while, #scan_pattern_until
 #modify
 
 The methods below deal with numeric positions (a pos) to represent the cursor location.
@@ -60,22 +61,13 @@ end.  Also included in this list below is #prop for manipulating properities
 for the current cursor location.  One typical use is for tracking line and
 column numbers.
 
-#pos, #pos=, #to_i, #prop, #to_s,
+#pos, #pos=, #pos?, #to_i, #prop, #to_s,
 
 The position methods below use a Cursor object (Cursor::Position in the base class) to
 hold the position rather than simply a numeric position.  These
 position objects hold a #pos and whatever is
 in #prop.  Also, the #pos in these objects adjust based on
-insertions and deletions.  It is preferrable to use these position objects
-over numeric positions because
-a) derived classes may have a more efficient means of holding a position (i.e. linked list could hold a node reference),
-b) they may trigger things like buffering in derived classes,
-c) they hold what's in #prop,
-d) they adjust with insert/delete,
-e) when the numeric positions can't be implemented these methods still may, and
-f) the covenience of saving and possibly restoring position
-before/after executing a code block is available (should be implementable before
-any of the others).
+insertions and deletions.
 
 #position, #position=, #position?, #position!,
 #close, #closed?
@@ -86,7 +78,7 @@ Return a remote #position: #+, #succ, #pred, #begin, #end
 
 Access the entire collection: #empty?, #length/#size, #data, #replace
 
-Random access: #[]/#slice, #slice!, #[]=,  #<<, #>>
+Random access: #[]/#slice, #slice!, #[]=,  #<<, #>>, #concat, #prepend
 
 Enumerable: #each, #collect!/#map!
 
@@ -272,9 +264,12 @@ class Cursor
     def new_data
         @cursor.new_data
     end
-    # read +len+ elements.  A negative +len+ will go in reverse.  +hold+ will
-    # hold the cursor in place.  +hold+==+nil+ (not false) will make it delete.
-    def read(len,hold=false,buffer=new_data)
+    # read +len+ elements.
+    # A negative +len+ will go in reverse.
+    # +hold+ will hold the cursor in place.
+    # +hold+.nil? will make it delete.
+    def read(len,hold=false,buffer=nil)
+        buffer0 = buffer or buffer = new_data
         reverse = len<0
         len = len.abs
         meth = method(hold.nil? ?
@@ -282,35 +277,39 @@ class Cursor
             (reverse ? :read1prev : :read1next) )
         len0 = 0
         while len>len0
-            (v0 = meth.call).nil? and return(
+            (v0 = meth.call).nil? and (
                 skip(reverse ? len0 : -len0) if hold
-                len0.nonzero?&&buffer
+                return len0.nonzero?&&(buffer0 ? len0 : buffer)
             )
             buffer << v0
             len0 += 1
         end
         skip(reverse ? len0 : -len0) if hold
-        buffer
+        buffer0 ? len0 : buffer
     end
-    # read the remaining elements.  +hold+ will
-    # hold the cursor in place.  +hold+==+nil+ (not false) will make it delete.
-    def read!(reverse=false,hold=false,buffer=new_data)
+    # read the remaining elements.
+    # +hold+ will hold the cursor in place.
+    # +hold+.nil? will make it delete.
+    def read!(reverse=false,hold=false,buffer=nil)
+        buffer0 = buffer or buffer = new_data
         meth = method(hold.nil? ?
             (reverse ? :delete1before? : :delete1after?) :
             (reverse ? :read1prev : :read1next) )
         len0 = 0
         loop do
-            (v0 = meth.call).nil? and return(
+            (v0 = meth.call).nil? and (
                 skip(reverse ? len0 : -len0) if hold
-                len0.nonzero?&&buffer
+                return len0.nonzero? && (buffer0 ? len0 : buffer)
             )
             buffer << v0
             len0 += 1
         end
     end
-    # skip +len+ elements and return the count.  A negative +len+ will go in
-    # reverse.  +hold+ will
-    # hold the cursor in place.  +hold+==+nil+ (not false) will make it delete.
+    # skip +len+ elements.
+    # A negative +len+ will go in reverse.
+    # +hold+ will hold the cursor in place.
+    # +hold+.nil? will make it delete.
+    # The amount skipped is returned (<+len+ if reached beginning/end).
     def skip(len,hold=false)
         reverse = len<0
         len = len.abs
@@ -319,34 +318,41 @@ class Cursor
             (reverse ? :skip1prev : :skip1next) )
         len0 = 0
         while len>len0
-            meth.call or return(
+            meth.call or (
                 skip(reverse ? len0 : -len0) if hold
-                len0.nonzero?
+                return len0.nonzero?
             )
             len0 += 1
         end
         skip(reverse ? len0 : -len0) if hold
         len0
     end
-    # skip the remaining elements and return the count.  A negative +len+ will go in
-    # reverse.  +hold+ will hold the cursor in place.  +hold+==+nil+ (not false)
-    # will make it delete.
+    # skip the remaining elements.
+    # A negative +len+ will go in reverse.
+    # +hold+ will hold the cursor in place.
+    # +hold+.nil? will make it delete.
+    # The amount skipped is returned.
     def skip!(reverse=false,hold=false)
         meth = method(hold.nil? ?
             (reverse ? :delete1before : :delete1after) :
             (reverse ? :skip1prev : :skip1next) )
         len0 = 0
         loop do
-            meth.call or return(
+            meth.call or (
                 skip(reverse ? len0 : -len0) if hold
-                len0.nonzero?
+                return len0.nonzero?
             )
             len0 += 1
         end
     end
-    # write a sequence of elements and return the overwrite count.  +hold+ will
-    # hold the cursor in place.  +hold+==+nil+ (not false) will make it insert.
+    # write a sequence of elements (+value+).
+    # +hold+ will hold the cursor in place.
+    # +hold+.nil? will make it insert.
     # +overwrite_only+ will prevent insertion when the cursor is at the beginning/end.
+    # When the entire +value+ is written, the length is returned.
+    # When nothing of the +value+ could be written, +nil+ is returned.
+    # When a portion of +value+ is written, the negative of the length written
+    # is returned.
     def write(value,reverse=false,hold=false,overwrite_only=false)
         meth = method(
             hold.nil? ? (reverse ? :insert1after : :insert1before) :
@@ -354,53 +360,68 @@ class Cursor
                 (reverse ? :write1prev! : :write1next!) )
         i = 0
         until (v = value[i]).nil?
-            meth.call(v) or return(
+            meth.call(v) or (
                 skip(reverse ? i : -i) if hold
-                i.nonzero?
+                return (-i).nonzero?
             )
             i += 1
         end
         skip(reverse ? i : -i) if hold
         i
     end
-    # overwrite a sequence of elements and return the sequence overwritten.
+    # overwrite a sequence of elements while reading what is overwritten.
+    # and return the sequence overwritten.
     # +hold+ will hold the cursor in place.
-    def write?(value,reverse=false,hold=false,buffer=value.class.new)
+    def write?(value,reverse=false,hold=false,buffer=nil)
+        buffer0 = buffer or buffer = new_data
         meth = method(reverse ? :write1prev? : :write1next?)
         i = 0
         until (v = value[i]).nil?
-            (v0 = meth.call(v)).nil? and return(
+            (v0 = meth.call(v)).nil? and (
                 skip(reverse ? i : -i) if hold
-                i.nonzero? && buffer
+                return i.nonzero? && (buffer0 ? -i : buffer)
             )
             buffer << v0
             i += 1
         end
         skip(reverse ? i : -i) if hold
-        buffer
-    end
-    # scan for +value+ at the cursor.  When there is a mismatch, +nil+ is returned
-    # and the cursor is move back to where it started (unless hold==+nil+:
-    # cursor position will indeterminate).
-    # +hold+ will hold the cursor in place even on a match.
-    def scan(value,reverse=false,hold=false,buffer=value.class.new)
-        meth = method(reverse ? :read1prev : :read1next)
+        buffer0 ? i : buffer
+    end
+    # scan for the sequence +value+.  Will terminate on the first mismatching
+    # element and leave the cursor at that mismatched element.
+    # Without +buffer+, the matching sequence found will be returned.
+    # With +buffer+, an integer will be returned where its absolute value is the
+    # number of elements matched.  Positive means the entire sequence matched
+    # and negative means only part of the sequence matched.
+    # If there is a mismatch on the very first element, +nil+ is returned
+    # (regardless of +buffer+).
+    def scan(value,reverse=false,hold=false,buffer=nil)
+        buffer0 = buffer or buffer = new_data
+        meth = method(reverse ? :scan1prev : :scan1next)
         i = 0
         until (v = value[i]).nil?
-            v0 = meth.call
-            (!v0.nil? and i += 1 and v==v0) or return(
-                skip(reverse ? i : -i) if !hold.nil?
-                nil
+            v0 = meth.call(v)
+            !v0.nil? or (
+                skip(reverse ? i : -i) if hold
+                return i.nonzero? && (buffer0 ? -i : buffer)
             )
             buffer << v0
+            i += 1
         end
         skip(reverse ? i : -i) if hold
-        buffer
-    end
-    # scan for +value+ until it is found (or the end is reached) and
-    # return that entire sequence.  +hold+ will
-    # hold the cursor in place.  +hold+==+nil+ (not false) will make it delete.
-    def scan_until(value,reverse=false,hold=false,buffer=value.class.new)
+        buffer0 ? i : buffer
+    end
+    # scan for +value+ until it is found (or the beginning/end is reached).
+    # +hold+.nil? will make it delete instead of read.
+    # Without +buffer+, sequence (including what +value+ matched) will be
+    # returned (or +nil+ if started at the beginning/end).
+    # With +buffer+, the length of the sequence scanned and the final index of
+    # +value+ is returned.  If the cursor started at the beginnning/end,
+    # +nil+ will be returned in place of the sequence length.  If the entire
+    # +value+ is not found (beginning/end reached), the index will be <=0 and
+    # its absolute value is the index of the mismatch.
+    def scan_until(value,reverse=false,hold=false,buffer=nil)
+        buffer0 = buffer or buffer = new_data
         meth = method(hold.nil? ?
             (reverse ? :delete1before? : :delete1after?) :
             (reverse ? :read1prev : :read1next) )
@@ -408,9 +429,13 @@ class Cursor
         len0 = 0
         i = 0
         until (v = value[i]).nil?
-            (v0 = meth.call).nil? and return(
+            (v0 = meth.call).nil? and (
                 skip(reverse ? len0 : -len0) if hold
-                len0.nonzero?&&buffer
+                if buffer0
+                    return len0.nonzero?,-i
+                else
+                    return len0.nonzero? && buffer
+                end
             )
             buffer << v0
             buffer2 << v0
@@ -426,41 +451,166 @@ class Cursor
             end
         end
         skip(reverse ? len0 : -len0) if hold
-        buffer
+        if buffer0
+            return len0,i
+        else
+            return buffer
+        end
     end
-    # scan for +value+ and return as much of the sequence that matched
-    def scan_partial(value,reverse=false,hold=false,buffer=value.class.new)
-        meth = method(reverse ? :scan1prev : :scan1next)
-        i = 0
-        until (v = value[i]).nil?
-            v0 = meth.call(v)
-            !v0.nil? or return(
-                skip(reverse ? i : -i) if hold
-                i.nonzero?&&buffer
+    # scan for +pattern+ at the cursor.
+    # +pattern+ should #match no more than than +len+ (< 0 goes in reverse) elements.
+    # Although +pattern+ is implicitly anchored to the current cursor location
+    # (\A) the current implementation is more efficient with the anchor explicit.
+    # +pattern+ should not use any end anchors (\Z or $).
+    # +pattern+.match should return a MatchData like object that needs
+    # to respond to #offset(0).
+    # An array of the what matched and this MatchData object is returned
+    # (or nil upon mismatch).
+    # #post_match isn't valid in this MatchData object.
+    # The cursor is advanced to right after the match unless there is mismatch or
+    # the cursor is requested to +hold+ position.
+    def scan_pattern(pattern,len=1,hold=false,buffer=nil)
+        reverse = len<0
+        matchbuffer = new_data
+        matchbuffer_len = read(len,false,matchbuffer) or return
+        (matchdata = pattern.match(matchbuffer) and
+        (b,e = matchdata.offset(0);b.zero?)) or (
+            skip(reverse ? +matchbuffer_len : -matchbuffer_len)
+            return
+        )
+        back_len = matchbuffer_len-e
+        matchbuffer.slice!(e,back_len)
+        back_len += e if hold
+        skip(reverse ? +back_len : -back_len)
+        if buffer
+            buffer.concat(matchbuffer)
+            matchdata
+        else
+            matchbuffer
+        end
+    end
+    # scan until +pattern+ is found.
+    # +pattern+ should need no more than +len+ (<0 goes in reverse) elements
+    # to determine a match.
+    # Initially, a sequence of +init+*+len+ elements is read to be matched.
+    # Until the +pattern+ matches the buffer, more data is read and tried to be
+    # matched with +pattern+.
+    # +pattern+.match should return a MatchData like object that needs
+    # to respond to #offset(0).
+    # An array of the prematch, what matched, and this
+    # MatchData object is returned (or nil upon mismatch).
+    # #post_match and #pre_match aren't valid in this MatchData object.
+    # The cursor is advanced to right after the match unless there is mismatch or
+    # the cursor is requested to +hold+ position.
+    def scan_pattern_until(pattern,len=1,hold=false,buffer=nil,init=16)
+        buffer0 = buffer or buffer = new_data
+        reverse = len<0
+        read_len = len*init
+        len = -len if reverse
+        matchbuffer = new_data
+        buffer_len = 0
+        matchbuffer_len = 0
+        read_len1 = read(read_len,false,matchbuffer) or (
+            if buffer0
+                return nil,nil,nil
+            else
+                return nil
+            end
+        )
+        matchbuffer_len += read_len1
+        until matchdata = pattern.match(matchbuffer)
+            matchbuffer_len>=len and (
+            buffer.concat(matchbuffer.slice!(0,matchbuffer_len-len+1))
+            buffer_len += matchbuffer_len-len+1
+            matchbuffer_len = len-1
+            read_len *= 2
+            read_len1 = read(read_len,false,matchbuffer)) or (
+                buffer.concat(matchbuffer)
+                buffer_len += matchbuffer_len
+                skip(reverse ? +buffer_len : -buffer_len) if hold
+                if buffer0
+                    return buffer_len,nil,nil
+                else
+                    return buffer
+                end
             )
-            buffer << v0
-            i += 1
+            p self
+            matchbuffer_len += read_len1
+        end
+        b,e = matchdata.offset(0)
+        back_len = matchbuffer_len-e
+        matchbuffer.slice!(e,back_len)
+        buffer.concat(matchbuffer)
+        buffer_len += e
+        back_len += buffer_len if hold
+        skip(reverse ? +back_len : -back_len)
+        if buffer0
+            return buffer_len-(e-b),buffer_len,matchdata
+        else
+            return buffer
         end
-        skip(reverse ? i : -i) if hold
-        buffer
     end
-    # modify elements using +lookup+[orignalElement] until that returns nil
-    def modify(lookup,reverse=false,hold=false,buffer=new_data)
-        meth = method(reverse ? :modify1prev : :modify1next)
-        len0 = 0
-        until (v0 = meth.call(lookup)).nil?
-            buffer << v0
-            len0 += 1
+    # scan while +pattern+ matches more data.
+    # +pattern+ should be a zero or more ("*") loop with the maximum match
+    # length per iteration being +len+ (< 0 goes in reverse).
+    # +pattern+ should not use any anchors (\A, \Z, or $).
+    # Initially, a sequence of +init+*+len+ elements is read to be matched.
+    # As long as the pattern matches more data, more data is read to be matched
+    # with the pattern.
+    # +pattern+.match should return a MatchData like object that needs
+    # to respond to #offset(0).
+    # An array of the what matched and this
+    # MatchData object is returned (or nil for a mismatch or empty match).
+    # #post_match, #pre_match, everything related to #[0] aren't valid in this
+    # MatchData object.
+    # The cursor is advanced to right after the match unless there is mismatch or
+    # the cursor is requested to +hold+ position.
+    def scan_pattern_while(pattern,len=1,hold=false,buffer=nil,init=16)
+        buffer0 = buffer or buffer = new_data
+        reverse = len<0
+        read_len = len*init
+        len = -len if reverse
+        matchbuffer = new_data
+        buffer_len = 0
+        matchbuffer_len = 0
+        while matchbuffer_len<len and
+                read_len1 = read(read_len,false,matchbuffer) and
+                matchbuffer_len += read_len1 and
+                matchdata = pattern.match(matchbuffer) and
+                (b,e = matchdata.offset(0);b.zero? and e.nonzero?)
+            buffer.concat(matchbuffer.slice!(0,e))
+            buffer_len += e
+            matchbuffer_len -= e
+            read_len *= 2
+        end
+        back_len = matchbuffer_len+(hold ? buffer_len : 0)
+        skip(reverse ? +back_len : -back_len)
+        if buffer0
+            buffer_len.nonzero?
+        else
+            buffer_len.nonzero? and buffer
         end
-        skip(reverse ? len0 : -len0) if hold
-        buffer
     end
 
-    # This will return a numeric position.  When not +reverse+,
+    # Without a block, this will return a numeric position.  When not +reverse+,
     # this numeric position is the number of elements from the beginning (0 is at the beginning).  With
     # +reverse+ it is negative and the number of elements from the end (-0.0 is at the end).
-    def pos(reverse=false)
-        reverse ? -(skip!(false,true)||0.0) : (skip!(true,true)||0)
+    # With a code block, it will execute some code and come back to where the
+    # cursor started.  The result of the block will be returned.
+    # Within the block, no operations that insert or delete elements
+    # before (or after if +reverse+) the starting cursor location should be executed.
+    # The cursor will be left in an unknown location if that happens.
+    def pos(reverse=false,&code) # :yield:
+        p = reverse ? -(skip!(false,true)||0.0) : (skip!(true,true)||0)
+        if code
+            begin
+                code[]
+            ensure
+                self.pos = p
+            end
+        else
+            p
+        end
     end
     # Returns #pos.to_i
     def to_i
@@ -474,6 +624,23 @@ class Cursor
         len.to_i.abs==skip(len) or raise(IndexError,"invalid pos=#{p}")
         p
     end
+    # Without a block, this checks to see if p is a valid numeric position.
+    # With a block, it will execute the block and come back to where the cursor
+    # started if the result of the block was +false+/+nil+.  The result of the
+    # block will be returned.  The restrictions on the #pos block also apply here.
+    def pos?(p=false,&code) # :yield:
+        if code
+            p = pos(p)
+            begin
+                ret = code[]
+            ensure
+                self.pos = p if !ret
+            end
+        else
+            len = p-pos((p.nonzero?||1.0/p)<0)
+            len.to_i.abs==skip(len,true)
+        end
+    end
     # Get (no +value+) and set cursor properties.  Normally, +name+
     # should be a symbol.  If +name+ is +nil+, it wil get/set using a hash
     # representing all of the properties.
@@ -506,7 +673,9 @@ class Cursor
     # represent the current location of the cursor.  When +reverse+, it will
     # anchor the #position to the element after.  Otherwise it will anchor it
     # to the element before.  This anchoring is used when an insertion occurs at
-    # that point affecting how this position is adjusted.
+    # that point affecting how this position is adjusted.  If the element that a
+    # #position is anchored to is deleted, that #position may become invalid
+    # or have an unknown behavior.
     #
     # With a code block, it saves the #position (also using +reverse+),
     # executes the code block, and returns the #position to where it
@@ -544,7 +713,7 @@ class Cursor
     # left it.  The result of the code block is returned.  This is useful when
     # you want the cursor to stay for a pass/match, and return to try something
     # else for a fail/mismatch.
-    def position?(p=nil,&code) # :yield:
+    def position?(p=false,&code) # :yield:
         if code
             start = position(p)
             begin
@@ -556,26 +725,19 @@ class Cursor
                     start.close
                 end
             end
-        elsif p
-            @positions && @positions.include?(p) || equal?(p) || nil
         else
-            @positions && (!@positions.empty? || nil)
+            @positions && @positions.include?(p) || equal?(p) || false
         end
     end
-    # Discard/close every child #position (+p+=+nil+) or discard (not close)
-    # the give +p+ (you probably want +p+.close instead).
-    def position!(p=nil)
-        if p
-            @positions.delete(p)
-        elsif @positions
-            @positions.each { |p| p.close }
-            remove_instance_variable(:@positions)
-        end
+    # Delete +p+ from the list of children (from #position).
+    # Should only be used by child #position.
+    def _delete_position(p) # :nodoc:
+        @positions.delete(p)
         self
     end
-    # Close the cursor.  This will also close every child #position.
+    # Close the cursor.  This will also close/invalidate every child #position.
     def close
-        position!
+        @positions and @positions.each { |p| p.close }
         # this should make just about any operation fail
         instance_variables.each { |v| instance_variable_set(v,nil) }
         nil
@@ -598,24 +760,24 @@ class Cursor
     end
     # Returns a new #position increased by +len+ (positive or negative).
     def +(len)
-        position { skip(len);position((len.nonzero?||1.0/len)<0) }
+        pos { skip(len);position((len.nonzero?||1.0/len)<0) }
     end
 
     # Return a new #position for next cursor location or +nil+ if we are at the end.
     def succ
-        position { skip1next && position(false) }
+        pos(false) { skip1next && position(false) }
     end
     # Return a new #position for previous cursor location or +nil+ if we are at the beginning.
     def pred
-        position { skip1prev && position(true) }
+        pos(true)  { skip1prev && position(true) }
     end
     # Return a new #position for the beginning.
     def begin
-        position { skip!(true);position(false) }
+        pos(false) { skip!(true);position(false) }
     end
     # Return a new #position for the end.
     def end
-        position { skip!(false);position(true) }
+        pos(true) { skip!(false);position(true) }
     end
     # Returns the number of elements.
     def size
@@ -631,55 +793,83 @@ class Cursor
         (skip!(false,nil)||0)+(skip!(true,nil)||0)
     end
     # Replace the all of the data and return self.
-    def replace(obj)
+    def replace(value,reverse=false)
         clear
-        write(obj,false,nil)
+        write(value,reverse,nil)
         self
     end
-    # Get all of the data and leave the cursor at the end.
-    def data
-        skip!(true)
-        read!(false)
+    # Get all of the data.
+    def data(reverse=false)
+        pos { skip!(!reverse);read!(reverse) }
     end
     # Appends a single element at the end and returns self.
     def << (v)
-        skip!(false)
-        insert1before(v)
+        pos(false) { skip!(false);write1next!(v) }
         self
     end
     # Prepends a single element at the beginning and returns self.
     def >> (v)
-        skip!(true)
-        insert1after(v)
+        pos(true) { skip!(true);write1prev!(v) }
+        self
+    end
+    # Appends a sequence to the end and returns self.
+    def concat(value)
+        pos(false) { skip!(false);write(value,false) }
+        self
+    end
+    # Prepends a sequence to the beginning and returns self.
+    def prepend(value)
+        pos(true) { skip!(true);write(value,true) }
+        self
+    end
+    def push(v)
+        pos(false) { skip!(false);write1next!(v) }
+        self
+    end
+    def unshift(v)
+        pos(true) { skip!(true);write1prev!(v) }
         self
     end
+    def pop
+        pos(false) { skip!(false);delete1before? }
+    end
+    def shift
+        pos(true) { skip!(true);delete1after? }
+    end
+    def first
+        pos(true) { skip!(true);read1next }
+    end
+    def last
+        pos(false) { skip!(false);read1prev }
+    end
 
     # Provides random access for the cursor like what is in Array/String.
     # +index+ can be +nil+ (start at the current location) or a numeric (for #pos=).
     # +len+ can be +nil+ (get a single element) or the number of elements to
-    # #read (positive or negative).  The cursor is left at +index+ (or not
-    # moved if +nil+).
+    # #read (positive or negative).  The cursor is left at where the access
+    # started (+index+==nil : no chnage, or +index).
     def slice(index=nil,len=nil)
         self.pos = index if index
-        len.nil? ? read1after : read(len,true)
+        len ? read(len,true) : read1after
     end
     alias [] slice
     # Like #slice except the element(s) are deleted.
     def slice!(index=nil,len=nil)
         self.pos = index if index
-        len.nil? ? delete1after? : read(len,nil)
+        len ? read(len,nil) : delete1after?
     end
     # Similar to #slice except data is written.  +index+ and +len+ have the
-    # same meaning as they do in #slice.  +value+ is written using #write.
+    # same meaning as they do in #slice.  +len+ elements are deleted and +value+
+    # is inserted.
     def []=(*args) # :args: (index=nil,len=nil,value)
         value = args.slice!(-1)
         index,len = *args
         self.pos = index if index
-        if len.nil?
-            write1after!(value)
-        else
+        if len
             skip(len,nil)
-            write(value,(len.nonzero?||1.0/len)>=0,nil)
+            write(value,(len.nonzero?||1.0/len)<0,nil)
+        else
+            write1after!(value)
         end
         value
     end
@@ -690,7 +880,7 @@ class Cursor
     # #scan_until(+terminator+) instead of using a single element.
     # The cursor will be left at the end (or beginning if +reverse+).
     # nil is returned (or the break value if the code does a break).
-    def each(index=+0.0,reverse=false,terminator=nil,&code) # :yield: value
+    def each(index=0,reverse=false,terminator=nil,&code) # :yield: value
         self.pos = index if index
         continue = true
         if terminator.nil?
@@ -713,7 +903,7 @@ class Cursor
     # When the code returns +nil+ the element/sequence will be deleted.
     # Accepts the same enhancements as #each does.
     # nil is returned (or the break value if the code does a break).
-    def collect!(index=+0.0,reverse=false,terminator=nil,&code) # :yield: value
+    def collect!(index=0,reverse=false,terminator=nil,&code) # :yield: value
         self.pos = index if index
         continue = true
         if terminator.nil?