hashie 3.6.0 → 4.0.0

data/lib/hashie/extensions/dash/indifferent_access.rb

@@ -7,11 +7,23 @@ module Hashie
           base.send :include, Hashie::Extensions::IndifferentAccess
         end
 
+        def self.maybe_extend(base)
+          return unless requires_class_methods?(base)
+
+          base.extend(ClassMethods)
+        end
+
+        def self.requires_class_methods?(klass)
+          klass <= Hashie::Dash &&
+            !klass.singleton_class.included_modules.include?(ClassMethods)
+        end
+        private_class_method :requires_class_methods?
+
         module ClassMethods
           # Check to see if the specified property has already been
           # defined.
           def property?(name)
-            name = translations[name.to_sym] if included_modules.include?(Hashie::Extensions::Dash::PropertyTranslation) && translation_exists?(name)
+            name = translations[name.to_sym] if translation_for?(name)
             name = name.to_s
             !!properties.find { |property| property.to_s == name }
           end
@@ -30,6 +42,13 @@ module Hashie
             name = name.to_s
             !!transforms.keys.find { |key| key.to_s == name }
           end
+
+          private
+
+          def translation_for?(name)
+            included_modules.include?(Hashie::Extensions::Dash::PropertyTranslation) &&
+              translation_exists?(name)
+          end
         end
       end
     end

data/lib/hashie/extensions/dash/property_translation.rb

@@ -58,7 +58,9 @@ module Hashie
           end
 
           def permitted_input_keys
-            @permitted_input_keys ||= properties.map { |property| inverse_translations.fetch property, property }
+            @permitted_input_keys ||=
+              properties
+              .map { |property| inverse_translations.fetch property, property }
           end
 
           # Defines a property on the Trash. Options are as follows:
@@ -135,7 +137,8 @@ module Hashie
           end
 
           def fail_self_transformation_error!(property_name)
-            raise ArgumentError, "Property name (#{property_name}) and :from option must not be the same"
+            raise ArgumentError,
+                  "Property name (#{property_name}) and :from option must not be the same"
           end
 
           def valid_transformer?(transformer)

data/lib/hashie/extensions/deep_fetch.rb

@@ -9,7 +9,8 @@ module Hashie
     #
     #  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.
+    # This is particularly useful for fetching values from deeply nested api responses
+    #   or params hashes.
     module DeepFetch
       class UndefinedPathError < StandardError; end
 
@@ -20,7 +21,8 @@ module Hashie
             obj.fetch(arg)
           rescue ArgumentError, IndexError, NoMethodError => e
             break yield(arg) if block
-            raise UndefinedPathError, "Could not fetch path (#{args.join(' > ')}) at #{arg}", e.backtrace
+            raise UndefinedPathError,
+                  "Could not fetch path (#{args.join(' > ')}) at #{arg}", e.backtrace
           end
         end
       end

data/lib/hashie/extensions/deep_find.rb

@@ -1,3 +1,4 @@
+require 'hashie/extensions/deep_locate'
 module Hashie
   module Extensions
     module DeepFind
@@ -24,7 +25,12 @@ module Hashie
       # 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 = {
+      #    users: [
+      #      { location: {address: '123 Street'} },
+      #      { location: {address: '234 Street'}}
+      #    ]
+      #  }
       #  options.extend(Hashie::Extensions::DeepFind)
       #  options.deep_find_all(:address) # => ['123 Street', '234 Street']
       #
@@ -33,7 +39,10 @@ module Hashie
       #  end
       #
       #  my_hash = MyHash.new
-      #  my_hash[:users] = [{location: {address: '123 Street'}}, {location: {address: '234 Street'}}]
+      #  my_hash[:users] = [
+      #    {location: {address: '123 Street'}},
+      #    {location: {address: '234 Street'}}
+      #  ]
       #  my_hash.deep_find_all(:address) # => ['123 Street', '234 Street']
       def deep_find_all(key)
         matches = _deep_find_all(key)
@@ -49,7 +58,7 @@ module Hashie
       end
 
       def _deep_find_all(key, object = self, matches = [])
-        deep_locate_result = Hashie::Extensions::DeepLocate.deep_locate(key, object).tap do |result|
+        deep_locate_result = DeepLocate.deep_locate(key, object).tap do |result|
           result.map! { |element| element[key] }
         end
 

