hashery 1.3.0 → 1.4.0

data/.ruby

@@ -0,0 +1,98 @@
+--- 
+name: hashery
+company: RubyWorks
+title: Hashery
+contact: Trans <transfire@gmail.com>
+maintainers: 
+- Trans <transfire@gmail.com>
+pom_verison: 1.0.0
+requires: 
+- group: 
+  - build
+  name: syckle
+  version: 0+
+- group: 
+  - test
+  name: qed
+  version: 0+
+resources: 
+  repo: git://github.com/rubyworks/hashery.git
+  code: http://github.com/rubyworks/hashery
+  api: http://rubyworks.github.com/hashery/docs/api
+  mail: http://groups.google.com/group/rubyworks-mailinglist
+  host: http://rubygems.org/gems/hashery
+  wiki: http://wiki.github.com/rubyworks/hashery
+  home: http://rubyworks.github.com/hashery
+manifest: 
+- .ruby
+- lib/hashery/association.rb
+- lib/hashery/basic_struct.rb
+- lib/hashery/basicobject.rb
+- lib/hashery/basicstruct.rb
+- lib/hashery/casting_hash.rb
+- lib/hashery/castinghash.rb
+- lib/hashery/dictionary.rb
+- lib/hashery/fuzzy_hash.rb
+- lib/hashery/fuzzyhash.rb
+- lib/hashery/ini.rb
+- lib/hashery/linked_list.rb
+- lib/hashery/linkedlist.rb
+- lib/hashery/lru_hash.rb
+- lib/hashery/lruhash.rb
+- lib/hashery/memoizer.rb
+- lib/hashery/open_cascade.rb
+- lib/hashery/open_hash.rb
+- lib/hashery/open_object.rb
+- lib/hashery/opencascade.rb
+- lib/hashery/openhash.rb
+- lib/hashery/openobject.rb
+- lib/hashery/ordered_hash.rb
+- lib/hashery/orderedhash.rb
+- lib/hashery/ostructable.rb
+- lib/hashery/property_hash.rb
+- lib/hashery/propertyhash.rb
+- lib/hashery/query_hash.rb
+- lib/hashery/queryhash.rb
+- lib/hashery/sparse_array.rb
+- lib/hashery/sparsearray.rb
+- lib/hashery/stash.rb
+- lib/hashery/static_hash.rb
+- lib/hashery/statichash.rb
+- lib/hashery.rb
+- lib/hashery.yml
+- qed/01_openhash.rdoc
+- qed/02_queryhash.rdoc
+- qed/03_castinghash.rdoc
+- qed/04_statichash.rdoc
+- qed/05_association.rdoc
+- qed/06_opencascade.rdoc
+- qed/07_fuzzyhash.rdoc
+- qed/08_properyhash.rdoc
+- qed/09_ostructable.rdoc
+- qed/applique/ae.rb
+- test/case_association.rb
+- test/case_dictionary.rb
+- test/case_opencascade.rb
+- test/case_openhash.rb
+- test/case_openobject.rb
+- test/case_sparsearray.rb
+- test/case_stash.rb
+- HISTORY.rdoc
+- LICENSE
+- README.rdoc
+- NOTICE
+version: 1.4.0
+licenses: 
+- Apache 2.0
+copyright: Copyright (c) 2010 Thomas Sawyer
+description: The Hashery is a collection of Hash-like classes, spun-off from the original Ruby Facets library. Included are the widely used OrderedHash, the related but more featured Dictionary class, a number of open classes, similiar to the standard OpenStruct and a few variations on the standard Hash.
+summary: Facets-bread collection of Hash-like classes.
+authors: 
+- Thomas Sawyer
+- Kirk Haines
+- Robert Klemme
+- Jan Molic
+- George Moschovitis
+- Jeena Paradies
+- Erik Veenstra
+created: 2010-04-21

data/HISTORY.rdoc

@@ -1,6 +1,19 @@
 = RELEASE HISTORY
 
-== 1.3.0 // 2010-10-01
+== 1.4.0 / 2011-01-19
+
+This release includes a copy of Ruby Facets' BasicObject class, which
+fixes the loading bug of the previous version. This release also renames
+OpenObject to BasicStruct, which is a much better destription of what the
+class actually provides.
+
+Changes:
+
+* Rename OpenObject to BasicStruct.
+* Fix basicobject.rb loading issue.
+
+
+== 1.3.0 / 2010-10-01
 
 This release fixes a minor bug in CastingHash and adds a new
 PropertyHash class.
