sequence 0.2.0 → 0.2.1

data/History.txt

@@ -0,0 +1,27 @@
+=== 0.2.1 / 2009-01-07
+* 1 Minor Enhancement:
+  * WeakRefSet now conforms to Set's api and tests more closely.
+
+* 1 Bugfix:
+  * fixed errors in MatchData when matching against a Regexp with an 
+    optional capture that didn't capture anything .
+
+=== 0.2.0 / 2008-08-28
+
+* 2 Major Enhancements:
+  * all tests now pass
+  * many small fixes in List; List is believed to actually work in all cases!
+
+* 2 Minor Enhancements:
+  * cleanup of Indexed#scan*
+  * try not to use out of bounds indexes (including negative)
+  * more List test data created by wrapping existing data in List(s)
+  * enabled some tests which had been failing
+
+=== 0.1.0 / 2006-10-05
+
+* 1 major enhancement
+
+  * Birthday!
+
+

data/Manifest.txt

@@ -21,7 +21,7 @@ lib/sequence/stringlike.rb
 lib/sequence/subseq.rb
 lib/sequence/usedata.rb
 lib/sequence/version.rb
-lib/weakrefset.rb
+lib/sequence/weakrefset.rb
 test/test.rb
 test/test_all.rb
 test/test_changes.rb
@@ -34,3 +34,4 @@ Manifest.txt
 README.txt
 COPYING
 GPL
+History.txt

data/README.txt

@@ -49,7 +49,7 @@ No unit tests at all for array-like sequences
 
 == INSTALL:
 
-* Just run: gem install sequence
+* Simply: gem install sequence
 
 == LICENSE:
 

data/Rakefile

@@ -5,13 +5,20 @@ require 'hoe'
 require 'lib/sequence/version.rb'
  
  
- 
+ if $*==["test"]
+  #hack to get 'rake test' to stay in one process
+  #which keeps netbeans happy
+  $:<<"lib"
+  require "test/test_all.rb"
+  Test::Unit::AutoRunner.run
+  exit
+end
  
    Hoe.new("sequence", Sequence::VERSION) do |_|
 
      _.author = "Caleb Clausen"
      _.email = "sequence-owner @at@ inforadical .dot. net"
-     _.url = "http://sequence.rubyforge.org/"
+     _.url = [ "http://sequence.rubyforge.org/", "http://rubyforge.org/projects/sequence"]
      _.summary = "A single api for reading and writing sequential data types."
      _.description = <<-END
 A unified wrapper api for accessing data in Strings, Arrays, Files, IOs, 

data/lib/sequence.rb

@@ -10,8 +10,9 @@
 
 require "forwardable"
 require 'assert'
-require 'weakrefset'
 require 'sequence/version'
+require 'sequence/weakrefset'
+
 
 =begin todo
 
@@ -30,6 +31,8 @@ match/matchback
 
 class Sequence
 
+#  WeakRefSet=::Set
+#  warn "warning: sequence uses Set instead of WeakRefSet; memory leak results"
 
     include Comparable
     include Enumerable
@@ -81,13 +84,6 @@ class Sequence
     end
     
 
-    # Return an empty object used for returning a sequence of elements.
-    # The only method required of this object is << (append to the sequence).
-    #usually [] or ""
-    def new_data
-        data_class.new
-    end
-    
     # attempt to read up to +len+ elements. the  position is left just after the data read.
     # #read may return less than the whole requested amount if less data than requested in 
     #+len+ is available. This can happen at end of file or if more data is simply unavailable
@@ -407,8 +403,8 @@ class Sequence
     #  numeric positions and also be tested
     def position?(p)
       case p
-      when Integer: (-size..size)===p 
-      when Position: equal? p.data
+      when Integer; (-size..size)===p 
+      when Position; equal? p.data
       else equal? p
       end
     end
@@ -443,6 +439,7 @@ class Sequence
       instance_variables.empty?
     end
 
+=begin who needs it?
     # Compare +other+ (a Position or Integer) to the current position.  return +1
     # for the self is after, -1 for self being before, and 0 for it being at
     # same location, nil (or false) if other is not a position of self.
@@ -451,6 +448,8 @@ class Sequence
         elsif position?(other) then pos<=>other.pos
         end
     end
