hashie 3.2.0 → 3.3.1

data/lib/hashie/extensions/coercion.rb

@@ -1,35 +1,75 @@
 module Hashie
+  class CoercionError < StandardError; end
+
   module Extensions
     module Coercion
+      CORE_TYPES = {
+        Integer    => :to_i,
+        Float      => :to_f,
+        Complex    => :to_c,
+        Rational   => :to_r,
+        String     => :to_s,
+        Symbol     => :to_sym
+      }
+
+      ABSTRACT_CORE_TYPES = {
+        Integer => [Fixnum, Bignum],
+        Numeric => [Fixnum, Bignum, Float, Complex, Rational]
+      }
+
       def self.included(base)
         base.send :include, InstanceMethods
         base.extend ClassMethods # NOTE: we wanna make sure we first define set_value_with_coercion before extending
 
-        base.send :alias_method, :'set_value_without_coercion', :[]=
-        base.send :alias_method, :[]=, :'set_value_with_coercion'
+        base.send :alias_method, :set_value_without_coercion, :[]= unless base.method_defined?(:set_value_without_coercion)
+        base.send :alias_method, :[]=, :set_value_with_coercion
       end
 
       module InstanceMethods
         def set_value_with_coercion(key, value)
           into = self.class.key_coercion(key) || self.class.value_coercion(value)
 
-          return set_value_without_coercion(key, value) unless value && into
-          return set_value_without_coercion(key, coerce_or_init(into).call(value)) unless into.is_a?(Enumerable)
+          return set_value_without_coercion(key, value) if value.nil? || into.nil?
 
-          if into.class >= Hash
-            key_coerce = coerce_or_init(into.flatten[0])
-            value_coerce = coerce_or_init(into.flatten[-1])
-            value = Hash[value.map { |k, v| [key_coerce.call(k), value_coerce.call(v)] }]
-          else # Enumerable but not Hash: Array, Set
-            value_coerce = coerce_or_init(into.first)
-            value = into.class.new(value.map { |v| value_coerce.call(v) })
+          begin
+            return set_value_without_coercion(key, coerce_or_init(into).call(value)) unless into.is_a?(Enumerable)
+
+            if into.class >= Hash
+              key_coerce = coerce_or_init(into.flatten[0])
+              value_coerce = coerce_or_init(into.flatten[-1])
+              value = Hash[value.map { |k, v| [key_coerce.call(k), value_coerce.call(v)] }]
+            else # Enumerable but not Hash: Array, Set
+              value_coerce = coerce_or_init(into.first)
+              value = into.class.new(value.map { |v| value_coerce.call(v) })
+            end
+          rescue NoMethodError, TypeError => e
+            raise CoercionError, "Cannot coerce property #{key.inspect} from #{value.class} to #{into}: #{e.message}"
           end
 
           set_value_without_coercion(key, value)
         end
 
         def coerce_or_init(type)
-          type.respond_to?(:coerce) ? ->(v) { type.coerce(v) } : ->(v) { type.new(v) }
+          return type if type.is_a? Proc
+
+          if CORE_TYPES.key?(type)
+            lambda do |v|
+              return v if v.is_a? type
+              return v.send(CORE_TYPES[type])
+            end
+          elsif type.respond_to?(:coerce)
+            lambda do |v|
+              return v if v.is_a? type
+              type.coerce(v)
+            end
+          elsif type.respond_to?(:new)
+            lambda do |v|
+              return v if v.is_a? type
+              type.new(v)
+            end
+          else
+            fail TypeError, "#{type} is not a coercable type"
+          end
         end
 
         private :coerce_or_init
@@ -102,6 +142,12 @@ module Hashie
         def coerce_value(from, into, options = {})
           options = { strict: true }.merge(options)
 
+          if ABSTRACT_CORE_TYPES.key? from
+            ABSTRACT_CORE_TYPES[from].each do | type |
+              coerce_value type, into, options
+            end
+          end
+
           if options[:strict]
             (@strict_value_coercions ||= {})[from] = into
           else

data/lib/hashie/extensions/deep_find.rb

