cursor 0.6 → 0.8

data/cursor/usenext/position.rb

@@ -0,0 +1,71 @@
+# $Id: position.rb,v 1.3 2005/07/18 14:46:28 eric_mahurin Exp $
+
+require 'cursor'
+
+class Cursor
+module UseNext
+class Position < Cursor::Position # :nodoc:     
+    def initialize(parent,reverse=false)
+        @parent = parent
+        @anchor_after = reverse
+        if @anchor_after && !@parent.skip1after
+            @pos = nil                              
+        else
+            @pos = @parent.__send__(:pos)
+        end
+        prop(nil,@parent.prop)
+    end
+    def pos(reverse=false)
+        if reverse.nil? ? @anchor_after : reverse
+            @pos && (@pos.to_i-@parent.size).nonzero? || -0.0
+        else
+            @pos || @parent.size
+        end
+    end
+    def pos=(p)
+        if (p.nonzero?||1.0/p)<0
+            @pos = p.to_i.nonzero?
+            @pos += @parent.size if @pos
+            @anchor_after = true
+            p
+        else
+            @anchor_after = false
+            @pos = p
+        end
+    end
+    protected
+    def _deletion(pos,len=1,reverse=false,eof=nil)
+        if @pos
+            if @pos==pos
+                @anchor_after = false
+            elsif @pos>pos
+                @pos -= len
+                if @pos<pos
+                    @pos = pos
+                    if reverse
+                        @anchor_after=true
+                        eof = !@parent.skip1after if eof.nil?
+                        @pos = nil if eof
+                    else
+                        @anchor_after = false
+                    end
+                elsif @pos==pos && !@anchor_after
+                    @anchor_after = true
+                    eof = !@parent.skip1after if eof.nil?
+                    @pos = nil if eof
+                end
+            end
+        end
+        eof
+    end
+    def _insertion(pos,len=1,dummy=nil)
+        if @pos and @pos>=pos+(@anchor_after ? 0 : 1)
+            @pos += len
+        end
+        nil
+    end
+end
+end
+end
+
+

data/cursor/useposition.rb

@@ -0,0 +1,42 @@
+# $Id: useposition.rb,v 1.10 2005/07/15 22:34:42 eric_mahurin Exp $
+
+;
+
+class Cursor
+# Mixin for derived classes to use #position as the basis for After/Before methods.
+# See Cursor for a description of these methods.
+module UsePosition # :nodoc:
+    def read1after
+        position(false) { read1next }
+    end
+    def read1before
+        position(true) { read1prev }
+    end
+    def skip1after 
+        position(false) { skip1next }
+    end
+    def skip1before
+        position(true) { skip1prev }
+    end
+    def write1after(v)
+        position(false) { write1next(v) }
+    end
+    def write1before(v)
+        position(true) { write1prev(v) }
+    end
+    def write1after!(v)
+        position(false) { write1next!(v) }
+    end
+    def write1before!(v)
+        position(true) { write1prev!(v) }
+    end
+    def write1after?(v)
+        position(false) { write1next?(v) }
+    end
+    def write1before?(v)
+        position(true) { write1prev?(v) }
+    end
+end
+end
+
+

data/cursor/usereadwrite.rb

@@ -0,0 +1,126 @@
+# $Id: usereadwrite.rb,v 1.13 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, #read1prev, #write1next, #write1prev,
+# #_delete1after?, #delete1before?, #_insert1before, #_insert1after.
+# See Cursor for a description of these methods.
+module UseReadWrite # :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 write1next!(v)
+        write1next(v) || insert1before(v)
+    end
+    def write1prev!(v)
+        write1prev(v) || insert1after(v)
+    end
+
+    def skip1next
+        read1next.nil? ? nil : true
+    end
+    def skip1prev
+        read1prev.nil? ? nil : true
+    end
+    def write1next?(v)
+        v0 = read1after
+        v0.nil? || write1next(v)
+        v0
+    end
+    def write1prev?(v)
+        v0 = read1before
+        v0.nil? || write1prev(v)
+        v0
+    end
+
+    def read1after
+        v0 = read1next
+        v0.nil? || skip1prev
+        v0
+    end
+    def read1before
+        v0 = read1prev
+        v0.nil? || skip1next
+        v0
+    end
+    def skip1after
+        skip1next && skip1prev
+    end
+    def skip1before
+        skip1prev && skip1next
+    end
+    def write1after(v)
+        write1next(v) && skip1prev
+    end
+    def write1after!(v)
+        write1next!(v)
+        skip1prev
+    end
+    def write1before(v)
+        write1prev(v) && skip1next
+    end
+    def write1before!(v)
+        write1prev!(v)
+        skip1next
+    end
+    def write1after?(v)
+        v0 = write1next?(v)
+        v0.nil? || skip1prev
+        v0
+    end
+    def write1before?(v)
+        v0 = write1prev?(v)
+        v0.nil? || skip1next
+        v0
+    end
+    def scan1next(v)
+        v0 = read1next
+        (v0.nil? || v==v0) ? v0 : (skip1prev;nil)
+    end
+    def scan1prev(v)
+        v0 = read1prev
+        (v0.nil? || v==v0) ? v0 : (skip1next;nil)
+    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
+end
+end
+
+