@@ -16,7 +29,7 @@ Changes:
   * Fixed CastingHash#new where #to_proc is called against NilClass
 
 
-== 1.2.0 // 2010-06-04
+== 1.2.0 / 2010-06-04
 
 This release makes two signifficant changes to the Hashery.
 First, we have a new shiny library called FuzzyHash by
@@ -37,7 +50,7 @@ Changes:
   * OpenCascade subclasses OpenHash and handles Array cascading.
 
 
-== 1.1.0 // 2010-04-28
+== 1.1.0 / 2010-04-28
 
 A follow-up release of Hashery that adds two new libraries:
 Association and SparseArray. Both of these may seem like odd
@@ -56,7 +69,7 @@ Changes:
   * Added sparsearray.rb
 
 
-== 1.0.0 // 2010-04-21
+== 1.0.0 / 2010-04-21
 
 This is the first release of the Facets Hashery.
 Most of included classes come directly from Ruby

data/NOTICE

@@ -0,0 +1,11 @@
+= COPYRIGHT NOTICES
+
+== BasicObject
+
+BasicObject class is a variation of Jim Weirich's BlankSlate class.
+
+  BlankSlate
+  Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
+  All rights reserved.
+
+

data/lib/hashery.rb

@@ -1,10 +1,10 @@
+require 'hashery/basicstruct'
 require 'hashery/castinghash'
 require 'hashery/dictionary'
 require 'hashery/lruhash'
 require 'hashery/memoizer'
 require 'hashery/opencascade'
 require 'hashery/openhash'
-require 'hashery/openobject'
 require 'hashery/orderedhash'
 require 'hashery/ostructable'
 require 'hashery/queryhash'

data/lib/hashery.yml

@@ -0,0 +1,98 @@
+--- 
+name: hashery
+company: RubyWorks
+title: Hashery
+contact: Trans <transfire@gmail.com>
+maintainers: 
+- Trans <transfire@gmail.com>
+pom_verison: 1.0.0
+requires: 
+- group: 
+  - build
+  name: syckle
+  version: 0+
+- group: 
+  - test
+  name: qed
+  version: 0+
+resources: 
+  repo: git://github.com/rubyworks/hashery.git
+  code: http://github.com/rubyworks/hashery
+  api: http://rubyworks.github.com/hashery/docs/api
+  mail: http://groups.google.com/group/rubyworks-mailinglist
+  host: http://rubygems.org/gems/hashery
+  wiki: http://wiki.github.com/rubyworks/hashery
+  home: http://rubyworks.github.com/hashery
+manifest: 
+- .ruby
+- lib/hashery/association.rb
+- lib/hashery/basic_struct.rb
+- lib/hashery/basicobject.rb
+- lib/hashery/basicstruct.rb
+- lib/hashery/casting_hash.rb
+- lib/hashery/castinghash.rb
+- lib/hashery/dictionary.rb
+- lib/hashery/fuzzy_hash.rb
+- lib/hashery/fuzzyhash.rb
+- lib/hashery/ini.rb
+- lib/hashery/linked_list.rb
+- lib/hashery/linkedlist.rb
+- lib/hashery/lru_hash.rb
+- lib/hashery/lruhash.rb
+- lib/hashery/memoizer.rb
+- lib/hashery/open_cascade.rb
+- lib/hashery/open_hash.rb
+- lib/hashery/open_object.rb
+- lib/hashery/opencascade.rb
+- lib/hashery/openhash.rb
+- lib/hashery/openobject.rb
+- lib/hashery/ordered_hash.rb
+- lib/hashery/orderedhash.rb
+- lib/hashery/ostructable.rb
+- lib/hashery/property_hash.rb
+- lib/hashery/propertyhash.rb
+- lib/hashery/query_hash.rb
+- lib/hashery/queryhash.rb
+- lib/hashery/sparse_array.rb
+- lib/hashery/sparsearray.rb
+- lib/hashery/stash.rb
+- lib/hashery/static_hash.rb
+- lib/hashery/statichash.rb
+- lib/hashery.rb
+- lib/hashery.yml
+- qed/01_openhash.rdoc
+- qed/02_queryhash.rdoc
+- qed/03_castinghash.rdoc
+- qed/04_statichash.rdoc
+- qed/05_association.rdoc
+- qed/06_opencascade.rdoc
+- qed/07_fuzzyhash.rdoc
+- qed/08_properyhash.rdoc
+- qed/09_ostructable.rdoc
+- qed/applique/ae.rb
+- test/case_association.rb
+- test/case_dictionary.rb
+- test/case_opencascade.rb
+- test/case_openhash.rb
+- test/case_openobject.rb
+- test/case_sparsearray.rb
+- test/case_stash.rb
+- HISTORY.rdoc
+- LICENSE
+- README.rdoc
+- NOTICE
+version: 1.4.0
+licenses: 
+- Apache 2.0
+copyright: Copyright (c) 2010 Thomas Sawyer
+description: The Hashery is a collection of Hash-like classes, spun-off from the original Ruby Facets library. Included are the widely used OrderedHash, the related but more featured Dictionary class, a number of open classes, similiar to the standard OpenStruct and a few variations on the standard Hash.
+summary: Facets-bread collection of Hash-like classes.
+authors: 
+- Thomas Sawyer
+- Kirk Haines
+- Robert Klemme
+- Jan Molic
+- George Moschovitis
+- Jeena Paradies
+- Erik Veenstra
+created: 2010-04-21

