facets 1.8.0 → 1.8.8

data/lib/facets/more/ann_attr.rb

@@ -1,4 +1,4 @@
-# = annattr.rb
+# = ann_attr.rb
 #
 # == Copyright (c) 2005 Thomas Sawyer
 #
@@ -14,6 +14,7 @@
 # == Authors & Contributors
 #
 # * Thomas Sawyer
+# * George Moschovitis
 
 # Author::    Thomas Sawyer
 # Copyright:: Copyright (c) 2005 Thomas Sawyer
@@ -86,8 +87,9 @@ class ::Module
           }
           attributes!.concat( args )  #merge!
 
-          if klass and klass.respond_to?(:included_as_property)
-            klass.included_as_property(self, args)
+          # Use this callback to customize for your needs.
+          if respond_to?(:attr_callback)
+            attr_callback(self, args, harg)
           end
 
           # return the names of the attributes created
@@ -100,31 +102,26 @@ class ::Module
 
   class_eval( code )
 
+  # TODO Should attribute alias be kept?
   alias_method :attribute, :attr_accessor
-  alias_method :property, :attr_accessor  # for nitro
 
-  # Return the serializable attributes of this class.
-  # Serializable are attributes with the class annotation that
-  # are not marked as :serializable => false.
+  # Return list of attributes that have a :class annotation.
   #
   #   class MyClass
   #     attr_accessor :test
   #     attr_accessor :name, String, :doc => 'Hello'
   #     attr_accessor :age, Fixnum
-  #     attr_accessor :body, String, :serialize => false
   #   end
   #
   #   MyClass.attributes # => [:test, :name, :age, :body]
-  #   MyClass.serializable_attributes # => [:name, :age]
+  #   MyClass.classified_attributes # => [:name, :age]
 
-  def serializable_attributes
-    attributes.find_all do |a| 
-      anno = self.ann(a)
-      anno.class? and (anno.serialize != false)
+  def classified_attributes
+    attributes.find_all do |a|
+      self.ann(a, :class)
     end
   end
 
-
 end
 
 

data/lib/facets/more/autovivify.rb

@@ -1,12 +1,12 @@
 # autovivify.rb
 
-require 'facets/more/openhash.rb'
+require 'facets/more/openobject.rb'
 
 # AutoVivify module houses the +method_missing+ defintion.
 
 module AutoVivify
   def method_missing( name, *args, &block )
-    oo = OpenHash.new
+    oo = OpenObject.new
     (class << self; self; end).send( :define_method, name ) { oo }
   end
 end

data/lib/facets/more/dictionary.rb

@@ -18,13 +18,13 @@
 # Thanks to Andrew Johnson for his suggestions and fixes of Hash[],
 # merge, to_a, inspect and shift.
 #
-# == Authors and Contributors
+# == Authors & Contributors
 #
 # * Jan Molic
 # * Thomas Sawyer
 
-# Author::    Jan Molic, Thomas Sawyer
-# Copyright:: Copyright (c) 2006 Jan Molic, Thomas Sawyer
+# Author::    Jan Molic
+# Copyright:: Copyright (c) 2006 Jan Molic
 # License::   Ruby License
 
 # = Dictionary
@@ -77,10 +77,11 @@ class Dictionary < Hash
     #--
     # TODO is this needed? Doesn't the super class do this?
     #++
+
     def []( *args )
       hsh = new
       if Hash === args[0]
-        hsh.replace( args[0] )
+        hsh.replace(args[0])
       elsif (args.size % 2) != 0
         raise ArgumentError, "odd number of elements for Hash"
       else
@@ -110,7 +111,7 @@ class Dictionary < Hash
     #   Dictionary.new.order_by { |key,value| key }
 
     def alpha( *args, &block )
-      new( *args, &block ).by_key
+      new( *args, &block ).order_by_key
     end
 
     # Alternate to #new which auto-creates sub-dictionaries as needed.
@@ -118,32 +119,17 @@ class Dictionary < Hash
     #   d = Dictionary.auto
     #   d["a"]["b"]["c"] = "abc"  #=> { "a"=>{"b"=>{"c"=>"abc"}}}
     #
