hashie 2.1.2 → 4.1.0

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

@@ -0,0 +1,61 @@
+module Hashie
+  module Extensions
+    module Mash
+      # Allow a Mash to properly respond to everything
+      #
+      # By default, Mashes only say they respond to methods for keys that exist
+      # in their key set or any of the affix methods (e.g. setter, underbang,
+      # etc.). This causes issues when you try to use them within a
+      # SimpleDelegator or bind to a method for a key that is unset.
+      #
+      # This extension allows a Mash to properly respond to `respond_to?` and
+      # `method` for keys that have not yet been set. This enables full
+      # compatibility with SimpleDelegator and thunk-oriented programming.
+      #
+      # There is a trade-off with this extension: it will run slower than a
+      # regular Mash; insertions and initializations with keys run approximately
+      # 20% slower and cost approximately 19KB of memory per class that you
+      # make permissive.
+      #
+      # @api public
+      # @example Make a new, permissively responding Mash subclass
+      #   class PermissiveMash < Hashie::Mash
+      #     include Hashie::Extensions::Mash::PermissiveRespondTo
+      #   end
+      #
+      #   mash = PermissiveMash.new(a: 1)
+      #   mash.respond_to? :b  #=> true
+      module PermissiveRespondTo
+        # The Ruby hook for behavior when including the module
+        #
+        # @api private
+        # @private
+        # @return void
+        def self.included(base)
+          base.instance_variable_set :@_method_cache, base.instance_methods
+          base.define_singleton_method(:method_cache) { @_method_cache }
+        end
+
+        # The Ruby hook for determining what messages a class might respond to
+        #
+        # @api private
+        # @private
+        def respond_to_missing?(_method_name, _include_private = false)
+          true
+        end
+
+        private
+
+        # Override the Mash logging behavior to account for permissiveness
+        #
+        # @api private
+        # @private
+        def log_collision?(method_key)
+          self.class.method_cache.include?(method_key) &&
+            !self.class.disable_warnings?(method_key) &&
+            !(regular_key?(method_key) || regular_key?(method_key.to_s))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Hashie
+  module Extensions
+    module Mash
+      module SafeAssignment
+        def custom_writer(key, *args) #:nodoc:
+          if !key?(key) && respond_to?(key, true)
+            raise ArgumentError, "The property #{key} clashes with an existing method."
+          end
+          super
+        end
+
+        def []=(*args)
+          custom_writer(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Hashie
+  module Extensions
+    module Mash
+      # Overrides Mash's default behavior of converting keys to strings
+      #
+      # @example
+      #   class LazyResponse < Hashie::Mash
+      #     include Hashie::Extensions::Mash::SymbolizedKeys
+      #   end
+      #
+      #   response = LazyResponse.new("id" => 123, "name" => "Rey").to_h
+      #   #=> {id: 123, name: "Rey"}
+      #
+      # @api public
+      module SymbolizeKeys
+        # Hook for being included in a class
+        #
+        # @api private
+        # @return [void]
+        # @raise [ArgumentError] when the base class isn't a Mash
+        def self.included(base)
+          raise ArgumentError, "#{base} must descent from Hashie::Mash" unless base <= Hashie::Mash
+        end
+
+        private
+
+        # Converts a key to a symbol
+        #
+        # @api private
+        # @param [String, Symbol] key the key to convert to a symbol
+        # @return [void]
+        def convert_key(key)
+          key.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/method_access.rb

@@ -27,15 +27,25 @@ module Hashie
     #
     #   user.not_declared # => NoMethodError
     module MethodReader
-      def respond_to?(name, include_private = false)
+      def respond_to_missing?(name, include_private = false)
         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)
-        super
+        if key?(name)
+          self[name]
+        else
+          sname = name.to_s
+          if key?(sname)
+            self[sname]
+          elsif sname[-1] == '?'
+            kname = sname[0..-2]
+            key?(kname) || key?(kname.to_sym)
+          else
+            super
+          end
+        end
       end
     end
 
@@ -57,7 +67,7 @@ module Hashie
     #   h['awesome'] # => 'sauce'
     #
     module MethodWriter
-      def respond_to?(name, include_private = false)
+      def respond_to_missing?(name, include_private = false)
         return true if name.to_s =~ /=$/
         super
       end
@@ -96,17 +106,42 @@ module Hashie
     #   h.def? # => false
     #   h.hji? # => NoMethodError
     module MethodQuery
-      def respond_to?(name, include_private = false)
-        return true if name.to_s =~ /(.*)\?$/ && (key?(Regexp.last_match[1]) || key?(Regexp.last_match[1].to_sym))
-        super
+      def respond_to_missing?(name, include_private = false)
+        if query_method?(name) && indifferent_key?(key_from_query_method(name))
+          true
+        else
+          super
+        end
       end
 
       def method_missing(name, *args)