data/lib/hashie/extensions/deep_locate.rb

@@ -14,10 +14,12 @@ module Hashie
       #     ...
       #   ]
       #
-      #   Hashie::Extensions::DeepLocate.deep_locate -> (key, value, object) { key == :title }, books
+      #   DeepLocate.deep_locate -> (key, value, object) { key == :title }, books
       #   # => [{:title=>"Ruby for beginners", :pages=>120}, ...]
       def self.deep_locate(comparator, object)
-        comparator = _construct_key_comparator(comparator, object) unless comparator.respond_to?(:call)
+        unless comparator.respond_to?(:call)
+          comparator = _construct_key_comparator(comparator, object)
+        end
 
         _deep_locate(comparator, object)
       end
@@ -53,17 +55,21 @@ module Hashie
       #   # http://ruby-journal.com/becareful-with-space-in-lambda-hash-rocket-syntax-between-ruby-1-dot-9-and-2-dot-0/
       #
       #   books.deep_locate -> (key, value, object) { key == :title && value.include?("Ruby") }
-      #   # => [{:title=>"Ruby for beginners", :pages=>120}, {:title=>"Ruby for the rest of us", :pages=>576}]
+      #   # => [{:title=>"Ruby for beginners", :pages=>120},
+      #   #     {:title=>"Ruby for the rest of us", :pages=>576}]
       #
       #   books.deep_locate -> (key, value, object) { key == :pages && value <= 120 }
-      #   # => [{:title=>"Ruby for beginners", :pages=>120}, {:title=>"CSS for intermediates", :pages=>80}]
+      #   # => [{:title=>"Ruby for beginners", :pages=>120},
+      #   #     {:title=>"CSS for intermediates", :pages=>80}]
       def deep_locate(comparator)
         Hashie::Extensions::DeepLocate.deep_locate(comparator, self)
       end
 
       def self._construct_key_comparator(search_key, object)
-        search_key = search_key.to_s if defined?(::ActiveSupport::HashWithIndifferentAccess) && object.is_a?(::ActiveSupport::HashWithIndifferentAccess)
-        search_key = search_key.to_s if object.respond_to?(:indifferent_access?) && object.indifferent_access?
+        if object.respond_to?(:indifferent_access?) && object.indifferent_access? ||
+           activesupport_indifferent?(object)
+          search_key = search_key.to_s
+        end
 
         lambda do |non_callable_object|
           ->(key, _, _) { key == non_callable_object }
@@ -73,7 +79,10 @@ module Hashie
 
       def self._deep_locate(comparator, object, result = [])
         if object.is_a?(::Enumerable)
-          result.push object if object.any? { |value| _match_comparator?(value, comparator, object) }
+          if object.any? { |value| _match_comparator?(value, comparator, object) }
+            result.push object
+          end
+
           (object.respond_to?(:values) ? object.values : object.entries).each do |value|
             _deep_locate(comparator, value, result)
           end
@@ -93,6 +102,12 @@ module Hashie
         comparator.call(key, value, object)
       end
       private_class_method :_match_comparator?
+
+      def self.activesupport_indifferent?(object)
+        defined?(::ActiveSupport::HashWithIndifferentAccess) &&
+          object.is_a?(::ActiveSupport::HashWithIndifferentAccess)
+      end
+      private_class_method :activesupport_indifferent?
     end
   end
 end

data/lib/hashie/extensions/indifferent_access.rb

@@ -24,9 +24,7 @@ module Hashie
     #
     module IndifferentAccess
       def self.included(base)
-        Hashie::Extensions::Dash::IndifferentAccess::ClassMethods.tap do |extension|
-          base.extend(extension) if base <= Hashie::Dash && !base.singleton_class.included_modules.include?(extension)
-        end
+        Hashie::Extensions::Dash::IndifferentAccess.maybe_extend(base)
 
         base.class_eval do
           alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)

data/lib/hashie/extensions/key_conflict_warning.rb