-    #def auto( *args )
-    #  AutoDictionary.new(*args)
-    #  #leet = lambda { |hsh, key| hsh[key] = new( &leet ) }
-    #  #new(*args, &leet)
-    #end
-
-    # Alternate to #new which auto-creates sub-dictionaries as needed.
-    #
-    #   d = Dictionary.autokey
-    #   d["a"]["b"]["c"] = "abc"  #=> { "a"=>{"b"=>{"c"=>"abc"}}}
-    #
-    #def auto_alpha(*args)
-    #  auto(*args).order_by{ |k,v| k }
-    #  #AutoDictionary.new(*args).order_by{ |k,v| k }
-    #  #leet = lambda { |hsh, key| hsh[key] = new( &leet ) }
-    #  #new(*args, &leet).order_by{ |k,v| k }
-    #end
-
+    def auto( *args )
+      #AutoDictionary.new(*args)
+      leet = lambda { |hsh, key| hsh[key] = new( &leet ) }
+      new(*args, &leet)
+    end
   end
 
-  attr_accessor :order
-
   def initialize( *args, &blk )
     @order = []
     @order_by = nil
-    super
+    @hash = Hash.new( *args, &blk )
   end
 
   def order
@@ -151,7 +137,7 @@ class Dictionary < Hash
     @order
   end
 
-  # Keep dictionary sorted by sepcifiec sort order.
+  # Keep dictionary sorted by a specific sort order.
 
   def order_by( &block )
     @order_by = block
@@ -161,7 +147,7 @@ class Dictionary < Hash
 
   # Keep dictionary sorted by key.
   #
-  #   d = Dictionary.new.by_key
+  #   d = Dictionary.new.order_by_key
   #   d["z"] = 1
   #   d["y"] = 2
   #   d["x"] = 3
@@ -173,7 +159,7 @@ class Dictionary < Hash
   #
   # The initializer Dictionary#alpha also provides this.
 
-  def by_key
+  def order_by_key
     @order_by = lambda { |k,v| k }
     order
     self
@@ -181,7 +167,7 @@ class Dictionary < Hash
 
   # Keep dictionary sorted by value.
   #
-  #   d = Dictionary.by_value
+  #   d = Dictionary.new.order_by_value
   #   d["z"] = 1
   #   d["y"] = 2
   #   d["x"] = 3
@@ -191,7 +177,7 @@ class Dictionary < Hash
   #
   #   Dictionary.new.order_by { |key,value| value }
 
-  def by_value
+  def order_by_value
     @order_by = lambda { |k,v| v }
     order
     self
@@ -201,31 +187,32 @@ class Dictionary < Hash
 
   def reorder
     if @order_by
-      assoc = @order.collect{ |k| [k,self[k]] }.sort_by( &@order_by )
+      assoc = @order.collect{ |k| [k,@hash[k]] }.sort_by( &@order_by )
       @order = assoc.collect{ |k,v| k }
     end
     @order
   end
 
-  #def store_only( a,b )
-  #  store( a,b )
+  #def ==( hsh2 )
+  #  return false if @order != hsh2.order
+  #  super hsh2
   #end
-  #alias_method :store_only, :store
-
-  alias_method :orig_store, :store
-  protected :orig_store
 
-  def insert( i,k,v )
-    @order.insert(i,k)
-    orig_store(k,v)
+  def ==( hsh2 )
+    if hsh2.is_a?( Dictionary )
+      @order == hsh2.order &&
+      @hash  == hsh2.instance_variable_get("@hash")
+    else
+      false
+    end
   end
 
-  #alias_method :unordered_store, :store
-  #private :unordered_store
+  def [] k
+    @hash[ k ]
+  end
 
-  def store( a,b )
-    @order.push( a ) unless has_key? a
-    super( a,b )
+  def fetch( k )
+    @hash.fetch( k )
   end
 
   # Store operator.
@@ -244,21 +231,24 @@ class Dictionary < Hash
     end
   end
 
-  #
+  def insert( i,k,v )
+    @order.insert( i,k )
+    @hash.store( k,v )
+  end
 
-  def ==( hsh2 )
-    return false if @order != hsh2.order
-    super hsh2
+  def store( a,b )
+    @order.push( a ) unless @hash.has_key?( a )
+    @hash.store( a,b )
   end
 
   def clear
     @order = []
-    super
+    @hash.clear
   end
 
   def delete( key )
-    @order.delete key
-    super
+    @order.delete( key )
+    @hash.delete( key )
   end
 
   def each_key
@@ -267,14 +257,12 @@ class Dictionary < Hash
   end
 
   def each_value
-    order.each { |k| yield( self[k] ) }
+    order.each { |k| yield( @hash[k] ) }
     self
   end
 
-  #alias_method :unordered_each, :each
-
   def each
-    order.each { |k| yield( k,self[k] ) }
+    order.each { |k| yield( k,@hash[k] ) }
     self
   end
   alias each_pair each
@@ -286,7 +274,7 @@ class Dictionary < Hash
 
   def values
     ary = []