@@ -0,0 +1,59 @@
+module Hashie
+  module Extensions
+    module DeepFind
+      # Performs a depth-first search on deeply nested data structures for
+      # a key and returns the first occurrence of the key.
+      #
+      #  options = {user: {location: {address: '123 Street'}}}
+      #  options.deep_find(:address) # => '123 Street'
+      def deep_find(key)
+        _deep_find(key)
+      end
+
+      alias_method :deep_detect, :deep_find
+
+      # Performs a depth-first search on deeply nested data structures for
+      # a key and returns all occurrences of the key.
+      #
+      #  options = {users: [{location: {address: '123 Street'}}, {location: {address: '234 Street'}}]}
+      #  options.deep_find_all(:address) # => ['123 Street', '234 Street']
+      def deep_find_all(key)
+        matches = _deep_find_all(key)
+        matches.empty? ? nil : matches
+      end
+
+      alias_method :deep_select, :deep_find_all
+
+      private
+
+      def _deep_find(key, object = self)
+        if object.respond_to?(:key?)
+          return object[key] if object.key?(key)
+
+          reduce_to_match(key, object.values)
+        elsif object.is_a?(Enumerable)
+          reduce_to_match(key, object)
+        end
+      end
+
+      def _deep_find_all(key, object = self, matches = [])
+        if object.respond_to?(:key?)
+          matches << object[key] if object.key?(key)
+          object.values.each { |v| _deep_find_all(key, v, matches) }
+        elsif object.is_a?(Enumerable)
+          object.each { |v| _deep_find_all(key, v, matches) }
+        end
+
+        matches
+      end
+
+      def reduce_to_match(key, enumerable)
+        enumerable.reduce(nil) do |found, value|
+          return found if found
+
+          _deep_find(key, value)
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/indifferent_access.rb

@@ -83,9 +83,9 @@ module Hashie
 
       def convert_value(value)
         if hash_lacking_indifference?(value)
-          IndifferentAccess.inject(value.dup)
+          IndifferentAccess.inject!(value)
         elsif value.is_a?(::Array)
-          value.dup.replace(value.map { |e| convert_value(e) })
+          value.replace(value.map { |e| convert_value(e) })
         else
           value
         end

data/lib/hashie/extensions/mash/safe_assignment.rb

@@ -0,0 +1,13 @@
+module Hashie
+  module Extensions
+    module Mash
+      module SafeAssignment
+        def assign_property(name, value)
+          fail ArgumentError, "The property #{name} clashes with an existing method." if methods.include?(name.to_sym)
+
+          self[name] = value
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/method_access.rb

@@ -120,5 +120,80 @@ module Hashie
         end
       end
     end
+
+    # MethodOverridingWriter gives you #key_name= shortcuts for
+    # writing to your hash. It allows methods to be overridden by
+    # #key_name= shortcuts and aliases those methods with two
+    # leading underscores.
+    #
+    # Keys are written as strings. Override #convert_key if you
+    # would like to have symbols or something else.
+    #
+    # Note that MethodOverridingWriter also overrides
+    # #respond_to_missing? such that any #method_name= will respond
+    # appropriately as true.
+    #
+    # @example
+    #   class MyHash < Hash
+    #     include Hashie::Extensions::MethodOverridingWriter
+    #   end
+    #
+    #   h = MyHash.new
+    #   h.awesome = 'sauce'
+    #   h['awesome'] # => 'sauce'
+    #   h.zip = 'a-dee-doo-dah'
+    #   h.zip # => 'a-dee-doo-dah'
+    #   h.__zip # => [[['awesome', 'sauce'], ['zip', 'a-dee-doo-dah']]]
+    #
+    module MethodOverridingWriter
+      def convert_key(key)
+        key.to_s
+      end
+
+      def method_missing(name, *args)
+        if args.size == 1 && name.to_s =~ /(.*)=$/
+          key = Regexp.last_match[1]
+          redefine_method(key) if method?(key) && !already_overridden?(key)
+          return self[convert_key(key)] = args.first
+        end
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        return true if name.to_s.end_with?('=')
+        super
+      end
+
+      protected
+
+      def already_overridden?(name)
+        method?("__#{name}")
+      end
+
+      def method?(name)
+        methods.map { |m| m.to_s }.include?(name)
+      end
+
+      def redefine_method(method_name)
+        eigenclass = class << self; self; end
+        eigenclass.__send__(:alias_method, "__#{method_name}", method_name)
+        eigenclass.__send__(:define_method, method_name, -> { self[method_name] })
+      end
+    end
+
+    # A macro module that will automatically include MethodReader,
+    # MethodOverridingWriter, and MethodQuery, giving you the ability
+    # to read, write, and query keys in a hash using method call
+    # shortcuts that can override object methods. Any overridden
+    # object method is automatically aliased with two leading
+    # underscores.
+    module MethodAccessWithOverride
+      def self.included(base)
+        [MethodReader, MethodOverridingWriter, MethodQuery].each do |mod|
+          base.send :include, mod
+        end
+      end
+    end
   end
 end

data/lib/hashie/extensions/parsers/yaml_erb_parser.rb

@@ -0,0 +1,21 @@
+require 'yaml'
+require 'erb'
+module Hashie
+  module Extensions
+    module Parsers
+      class YamlErbParser
+        def initialize(file_path)
+          @content = File.read(file_path)
+        end
+
+        def perform
+          YAML.load ERB.new(@content).result
+        end
+
+        def self.perform(file_path)
+          new(file_path).perform
+        end
+      end
+    end
+  end
+end

data/lib/hashie/mash.rb

@@ -59,6 +59,25 @@ module Hashie
 
     ALLOWED_SUFFIXES = %w(? ! = _)
 
