facets 1.7.46 → 1.8.0

data/lib/facets/more/multiton.rb

@@ -1,6 +1,6 @@
 # = multiton.rb
 #
-# == Copyright (c) 2005 Florian Frank, Thomas Sawyer
+# == Copyright (c) 2005 Ara T. Howard, Thomas Sawyer
 #
 #   Ruby License
 #
@@ -13,11 +13,11 @@
 #
 # == Author(s)
 #
-# * Florian Frank
-# * Thomas Sawyer
+# CREDIT Ara T. Howard
+# CREDIT Thomas Sawyer
 
-# Author::    Florian Frank, Thomas Sawyer
-# Copyright:: Copyright (c) 2005 Florian Frank, Thomas Sawyer
+# Author::    Ara T. Howard, Thomas Sawyer
+# Copyright:: Copyright (c) 2005 Ara T. Howard
 # License::   Ruby License
 
 # = Multiton
@@ -47,14 +47,14 @@
 #
 # == Previous Behavior
 #
-# In previous versions of Multion the #new method was made
+# In previous versions of Multiton the #new method was made
 # private and #instance was used in its stay --just like Singleton.
 # But this has proved less desirable for Multiton since Multitions can
 # have multiple instances, not just one.
 #
 # So instead Multiton now defines #create as a private alias of
-# the original #new method (jus tin case it is needed) and then
-# defines #new to handle the multion, and #instance is provided
+# the original #new method (just in case it is needed) and then
+# defines #new to handle the multiton, and #instance is provided
 # as an alias for it.
 #
 # So if you must have the old behavior, all you need do is re-alias
@@ -100,38 +100,57 @@ module Multiton
   MULTITON_NEW_HOOK = :multiton_new
 
   def self.append_features( klass )
-
     class << klass
+      unless method_defined?(MULTITON_NEW_HOOK)
+        alias_method MULTITON_NEW_HOOK, :new
+      end
 
-      alias_method :create, :new
-      private :create
+      def instance(*args, &block)
+        k = begin
+          # if the class defined 'multiton_id' we use this as the key
+          send MULTITON_ID_HOOK, *args, &block
+        rescue NameError
+          # otherwise we simply use the argument list
+          args
+        end
+
+        k = begin
+          Marshal.dump(k)
+        rescue TypeError
+          k
+        end
 
-      def new(*args, &block)
-        # if the class defined 'multiton_id' we use this as the key
-        # otherwise we simply use the argument list.
-        k = (respond_to?(MULTITON_ID_HOOK) ? send(MULTITON_ID_HOOK, *args, &block) : args)
-        unless (obj = (POOLS[self] ||= {})[k])
+        unless obj = (POOLS[self] ||= {})[k]
           begin
             critical = Thread.critical
             Thread.critical = true
-            if self.respond_to?(MULTITON_NEW_HOOK)
-              obj = (POOLS[self][k] = self.send(MULTITON_NEW_HOOK, *args, &block))
-            else
-              obj = (POOLS[self][k] = super)
-            end
+            obj = (POOLS[self][k] = send(MULTITON_NEW_HOOK, *args, &block))
           ensure
             Thread.critical = critical # restore state
           end
         end
+
         return obj
       end
 
-      alias_method :instance, :new
-
+      alias_method :create, :new
+      alias_method :new, :instance
     end
-
   end
 
+  # Recursive dehash function. This converts hash into associative
+  # arrays, and any hashes that contains, etc.
+  #def self.dehash(arg)
+  #  case arg
+  #  when Hash
+  #    arg.to_a.collect{|a| dehash(a)}
+  #  when Array
+  #    arg.collect{|a| dehash(a)}
+  #  else
+  #    arg
+  #  end
+  #end
+
 end
 
 #--

data/lib/facets/more/opencascade.rb

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

data/lib/facets/more/openhash.rb

