hashery 1.5.0 → 2.0.0

data/lib/hashery/query_hash.rb

@@ -1,35 +1,91 @@
-# = QueryHash
-#
-# QueryHash is a similar to OpenHash. Like OpenHash,
-# entries can be assigned via setter methods, but
-# entries can only be looked up via query methods
-# (i.e. methods ending in a ?-mark), hence the name
-# of this class.
-#
-# A QueryHash is not quite as elegant as an OpenHash
-# in that reader methods must end in ?-marks, but
-# it remains fully compatible with Hash regardless
-# of it's settings.
-
-class QueryHash < Hash
-
-  def to_h
-    dup
-  end
+module Hashery
 
-  def to_hash
-    dup
-  end
+  require 'hashery/key_hash'
+
+  # QueryHash is essentially a Hash class, but with some OpenStruct-like features.
+  #
+  #     q = QueryHash.new
+  #
+  # Entries can be added to the Hash via a setter method.
+  #
+  #     q.a = 1
+  #
+  # Then looked up via a query method.
+  #
+  #     q.a?  #=> 1
+  #
+  # The can also be looked up via a bang method.
+  # 
+  #     q.a!  #=> 1
+  #
+  # The difference between query methods and bang methods is that the bang method
+  # will auto-instantiate the entry if not present, where as a query method will not.
+  #
+  # A QueryHash might not be quite as elegant as an OpenHash in that reader
+  # methods must end in `?` or `!`, but it remains fully compatible with Hash
+  # regardless of it's settings.
+  #
+  class QueryHash < CRUDHash
 
-  def method_missing(s,*a,&b)
-    case s.to_s
-    when /\=$/
-      self[s.to_s.chomp('=').to_sym] = a[0]
-    when /\?$/
-      self[s.to_s.chomp('?').to_sym]
-    else
-      super(s,*a,&b)
+    #
+    # By default the `key_proc` is set to convert all keys to strings via `#to_s`.
+    #
+    # default      - Default object, or
+    # default_proc - Default procedure.
+    #
+    def initialize(*default, &default_proc)
+      @key_proc = Proc.new{ |k| k.to_s }
+      super(*default, &default_proc)
     end
+
+    #
+    # Route get and set calls.
+    #
+    # s - [Symbol] Name of method.
+    # a - [Array] Method arguments.
+    # b - [Proc] Block argument.
+    #
+    # Examples
+    #
+    #   o = QueryHash.new
+    #   o.a = 1
+    #   o.a?  #=> 1
+    #   o.b?  #=> nil
+    #
+    def method_missing(s,*a, &b)
+      type = s.to_s[-1,1]
+      name = s.to_s.sub(/[!?=]$/, '')     
+      key  = name  #key  = cast_key(name)
+
+      case type
+      when '='
+        store(key, a.first)
+      when '!'
+        default = (default_proc ? default_proc.call(self, key) : default)
+        key?(key) ?  fetch(key) : store(key, default)
+      when '?'
+        key?(key) ? fetch(key) : nil
+      else
+        # return self[key] if key?(key)
+        super(s,*a,&b)
+      end
+    end
+
+    #
+    # Custom #respond_to to account for #method_missing.
+    #
+    # name - The method name to check.
+    #
+    # Returns `true` or `false`.
+    #
+    def respond_to?(name)
+      return true if name.to_s.end_with?('=')
+      return true if name.to_s.end_with?('?')
+      return true if name.to_s.end_with?('!')
+      #key?(name.to_sym) || super(name)
+      super(name)
+    end
+
   end
 
 end

data/lib/hashery/stash.rb

@@ -1,10 +1,14 @@
-require 'hashery/keyhash'
+require 'hashery/key_hash'
 
-Stash = KeyHash
+module Hashery
+  # Stash is the original name for the KeyHash.
+  Stash = KeyHash
+end
 
 class Hash
   # Convert Hash to Stash.
   def to_stash
-    Stash[self]
+    Hashery::Stash[self]
   end
 end
+

data/lib/hashery/static_hash.rb

@@ -1,48 +1,53 @@
-# = StaticHash
-#
-# A Hash object which raises an error if any
-# previously-defined key attempts to be set again.
-#
-# == Synopsis
-#
-#   foo = StaticHash.new
-#   foo['name'] = 'Tom'    #=> 'Tom'
-#   foo['age']  = 30       #=> 30
-#   foo['name'] = 'Bob'
-#
-# _produces_
-#
-#   ArgumentError: Duplicate key for StaticHash -- 'name'
-#
-# == Credit
-#
-# StaticHash has it's orgins in Gavin Kistner's WriteOnceHash
-# class found in his +basiclibrary.rb+ script.
+module Hashery
 
-class StaticHash < Hash
-
-  # Set a value for a key. Raises an error if that key already
-  # exists with a different value.
+  # StaticHash ia a Hash object which raises an error if any
+  # previously-defined key attempts to be set again.
+  #
+  #     foo = StaticHash.new
+  #     foo['name'] = 'Tom'    #=> 'Tom'
+  #     foo['age']  = 30       #=> 30
+  #     foo['name'] = 'Bob'
+  #
+  # produces
+  #
+  #     ArgumentError: Duplicate key for StaticHash -- 'name'
+  #
+  # StaticHash has it's orgins in Gavin Kistner's WriteOnceHash
+  # class found in his +basiclibrary.rb+ script.
+  #
+  # TODO: Maybe StaticHash isn't bets name for this class?
+  #
+  class StaticHash < CRUDHash
 
-  def []=(key, value)
-    if key?(key) && self[key] != value
-      raise ArgumentError, "Duplicate key for StaticHash -- #{key.inspect}"
+    #
+    # Set a value for a key. Raises an error if that key already
+    # exists with a different value.
+    #
+    # key   - Index key to associate with value.
+    # value - Value to associate with key.
+    #
+    # Retruns value.
+    #
+    def store(key, value)
+      if key?(key) && read(key) != value
+        raise ArgumentError, "Duplicate key for StaticHash -- #{key.inspect}"
+      end
+      super(key, value)
     end
-    super(key, value)
-  end
 
-  #
-  def update(hash)
-    dups = (keys | hash.keys)
-    if dups.empty?
-      super(hash)
-    else
-      raise ArgumentError, "Duplicate key for StaticHash -- #{dups.inspect}"
-    end
-  end
+    #
+    #def update(hash)
+    #  dups = (keys | hash.keys)
+    #  if dups.empty?
+    #    super(hash)
+    #  else
+    #    raise ArgumentError, "Duplicate key for StaticHash -- #{dups.inspect}"
+    #  end
+    #end
 
-  #
-  alias_method :merge!, :update
+    #
+    #alias_method :merge!, :update
 
-end
+  end
 
+end

data/test/case_association.rb

@@ -1,6 +1,6 @@
-require 'lemon'
-require 'ae'
+require 'helper'
 
+# must be required independently
 require 'hashery/association'
 
 testcase Association do
@@ -11,6 +11,28 @@ testcase Association do
     end
   end
 
+  class_method :[] do
+    test do
+      a = Association[:a, 1]
+      a.assert.index == :a
+      a.assert.value == 1
+    end
+  end
+
+  method :index do
+    test do
+      a = Association.new(:a,1)
+      a.index.assert == :a
+    end
+  end
+
+  method :value do
+    test do
+      a = Association.new(:a,1)
+      a.value.assert == 1
+    end
+  end
+
   method :to_ary do
     test do
       k,v = [],[]
@@ -28,13 +50,52 @@ testcase Association do
     end
   end
 
+  method :<=> do
+    test 'when differnt in value' do
+      a = Association.new(:a,1)
+      b = Association.new(:b,2)
+      (a <=> b).assert == -1
+      (b <=> a).assert == 1
+    end
+
+    test 'when equal value' do
+      a = Association.new(:a,1)
+      b = Association.new(:b,1)
+      (a <=> b).assert == 0
+    end
+  end
+
+  method :invert! do
+    test do
+      a = Association.new(:a,1)
+      a.invert!
+      a.index.assert == 1
+      a.value.assert == :a
+    end
+  end
+
+  method :inspect do
+    test do
+      a = Association.new(:a,1)
+      a.inspect.assert == ":a >> 1"
+    end
+  end
+
+  method :to_s do
+    test do
+      a = Association.new(:a,1)
+      a.to_s.assert == "a >> 1"
+    end
+  end
+
 end
 
 testcase Object do
   method :associations do
     test do
-      complex = [ :a >> :b, :a >> :c ]
-      :a.associations.assert == [ :b, :c ]
+      s = 'a'
+      complex = [ s >> :b, s >> :c ]
+      s.associations.assert == [:b, :c]
     end
   end
 

data/test/case_dictionary.rb

@@ -1,8 +1,4 @@
-require 'lemon'
-require 'ae'
-require 'ae/legacy'
-
-require 'hashery/dictionary'
+require 'helper'
 
 testcase Dictionary do
   include AE::Legacy::Assertions
@@ -178,5 +174,153 @@ testcase Dictionary do
     end
   end
 
+  method :select do
+    test do
+      d = Dictionary[:a=>1, :b=>2, :c=>3]
+      r = d.select{ |k,v| v % 2 == 1 }
+      r.assert == [[:a, 1], [:c, 3]]
+    end
+  end
+
+  method :to_h do
+    test do
+      d = Dictionary[:a=>1, :b=>2]
+      h = d.to_h
+      h.assert == {:a=>1, :b=>2}
+    end
+  end
+
+  method :replace do
+    test do
+      d1 = Dictionary[:a=>1, :b=>2]
+      d2 = Dictionary[:c=>3, :d=>4]
+      d1.replace(d2)
+      d1.to_h.assert == {:c=>3, :d=>4}
+    end
+  end
+
+  method :reverse do
+    test do
+      d = Dictionary[:a=>1, :b=>2, :c=>3]
+      r = d.reverse
+      r.first.assert == 3
+    end
+  end
+
+  method :invert do
+    test do
+      d = Dictionary[:a=>1, :b=>2, :c=>3]
+      r = d.invert
+      Dictionary.assert === r
+      r.to_h.assert == {1=>:a, 2=>:b, 3=>:c}
+    end
+  end
+
+  method :each_key do
+    d = Dictionary[:a=>1, :b=>2, :c=>3]
+    a = []
+    d.each_key{ |k| a << k }
+    a.assert == [:a, :b, :c]
+  end
+
+  method :each_value do
+    d = Dictionary[:a=>1, :b=>2, :c=>3]
+    a = []
+    d.each_value{ |v| a << v }
+    a.assert == [1, 2, 3]
+  end
+
+  method :clear do
+    d = Dictionary[:a=>1, :b=>2, :c=>3]
+    d.clear
+    d.to_a.assert == []
+  end
+
+  method :fetch do
+    d = Dictionary[:a=>1, :b=>2, :c=>3]
+    d.fetch(:a).assert == 1
+  end
+
+  method :key? do
+    test do
+      d = Dictionary[:a=>1, :b=>2, :c=>3]
+      d.assert.key?(:a)
+      d.refute.key?(:d)
+    end
+  end
+
+  method :has_key? do
+    test do
+      d = Dictionary[:a=>1, :b=>2, :c=>3]
+      d.assert.has_key?(:a)
+      d.refute.has_key?(:d)
+    end
+  end
+
+  method :length do
+    test do
+      d = Dictionary[:a=>1, :b=>2, :c=>3]
+      d.length.assert == 3
+    end
+  end
+
+  method :to_a do
+    test do
+      d = Dictionary[:a=>1, :b=>2, :c=>3]
+      d.to_a.assert == [[:a,1], [:b,2], [:c,3]]
+    end
+  end
+
+  method :to_hash do
+    test do
+      d = Dictionary[:a=>1, :b=>2, :c=>3]
+      d.to_hash.assert == {:a=>1, :b=>2, :c=>3}
+    end
+  end
+
+  method :empty? do
+    test "is emtpy" do
+      d = Dictionary[]
+      d.assert.empty?
+    end
+
+    test 'is not emtpy' do
+      d = Dictionary[:a=>1, :b=>2, :c=>3]
+      d.refute.empty?
+    end
+  end
+
+  method :order_by_key do
+    test do
+      d = Dictionary[:b=>1, :c=>2, :a=>4]
+      d.order_by_key
+      d.order.assert == [:a, :b, :c]
+    end
+  end
+
+  method :order_by_value do
+    test do
+      d = Dictionary[:b=>1, :c=>2, :a=>4]
+      d.order_by_value
+      d.order.assert == [:b, :c, :a]
+    end
+  end
+
+  class_method :alpha do
+    test do
+      d = Dictionary.alpha
+      d.update(:b=>1, :c=>2, :a=>4)
+      d.order.assert == [:a, :b, :c]
+    end
+  end
+
+  class_method :auto do
+    test do
+      d = Dictionary.auto
+      s = d[:foo]
+      s.class.assert == Dictionary
+    end
+  end
+
 end