hashery 1.2.0 → 1.3.0

data/{HISTORY → HISTORY.rdoc}

@@ -1,5 +1,21 @@
 = RELEASE HISTORY
 
+== 1.3.0 // 2010-10-01
+
+This release fixes a minor bug in CastingHash and adds a new
+PropertyHash class.
+
+Changes:
+
+* 1 New Library
+
+  * Added PropertyHash
+
+* 1 Bug Fix
+
+  * Fixed CastingHash#new where #to_proc is called against NilClass
+
+
 == 1.2.0 // 2010-06-04
 
 This release makes two signifficant changes to the Hashery.

data/LICENSE

@@ -1,23 +1,206 @@
-The MIT License
+.
 
-Copyright (c) 2005 Thomas Sawyer
+                             Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+   1. Definitions.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
 
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+.
 

data/PROFILE

@@ -0,0 +1,35 @@
+--- 
+title: Hashery
+suite: rubyworks
+summary: Facets bread collection of Hash-like classes.
+license: MIT
+contact: Trans <transfire@gmail.com>
+created: 2010-04-21
+
+authors:
+  - Thomas Sawyer
+  - Kirk Haines
+  - Robert Klemme
+  - Jan Molic
+  - George Moschovitis
+  - Jeena Paradies
+  - Erik Veenstra
+
+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.
+
+resources:
+  home  : http://rubyworks.github.com/hashery
+  code  : http://github.com/rubyworks/hashery
+  mail  : http://groups.google.com/group/rubyworks-mailinglist
+  api   : http://rubyworks.github.com/hashery/docs/api
+  host  : http://rubygems.org/gems/hashery
+  wiki  : http://wiki.github.com/rubyworks/hashery
+  repo  : git://github.com/rubyworks/hashery.git
+
+copyright:
+  Copyright (c) 2010 Thomas Sawyer

data/README.rdoc

@@ -25,7 +25,7 @@ Please see the HISTORY file.
 
 == HOW TO USE
 
-For usage information, see the individual library files include
+For usage information, see the individual library files included
 in this collection.
 
 
