facets 1.4.5 → 1.7.0

data/lib/facets/more/opencascade.rb

@@ -41,29 +41,14 @@ require 'facets/more/openobject.rb'
 # OpenCascade is subclass of OpenObject, but differs in a few
 # significant ways.
 #
-# Mainly, and why it's labeled a "cascade", every internal Hash
-# is trandformed into an OpenCascade dynamically upon access.
+# The main reason this class is labeled "cascade", every internal
+# Hash is trandformed into an OpenCascade dynamically upon access.
 # This makes it easy to create "cascading" references.
 #
-#   h = { :a => { :b => { :c => 1 } } }
-#   o = OpenCascade.new(h)
-#   o.a.b.c  #=> 1
+#   h = { :x => { :y => { :z => 1 } } }
+#   c = OpenCascade[h]
+#   c.x.y.z  #=> 1
 #
-# OpenCascade also has an inheritance feature which allows lookup
-# to be passed on to a "parent" if a key is not found. Simple use
-# the keyword option ++:inherit++ (or ++:parent++).
-#
-#    p = { :a => 1 }
-#    o = OpenCascade.new( {}, :inherit => p }
-#    o.a  #=> 1
-#
-# OpenCascade also supports acquisition which applies inheritance
-# to every sub-access. Eg.
-#
-#    o = OpenCascade.new( { :a => 1, :q => {} }, :acquisition => true }
-#    o.q.a  #=> 1
-#
-# The two can, of course, be used together.
 #--
 # Last, when an entry is not found, 'null' is returned rather then 'nil'.
 # This allows for run-on entries withuot error. Eg.
@@ -82,49 +67,24 @@ require 'facets/more/openobject.rb'
 
 class OpenCascade < OpenObject
 
-  def initialize( init=nil, opt={} )
-    super( init )
-    @parent = opt[:inherit] || opt[:parent]
-    @acquire = opt[:acquisition] ? true : false
-  end
-
-  def method_missing( sym, *args )
+  def method_missing( sym, arg=nil )
     type = sym.to_s[-1,1]
     name = sym.to_s.gsub(/[=!?]$/, '').to_sym
     if type == '='
-      @table[name] = args[0]
-    elsif type == '!' and args.size > 0
-      @table[name] = args[0]
+      self[name] = arg
+    elsif type == '!'
+      self[name] = arg
       self
     else
-      if @table.key?(name)
-        if Hash === @table[name]
-          if @acquire
-            self.__class__.new( @table[name], :inherit => self, :acquisition => true )
-          else
-            self.__class__.new( @table[name] )
-          end
-        else
-          @table[name]
-        end
-      elsif @parent
-        # error catch?
-        @parent.__send__(name)
-      else
-        nil
-        # Kernel.null
-        # @table[name] = instance.class.new
-      end
+      val = self[name]
+      val = object_class[val] if Hash === val
+      val
     end
   end
 
-  def __parent__ ; @parent ; end
-  def __parent__=(x) ; @parent = x ; end
-
 end
 
 
-
 #  _____         _
 # |_   _|__  ___| |_
 #   | |/ _ \/ __| __|
@@ -136,43 +96,53 @@ end
 
   require 'test/unit'
 
-  class TC01 < Test::Unit::TestCase
+  class TestOpenCascade1 < Test::Unit::TestCase
 
-    def test_01_001
+    def test_1_01
+      o = OpenCascade[:a=>1,:b=>2]
+      assert_equal( 1, o.a )
+      assert_equal( 2, o.b )
+    end
+
+    def test_1_02
+      o = OpenCascade[:a=>1,:b=>2,:c=>{:x=>9}]
+      assert_equal( 9, o.c.x )
+    end
+
+    def test_1_03
       f0 = OpenCascade.new
       f0[:a] = 1
-      assert_equal( [1], f0.to_a )
+      assert_equal( [[:a,1]], f0.to_a )
       assert_equal( {:a=>1}, f0.to_h )
     end
 
-    def test_01_002
-      f0 = OpenCascade.new( {:a=>1} )
+    def test_1_04
+      f0 = OpenCascade[:a=>1]
       f0[:b] = 2
       assert_equal( {:a=>1,:b=>2}, f0.to_h )
     end
   end
 
