hashie 2.0.5 → 2.1.0

data/lib/hashie/extensions/key_conversion.rb

@@ -10,7 +10,7 @@ module Hashie
       def stringify_keys!
         keys.each do |k|
           stringify_keys_recursively!(self[k])
-          self[k.to_s] = self.delete(k)
+          self[k.to_s] = delete(k)
         end
         self
       end
@@ -51,7 +51,7 @@ module Hashie
       def symbolize_keys!
         keys.each do |k|
           symbolize_keys_recursively!(self[k])
-          self[k.to_sym] = self.delete(k)
+          self[k.to_sym] = delete(k)
         end
         self
       end
@@ -81,7 +81,7 @@ module Hashie
         end
       end
     end
-    
+
     module KeyConversion
       def self.included(base)
         base.send :include, SymbolizeKeys

data/lib/hashie/extensions/method_access.rb

@@ -5,8 +5,8 @@ module Hashie
     # to access your hash's keys. It will recognize keys
     # either as strings or symbols.
     #
-    # Note that while nil keys will be returned as nil, 
-    # undefined keys will raise NoMethodErrors. Also note that 
+    # Note that while nil keys will be returned as nil,
+    # undefined keys will raise NoMethodErrors. Also note that
     # #respond_to? has been patched to appropriately recognize
     # key methods.
     #
@@ -18,9 +18,9 @@ module Hashie
     #   user = User.new
     #   user['first_name'] = 'Michael'
     #   user.first_name # => 'Michael'
-    #   
+    #
     #   user[:last_name] = 'Bleigh'
-    #   user.last_name # => 'Bleigh'    
+    #   user.last_name # => 'Bleigh'
     #
     #   user[:birthday] = nil
     #   user.birthday # => nil
@@ -31,7 +31,7 @@ module Hashie
         return true if key?(name.to_s) || key?(name.to_sym)
         super
       end
-      
+
       def method_missing(name, *args)
         return self[name.to_s] if key?(name.to_s)
         return self[name.to_sym] if key?(name.to_sym)
@@ -64,7 +64,7 @@ module Hashie
 
       def method_missing(name, *args)
         if args.size == 1 && name.to_s =~ /(.*)=$/
-          return self[convert_key($1)] = args.first
+          return self[convert_key(Regexp.last_match[1])] = args.first
         end
 
         super
@@ -97,13 +97,13 @@ module Hashie
     #   h.hji? # => NoMethodError
     module MethodQuery
       def respond_to?(name, include_private = false)
-        return true if name.to_s =~ /(.*)\?$/ && (key?($1) || key?($1.to_sym))
+        return true if name.to_s =~ /(.*)\?$/ && (key?(Regexp.last_match[1]) || key?(Regexp.last_match[1].to_sym))
         super
       end
 
       def method_missing(name, *args)
-        if args.empty? && name.to_s =~ /(.*)\?$/ && (key?($1) || key?($1.to_sym))
-          return self[$1] || self[$1.to_sym]
+        if args.empty? && name.to_s =~ /(.*)\?$/ && (key?(Regexp.last_match[1]) || key?(Regexp.last_match[1].to_sym))
+          return self[Regexp.last_match[1]] || self[Regexp.last_match[1].to_sym]
         end
 
         super

data/lib/hashie/hash.rb

@@ -7,19 +7,19 @@ module Hashie
   class Hash < ::Hash
     include HashExtensions
 
-    # Converts a mash back to a hash (with stringified keys)
-    def to_hash(options={})
+    # Converts a mash back to a hash (with stringified or symbolized keys)
+    def to_hash(options = {})
       out = {}
       keys.each do |k|
+        assignment_key = k.to_s
+        assignment_key = assignment_key.to_sym if options[:symbolize_keys]
         if self[k].is_a?(Array)
-          k = options[:symbolize_keys] ? k.to_sym : k.to_s
-          out[k] ||= []
+          out[assignment_key] ||= []
           self[k].each do |array_object|
-            out[k] << (Hash === array_object ? array_object.to_hash : array_object)
+            out[assignment_key] << (Hash === array_object ? array_object.to_hash(options) : array_object)
           end
         else
