hashery 1.0.0

data/lib/hashery/openobject.rb

@@ -0,0 +1,279 @@
+require 'facets/basicobject'
+#require 'facets/hash/to_h'
+#require 'facets/kernel/object_class'
+#require 'facets/kernel/object_hexid'
+
+# = OpenObject
+#
+# OpenObject is very similar to Ruby's own OpenStruct, but it offers some
+# advantages. With OpenStruct, slots with the same name as predefined
+# Object methods can not be used. With OpenObject, almost any slot can be
+# defined. OpenObject is a subclass of BasicObject to ensure all method
+# slots, except those that are absolutely essential, are open for use.
+#
+#--
+# 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 #as_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}>
+#++
+#
+# Unlike a Hash, all OpenObject's keys are symbols and all keys are converted
+# to such using #to_sym on the fly.
+
+class OpenObject < BasicObject
+
+  #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 different than that of Hash.
+  # It does not take a default parameter, but an initial priming Hash,
+  # like OpenStruct. The initializer can still take a default block
+  # however. To set the default value use <code>#default!(value)</code>.
+  #
+  #   OpenObject.new(:a=>1).default!(0)
+  #
+  def initialize(hash=nil, &yld)
+    @hash = Hash.new(&yld)
+    if hash
+      hash.each{ |k,v| store(k,v) }
+    end
+  end
+
+  #
+  def initialize_copy( orig )
+    orig.each{ |k,v| store(k,v) }
+  end
+
+  # Object inspection.
+  # TODO: Need to get __class__ and __id__ in hex form.
+  def inspect
+    #@hash.inspect
+    hexid = __id__
+    klass = "OpenObject" # __class__
+    "#<#{klass}:#{hexid} #{@hash.inspect}>"
+  end
+
+  # Convert to an associative array.
+  def to_a
+    @hash.to_a
+  end
+
+  #
+  def to_h
+    @hash.dup
+  end
+
+  #
+  def to_hash
+    @hash.dup
+  end
+
+  #
+  def to_openobject
+    self
+  end
+
+  # Convert to an assignment procedure.
+  def to_proc(response=false)
+    hash = @hash
+    if response
+      lambda do |o|
+        hash.each do |k,v|
+          o.__send__("#{k}=", v) rescue nil
+        end
+      end
+    else
+      lambda do |o|
+        hash.each{ |k,v| o.__send__("#{k}=", v) }
+      end
+    end
+  end
+
+  # NOT SURE ABOUT THIS
+  def as_hash
+    @hash
+  end
+
+  # Is a given +key+ defined?
+  def key?(key)
+    @hash.key?(key.to_sym)
+  end
+
+  #
+  def is_a?(klass)
+    return true if klass == Hash  # TODO: Is this wise? How to fake a subclass?
+    return true if klass == OpenObject
+    false
+  end
+
+  # Iterate over each key-value pair.
+  def each(&yld)
+    @hash.each(&yld)
+  end
+
+  # Set the default value.
+  def default!(default)
+    @hash.default = default
+  end
+
+  # Check equality.
+  def ==( other )
+    case other
+    when OpenObject
+      @hash == other.as_hash
+    when Hash
+      @hash == other
+    else
+      if other.respond_to?(:to_hash)
+        @hash == other.to_hash
+      else
+        false
+      end
+    end
+  end
+
+  #
+  def eql?( other )
+    case other
+    when OpenObject
+      @hash.eql?(other.as_hash)
+    else
+      false
+    end
+  end
+
+  #
+  def <<(x)
+    case x
+    when Hash
+      @hash.update(x)
+    when Array
+      x.each_slice(2) do |(k,v)|
+        @hash[k] = v
+      end
+    end
+  end
+
+  #
+  def []=(k,v)
+    @hash[k.to_sym] = v
+  end
+
+  #
+  def [](k)
+    @hash[k.to_sym]
+  end
+
+  #
+  def merge!(other)
+    OpenObject.new(@hash.merge!(other))
+  end
+
+  #
+  def update!(other)
+    @hash.update(other)
+    self
+  end
+
+  protected
+
+    def store(k, v)
+      @hash.store(k.to_sym, v)
+    end
+
+    def fetch(k, *d, &b)
+      @hash.fetch(k.to_sym, *d, &b)
+    end
+
+    #def as_hash!
+    #  Functor.new do |op,*a,&b|
+    #    result = @hash.__send__(op,*a,&b)
+    #    case result
+    #    when Hash
+    #      OpenObject.new(result)
+    #    else
+    #      result
+    #    end
+    #  end
+    #end
+
+    #def define_slot(key, value=nil)
+    #  @hash[key.to_sym] = value
+    #end
+
+    #def protect_slot( key )
+    #  (class << self; self; end).class_eval {
+    #    protected key rescue nil
+    # }
+    #end
+
+    def method_missing(sym, *args, &blk)
+      type = sym.to_s[-1,1]
+      key  = sym.to_s.sub(/[=?!]$/,'').to_sym
+      case type
+      when '='
+        store(key, args[0])
+      when '!'
+        @hash.__send__(key, *args, &blk)
+      #  if key?(key)
+      #    fetch(key)
+      #  else
+      #    store(key, OpenObject.new)
+      #  end
+      when '?'
+        fetch(key)
+      else
+        fetch(key)
+      end
+    end
+
+end
+
+# Core Extensions
+
+class Hash
+  # Convert a Hash into an OpenObject.
+  def to_openobject
+    OpenObject[self]
+  end
+end
+
+=begin
+class NilClass
+  # Nil converts to an empty OpenObject.
+  def to_openobject
+    OpenObject.new
+  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
+=end
+