@@ -0,0 +1,55 @@
+module Hashie
+  module Extensions
+    module KeyConflictWarning
+      class CannotDisableMashWarnings < StandardError
+        def initialize
+          super(
+            'You cannot disable warnings on the base Mash class. ' \
+            'Please subclass the Mash and disable it in the subclass.'
+          )
+        end
+      end
+
+      # Disable the logging of warnings based on keys conflicting keys/methods
+      #
+      # @api semipublic
+      # @return [void]
+      def disable_warnings(*method_keys)
+        raise CannotDisableMashWarnings if self == Hashie::Mash
+        if method_keys.any?
+          disabled_warnings.concat(method_keys).tap(&:flatten!).uniq!
+        else
+          disabled_warnings.clear
+        end
+
+        @disable_warnings = true
+      end
+
+      # Checks whether this class disables warnings for conflicting keys/methods
+      #
+      # @api semipublic
+      # @return [Boolean]
+      def disable_warnings?(method_key = nil)
+        return disabled_warnings.include?(method_key) if disabled_warnings.any? && method_key
+        @disable_warnings ||= false
+      end
+
+      # Returns an array of methods that this class disables warnings for.
+      #
+      # @api semipublic
+      # @return [Boolean]
+      def disabled_warnings
+        @_disabled_warnings ||= []
+      end
+
+      # Inheritance hook that sets class configuration when inherited.
+      #
+      # @api semipublic
+      # @return [void]
+      def inherited(subclass)
+        super
+        subclass.disable_warnings(disabled_warnings) if disable_warnings?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module Hashie
+  module Extensions
+    module Mash
+      module DefineAccessors
+        def self.included(klass)
+          klass.class_eval do
+            mod = Ext.new
+            include mod
+          end
+        end
+
+        def self.extended(obj)
+          included(obj.singleton_class)
+        end
+
+        class Ext < Module
+          def initialize
+            mod = self
+            define_method(:method_missing) do |method_name, *args, &block|
+              key, suffix = method_name_and_suffix(method_name)
+              case suffix
+              when '='.freeze
+                mod.define_writer(key, method_name)
+              when '?'.freeze
+                mod.define_predicate(key, method_name)
+              when '!'.freeze
+                mod.define_initializing_reader(key, method_name)
+              when '_'.freeze
+                mod.define_underbang_reader(key, method_name)
+              else
+                mod.define_reader(key, method_name)
+              end
+              send(method_name, *args, &block)
+            end
+          end
+
+          def define_reader(key, method_name)
+            define_method(method_name) do |&block|
+              if key? method_name
+                self.[](method_name, &block)
+              else
+                self.[](key, &block)
+              end
+            end
+          end
+
+          def define_writer(key, method_name)
+            define_method(method_name) do |value = nil|
+              if key? method_name
+                self.[](method_name, &proc)
+              else
+                assign_property(key, value)
+              end
+            end
+          end
+
+          def define_predicate(key, method_name)
+            define_method(method_name) do
+              if key? method_name
+                self.[](method_name, &proc)
+              else
+                !!self[key]
+              end
+            end
+          end
+
+          def define_initializing_reader(key, method_name)
+            define_method(method_name) do
+              if key? method_name
+                self.[](method_name, &proc)
+              else
+                initializing_reader(key)
+              end
+            end
+          end
+
+          def define_underbang_reader(key, method_name)
+            define_method(method_name) do
+              if key? method_name
+                self.[](key, &proc)
+              else
+                underbang_reader(key)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -15,7 +15,8 @@ module Hashie
       #   mash[:symbol_key] == mash['symbol_key']  #=> true
       module KeepOriginalKeys
         def self.included(descendant)
-          raise ArgumentError, "#{descendant} is not a kind of Hashie::Mash" unless descendant <= Hashie::Mash
+          error_message = "#{descendant} is not a kind of Hashie::Mash"
+          raise ArgumentError, error_message unless descendant <= Hashie::Mash
         end
 
         private

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

@@ -3,7 +3,9 @@ module Hashie
     module Mash
       module SafeAssignment
         def custom_writer(key, *args) #:nodoc:
-          raise ArgumentError, "The property #{key} clashes with an existing method." if !key?(key) && respond_to?(key, true)
+          if !key?(key) && respond_to?(key, true)
+            raise ArgumentError, "The property #{key} clashes with an existing method."
+          end
           super
         end
 

data/lib/hashie/extensions/method_access.rb

@@ -73,7 +73,9 @@ module Hashie
       end
 
       def method_missing(name, *args)
