hashie 3.4.2 → 3.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbee5492036900b505f6bf76d5133640e02b525b
-  data.tar.gz: 5a358bc6a11697e33e7d2c806d39b01d79cb3dba
+  metadata.gz: 6121c5c81c02643a5ac8bcf1633e09c0d18dd238
+  data.tar.gz: bfa9a6bed6dc2aef1f034297f30bc66ebe72b7ef
 SHA512:
-  metadata.gz: 660342313eec115f629d20bc0d68fa1f1ee6361860234dbf2a90f707fe92d2c609bb03533748d3fbb0ea8dbab4197f332281c2c70fdad87fb0a34485e0b2ae56
-  data.tar.gz: ee46052bf7249f60c4c23825f782f19b879582f8cb009a156644b3c89f7aba1a76a19f3f01f235b4915e00e5b773e2559a32bde349ae7d541d2bc0c6f19c4163
+  metadata.gz: cad338b78028860f36e964e2d531d793419e7ae533f2f33c452c60cd5e3df0a5e1f7838da102ed7b3b39f2be5c8ef3123bed779f477d970533b69d91ff6c27fd
+  data.tar.gz: 5bbb4adec507c10102832cca447f302ff5693e97131bc8d4c13f0e14038cff6605ceed36e77153d7bfa078aefe838513216ac64da945af464cb9a8213dbd5cd2

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 3.4.2 (10/25/2015)
+
+* [#314](https://github.com/intridea/hashie/pull/314): Added a `StrictKeyAccess` extension that will raise an error whenever a key is accessed that does not exist in the hash - [@pboling](https://github.com/pboling).
+* [#304](https://github.com/intridea/hashie/pull/304): Ensured compatibility of `Hash` extensions with singleton objects - [@regexident](https://github.com/regexident).
+* [#306](https://github.com/intridea/hashie/pull/306): Added `Hashie::Extensions::Dash::Coercion` - [@marshall-lee](https://github.com/marshall-lee).
+* [#310](https://github.com/intridea/hashie/pull/310): Fixed `Hashie::Extensions::SafeAssignment` bug with private methods - [@marshall-lee](https://github.com/marshall-lee).
+* [#313](https://github.com/intridea/hashie/pull/313): Restrict pending spec to only Ruby versions 2.2.0-2.2.2 - [@pboling](https://github.com/pboling).
+* [#315](https://github.com/intridea/hashie/pull/315): Default `bin/` scripts: `console` and `setup` - [@pboling](https://github.com/pboling).
+
 ## 3.4.2 (6/2/2015)
 
 * [#292](https://github.com/intridea/hashie/pull/292): Removed `Mash#id` and `Mash#type` - [@jrochkind](https://github.com/jrochkind).

data/README.md

@@ -18,9 +18,9 @@ Hashie is available as a RubyGem:
 $ gem install hashie
 ```
 
-## Upgrading
+## Stable Release
 
-You're reading the documentation for the stable release of Hashie, which is 3.4.2. Please read [UPGRADING](UPGRADING.md) when upgrading from a previous version.
+You're reading the documentation for the stable release [3.4.3](https://github.com/intridea/hashie/blob/v3.4.3/README.md).
 
 ## Hash Extensions
 
@@ -392,6 +392,25 @@ books.deep_locate -> (key, value, object) { key == :pages && value <= 120 }
 # => [{:title=>"Ruby for beginners", :pages=>120}, {:title=>"CSS for intermediates", :pages=>80}]
 ```
 
+## StrictKeyAccess
+
+This extension can be mixed in to allow a Hash to raise an error when attempting to extract a value using a non-existent key.
+
+### Example:
+
+```ruby
+class StrictKeyAccessHash < Hash
+  include Hashie::Extensions::StrictKeyAccess
+end
+
+>> hash = StrictKeyAccessHash[foo: "bar"]
+=> {:foo=>"bar"}
+>> hash[:foo]
+=> "bar"
+>> hash[:cow]
+  KeyError: key not found: :cow
+```
+
 ## Mash
 
 Mash is an extended Hash that gives simple pseudo-object functionality that can be built from hashes and easily extended. It is intended to give the user easier access to the objects within the Mash through a property-like syntax, while still retaining all Hash functionality.
@@ -607,6 +626,36 @@ model.created_at.class  #=> Time
 
 To enable compatibility with Rails 4 use the [hashie-forbidden_attributes](https://github.com/Maxim-Filimonov/hashie-forbidden_attributes) gem.
 
+### Dash Extension: Coercion.
+
+If you want to use `Hashie::Extensions::Coercion` together with `Dash` then
+you may probably want to use `Hashie::Extensions::Dash::Coercion` instead.
+This extension automatically includes `Hashie::Extensions::Coercion`
+and also adds a convenient `:coerce` option to `property` so you can define coercion in one line
+instead of using `property` and `coerce_key` separate:
+
+```ruby
+class UserHash < Hashie::Dash
+  include Hashie::Extensions::Coercion
+
+  property :id
+  property :posts
+
+  coerce_key :posts, Array[PostHash]
+end
+```
+
+This is the same as:
+
+```ruby
+class UserHash < Hashie::Dash
+  include Hashie::Extensions::Dash::Coercion
+
+  property :id
+  property :posts, coerce: Array[PostHash]
+end
+```
+
 ## Trash
 
 A Trash is a Dash that allows you to translate keys on initialization. It mixes

data/hashie.gemspec

@@ -18,4 +18,5 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec', '~> 3.0'
+  gem.add_development_dependency 'rspec-pending_for', '~> 0.1'
 end

data/lib/hashie.rb

@@ -26,6 +26,7 @@ module Hashie
     autoload :PrettyInspect,     'hashie/extensions/pretty_inspect'
     autoload :KeyConversion,     'hashie/extensions/key_conversion'
     autoload :MethodAccessWithOverride, 'hashie/extensions/method_access'
+    autoload :StrictKeyAccess, 'hashie/extensions/strict_key_access'
 
     module Parsers
       autoload :YamlErbParser, 'hashie/extensions/parsers/yaml_erb_parser'
@@ -34,6 +35,7 @@ module Hashie
     module Dash
       autoload :IndifferentAccess, 'hashie/extensions/dash/indifferent_access'
       autoload :PropertyTranslation, 'hashie/extensions/dash/property_translation'
+      autoload :Coercion, 'hashie/extensions/dash/coercion'
     end
 
     module Mash

data/lib/hashie/extensions/coercion.rb

@@ -29,51 +29,17 @@ module Hashie
         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) if value.nil? || into.nil?
-
-          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 = into.class[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) })
+          unless value.nil? || into.nil?
+            begin
+              value = self.class.fetch_coercion(into).call(value)
+            rescue NoMethodError, TypeError => e
+              raise CoercionError, "Cannot coerce property #{key.inspect} from #{value.class} to #{into}: #{e.message}"
             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)
-          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
-
         def custom_writer(key, value, _convert = true)
           self[key] = value
         end
@@ -175,6 +141,66 @@ module Hashie
           strict_value_coercions[from] || lenient_value_coercions[from]
         end
 
+        def fetch_coercion(type)
+          return type if type.is_a? Proc
+          coercion_cache[type]
+        end
+
+        def coercion_cache
+          @coercion_cache ||= ::Hash.new do |hash, type|
+            hash[type] = build_coercion(type)
+          end
+        end
+
+        def build_coercion(type)
+          if type.is_a? Enumerable
+            if type.class <= ::Hash
+              type, key_type, value_type = type.class, *type.first
+              build_hash_coercion(type, key_type, value_type)
+            else # Enumerable but not Hash: Array, Set
+              type, value_type = type.class, type.first
+              build_container_coercion(type, value_type)
+            end
+          elsif CORE_TYPES.key? type
+            build_core_type_coercion(type)
+          elsif type.respond_to? :coerce
+            lambda do |value|
+              return value if value.is_a? type
+              type.coerce(value)
+            end
+          elsif type.respond_to? :new
+            lambda do |value|
+              return value if value.is_a? type
+              type.new(value)
+            end
+          else
+            fail TypeError, "#{type} is not a coercable type"
+          end
+        end
+
+        def build_hash_coercion(type, key_type, value_type)
+          key_coerce = fetch_coercion(key_type)
+          value_coerce = fetch_coercion(value_type)
+          lambda do |value|
+            type[value.map { |k, v| [key_coerce.call(k), value_coerce.call(v)] }]
+          end
+        end
+
+        def build_container_coercion(type, value_type)
+          value_coerce = fetch_coercion(value_type)
+          lambda do |value|
+            type.new(value.map { |v| value_coerce.call(v) })
+          end
+        end
+
+        def build_core_type_coercion(type)
+          name = CORE_TYPES[type]
+          lambda do |value|
+            return value if value.is_a? type
+            return value.send(name)
+          end
+        end
+
         def inherited(klass)
           super
 

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

@@ -0,0 +1,25 @@
+module Hashie
+  module Extensions
+    module Dash
+      module Coercion
+        # Extends a Dash with the ability to define coercion for properties.
+
+        def self.included(base)
+          base.send :include, Hashie::Extensions::Coercion
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          # Defines a property on the Dash. Options are the standard
+          # <tt>Hashie::Dash#property</tt> options plus:
+          #
+          # * <tt>:coerce</tt> - The class into which you want the property coerced.
+          def property(property_name, options = {})
+            super
+            coerce_key property_name, options[:coerce] if options[:coerce]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -72,8 +72,6 @@ module Hashie
           def property(property_name, options = {})
             super
 
-            options[:from] = options[:from] if options[:from]
-
             if options[:from]
               if property_name == options[:from]
                 fail ArgumentError, "Property name (#{property_name}) and :from option must not be the same"

data/lib/hashie/extensions/deep_merge.rb

@@ -3,7 +3,9 @@ module Hashie
     module DeepMerge
       # Returns a new hash with +self+ and +other_hash+ merged recursively.
       def deep_merge(other_hash, &block)
-        dup.deep_merge!(other_hash, &block)
+        copy = dup
+        copy.extend(Hashie::Extensions::DeepMerge) unless copy.respond_to?(:deep_merge!)
+        copy.deep_merge!(other_hash, &block)
       end
 
       # Returns a new hash with +self+ and +other_hash+ merged recursively.

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

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

data/lib/hashie/extensions/strict_key_access.rb

@@ -0,0 +1,74 @@
+module Hashie
+  module Extensions
+    # SRP: This extension will fail an error whenever a key is accessed that does not exist in the hash.
+    #
+    #   EXAMPLE:
+    #
+    #     class StrictKeyAccessHash < Hash
+    #       include Hashie::Extensions::StrictKeyAccess
+    #     end
+    #
+    #     >> hash = StrictKeyAccessHash[foo: "bar"]
+    #     => {:foo=>"bar"}
+    #     >> hash[:foo]
+    #     => "bar"
+    #     >> 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".
+    #
+    module StrictKeyAccess
+      class DefaultError < StandardError
+        def initialize(msg = 'Setting or using a default with Hashie::Extensions::StrictKeyAccess does not make sense', *args)
+          super
+        end
+      end
+
+      # NOTE: Defaults don't make any sense with a StrictKeyAccess.
+      # NOTE: When key lookup fails a KeyError is raised.
+      #
+      # Normal:
+      #
+      #     >> a = Hash.new(123)
+      #     => {}
+      #     >> a["noes"]
+      #     => 123
+      #
+      # With StrictKeyAccess:
+      #
+      #     >> a = StrictKeyAccessHash.new(123)
+      #     => {}
+      #     >> a["noes"]
+      #       KeyError: key not found: "noes"
+      #
+      def [](key)
+        fetch(key)
+      end
+
+      def default(_ = nil)
+        fail DefaultError
+      end
+
+      def default=(_)
+        fail DefaultError
+      end
+
+      def default_proc
+        fail DefaultError
+      end
+
+      def default_proc=(_)
+        fail DefaultError
+      end
+
+      def key(value)
+        result = super
+        if result.nil? && (!key?(result) || self[result] != value)
+          fail KeyError, "key not found with value of #{value.inspect}"
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/hashie/extensions/stringify_keys.rb

@@ -15,7 +15,7 @@ module Hashie
       # Return a new hash with all keys converted
       # to strings.
       def stringify_keys
-        dup.stringify_keys!
+        StringifyKeys.stringify_keys(self)
       end
 
       module ClassMethods
@@ -25,7 +25,7 @@ module Hashie
         def stringify_keys_recursively!(object)
           case object
           when self.class
-            object.stringify_keys!
+            stringify_keys!(object)
           when ::Array
             object.each do |i|
               stringify_keys_recursively!(i)
@@ -43,6 +43,7 @@ module Hashie
         #   test.stringify_keys!
         #   test # => {'abc' => 'def'}
         def stringify_keys!(hash)
+          hash.extend(Hashie::Extensions::StringifyKeys) unless hash.respond_to?(:stringify_keys!)
           hash.keys.each do |k|
             stringify_keys_recursively!(hash[k])
             hash[k.to_s] = hash.delete(k)
@@ -54,8 +55,10 @@ module Hashie
         # to strings.
         # @param [::Hash] hash
         def stringify_keys(hash)
-          hash.dup.tap do | new_hash |
-            stringify_keys! new_hash
+          copy = hash.dup
+          copy.extend(Hashie::Extensions::StringifyKeys) unless copy.respond_to?(:stringify_keys!)
+          copy.tap do |new_hash|
+            stringify_keys!(new_hash)
           end
         end
       end

data/lib/hashie/extensions/symbolize_keys.rb

@@ -15,7 +15,7 @@ module Hashie
       # Return a new hash with all keys converted
       # to symbols.
       def symbolize_keys
-        dup.symbolize_keys!
+        SymbolizeKeys.symbolize_keys(self)
       end
 
       module ClassMethods
@@ -23,9 +23,9 @@ module Hashie
         # hashes and arrays.
         # @api private
         def symbolize_keys_recursively!(object)
-          object.symbolize_keys! if object.respond_to? :symbolize_keys!
-
           case object
+          when self.class
+            symbolize_keys!(object)
           when ::Array
             object.each do |i|
               symbolize_keys_recursively!(i)
@@ -43,6 +43,7 @@ module Hashie
         #   Hashie.symbolize_keys! test
         #   test # => {:abc => 'def'}
         def symbolize_keys!(hash)
+          hash.extend(Hashie::Extensions::SymbolizeKeys) unless hash.respond_to?(:symbolize_keys!)
           hash.keys.each do |k|
             symbolize_keys_recursively!(hash[k])
             hash[k.to_sym] = hash.delete(k)
@@ -54,8 +55,10 @@ module Hashie
         # to symbols.
         # @param [::Hash] hash
         def symbolize_keys(hash)
-          hash.dup.tap do | new_hash |
-            symbolize_keys! new_hash
+          copy = hash.dup
+          copy.extend(Hashie::Extensions::SymbolizeKeys) unless copy.respond_to?(:symbolize_keys!)
+          copy.tap do |new_hash|
+            symbolize_keys!(new_hash)
           end
         end
       end

data/lib/hashie/mash.rb

@@ -58,7 +58,6 @@ module Hashie
     include Hashie::Extensions::PrettyInspect
 
     ALLOWED_SUFFIXES = %w(? ! = _)
-    SUFFIXES_PARSER  = /(.*?)([#{ALLOWED_SUFFIXES.join}]?)$/
 
     def self.load(path, options = {})
       @_mashes ||= new
@@ -211,10 +210,9 @@ module Hashie
 
     def respond_to_missing?(method_name, *args)
       return true if key?(method_name)
-      _, suffix = method_suffix(method_name)
-      case suffix
-      when '=', '?', '!', '_'
-        return true
+      suffix = method_suffix(method_name)
+      if suffix
+        true
       else
         super
       end
@@ -227,15 +225,15 @@ module Hashie
 
     def method_missing(method_name, *args, &blk)
       return self.[](method_name, &blk) if key?(method_name)
-      name, suffix = method_suffix(method_name)
+      name, suffix = method_name_and_suffix(method_name)
       case suffix
-      when '='
+      when '='.freeze
         assign_property(name, args.first)
-      when '?'
+      when '?'.freeze
         !!self[name]
-      when '!'
+      when '!'.freeze
         initializing_reader(name)
-      when '_'
+      when '_'.freeze
         underbang_reader(name)
       else
         self[method_name]
@@ -254,9 +252,18 @@ module Hashie
 
     protected
 
+    def method_name_and_suffix(method_name)
+      method_name = method_name.to_s
+      if method_name.end_with?(*ALLOWED_SUFFIXES)
+        [method_name[0..-2], method_name[-1]]
+      else
+        [method_name[0..-1], nil]
+      end
+    end
+
     def method_suffix(method_name)
-      match = method_name.to_s.match(SUFFIXES_PARSER)
-      [match[1], match[2]]
+      method_name = method_name.to_s
+      method_name[-1] if method_name.end_with?(*ALLOWED_SUFFIXES)
     end
 
     def convert_key(key) #:nodoc:

data/lib/hashie/version.rb

@@ -1,3 +1,3 @@
 module Hashie
-  VERSION = '3.4.2'
+  VERSION = '3.4.3'
 end

data/spec/hashie/extensions/dash/coercion_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Hashie::Extensions::Dash::Coercion do
+  class DashWithCoercion < Hashie::Dash
+    include Hashie::Extensions::Dash::Coercion
+
+    property :type, coerce: Symbol
+  end
+
+  it 'does the coercion of properties' do
+    expect(DashWithCoercion.new(type: 'something')).to eq(type: :something)
+  end
+end

data/spec/hashie/extensions/deep_merge_spec.rb

@@ -42,4 +42,24 @@ describe Hashie::Extensions::DeepMerge do
       expect(h1).to eq expected_hash
     end
   end
+
+  context 'from extended object' do
+    subject { Hash }
+    let(:h1) { subject.new.merge(a: 100, c: { c1: 100 }).extend(Hashie::Extensions::DeepMerge) }
+    let(:h2) { { b: 250, c: { c1: 200 } } }
+    let(:expected_hash) { { a: 100, b: 250, c: { c1: 200 } } }
+
+    it 'does not raise error' do
+      expect { h1.deep_merge(h2) } .not_to raise_error
+    end
+
+    it 'deep merges two hashes' do
+      expect(h1.deep_merge(h2)).to eq expected_hash
+    end
+
+    it 'deep merges another hash in place via bang method' do
+      h1.deep_merge!(h2)
+      expect(h1).to eq expected_hash
+    end
+  end
 end

data/spec/hashie/extensions/mash/safe_assignment_spec.rb

@@ -3,17 +3,44 @@ require 'spec_helper'
 describe Hashie::Extensions::Mash::SafeAssignment do
   class MashWithSafeAssignment < Hashie::Mash
     include Hashie::Extensions::Mash::SafeAssignment
+
+    private
+
+    def my_own_private
+      :hello!
+    end
   end
 
   context 'when included in Mash' do
     subject { MashWithSafeAssignment.new }
 
+    context 'when not attempting to override a method' do
+      it 'assigns just fine' do
+        expect do
+          subject.blabla = 'Test'
+          subject.blabla = 'Test'
+        end.to_not raise_error
+      end
+    end
+
     context 'when attempting to override a method' do
       it 'raises an error' do
         expect { subject.zip = 'Test' }.to raise_error(ArgumentError)
       end
     end
 
+    context 'when attempting to override a private method' do
+      it 'raises an error' do
+        expect { subject.my_own_private = 'Test' }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when attempting to initialize with predefined method' do
+      it 'raises an error' do
+        expect { MashWithSafeAssignment.new(zip: true) }.to raise_error(ArgumentError)
+      end
+    end
+
     context 'when setting as a hash key' do
       it 'still raises if conflicts with a method' do
         expect { subject[:zip] = 'Test' }.to raise_error(ArgumentError)

data/spec/hashie/extensions/strict_key_access_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Hashie::Extensions::StrictKeyAccess do
+  class StrictKeyAccessHash < Hash
+    include Hashie::Extensions::StrictKeyAccess
+  end
+
+  shared_examples_for 'StrictKeyAccess with valid key' do |options = {}|
+    before { pending_for(options[:pending]) } if options[:pending]
+    context 'set' do
+      let(:new_value) { 42 }
+      it('returns value') do
+        expect(instance.send(:[]=, valid_key, new_value)).to eq new_value
+      end
+    end
+    context 'access' do
+      it('returns value') do
+        expect(instance[valid_key]).to eq valid_value
+      end
+    end
+    context 'lookup' do
+      it('returns key') do
+        expect(instance.key(valid_value)).to eq valid_key
+      end
+    end
+  end
+  shared_examples_for 'StrictKeyAccess with invalid key' do |options = {}|
+    before { pending_for(options[:pending]) } if options[:pending]
+    context 'access' do
+      it('raises an error') do
+        # Formatting of the error message varies on Rubinius and ruby-head
+        expect { instance[invalid_key] }.to raise_error KeyError
+      end
+    end
+    context 'lookup' do
+      it('raises an error') do
+        # Formatting of the error message does not vary here because raised by StrictKeyAccess
+        expect { instance.key(invalid_value) }.to raise_error KeyError,
+                                                              %(key not found with value of #{invalid_value.inspect})
+      end
+    end
+  end
+  shared_examples_for 'StrictKeyAccess raises KeyError instead of allowing defaults' do
+    context '#default' do
+      it 'raises an error' do
+        expect { instance.default(invalid_key) }.to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError,
+                                                                'Setting or using a default with Hashie::Extensions::StrictKeyAccess does not make sense'
+      end
+    end
+    context '#default=' do
+      it 'raises an error' do
+        expect { instance.default = invalid_key }.to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError,
+                                                                 'Setting or using a default with Hashie::Extensions::StrictKeyAccess does not make sense'
+      end
+    end
+    context '#default_proc' do
+      it 'raises an error' do
+        expect { instance.default_proc }.to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError,
+                                                        'Setting or using a default with Hashie::Extensions::StrictKeyAccess does not make sense'
+      end
+    end
+    context '#default_proc=' do
+      it 'raises an error' do
+        expect { instance.default_proc = proc {} }.to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError,
+                                                                  'Setting or using a default with Hashie::Extensions::StrictKeyAccess does not make sense'
+      end
+    end
+  end
+
+  let(:klass) { StrictKeyAccessHash }
+  let(:instance) { StrictKeyAccessHash.new(*initialization_args) }
+  let(:initialization_args) do
+    [
+      { valid_key => valid_value }
+    ]
+  end
+  let(:valid_key) { :abc }
+  let(:valid_value) { 'def' }
+  let(:invalid_key) { :mega }
+  let(:invalid_value) { 'death' }
+
+  context '.new' do
+    context 'no defaults at initialization' do
+      let(:initialization_args) { [] }
+      before do
+        instance.merge!(valid_key => valid_value)
+      end
+      it_behaves_like 'StrictKeyAccess with valid key'
+      it_behaves_like 'StrictKeyAccess with invalid key'
+      it_behaves_like 'StrictKeyAccess raises KeyError instead of allowing defaults'
+    end
+    context 'with defaults at initialization' do
+      before do
+        instance.merge!(valid_key => valid_value)
+      end
+      it_behaves_like 'StrictKeyAccess with valid key'
+      it_behaves_like 'StrictKeyAccess with invalid key'
+      it_behaves_like 'StrictKeyAccess raises KeyError instead of allowing defaults'
+    end
+    it_behaves_like 'StrictKeyAccess with invalid key'
+    it_behaves_like 'StrictKeyAccess raises KeyError instead of allowing defaults'
+  end
+
+  context '.[]' do
+    let(:instance) { StrictKeyAccessHash[*initialization_args] }
+    it_behaves_like 'StrictKeyAccess with valid key', pending: { engine: 'rbx' }
+    it_behaves_like 'StrictKeyAccess with invalid key', pending: { engine: 'rbx' }
+    it_behaves_like 'StrictKeyAccess raises KeyError instead of allowing defaults'
+  end
+end

data/spec/hashie/extensions/stringify_keys_spec.rb

@@ -80,6 +80,29 @@ describe Hashie::Extensions::StringifyKeys do
       include_examples 'stringify_keys!'
     end
   end
+
+  context 'singleton methods' do
+    subject { Hash }
+    let(:object) { subject.new.merge(a: 1, b: { c: 2 }).extend(Hashie::Extensions::StringifyKeys) }
+    let(:expected_hash) { { 'a' => 1, 'b' => { 'c' => 2 } } }
+
+    describe '.stringify_keys' do
+      it 'does not raise error' do
+        expect { object.stringify_keys } .not_to raise_error
+      end
+      it 'produces expected stringified hash' do
+        expect(object.stringify_keys).to eq(expected_hash)
+      end
+    end
+    describe '.stringify_keys!' do
+      it 'does not raise error' do
+        expect { object.stringify_keys! } .not_to raise_error
+      end
+      it 'produces expected stringified hash' do
+        expect(object.stringify_keys!).to eq(expected_hash)
+      end
+    end
+  end
 end
 
 describe Hashie do

data/spec/hashie/extensions/symbolize_keys_spec.rb

@@ -85,6 +85,29 @@ describe Hashie::Extensions::SymbolizeKeys do
       include_examples 'symbolize_keys!'
     end
   end
+
+  context 'singleton methods' do
+    subject { Hash }
+    let(:object) { subject.new.merge('a' => 1, 'b' => { 'c' => 2 }).extend(Hashie::Extensions::SymbolizeKeys) }
+    let(:expected_hash) { { a: 1, b: { c: 2 } } }
+
+    describe '.symbolize_keys' do
+      it 'does not raise error' do
+        expect { object.symbolize_keys }.not_to raise_error
+      end
+      it 'produces expected symbolized hash' do
+        expect(object.symbolize_keys).to eq(expected_hash)
+      end
+    end
+    describe '.symbolize_keys!' do
+      it 'does not raise error' do
+        expect { object.symbolize_keys! }.not_to raise_error
+      end
+      it 'produces expected symbolized hash' do
+        expect(object.symbolize_keys!).to eq(expected_hash)
+      end
+    end
+  end
 end
 
 describe Hashie do

data/spec/hashie/mash_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'delegate'
-require 'support/ruby_version'
 
 describe Hashie::Mash do
   subject { Hashie::Mash.new }
@@ -364,9 +363,7 @@ describe Hashie::Mash do
 
     it 'is able to access an unknown suffixed key as a method' do
       # See https://github.com/intridea/hashie/pull/285 for more information
-      if mri22?
-        pending 'Bug in MRI 2.2.x means this behavior is broken in those versions'
-      end
+      pending_for(engine: 'ruby', versions: %w(2.2.0 2.2.1 2.2.2))
 
       %w(= ? ! _).each do |suffix|
         expect(subject.method(:"xyz#{suffix}")).to_not be_nil

data/spec/spec_helper.rb

@@ -7,6 +7,7 @@ require 'pry'
 
 require 'rspec'
 require 'hashie'
+require 'rspec/pending_for'
 
 RSpec.configure do |config|
   config.expect_with :rspec do |expect|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hashie
 version: !ruby/object:Gem::Version
-  version: 3.4.2
+  version: 3.4.3
 platform: ruby
 authors:
 - Michael Bleigh
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-02 00:00:00.000000000 Z
+date: 2015-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -39,6 +39,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-pending_for
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 description: Hashie is a collection of classes and mixins that make hashes more powerful.
 email:
 - michael@intridea.com
@@ -59,6 +73,7 @@ files:
 - lib/hashie/clash.rb
 - lib/hashie/dash.rb
 - lib/hashie/extensions/coercion.rb
+- lib/hashie/extensions/dash/coercion.rb
 - lib/hashie/extensions/dash/indifferent_access.rb
 - lib/hashie/extensions/dash/property_translation.rb
 - lib/hashie/extensions/deep_fetch.rb
@@ -73,6 +88,7 @@ files:
 - lib/hashie/extensions/method_access.rb
 - lib/hashie/extensions/parsers/yaml_erb_parser.rb
 - lib/hashie/extensions/pretty_inspect.rb
+- lib/hashie/extensions/strict_key_access.rb
 - lib/hashie/extensions/stringify_keys.rb
 - lib/hashie/extensions/symbolize_keys.rb
 - lib/hashie/hash.rb
@@ -84,6 +100,7 @@ files:
 - spec/hashie/dash_spec.rb
 - spec/hashie/extensions/autoload_spec.rb
 - spec/hashie/extensions/coercion_spec.rb
+- spec/hashie/extensions/dash/coercion_spec.rb
 - spec/hashie/extensions/dash/indifferent_access_spec.rb
 - spec/hashie/extensions/deep_fetch_spec.rb
 - spec/hashie/extensions/deep_find_spec.rb
@@ -96,6 +113,7 @@ files:
 - spec/hashie/extensions/mash/safe_assignment_spec.rb
 - spec/hashie/extensions/merge_initializer_spec.rb
 - spec/hashie/extensions/method_access_spec.rb
+- spec/hashie/extensions/strict_key_access_spec.rb
 - spec/hashie/extensions/stringify_keys_spec.rb
 - spec/hashie/extensions/symbolize_keys_spec.rb
 - spec/hashie/hash_spec.rb
@@ -106,7 +124,6 @@ files:
 - spec/hashie/version_spec.rb
 - spec/spec_helper.rb
 - spec/support/module_context.rb
-- spec/support/ruby_version.rb
 homepage: https://github.com/intridea/hashie
 licenses:
 - MIT
@@ -127,35 +144,36 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Your friendly neighborhood hash library.
 test_files:
-- spec/spec_helper.rb
-- spec/support/ruby_version.rb
-- spec/support/module_context.rb
-- spec/hashie/parsers/yaml_erb_parser_spec.rb
-- spec/hashie/version_spec.rb
-- spec/hashie/rash_spec.rb
-- spec/hashie/dash_spec.rb
-- spec/hashie/hash_spec.rb
 - spec/hashie/clash_spec.rb
-- spec/hashie/mash_spec.rb
-- spec/hashie/trash_spec.rb
+- spec/hashie/dash_spec.rb
+- spec/hashie/extensions/autoload_spec.rb
+- spec/hashie/extensions/coercion_spec.rb
+- spec/hashie/extensions/dash/coercion_spec.rb
+- spec/hashie/extensions/dash/indifferent_access_spec.rb
 - spec/hashie/extensions/deep_fetch_spec.rb
-- spec/hashie/extensions/method_access_spec.rb
-- spec/hashie/extensions/key_conversion_spec.rb
+- spec/hashie/extensions/deep_find_spec.rb
 - spec/hashie/extensions/deep_locate_spec.rb
 - spec/hashie/extensions/deep_merge_spec.rb
-- spec/hashie/extensions/indifferent_access_with_rails_hwia_spec.rb
-- spec/hashie/extensions/symbolize_keys_spec.rb
-- spec/hashie/extensions/mash/safe_assignment_spec.rb
-- spec/hashie/extensions/deep_find_spec.rb
 - spec/hashie/extensions/ignore_undeclared_spec.rb
-- spec/hashie/extensions/autoload_spec.rb
-- spec/hashie/extensions/stringify_keys_spec.rb
 - spec/hashie/extensions/indifferent_access_spec.rb
-- spec/hashie/extensions/coercion_spec.rb
+- spec/hashie/extensions/indifferent_access_with_rails_hwia_spec.rb
+- spec/hashie/extensions/key_conversion_spec.rb
+- spec/hashie/extensions/mash/safe_assignment_spec.rb
 - spec/hashie/extensions/merge_initializer_spec.rb
-- spec/hashie/extensions/dash/indifferent_access_spec.rb
+- spec/hashie/extensions/method_access_spec.rb
+- spec/hashie/extensions/strict_key_access_spec.rb
+- spec/hashie/extensions/stringify_keys_spec.rb
+- spec/hashie/extensions/symbolize_keys_spec.rb
+- spec/hashie/hash_spec.rb
+- spec/hashie/mash_spec.rb
+- spec/hashie/parsers/yaml_erb_parser_spec.rb
+- spec/hashie/rash_spec.rb
+- spec/hashie/trash_spec.rb
+- spec/hashie/version_spec.rb
+- spec/spec_helper.rb
+- spec/support/module_context.rb

data/spec/support/ruby_version.rb

@@ -1,10 +0,0 @@
-def mri22?
-  ruby_version.start_with?('ruby_2.2')
-end
-
-def ruby_version
-  interpreter = Object.const_defined?(:RUBY_ENGINE) && RUBY_ENGINE
-  version = Object.const_defined?(:RUBY_VERSION) && RUBY_VERSION
-
-  "#{interpreter}_#{version}"
-end