-          k = options[:symbolize_keys] ? k.to_sym : k.to_s
-          out[k] = Hash === self[k] ? self[k].to_hash : self[k]
+          out[assignment_key] = Hash === self[k] ? self[k].to_hash(options) : self[k]
         end
       end
       out

data/lib/hashie/hash_extensions.rb

@@ -11,10 +11,8 @@ module Hashie
     # Destructively convert all of the keys of a Hash
     # to their string representations.
     def hashie_stringify_keys!
-      self.keys.each do |k|
-        unless String === k
-          self[k.to_s] = self.delete(k)
-        end
+      keys.each do |k|
+        self[k.to_s] = delete(k) unless String === k
       end
       self
     end
@@ -22,7 +20,7 @@ module Hashie
     # Convert all of the keys of a Hash
     # to their string representations.
     def hashie_stringify_keys
-      self.dup.stringify_keys!
+      dup.stringify_keys!
     end
 
     # Convert this hash into a Mash
@@ -38,11 +36,11 @@ module Hashie
     end
 
     def hashie_inspect
-      ret = "#<#{self.class.to_s}"
+      ret = "#<#{self.class}"
       stringify_keys.keys.sort.each do |key|
         ret << " #{key}=#{self[key].inspect}"
       end
-      ret << ">"
+      ret << '>'
       ret
     end
   end

data/lib/hashie/mash.rb

@@ -55,6 +55,7 @@ module Hashie
   #   mash.author # => <Mash>
   #
   class Mash < Hash
+    ALLOWED_SUFFIXES = %w(? ! = _)
     include Hashie::PrettyInspect
     alias_method :to_s, :inspect
 
@@ -67,14 +68,14 @@ module Hashie
       default ? super(default) : super(&blk)
     end
 
-    class << self; alias [] new; end
+    class << self; alias_method :[], :new; end
 
     def id #:nodoc:
-      self["id"]
+      self['id']
     end
 
     def type #:nodoc:
-      self["type"]
+      self['type']
     end
 
     alias_method :regular_reader, :[]
@@ -91,8 +92,8 @@ module Hashie
     # Sets an attribute in the Mash. Key will be converted to
     # a string before it is set, and Hashes will be converted
     # into Mashes for nesting purposes.
-    def custom_writer(key,value) #:nodoc:
-      regular_writer(convert_key(key), convert_value(value))
+    def custom_writer(key, value, convert = true) #:nodoc:
+      regular_writer(convert_key(key), convert ? convert_value(value) : value)
     end
 
     alias_method :[], :custom_reader
@@ -128,7 +129,7 @@ module Hashie
     alias_method :regular_dup, :dup
     # Duplicates the current mash as a new mash.
     def dup
-      self.class.new(self, self.default)
+      self.class.new(self, default)
     end
 
     def key?(key)
@@ -148,14 +149,14 @@ module Hashie
     # Recursively merges this mash with the passed
     # in hash, merging each hash in the hierarchy.
     def deep_update(other_hash, &blk)
-      other_hash.each_pair do |k,v|
+      other_hash.each_pair do |k, v|
         key = convert_key(k)
-        if regular_reader(key).is_a?(Mash) and v.is_a?(::Hash)
+        if regular_reader(key).is_a?(Mash) && v.is_a?(::Hash)
           custom_reader(key).deep_update(v, &blk)
         else
           value = convert_value(v, true)
-          value = blk.call(key, self[k], value) if blk
-          custom_writer(key, value)
+          value = convert_value(blk.call(key, self[k], value), true) if blk
+          custom_writer(key, value, false)
         end
       end
       self
@@ -172,7 +173,7 @@ module Hashie
     # Merges (non-recursively) the hash from the argument,
     # changing the receiving hash
     def shallow_update(other_hash)
-      other_hash.each_pair do |k,v|
+      other_hash.each_pair do |k, v|
         regular_writer(convert_key(k), convert_value(v, true))
       end
       self
@@ -186,25 +187,31 @@ module Hashie
 
     # Will return true if the Mash has had a key
     # set in addition to normal respond_to? functionality.