-    order.each { |k| ary.push self[k] }
+    order.each { |k| ary.push @hash[k] }
     ary
   end
 
@@ -296,7 +284,7 @@ class Dictionary < Hash
 
   def invert
     hsh2 = self.class.new
-    order.each { |k| hsh2[self[k]] = k }
+    order.each { |k| hsh2[@hash[k]] = k }
     hsh2
   end
 
@@ -310,8 +298,8 @@ class Dictionary < Hash
   end
 
   def replace( hsh2 )
-    @order = hsh2.keys
-    super hsh2
+    @order = hsh2.order
+    @hash = hsh2.hash
   end
 
   def shift
@@ -320,9 +308,9 @@ class Dictionary < Hash
   end
 
   def unshift( k,v )
-    unless self.include? k
-      @order.unshift k
-      orig_store(k,v)
+    unless @hash.include?( k )
+      @order.unshift( k )
+      @hash.store( k,v )
       true
     else
       false
@@ -334,9 +322,9 @@ class Dictionary < Hash
   end
 
   def push( k,v )
-    unless self.include? k
-      @order.push k
-      orig_store(k,v)
+    unless @hash.include?( k )
+      @order.push( k )
+      @hash.store( k,v )
       true
     else
       false
@@ -386,16 +374,22 @@ class Dictionary < Hash
   end
 
   def first
-    self[order.first]
+    @hash[order.first]
   end
 
   def last
-    self[order.last]
+    @hash[order.last]
   end
 
+  def length
+    @order.length
+  end
+  alias :size :length
+
 end
 
 
+
 #  _____         _
 # |_   _|__  ___| |_
 #   | |/ _ \/ __| __|

data/lib/facets/more/opencascade.rb

@@ -33,12 +33,12 @@
 # License::   Ruby License
 
 require 'facets/core/kernel/bool.rb'
-require 'facets/more/openhash.rb'
+require 'facets/more/openobject.rb'
 #require 'facets/more/nullclass'
 
 # = OpenCascade
 #
-# OpenCascade is subclass of OpenHash. It differs in a few
+# OpenCascade is subclass of OpenObject. It differs in a few
 # significant ways.
 #
 # The main reason this class is labeled "cascade", every internal
@@ -65,7 +65,7 @@ require 'facets/more/openhash.rb'
 # So be sure to take that into account.
 #++
 
-class OpenCascade < OpenHash
+class OpenCascade < OpenObject
 
   def method_missing( sym, arg=nil )
     type = sym.to_s[-1,1]

data/lib/facets/more/openobject.rb

@@ -1,13 +1,200 @@
-# TO BE DEPRECTATED!!!
+# = openobject.rb
+#
+# == Copyright (c) 2005,2006 Thomas Sawyer
+#
+#   Ruby License
+#
+#   This module is free software. You may use, modify, and/or redistribute this
+#   software under the same terms as Ruby.
+#
+#   This program is distributed in the hope that it will be useful, but WITHOUT
+#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+#   FOR A PARTICULAR PURPOSE.
+#
+# == Authors and Contributors
+#
+# * Thomas Sawyer
+# * George Moschovitis
 
-require 'facets/more/openhash'
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2005 Thomas Sawyer
+# License::   Ruby License
 