-        return self[convert_key(Regexp.last_match[1])] = args.first if args.size == 1 && name.to_s =~ /(.*)=$/
+        if args.size == 1 && name.to_s =~ /(.*)=$/
+          return self[convert_key(Regexp.last_match[1])] = args.first
+        end
 
         super
       end
@@ -231,7 +233,8 @@ module Hashie
     # underscores.
     module MethodAccessWithOverride
       def self.included(base)
-        [MethodReader, MethodOverridingWriter, MethodQuery, MethodOverridingInitializer].each do |mod|
+        [MethodReader, MethodOverridingWriter,
+         MethodQuery, MethodOverridingInitializer].each do |mod|
           base.send :include, mod
         end
       end

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

@@ -6,19 +6,24 @@ module Hashie
   module Extensions
     module Parsers
       class YamlErbParser
-        def initialize(file_path)
+        def initialize(file_path, options = {})
           @content = File.read(file_path)
           @file_path = file_path.is_a?(Pathname) ? file_path.to_s : file_path
+          @options = options
         end
 
         def perform
           template = ERB.new(@content)
           template.filename = @file_path
-          YAML.safe_load template.result
+          permitted_classes = @options.fetch(:permitted_classes) { [] }
+          permitted_symbols = @options.fetch(:permitted_symbols) { [] }
+          aliases = @options.fetch(:aliases) { true }
+          # TODO: Psych in newer rubies expects these args to be keyword args.
+          YAML.safe_load template.result, permitted_classes, permitted_symbols, aliases
         end
 
-        def self.perform(file_path)
-          new(file_path).perform
+        def self.perform(file_path, options = {})
+          new(file_path, options).perform
         end
       end
     end

data/lib/hashie/extensions/strict_key_access.rb

@@ -1,6 +1,7 @@
 module Hashie
   module Extensions
-    # SRP: This extension will fail an error whenever a key is accessed that does not exist in the hash.
+    # SRP: This extension will fail an error whenever a key is accessed
+    #   that does not exist in the hash.
     #
     #   EXAMPLE:
     #
@@ -15,12 +16,15 @@ module Hashie
     #     >> hash[:cow]
     #       KeyError: key not found: :cow
     #
-    # NOTE: For googlers coming from Python to Ruby, this extension makes a Hash behave more like a "Dictionary".
+    # NOTE: For googlers coming from Python to Ruby, this extension makes a Hash
+    # behave more like a "Dictionary".
     #
     module StrictKeyAccess
       class DefaultError < StandardError
-        def initialize(msg = 'Setting or using a default with Hashie::Extensions::StrictKeyAccess does not make sense', *args)
-          super
+        def initialize
+          super('Setting or using a default with Hashie::Extensions::StrictKeyAccess'\
+                ' does not make sense'
+          )
         end
       end
 

data/lib/hashie/hash.rb

@@ -18,20 +18,21 @@ module Hashie
     def to_hash(options = {})
       out = {}
       each_key do |k|
-        assignment_key = if options[:stringify_keys]
-                           k.to_s
-                         elsif options[:symbolize_keys]
-                           k.to_s.to_sym
-                         else
-                           k
-                         end
+        assignment_key =
+          if options[:stringify_keys]
+            k.to_s
+          elsif options[:symbolize_keys]
+            k.to_s.to_sym
+          else
+            k
+          end
         if self[k].is_a?(Array)
           out[assignment_key] ||= []
           self[k].each do |array_object|
-            out[assignment_key] << (array_object.is_a?(Hash) ? flexibly_convert_to_hash(array_object, options) : array_object)
+            out[assignment_key] << maybe_convert_to_hash(array_object, options)
           end
         else
-          out[assignment_key] = self[k].is_a?(Hash) || self[k].respond_to?(:to_hash) ? flexibly_convert_to_hash(self[k], options) : self[k]
+          out[assignment_key] = maybe_convert_to_hash(self[k], options)
         end
       end
       out
@@ -44,6 +45,12 @@ module Hashie
 
     private
 
+    def maybe_convert_to_hash(object, options)
+      return object unless object.is_a?(Hash) || object.respond_to?(:to_hash)
+
+      flexibly_convert_to_hash(object, options)
+    end
+
     def flexibly_convert_to_hash(object, options = {})
       if object.method(:to_hash).arity.zero?
         object.to_hash