cursor 0.8 → 0.9

data/cursor/usenext/position.rb

@@ -1,4 +1,4 @@
-# $Id: position.rb,v 1.3 2005/07/18 14:46:28 eric_mahurin Exp $
+# $Id: position.rb,v 1.4 2005/08/31 14:41:16 eric_mahurin Exp $
 
 require 'cursor'
 
@@ -15,8 +15,10 @@ class Position < Cursor::Position # :nodoc:
         end
         prop(nil,@parent.prop)
     end
-    def pos(reverse=false)
-        if reverse.nil? ? @anchor_after : reverse
+    def pos(reverse=false,&code)
+        if code
+            super
+        elsif reverse.nil? ? @anchor_after : reverse
             @pos && (@pos.to_i-@parent.size).nonzero? || -0.0
         else
             @pos || @parent.size

data/duck.rb

@@ -1,28 +1,43 @@
-# $Id: duck.rb,v 1.3 2005/07/21 15:15:38 eric_mahurin Exp $
+# $Id: duck.rb,v 1.4 2005/10/14 00:22:58 eric_mahurin Exp $
 
 class Object
-    # Return a new object that maps methods the original object to different
+    # Return a new object (starts with a #clone) that maps methods the original
+    # object to different
     # names.  The arguments are a list alternating new and old method names
     # (strings or symbols).  If an odd number (usually one) of arguments is given,
     # the last old method is assumed to be the original object itself -
     # hopefully a Proc or Method and it is used to map to the new name in the
     # new object.
     def duck(*new_old)
-        obj = Object.new
+        obj = clone
+        0.step(new_old.size-1,2) { |i|
+            old = new_old[i+1]
+            new_old[i+1] = old ? begin
+                self.method(old)
+            rescue
+                old # assume old is a Proc/Method
+            end : lambda(&self)
+        }
         klass = (class << obj;self;end)
-        until new_old.empty?
-            new,old = new_old.slice!(0,2)
-            klass.__send__(:define_method,new,&(old ? self.method(old) : self))
-        end
+        0.step(new_old.size-1,2) { |i|
+            klass.__send__(:define_method,new_old[i],&new_old[i+1])
+        }
         obj
     end
-    # Return a new object that maps a hash of name=>proc to the methods of the
-    # object.
-    def self.duck(methods)
-        obj = self.new
+    # Same as #duck except it modifies and returns self rather than a #clone.
+    def duck!(*new_old)
+        obj = self
+        0.step(new_old.size-1,2) { |i|
+            old = new_old[i+1]
+            new_old[i+1] = old ? begin
+                self.method(old)
+            rescue
+                old # assume old is a Proc/Method
+            end : lambda(&self)
+        }
         klass = (class << obj;self;end)
-        methods.each { |name,proc|
-            klass.__send__(:define_method,name,&proc)
+        0.step(new_old.size-1,2) { |i|
+            klass.__send__(:define_method,new_old[i],&new_old[i+1])
         }
         obj
     end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: cursor
 version: !ruby/object:Gem::Version 
-  version: "0.8"
-date: 2005-07-21
+  version: "0.9"
+date: 2005-10-13
 summary: external iterator API
 require_paths: 
   - "."
@@ -28,7 +28,6 @@ authors:
   - Eric Mahurin
 files: 
   - cursor.rb
-  - regexp_cursor.rb
   - weakrefset.rb
   - duck.rb
   - cursor/position.rb

data/regexp_cursor.rb

@@ -1,50 +0,0 @@
-# $Id: regexp_cursor.rb,v 1.2 2005/07/21 15:20:48 eric_mahurin Exp $
-
-require 'strscan'
-
-class Regexp
-    # Scan the cursor for the regexp and return what was matched or +nil+ for
-    # a mismatch.  The regexp will be implicitly anchored at the cursor location.
-    # Unless +hold+ or a mismatch, the cursor will be advanced to a point right
-    # after the match.  +len+ should be the max length that the regexp can match or
-    # zero to look at everything.  A negative +len+ (including -0.0) will scan
-    # the cursor in reverse.
-    def scan_cursor(cursor,len=0,hold=false)
-        reverse = (len.nonzero?||1.0/len)<0
-        buffer = len.zero? ? cursor.read!(reverse,true,"") : cursor.read(len,true,"")
-        buffer or return
-        scanner = StringScanner.new(buffer)
-        ret = scanner.scan(self)
-        if ret
-            len = scanner.pos
-            cursor.skip(reverse ? -len : +len) if !hold
-        end
-        ret
-    end
-    # Scan the cursor until it matches the regexp and what was scanned up to and
-    # including the match or +nil+ if it never matched.
-    # Unless +hold+ or a mismatch, the cursor will be advanced to a point right
-    # after the match.  +len+ should be the start buffer size of what to look at
-    # from the cursor or zero to look at everything at once.  A negative +len+
-    # (including -0.0) will scan the cursor in reverse.
-    def scan_cursor_until(cursor,len=1,hold=false)
-        reverse = (len.nonzero?||1.0/len)<0
-        buffer = ""
-        scanner = StringScanner.new(buffer)
-        if len.zero?
-            buffer = cursor.read!(reverse,true,buffer) or return
-            ret = scanner.scan_until(self)
-        else
-            while cursor.read(len,false,buffer)
-                ret = scanner.scan_until(self) and break(ret)
-                len *= 2
-            end
-            len = buffer.length
-        end
-        len = (hold ? 0 : scanner.pos)-len
-        cursor.skip(reverse ? -len : +len) if len.nonzero?
-        ret
-    end
-end
-
-