hashie 2.1.2 → 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6033c13b11711b7a5951864fcec0108fc3f93acc
+  data.tar.gz: e8f54e062f1593b56cc1c0ecea1b7cb5d43dd218
+SHA512:
+  metadata.gz: a039149a6d895259bd07ab8a9761bc6d4414b69451c8b8cf4a334e2da448cfd336841d8a7fe481c2911503c4d448276a1d6005240ee0ac18b9b2db00fa0d09e9
+  data.tar.gz: 918c0b19e472b27f71776573e241738fe0d9bd6f1d700b891bd36a7496a5f5410f638b4c98be62f2ce9fa58835e363086ac4322df4de3afc90542e15c30c295b

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
+
 rvm:
   - ruby-head
   - 2.1.1
@@ -7,8 +8,8 @@ rvm:
   - 1.9.3
   - jruby-19mode
   - jruby-head
-  - rbx-2.1
-  - rbx-2.2
+  - rbx-2
+
 matrix:
   allow_failures:
     - rvm: ruby-head

data/CHANGELOG.md

@@ -1,6 +1,14 @@
-## 2.1.2 (5/12/2014)
+## 3.0 (6/3/2014)
 
-* [#169](https://github.com/intridea/hashie/pull/169): Hash#to_hash will also convert nested objects that implement `to_hash` - [@gregory](https://github.com/gregory).
+**Note:** This version introduces several backward incompatible API changes. See [UPGRADING](UPGRADING.md) for details.
+
+* [#150](https://github.com/intridea/hashie/pull/159): Handle nil intermediate object on deep fetch - [@stephenaument](https://github.com/stephenaument).
+* [#146](https://github.com/intridea/hashie/issues/146): Mash#respond_to? inconsistent with #method_missing and does not respond to #permitted? - [@dblock](https://github.com/dblock).
+* [#152](https://github.com/intridea/hashie/pull/152): Do not convert keys to String in Hashie::Dash and Hashie::Trash, use Hashie::Extensions::Dash::IndifferentAccess to achieve backward compatible behavior - [@dblock](https://github.com/dblock).
+* [#152](https://github.com/intridea/hashie/pull/152): Do not automatically stringify keys in Hashie::Hash#to_hash, pass `:stringify_keys` to achieve backward compatible behavior - [@dblock](https://github.com/dblock).
+* [#148](https://github.com/intridea/hashie/pull/148): Consolidated Hashie::Hash#stringify_keys implementation - [@dblock](https://github.com/dblock).
+* [#149](https://github.com/intridea/hashie/issues/149): Allow IgnoreUndeclared and DeepMerge to be used with undeclared properties - [@jhaesus](https://github.com/jhaesus).
+* Your contribution here.
 
 ## 2.1.1 (4/12/2014)
 
@@ -11,7 +19,7 @@
 * [#134](https://github.com/intridea/hashie/pull/134): Add deep_fetch extension for nested access - [@tylerdooling](https://github.com/tylerdooling).
 * Removed support for Ruby 1.8.7 - [@dblock](https://github.com/dblock).
 * Ruby style now enforced with Rubocop - [@dblock](https://github.com/dblock).
-* [#138](https://github.com/intridea/hashie/pull/138): Added Hashie::Rash, a hash whose keys can be regular expressions or ranges - [@epitron](https://github.com/epitron).
+* [#138](https://github.com/intridea/hashie/pull/138): Added Hashie#Rash, a hash whose keys can be regular expressions or ranges - [@epitron](https://github.com/epitron).
 * [#131](https://github.com/intridea/hashie/pull/131): Added IgnoreUndeclared, an extension to silently ignore undeclared properties at intialization - [@righi](https://github.com/righi).
 * [#136](https://github.com/intridea/hashie/issues/136): Removed Hashie::Extensions::Structure - [@markiz](https://github.com/markiz).
 * [#107](https://github.com/intridea/hashie/pull/107): Fixed excessive value conversions, poor performance of deep merge in Hashie::Mash - [@davemitchell](https://github.com/dblock), [@dblock](https://github.com/dblock).

data/Gemfile

@@ -8,4 +8,4 @@ end
 
 gemspec
 
-gem 'rubocop', '0.20.0'
+gem 'rubocop', '0.21.0'

data/README.md

@@ -1,7 +1,6 @@
-# Hashie [![Build Status](https://secure.travis-ci.org/intridea/hashie.png)](http://travis-ci.org/intridea/hashie) [![Dependency Status](https://gemnasium.com/intridea/hashie.png)](https://gemnasium.com/intridea/hashie)
+# Hashie [![Build Status](https://secure.travis-ci.org/intridea/hashie.png)](http://travis-ci.org/intridea/hashie) [![Dependency Status](https://gemnasium.com/intridea/hashie.png)](https://gemnasium.com/intridea/hashie) [![Code Climate](https://codeclimate.com/github/intridea/hashie.png)](https://codeclimate.com/github/intridea/hashie)
 
-Hashie is a growing collection of tools that extend Hashes and make
-them more useful.
+Hashie is a growing collection of tools that extend Hashes and make them more useful.
 
 ## Installation
 
@@ -11,22 +10,19 @@ Hashie is available as a RubyGem:
 $ gem install hashie
 ```
 
+## Upgrading
+
+You're reading the documentation for the stable release of Hashie, 3.0. Please read [UPGRADING](UPGRADING.md) when upgrading from a previous version.
+
 ## Hash Extensions
 
-The library is broken up into a number of atomically includeable Hash
-extension modules as described below. This provides maximum flexibility
-for users to mix and match functionality while maintaining feature parity
-with earlier versions of Hashie.
+The library is broken up into a number of atomically includeable Hash extension modules as described below. This provides maximum flexibility for users to mix and match functionality while maintaining feature parity with earlier versions of Hashie.
 
-Any of the extensions listed below can be mixed into a class by
-`include`-ing `Hashie::Extensions::ExtensionName`.
+Any of the extensions listed below can be mixed into a class by `include`-ing `Hashie::Extensions::ExtensionName`.
 
 ### Coercion
 
-Coercions allow you to set up "coercion rules" based either on the key
-or the value type to massage data as it's being inserted into the Hash.
-Key coercions might be used, for example, in lightweight data modeling
-applications such as an API client:
+Coercions allow you to set up "coercion rules" based either on the key or the value type to massage data as it's being inserted into the Hash. Key coercions might be used, for example, in lightweight data modeling applications such as an API client:
 
 ```ruby
 class Tweet < Hash
@@ -40,9 +36,7 @@ Tweet.new(user: user_hash)
 #    User.new(user_hash) if that isn't present.
 ```
 
-Value coercions, on the other hand, will coerce values based on the type
-of the value being inserted. This is useful if you are trying to build a
-Hash-like class that is self-propagating.
+Value coercions, on the other hand, will coerce values based on the type of the value being inserted. This is useful if you are trying to build a Hash-like class that is self-propagating.
 
 ```ruby
 class SpecialHash < Hash
@@ -60,22 +54,15 @@ end
 
 ### KeyConversion
 
-The KeyConversion extension gives you the convenience methods of
-`symbolize_keys` and `stringify_keys` along with their bang
-counterparts. You can also include just stringify or just symbolize with
-`Hashie::Extensions::StringifyKeys` or `Hashie::Extensions::SymbolizeKeys`.
+The KeyConversion extension gives you the convenience methods of `symbolize_keys` and `stringify_keys` along with their bang counterparts. You can also include just stringify or just symbolize with `Hashie::Extensions::StringifyKeys` or `Hashie::Extensions::SymbolizeKeys`.
 
 ### MergeInitializer
 
-The MergeInitializer extension simply makes it possible to initialize a
-Hash subclass with another Hash, giving you a quick short-hand.
+The MergeInitializer extension simply makes it possible to initialize a Hash subclass with another Hash, giving you a quick short-hand.
 
 ### MethodAccess
 
-The MethodAccess extension allows you to quickly build method-based
-reading, writing, and querying into your Hash descendant. It can also be
-included as individual modules, i.e. `Hashie::Extensions::MethodReader`,
-`Hashie::Extensions::MethodWriter` and `Hashie::Extensions::MethodQuery`
+The MethodAccess extension allows you to quickly build method-based reading, writing, and querying into your Hash descendant. It can also be included as individual modules, i.e. `Hashie::Extensions::MethodReader`, `Hashie::Extensions::MethodWriter` and `Hashie::Extensions::MethodQuery`.
 
 ```ruby
 class MyHash < Hash
@@ -90,22 +77,15 @@ h.abc? # => true
 
 ### IndifferentAccess
 
-This extension can be mixed in to instantly give you indifferent access
-to your Hash subclass. This works just like the params hash in Rails and
-other frameworks where whether you provide symbols or strings to access
-keys, you will get the same results.
+This extension can be mixed in to instantly give you indifferent access to your Hash subclass. This works just like the params hash in Rails and other frameworks where whether you provide symbols or strings to access keys, you will get the same results.
+
+A unique feature of Hashie's IndifferentAccess mixin is that it will inject itself recursively into subhashes *without* reinitializing the hash in question. This means you can safely merge together indifferent and non-indifferent hashes arbitrarily deeply without worrying about whether you'll be able to `hash[:other][:another]` properly.
 
-A unique feature of Hashie's IndifferentAccess mixin is that it will
-inject itself recursively into subhashes *without* reinitializing the
-hash in question. This means you can safely merge together indifferent
-and non-indifferent hashes arbitrarily deeply without worrying about
-whether you'll be able to `hash[:other][:another]` properly.
+Use `Hashie::Extensions::Dash::IndifferentAccess` for instances of `Hashie::Dash`.
 
 ### IgnoreUndeclared
 
-This extension can be mixed in to silently ignore undeclared properties on
-initialization instead of raising an error. This is useful when using a
-Trash to capture a subset of a larger hash.
+This extension can be mixed in to silently ignore undeclared properties on initialization instead of raising an error. This is useful when using a Trash to capture a subset of a larger hash.
 
 ```ruby
 class Person < Trash
@@ -143,19 +123,15 @@ h2 = MyHash.new
 h1 = { x: { y: [4,5,6] }, z: [7,8,9] }
 h2 = { x: { y: [7,8,9] }, z: "xyz" }
 
-h1.deep_merge(h2) #=> { x: { y: [7, 8, 9] }, z: "xyz" }
-h2.deep_merge(h1) #=> { x: { y: [4, 5, 6] }, z: [7, 8, 9] }
+h1.deep_merge(h2) # => { x: { y: [7, 8, 9] }, z: "xyz" }
+h2.deep_merge(h1) # => { x: { y: [4, 5, 6] }, z: [7, 8, 9] }
 ```
 
 ### DeepFetch
 
-This extension can be mixed in to provide for safe and concise retrieval of
-deeply nested hash values. In the event that the requested key does not exist
-a block can be provided and its value will be returned.
+This extension can be mixed in to provide for safe and concise retrieval of deeply nested hash values. In the event that the requested key does not exist a block can be provided and its value will be returned.
 
-Though this is a hash extension, it conveniently allows for arrays to be
-present in the nested structure. This feature makes the extension particularly
-useful for working with JSON API responses.
+Though this is a hash extension, it conveniently allows for arrays to be present in the nested structure. This feature makes the extension particularly useful for working with JSON API responses.
 
 ```ruby
 user = {
@@ -165,24 +141,22 @@ user = {
     { name: 'Open source enthusiasts' }
   ]
 }
+
 user.extend Hashie::Extensions::DeepFetch
 
-user.deep_fetch :name, :first #=> 'Bob'
-user.deep_fetch :name, :middle #=> 'KeyError: Could not fetch middle'
+user.deep_fetch :name, :first # => 'Bob'
+user.deep_fetch :name, :middle # => 'KeyError: Could not fetch middle'
 
 # using a default block
-user.deep_fetch :name, :middle { |key| 'default' }  #=>  'default'
+user.deep_fetch :name, :middle { |key| 'default' }  # =>  'default'
 
 # a nested array
-user.deep_fetch :groups, 1, :name #=> 'Open source enthusiasts'
+user.deep_fetch :groups, 1, :name # => 'Open source enthusiasts'
 ```
 
 ## Mash
 
-Mash is an extended Hash that gives simple pseudo-object functionality
-that can be built from hashes and easily extended. It is designed to
-be used in RESTful API libraries to provide easy object-like access
-to JSON and XML parsed hashes.
+Mash is an extended Hash that gives simple pseudo-object functionality that can be built from hashes and easily extended. It is designed to be used in RESTful API libraries to provide easy object-like access to JSON and XML parsed hashes.
 
 ### Example:
 
@@ -195,27 +169,22 @@ mash.name # => "My Mash"
 mash.name? # => true
 mash.inspect # => <Hashie::Mash name="My Mash">
 
-mash = Mash.new
+mash = Hashie::Mash.new
 # use bang methods for multi-level assignment
 mash.author!.name = "Michael Bleigh"
 mash.author # => <Hashie::Mash name="Michael Bleigh">
 
-mash = Mash.new
+mash = Hashie::Mash.new
 # use under-bang methods for multi-level testing
 mash.author_.name? # => false
 mash.inspect # => <Hashie::Mash>
 ```
 
-**Note:** The `?` method will return false if a key has been set
-to false or nil. In order to check if a key has been set at all, use the
-`mash.key?('some_key')` method instead.
+**Note:** The `?` method will return false if a key has been set to false or nil. In order to check if a key has been set at all, use the `mash.key?('some_key')` method instead.
 
 ## Dash
 
-Dash is an extended Hash that has a discrete set of defined properties
-and only those properties may be set on the hash. Additionally, you
-can set defaults for each property. You can also flag a property as
-required. Required properties will raise an exception if unset.
+Dash is an extended Hash that has a discrete set of defined properties and only those properties may be set on the hash. Additionally, you can set defaults for each property. You can also flag a property as required. Required properties will raise an exception if unset.
 
 ### Example:
 
@@ -238,10 +207,40 @@ p[:awesome]    # => NoMethodError
 p[:occupation] # => 'Rubyist'
 ```
 
+Properties defined as symbols are not the same thing as properties defined as strings.
+
+### Example:
+
+```ruby
+class Tricky < Hashie::Dash
+  property :trick
+  property 'trick'
+end
+
+p = Tricky.new(trick: 'one', 'trick' => 'two')
+p.trick # => 'one', always symbol version
+p[:trick] # => 'one'
+p['trick'] # => 'two'
+```
+
+Note that accessing a property as a method always uses the symbol version.
+
+```ruby
+class Tricky < Hashie::Dash
+  property 'trick'
+end
+
+p = Tricky.new('trick' => 'two')
+p.trick # => NoMethodError
+```
+
+### Mash and Rails 4 Strong Parameters
+
+To enable compatibility with Rails 4 use the [hashie_rails](http://rubygems.org/gems/hashie_rails) gem.
+
 ## Trash
 
-A Trash is a Dash that allows you to translate keys on initialization.
-It is used like so:
+A Trash is a Dash that allows you to translate keys on initialization. It is used like so:
 
 ```ruby
 class Person < Hashie::Trash
@@ -256,8 +255,7 @@ when it is initialized using a hash such as through:
 Person.new(firstName: 'Bob')
 ```
 
-Trash also supports translations using lambda, this could be useful when dealing with
-external API's. You can use it in this way:
+Trash also supports translations using lambda, this could be useful when dealing with external API's. You can use it in this way:
 
 ```ruby
 class Result < Hashie::Trash
@@ -276,13 +274,9 @@ result.created_at.class # => Time
 
 ## Clash
 
-Clash is a Chainable Lazy Hash that allows you to easily construct
-complex hashes using method notation chaining. This will allow you
-to use a more action-oriented approach to building options hashes.
+Clash is a Chainable Lazy Hash that allows you to easily construct complex hashes using method notation chaining. This will allow you to use a more action-oriented approach to building options hashes.
 
-Essentially, a Clash is a generalized way to provide much of the same
-kind of "chainability" that libraries like Arel or Rails 2.x's named_scopes
-provide.
+Essentially, a Clash is a generalized way to provide much of the same kind of "chainability" that libraries like Arel or Rails 2.x's named_scopes provide.
 
 ### Example:
 
@@ -317,22 +311,21 @@ If the Rash's value is a `proc`, the `proc` will be automatically called with th
 
 # Mapping names to appropriate greetings
 greeting = Hashie::Rash.new( /^Mr./ => "Hello sir!", /^Mrs./ => "Evening, madame." )
-greeting["Mr. Steve Austin"] #=> "Hello sir!"
-greeting["Mrs. Steve Austin"] #=> "Evening, madame."
+greeting["Mr. Steve Austin"] # => "Hello sir!"
+greeting["Mrs. Steve Austin"] # => "Evening, madame."
 
 # Mapping statements to saucy retorts
 mapper = Hashie::Rash.new(
   /I like (.+)/ => proc { |m| "Who DOESN'T like #{m[1]}?!" },
   /Get off my (.+)!/ => proc { |m| "Forget your #{m[1]}, old man!" }
 )
-mapper["I like traffic lights"] #=> "Who DOESN'T like traffic lights?!"
-mapper["Get off my lawn!"]      #=> "Forget your lawn, old man!"
+mapper["I like traffic lights"] # => "Who DOESN'T like traffic lights?!"
+mapper["Get off my lawn!"]      # => "Forget your lawn, old man!"
 ```
 
 ### Auto-optimized
 
-**Note:** The Rash is automatically optimized every 500 accesses
-(which means that it sorts the list of Regexps, putting the most frequently matched ones at the beginning).
+**Note:** The Rash is automatically optimized every 500 accesses (which means that it sorts the list of Regexps, putting the most frequently matched ones at the beginning).
 
 If this value is too low or too high for your needs, you can tune it by setting: `rash.optimize_every = n`.
 

data/UPGRADING.md

@@ -0,0 +1,93 @@
+Upgrading Hashie
+================
+
+### Upgrading to 3.0
+
+#### Compatibility with Rails 4 Strong Parameters
+
+Version 2.1 introduced support to prevent default Rails 4 mass-assignment protection behavior. This was [issue #89](https://github.com/intridea/hashie/issues/89), resolved in [#104](https://github.com/intridea/hashie/pull/104). In version 2.2 this behavior has been removed in [#147](https://github.com/intridea/hashie/pull/147) in favor of a mixin and finally extracted into a separate gem in Hashie 3.0.
+
+To enable 2.1 compatible behavior with Rails 4, use the [hashie_rails](http://rubygems.org/gems/hashie_rails) gem.
+
+```
+gem 'hashie_rails'
+```
+
+See [#154](https://github.com/intridea/hashie/pull/154) and [Mash and Rails 4 Strong Parameters](README.md#mash-and-rails-4-strong-parameters) for more details.
+
+#### Key Conversions in Hashie::Dash and Hashie::Trash
+
+Version 2.1 and older of Hashie::Dash and Hashie::Trash converted keys to strings by default. This is no longer the case in 2.2.
+
+Consider the following code.
+
+```ruby
+class Person < Hashie::Dash
+  property :name
+end
+
+p = Person.new(name: 'dB.')
+```
+
+Version 2.1 behaves as follows.
+
+```ruby
+p.name # => 'dB.'
+p[:name] # => 'dB.'
+p['name'] # => 'dB.'
+
+# not what I put in
+p.inspect # => { 'name' => 'dB.' }
+p.to_hash # => { 'name' => 'dB.' }
+```
+
+It was not possible to achieve the behavior of preserving keys, as described in [issue #151](https://github.com/intridea/hashie/issues/151).
+
+Version 2.2 does not perform this conversion by default.
+
+```ruby
+p.name # => 'dB.'
+p[:name] # => 'dB.'
+# p['name'] # => NoMethodError
+
+p.inspect # => { :name => 'dB.' }
+p.to_hash # => { :name => 'dB.' }
+```
+
+To enable behavior compatible with older versions, use `Hashie::Extensions::Dash::IndifferentAccess`.
+
+```ruby
+class Person < Hashie::Dash
+  include Hashie::Extensions::Dash::IndifferentAccess
+  property :name
+end
+```
+
+#### Key Conversions in Hashie::Hash#to_hash
+
+Version 2.1 or older of Hash#to_hash converted keys to strings automatically.
+
+```ruby
+instance = Hashie::Hash[first: 'First', 'last' => 'Last']
+instance.to_hash # => { "first" => 'First', "last" => 'Last' }
+```
+
+It was possible to symbolize keys by passing `:symbolize_keys`, however it was not possible to retrieve the hash with initial key values.
+
+```ruby
+instance.to_hash(symbolize_keys: true) # => { :first => 'First', :last => 'Last' }
+instance.to_hash(stringify_keys: true) # => { "first" => 'First', "last" => 'Last' }
+```
+
+Version 2.2 no longer converts keys by default.
+
+```ruby
+instance = Hashie::Hash[first: 'First', 'last' => 'Last']
+instance.to_hash # => { :first => 'First', "last" => 'Last' }
+```
+
+The behavior with `symbolize_keys` and `stringify_keys` is unchanged.
+
+See [#152](https://github.com/intridea/hashie/pull/152) for more information.
+
+

data/hashie.gemspec

@@ -1,20 +1,20 @@
 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 collection of classes and mixins that make hashes more powerful.}
-  gem.summary       = %q{Your friendly neighborhood hash library.}
+  gem.authors       = ['Michael Bleigh', 'Jerry Cheung']
+  gem.email         = ['michael@intridea.com', 'jollyjerry@gmail.com']
+  gem.description   = 'Hashie is a collection of classes and mixins that make hashes more powerful.'
+  gem.summary       = '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) }
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  gem.name          = "hashie"
+  gem.name          = 'hashie'
   gem.require_paths = ['lib']
   gem.version       = Hashie::VERSION
-  gem.license       = "MIT"
+  gem.license       = 'MIT'
 
   gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rspec', '~> 3.0'
 end