cursor 0.6 → 0.8

data/cursor/test_circulars.rb

@@ -0,0 +1,87 @@
+#!/bin/env ruby
+#
+# $Id: test_circulars.rb,v 1.10 2005/07/21 15:15:38 eric_mahurin Exp $
+#
+# Run this to test circular cursors.
+# Here is a list of the optional arguments:
+#
+#  <iterations> : approximate number of times to test each method
+#  <seed>       : seed for random number generation (0: none)
+#  <classRE>    : regular expression for the classes to test ('': all)
+#  <methodRE>   : regular expression for the methods to test ('': all)
+#  <flags>      : Combination of bits for various flags
+#    1 : disable testing of positions
+#    2 : only test with strings/characters
+#
+# All of the standar Test::Unit auto runner options apply.  The --verbose=<level>
+# option is especially useful.  Here are the various levels:
+#
+#  s[ilent]   : don't display anything
+#  p[rogress] : show a progress bar.  Upon fail, show the test and seed.
+#  n[ormal]   : show each method (and args) tested
+#  v[erbose]  : show each method and the object state (inspect)
+#
+# If you want to see a demo for a particular method, usually a good command
+# line would be something like this:
+#
+#  ruby cursor/test_circulars.rb --verbose=v 10 0 Indexed '^(<method>|close)$'
+
+require 'cursor/test'
+require 'cursor/circular'
+require 'cursor/indexed'
+require 'cursor/circular/indexed'
+require 'cursor/circular/shifting'
+require 'cursor/circular/split'
+require 'cursor/circular/linked'
+
+# :stopdoc:
+
+class Cursor
+class Test
+class Circulars < Test
+    def self.suite
+        @reject = /^(scan_until|modify|each|collect!|map!)$/
+        $0==__FILE__ ? super(*ARGV) : super()
+    end
+    def self.seed(before,after)
+        cursors = [
+            Cursor::Circular::Indexed.new(before+after,before.size),
+            Cursor::Circular::Indexed.new(after+before,0),
+            Cursor::Circular::Shifting.new(after+before,after.size),
+            Cursor::Circular::Split.new(before.clone,after.reverse),
+            Cursor::Circular::Linked.new(before.clone,after.reverse),
+            Cursor::Circular.new(Cursor::Indexed.new(before+after,before.size)),
+        ]
+        if rand(2).zero?
+            @use_positions = false
+            cursors << Cursor::Circular.new(
+                    Cursor::Indexed.new(before+after,before.size)
+                ).position
+        else
+            @use_positions = @flags[0].zero?
+        end
+        cursors
+    end
+    def self.plant
+        @characters = rand(2).zero?
+        super
+    end
+    def self.elements
+        @characters ? [?\n,?\0,?0] : [false,"",[]]
+    end
+    def self.empty
+        @characters&&rand(2).zero? ? "" : []
+    end
+    def self.reject(name,*args,&block)
+        case name
+        when :position!  then !@use_positions && args[0].nil?
+        when :position?  then !@use_positions && args[0].nil? && block.nil?
+        end
+    end
+end
+end
+end
+
+# :startdoc:
+
+

data/cursor/test_cursors.rb

