hashie 2.0.5 → 2.1.0

data/Rakefile

@@ -6,8 +6,10 @@ Bundler::GemHelper.install_tasks
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new do |spec|
-  # spec.libs << 'lib' << 'spec'
   spec.pattern = 'spec/**/*_spec.rb'
 end
 
-task :default => :spec
+require 'rubocop/rake_task'
+Rubocop::RakeTask.new(:rubocop)
+
+task default: [:rubocop, :spec]

data/hashie.gemspec

@@ -3,8 +3,8 @@ require File.expand_path('../lib/hashie/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Michael Bleigh", "Jerry Cheung"]
   gem.email         = ["michael@intridea.com", "jollyjerry@gmail.com"]
-  gem.description   = %q{Hashie is a small collection of tools that make hashes more powerful. Currently includes Mash (Mocking Hash) and Dash (Discrete Hash).}
-  gem.summary       = %q{Your friendly neighborhood hash toolkit.}
+  gem.description   = %q{Hashie is a collection of classes and mixins that make hashes more powerful.}
+  gem.summary       = %q{Your friendly neighborhood hash library.}
   gem.homepage      = 'https://github.com/intridea/hashie'
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
@@ -15,9 +15,6 @@ Gem::Specification.new do |gem|
   gem.version       = Hashie::VERSION
   gem.license       = "MIT"
 
-  gem.add_development_dependency 'rake', '~> 0.9.2'
-  gem.add_development_dependency 'rspec', '~> 2.5'
-  gem.add_development_dependency 'guard'
-  gem.add_development_dependency 'guard-rspec'
-  gem.add_development_dependency 'growl'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
 end

data/lib/hashie.rb

@@ -6,11 +6,13 @@ module Hashie
   autoload :Mash,           'hashie/mash'
   autoload :PrettyInspect,  'hashie/hash_extensions'
   autoload :Trash,          'hashie/trash'
+  autoload :Rash,           'hashie/rash'
 
   module Extensions
     autoload :Coercion,          'hashie/extensions/coercion'
     autoload :DeepMerge,         'hashie/extensions/deep_merge'
     autoload :KeyConversion,     'hashie/extensions/key_conversion'
+    autoload :IgnoreUndeclared,  'hashie/extensions/ignore_undeclared'
     autoload :IndifferentAccess, 'hashie/extensions/indifferent_access'
     autoload :MergeInitializer,  'hashie/extensions/merge_initializer'
     autoload :MethodAccess,      'hashie/extensions/method_access'
@@ -19,5 +21,6 @@ module Hashie
     autoload :MethodWriter,      'hashie/extensions/method_access'
     autoload :StringifyKeys,     'hashie/extensions/key_conversion'
     autoload :SymbolizeKeys,     'hashie/extensions/key_conversion'
+    autoload :DeepFetch,         'hashie/extensions/deep_fetch'
   end
 end

data/lib/hashie/clash.rb

@@ -3,10 +3,10 @@ require 'hashie/hash'
 module Hashie
   #
   # A Clash is a "Chainable Lazy Hash". Inspired by libraries such as Arel,
-  # a Clash allows you to chain together method arguments to build a 
+  # a Clash allows you to chain together method arguments to build a
   # hash, something that's especially useful if you're doing something
   # like constructing a complex options hash. Here's a basic example:
-  # 
+  #
   #     c = Hashie::Clash.new.conditions(:foo => 'bar').order(:created_at)
   #     c # => {:conditions => {:foo => 'bar'}, :order => :created_at}
   #
@@ -15,7 +15,7 @@ module Hashie
   # back out again with the _end! method. Example:
   #
   #     c = Hashie::Clash.new.conditions!.foo('bar').baz(123)._end!.order(:created_at)
-  #     c # => {:conditions => {:foo => 'bar', :baz => 123}, :order => :created_at}
+  #     c # => { conditions: { foo: 'bar', baz: 123 }, order: :created_at}
   #
   # Because the primary functionality of Clash is to build options objects,
   # all keys are converted to symbols since many libraries expect symbols explicitly
@@ -25,7 +25,7 @@ module Hashie
     class ChainError < ::StandardError; end
     # The parent Clash if this Clash was created via chaining.
     attr_reader :_parent
-    
+
     # Initialize a new clash by passing in a Hash to
     # convert and, optionally, the parent to which this
     # Clash is chained.
@@ -35,7 +35,7 @@ module Hashie
         self[k.to_sym] = v
       end
     end
-    
+
     # Jump back up a level if you are using bang method
     # chaining. For example:
     #
@@ -43,44 +43,44 @@ module Hashie
     # c.baz!.foo(123) # => c[:baz]
     # c.baz!._end! # => c
     def _end!
-      self._parent
+      _parent
     end
-    
+
     def id(*args) #:nodoc:
       method_missing(:id, *args)
     end
-    
+
     def merge_store(key, *args) #:nodoc:
       case args.length
-        when 1
-          val = args.first
-          val = self[key].merge(val) if self[key].is_a?(::Hash) && val.is_a?(::Hash)
-        else
-          val = args
+      when 1
+        val = args.first
+        val = self[key].merge(val) if self[key].is_a?(::Hash) && val.is_a?(::Hash)
+      else
+        val = args
       end
 
       self[key.to_sym] = val
       self
     end
-    
+
     def method_missing(name, *args) #:nodoc:
       name = name.to_s
       if name.match(/!$/) && args.empty?
         key = name[0...-1].to_sym
-        
+
         if self[key].nil?
           self[key] = Clash.new({}, self)
         elsif self[key].is_a?(::Hash) && !self[key].is_a?(Clash)
           self[key] = Clash.new(self[key], self)
         else
-          raise ChainError, "Tried to chain into a non-hash key."
+          fail ChainError, 'Tried to chain into a non-hash key.'
         end
-        
+
         self[key]
       elsif args.any?
         key = name.to_sym
-        self.merge_store(key, *args)
+        merge_store(key, *args)
       end
     end
   end
-end
+end

data/lib/hashie/dash.rb

@@ -30,24 +30,18 @@ module Hashie
     def self.property(property_name, options = {})
       property_name = property_name.to_sym
 
-      self.properties << property_name
+      properties << property_name
 
-      if options.has_key?(:default)
-        self.defaults[property_name] = options[:default]
-      elsif self.defaults.has_key?(property_name)
-        self.defaults.delete property_name
+      if options.key?(:default)
+        defaults[property_name] = options[:default]
+      elsif defaults.key?(property_name)
+        defaults.delete property_name
       end
 
       unless instance_methods.map { |m| m.to_s }.include?("#{property_name}=")
-        class_eval <<-ACCESSORS
-          def #{property_name}(&block)
-            self.[](#{property_name.to_s.inspect}, &block)
-          end
-
-          def #{property_name}=(value)
-            self.[]=(#{property_name.to_s.inspect}, value)
-          end
-        ACCESSORS
+        define_method(property_name) { |&block| self.[](property_name.to_s, &block) }
+        property_assignment = property_name.to_s.concat('=').to_sym
+        define_method(property_assignment) { |value| self.[]=(property_name.to_s, value) }
       end
 
       if defined? @subclasses
@@ -67,9 +61,9 @@ module Hashie
     def self.inherited(klass)
       super
       (@subclasses ||= Set.new) << klass
-      klass.instance_variable_set('@properties', self.properties.dup)
-      klass.instance_variable_set('@defaults', self.defaults.dup)
-      klass.instance_variable_set('@required_properties', self.required_properties.dup)
+      klass.instance_variable_set('@properties', properties.dup)
+      klass.instance_variable_set('@defaults', defaults.dup)
+      klass.instance_variable_set('@required_properties', required_properties.dup)
     end
 
     # Check to see if the specified property has already been
@@ -127,6 +121,21 @@ module Hashie
       super(property.to_s, value)
     end
 
+    def merge(other_hash)
+      new_dash = dup
+      other_hash.each do |k, v|
+        new_dash[k] = block_given? ? yield(k, self[k], v) : v
+      end
+      new_dash
+    end
+
+    def merge!(other_hash)
+      other_hash.each do |k, v|
+        self[k] = block_given? ? yield(k, self[k], v) : v
+      end
+      self
+    end
+
     def replace(other_hash)
       other_hash = self.class.defaults.merge(other_hash)
       (keys - other_hash.keys).each { |key| delete(key) }
@@ -136,35 +145,34 @@ module Hashie
 
     private
 
-      def initialize_attributes(attributes)
-        attributes.each_pair do |att, value|
-          self[att] = value
-        end if attributes
-      end
+    def initialize_attributes(attributes)
+      attributes.each_pair do |att, value|
+        self[att] = value
+      end if attributes
+    end
 
-      def assert_property_exists!(property)
-        unless self.class.property?(property)
-          raise NoMethodError, "The property '#{property}' is not defined for this Dash."
-        end
+    def assert_property_exists!(property)
+      unless self.class.property?(property)
+        fail NoMethodError, "The property '#{property}' is not defined for this Dash."
       end
+    end
 
-      def assert_required_properties_set!
-        self.class.required_properties.each do |required_property|
-          assert_property_set!(required_property)
-        end
+    def assert_required_properties_set!
+      self.class.required_properties.each do |required_property|
+        assert_property_set!(required_property)
       end
+    end
 
-      def assert_property_set!(property)
-        if send(property).nil?
-          raise ArgumentError, "The property '#{property}' is required for this Dash."
-        end
+    def assert_property_set!(property)
+      if send(property).nil?
+        fail ArgumentError, "The property '#{property}' is required for this Dash."
       end
+    end
 
-      def assert_property_required!(property, value)
-        if self.class.required?(property) && value.nil?
-          raise ArgumentError, "The property '#{property}' is required for this Dash."
-        end
+    def assert_property_required!(property, value)
+      if self.class.required?(property) && value.nil?
+        fail ArgumentError, "The property '#{property}' is required for this Dash."
       end
-
+    end
   end
 end

data/lib/hashie/extensions/coercion.rb

@@ -2,7 +2,7 @@ module Hashie
   module Extensions
     module Coercion
       def self.included(base)
-        base.send :extend, ClassMethods
+        base.extend ClassMethods
         base.send :include, InstanceMethods
       end
 
@@ -21,7 +21,7 @@ module Hashie
           super(key, value)
         end
 
-        def custom_writer(key, value)
+        def custom_writer(key, value, convert = true)
           self[key] = value
         end
 
@@ -53,7 +53,7 @@ module Hashie
           attrs.each { |key| @key_coercions[key] = into }
         end
 
-        alias :coerce_keys :coerce_key
+        alias_method :coerce_keys, :coerce_key
 
         # Returns a hash of any existing key coercions.
         def key_coercions
@@ -87,7 +87,7 @@ module Hashie
         #     end
         #   end
         def coerce_value(from, into, options = {})
-          options = {:strict => true}.merge(options)
+          options = { strict: true }.merge(options)
 
           if options[:strict]
             (@strict_value_coercions ||= {})[from] = into
@@ -100,9 +100,13 @@ module Hashie
         end
 
         # Return all value coercions that have the :strict rule as true.
-        def strict_value_coercions; @strict_value_coercions || {} end
+        def strict_value_coercions
+          @strict_value_coercions || {}
+        end
         # Return all value coercions that have the :strict rule as false.
-        def lenient_value_coercions; @value_coercions || {} end
+        def lenient_value_coercions
+          @value_coercions || {}
+        end
 
         # Fetch the value coercion, if any, for the specified object.
         def value_coercion(value)

data/lib/hashie/extensions/deep_fetch.rb

@@ -0,0 +1,29 @@
+module Hashie
+  module Extensions
+    # Searches a deeply nested datastructure for a key path, and returns the associated value.
+    #
+    #  options = { user: { location: { address: '123 Street' } } }
+    #  options.deep_fetch :user, :location, :address #=> '123 Street'
+    #
+    # If a block is provided its value will be returned if the key does not exist.
+    #
+    #  options.deep_fetch(:user, :non_existent_key) { 'a value' } #=> 'a value'
+    #
+    # This is particularly useful for fetching values from deeply nested api responses or params hashes.
+    module DeepFetch
+      class UndefinedPathError < StandardError; end
+
+      def deep_fetch(*args, &block)
+        args.reduce(self) do |obj, arg|
+          begin
+            arg = Integer(arg) if obj.kind_of? Array
+            obj.fetch(arg)
+          rescue ArgumentError, IndexError => e
+            break block.call(arg) if block
+            raise UndefinedPathError, "Could not fetch path (#{args.join(' > ')}) at #{arg}", e.backtrace
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/deep_merge.rb

@@ -3,19 +3,28 @@ module Hashie
     module DeepMerge
       # Returns a new hash with +self+ and +other_hash+ merged recursively.
       def deep_merge(other_hash)
-        (class << (h = dup); self; end).send :include, Hashie::Extensions::DeepMerge
-        h.deep_merge!(other_hash)
+        dup.deep_merge!(other_hash)
       end
 
       # Returns a new hash with +self+ and +other_hash+ merged recursively.
       # Modifies the receiver in place.
       def deep_merge!(other_hash)
-        other_hash.each do |k,v|
-          (class << (tv = self[k]); self; end).send :include, Hashie::Extensions::DeepMerge
-          self[k] = tv.is_a?(::Hash) && v.is_a?(::Hash) ? tv.deep_merge(v) : v
-        end
+        _recursive_merge(self, other_hash)
         self
       end
+
+      private
+
+      def _recursive_merge(hash, other_hash)
+        if other_hash.is_a?(::Hash) && hash.is_a?(::Hash)
+          other_hash.each do |k, v|
+            hash[k] = hash.key?(k) ? _recursive_merge(hash[k], v) : v
+          end
+          hash
+        else
+          other_hash
+        end
+      end
     end
   end
 end

data/lib/hashie/extensions/ignore_undeclared.rb

@@ -0,0 +1,41 @@
+module Hashie
+  module Extensions
+    # IgnoreUndeclared is a simple mixin that silently ignores
+    # undeclared properties on initialization instead of
+    # raising an error. This is useful when using a Trash to
+    # capture a subset of a larger hash.
+    #
+    # Note that attempting to retrieve an undeclared property
+    # will still raise a NoMethodError, even if a value for
+    # that property was provided at initialization.
+    #
+    # @example
+    #   class Person < Trash
+    #     include Hashie::Extensions::IgnoreUndeclared
+    #
+    #     property :first_name
+    #     property :last_name
+    #   end
+    #
+    #   user_data = {
+    #      :first_name => 'Freddy',
+    #      :last_name => 'Nostrils',
+    #      :email => 'freddy@example.com'
+    #   }
+    #
+    #   p = Person.new(user_data) # 'email' is silently ignored
+    #
+    #   p.first_name # => 'Freddy'
+    #   p.last_name  # => 'Nostrils'
+    #   p.email      # => NoMethodError
+    module IgnoreUndeclared
+      def initialize_attributes(attributes)
+        attributes.each_pair do |att, value|
+          if self.class.property?(att) || (self.class.respond_to?(:translations) && self.class.translations.include?(att.to_sym))
+            self[att] = value
+          end
+        end if attributes
+      end
+    end
+  end
+end

data/lib/hashie/extensions/indifferent_access.rb

@@ -27,6 +27,7 @@ module Hashie
         base.class_eval do
           alias_method :regular_writer, :[]=
           alias_method :[]=, :indifferent_writer
+          alias_method :store, :indifferent_writer
           %w(default update replace fetch delete key? values_at).each do |m|
             alias_method "regular_#{m}", m
             alias_method m, "indifferent_#{m}"
@@ -35,6 +36,16 @@ module Hashie
           %w(include? member? has_key?).each do |key_alias|
             alias_method key_alias, :indifferent_key?
           end
+
+          class << self
+            def [](*)
+              super.convert!
+            end
+
+            def try_convert(*)
+              (hash = super) && self[hash]
+            end
+          end
         end
       end
 
@@ -61,7 +72,7 @@ module Hashie
       # is injecting itself into member hashes.
       def convert!
         keys.each do |k|
-          regular_writer convert_key(k), convert_value(self.regular_delete(k))
+          regular_writer convert_key(k), convert_value(regular_delete(k))
         end
         self
       end
@@ -75,7 +86,7 @@ module Hashie
           value
         end
       end
-      
+
       def indifferent_default(key = nil)
         return self[convert_key(key)] if key?(key)
         regular_default(key)
@@ -83,18 +94,34 @@ module Hashie
 
       def indifferent_update(other_hash)
         return regular_update(other_hash) if hash_with_indifference?(other_hash)
-        other_hash.each_pair do |k,v|
+        other_hash.each_pair do |k, v|
           self[k] = v
         end
       end
-      
-      def indifferent_writer(key, value);  regular_writer convert_key(key), convert_value(value) end
-      def indifferent_fetch(key, *args);   regular_fetch  convert_key(key), *args                end
-      def indifferent_delete(key);         regular_delete convert_key(key)                       end
-      def indifferent_key?(key);           regular_key?   convert_key(key)                       end
-      def indifferent_values_at(*indices); indices.map{|i| self[i] }                             end
 
-      def indifferent_access?; true end
+      def indifferent_writer(key, value)
+        regular_writer convert_key(key), convert_value(value)
+      end
+
+      def indifferent_fetch(key, *args)
+        regular_fetch convert_key(key), *args
+      end
+
+      def indifferent_delete(key)
+        regular_delete convert_key(key)
+      end
+
+      def indifferent_key?(key)
+        regular_key? convert_key(key)
+      end
+
+      def indifferent_values_at(*indices)
+        indices.map { |i| self[i] }
+      end
+
+      def indifferent_access?
+        true
+      end
 
       def indifferent_replace(other_hash)
         (keys - other_hash.keys).each { |key| delete(key) }