-  class TC02 < Test::Unit::TestCase
+  class TestOpenCascade2 < Test::Unit::TestCase
 
     def test_02_001
-      f0 = OpenCascade.new( :f0=>"f0" )
+      f0 = OpenCascade[:f0=>"f0"]
       h0 = { :h0=>"h0" }
-      assert_equal( OpenCascade.new( :f0=>"f0", :h0=>"h0" ), f0.__merge__( h0 ) )
+      assert_equal( OpenCascade[:f0=>"f0", :h0=>"h0"], f0.send(:merge,h0) )
       assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
     end
 
     def test_02_002
-      f1 = OpenCascade.new( :f1=>"f1" )
+      f1 = OpenCascade[:f1=>"f1"]
       h1 = { :h1=>"h1" }
-      f1.__update__( h1 )
+      f1.send(:update, h1)
       h1.update( f1 )
-      assert_equal( OpenCascade.new( :f1=>"f1", :h1=>"h1" ), f1 )
+      assert_equal( OpenCascade[:f1=>"f1", :h1=>"h1"], f1 )
       assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
     end
-
   end
 
-  class TC03 < Test::Unit::TestCase
+  class TestOpenCascade3 < Test::Unit::TestCase
 
     def test_01_001
       fo = OpenCascade.new
@@ -181,7 +151,6 @@ end
         assert_equal( 1, fo.__send__( "n#{i}" ) )
       }
     end
-
   end
 
 =end

data/lib/facets/more/openobject.rb

@@ -1,6 +1,6 @@
 # = openobject.rb
 #
-# == Copyright (c) 2005 Thomas Sawyer, George Moschovitis
+# == Copyright (c) 2005,2006 Thomas Sawyer
 #
 #   Ruby License
 #
@@ -16,196 +16,199 @@
 # * Thomas Sawyer
 # * George Moschovitis
 
-# Author::    Thomas Sawyer, George Moschovitis
-# Copyright:: Copyright (c) 2005 Thomas Sawyer, George Moschovitis
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2005 Thomas Sawyer
 # License::   Ruby License
 
-require 'facets/core/hash/keys_to_sym'
+require 'facets/core/hash/to_h'
 require 'facets/core/hash/to_proc'
-require 'facets/more/basicobject'
-#require 'facets/more/nullclass'
+require 'facets/core/hash/symbolize_keys'
+require 'facets/core/kernel/object_class'
+require 'facets/core/kernel/object_hexid'
+
+#require 'facets/more/methodfilter'
 
 # = OpenObject
 #
-# OpenObject is similar to OpenStruct, but differs in a few
-# significant ways.
+# OpenObject is similar to OpenStruct, but differs in a couple ways.
+#
+# OpenObject is a subclass of Hash and can do just about everything
+# a Hash can do, except that most public methods have been made
+# protected and thus only available internally or via #send.
+# A small number, like #each are stillexposed publically though
+# b/c of their importance.
+#
+# OpenObject will also clobber any method for which a slot is defined.
+# Even generally very important methods can be clobbered, like
+# instance_eval. So be careful. OpenObject should be used in highly
+# controlled scenarios. If you want to pass one off to a general
+# rountine, it is best to convert it to a Hash first and convert it
+# back to an OpenObject when finished. To facilitate this the method
+# #as_hash! is provided.
 #
-# OpenObject is a sublcass of BasicObject, so there are
-# many fewer reserved Kernel methods in the object's namespace.
+#   o = OpenObject.new(:a=>1,:b=>2)
+#   o.as_hash!{ |h| h.update(:a=>6) }
+#   o #=> #<OpenObject {:a=>6,:b=>2}>
 #
-# Also it does not create any instance methods for the added entries,
-# but rather strictly uses a hash. OpenStruct creates methods, but is
-# actaully inconsitant in their use --try #dup on an OpenStruct and
-# all the methods disappear. Morevoer, I beleive this feature was added
-# to OpenStruct for speed, but I have not been able to find this
-# advantage in benchmark tests.
+# Finally, unlike a regular Hash, all OpenObject's keys are symbols and
+# all keys are converted to such using #to_sym on the fly.
 #
 #--