@@ -0,0 +1,112 @@
+#!/bin/env ruby
+#
+# $Id: test_cursors.rb,v 1.6 2005/07/21 15:15:38 eric_mahurin Exp $
+#
+# Run this to test non-circular cursors.
+# Here is a list of the optional arguments:
+#
+#  <iterations> : approximate number of times to test each method
+#  <seed>       : seed for random number generation (0: none)
+#  <classRE>    : regular expression for the classes to test ('': all)
+#  <methodRE>   : regular expression for the methods to test ('': all)
+#  <flags>      : Combination of bits for various flags
+#    1 : disable testing of positions
+#    2 : only test with strings/characters
+#
+# All of the standar Test::Unit auto runner options apply.  The --verbose=<level>
+# option is especially useful.  Here are the various levels:
+#
+#  s[ilent]   : don't display anything
+#  p[rogress] : show a progress bar.  Upon fail, show the test and seed.
+#  n[ormal]   : show each method (and args) tested
+#  v[erbose]  : show each method and the object state (inspect)
+#
+# If you want to see a demo for a particular method, usually a good command
+# line would be something like this:
+#
+#  ruby cursor/test_cursors.rb --verbose=v 10 0 Indexed '^(<method>|close)$'
+
+require 'cursor/test'
+require 'cursor/indexed'
+require 'cursor/shifting'
+require 'cursor/split'
+require 'cursor/linked'
+require 'cursor/buffered'
+require 'cursor/lined'
+require 'cursor/reversed'
+require 'cursor/usedeleteinsert'
+require 'cursor/usereadwrite'
+require 'cursor/usenext'
+require 'cursor/useposition'
+require 'stringio'
+require 'cursor/io'
+
+# :stopdoc:
+
+class Cursor
+class Test
+class Cursors < Test
+    def self.suite
+        @reject = /to_s/ # because of Cursor::Lined
+        $0==__FILE__ ? super(*ARGV) : super()
+    end
+    def self.seed(before,after)
+        cursors = [
+            (before+after).to_cursor(before.size),
+            Cursor::Shifting.new(after+before,after.size),
+            Cursor::Split.new(before.clone,after.reverse),
+            Cursor::Linked.new(before.clone,after.reverse),
+            Cursor.new(Cursor::Indexed.new(before+after,before.size)),
+            Cursor.new(Cursor::Indexed.new(before+after,before.size)).extend(UseDeleteInsert),
+            Cursor.new(Cursor::Indexed.new(before+after,before.size)).extend(UseReadWrite),
+            Cursor.new(Cursor::Indexed.new(before+after,before.size)).extend(UseNext),
+            Cursor.new(Cursor::Indexed.new(before+after,before.size)).extend(UsePosition),
+            Cursor::Buffered.new(
+                Cursor::Indexed.new(after.clone),
+                Cursor::Indexed.new(before.clone,before.size),
+                before.size
+            ),
+            Cursor::Lined.new(Cursor::Indexed.new(before+after,before.size)),
+            Cursor::Reversed.new(Cursor::Indexed.new((before+after).reverse,after.size)),
+        ]
+        if String===before
+            io=StringIO.new(before+after)
+            io.pos=before.size
+            cursors << io.to_cursor
+            cursors << Cursor::Buffered.new(
+                StringIO.new(after),
+                Cursor::Indexed.new(before.clone,before.size),
+                before.size
+            )
+        end
+        if rand(2).zero?
+            @use_positions = false
+            cursors << Cursor.new(Cursor::Indexed.new(before+after,before.size)).position
+        else
+            @use_positions = @flags[0].zero?
+        end
+        cursors
+    end
+    def self.plant
+        @characters = @flags[1].nonzero?||rand(2).zero?
+        super
+    end
+    def self.elements
+        @characters ? [?\n,?\0,?0] : [false,"",[]]
+    end
+    def self.empty
+        @characters&&(@flags[1].nonzero?||rand(2).zero?) ? "" : []
+    end
+    def self.reject(name,*args,&block)
+        case name
+        when :position! then !@use_positions && args[0].nil?
+        when :position? then !@use_positions && args[0].nil? && block.nil?
+        end
+    end
+end
+end
+end
+
+# :startdoc:
+
+

data/cursor/usedeleteinsert.rb

@@ -0,0 +1,150 @@
+# $Id: usedeleteinsert.rb,v 1.11 2005/07/15 22:34:42 eric_mahurin Exp $
+
+;
+
+class Cursor
+# Mixin for derived classes to use these methods as the basis for others:
+# #_delete1after?, #delete1before?, #_insert1before, #_insert1after.
+# See Cursor for a description of these methods.
+module UseDeleteInsert # :nodoc:
+    protected
+    def _delete1after
+        _delete1after?.nil? ? nil : true
+    end
+    def _delete1before
+        _delete1before?.nil? ? nil : true
+    end
+    public
+    def delete1after
+        _delete1after && (@positions && _adjust_delete;true)
+    end
+    def delete1before
+        _delete1before && (@positions && _adjust_delete;true)
+    end
+    def delete1after?
+        v0 = _delete1after?
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def delete1before?
+        v0 = _delete1before?
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def insert1before(v)
+        @positions && _adjust_insert
+        _insert1before(v)
+    end
+    def insert1after(v)
+        @positions && _adjust_insert
+        _insert1after(v)
+    end
+    
+    def read1next
+        v0 = _delete1after?
+        v0.nil? || _insert1before(v0)
+        v0
+    end
+    def read1prev
+        v0 = _delete1before?
+        v0.nil? || _insert1after(v0)
+        v0
+    end
+    def read1after
+        v0 = _delete1after?
+        v0.nil? || _insert1after(v0)
+        v0
+    end
+    def read1before
+        v0 = _delete1before?
+        v0.nil? || _insert1before(v0)
+        v0
+    end
+    def skip1next
+        v0 = _delete1after?
+        v0.nil? ? nil : _insert1before(v0)
+    end
+    def skip1prev
+        v0 = _delete1before?
+        v0.nil? ? nil : _insert1after(v0)
+    end
+    def skip1after
+        v0 = _delete1after?
+        v0.nil? ? nil : _insert1after(v0)
+    end
+    def skip1before
+        v0 = _delete1before?
+        v0.nil? ? nil : _insert1before(v0)
+    end
+    def write1next(v)
+        _delete1after && _insert1before(v)
+    end
+    def write1prev(v)
+        _delete1before && _insert1after(v)
+    end
+    def write1after(v)
+        _delete1after && _insert1after(v)
+    end
+    def write1before(v)
+        _delete1before && _insert1before(v)
+    end
+    def write1next!(v)
+        _delete1after ? _insert1before(v) : insert1before(v)
+    end
+    def write1prev!(v)
+        _delete1before ? _insert1after(v) : insert1after(v)
+    end
+    def write1after!(v)
+        _delete1after ? _insert1after(v) : insert1after(v)
+    end
+    def write1before!(v)
+        _delete1before ? _insert1before(v) : insert1before(v)
+    end
+    def write1next?(v)
+        v0 = _delete1after?
+        v0.nil? || _insert1before(v)
+        v0
+    end
+    def write1prev?(v)
+        v0 = _delete1before?
+        v0.nil? || _insert1after(v)
+        v0
+    end
+    def write1after?(v)
+        v0 = _delete1after?
+        v0.nil? || _insert1after(v)
+        v0    
+    end
+    def write1before?(v)
+        v0 = _delete1before?
+        v0.nil? || _insert1before(v)
+        v0
+    end
+    def scan1next(v)
+        v0 = _delete1after?
+        v0.nil? ? nil :
+        (v!=v0) ? (_insert1after(v0);nil) :
+        (_insert1before(v0);v0)
+    end
+    def scan1prev(v)
+        v0 = _delete1before?
+        v0.nil? ? nil :
+        (v!=v0) ? (_insert1before(v0);nil) :
+        (_insert1after(v0);v0)
+    end
+    def modify1next(r)
+        v0 = _delete1after?
+        v0.nil? ? nil :
+        (v = r[v0]).nil? ? (_insert1after(v0);nil) :
+        (_insert1before(v);v0)
+    end
+    def modify1prev(r)
+        v0 = _delete1before?
+        v0.nil? ? nil :
+        (v = r[v0]).nil? ? (_insert1before(v0);nil) :
+        (_insert1after(v);v0)
+    end
+end
+end
+
+