data/lib/hashery/orderedhash.rb

@@ -0,0 +1,417 @@
+# = OrderedHash
+#
+# The OrderedHash class is a Hash that preserves order.
+# So it has some array-like extensions also. By defualt
+# an OrderedHash object preserves insertion order, but any
+# order can be specified including alphabetical key order.
+#
+# == Usage
+#
+# Just require this file and use OrderedHash instead of Hash.
+#
+#   # You can do simply
+#   hsh = OrderedHash.new
+#   hsh['z'] = 1
+#   hsh['a'] = 2
+#   hsh['c'] = 3
+#   p hsh.keys     #=> ['z','a','c']
+#
+#   # or using OrderedHash[] method
+#   hsh = OrderedHash['z', 1, 'a', 2, 'c', 3]
+#   p hsh.keys     #=> ['z','a','c']
+#
+#   # but this don't preserve order
+#   hsh = OrderedHash['z'=>1, 'a'=>2, 'c'=>3]
+#   p hsh.keys     #=> ['a','c','z']
+#
+#   # OrderedHash has useful extensions: push, pop and unshift
+#   p hsh.push('to_end', 15)       #=> true, key added
+#   p hsh.push('to_end', 30)       #=> false, already - nothing happen
+#   p hsh.unshift('to_begin', 50)  #=> true, key added
+#   p hsh.unshift('to_begin', 60)  #=> false, already - nothing happen
+#   p hsh.keys                     #=> ["to_begin", "a", "c", "z", "to_end"]
+#   p hsh.pop                      #=> ["to_end", 15], if nothing remains, return nil
+#   p hsh.keys                     #=> ["to_begin", "a", "c", "z"]
+#   p hsh.shift                    #=> ["to_begin", 30], if nothing remains, return nil
+#
+# == Usage Notes
+#
+# * You can use #order_by to set internal sort order.
+# * #<< takes a two element [k,v] array and inserts.
+# * Use ::auto which creates Dictionay sub-entries as needed.
+# * And ::alpha which creates a new OrderedHash sorted by key.
+#
+# == Acknowledgments
+#
+# * Andrew Johnson (merge, to_a, inspect, shift and Hash[])
+# * Jeff Sharpe    (reverse and reverse!)
+# * Thomas Leitner (has_key? and key?)
+#
+# Ported from OrderHash 2.0, Copyright (c) 2005 Jan Molic
+
+class OrderedHash
+
+  include Enumerable
+
+  class << self
+    #--
+    # TODO is this needed? Doesn't the super class do this?
+    #++
+
+    def [](*args)
+      hsh = new
+      if Hash === args[0]
+        hsh.replace(args[0])
+      elsif (args.size % 2) != 0
+        raise ArgumentError, "odd number of elements for Hash"
+      else
+        while !args.empty?
+          hsh[args.shift] = args.shift
+        end
+      end
+      hsh
+    end
+
+    # Like #new but the block sets the order.
+    #
+    def new_by(*args, &blk)
+      new(*args).order_by(&blk)
+    end
+
+    # Alternate to #new which creates a dictionary sorted by key.
+    #
+    #   d = OrderedHash.alpha
+    #   d["z"] = 1
+    #   d["y"] = 2
+    #   d["x"] = 3
+    #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+    #
+    # This is equivalent to:
+    #
+    #   OrderedHash.new.order_by { |key,value| key }
+
+    def alpha(*args, &block)
+      new(*args, &block).order_by_key
+    end
+
+    # Alternate to #new which auto-creates sub-dictionaries as needed.
+    #
+    #   d = OrderedHash.auto
+    #   d["a"]["b"]["c"] = "abc"  #=> { "a"=>{"b"=>{"c"=>"abc"}}}
+    #
+    def auto(*args)
+      #AutoOrderedHash.new(*args)
+      leet = lambda { |hsh, key| hsh[key] = new(&leet) }
+      new(*args, &leet)
+    end
+  end
+
+   # New Dictiionary.
+
+  def initialize(*args, &blk)
+    @order = []
+    @order_by = nil
+    if blk
+      dict = self                                  # This ensure autmatic key entry effect the
+      oblk = lambda{ |hsh, key| blk[dict,key] }    # dictionary rather then just the interal hash.
+      @hash = Hash.new(*args, &oblk)
+    else
+      @hash = Hash.new(*args)
+    end
+  end
+
+  def order
+    reorder if @order_by
+    @order
+  end
+
+  # Keep dictionary sorted by a specific sort order.
+
+  def order_by( &block )
+    @order_by = block
+    order
+    self
+  end
+
+  # Keep dictionary sorted by key.
+  #
+  #   d = OrderedHash.new.order_by_key
+  #   d["z"] = 1
+  #   d["y"] = 2
+  #   d["x"] = 3
+  #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+  #
+  # This is equivalent to:
+  #
+  #   OrderedHash.new.order_by { |key,value| key }
+  #
+  # The initializer OrderedHash#alpha also provides this.
+
+  def order_by_key
+    @order_by = lambda { |k,v| k }
+    order
+    self
+  end
+
+  # Keep dictionary sorted by value.
+  #
+  #   d = OrderedHash.new.order_by_value
+  #   d["z"] = 1
+  #   d["y"] = 2
+  #   d["x"] = 3
+  #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+  #
+  # This is equivalent to:
+  #
+  #   OrderedHash.new.order_by { |key,value| value }
+
+  def order_by_value
+    @order_by = lambda { |k,v| v }
+    order
+    self
+  end
+
+  #
+  def reorder
+    if @order_by
+      assoc = @order.collect{ |k| [k,@hash[k]] }.sort_by(&@order_by)
+      @order = assoc.collect{ |k,v| k }
+    end
+    @order
+  end
+
+  #def ==( hsh2 )
+  #  return false if @order != hsh2.order
+  #  super hsh2
+  #end
+
+  def ==(hsh2)
+    if hsh2.is_a?( OrderedHash )
+      @order == hsh2.order &&
+      @hash  == hsh2.instance_variable_get("@hash")
+    else
+      false
+    end
+  end
+
+  def [] k
+    @hash[ k ]
+  end
+
+  def fetch(k, *a, &b)
+    @hash.fetch(k, *a, &b)
+  end
+
+  # Store operator.
+  #
+  #   h[key] = value
+  #
+  # Or with additional index.
+  #
+  #  h[key,index] = value
+
+  def []=(k, i=nil, v=nil)
+    if v
+      insert(i,k,v)
+    else
+      store(k,i)
+    end
+  end
+
+  def insert( i,k,v )
+    @order.insert( i,k )
+    @hash.store( k,v )
+  end
+
+  def store( a,b )
+    @order.push( a ) unless @hash.has_key?( a )
+    @hash.store( a,b )
+  end
+
+  def clear
+    @order = []
+    @hash.clear
+  end
+
+  def delete( key )
+    @order.delete( key )
+    @hash.delete( key )
+  end
+
+  def each_key
+    order.each { |k| yield( k ) }
+    self
+  end
+
+  def each_value
+    order.each { |k| yield( @hash[k] ) }
+    self
+  end
+
+  def each
+    order.each { |k| yield( k,@hash[k] ) }
+    self
+  end
+  alias each_pair each
+
+  def delete_if
+    order.clone.each { |k| delete k if yield(k,@hash[k]) }
+    self
+  end
+
+  def values
+    ary = []
+    order.each { |k| ary.push @hash[k] }
+    ary
+  end
+
+  def keys
+    order
+  end
+
+  def invert
+    hsh2 = self.class.new
+    order.each { |k| hsh2[@hash[k]] = k }
+    hsh2
+  end
+
+  def reject(&block)
+    self.dup.delete_if(&block)
+  end
+
+  def reject!( &block )
+    hsh2 = reject(&block)
+    self == hsh2 ? nil : hsh2
+  end
+
+  def replace(hsh2)
+    case hsh2
+    when Hash
+      @order = hsh2.keys
+      @hash  = hsh2
+    else
+      @order = hsh2.order
+      @hash  = hsh2.hash
+    end
+    reorder
+  end
+
+  def shift
+    key = order.first
+    key ? [key,delete(key)] : super
+  end
+
+  def unshift( k,v )
+    unless @hash.include?( k )
+      @order.unshift( k )
+      @hash.store( k,v )
+      true
+    else
+      false
+    end
+  end
+
+  def <<(kv)
+    push(*kv)
+  end
+
+  def push( k,v )
+    unless @hash.include?( k )
+      @order.push( k )
+      @hash.store( k,v )
+      true
+    else
+      false
+    end
+  end
+
+  def pop
+    key = order.last
+    key ? [key,delete(key)] : nil
+  end
+
+  def inspect
+    ary = []
+    each {|k,v| ary << k.inspect + "=>" + v.inspect}
+    '{' + ary.join(", ") + '}'
+  end
+
+  def dup
+    a = []
+    each{ |k,v| a << k; a << v }
+    self.class[*a]
+  end
+
+  def update( hsh2 )
+    hsh2.each { |k,v| self[k] = v }
+    reorder
+    self
+  end
+  alias :merge! update
+
+  def merge( hsh2 )
+    self.dup.update(hsh2)
+  end
+
+  def select
+    ary = []
+    each { |k,v| ary << [k,v] if yield k,v }
+    ary
+  end
+
+  def reverse!
+    @order.reverse!
+    self
+  end
+
+  def reverse
+    dup.reverse!
+  end
+
+  #
+  def first(x=nil)
+    return @hash[order.first] unless x
+    order.first(x).collect { |k| @hash[k] }
+  end
+
+  #
+  def last(x=nil)
+    return @hash[order.last] unless x
+    order.last(x).collect { |k| @hash[k] }
+  end
+
+  def length
+    @order.length
+  end
+  alias :size :length
+
+  def empty?
+    @hash.empty?
+  end
+
+  def has_key?(key)
+    @hash.has_key?(key)
+  end
+
+  def key?(key)
+    @hash.key?(key)
+  end
+
+  def to_a
+    ary = []
+    each { |k,v| ary << [k,v] }
+    ary
+  end
+
+  def to_s
+    self.to_a.to_s
+  end
+
+  def to_hash
+    @hash.dup
+  end
+
+  def to_h
+    @hash.dup
+  end
+end