-    def respond_to?(method_name, include_private=false)
-      return true if key?(method_name) || method_name.to_s.slice(/[=?!_]\Z/)
+    def respond_to?(method_name, include_private = false)
+      return true if key?(method_name) || prefix_method?(method_name)
       super
     end
 
+    def prefix_method?(method_name)
+      method_name = method_name.to_s
+      method_name.end_with?(*ALLOWED_SUFFIXES) && key?(method_name.chop)
+    end
+
     def method_missing(method_name, *args, &blk)
       return self.[](method_name, &blk) if key?(method_name)
-      match = method_name.to_s.match(/(.*?)([?=!_]?)$/)
+      suffixes_regex = ALLOWED_SUFFIXES.join
+      match = method_name.to_s.match(/(.*?)([#{suffixes_regex}]?)$/)
       case match[2]
-      when "="
+      when '='
         self[match[1]] = args.first
-      when "?"
+      when '?'
         !!self[match[1]]
-      when "!"
+      when '!'
         initializing_reader(match[1])
-      when "_"
+      when '_'
         underbang_reader(match[1])
       else
-        default(method_name, *args, &blk)
+        default(method_name)
       end
     end
 
@@ -214,19 +221,19 @@ module Hashie
       key.to_s
     end
 
-    def convert_value(val, duping=false) #:nodoc:
+    def convert_value(val, duping = false) #:nodoc:
       case val
-        when self.class
-          val.dup
-        when Hash
-          duping ? val.dup : val
-        when ::Hash
-          val = val.dup if duping
-          self.class.new(val)
-        when Array
-          val.collect{ |e| convert_value(e) }
-        else
-          val
+      when self.class
+        val.dup
+      when Hash
+        duping ? val.dup : val
+      when ::Hash
+        val = val.dup if duping
+        self.class.new(val)
+      when Array
+        val.map { |e| convert_value(e) }
+      else
+        val
       end
     end
   end

data/lib/hashie/rash.rb

@@ -0,0 +1,119 @@
+module Hashie
+  #
+  # Rash is a Hash whose keys can be Regexps, or Ranges, which will
+  # match many input keys.
+  #
+  # A good use case for this class is routing URLs in a web framework.
+  # The Rash's keys match URL patterns, and the values specify actions
+  # which can handle the URL. When the Rash's value is proc, the proc
+  # will be automatically called with the regexp's matched groups as
+  # block arguments.
+  #
+  # Usage example:
+  #
+  #     greeting = Hashie::Rash.new( /^Mr./ => "Hello sir!", /^Mrs./ => "Evening, madame." )
+  #     greeting["Mr. Steve Austin"] #=> "Hello sir!"
+  #     greeting["Mrs. Steve Austin"] #=> "Evening, madame."
+  #
+  # Note: The Rash is automatically optimized every 500 accesses
+  #       (Regexps get sorted by how often they get matched).
+  #       If this is too low or too high, you can tune it by
+  #       setting: `rash.optimize_every = n`
+  #
+  class Rash
+    attr_accessor :optimize_every
+
+    def initialize(initial = {})
+      @hash           = {}
+      @regexes        = []
+      @ranges         = []
+      @regex_counts   = Hash.new(0)
+      @optimize_every = 500
+      @lookups        = 0
+
+      update(initial)
+    end
+
+    def update(other)
+      other.each do |key, value|
+        self[key] = value
+      end
+
+      self
+    end
+
+    def []=(key, value)
+      case key
+      when Regexp
+        # key = normalize_regex(key)  # this used to just do: /#{regexp}/
+        @regexes << key
+      when Range
+        @ranges << key
+      end
+      @hash[key] = value
+    end
+
+    #
+    # Return the first thing that matches the key.
+    #
+    def [](key)
+      all(key).first
+    end
+
+    #
+    # Return everything that matches the query.
+    #
+    def all(query)
+      return to_enum(:all, query) unless block_given?
+
+      if @hash.include? query
+        yield @hash[query]
+        return
+      end
+
+      case query
+      when String
+        optimize_if_necessary!
+
+        # see if any of the regexps match the string
+        @regexes.each do |regex|
+          match = regex.match(query)
+          if match
+            @regex_counts[regex] += 1
+            value = @hash[regex]
+            if value.respond_to? :call
+              yield value.call(match)
+            else
+              yield value
+            end
+          end
+        end
+
+      when Integer
+        # see if any of the ranges match the integer
+        @ranges.each do |range|
+          yield @hash[range] if range.include? query
+        end
+
+      when Regexp
+        # Reverse operation: `rash[/regexp/]` returns all the hash's string keys which match the regexp
+        @hash.each do |key, val|
+          yield val if key.is_a?(String) && query =~ key
+        end
+      end
+    end
+
+    def method_missing(*args, &block)
+      @hash.send(*args, &block)
+    end
+
+    private
+
+    def optimize_if_necessary!
+      if (@lookups += 1) >= @optimize_every
+        @regexes = @regex_counts.sort_by { |regex, count| -count }.map { |regex, count| regex }
+        @lookups = 0
+      end
+    end
+  end
+end

data/lib/hashie/trash.rb

@@ -8,7 +8,6 @@ module Hashie
   # such as a Java api, where the keys are named differently from how we would
   # in Ruby.
   class Trash < Dash
-
     # Defines a property on the Trash. Options are as follows:
     #
     # * <tt>:default</tt> - Specify a default value for this property, to be
@@ -20,33 +19,31 @@ module Hashie
     def self.property(property_name, options = {})
       super
 
+      options[:from] = options[:from].to_sym if options[:from]
+      property_name = property_name.to_sym
+
       if options[:from]
-        if property_name.to_sym == options[:from].to_sym
-          raise ArgumentError, "Property name (#{property_name}) and :from option must not be the same"
+        if property_name == options[:from]
+          fail ArgumentError, "Property name (#{property_name}) and :from option must not be the same"
+        end
+
+        translations[options[:from].to_sym] = property_name.to_sym
+
+        define_method "#{options[:from]}=" do |val|
+          with = options[:with] || options[:transform_with]
+          self[property_name.to_sym] = with.respond_to?(:call) ? with.call(val) : val
         end
-        translations << options[:from].to_sym
-        if options[:with].respond_to? :call
-          class_eval do
-            define_method "#{options[:from]}=" do |val|
-              self[property_name.to_sym] = options[:with].call(val)
-            end
-          end
-        else
-          class_eval <<-RUBY
-            def #{options[:from]}=(val)
-              self[:#{property_name}] = val
-            end
-          RUBY
+      else
+        if options[:transform_with].respond_to? :call
+          transforms[property_name.to_sym] = options[:transform_with]
         end
-      elsif options[:transform_with].respond_to? :call
-        transforms[property_name.to_sym] = options[:transform_with]
       end
     end
 
     # Set a value on the Dash in a Hash-like way. Only works
     # on pre-existing properties.
     def []=(property, value)
-      if self.class.translations.include? property.to_sym
+      if self.class.translations.key? property.to_sym
         send("#{property}=", value)
       elsif self.class.transforms.key? property.to_sym
         super property, self.class.transforms[property.to_sym].call(value)
@@ -55,10 +52,22 @@ module Hashie
       end
     end
 
+    def self.permitted_input_keys
+      @permitted_input_keys ||= properties.map { |property| inverse_translations.fetch property, property }
+    end
+
     private
 
+    def self.properties
+      @properties ||= []
+    end
+
     def self.translations
-      @translations ||= []
+      @translations ||= {}
+    end
+
+    def self.inverse_translations
+      @inverse_translations ||= Hash[translations.map(&:reverse)]
     end
 
     def self.transforms
@@ -69,7 +78,7 @@ module Hashie
     #
     def property_exists?(property)
       unless self.class.property?(property.to_sym)
-        raise NoMethodError, "The property '#{property}' is not defined for this Trash."
+        fail NoMethodError, "The property '#{property}' is not defined for this Trash."
       end
       true
     end
@@ -79,7 +88,7 @@ module Hashie
     # Deletes any keys that have a translation
     def initialize_attributes(attributes)
       return unless attributes
-      attributes_copy = attributes.dup.delete_if do |k,v|
+      attributes_copy = attributes.dup.delete_if do |k, v|
         if self.class.translations.include?(k.to_sym)
           self[k] = v
           true