@@ -0,0 +1,350 @@
+# = openhash.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
+
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2005 Thomas Sawyer
+# License::   Ruby License
+
+require 'facets/core/hash/to_h'
+require 'facets/core/hash/to_proc'
+require 'facets/core/kernel/object_class'
+require 'facets/core/kernel/object_hexid'
+#require 'facets/core/hash/symbolize_keys'
+#require 'facets/more/methodfilter'
+
+# = OpenHash
+#
+# OpenHash is similar to OpenStruct, but differs in a couple ways.
+#
+# OpenHash 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.
+#
+# OpenHash 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. OpenHash 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 OpenHash when finished. To facilitate this the method
+# #as_hash! is provided.
+#
+#   o = OpenHash.new(:a=>1,:b=>2)
+#   o.as_hash!{ |h| h.update(:a=>6) }
+#   o #=> #<OpenHash {:a=>6,:b=>2}>
+#
+# Finally, unlike a regular Hash, all OpenHash's keys are symbols and
+# all keys are converted to such using #to_sym on the fly.
+
+class OpenHash < 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 OpenHash 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)++.
+  #
+  #   OpenHash(: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_openhash() self end
+
+  # Iterate over each key-value pair. (Careful, this can be clobbered!)
+
+  def each(&yld) super(&yld) end
+
+  # Merge one OpenHash with another creating a new OpenHash.
+
+  def merge( other )
+    d = dup
+    d.send(:update, other)
+    d
+  end
+
+  # Update this OpenHash with another.
+
+  def update( other )
+    begin
+      other.each { |k,v| define_slot(k,v) }
+    rescue
+      other = other.to_h
+      retry
+    end
+  end
+
+  # Set the default value.
+
+  def default!(default)
+    self.default = default
+  end
+
+  # Preform inplace action on OpenHash 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 OpenHash === 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.
+
+  def to_openhash
+    OpenHash.new
+  end
+end
+
+class Hash
+  # Convert a Hash into an OpenHash.
+
+  def to_openhash
+    OpenHash[self]
+  end
+end
+
+class Proc
+  # Translates a Proc into an OpenHash. By droping an OpenHash into
+  # the Proc, the resulting assignments incured as the procedure is
+  # evaluated produce the OpenHash. This technique is simlar to that
+  # of MethodProbe.
+  #
+  #   p = lambda { |x|
+  #     x.word = "Hello"
+  #   }
+  #   o = p.to_openhash
+  #   o.word #=> "Hello"
+  #
+  # NOTE The Proc must have an arity of one --no more and no less.
+
+  def to_openhash
+    raise ArgumentError, 'bad arity for converting Proc to openhash' if arity != 1
+    o = OpenHash.new
+    self.call( o )
+    o
+  end
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  class TestOpenHash1 < Test::Unit::TestCase
+
+    def test_1_01
+      o = OpenHash.new
+      assert( o.respond_to?(:key?) )
+    end
+
+    def test_1_02
+      assert_instance_of( OpenHash, OpenHash[{}] )
+    end
+
+    def test_1_03
+      f0 = OpenHash.new
+      f0[:a] = 1
+      #assert_equal( [1], f0.to_a )
+      assert_equal( {:a=>1}, f0.to_h )
+    end
+
+    def test_1_04
+      f0 = OpenHash[:a=>1]
+      f0[:b] = 2
+      assert_equal( {:a=>1,:b=>2}, f0.to_h )
+    end
+
+    def test_1_05
+      f0 = OpenHash[:class=>1]
+      assert_equal( 1, f0.class )
+    end
+  end
+
+  class TestOpenHash2 < Test::Unit::TestCase
+
+    def test_2_01
+      f0 = OpenHash[:f0=>"f0"]
+      h0 = { :h0=>"h0" }
+      assert_equal( OpenHash[:f0=>"f0", :h0=>"h0"], f0.send(:merge,h0) )
+      assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
+    end
+
+    def test_2_02
+      f1 = OpenHash[:f1=>"f1"]
+      h1 = { :h1=>"h1" }
+      f1.send(:update,h1)
+      h1.update( f1 )
+      assert_equal( OpenHash[:f1=>"f1", :h1=>"h1"], f1 )
+      assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
+    end
+
+    def test_2_03
+      o = OpenHash[:a=>1,:b=>{:x=>9}]
+      assert_equal( 9, o[:b][:x] )
+      assert_equal( 9, o.b[:x] )
+    end
+
+    def test_2_04
+      o = OpenHash["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 TestOpenHash3 < Test::Unit::TestCase
+    def test_3_01
+      fo = OpenHash.new
+      9.times{ |i| fo.send( "n#{i}=", 1 ) }
+      9.times{ |i|
+        assert_equal( 1, fo.send( "n#{i}" ) )
+      }
+    end
+  end
+
+  class TestOpenHash4 < Test::Unit::TestCase
+
+    def test_4_01
+      ho = {}
+      fo = OpenHash.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 TestOpenHash5 < Test::Unit::TestCase
+
+    def test_5_01
+      p = lambda { |x|
+        x.word = "Hello"
+      }
+      o = p.to_openhash
+      assert_equal( "Hello", o.word )
+    end
+
+    def test_5_02
+      p = lambda { |x|
+        x.word = "Hello"
+      }
+      o = OpenHash[:a=>1,:b=>2]
+      assert_instance_of( Proc, o.to_proc )
+    end
+
+  end
+
+=end