data/lib/hashery/basic_struct.rb

@@ -0,0 +1 @@
+require 'hashery/superstruct'

data/lib/hashery/basicobject.rb

@@ -0,0 +1,74 @@
+# Facets' BasicObject is an implementation of Jim Weirich's BlankSlate.
+#
+# BlankSlate
+# Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+#
+# Since Ruby 1.9 has a BasicObject class this will of course be
+# deprecated as 1.9 goes mainstream.
+
+unless defined? BasicObject  # in case it already exists!
+
+  # BasicObject provides an abstract base class with no predefined
+  # methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+  # BlankSlate is useful as a base class when writing classes that
+  # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+  class BasicObject
+    class << self
+      # Hide the method named +name+ in the BlankSlate class.  Don't
+      # hide +instance_eval+ or any method beginning with "__".
+      #
+      # According to 1.9.1 it should have only these methods:
+      #
+      # * #__send__
+      # * #instance_eval
+      # * #instance_exec
+      # * #equal?
+      # * #==
+      # * #!
+      # * #!=
+      # * respond_to?
+      #
+      # Seems to me it should have #__id__ too.
+      def hide(name)
+        undef_method name if
+          instance_methods.include?(name.to_s) and
+          name !~ /^(__|respond_to\?|instance_eval$|instance_exec$|equal\?$|\=\=$)/
+      end
+    end
+    instance_methods.each{ |m| hide(m) }
+  end
+
+  # Since Ruby is very dynamic, methods added to the ancestors of
+  # BlankSlate <em>after BlankSlate is defined</em> will show up in the
+  # list of available BlankSlate methods.  We handle this by defining a
+  # hook in the Object and Kernel classes that will hide any defined
+  module Kernel #:nodoc:
+    class << self
+      alias_method :basic_object_method_added, :method_added
+
+      # Detect method additions to Kernel and remove them in the
+      # BlankSlate class.
+      def method_added(name)
+        basic_object_method_added(name)
+        return if self != Kernel
+        BasicObject.hide(name)
+      end
+    end
+  end
+
+  class Object #:nodoc:
+    class << self
+      alias_method :basic_object_method_added, :method_added
+
+      # Detect method additions to Object and remove them in the
+      # BlankSlate class.
+      def method_added(name)
+        basic_object_method_added(name)
+        return if self != Object
+        BasicObject.hide(name)
+      end
+    end
+  end
+
+end

data/lib/hashery/basicstruct.rb