data/duck.rb

@@ -0,0 +1,31 @@
+# $Id: duck.rb,v 1.3 2005/07/21 15:15:38 eric_mahurin Exp $
+
+class Object
+    # Return a new object 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
+        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
+        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
+        klass = (class << obj;self;end)
+        methods.each { |name,proc|
+            klass.__send__(:define_method,name,&proc)
+        }
+        obj
+    end
+end
+
+

data/regexp_cursor.rb

@@ -0,0 +1,50 @@
+# $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
+
+

data/weakrefset.rb

@@ -0,0 +1,130 @@
+# $Id: weakrefset.rb,v 1.5 2005/06/29 15:22:38 eric_mahurin Exp $
+
+# WeakRefSet implements an unordered collection of weak references to objects.
+# These references don't prevent garbage collection on these objects.  As these
+# objects are thrown away so does their entry in a WeakRefSet.  Immmediate
+# objects are not handled by this class (and wouldn't be useful).
+class WeakRefSet
+    include Enumerable
+    private
+    def finalizer(id)
+        @ids.delete(id >> 1)
+    end
+    public
+    # create a new WeakRefSet from an optional Enumerable (of objects)
+    # which is optionally processed through a block
+    def initialize(enum=[],&block) # :yield: obj
+        replace(enum.collect(&block))
+    end
+    # add a weak reference to the set
+    def add(obj)
+        @ids[obj.__id__ >> 1] = true
+        ObjectSpace.define_finalizer(obj,method(:finalizer))
+        self
+    end
+    alias << add
+    # iterate over remaining valid objects in the set
+    def each(&block)
+        @ids.each_key { |id|
+            begin
+                o = ObjectSpace._id2ref(id << 1)
+            rescue RangeError
+                next
+            end
+            block.call(o) if @ids.include?(id)
+        }
+        nil
+    end
+    # clear the set (return self)
+    def clear
+        @ids = {}
+        self
+    end
+    # merge some more objects into the set (return self)
+    def merge(enum)
+        enum.each { |obj| add(obj) }
+        self
+    end
+    # replace the objects in the set (return self)
+    def replace(enum)
+        clear
+        merge(enum)
+        self
+    end
+    # delete an object in the set (return self)
+    def delete(obj)
+        @ids.delete(obj.__id__ >> 1)
+        self
+    end
+    # delete an object in the set (return self or nil if nothing deleted)
+    def delete?(obj)
+        @ids.delete(obj.__id__ >> 1)&&self
+    end
+    # any objects in the set still valid?
+    def empty?
+        each { return(false) }
+        true
+    end
+    # is this object in the set?
+    def include?(obj)
+        @ids.include?(obj.__id__ >> 1)
+    end
+    alias member? include?
+    # return a string showing the object classes and ids
+    def inspect
+        s = sprintf("#<#{self.class}:0x%x {",__id__ << 1)
+        s += collect { |obj| obj.inspect }.join(", ")
+        s + "}>"
+    end
+    # remove some objects from the set (return self)
+    def subtract(enum)
+        enum.each { |obj| delete(obj) }
+        self
+    end
+    # number of objects in the set still valid
+    def size
+        n=0
+        each { n+=1 }
+        n
+    end
+    alias length size
+end
+
+# :stopdoc:
+
+if __FILE__==$0
+    require 'benchmark'
+    MyString = Class.new(String)
+    weakrefs = WeakRefSet.new
+    $stdout.sync=true
+    obj = nil
+    times = Benchmark.measure {
+    10000.times { |i|
+        print(".")
+        obj = MyString.new("X"*rand(i+1))
+        weakrefs << obj
+        weakrefs.each { |o|
+            MyString==o.class or raise
+        }
+        weakrefs.include?(obj) or raise
+        if rand(10).zero?
+            weakrefs.delete?(obj) or raise
+            !weakrefs.include?(obj) or raise
+        end
+    }
+    }
+    puts
+    p(weakrefs)
+    p((weakrefs.size.nonzero? or raise))
+    weakrefs.empty? and raise
+    GC.start
+    p(weakrefs)
+    p(weakrefs.clear)
+    weakrefs.size.zero? or raise
+    weakrefs.empty? or raise
+    puts(times)
+end
+
+# :stopdoc:
+
+