+=end
+
     #if passed an integer arg, return a new position decreased by len. if passed
     # a position, return the distance (number
     # or elements) from +other+ (a #position) to +self+.  This can be +, -, or 0.

data/lib/sequence/arraylike.rb

@@ -2,6 +2,10 @@
 # Distributed under the terms of Ruby's license.
 class Sequence
   module ArrayLike
+    # Return an empty object used for returning a sequence of elements.
+    # The only method required of this object is << (append to the sequence).
+    #usually [] or ""
+    def new_data; [] end
     def data_class; Array end
     def like; ArrayLike end
 

data/lib/sequence/buffered.rb

@@ -43,46 +43,6 @@ class Buffered < Sequence
     def new_data
         @input.new_data
     end
-=begin
-    protected
-    def _delete1after?
-        v0 = @buffer.delete1after?
-        v0.nil? && @input && (v0 = @input.read(1)) && (v0 = v0[0])
-        v0
-    end
-    def _delete1before?
-        v0 = @buffer.delete1before?
-        v0.nil? && @output_pos>0 && (@output_pos -= 1;v0 = @output.read(-1)) && (v0 = v0[0])
-        v0
-    end
-    def _insert1before(v)
-        if not position?
-            len = @buffer.move!(true)
-            if @output
-                value = @buffer.read(len,nil)
-                value << v
-                @output.write(value)
-            else
-                @buffer.read(len,nil) if len
-            end
-            @output_pos += (len||0)+1
-        else
-            @buffer.insert1before(v)
-        end
-        true
-    end
-    def _insert1after(v)
-        @buffer.insert1after(v)
-    end
-    public
-    def close
-        if @output
-            @buffer.move!(true)
-            value = @buffer.read!(false) and @output.write(value)
-        end
-        super
-    end
-=end 
     def _default_maxmatchlen; @buffer_size/2 end
 
     attr :pos

data/lib/sequence/io.rb

@@ -36,7 +36,7 @@ class IO < Sequence
 
   undef pos=, _pos=, position, position?, holding, holding?, holding!, readback, readback1
   undef readahead, readbehind, readahead1, readbehind1, write#, write1
-  undef goto, move, move!, subseq, reversed, <=>, +, -, succ, pred, begin, end
+  undef goto, move, move!, subseq, reversed, +, -, succ, pred, begin, end
   undef begin!, end!,  first, last, slice, [], modify, []=
 
 
@@ -99,4 +99,4 @@ class IO < Sequence
     end
   end
 end
-end
+end

data/lib/sequence/ofobjectmethods.rb

@@ -2,7 +2,7 @@
 # Distributed under the terms of Ruby's license.
 require 'sequence'
 require 'sequence/indexed'
-reuqire 'sequence/functional'
+require 'sequence/functional'
 require 'set'
 
 
@@ -84,4 +84,4 @@ class Sequence
       return nil
     end
   end
-end
+end

data/lib/sequence/stringlike.rb

@@ -4,6 +4,11 @@ require 'sequence/subseq'
 
 class Sequence
   module StringLike
+    # Return an empty object used for returning a sequence of elements.
+    # The only method required of this object is << (append to the sequence).
+    #usually [] or ""
+    def new_data; '' end
+
     def data_class; String end
     
     def like; StringLike end
@@ -218,9 +223,13 @@ class Sequence
     begins=[]
     ends=[]
     matchdata.to_a.each_with_index{|substr,i| 
-      next unless substr
-      begins<<matchdata.begin(i)+pos_adjust
-      ends<<matchdata.end(i)+pos_adjust
+      if substr
+        begins<<matchdata.begin(i)+pos_adjust
+        ends<<matchdata.end(i)+pos_adjust
+      else
+        begins<<nil
+        ends<<nil
+      end
     }
     
     #..remove data at group indexes we added above

data/lib/sequence/version.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2006,2008  Caleb Clausen
 # Distributed under the terms of Ruby's license.
 class Sequence
-  VERSION='0.2.0'
+  VERSION='0.2.1'
 end

data/lib/sequence/weakrefset.rb