-OpenObject = OpenHash
+require 'facets/core/hash/to_h'
+require 'facets/core/hash/to_proc'
+require 'facets/core/kernel/object_class'
+require 'facets/core/kernel/object_hexid'
+
+# = OpenObject
+#
+# 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 still exposed 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 an "unknown"
+# 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.
+#
+#   o = OpenObject.new(:a=>1,:b=>2)
+#   o.as_hash!{ |h| h.update(:a=>6) }
+#   o #=> #<OpenObject {:a=>6,:b=>2}>
+#
+# Finally, unlike a regular Hash, all OpenObject's keys are symbols and
+# all keys are converted to such using #to_sym on the fly.
+
+class OpenObject < Hash
+
+  PUBLIC_METHODS = /(^__|^instance_|^object_|^\W|^as$|^send$|^class$|\?$)/
+
+  protected *public_instance_methods.select{ |m| m !~ PUBLIC_METHODS }
+
+  def self.[](hash=nil)
+    new(hash)
+  end
+
+  # Inititalizer for OpenObject is slightly differnt than that 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)++.
+  #
+  #   OpenObject(:a=>1).default!(0)
+
+  def initialize( hash=nil, &yld )
+    super( &yld )
+    hash.each { |k,v| define_slot(k,v) } if hash
+  end
+
+  def initialize_copy( orig )
+    orig.each { |k,v| define_slot(k,v) }
+  end
+
+  # Object inspection. (Careful, this can be clobbered!)
+
+  def inspect
+    "#<#{object_class}:#{object_hexid} #{super}>"
+  end
+
+  # Conversion methods. (Careful, these can be clobbered!)
+
+  def to_a() super end
+
+  def to_h() {}.update(self) end
+  def to_hash() {}.update(self) 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
+
+  # Merge one OpenObject with another creating a new OpenObject.
+
+  def merge( other )
+    d = dup
+    d.send(:update, other)
+    d
+  end
+
+  # Update this OpenObject with another.
+
+  def update( other )
+    begin
+      other.each { |k,v| define_slot(k,v) }
+    rescue
+      other = other.to_h
+      retry
+    end
+  end
+
+  #
+  
+  def delete(key)
+    super(key.to_sym)
+  end
+
+  # Set the default value.
+
+  def default!(default)
+    self.default = default
+  end
+
+  # Preform inplace action on OpenObject as if it were a regular Hash.
+  #--
+  # TODO Not so sure about #as_hash!. For starters if it doesn't return a hash it will fail.
+  # TODO Replace by using #as(Hash). Perhaps as_hash and as_object shortcuts? Why?
+  #++
+
+  def as_hash!(&yld)
+    replace(yld.call(to_hash))
+  end
+
+  # Check equality. (Should equal be true for Hash too?)
+
+  def ==( other )
+    return false unless OpenObject === other
+    super(other) #(other.send(:table))
+  end
+
+  def []=(k,v)
+    protect_slot(k)
+    super(k.to_sym,v)
+  end
+
+  def [](k)
+    super(k.to_sym)
+  end
+
+  protected
+
+    def store(k,v)
+      super(k.to_sym,v)
+      define_slot(k)
+    end
+
+    def fetch(k,*d,&b)
+      super(k.to_sym,*d,&b)
+    end
+
+    def define_slot( key, value=nil )
+      protect_slot( key )
+      self[key.to_sym] = value
+    end
+
+    def protect_slot( key )
+      (class << self; self; end).class_eval {
+        protected key rescue nil
+      }
+    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
+
+end
 
 # Core Extensions
 
 class NilClass
-  # Nil converts to an empty OpenHash.
+  # Nil converts to an empty OpenObject.
 
   def to_openobject
     OpenObject.new
@@ -15,7 +202,7 @@ class NilClass
 end
 
 class Hash
-  # Convert a Hash into an OpenHash.
+  # Convert a Hash into an OpenObject.
 
   def to_openobject
     OpenObject[self]
@@ -23,23 +210,145 @@ class Hash
 end
 
 class Proc
-  # Translates a Proc into an OpenHash. By droping an OpenHash into
+  # Translates a Proc into an OpenObject. By droping an OpenObject into
   # the Proc, the resulting assignments incured as the procedure is
-  # evaluated produce the OpenHash. This technique is simlar to that
+  # evaluated produce the OpenObject. This technique is simlar to that
   # of MethodProbe.
   #
   #   p = lambda { |x|
   #     x.word = "Hello"
   #   }
-  #   o = p.to_openhash
+  #   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 openhash' if arity != 1
+    raise ArgumentError, 'bad arity for converting Proc to openobject' if arity != 1
     o = OpenObject.new
     self.call( o )
     o
   end
 end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  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_1_03
+      f0 = OpenObject.new
+      f0[:a] = 1
+      #assert_equal( [1], f0.to_a )
+      assert_equal( {:a=>1}, f0.to_h )
+    end
+
+    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 TestOpenObject2 < Test::Unit::TestCase
+
+    def test_2_01
+      f0 = OpenObject[:f0=>"f0"]
+      h0 = { :h0=>"h0" }
+      assert_equal( OpenObject[:f0=>"f0", :h0=>"h0"], f0.send(:merge,h0) )
+      assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
+    end
+
+    def test_2_02
+      f1 = OpenObject[:f1=>"f1"]
+      h1 = { :h1=>"h1" }
+      f1.send(:update,h1)
+      h1.update( f1 )
+      assert_equal( OpenObject[:f1=>"f1", :h1=>"h1"], f1 )
+      assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
+    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
+
+    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
+
+  end
+
+  class TestOpenObject3 < Test::Unit::TestCase
+    def test_3_01
+      fo = OpenObject.new
+      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 TestOpenObject5 < Test::Unit::TestCase
+
+    def test_5_01
+      p = lambda { |x|
+        x.word = "Hello"
+      }
+      o = p.to_openobjrct
+      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