-# Third, when an entry is not found 'null' is returned rather then 'nil'.
+# Also, when an entry is not found 'null' is returned rather then 'nil'.
 # This allows for run-on entries withuot error. Eg.
 #
 #   OpenObject.new.a.b.c  #=> null
 #++
 
-class OpenObject < BasicObject
-
-  def initialize( init=nil )
-    case init
-    when Array
-      @table = Hash[*init].keys_to_sym
-    when Hash
-      @table = init.keys_to_sym
-    when NilClass
-      @table = {}
-    when OpenObject
-      @table = init.__table__.dup
-    else
-      @table = init.to_h.keys_to_sym
-    end
-  end
+class OpenObject < Hash
 
-  def to_openobject ; self    ; end
+  PUBLIC_METHODS = /(^__|^instance__|^object__|^\W|^send$|^class$|\?$)/
 
-  def to_a    ; @table.values ; end
-  def to_h    ; @table.dup    ; end
-  def to_hash ; @table.dup    ; end
+  protected *public_instance_methods.select{ |m| m !~ PUBLIC_METHODS }
 
-  # OpenObejct can be converted to an assignment Proc.
-  #
-  #   o = OpenObject.new( :a=>1 )
-  #   p = o.to_proc
-  #   x = OpenObject.new
-  #   p[x]
-  #   x.a #=> 1
+  def self.[](hash=nil)
+    new(hash)
+  end
+
+  # Inititalizer for OpenObject is slightly differnt than taht of Hash.
+  # It does not take a default parameter, but an initial priming Hash
+  # as with OpenStruct. The initializer can still take a default block
+  # however. To set the degault value use ++#default!(value)++.
   #
-  def to_proc
-    @table.to_proc
+  #   OpenObject(:a=>1).default!(0)
+
+  def initialize( hash=nil, &yld )
+    super( &yld )
+    hash.each { |k,v| define_slot(k,v) } if hash
   end
 
-  # duplicate
   def initialize_copy( orig )
-    super
-    @table = @table.dup
+    orig.each { |k,v| define_slot(k,v) }
   end
 
+  # Object inspection. (Careful, this can be clobbered!)
+
   def inspect
-    s = "<#{__class__}"
-    s << " " << @table.collect{|k,v| "#{k}=#{v.inspect}"}.join(' ') unless @table.empty?
-    s << ">"
+    "#<#{object_class}:#{object_hexid} #{super}>"
   end
 
-  def marshal_dump
-    @table
-  end
+  # Conversion methods. (Careful, these can be clobbered!)
 
-  def marshal_load( tbl )
-    @table = tbl
-  end
+  def to_a() super end
+  def to_h() super end
+
+  def to_hash() super end
+  def to_proc() super  end
+
+  def to_openobject() self end
+
+  # Iterate over each key-value pair. (Careful, this can be clobbered!)
+
+  def each(&yld) super(&yld) end
+
+  # Set the default value.
 
-  # Compare this object and +other+ for equality.
-  def ==(other)
-    return false unless other.kind_of?( __class__ )
-    return @table == other.__table__
+  def default!(default)
+    self.default = default
   end
 
-  def method_missing( sym, *args )
-    type = sym.to_s[-1,1]
-    name = sym.to_s.gsub(/[=!?]$/, '').to_sym
-
-    if type == '='
-      @table[name] = args[0]
-    elsif type == '!' and args.size > 0
-      @table[name] = args[0]
-      self
-    else
-      if @table.key?(name)
-        @table[name]
-      #elsif @parent
-      #  @parent.__send__(name)
-      else
-        nil
-      end
-    end
+  # Preform action on OpenObject as if it were a regular Hash.
+
+  def as_hash!
+    replace(yld.call(to_hash))
   end
 
-  def [](name)
-    name = name.to_sym
-    #if @table.key?(name)
-      @table[name]
-    #else
-    #  Kernel.null
-    #end
+  # Check equality. (Should equal be true for Hash too?)
+
+  def ==( other )
+    return false unless OpenObject === other
+    super(other) #(other.send(:table))
   end
 
-  def []=(name,val)
-    @table[name.to_sym] = val
+  def []=(k,v)
+    super(k.to_sym,v)
+    define_slot(k)
   end
 
