hashie 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6033c13b11711b7a5951864fcec0108fc3f93acc
-  data.tar.gz: e8f54e062f1593b56cc1c0ecea1b7cb5d43dd218
+  metadata.gz: f8151e8630508db39e56ae5ac2b5333913573f3f
+  data.tar.gz: de13b700b22ff856acabc7be36581e32f50ea43e
 SHA512:
-  metadata.gz: a039149a6d895259bd07ab8a9761bc6d4414b69451c8b8cf4a334e2da448cfd336841d8a7fe481c2911503c4d448276a1d6005240ee0ac18b9b2db00fa0d09e9
-  data.tar.gz: 918c0b19e472b27f71776573e241738fe0d9bd6f1d700b891bd36a7496a5f5410f638b4c98be62f2ce9fa58835e363086ac4322df4de3afc90542e15c30c295b
+  metadata.gz: 4a2ea8a3fd07a80a75bbb4a687258c0ae92f3a85fdef18178bc9319fc0bc122a1c2b7d7f47fdfd6ba378d3459165642cdf8610e491d7e6438254a289434ed75f
+  data.tar.gz: cf309ea2aec15071033875bcdeb4885f2a4755a0611856acdb44c4d92c07b2b8a739d5e81c42ba163014a0485788f7597ca055ae86f913105e6efea3f90b8519

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 3.1 (7/25/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).
+* [#171](https://github.com/intridea/hashie/pull/171): Include Trash and Dash class name when raising `NoMethodError` - [@gregory](https://github.com/gregory).
+* [#172](https://github.com/intridea/hashie/pull/172): Added Dash and Trash#update_attributes! - [@gregory](https://github.com/gregory).
+* [#173](https://github.com/intridea/hashie/pull/173): Auto include Dash::IndifferentAccess when IndiferentAccess is included in Dash - [@gregory](https://github.com/gregory).
+* [#174](https://github.com/intridea/hashie/pull/174): Fixed `from` and `transform_with` Trash features when IndifferentAccess is included - [@gregory](https://github.com/gregory).
+
 ## 3.0 (6/3/2014)
 
 **Note:** This version introduces several backward incompatible API changes. See [UPGRADING](UPGRADING.md) for details.
@@ -8,10 +16,8 @@
 * [#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)
-
 * [#144](https://github.com/intridea/hashie/issues/144): Fixed regression invoking `to_hash` with no parameters - [@mbleigh](https://github.com/mbleigh).
 
 ## 2.1.0 (4/6/2014)

data/README.md

@@ -12,7 +12,7 @@ $ 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.
+You're reading the documentation for the stable release of Hashie, 3.1. Please read [UPGRADING](UPGRADING.md) when upgrading from a previous version.
 
 ## Hash Extensions
 
@@ -81,8 +81,6 @@ This extension can be mixed in to instantly give you indifferent access to your
 
 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.
@@ -205,6 +203,11 @@ p.occupation   # => 'Rubyist'
 p.email        # => 'abc@def.com'
 p[:awesome]    # => NoMethodError
 p[:occupation] # => 'Rubyist'
+p.update_attributes!(name: 'Trudy', occupation: 'Evil')
+p.occupation   # => 'Evil'
+p.name         # => 'Trudy'
+p.update_attributes!(occupation: nil)
+p.occupation   # => 'Rubyist'
 ```
 
 Properties defined as symbols are not the same thing as properties defined as strings.

data/lib/hashie/dash.rb

@@ -91,7 +91,7 @@ module Hashie
       end
 
       initialize_attributes(attributes)
-      assert_required_properties_set!
+      assert_required_attributes_set!
     end
 
     alias_method :_regular_reader, :[]
@@ -142,6 +142,19 @@ module Hashie
       self
     end
 
+    def update_attributes!(attributes)
+      initialize_attributes(attributes)
+
+      self.class.defaults.each_pair do |prop, value|
+        self[prop] = begin
+          value.dup
+        rescue TypeError
+          value
+        end if self[prop].nil?
+      end
+      assert_required_attributes_set!
+    end
+
     private
 
     def initialize_attributes(attributes)
@@ -151,27 +164,29 @@ module Hashie
     end
 
     def assert_property_exists!(property)
-      unless self.class.property?(property)
-        fail NoMethodError, "The property '#{property}' is not defined for this Dash."
-      end
+      fail_no_property_error!(property) unless self.class.property?(property)
     end
 
-    def assert_required_properties_set!
+    def assert_required_attributes_set!
       self.class.required_properties.each do |required_property|
         assert_property_set!(required_property)
       end
     end
 
     def assert_property_set!(property)
-      if send(property).nil?
-        fail ArgumentError, "The property '#{property}' is required for this Dash."
-      end
+      fail_property_required_error!(property) if send(property).nil?
     end
 
     def assert_property_required!(property, value)
-      if self.class.required?(property) && value.nil?
-        fail ArgumentError, "The property '#{property}' is required for this Dash."
-      end
+      fail_property_required_error!(property) if self.class.required?(property) && value.nil?
+    end
+
+    def fail_property_required_error!(property)
+      fail ArgumentError, "The property '#{property}' is required for #{self.class.name}."
+    end
+
+    def fail_no_property_error!(property)
+      fail NoMethodError, "The property '#{property}' is not defined for #{self.class.name}."
     end
   end
 end

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

@@ -14,6 +14,21 @@ module Hashie
             name = name.to_s
             !!properties.find { |property| property.to_s == name }
           end
+
+          def translation_exists?(name)
+            name = name.to_s
+            !!translations.keys.find { |key| key.to_s == name }
+          end
+
+          def transformed_property(property_name, value)
+            transform = transforms[property_name] || transforms[:"#{property_name}"]
+            transform.call(value)
+          end
+
+          def transformation_exists?(name)
+            name = name.to_s
+            !!transforms.keys.find { |key| key.to_s == name }
+          end
         end
       end
     end

data/lib/hashie/extensions/indifferent_access.rb

@@ -24,6 +24,10 @@ 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
+
         base.class_eval do
           alias_method :regular_writer, :[]=
           alias_method :[]=, :indifferent_writer

data/lib/hashie/hash.rb

@@ -31,7 +31,7 @@ module Hashie
             out[assignment_key] << (Hash === array_object ? flexibly_convert_to_hash(array_object, options) : array_object)
           end
         else
-          out[assignment_key] = Hash === self[k] ? flexibly_convert_to_hash(self[k], options) : self[k]
+          out[assignment_key] = (Hash === self[k] || self[k].respond_to?(:to_hash)) ? flexibly_convert_to_hash(self[k], options) : self[k]
         end
       end
       out

data/lib/hashie/trash.rb

@@ -42,15 +42,27 @@ module Hashie
     # Set a value on the Dash in a Hash-like way. Only works
     # on pre-existing properties.
     def []=(property, value)
-      if self.class.translations.key? property
+      if self.class.translation_exists? property
         send("#{property}=", value)
-      elsif self.class.transforms.key? property
-        super property, self.class.transforms[property].call(value)
+      elsif self.class.transformation_exists? property
+        super property, self.class.transformed_property(property, value)
       elsif property_exists? property
         super
       end
     end
 
+    def self.transformed_property(property_name, value)
+      transforms[property_name].call(value)
+    end
+
+    def self.translation_exists?(name)
+      translations.key? name
+    end
+
+    def self.transformation_exists?(name)
+      transforms.key? name
+    end
+
     def self.permitted_input_keys
       @permitted_input_keys ||= properties.map { |property| inverse_translations.fetch property, property }
     end
@@ -76,9 +88,7 @@ module Hashie
     # Raises an NoMethodError if the property doesn't exist
     #
     def property_exists?(property)
-      unless self.class.property?(property)
-        fail NoMethodError, "The property '#{property}' is not defined for this Trash."
-      end
+      fail_no_property_error!(property) unless self.class.property?(property)
       true
     end
 

data/lib/hashie/version.rb

@@ -1,3 +1,3 @@
 module Hashie
-  VERSION = '3.0.0'
+  VERSION = '3.1.0'
 end

data/spec/hashie/dash_spec.rb

@@ -18,6 +18,14 @@ class DashNoRequiredTest < Hashie::Dash
   property :count, default: 0
 end
 
+class DashWithCoercion < Hashie::Dash
+  include Hashie::Extensions::Coercion
+  property :person
+  property :city
+
+  coerce_key :person, ::DashNoRequiredTest
+end
+
 class PropertyBangTest < Hashie::Dash
   property :important!
 end
@@ -35,6 +43,14 @@ class DeferredTest < Hashie::Dash
 end
 
 describe DashTest do
+  def property_required_error(property)
+    [ArgumentError, "The property '#{property}' is required for #{subject.class.name}."]
+  end
+
+  def no_property_error(property)
+    [NoMethodError, "The property '#{property}' is not defined for #{subject.class.name}."]
+  end
+
   subject { DashTest.new(first_name: 'Bob', email: 'bob@example.com') }
 
   it('subclasses Hashie::Hash') { should respond_to(:to_mash) }
@@ -60,30 +76,30 @@ describe DashTest do
   it { should_not respond_to(:nonexistent) }
 
   it 'errors out for a non-existent property' do
-    expect { subject['nonexistent'] }.to raise_error(NoMethodError)
+    expect { subject['nonexistent'] }.to raise_error(*no_property_error('nonexistent'))
   end
 
   it 'errors out when attempting to set a required property to nil' do
-    expect { subject.first_name = nil }.to raise_error(ArgumentError)
+    expect { subject.first_name = nil }.to raise_error(*property_required_error('first_name'))
   end
 
   context 'writing to properties' do
     it 'fails writing a required property to nil' do
-      expect { subject.first_name = nil }.to raise_error(ArgumentError)
+      expect { subject.first_name = nil }.to raise_error(*property_required_error('first_name'))
     end
 
     it 'fails writing a required property to nil using []=' do
-      expect { subject[:first_name] = nil }.to raise_error(ArgumentError)
+      expect { subject[:first_name] = nil }.to raise_error(*property_required_error('first_name'))
     end
 
     it 'fails writing to a non-existent property using []=' do
-      expect { subject['nonexistent'] = 123 }.to raise_error(NoMethodError)
+      expect { subject['nonexistent'] = 123 }.to raise_error(*no_property_error('nonexistent'))
     end
 
     it 'works for an existing property using []=' do
       subject[:first_name] = 'Bob'
       expect(subject[:first_name]).to eq 'Bob'
-      expect { subject['first_name'] }.to raise_error(NoMethodError)
+      expect { subject['first_name'] }.to raise_error(*no_property_error('first_name'))
     end
 
     it 'works for an existing property using a method call' do
@@ -94,7 +110,7 @@ describe DashTest do
 
   context 'reading from properties' do
     it 'fails reading from a non-existent property using []' do
-      expect { subject['nonexistent'] }.to raise_error(NoMethodError)
+      expect { subject['nonexistent'] }.to raise_error(*no_property_error('nonexistent'))
     end
 
     it 'is able to retrieve properties through blocks' do
@@ -125,7 +141,7 @@ describe DashTest do
 
   describe '#new' do
     it 'fails with non-existent properties' do
-      expect { described_class.new(bork: '') }.to raise_error(NoMethodError)
+      expect { described_class.new(bork: '') }.to raise_error(*no_property_error('bork'))
     end
 
     it 'sets properties that it is able to' do
@@ -144,7 +160,7 @@ describe DashTest do
     end
 
     it 'fails when required values are missing' do
-      expect { DashTest.new }.to raise_error(ArgumentError)
+      expect { DashTest.new }.to raise_error(*property_required_error('first_name'))
     end
 
     it 'does not overwrite default values' do
@@ -168,11 +184,11 @@ describe DashTest do
     end
 
     it 'fails with non-existent properties' do
-      expect { subject.merge(middle_name: 'James') }.to raise_error(NoMethodError)
+      expect { subject.merge(middle_name: 'James') }.to raise_error(*no_property_error('middle_name'))
     end
 
     it 'errors out when attempting to set a required property to nil' do
-      expect { subject.merge(first_name: nil) }.to raise_error(ArgumentError)
+      expect { subject.merge(first_name: nil) }.to raise_error(*property_required_error('first_name'))
     end
 
     context 'given a block' do
@@ -266,6 +282,49 @@ describe DashTest do
       end
     end
   end
+
+  describe '#update_attributes!(params)' do
+    let(:params) { { first_name: 'Alice', email: 'alice@example.com' } }
+
+    context 'when there is coercion' do
+      let(:params_before) { { city: 'nyc', person: { first_name: 'Bob', email: 'bob@example.com' } } }
+      let(:params_after) { { city: 'sfo', person: { first_name: 'Alice', email: 'alice@example.com' } } }
+
+      subject { DashWithCoercion.new(params_before) }
+
+      it 'update the attributes' do
+        expect(subject.person.first_name).to eq params_before[:person][:first_name]
+        subject.update_attributes!(params_after)
+        expect(subject.person.first_name).to eq params_after[:person][:first_name]
+      end
+    end
+
+    it 'update the attributes' do
+      subject.update_attributes!(params)
+      expect(subject.first_name).to eq params[:first_name]
+      expect(subject.email).to eq params[:email]
+      expect(subject.count).to eq subject.class.defaults[:count]
+    end
+
+    context 'when required property is update to nil' do
+      let(:params) { { first_name: nil, email: 'alice@example.com' } }
+
+      it 'raise an ArgumentError' do
+        expect { subject.update_attributes!(params) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when a default property is update to nil' do
+      let(:params) { { count: nil, email: 'alice@example.com' } }
+
+      it 'set the property back to the default value' do
+        subject.update_attributes!(params)
+        expect(subject.email).to eq params[:email]
+        expect(subject.count).to eq subject.class.defaults[:count]
+      end
+    end
+  end
+
 end
 
 describe Hashie::Dash, 'inheritance' do

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

@@ -1,11 +1,37 @@
 require 'spec_helper'
 
 describe Hashie::Extensions::Dash::IndifferentAccess do
+  class TrashWithIndifferentAccess < Hashie::Trash
+    include Hashie::Extensions::Dash::IndifferentAccess
+    property :per_page, transform_with: lambda { |v| v.to_i }
+    property :total, from: :total_pages
+  end
+
   class DashWithIndifferentAccess < Hashie::Dash
     include Hashie::Extensions::Dash::IndifferentAccess
     property :name
   end
 
+  context 'when included in Trash' do
+    let(:params) { { per_page: '1', total_pages: 2 } }
+    subject { TrashWithIndifferentAccess.new(params) }
+
+    it 'gets the expected behaviour' do
+      expect(subject.per_page).to eq params[:per_page].to_i
+      expect(subject.total).to eq params[:total_pages]
+    end
+  end
+
+  context 'when included in Dash' do
+    let(:patch) { Hashie::Extensions::Dash::IndifferentAccess::ClassMethods }
+    let(:dash_class) { Class.new(Hashie::Dash) }
+
+    it 'extends with the patch once' do
+      expect(patch).to receive(:extended).with(dash_class).once
+      dash_class.send(:include, Hashie::Extensions::Dash::IndifferentAccess)
+    end
+  end
+
   context 'initialized with' do
     it 'string' do
       instance = DashWithIndifferentAccess.new('name' => 'Name')

data/spec/hashie/extensions/indifferent_access_spec.rb

@@ -26,6 +26,20 @@ describe Hashie::Extensions::IndifferentAccess do
     end
   end
 
+  class IndifferentHashWithDash < Hashie::Dash
+    include Hashie::Extensions::IndifferentAccess
+    property :foo
+  end
+
+  describe 'when included in dash' do
+    let(:params) { { foo: 'bar' } }
+    subject { IndifferentHashWithDash.new(params) }
+
+    it 'initialize with a symbol' do
+      expect(subject.foo).to eq params[:foo]
+    end
+  end
+
   shared_examples_for 'hash with indifferent access' do
     it 'is able to access via string or symbol' do
       h = subject.build(abc: 123)

data/spec/hashie/hash_spec.rb

@@ -55,4 +55,30 @@ describe Hash do
     h[:key] = BareCustomMash.new
     expect { h.to_hash }.not_to raise_error
   end
+
+  describe 'when the value is an object that respond_to to_hash' do
+    class ClassRespondsToHash
+      def to_hash(options = {})
+        Hashie::Hash['a' => 'hey', b: 'bar', 123 => 'bob', 'array' => [1, 2, 3]].to_hash(options)
+      end
+    end
+
+    it '#to_hash returns a hash with same keys' do
+      hash = Hashie::Hash['a' => 'hey', 123 => 'bob', 'array' => [1, 2, 3], subhash: ClassRespondsToHash.new]
+      stringified_hash = hash.to_hash
+      expect(stringified_hash).to eq('a' => 'hey', 123 => 'bob', 'array' => [1, 2, 3], subhash: { 'a' => 'hey', b: 'bar', 123 => 'bob', 'array' => [1, 2, 3] })
+    end
+
+    it '#to_hash with stringify_keys set to true returns a hash with stringified_keys' do
+      hash = Hashie::Hash['a' => 'hey', 123 => 'bob', 'array' => [1, 2, 3], subhash: ClassRespondsToHash.new]
+      symbolized_hash = hash.to_hash(stringify_keys: true)
+      expect(symbolized_hash).to eq('a' => 'hey', '123' => 'bob', 'array' => [1, 2, 3], 'subhash' => { 'a' => 'hey', 'b' => 'bar', '123' => 'bob', 'array' => [1, 2, 3] })
+    end
+
+    it '#to_hash with symbolize_keys set to true returns a hash with symbolized keys' do
+      hash = Hashie::Hash['a' => 'hey', 123 => 'bob', 'array' => [1, 2, 3], subhash: ClassRespondsToHash.new]
+      symbolized_hash = hash.to_hash(symbolize_keys: true)
+      expect(symbolized_hash).to eq(:a => 'hey', :"123" => 'bob', :array => [1, 2, 3], subhash: { :a => 'hey', :b => 'bar', :'123' => 'bob', :array => [1, 2, 3] })
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hashie
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Michael Bleigh
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-03 00:00:00.000000000 Z
+date: 2014-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake