Add bin and edit workflow

bin/gems/hashery-2.1.2/lib/hashery/casting_hash.rb

@@ -0,0 +1,164 @@
+require 'hashery/crud_hash'
+
+module Hashery
+
+  # CastingHash is just like CRUDHash, except that both keys and values
+  # can be passed through casting procedures.
+  #
+  class CastingHash < CRUDHash
+
+    #
+    # Like `#new` but can take a priming Hash or Array-pairs.
+    #
+    # hash - Hash-like object.
+    #
+    # Examples
+    #
+    #   CastingHash[:a,1,:b,2]
+    #
+    # Returns `CastingHash`.
+    #
+    def self.[](hash)
+      s = new
+      hash.each{ |k,v| s[k] = v }
+      s
+    end
+
+    #
+    # Unlike traditional Hash a CastingHash's block argument
+    # coerces key/value pairs when #store is called.
+    #
+    # default   - Default value.
+    # cast_proc - Casting procedure.
+    #
+    def initialize(default=nil, &cast_proc)
+      @cast_proc = cast_proc
+      super(default, &nil)
+    end
+
+    #
+    # The cast procedure.
+    #
+    # proc - Casting procedure.
+    #
+    # Returns `Proc` used for casting.
+    #
+    def cast_proc(&proc)
+      @cast_proc = proc if proc
+      @cast_proc
+    end
+
+    #
+    # Set `cast_proc`. This procedure must take two arguments (`key, value`)
+    # and return the same.
+    #
+    # proc - Casting procedure.
+    #
+    # Returns +proc+.
+    #
+    def cast_proc=(proc)
+      raise ArgumentError unless Proc === proc or NilClass === proc
+      @cast_proc = proc
+    end
+
+    #
+    # CRUD method for create and update. Unlike the parent class
+    # the key, value pair are passed threw the cast_proc before
+    # being set in the underlying hash table.
+    #
+    # key   - Key of entry.
+    # value - Value of entry.
+    #
+    # Returns the +value+.
+    #
+    def store(key, value)
+      super(*cast_pair(key, value))
+    end
+
+    #
+    # Replace current entries with those from another Hash,
+    # or Hash-like object. Each entry is run through the
+    # casting procedure as it is added.
+    #
+    # other - Hash-like object.
+    #
+    # Returns +self+.
+    # 
+    def replace(other)
+      super cast(other)
+    end
+
+    #
+    # Convert the CastingHash to a regular Hash.
+    #
+    # Returns an ordinary `Hash`.
+    #
+    def to_hash
+      h = {}; each{ |k,v| h[k] = v }; h
+    end
+
+    #
+    # Returns an ordinary `Hash`.
+    #
+    alias_method :to_h, :to_hash
+
+    #
+    # Recast all entries via the cast procedure.
+    #
+    # TODO: Isn't this the same as `#rehash`?
+    #
+    # Returns +self+.
+    #
+    def recast!
+      replace self
+    end
+
+  private
+
+    #
+    # If `cast_proc` is defined then use it to process key-value pair,
+    # otherwise return them as is.
+    #
+    # key   - Key of entry.
+    # value - Value of entry.
+    #
+    # Returns `Array` of key-value pair.
+    #
+    def cast_pair(key, value)
+      if cast_proc
+        return cast_proc.call(key, value)
+      else
+        return key, value
+      end
+    end
+
+    #
+    # Cast a given +hash+ according to the `#key_proc` and `#value_proc`.
+    #
+    # hash - A `Hash` or anything the responds to `#each` like a hash.
+    #
+    # Returns a recasted `Hash`.
+    #
+    def cast(hash)
+      h = {}
+      hash.each do |k,v|
+        k, v = cast_pair(k, v)
+        h[k] = v
+      end
+      h
+    end
+
+  end
+
+end
+
+# TODO: Should we add #to_casting_hash to Hash classs?
+
+#class Hash
+#
+#  # Convert a Hash to a CastingHash.
+#  def to_casting_hash(value_cast=nil, &key_cast)
+#    CastingHash.new(self, value_cast, &key_cast)
+#  end
+#
+#end