+    def self.load(path, options = {})
+      @_mashes ||= new do |h, file_path|
+        fail ArgumentError, "The following file doesn't exist: #{file_path}" unless File.file?(file_path)
+
+        parser = options.fetch(:parser) {  Hashie::Extensions::Parsers::YamlErbParser }
+        h[file_path] = new(parser.perform(file_path)).freeze
+      end
+      @_mashes[path]
+    end
+
+    def to_module(mash_method_name = :settings)
+      mash = self
+      Module.new do |m|
+        m.send :define_method, mash_method_name.to_sym do
+          mash
+        end
+      end
+    end
+
     alias_method :to_s, :inspect
 
     # If you pass in an existing hash, it will
@@ -171,6 +190,11 @@ module Hashie
     alias_method :update, :deep_update
     alias_method :merge!, :update
 
+    # Assigns a value to a key
+    def assign_property(name, value)
+      self[name] = value
+    end
+
     # Performs a shallow_update on a duplicate of the current mash
     def shallow_merge(other_hash)
       dup.shallow_update(other_hash)
@@ -212,7 +236,7 @@ module Hashie
       name, suffix = method_suffix(method_name)
       case suffix
       when '='
-        self[name] = args.first
+        assign_property(name, args.first)
       when '?'
         !!self[name]
       when '!'

data/lib/hashie/rash.rb

@@ -60,6 +60,28 @@ module Hashie
       all(key).first
     end
 
+    #
+    # Raise (or yield) unless something matches the key.
+    #
+    def fetch(*args)
+      fail ArgumentError, "Expected 1-2 arguments, got #{args.length}" \
+        unless (1..2).cover?(args.length)
+
+      key, default = args
+
+      all(key) do |value|
+        return value
+      end
+
+      if block_given?
+        yield key
+      elsif default
+        default
+      else
+        fail KeyError, "key not found: #{key.inspect}"
+      end
+    end
+
     #
     # Return everything that matches the query.
     #
@@ -106,6 +128,10 @@ module Hashie
       @hash.send(*args, &block)
     end
 
+    def respond_to_missing?(*args)
+      @hash.respond_to?(*args)
+    end
+
     private
 
     def optimize_if_necessary!

data/lib/hashie/trash.rb

@@ -26,11 +26,13 @@ module Hashie
           fail ArgumentError, "Property name (#{property_name}) and :from option must not be the same"
         end
 
-        translations[options[:from]] = property_name
+        translations_hash[options[:from]] ||= {}
+        translations_hash[options[:from]][property_name] = options[:with] || options[:transform_with]
 
         define_method "#{options[:from]}=" do |val|
-          with = options[:with] || options[:transform_with]
-          self[property_name] = with.respond_to?(:call) ? with.call(val) : val
+          self.class.translations_hash[options[:from]].each do |name, with|
+            self[name] = with.respond_to?(:call) ? with.call(val) : val
+          end
         end
       else
         if options[:transform_with].respond_to? :call
@@ -39,6 +41,18 @@ module Hashie
       end
     end
 
+    class << self
+      attr_reader :transforms, :translations_hash
+    end
+    instance_variable_set('@transforms', {})
+    instance_variable_set('@translations_hash', {})
+
+    def self.inherited(klass)
+      super
+      klass.instance_variable_set('@transforms', transforms.dup)
+      klass.instance_variable_set('@translations_hash', translations_hash.dup)
+    end
+
     # Set a value on the Dash in a Hash-like way. Only works
     # on pre-existing properties.
     def []=(property, value)
@@ -56,7 +70,7 @@ module Hashie
     end
 
     def self.translation_exists?(name)
-      translations.key? name
+      translations_hash.key? name
     end
 
     def self.transformation_exists?(name)
@@ -69,20 +83,26 @@ module Hashie
 
     private
 
-    def self.properties
-      @properties ||= []
-    end
-
     def self.translations
-      @translations ||= {}
+      @translations ||= begin
+        h = {}
+        translations_hash.each do |(property_name, property_translations)|
+          h[property_name] = property_translations.size > 1 ? property_translations.keys : property_translations.keys.first
+        end
+        h
+      end
     end
 
     def self.inverse_translations
-      @inverse_translations ||= Hash[translations.map(&:reverse)]
-    end
-
-    def self.transforms
-      @transforms ||= {}
+      @inverse_translations ||= begin
+        h = {}
+        translations_hash.each do |(property_name, property_translations)|
+          property_translations.keys.each do |k|
+            h[k] = property_name
+          end
+        end
+        h
+      end
     end
 
     # Raises an NoMethodError if the property doesn't exist
@@ -98,7 +118,7 @@ module Hashie
     def initialize_attributes(attributes)
       return unless attributes
       attributes_copy = attributes.dup.delete_if do |k, v|
-        if self.class.translations.include?(k)
+        if self.class.translations_hash.include?(k)
           self[k] = v
           true
         end