@@ -0,0 +1,336 @@
+# $Id$
+# Copyright (C) 2006,2008  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+
+#require 'yaml'
+require 'set'
+begin
+  require 'weakref'
+rescue Exception
+end
+
+# 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 Sequence
+class WeakRefSet<Set
+  include Enumerable
+  # create a new WeakRefSet from an optional Enumerable (of objects)
+  # which is optionally processed through a block
+  def initialize(items=nil,&block) # :yield: obj
+    items=[] if items.nil?
+    raise ArgumentError unless items.respond_to? :each
+    items=items.map(&block) if block
+    replace(items)
+  end
+  alias initialize_copy initialize
+  class<<self
+    def [] *items
+      new(items)
+    end
+  end
+
+  private
+  def finalizer(id)
+    @ids.delete(id)
+  end
+
+sss="a string"
+if WeakRef.respond_to? :create_weakref   and  #rubinius
+   WeakRef.create_weakref(sss).at(0).equal?(sss)
+
+  def ref o
+    WeakRef.create_weakref o
+  end
+  def unref id
+    id.at(0)
+  rescue Exception
+    return nil
+  end
+
+else
+
+  def ref o
+    o.__id__
+  end
+  def unref id
+    ObjectSpace._id2ref id
+  rescue RangeError
+    return nil
+  end
+end
+
+  public
+
+  # add a weak reference to the set
+  def add(obj)
+    return self if include? obj
+#        Symbol===obj || Fixnum===obj || nil==obj || true==obj || false==obj and 
+#          raise ArgumentError, "no immediates in weakrefset"
+        id=ref obj
+        case (o2=unref id) #test id for validity
+        when Fixnum; 
+          obj.equal? o2 or raise
+        when Symbol,true,false,nil;          id=obj #hopefully rare
+        else         
+          obj.equal? o2 or raise
+          ObjectSpace.define_finalizer(obj,method(:finalizer))
+        end
+        @ids[id] = true
+        self
+  end
+  alias << add
+
+  # iterate over remaining valid objects in the set
+  def each
+        @ids.each_key { |id|
+          case id
+          when Integer
+            @ids.include?(id) or next
+            o = unref(id) or next
+            #i don't know where the random symbols come from, but at least they're always symbols...
+          else
+            o=id
+          end
+#          case o
+#            when Symbol,Fixnum,true,false,nil: warn "immediate value #{o.inspect} found in weakrefset"
+#            else 
+              yield(o) 
+#          end
+        }
+        self
+  end
+
+  def to_a
+    map{|x| x}
+  end
+
+  def == other
+    return true if self.equal? other
+    other.is_a? Set and other.size==self.size and
+      all?{|x| other.include?(x) }
+  end
+  alias eql? ==
+
+  def hash
+    result=0
+    each{|x| result^=x.hash }
+    result
+  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)
+        delete?(obj)
+        self
+  end
+
+  # delete an object in the set (return self if obj was found, else nil if nothing deleted)
+  def delete?(obj)
+    x=include?(obj)
+    if x
+      fail unless  @ids.delete(ref( obj ))||@ids.delete(obj)
+      return self
+    end
+  end
+
+  # Deletes every element of the set for which block evaluates to
+  # true, and returns self.
+  def delete_if
+    to_a.each { |o| delete(o) if yield(o) }
+    self
+  end
+
+  # is this object in the set?
+  def include?(obj)
+    any?{|x| obj==x}
+  end
+  alias member? include?
+
+
+  # return a human-readable string showing the set
+  def inspect
+    #unless $weakrefset_verbose_inspect 
+    #  return sprintf('#<%s:0x%x {...}>', self.class.name, object_id)
+    #end
+    ids = (Thread.current[:__weakrefset__inspect_key__] ||= [])
+
+    if ids.include?(object_id)
+      return sprintf('#<%s: {...}>', self.class.name)
+    end
+
+    begin
+      ids << object_id
+      return sprintf('#<%s: {%s}>', self.class.name, to_a.inspect[1..-2])
+    ensure
+      ids.pop
+      Thread.current[:__weakrefset__inspect_key__].empty? and
+        Thread.current[:__weakrefset__inspect_key__]=nil
+    end
+  end
+
+if false      #this is broken; emits yaml for a hash. 
+
+  YAML::add_domain_type( "inforadical.net,2005", "object:WeakRefSet" ) do |type, val|
+       WeakRefSet.new( *val["items"] )
+  end
+
+  def is_complex_yaml?; true  end
+  
+  def to_yaml_type; "!inforadical.net,2005/object:WeakRefSet" end
+  
+  alias to_yaml_properties to_a
+  
+  def to_yaml( opts = {} )
+    YAML::quick_emit( object_id, opts ) { |out|
+      out.map( to_yaml_type ) { |map|
+        map.add( "items", to_yaml_properties)
+      }
+    }
+  end
+end
+  
+  # remove some objects from the set (return self)
+  def subtract(enum)
+        enum.each { |obj| delete(obj) }
+        self
+  end
+
+  # Returns a new set containing elements exclusive between the set
+  # and the given enumerable object.  (set ^ enum) is equivalent to
+  # ((set | enum) - (set & enum)).
+  def ^(enum)
+    enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
+    n = self.class.new(enum)
+    each { |o| if n.include?(o) then n.delete(o) else n.add(o) end }
+    n
+  end
+
+  # any objects in the set still valid?
+  def empty?
+    @ids.empty?
+  end
+
+  # number of objects in the set still valid
+  def size
+    @ids.size
+  end
+  alias length size
+end
+end
+
+# :stopdoc:
+
+if __FILE__==$0
+    require 'benchmark'
+    class MyString <String;
+      def initialize(*)
+        @owner=0
+        super
+      end
+     
+    end
+    class MyObject; end
+    class MyClass < Module; end
+    weakrefsets = (1..10).map {Sequence::WeakRefSet[]}
+    $stdout.sync=true
+    obj = nil
+    arr=[]
+#    srand(2389547343)
+    classes=[]
+    ObjectSpace.each_object(Class){|ob| classes<<ob}
+    maybe_Data=Data if defined? Data #whatever Data is supposed to be, idunno.....
+    classes-=[Symbol,Integer,NilClass,FalseClass,TrueClass,Numeric,maybe_Data,Bignum,Fixnum,
+              Float,Struct,Method,UnboundMethod,Proc,Thread,Binding,Continuation]
+    classes.delete_if{|k| begin k.allocate; rescue; true else false end}
+    def shuffle!(arr)
+      arr.sort_by{rand}    
+    end
+
+    iterations=ARGV[0]||100_000
+    iterations=iterations.to_i
+
+    times = Benchmark.measure {
+    iterations.times { |i|
+#        print(weakrefs.size>70?"|":((60..70)===weakrefs.size ? ":" : (weakrefs.size>50?',':'.')))
+        print "." if 0==i%128
+        #obj = (k=classes[rand(classes.size)]).allocate  
+        obj = (k=MyString).new "X#{rand(i+1)}_#{i}"
+#        obj= (k=Object).new
+#        obj= (k=MyObject).new
+        #obj= (k=MyClass).new
+        k==obj.class or raise
+        weakrefs=weakrefsets[rand(weakrefsets.size)]
+        obj.instance_eval{@owner=weakrefs}
+        obj.instance_eval{@owner}.equal? weakrefs or raise
+        weakrefs << obj
+        weakrefs.include?(obj) or raise
+        weakrefs.include?(obj) or raise
+        if rand(10).zero?
+            weakrefs.delete?(obj) or raise
+            !weakrefs.include?(obj) or raise
+        elsif rand(4).zero?
+          arr<<obj #prevent garbage collection
+        end
+        if rand(1000).zero?
+          shuffle! arr
+          arr.slice!(0..rand(arr.size))
+        end
+        arr.each{|o| o.instance_eval{@owner}.include? o or raise }
+        #rand(100).zero? and          GC.start
+      }
+    }
+    puts
+    GC.start
+    weakrefsets.each{|weakrefs|
+      weakrefs.clear
+      weakrefs.size.zero? or raise
+      weakrefs.empty? or raise
+    }
+    puts(times)
+
+
+
+
+   class NotReallyWeakRefSet<Sequence::WeakRefSet
+     #ensure the items referenced never get gc'd
+     class<<self
+       @@keeprefs=[]
+       def new(*args)
+         @@keeprefs.concat args
+         super
+       end
+     end
+   end
+
+   #"now I should reuse Set's original tests, but replacing Set with NotReallyWeakRefSet"
+   origset=$:.find{|dir| File.exist? dir+"/set.rb"} +"/set.rb"
+   testcode=File.read(origset).split("\n__END__\n",2).last
+   testcode=testcode.split("\nclass TC_SortedSet",2).first #hack off some unwanted tests
+   testcode.gsub! 'Set', 'NotReallyWeakRefSet'
+
+   eval testcode
+end
+
+# :stopdoc:
+
+