-  # For compatibility with other types of hash-like objects.
-  # Also make OpenObject usable via Enumerator.
-  def each(&yld)
-    @table.each( &yld )
+  def [](k)
+    super(k.to_sym)
   end
 
-  # Shadow methods
+  protected
 
-  # Access to internal table.
-  def __table__ ; @table ; end
+    def store(k,v)
+      super(k.to_sym,v)
+      define_slot(k)
+    end
 
-  #--
-  # TODO Parent feature? Or better only for OpenCascade?
-  #++
-  #def __parent__ ; @parent ; end
-  #def __parent__=(x) ; @parent = x ; end
+    def fetch(k,*d,&b)
+      super(k.to_sym,*d,&b)
+    end
 
-  #def __fetch__(k) ; @table.key?(k.to_sym) ? @table[k.to_sym] : null ; end
-  def __fetch__(k)  ; @table[k.to_sym] ; end
-  def __store__(k)  ; @table[k.to_sym]=v ; end
+    def define_slot( key, value=nil )
+      (class << self; self; end).class_eval {
+        protected key rescue nil
+        #def #{key}()   self[:#{key}]    end
+        #def #{key}=(o) self[:#{key}]=o  end
+      }
+      self[key.to_sym] = value if value
+    end
 
-  def __key__?(k) ; @table.key?(k.to_sym) ; end
-  def __keys__    ; @table.keys ; end
+    def merge( other )
+      d = dup
+      d.send(:update, other)
+      d
+    end
 
-  def __update__( other )
-    other = Hash[*other] if other.is_a?(Array)
-    other.each{ |k, v| @table[k.to_sym] = v }
-  end
+    def update( other )
+      other.each { |k,v| define_slot(k,v) }
+    end
 
-  def __merge__( other )
-    o = dup
-    o.__update__( other )
-    o
-  end
+    def method_missing( sym, arg=nil, &blk)
+      type = sym.to_s[-1,1]
+      key = sym.to_s.sub(/[=?!]$/,'').to_sym
+      if type == '='
+        define_slot(key,arg)
+      elsif type == '!'
+        define_slot(key,arg)
+        self
+      else
+        self[key]
+      end
+    end
 
-  # Core Extensions
+end
 
-  class ::Hash
-    # Convert a Hash into an OpenObject.
-    def to_openobject
-      OpenObject.new( self )
-    end
-  end
+# Core Extensions
 
-  class ::Proc
-    # Translates a Proc into an OpenObject. By droping an OpenObject into
-    # the Proc, the resulting assignments incured as the procedure is
-    # evaluated produce the OpenObject. This technique is simlar to that
-    # of MethodProbe.
-    #
-    #   p = lambda { |x|
-    #     x.word = "Hello"
-    #   }
-    #   o = p.to_openobject
-    #   o.word #=> "Hello"
-    #
-    # NOTE The Proc must have an arity of one --no more and no less.
-    def to_openobject
-      raise ArgumentError, 'bad arity for converting Proc to openobject' if arity != 1
-      o = OpenObject.new
-      self.call( o )
-      o
-    end
+class Hash
+  # Convert a Hash into an OpenObject.
+
+  def to_openobject
+    OpenObject[self]
   end
+end
 
+class Proc
+  # Translates a Proc into an OpenObject. By droping an OpenObject into
+  # the Proc, the resulting assignments incured as the procedure is
+  # evaluated produce the OpenObject. This technique is simlar to that
+  # of MethodProbe.
+  #
+  #   p = lambda { |x|
+  #     x.word = "Hello"
+  #   }
+  #   o = p.to_openobject
+  #   o.word #=> "Hello"
+  #
+  # NOTE The Proc must have an arity of one --no more and no less.
+
+  def to_openobject
+    raise ArgumentError, 'bad arity for converting Proc to openobject' if arity != 1
+    o = OpenObject.new
+    self.call( o )
+    o
+  end
 end
 
 
@@ -220,57 +223,97 @@ end
 
   require 'test/unit'
 
