facets 1.8.54 → 2.0.0

data/lib/more/facets/openobject.rb

@@ -0,0 +1,362 @@
+# TITLE:
+#
+#   OpenObject
+#
+# DESCRIPTION:
+#
+#   Similar to Ruby's own OpenStruct, but alittle more bold.
+#   It will override any method, where as OpenStruct will not.
+#
+# AUTHOR:
+#
+#   - Thomas Sawyer
+#   - George Moschovitis
+#
+# LICENSE:
+#
+#   Copyright (c) 2005 Thomas Sawyer, George Moschovitis
+#
+#   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.
+
+
+require 'facets/conversion'   # to_h, to_proc
+require 'facets/kernel/object' # object_class, object_hexid
+
+# = OpenObject
+#
+# OpenObject is very similar to Ruby's own OpenStruct, but it offers some
+# useful advantages. With OpenStruct slots with the same name's as predefined
+# Object methods can not be used. With OpenObject any slot can be defined,
+# OpendObject is also a bit faster becuase it is based on a Hash, not
+# method signitures.
+#
+# Because OpenObject is a subclass of Hash, it can do just about
+# everything a Hash can do, except that most public methods have been
+# made protected and thus available only internally or via #send.
+#
+# 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 aware of this. OpenObject should be used in well
+# controlled scenarios.
+#
+# If you wish to pass an OpenObject to a routine that normal takes a Hash,
+# but are uncertain it can handle the distictions properly  you can convert
+# easily to a Hash using #to_hash! and the result will automatically be
+# converted back to an OpenObject on return.
+#
+#   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 OpenObject.
+
+  def to_openobject
+    OpenObject.new
+  end
+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
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=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_openobject
+      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

data/lib/more/facets/orderedhash.rb

@@ -0,0 +1,42 @@
+# TITLE:
+#
+#   OrderedHash
+#
+# DESCRIPTION:
+#
+#   Another name for Dictionary.
+#
+# LICENSE:
+#
+#   Copyright (c) 2005 Thomas Sawyer, George Moschovitis
+#
+#   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.
+#
+# TODO:
+#
+#   - Make this an alternative to Dictionary that
+#     is more "slim", not having the extra sorting
+#     features of dictionary.
+
+
+require 'facets/dictionary'
+
+# = OrderedHash
+#
+# OrderedHash is an alias for the Dictionary class
+
+OrderedHash = Dictionary
+
+# = AutoOrderedHash
+#
+# AutoOrderedHash is an alias for the AutoDictionary class
+
+#AutoOrderedHash = AutoDictionary  # was replaced by Dictionary.auto() (or autonew?)
+

data/lib/more/facets/ostruct.rb