data/test/test_rexscan.rb

@@ -57,6 +57,7 @@ $Debug=true
         test_read 
         test_slice 
         test_slice_empty 
+        test_optional_capture
       ]
       MODIFYMETHODS=%w[
         test_insert 
@@ -257,8 +258,8 @@ $Debug=true
         const_set k, xk=Class.new(xk)
         xk.instance_eval do
           define_method :a_seq do
-            result=super
-            result.maxmatchlen=6
+            result=super()
+            result.maxmatchlen=10
             result
           end
         end
@@ -273,7 +274,7 @@ $Debug=true
         const_set k, xk=Class.new(xk)
         xk.instance_eval do
           define_method :a_seq do
-            result=Sequence::List.new([wrappee=super])
+            result=Sequence::List.new([wrappee=super()])
             result.pos=wrappee.pos
             return result
           end
@@ -290,7 +291,7 @@ $Debug=true
         const_set k, xk=Class.new(xk)
         xk.instance_eval do
           define_method :a_seq do
-            result=Sequence::List.new([wrappee=super])
+            result=Sequence::List.new([wrappee=super()])
             chunk=rand_pos_pair
             chunk=chunk.first..chunk.last
             result[chunk]=result[chunk]
@@ -344,6 +345,25 @@ $Debug=true
 =end
  
     class Indexed
+    def test_optional_capture
+       seq=a_seq
+       word=seq.scan /(more of )?that (tough)/
+       md=seq.last_match
+       assert_equal "that tough", word
+       assert_equal "that tough", md[0]
+       assert_equal nil, md[1]
+       assert_equal "tough", md[2]
+        
+       assert_equal OFFSET, md.begin(0)
+       assert_equal OFFSET+10, md.end(0)
+       assert_equal nil, md.begin(1)
+       assert_equal nil, md.end(1)
+       assert_equal OFFSET+5, md.begin(2)
+       assert_equal OFFSET+10, md.end(2)
+
+    end
+
+
     RANDOMIZED_METHODS=[:test_slice,:test_insert,:test_delete,:test_modify]
     undef test_randomized_methods_some_more
     def test_randomized_methods_some_more n=50

metadata

@@ -1,33 +1,37 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: sequence
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2008-08-29 00:00:00 +01:00
-summary: A single api for reading and writing sequential data types.
-require_paths: 
-- lib
-email: sequence-owner @at@ inforadical .dot. net
-homepage: http://sequence.rubyforge.org/
-rubyforge_project: sequence
-description: A unified wrapper api for accessing data in Strings, Arrays, Files, IOs,  and Enumerations. Each sequence encapsulates some data and a current position  within it. There are methods for moving the position, reading and writing data (with or without moving the position) forward or backward from the current position (or anywhere at all), scanning for patterns (like StringScanner, but  it works in Files too, among others), and saving a position that will remain valid even after data is deleted or inserted elsewhere within the sequence.   There are also some utility classes for making sequences reversed or circular, turning one-way sequences into two-way, buffering, and making sequences that are subsets or aggregations of existing sequences.
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.2.1
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Caleb Clausen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-06 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.12.2
+    version: 
+description: A unified wrapper api for accessing data in Strings, Arrays, Files, IOs,  and Enumerations. Each sequence encapsulates some data and a current position  within it. There are methods for moving the position, reading and writing data (with or without moving the position) forward or backward from the current position (or anywhere at all), scanning for patterns (like StringScanner, but  it works in Files too, among others), and saving a position that will remain valid even after data is deleted or inserted elsewhere within the sequence.   There are also some utility classes for making sequences reversed or circular, turning one-way sequences into two-way, buffering, and making sequences that are subsets or aggregations of existing sequences.
+email: sequence-owner @at@ inforadical .dot. net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+- README.txt
+- History.txt
 files: 
 - lib/assert.rb
 - lib/sequence.rb
@@ -52,7 +56,7 @@ files:
 - lib/sequence/subseq.rb
 - lib/sequence/usedata.rb
 - lib/sequence/version.rb
-- lib/weakrefset.rb
+- lib/sequence/weakrefset.rb
 - test/test.rb
 - test/test_all.rb
 - test/test_changes.rb
@@ -65,27 +69,33 @@ files:
 - README.txt
 - COPYING
 - GPL
-test_files: 
-- test/test_all.rb
+- History.txt
+has_rdoc: true
+homepage: http://sequence.rubyforge.org/
+post_install_message: 
 rdoc_options: 
 - --main
 - README.txt
-extra_rdoc_files: 
-- Manifest.txt
-- README.txt
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: hoe
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.5.1
-    version: 
+rubyforge_project: sequence
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A single api for reading and writing sequential data types.
+test_files: 
+- test/test_all.rb

data/lib/weakrefset.rb

@@ -1,254 +0,0 @@
-# $Id$
-# Copyright (C) 2006  Caleb Clausen
-# Distributed under the terms of Ruby's license.
-
-require 'yaml'
-require 'assert'
-
-# 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
-    # create a new WeakRefSet from an optional Enumerable (of objects)
-    # which is optionally processed through a block
-    def initialize(items) # :yield: obj
-        replace(items)
-    end
-    class<<self
-      def [] *items
-        new(items)
-      end
-    end
-
-    private
-    def finalizer(id)
-        @ids.delete(id)
-    end
-
-    public
-
-
-
-    # add a weak reference to the set
-    def add(obj)
-        Symbol===obj || Fixnum===obj || nil==obj || true==obj || false==obj and 
-          raise ArgumentError, "no immediates in weakrefset"
-        id=obj.object_id
-        case (o2=ObjectSpace._id2ref id) #test id for validity
-        when Symbol,Fixnum,true,false,nil:          id=obj #hopefully rare
-        else         obj.equal? o2 or raise
-          ObjectSpace.define_finalizer(obj,method(:finalizer))
-        end
-        @ids[id] = true
-        self
-    end
-    alias << add
-    # iterate over remaining valid objects in the set
-    def each
-        @ids.each_key { |id|
-          case id
-          when Integer:
-            begin
-                o = ObjectSpace._id2ref(id)
-            rescue RangeError
-                next
-            end
-            @ids.include?(id) or next
-            #i don't know where the random symbols come from, but at least they're always symbols...
-          else
-            o=id
-          end
-            case o
-              when Symbol,Fixnum,true,false,nil: warn "immediate value #{o.inspect} found in weakrefset"
-              else yield(o) 
-            end
-        }
-        self
-    end
-    
-    def == other
-      size==other.size and
-      each{|x|
-        other.include? x or return
-      }
-    
-    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)
-        delete?(obj)
-        self
-    end
-    # delete an object in the set (return self or nil if nothing deleted)
-    def delete?(obj)
-        x=include?(obj) and @ids.delete(x.__id__)||@ids.delete(x) and self
-    end
-    # is this object in the set?
-    def include?(obj)
-        find{|x| obj==x}
-    end
-    alias member? include?
-
-    # return a human-readable string showing the set
-  def inspect
-    #unless $weakrefset_verbose_inspect 
-    #  return sprintf('#<%s:0x%x {...}>', self.class.name, object_id)
-    #end
-    ids = (Thread.current[:__weakrefset__inspect_key__] ||= [])
-
-    if ids.include?(object_id)
-      return sprintf('#<%s {...}>', self.class.name)
-    end
-
-    begin
-      ids << object_id
-      return sprintf('#<%s {%s}>', self.class.name, to_a.inspect[1..-2])
-    ensure
-      ids.pop
-      Thread.current[:__weakrefset__inspect_key__].empty? and
-        Thread.current[:__weakrefset__inspect_key__]=nil
-    end
-  end
-
-if false      #this is broken; emits yaml for a hash. 
-
-  YAML::add_domain_type( "inforadical.net,2005", "object:WeakRefSet" ) do |type, val|
-       WeakRefSet.new( *val["items"] )
-  end
-
-  def is_complex_yaml?; true  end
-  
-  def to_yaml_type; "!inforadical.net,2005/object:WeakRefSet" end
-  
-  alias to_yaml_properties to_a
-  
-  def to_yaml( opts = {} )
-    YAML::quick_emit( object_id, opts ) { |out|
-      out.map( to_yaml_type ) { |map|
-        map.add( "items", to_yaml_properties)
-      }
-    }
-  end
-end
-  
-    # remove some objects from the set (return self)
-    def subtract(enum)
-        enum.each { |obj| delete(obj) }
-        self
-    end
-    # any objects in the set still valid?
-    def empty?
-        @ids.empty?
-    end
-    # number of objects in the set still valid
-    def size
-        @ids.size
-    end
-    alias length size
-end
-
-# :stopdoc:
-
-if __FILE__==$0
-    require 'benchmark'
-    class MyString <String;
-      def initialize(*)
-        @owner=0
-        super
-      end
-     
-    end
-    class MyObject; end
-    class MyClass < Module; end
-    weakrefsets = (1..10).map {WeakRefSet[]}
-    $stdout.sync=true
-    obj = nil
-    arr=[]
-#    srand(2389547343)
-    classes=[]
-    ObjectSpace.each_object(Class){|ob| classes<<ob}
-    classes-=[Symbol,Integer,NilClass,FalseClass,TrueClass,Numeric,Data,Bignum,Fixnum,
-              Float,Struct,Method,UnboundMethod,Proc,Thread,Binding,Continuation]
-    classes.delete_if{|k| begin k.allocate; rescue; true else false end}
-    def shuffle!(arr)
-      arr.sort_by{rand}    
-    end
-    times = Benchmark.measure {
-    100000.times { |i|
-#        print(weakrefs.size>70?"|":((60..70)===weakrefs.size ? ":" : (weakrefs.size>50?',':'.')))
-        print "." if 0==i%128
-        #obj = (k=classes[rand(classes.size)]).allocate  
-        obj = (k=MyString).new "X" #*rand(i+1)
-#        obj= (k=Object).new
-#        obj= (k=MyObject).new
-        #obj= (k=MyClass).new
-        k==obj.class or raise
-        weakrefs=weakrefsets[rand(weakrefsets.size)]
-        obj.instance_eval{@owner=weakrefs}
-        obj.instance_eval{@owner}.equal? weakrefs or raise
-        weakrefs.each { |o|
- #           k==o.class or raise "set contained a #{o.class}. i=#{i}. size=#{weakrefs.size}"
-            (o2=o.instance_eval{@owner})==weakrefs or 
-               raise "expected owner #{weakrefs.map{|w| w.__id__}.inspect}, "+
-              "got #{o2.inspect}, item #{o}, id #{o.__id__}, obj #{obj.__id__}"
-        }
-        weakrefs << obj
-        weakrefs.each { |o|
- #           k==o.class or raise "set contained a #{o.class}. i=#{i}. size=#{weakrefs.size}"
-            (o2=o.instance_eval{@owner})==weakrefs or 
-               raise "expected owner #{weakrefs.map{|w| w.__id__}.inspect}, "+
-              "got #{o2.inspect}, item #{o}, id #{o.__id__}, obj #{obj.__id__}"
-        }
-        weakrefs.include?(obj) or raise
-        weakrefs.each { |o|
- #           k==o.class or raise "set contained a #{o.class}. i=#{i}. size=#{weakrefs.size}"
-            (o2=o.instance_eval{@owner})==weakrefs or 
-               raise "expected owner #{weakrefs.map{|w| w.__id__}.inspect}, "+
-              "got #{o2.inspect}, item #{o}, id #{o.__id__}, obj #{obj.__id__}"
-        }
-        weakrefs.include?(obj) or raise
-        if rand(10).zero?
-            weakrefs.delete?(obj) or raise
-            !weakrefs.include?(obj) or raise
-        elsif rand(4).zero?
-          arr<<obj #prevent garbage collection
-        end
-        if rand(1000).zero?
-          shuffle! arr
-          arr.slice!(0..rand(arr.size))
-        end
-        arr.each{|o| o.instance_eval{@owner}.include? o or raise }
-        #rand(100).zero? and          GC.start
-    }
-    }
-    puts
-    GC.start
-    weakrefsets.each{|weakrefs|
-    weakrefs.clear
-    weakrefs.size.zero? or raise
-    weakrefs.empty? or raise
-    }
-    puts(times)
-end
-
-# :stopdoc:
-
-