hashery 1.4.0 → 1.5.0

data/lib/hashery/castinghash.rb

@@ -1,171 +1 @@
-# CastingHash is just like Hash, except that all keys and values
-# are passed through casting procedures.
-#--
-# TODO: Handle default_proc.
-#++
-class CastingHash < Hash
-
-  # Default key conversion procedure.
-  KEY_PROC = lambda{ |x| x } #.to_s }
-
-  # Default value conversion procedure.
-  VAL_PROC = lambda{ |x| x }
-
-  #
-  def self.[](hash)
-    s = new
-    hash.each{ |k,v| s[k] = v }
-    s
-  end
-
-  #
-  def initialize(hash={}, value_cast=nil, &key_cast)
-    @key_proc   = (key_cast   || KEY_PROC)
-    @value_proc = (value_cast || VAL_PROC).to_proc
-    hash.each{ |k,v| self[k] = v }
-  end
-
-  #
-  def key_proc
-    @key_proc
-  end
-
-  #
-  def key_proc=(proc)
-    @key_proc = proc.to_proc
-  end
-
-  #
-  def value_proc
-    @value_proc
-  end
-
-  #
-  def value_proc=(proc)
-    @value_proc = proc.to_proc
-  end
-
-  #
-  def [](k)
-    super(key_proc[k])
-  end
-
-  #
-  def []=(k,v)
-    super(key_proc[k], value_proc[v])
-  end
-
-  #
-  def <<(other)
-    case other
-    when Hash
-      super(cast(other))
-    when Array
-      self[other[0]] = other[1]
-    else
-      raise ArgumentError
-    end
-  end
-
-  def fetch(k)
-    super(key_proc[k])
-  end
-
-  #
-  def store(k, v)
-    super(key_proc[k], value_proc[v])
-  end
-
-  #
-  def key?(k)
-    super(key_proc[k])
-  end
-
-  #
-  def has_key?(k)
-    super(key_proc[k])
-  end
-
-  # Synonym for Hash#rekey, but modifies the receiver in place (and returns it).
-  #
-  #   foo = { :name=>'Gavin', :wife=>:Lisa }.to_stash
-  #   foo.rekey!{ |k| k.upcase }  #=>  { "NAME"=>"Gavin", "WIFE"=>:Lisa }
-  #   foo.inspect                 #=>  { "NAME"=>"Gavin", "WIFE"=>:Lisa }
-  #
-  def rekey!(*args, &block)
-    # for backward comptability (DEPRECATE?).
-    block = args.pop.to_sym.to_proc if args.size == 1
-    if args.empty?
-      block = lambda{|k| k} unless block
-      keys.each do |k|
-        nk = block[k]
-        self[nk] = delete(k) #if nk
-      end
-    else
-      raise ArgumentError, "3 for 2" if block
-      to, from = *args
-      self[to] = delete(from) if has_key?(from)
-    end
-    self
-  end
-
-  #
-  def rekey(*args, &block)
-    dup.rekey!(*args, &block)
-  end
-
-  #
-  def delete(k)
-    super(key_proc[k])
-  end
-
-  #
-  def update(other)
-    super(cast(other))
-  end
-
-  # Same as #update.
-  def merge!(other)
-    super(cast(other))
-  end
-
-  #
-  def replace(other)
-    super(cast(other))
-  end
-
-  #
-  def values_at(*keys)
-    super(keys.map(&key_proc))
-  end
-
-  #
-  def to_hash
-    h = {}; each{ |k,v| h[k] = v }; h
-  end
-
-  #
-  alias_method :to_h, :to_hash
-
-  private
-
-    #
-    def cast(hash)
-      h
-      hash.each do |k,v|
-        h[key_proc[k]] = value_proc[v]
-      end
-      h
-    end
-
-end
-
-
-#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
+require 'hashery/casting_hash'

data/lib/hashery/core_ext.rb

@@ -0,0 +1,82 @@
+module Hashery
+
+  # This module is included into Ruby's core Hash class.
+  #
+  # These method derive from Ruby Facets.
+  module CoreExt
+
+    #
+    def to_h
+      self
+    end
+
+    #
+    def to_hash
+      self
+    end
+
+    # Synonym for Hash#rekey, but modifies the receiver in place (and returns it).
+    #
+    #   foo = { :name=>'Gavin', :wife=>:Lisa }
+    #   foo.rekey!{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+    #   foo.inspect               #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+    #
+    def rekey(key_map=nil, &block)
+      if !(key_map or block)
+        block = lambda{|k| k.to_sym}
+      end
+
+      key_map ||= {} 
+
+      hash = {}
+
+      (keys - key_map.keys).each do |key|
+        hash[key] = self[key]
+      end
+
+      key_map.each do |from, to|
+        hash[to] = self[from] if key?(from)
+      end
+
+      hash2 = {}
+
+      if block
+        if block.arity == 1  # TODO: is this condition needed?
+          hash.each do |k, v|
+            nk = block[k]
+            #nk = (NA == nk ? k : nk)  # TODO: Can't support this here.
+            hash2[nk] = v
+          end
+        else
+          hash.each do |k, v|
+            nk = block[k,v]
+            #nk = (NA == nk ? k : nk)  # TODO:
+            hash2[nk] = v
+          end
+        end
+      else
+        hash2 = hash
+      end
+
+      hash2
+    end
+
+    # Synonym for Hash#rekey, but modifies the receiver in place (and returns it).
+    #
+    #   foo = { :name=>'Gavin', :wife=>:Lisa }
+    #   foo.rekey!{ |k| k.to_s }  #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+    #   foo                       #=>  { "name"=>"Gavin", "wife"=>:Lisa }
+    #
+    # CREDIT: Trans, Gavin Kistner
+
+    def rekey!(key_map=nil, &block)
+      replace(rekey(key_map, &block))
+    end
+
+  end
+
+end
+
+class Hash #:nodoc:
+  include Hashery::CoreExt
+end

data/lib/hashery/dictionary.rb

@@ -124,6 +124,8 @@ class Dictionary
     end
   end
 
+  #
+
   def order
     reorder if @order_by
     @order
@@ -176,6 +178,7 @@ class Dictionary
   end
 
   #
+
   def reorder
     if @order_by
       assoc = @order.collect{ |k| [k,@hash[k]] }.sort_by(&@order_by)

data/lib/hashery/fuzzy_hash.rb

@@ -1 +1,154 @@
-require 'hashery/fuzzyhash'
+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/fuzzyhash.rb

@@ -1,154 +1 @@
-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
-
+require 'hashery/fuzzy_hash'