@@ -0,0 +1,314 @@
+# TITLE:
+#
+#   OpenStruct
+#
+# DESCRIPTION:
+#
+#   Ruby's standard OpenStruct with a few extensions added-in.
+#
+# AUTHOR:
+#
+#   - Thomas Sawyer
+#
+# LICENSE:
+#
+#   Copyright (c) 2005 Thomas Sawyer, George Moschovitis
+#
+#   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.
+#
+# LOG:
+#   - 2006-11-04 trans  Deprecate #instance in favor of #instance_delegate.
+#   - 2007-04-15 trans  Filled out with actual methods, used "ostruct_" for some accessors.
+
+
+require 'ostruct'
+
+class OpenStruct
+
+  def to_h
+    @table
+  end
+
+  # Access a value in the OpenStruct by key, like a Hash.
+  # This increases OpenStruct's "duckiness".
+  #
+  #   o = OpenStruct.new
+  #   o.t = 4
+  #   o['t']  #=> 4
+  #
+  def [](key)
+    key = key.to_sym unless key.is_a?(Symbol)
+    @table[key]
+  end
+
+  # Set a value in the OpenStruct by key, like a Hash.
+  #
+  #   o = OpenStruct.new
+  #   o['t'] = 4
+  #   o.t  #=> 4
+  #
+  def []=(key,val)
+    raise TypeError, "can't modify frozen #{self.class}", caller(1) if self.frozen?
+    key = key.to_sym unless key.is_a?(Symbol)
+    @table[key]=val
+  end
+
+  # CREDIT Robert J. Berger <rberger AT ibd.com>
+  # Thanks for reporting issues that this method resolved.
+
+  # Provides access to an OpenStruct's inner table.
+  #
+  #   o = OpenStruct.new
+  #   o.a = 1
+  #   o.b = 2
+  #   o.instance_delegate.each { |k, v| puts "#{k} #{v}" }
+  #
+  # produces
+  #
+  #   a 1
+  #   b 2
+  #
+  #
+  def instance_delegate
+    @table
+  end
+  alias ostruct_delegate instance_delegate
+
+  # Insert/update hash data on the fly.
+  #
+  #   o = OpenStruct.new
+  #   o.ostruct_update { :a => 2 }
+  #   o.a  #=> 2
+  #
+  def ostruct_update(other)
+    hash = other.to_hash  #to_h ?
+    for k,v in hash
+      @table[k.to_sym] = v
+    end
+    self
+  end
+
+  # Merge hash data creating a new OpenStruct object.
+  #
+  #   o = OpenStruct.new
+  #   o.ostruct_merge { :a => 2 }
+  #   o.a  #=> 2
+  #
+  def ostruct_merge(other)
+    o = dup
+    o.ostruct_update(other)
+    o
+  end
+
+  ##
+  # TO BE DEPRECATED
+  # Must consider that accessing instance_delegate instead can be dangerous.
+  # Might we us a Functor to ensure the table keys are always symbols?
+  ##
+
+  # Insert/update hash data on the fly.
+  #
+  #   o = OpenStruct.new
+  #   o.ostruct_update { :a => 2 }
+  #   o.a  #=> 2
+  #
+  def __update__( other )
+    hash = other.to_h
+    for k,v in hash
+      @table[k.to_sym] = v
+    end
+    self
+  end
+
+  # Merge hash data creating a new OpenStruct object.
+  #
+  #   o = OpenStruct.new
+  #   o.ostruct_merge { :a => 2 }
+  #   o.a  #=> 2
+  #
+  def __merge__( other )
+    o = dup
+    o.__update__( other )
+    o
+  end
+end
+
+
+class Hash
+
+  # Turns a hash into a generic object using an OpenStruct.
+  #
+  #   o = { 'a' => 1 }.to_ostruct
+  #   o.a  #=> 1
+  #
+  def to_ostruct
+    OpenStruct.new(self)
+  end
+
+  # CREDIT Alison Rowland
+  # CREDIT Jamie Macey
+  # CREDIT Mat Schaffer
+
+  #--
+  # Special thanks to Alison Rowland, Jamie Macey and Mat Schaffer
+  # for inspiring recursive improvements.
+  #++
+
+  # Like to_ostruct but recusively objectifies all hash elements as well.
+  #
+  #     o = { 'a' => { 'b' => 1 } }.to_ostruct_recurse
+  #     o.a.b  #=> 1
+  #
+  # The +exclude+ parameter is used internally to prevent infinite
+  # recursion and is not intended to be utilized by the end-user.
+  # But for more advance use, if there is a particular subhash you
+  # would like to prevent from being converted to an OpoenStruct
+  # then include it in the +exclude+ hash referencing itself. Eg.
+  #
+  #     h = { 'a' => { 'b' => 1 } }
+  #     o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
+  #     o.a['b']  #=> 1
+  #
+  def to_ostruct_recurse( exclude={} )
+    return exclude[self] if exclude.key?( self )
+    o = exclude[self] = OpenStruct.new
+    h = self.dup
+    each_pair do |k,v|
+      h[k] = v.to_ostruct_recurse( exclude ) if v.respond_to?( :to_ostruct_recurse )
+    end
+    o.__update__( h )
+  end
+
+end
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TestOpenStruct < Test::Unit::TestCase
+
+    def setup
+      @o = OpenStruct.new(:q => 1)
+    end
+
+    def test_update
+      o = OpenStruct.new( { :a => 1 } )
+      h = { :b => 2 }
+      assert_nothing_raised { o.__update__( h ) }
+      assert_equal( 2, o.b )
+    end
+
+    def test_merge_1
+      o = OpenStruct.new( { :a => 1 } )
+      h = { :b => 2 }
+      q = o.__merge__( h )
+      assert_equal( 1, q.a )
+      assert_equal( 2, q.b )
+    end
+
+    def test_merge_2
+      o1 = OpenStruct.new( { :a => 1 } )
+      o2 = OpenStruct.new( { :b => 2 } )
+      q = o1.__merge__( o2 )
+      assert_equal( 1, q.a )
+      assert_equal( 2, q.b )
+    end
+
+    def test_store
+      @o.instance_delegate.store(:a,1)
+      assert_equal( 1, @o.a )
+    end
+
+    def test_update
+      @o.instance_delegate.update(:a=>1)
+      assert_equal( 1, @o.a )
+    end
+
+    def test_op_fetch
+      o = OpenStruct.new( { :a => 1 } )
+      assert_equal( 1, o[:a] )
+    end
+
+    def test_op_store
+      o = OpenStruct.new( { :a => 1 } )
+      assert_nothing_raised { o[:b] = 2 }
+      assert_equal( 2, o.b )
+    end
+
+    def test_update
+      o = OpenStruct.new( { :a => 1 } )
+      h = { :b => 2 }
+      assert_nothing_raised { o.__update__( h ) }
+      assert_equal( 2, o.b )
+    end
+
+    def test_merge_1
+      o = OpenStruct.new( { :a => 1 } )
+      h = { :b => 2 }
+      q = o.__merge__( h )
+      assert_equal( 1, q.a )
+      assert_equal( 2, q.b )
+    end
+
+    def test_merge_2
+      o1 = OpenStruct.new( { :a => 1 } )
+      o2 = OpenStruct.new( { :b => 2 } )
+      q = o1.__merge__( o2 )
+      assert_equal( 1, q.a )
+      assert_equal( 2, q.b )
+    end
+
+  end
+
+
+  class TestHashToOpenStruct < Test::Unit::TestCase
+
+    def test_to_ostruct
+      a = { :a => 1, :b => 2, :c => 3 }
+      ao = a.to_ostruct
+      assert_equal( a[:a], ao.a )
+      assert_equal( a[:b], ao.b )
+      assert_equal( a[:c], ao.c )
+    end
+
+    def test_to_ostruct_recurse
+      a = { :a => 1, :b => 2, :c => { :x => 4 } }
+      ao = a.to_ostruct_recurse
+      assert_equal(  a[:a], ao.a )
+      assert_equal(  a[:b], ao.b )
+      assert_equal(  a[:c][:x], ao.c.x )
+    end
+
+    def test_to_ostruct_recurse_with_recursion
+      a = {}
+      a[:a] = a
+      ao = a.to_ostruct_recurse
+      assert_equal( ao, ao.a )
+    end
+
+    def test_to_ostruct_advanced
+      h = { 'a' => { 'b' => 1 } }
+      o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
+      assert_equal( 1, o.a['b'] )
+      assert( Hash === o.a )
+    end
+
+  end
+
+=end