@@ -39,18 +39,9 @@ Tarball packages are available for manual site installations
 via {Ruby Setup}[http://proutils.github.com/setup].
 
 
-== LICENSE
-
-Copyright (c) 2005, 2010 Thomas Sawyer
-
-This library is distributed under the terms of the MIT license.
+== AUTHORS
 
-See LICENSE file for details.
-
-Some libraries included in the Hashery have special copyrights
-attributing specific authors. Please see each file for details.
-
-Contributing authors include:
+Developers whose code has contributed the project include:
 
 * Kirk Haines
 * Joshua Hull
@@ -60,3 +51,28 @@ Contributing authors include:
 * Jeena Paradies
 * Erik Veenstra
 
+
+== LICENSE
+
+(Apache 2.0 License)
+
+Copyright (c) 2010 Thomas Sawyer
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this program except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+See LICENSE file for further details.
+
+Some libraries included in the Hashery have special copyrights
+attributing specific authors. Please see each library script for
+specifics.
+

data/VERSION

@@ -0,0 +1,3 @@
+name    : hashery
+version : 1.3.0
+date    : 2010-10-10

data/lib/hashery/casting_hash.rb

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

data/lib/hashery/castinghash.rb

@@ -20,8 +20,8 @@ class CastingHash < Hash
 
   #
   def initialize(hash={}, value_cast=nil, &key_cast)
-    @key_proc   = key_cast           || KEY_PROC
-    @value_proc = value_cast.to_proc || VAL_PROC
+    @key_proc   = (key_cast   || KEY_PROC)
+    @value_proc = (value_cast || VAL_PROC).to_proc
     hash.each{ |k,v| self[k] = v }
   end
 

data/lib/hashery/fuzzy_hash.rb

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

data/lib/hashery/fuzzyhash.rb

@@ -0,0 +1,154 @@
+require 'set'
+
+# = Fuzzy Hash
+#
+# A weird hash with special semantics for regex keys.
+#
+# This is useful when you want to have a lookup table that can either contain strings or regexes.
+# For instance, you might want a catch all for certain regexes that perform a certain logic.
+#
+#  >> hash = FuzzyHash.new
+#  >> hash[/^\d+$/] = 'number'
+#  >> hash[/.*/] = 'something'
+#  >> hash['chunky'] = 'bacon'
+#  >> hash['foo'] = 'vader'
+#  
+#  >> hash['foo']
+#  << 'vader'
+#  >> hash['food']
+#  << 'something'
+#  >> hash['123']
+#  << 'number'
+#
+# Copyright (c) 2009 Joshua Hull
+
+class FuzzyHash
+
+  def initialize(init_hash = nil)
+    @fuzzies = []
+    @hash_reverse = {}
+    @fuzzies_reverse = {}
+    @fuzzy_hash = {}
+    @hash = {}
+    init_hash.each{ |key,value| self[key] = value } if init_hash
+  end
+
+  def clear
+    hash.clear
+    fuzzies.clear
+    hash_reverse.clear
+    fuzzies_reverse.clear
+  end
+
+  def size
+    hash.size + fuzzies.size
+  end
+  alias_method :count, :size
+
+
+  def ==(o)
+    o.is_a?(FuzzyHash)
+    o.send(:hash) == hash &&
+    o.send(:fuzzies) == fuzzies
+  end
+
+  def empty?
+    hash.empty? && fuzzies.empty?
+  end
+
+  def keys
+    hash.keys + fuzzy_hash.keys
+  end
+
+  def values
+    hash.values + fuzzies.collect{|r| r.last}
+  end
+
+  def each
+    hash.each{|k,v| yield k,v }
+    fuzzies.each{|v| yield v.first, v.last }
+  end
+
+  def delete_value(value)
+    hash.delete(hash_reverse[value]) || ((rr = fuzzies_reverse[value]) && fuzzies.delete_at(rr[0]))
+  end
+
+  def []=(key, value)
+    if Regexp === key
+      fuzzies.delete_if{|f| f.first.inspect.hash == key.inspect.hash}
+      fuzzies_reverse.delete_if{|k, v| v[1].inspect.hash == key.inspect.hash}
+      hash_reverse.delete_if{|k,v| v.inspect.hash == key.inspect.hash}
+
+      fuzzy_hash[key] = value
+      fuzzies << [key, value]
+      reset_fuzz_test!
+      fuzzies_reverse[value] = [fuzzies.size - 1, key, value]
+    else
+      hash[key] = value
+      hash_reverse.delete_if{|k,v| v.hash == key.hash}
+      hash_reverse[value] = key
+    end
+    value
+  end
+
+  def replace(src, dest)
+    if hash_reverse.key?(src)
+      key = hash_reverse[src]
+      hash[key] = dest
+      hash_reverse.delete(src)
+      hash_reverse[dest] = key
+    elsif fuzzies_reverse.key?(src)
+      key = fuzzies_reverse[src]
+      fuzzies[rkey[0]] = [rkey[1], dest]
+      fuzzies_reverse.delete(src)
+      fuzzies_reverse[dest] = [rkey[0], rkey[1], dest]
+    end
+  end
+
+  def [](key)
+    (hash.key?(key) && hash[key])  ||
+      ((lookup = fuzzy_lookup(key)) && lookup && lookup.first) ||
+      fuzzy_hash[key]
+  end
+
+  def match_with_result(key)
+    if hash.key?(key)
+      [hash[key], key]
+    else
+      fuzzy_lookup(key)
+    end
+  end
+
+  private
+  attr_reader :fuzzies, :hash_reverse, :fuzzies_reverse, :hash, :fuzzy_hash
+  attr_writer :fuzz_test
+
+  def reset_fuzz_test!
+    self.fuzz_test = nil
+  end
+
+  def fuzz_test
+    unless @fuzz_test
+      @fuzz_test = Object.new
+      @fuzz_test.instance_variable_set(:'@fuzzies', fuzzies)
+      method = "
+        def match(str)
+          case str\n
+      "
+      fuzzies.each_with_index do |reg, index|
+        method << "when #{reg.first.inspect}; [@fuzzies[#{index}][1], Regexp.last_match(0)];"
+      end
+      method << "end\nend\n"
+      @fuzz_test.instance_eval method
+    end
+    @fuzz_test
+  end
+
+  def fuzzy_lookup(key)
+    if !fuzzies.empty? && (value = fuzz_test.match(key))
+      value
+    end
+  end
+
+end
+

data/lib/hashery/linked_list.rb

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

data/lib/hashery/lru_hash.rb

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

data/lib/hashery/open_cascade.rb

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

data/lib/hashery/open_hash.rb

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

data/lib/hashery/open_object.rb

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

data/lib/hashery/opencascade.rb

@@ -3,7 +3,7 @@ require 'hashery/openhash'
 
 # = OpenCascade
 #
-# OpenCascade is subclass of OpenObject. It 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

data/lib/hashery/ordered_hash.rb

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

data/lib/hashery/property_hash.rb

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

data/lib/hashery/propertyhash.rb

@@ -0,0 +1,97 @@
+# A PropertyHash is the same as a regular Hash except it strictly limits the
+# allowed keys.
+#
+# There are two ways to use it.
+#
+# 1) As an object in itself.
+#
+#   h = PropertyHash.new(:a=>1, :b=>2)
+#   h[:a]        #=> 1
+#   h[:a] = 3
+#   h[:a]        #=> 3
+#
+# But if we try to set key that was not fixed, then we will get an error.
+#
+#   h[:x] = 5    #=> ArgumentError
+# 
+# 2) As a superclass.
+#
+#   class MyPropertyHash < PropertyHash
+#     property :a, :default => 1
+#     property :b, :default => 2
+#   end
+#
+#   h = MyPropertyHash.new
+#   h[:a]        #=> 1
+#   h[:a] = 3
+#   h[:a]        #=> 3
+#
+# Again, if we try to set key that was not fixed, then we will get an error.
+#
+#   h[:x] = 5    #=> ArgumentError
+#
+class PropertyHash < Hash
+
+  #
+  def self.properties
+    @properties ||= (
+      parent = ancestors[1]
+      if parent.respond_to?(:properties)
+        parent.properties
+      else
+        {}
+      end
+    )
+  end
+
+  #
+  def self.property(key, opts={})
+    properties[key] = opts[:default]
+  end
+
+  #
+  def initialize(properties={})
+    super()
+    fixed = self.class.properties.merge(properties)
+    replace(fixed)
+  end
+
+  #
+  def []=(k,v)
+    assert_key!(k)
+    super(k,v)
+  end
+
+  #
+  def update(h)
+    h.keys.each{ |k| assert_key!(k) }
+    super(h)
+  end
+
+  #
+  def merge!(h)
+    h.keys.each{ |k| assert_key!(k) }
+    super(h)
+  end
+
+  #
+  def <<(a)
+    k,v = *a
+    self[k] = v
+  end
+
+  # Add a new acceptable key.
+  # TODO: Should this be supported?
+  def accept_key!(k,v=nil)
+    self[k] = v
+  end
+
+  private
+
+  def assert_key!(key)
+    unless key?(key)
+      raise ArgumentError, "The key '#{key}' is not defined for this FixedHash."
+    end
+  end
+
+end

data/lib/hashery/query_hash.rb

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

data/lib/hashery/sparse_array.rb

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

data/lib/hashery/static_hash.rb

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

data/test/case_sparsearray.rb

@@ -0,0 +1,316 @@
+require 'hashery/sparsearray'
+require 'ae/legacy'
+
+# This is a mostly complete testcase for SparseArray.
+# SparseArray is tested by comparison to standard Array.
+
+Case SparseArray do
+
+  def aha(a)
+    return a, SparseArray[*a]
+  end
+
+  Unit :to_ary do
+    a, ha = aha [1,3,'a',8,nil,[1]]
+    assert_equal(ha, ha.to_ary)  # these need to be opposite
+  end
+
+  Unit :to_a do
+    a, ha = aha [1,3,'a',8,nil,[1]]
+    assert_equal(a, ha.to_a)     #
+    assert_equal(a.to_s, ha.to_s)
+  end
+
+  Unit :to_s do
+    a, ha = aha [1,3,'a',8,nil,[1]]
+    assert_equal(a.to_s, ha.to_s)
+  end
+
+  Unit :|, :&, :+, :- do
+    a, ha = aha [1,3,5,8,9]
+    b, hb = aha [2,3,6,8,9]
+    assert_equal(a | b, (ha | hb).to_a)
+    assert_equal(a & b, (ha & hb).to_a)
+    assert_equal(a + b, (ha + hb).to_a)
+    assert_equal(a - b, (ha - hb).to_a)
+  end
+
+  Unit :* do
+    a, ha = aha [1,3]
+    assert_equal(a*3,(ha*3).to_a)
+  end
+
+  Unit :[]= do
+    a, ha = aha [1,2,3,4]
+    a[1..2] = [8,9]
+    ha[1..2] = [8,9]
+    assert_equal(a, ha.to_a)
+  end
+
+  Unit :assoc do
+    a, ha = aha [[1,2],[3,4],[3,6]]
+    assert_equal(a.assoc(3), ha.assoc(3).to_a)
+  end
+
+  Unit :at do
+    a, ha = aha [4,5,6,6]
+    assert_equal(a.at(0), ha.at(0))
+    assert_equal(a.at(2), ha.at(2))
+    assert_equal(a.at(4), ha.at(4))
+    assert_equal(a.at(9), ha.at(9))
+    assert_equal(a.at(-1), ha.at(-1))
+    assert_equal(a.at(-3), ha.at(-3))
+    assert_equal(a.at(-4), ha.at(-4))
+    assert_equal(a.at(-5), ha.at(-5))
+  end
+
+  Unit :collect do
+    a, ha = aha [4,5,6,6]
+    assert_equal(a.collect{|e|e}, ha.collect{|e|e}.to_a)
+    assert_equal(a.collect!{|e|e}, ha.collect!{|e|e}.to_a)
+    assert_equal(a,ha.to_a)
+  end
+
+  Unit :compact do
+    a, ha = aha [4,nil,5,nil,6]
+    assert_equal(a.compact, ha.compact.to_a)
+  end
+
+  Unit :concat do
+    a, ha = aha [1,3,5,8,9]
+    b, hb = aha [2,3,6,8,9]
+    assert_equal(a.concat(b),ha.concat(hb).to_a)
+  end
+
+  Unit :count do
+    ha = SparseArray[9,3,9,5,nil,nil,9,3]
+    assert_equal(2,ha.count)
+    assert_equal(2,ha.count(3))
+    assert_equal(3,ha.count{|e|e==9})
+  end
+
+  Unit :delete do
+    a, ha = aha [1,3,5,8,9,'a','b','c','c','d']
+    # test delete
+    assert_equal(a.delete(1),ha.delete(1))
+    assert_equal(a,ha.to_a)
+    assert_equal(a.delete('a'),ha.delete('a'))
+    assert_equal(a,ha.to_a)
+    # test delete_at
+    assert_equal(a.delete_at(0),ha.delete_at(0))
+    assert_equal(a,ha.to_a)
+    # test delete_if
+    assert_equal(a.delete_if{|v|v=='c'},ha.delete_if{|v|v=='c'}.to_a)
+    assert_equal(a,ha.to_a)
+  end
+
+  Unit :each do
+    a, ha = aha [4,'a',nil,'b']
+    # test each
+    ca, cha = '', ''
+    a.each{|e| ca += e.to_s}
+    ha.each{|e| cha += e.to_s}
+    assert_equal(ca,cha)
+    assert_equal(a,ha.to_a)
+    # test each_index
+    ca, cha = '', ''
+    a.each_index{|i| ca += i.to_s}
+    ha.each_index{|i| cha += i.to_s}
+    assert_equal(ca,cha)
+    assert_equal(a,ha.to_a)
+  end
+
+  Unit :eql? do
+    a, ha = aha [4,'a',nil,'b']
+    b, hb = aha [4,'a',nil,'b']
+    assert_equal(a,b)
+    assert_equal(ha,hb)
+    assert_equal(a.eql?(b),ha.eql?(hb))
+    assert_equal(b.eql?(a),hb.eql?(ha))
+    assert(ha.eql?(hb))
+    assert(hb.eql?(ha))
+  end
+
+  Unit :empty? do
+    a, ha = aha []
+    assert_equal(a.empty?,ha.empty?)
+    a, ha = aha [1,2,3]
+    assert_equal(a.empty?,ha.empty?)
+  end
+
+  Unit :fill do
+    a, ha = aha ['a','b','c','d']
+    assert_equal(a.fill('x'),ha.fill('x').to_a)
+    assert_equal(a,ha.to_a)
+    assert_equal(a.fill('y',2,2),ha.fill('y',2,2).to_a)
+    assert_equal(a,ha.to_a)
+    assert_equal(a.fill('z',0..1),ha.fill('z',0..1).to_a)
+    assert_equal(a,ha.to_a)
+  end
+
+  Unit :first do
+    a, ha = aha [2,3,4]
+    assert_equal(a.first,ha.first)
+  end
+
+  Unit :flatten do
+    a, ha = aha [2,[3],'a',[[1,2],4],nil,5]
+    assert_equal(a.flatten,ha.flatten.to_a)
+    a, ha = aha [2,[3],'a',[[1,2],4],nil,5]
+    assert_equal(a.flatten!,ha.flatten!.to_a)
+    assert_equal(a,ha.to_a)
+    a, ha = aha [2,3,'a',nil,5]
+    assert_equal(a.flatten!,ha.flatten!)
+  end
+
+  Unit :include? do
+    a, ha = aha ['a','b','c','d']
+    assert_equal(a.include?('b'),ha.include?('b'))
+    assert_equal(a.include?('x'),ha.include?('x'))
+  end
+
+  Unit :index do
+    a, ha = aha ['a','b','b','c','d']
+    assert_equal(a.index('b'),ha.index('b'))
+    assert_equal(a.index('x'),ha.index('x'))
+  end
+
+  Unit :join do
+    a, ha = aha [2,3,4]
+    assert_equal(a.join,ha.join)
+    assert_equal(a.join(','),ha.join(','))
+  end
+
+  Unit :last do
+    a, ha = aha [2,3,4]
+    assert_equal(a.last,ha.last)
+  end
+
+  Unit :length do
+    a, ha = aha [2,3,4]
+    assert_equal(a.length,ha.length)
+  end
+
+  Unit :map! do
+    a, ha = aha [4,5,6,6]
+    assert_equal(a.map!{|e|e}, ha.map!{|e|e}.to_a)
+    assert_equal(a,ha.to_a)
+  end
+
+  Unit :nitems do
+    a, ha = aha [4,5,nil,6,nil]
+    assert_equal(a.nitems, ha.nitems)
+  end
+
+  Unit :pop do
+    a, ha = aha [4,5,nil,6,nil]
+    assert_equal(a.pop, ha.pop)
+    assert_equal(a, ha.to_a)
+    assert_equal(a.pop, ha.pop)
+    assert_equal(a, ha.to_a)
+  end
+
+  Unit :push do
+    a, ha = aha [4,5,nil,6,nil]
+    args = [1,2,3]
+    assert_equal(a.push(*args), ha.push(*args).to_a)
+    assert_equal(a, ha.to_a)
+  end
+
+  Unit :rassoc do
+    a, ha = aha [[1,2],[1,3],[1,3]]
+    assert_equal(a.rassoc(3), ha.rassoc(3).to_a)
+  end
+
+  Unit :reject! do
+    a, ha = aha ['a','b','c','c','d']
+    assert_equal(a.reject!{|v|v=='c'},ha.reject!{|v|v=='c'}.to_a)
+    assert_equal(a,ha.to_a)
+    assert_equal(a.reject!{|v|v=='x'},ha.reject!{|v|v=='x'})
+    assert_equal(a,ha.to_a)
+  end
+
+  Unit :reverse do
+    a, ha = aha ['a','b','c','c','d']
+    assert_equal(a.reverse,ha.reverse.to_a)
+    assert_equal(a.reverse!,ha.reverse!.to_a)
+    assert_equal(a,ha.to_a)
+    a, ha = aha [1,2,3,'a','b','c']
+    assert_equal(a.reverse!,ha.reverse!.to_a)
+    assert_equal(a,ha.to_a)
+  end
+
+  Unit :reverse_each do
+    a, ha = aha [4,'a',nil,'b']
+    # test each
+    ca, cha = '', ''
+    a.reverse_each{|e| ca += e.to_s}
+    ha.reverse_each{|e| cha += e.to_s}
+    assert_equal(ca,cha)
+    assert_equal(a,ha.to_a)
+  end
+
+  Unit :rindex do
+    a, ha = aha ['a','b','c','c','d']
+    assert_equal(a.rindex('c'),ha.rindex('c'))
+    assert_equal(a.rindex('x'),ha.rindex('x'))
+  end
+
+  Unit :shift do
+    a, ha = aha ['a','b','c','c','d']
+    assert_equal(a.shift,ha.shift)
+    assert_equal(a,ha.to_a)
+  end
+
+  Unit :slice do
+    a, ha = aha [1,2,3,4]
+    # test []
+    assert_equal(a[1], ha[1])
+    assert_equal(a[1..2], ha[1..2].to_a)
+    assert_equal(a[1...2], ha[1...2].to_a)
+    assert_equal(a[1..7], ha[1..7].to_a)
+    assert_equal(a[1,2], ha[1,2].to_a)
+    # test slice
+    assert_equal(a.slice(1), ha.slice(1))
+    assert_equal(a.slice(1..2), ha.slice(1..2).to_a)
+    assert_equal(a.slice(1...2), ha.slice(1...2).to_a)
+    assert_equal(a.slice(1...2), ha.slice(1...2).to_a)
+    assert_equal(a.slice(1,2), ha.slice(1,2).to_a)
+    # test slice!
+    assert_equal(a.slice!(1..2), ha.slice!(1..2).to_a)
+    assert_equal(a, ha.to_a)
+  end
+
+  Unit :sort do
+    a, ha = aha [1,2,3,4]
+    # test sort
+    assert_equal(a.sort, ha.sort.to_a)
+    #assert_equal(a.sort{|x,y| y<=>x}, ha.sort{|x,y| y<=>x}.to_a)
+    # test sort!
+    assert_equal(a.sort!, ha.sort!.to_a)
+    assert_equal(a, ha.to_a)
+  end
+
+  Unit :uniq do
+    a, ha = aha [1,1,2,3,3,4,5,6,6]
+    assert_equal(a.uniq, ha.uniq.to_a)
+  end
+
+  Unit :uniq! do
+    a, ha = aha [1,1,2,3,3,4,5,6,6]
+    a.uniq!; ha.uniq!
+    assert_equal(a, ha.to_a)
+  end
+
+  Unit :values_at do
+    a, ha = aha ['a','b','c','d']
+    assert_equal(a.values_at(1,3),ha.values_at(1,3).to_a)
+  end
+
+  Unit :unshift do
+    a, ha = aha ['a','b','c','c','d']
+    assert_equal(a.unshift('x'),ha.unshift('x').to_a)
+    assert_equal(a,ha.to_a)
+  end
+end
+

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
-  - 2
+  - 3
   - 0
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors: 
 - Thomas Sawyer
@@ -20,7 +20,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-04 00:00:00 -04:00
+date: 2010-10-10 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -34,20 +34,34 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - lib/hashery/association.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
 - test/case_association.rb
@@ -55,15 +69,17 @@ files:
 - test/case_opencascade.rb
 - test/case_openhash.rb
 - test/case_openobject.rb
+- test/case_sparsearray.rb
 - test/case_stash.rb
+- HISTORY.rdoc
+- PROFILE
 - LICENSE
 - README.rdoc
-- ROADMAP.rdoc
-- HISTORY
+- VERSION
 has_rdoc: true
 homepage: http://rubyworks.github.com/hashery
-licenses: []
-
+licenses: 
+- MIT
 post_install_message: 
 rdoc_options: 
 - --title
@@ -73,6 +89,7 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -80,6 +97,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -89,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: hashery
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Facets bread collection of Hash-like classes.

data/ROADMAP.rdoc

@@ -1,13 +0,0 @@
-= ROADMAP
-
-== 1.1.0
-
-* Improve test coverage.
-* Consider using Hashery:: namespace.
-* Should Stash have a more explict name?
-
-== 1.2.0
-
-* Add a defined property Hash. Needed?
-* Any other Hash-like classes to add?
-