@@ -0,0 +1,280 @@
+require 'hashery/basicobject'
+
+#require 'facets/hash/to_h'
+#require 'facets/kernel/object_class'
+#require 'facets/kernel/object_hexid'
+
+# = BasicStruct
+#
+# BasicObject is very similar to Ruby's own OpenStruct, but it offers some
+# advantages. With OpenStruct, slots with the same name as predefined
+# Object methods cannot be used. With BasicObject, almost any slot can be
+# defined. BasicObject 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 BasicObject 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 BasicObject on return.
+#
+#   o = BasicObject.new(:a=>1,:b=>2)
+#   o.as_hash!{ |h| h.update(:a=>6) }
+#   o #=> #<BasicObject {:a=>6,:b=>2}>
+#++
+#
+# Unlike a Hash, all BasicObject's keys are symbols and all keys are converted
+# to such using #to_sym on the fly.
+
+class BasicStruct < 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 BasicObject 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>.
+  #
+  #   BasicObject.new(:a=>1).default!(0)
+  #
+  def initialize(hash=nil, &yld)
+    @table = 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
+    #@table.inspect
+    hexid = __id__
+    klass = "BasicObject" # __class__
+    "#<#{klass}:#{hexid} #{@table.inspect}>"
+  end
+
+  # Convert to an associative array.
+  def to_a
+    @table.to_a
+  end
+
+  #
+  def to_h
+    @table.dup
+  end
+
+  #
+  def to_hash
+    @table.dup
+  end
+
+  #
+  def to_basicstruct
+    self
+  end
+
+  # Convert to an assignment procedure.
+  def to_proc(response=false)
+    hash = @table
+    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
+    @table
+  end
+
+  # Is a given +key+ defined?
+  def key?(key)
+    @table.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 == BasicObject
+    false
+  end
+
+  # Iterate over each key-value pair.
+  def each(&yld)
+    @table.each(&yld)
+  end
+
+  # Set the default value.
+  def default!(default)
+    @table.default = default
+  end
+
+  # Check equality.
+  def ==( other )
+    case other
+    when BasicObject
+      @table == other.as_hash
+    when Hash
+      @table == other
+    else
+      if other.respond_to?(:to_hash)
+        @table == other.to_hash
+      else
+        false
+      end
+    end
+  end
+
+  #
+  def eql?( other )
+    case other
+    when BasicObject
+      @table.eql?(other.as_hash)
+    else
+      false
+    end
+  end
+
+  #
+  def <<(x)
+    case x
+    when Hash
+      @table.update(x)
+    when Array
+      x.each_slice(2) do |(k,v)|
+        @table[k] = v
+      end
+    end
+  end
+
+  #
+  def []=(key, value)
+    @table[key.to_sym] = value
+  end
+
+  #
+  def [](key)
+    @table[key.to_sym]
+  end
+
+  #
+  def merge!(other)
+    BasicObject.new(@table.merge!(other))
+  end
+
+  #
+  def update!(other)
+    @table.update(other)
+    self
+  end
+
+  protected
+
+    def store(k, v)
+      @table.store(k.to_sym, v)
+    end
+
+    def fetch(k, *d, &b)
+      @table.fetch(k.to_sym, *d, &b)
+    end
+
+    #def as_hash!
+    #  Functor.new do |op,*a,&b|
+    #    result = @table.__send__(op,*a,&b)
+    #    case result
+    #    when Hash
+    #      BasicObject.new(result)
+    #    else
+    #      result
+    #    end
+    #  end
+    #end
+
+    #def define_slot(key, value=nil)
+    #  @table[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 '!'
+        @table.__send__(key, *args, &blk)
+      #  if key?(key)
+      #    fetch(key)
+      #  else
+      #    store(key, BasicObject.new)
+      #  end
+      when '?'
+        fetch(key)
+      else
+        fetch(key)
+      end
+    end
+
+end
+
+# Core Extensions
+
+class Hash
+  # Convert a Hash into a BasicStruct.
+  def to_basicstruct
+    BasicStruct[self]
+  end
+end
+
+=begin
+class NilClass
+  # Nil converts to an empty BasicObject.
+  def to_basicstruct
+    BasicObject.new
+  end
+end
+
+class Proc
+  # Translates a Proc into an BasicObject. By droping an BasicObject into
+  # the Proc, the resulting assignments incured as the procedure is
+  # evaluated produce the BasicObject. This technique is simlar to that
+  # of MethodProbe.
+  #
+  #   p = lambda { |x|
+  #     x.word = "Hello"
+  #   }
+  #   o = p.to_basicstruct
+  #   o.word #=> "Hello"
+  #
+  # NOTE The Proc must have an arity of one --no more and no less.
+  def to_basicstruct
+    raise ArgumentError, 'bad arity for converting Proc to basicstruct' if arity != 1
+    o = BasicObject.new
+    self.call( o )
+    o
+  end
+end
+=end
+