-        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]
+        return super unless args.empty?
+
+        if query_method?(name)
+          key = key_from_query_method(name)
+          if indifferent_key?(key)
+            !!(self[key] || self[key.to_sym])
+          else
+            super
+          end
+        else
+          super
         end
+      end
 
-        super
+      private
+
+      def indifferent_key?(name)
+        name = name.to_s
+        key?(name) || key?(name.to_sym)
+      end
+
+      def key_from_query_method(query_method)
+        query_method.to_s[0..-2]
+      end
+
+      def query_method?(name)
+        name.to_s.end_with?('?')
       end
     end
 
@@ -120,5 +155,113 @@ module Hashie
         end
       end
     end
+
+    # A module shared between MethodOverridingWriter and MethodOverridingInitializer
+    # to contained shared logic. This module aids in redefining existing hash methods.
+    module RedefineMethod
+      protected
+
+      def method?(name)
+        methods.map(&: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
+
+    # 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
+      include RedefineMethod
+
+      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
+    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, MethodOverridingInitializer].each do |mod|
+          base.send :include, mod
+        end
+      end
+    end
+
+    # MethodOverridingInitializer allows you to override default hash
+    # methods when passing in values from an existing hash. The overriden
+    # methods are aliased with two leading underscores.
+    #
+    # @example
+    #   class MyHash < Hash
+    #     include Hashie::Extensions::MethodOverridingInitializer
+    #   end
+    #
+    #   h = MyHash.new(zip: 'a-dee-doo-dah')
+    #   h.zip # => 'a-dee-doo-dah'
+    #   h.__zip # => [[['zip', 'a-dee-doo-dah']]]
+    module MethodOverridingInitializer
+      include RedefineMethod
+
+      def initialize(hash = {})
+        hash.each do |key, value|
+          skey = key.to_s
+          redefine_method(skey) if method?(skey)
+          self[skey] = value
+        end
+      end
+    end
   end
 end

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

@@ -0,0 +1,48 @@
+require 'yaml'
+require 'erb'
+require 'pathname'
+
+module Hashie
+  module Extensions
+    module Parsers
+      class YamlErbParser
+        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
+          permitted_classes = @options.fetch(:permitted_classes) { [] }
+          permitted_symbols = @options.fetch(:permitted_symbols) { [] }
+          aliases = @options.fetch(:aliases) { true }
+
+          yaml_safe_load(template, permitted_classes, permitted_symbols, aliases)
+        end
+
+        def self.perform(file_path, options = {})
+          new(file_path, options).perform
+        end
+
+        private
+
+        if Gem::Version.new(Psych::VERSION) >= Gem::Version.new('3.1.0') # Ruby 2.6+
+          def yaml_safe_load(template, permitted_classes, permitted_symbols, aliases)
+            YAML.safe_load(
+              template.result,
+              permitted_classes: permitted_classes,
+              permitted_symbols: permitted_symbols,
+              aliases: aliases
+            )
+          end
+        else
+          def yaml_safe_load(template, permitted_classes, permitted_symbols, aliases)
+            YAML.safe_load(template.result, permitted_classes, permitted_symbols, aliases)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/pretty_inspect.rb

@@ -0,0 +1,19 @@
+module Hashie
+  module Extensions
+    module PrettyInspect
+      def self.included(base)
+        base.send :alias_method, :hash_inspect, :inspect
+        base.send :alias_method, :inspect, :hashie_inspect
+      end
+
+      def hashie_inspect
+        ret = "#<#{self.class}"
+        keys.sort_by(&:to_s).each do |key|
+          ret << " #{key}=#{self[key].inspect}"
+        end
+        ret << '>'
+        ret
+      end
+    end
+  end
+end

data/lib/hashie/extensions/ruby_version.rb

@@ -0,0 +1,60 @@
+# Copyright (c) Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# Portions copyright (c) Engine Yard and Andre Arko
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# 'Software'), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+module Hashie
+  module Extensions
+    class RubyVersion
+      include Comparable
+
+      attr_accessor :segments
+
+      def initialize(version)
+        @segments = split_to_segments(version)
+      end
+
+      def <=>(other)
+        lhsegments = segments
+        rhsegments = other.segments
+
+        lhsize = lhsegments.size
+        rhsize = rhsegments.size
+        limit  = (lhsize > rhsize ? lhsize : rhsize) - 1
+
+        i = 0
+
+        while i <= limit
+          lhs = lhsegments[i] || 0
+          rhs = rhsegments[i] || 0
+          i += 1
+
+          next      if lhs == rhs
+          return -1 if lhs.is_a?(String) && rhs.is_a?(Numeric)
+          return  1 if lhs.is_a?(Numeric) && rhs.is_a?(String)
+
+          return lhs <=> rhs
+        end
+
+        0
+      end
+
+      private
+
+      def split_to_segments(version)
+        version.scan(/[0-9]+|[a-z]+/i).map do |segment|
+          /^\d+$/ =~ segment ? segment.to_i : segment
+        end.freeze
+      end
+    end
+  end
+end