-  class TC01 < Test::Unit::TestCase
+  class TestOpenObject1 < Test::Unit::TestCase
+
+    def test_1_01
+      o = OpenObject.new
+      assert( o.respond_to?(:key?) )
+    end
+
+    def test_1_02
+      assert_instance_of( OpenObject, OpenObject[{}] )
+    end
 
-    def test_01_001
+    def test_1_03
       f0 = OpenObject.new
       f0[:a] = 1
-      assert_equal( [1], f0.to_a )
+      #assert_equal( [1], f0.to_a )
       assert_equal( {:a=>1}, f0.to_h )
     end
 
-    def test_01_002
-      f0 = OpenObject.new( {:a=>1} )
+    def test_1_04
+      f0 = OpenObject[:a=>1]
       f0[:b] = 2
       assert_equal( {:a=>1,:b=>2}, f0.to_h )
     end
+
+    def test_1_05
+      f0 = OpenObject[:class=>1]
+      assert_equal( 1, f0.class )
+    end
   end
 
-  class TC02 < Test::Unit::TestCase
+  class TestOpenObject2 < Test::Unit::TestCase
 
-    def test_02_001
-      f0 = OpenObject.new( :f0=>"f0" )
+    def test_2_01
+      f0 = OpenObject[:f0=>"f0"]
       h0 = { :h0=>"h0" }
-      assert_equal( OpenObject.new( :f0=>"f0", :h0=>"h0" ), f0.__merge__( h0 ) )
+      assert_equal( OpenObject[:f0=>"f0", :h0=>"h0"], f0.send(:merge,h0) )
       assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
     end
 
-    def test_02_002
-      f1 = OpenObject.new( :f1=>"f1" )
+    def test_2_02
+      f1 = OpenObject[:f1=>"f1"]
       h1 = { :h1=>"h1" }
-      f1.__update__( h1 )
+      f1.send(:update,h1)
       h1.update( f1 )
-      assert_equal( OpenObject.new( :f1=>"f1", :h1=>"h1" ), f1 )
+      assert_equal( OpenObject[:f1=>"f1", :h1=>"h1"], f1 )
       assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
     end
 
-  end
+    def test_2_03
+      o = OpenObject[:a=>1,:b=>{:x=>9}]
+      assert_equal( 9, o[:b][:x] )
+      assert_equal( 9, o.b[:x] )
+    end
 
-  class TC03 < Test::Unit::TestCase
+    def test_2_04
+      o = OpenObject["a"=>1,"b"=>{:x=>9}]
+      assert_equal( 1, o["a"] )
+      assert_equal( 1, o[:a] )
+      assert_equal( {:x=>9}, o["b"] )
+      assert_equal( {:x=>9}, o[:b] )
+      assert_equal( 9, o["b"][:x] )
+      assert_equal( nil, o[:b]["x"] )
+    end
 
-    def test_03_001
+  end
+
+  class TestOpenObject3 < Test::Unit::TestCase
+    def test_3_01
       fo = OpenObject.new
-      99.times{ |i| fo.__send__( "n#{i}=", 1 ) }
-      99.times{ |i|
-        assert_equal( 1, fo.__send__( "n#{i}" ) )
+      9.times{ |i| fo.send( "n#{i}=", 1 ) }
+      9.times{ |i|
+        assert_equal( 1, fo.send( "n#{i}" ) )
       }
     end
+  end
+
+  class TestOpenObject4 < Test::Unit::TestCase
+
+    def test_4_01
+      ho = {}
+      fo = OpenObject.new
+      5.times{ |i| ho["n#{i}".to_sym]=1 }
+      5.times{ |i| fo.send( "n#{i}=", 1 ) }
+      assert_equal(ho, fo.to_h)
+    end
 
   end
 
-  class TC04 < Test::Unit::TestCase
+  class TestOpenObject5 < Test::Unit::TestCase
 
-    def test_04_001
+    def test_5_01
       p = lambda { |x|
         x.word = "Hello"
       }
@@ -278,6 +321,14 @@ end
       assert_equal( "Hello", o.word )
     end
 
+    def test_5_02
+      p = lambda { |x|
+        x.word = "Hello"
+      }
+      o = OpenObject[:a=>1,:b=>2]
+      assert_instance_of( Proc, o.to_proc )
+    end
+
   end
 
 =end