data/cursor/usenext.rb

@@ -0,0 +1,145 @@
+# $Id: usenext.rb,v 1.12 2005/07/15 22:34:42 eric_mahurin Exp $
+
+;
+
+class Cursor
+# Mixin for derived classes to use these methods as the basis for others:
+# #read1next, #write1next, #skip1prev,
+# #_delete1after?, #_insert1before.
+# See Cursor for a description of these methods.
+# You may also override methods with the same name as above except the "1" is
+# replaced with "_".  These operate on sequences rather than single elements.
+module UseNext # :nodoc:
+    protected
+    def _delete1after
+        _delete1after?.nil? ? nil : true
+    end
+    public
+    def delete1after
+        _delete1after && (@positions && _adjust_delete;true)
+    end
+    def delete1after?
+        v0 = _delete1after?
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def insert1before(v)
+        @positions && _adjust_insert
+        _insert1before(v)
+    end
+    def write1next!(v)
+        write1next(v) || _insert1before(v)
+    end
+
+    def delete1before
+        skip1prev && delete1after
+    end
+    def delete1before?
+        skip1prev && delete1after?
+    end
+    def insert1after(v)
+        insert1before(v)
+        skip1prev
+    end
+                                                     
+    def skip1next
+        read1next.nil? ? nil : true
+    end
+    def read1after
+        v0 = read1next
+        v0.nil? || skip1prev
+        v0
+    end
+    def write1after(v)
+        write1next(v) && skip1prev
+    end
+    def write1after!(v)
+        write1next!(v)
+        skip1prev
+    end
+
+    def read1before
+        skip1prev && read1next
+    end
+    def write1before(v)
+        skip1prev && write1next(v)
+    end
+    def write1before!(v)
+        skip1prev ? write1next(v) : insert1before(v)
+    end
+
+    def skip1after
+        skip1next && skip1prev
+    end
+    def skip1before
+        skip1prev && skip1next
+    end
+
+    def read1prev
+        skip1prev && read1after
+    end
+    def write1prev(v)
+        skip1prev && write1after(v)
+    end
+    def write1prev!(v)
+        skip1prev ? write1after(v) : insert1after(v)
+    end
+    def write1next?(v)
+        v0 = read1after
+        v0.nil? || write1next(v)
+        v0
+    end
+    def write1prev?(v)
+        v0 = read1before
+        v0.nil? || write1prev(v)
+        v0
+    end
+    def write1after?(v)
+        v0 = read1after
+        v0.nil? || write1after(v)
+        v0
+    end
+    def write1before?(v)
+        v0 = read1before
+        v0.nil? || write1before(v)
+        v0
+    end
+    def scan1next(v)
+        v0 = read1next
+        (v0.nil? || v==v0) ? v0 : (skip1prev;nil)
+    end
+    def scan1prev(v)
+        v0 = read1before
+        (v0.nil? || v!=v0) ? nil : (skip1prev;v0)
+    end
+    def modify1next(r)
+        v0 = read1after
+        (v0.nil? || (v = r[v0]).nil?) ? nil : (write1next(v);v0)
+    end
+    def modify1prev(r)
+        v0 = read1before
+        (v0.nil? || (v = r[v0]).nil?) ? nil : (write1prev(v);v0)
+    end
+    def position(reverse=false,&code) # :yield:
+        p = Position.new(self,reverse)
+        (@positions||=WeakRefSet.new) << p
+        if code
+            begin
+                code[]
+            ensure
+                begin
+                    self.position = p
+                ensure
+                    p.close
+                end
+            end
+        else
+            p
+        end
+    end
+end
+end
+
+require 'cursor/usenext/position'
+
+