hashie 2.1.2 → 3.0.0

data/lib/hashie/rash.rb

@@ -111,7 +111,7 @@ module Hashie
 
     def optimize_if_necessary!
       if (@lookups += 1) >= @optimize_every
-        @regexes = @regex_counts.sort_by { |regex, count| -count }.map { |regex, count| regex }
+        @regexes = @regex_counts.sort_by { |_, count| -count }.map { |regex, _| regex }
         @lookups = 0
       end
     end

data/lib/hashie/trash.rb

@@ -19,23 +19,22 @@ module Hashie
     def self.property(property_name, options = {})
       super
 
-      options[:from] = options[:from].to_sym if options[:from]
-      property_name = property_name.to_sym
+      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"
         end
 
-        translations[options[:from].to_sym] = property_name.to_sym
+        translations[options[:from]] = property_name
 
         define_method "#{options[:from]}=" do |val|
           with = options[:with] || options[:transform_with]
-          self[property_name.to_sym] = with.respond_to?(:call) ? with.call(val) : val
+          self[property_name] = with.respond_to?(:call) ? with.call(val) : val
         end
       else
         if options[:transform_with].respond_to? :call
-          transforms[property_name.to_sym] = options[:transform_with]
+          transforms[property_name] = options[:transform_with]
         end
       end
     end
@@ -43,10 +42,10 @@ 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.to_sym
+      if self.class.translations.key? property
         send("#{property}=", value)
-      elsif self.class.transforms.key? property.to_sym
-        super property, self.class.transforms[property.to_sym].call(value)
+      elsif self.class.transforms.key? property
+        super property, self.class.transforms[property].call(value)
       elsif property_exists? property
         super
       end
@@ -77,7 +76,7 @@ module Hashie
     # Raises an NoMethodError if the property doesn't exist
     #
     def property_exists?(property)
-      unless self.class.property?(property.to_sym)
+      unless self.class.property?(property)
         fail NoMethodError, "The property '#{property}' is not defined for this Trash."
       end
       true
@@ -89,7 +88,7 @@ module Hashie
     def initialize_attributes(attributes)
       return unless attributes
       attributes_copy = attributes.dup.delete_if do |k, v|
-        if self.class.translations.include?(k.to_sym)
+        if self.class.translations.include?(k)
           self[k] = v
           true
         end

data/lib/hashie/version.rb

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

data/spec/hashie/dash_spec.rb

@@ -22,7 +22,7 @@ class PropertyBangTest < Hashie::Dash
   property :important!
 end
 
-class Subclassed < DashTest
+class SubclassedTest < DashTest
   property :last_name, required: true
 end
 
@@ -35,7 +35,6 @@ class DeferredTest < Hashie::Dash
 end
 
 describe DashTest do
-
   subject { DashTest.new(first_name: 'Bob', email: 'bob@example.com') }
 
   it('subclasses Hashie::Hash') { should respond_to(:to_mash) }
@@ -74,7 +73,7 @@ describe DashTest do
     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(ArgumentError)
     end
 
     it 'fails writing to a non-existent property using []=' do
@@ -82,9 +81,9 @@ describe DashTest do
     end
 
     it 'works for an existing property using []=' do
-      subject['first_name'] = 'Bob'
-      expect(subject['first_name']).to eq 'Bob'
+      subject[:first_name] = 'Bob'
       expect(subject[:first_name]).to eq 'Bob'
+      expect { subject['first_name'] }.to raise_error(NoMethodError)
     end
 
     it 'works for an existing property using a method call' do
@@ -99,14 +98,14 @@ describe DashTest do
     end
 
     it 'is able to retrieve properties through blocks' do
-      subject['first_name'] = 'Aiden'
+      subject[:first_name] = 'Aiden'
       value = nil
-      subject.[]('first_name') { |v| value = v }
+      subject.[](:first_name) { |v| value = v }
       expect(value).to eq 'Aiden'
     end
 
     it 'is able to retrieve properties through blocks with method calls' do
-      subject['first_name'] = 'Frodo'
+      subject[:first_name] = 'Frodo'
       value = nil
       subject.first_name { |v| value = v }
       expect(value).to eq 'Frodo'
@@ -115,12 +114,12 @@ describe DashTest do
 
   context 'reading from deferred properties' do
     it 'evaluates proc after initial read' do
-      expect(DeferredTest.new['created_at']).to be_instance_of(Time)
+      expect(DeferredTest.new[:created_at]).to be_instance_of(Time)
     end
 
     it 'does not evalute proc after subsequent reads' do
       deferred = DeferredTest.new
-      expect(deferred['created_at'].object_id).to eq deferred['created_at'].object_id
+      expect(deferred[:created_at].object_id).to eq deferred[:created_at].object_id
     end
   end
 
@@ -139,7 +138,7 @@ describe DashTest do
     end
 
     it 'accepts block to define a global default' do
-      obj = described_class.new { |hash, key| key.to_s.upcase }
+      obj = described_class.new { |_, key| key.to_s.upcase }
       expect(obj.first_name).to eq 'FIRST_NAME'
       expect(obj.count).to be_zero
     end
@@ -220,17 +219,17 @@ describe DashTest do
     end
 
     it 'checks if a property exists' do
-      expect(described_class.property?('first_name')).to be true
-      expect(described_class.property?(:first_name)).to be true
+      expect(described_class.property?(:first_name)).to be_truthy
+      expect(described_class.property?('first_name')).to be_falsy
     end
 
     it 'checks if a property is required' do
-      expect(described_class.required?('first_name')).to be true
-      expect(described_class.required?(:first_name)).to be true
+      expect(described_class.required?(:first_name)).to be_truthy
+      expect(described_class.required?('first_name')).to be_falsy
     end
 
     it 'doesnt include property from subclass' do
-      expect(described_class.property?(:last_name)).to be false
+      expect(described_class.property?(:last_name)).to be_falsy
     end
 
     it 'lists declared defaults' do
@@ -238,7 +237,7 @@ describe DashTest do
     end
 
     it 'allows properties that end in bang' do
-      expect(PropertyBangTest.property?(:important!)).to be true
+      expect(PropertyBangTest.property?(:important!)).to be_truthy
     end
   end
 
@@ -246,7 +245,7 @@ describe DashTest do
     before { subject.replace(first_name: 'Cain') }
 
     it 'return self' do
-      expect(subject.replace(email: 'bar').to_hash).to eq('email' => 'bar', 'count' => 0)
+      expect(subject.replace(email: 'bar').to_hash).to eq(email: 'bar', count: 0)
     end
 
     it 'sets all specified keys to their corresponding values' do
@@ -254,7 +253,7 @@ describe DashTest do
     end
 
     it 'leaves only specified keys and keys with default values' do
-      expect(subject.keys.sort).to eq %w(count first_name)
+      expect(subject.keys.sort_by { |key| key.to_s }).to eq [:count, :first_name]
       expect(subject.email).to be_nil
       expect(subject.count).to eq 0
     end
@@ -310,13 +309,14 @@ describe Hashie::Dash, 'inheritance' do
 
   it 'allows nil defaults' do
     @bottom.property :echo, default: nil
-    expect(@bottom.new).to have_key('echo')
+    expect(@bottom.new).to have_key(:echo)
+    expect(@bottom.new).to_not have_key('echo')
   end
 
 end
 
-describe Subclassed do
-  subject { Subclassed.new(first_name: 'Bob', last_name: 'McNob', email: 'bob@example.com') }
+describe SubclassedTest do
+  subject { SubclassedTest.new(first_name: 'Bob', last_name: 'McNob', email: 'bob@example.com') }
 
   describe '#count' do
     subject { super().count }
@@ -329,10 +329,55 @@ describe Subclassed do
   it { should respond_to(:last_name=) }
 
   it 'has one additional property' do
-    expect(described_class.property?(:last_name)).to be true
+    expect(described_class.property?(:last_name)).to be_truthy
   end
 
   it "didn't override superclass inheritance logic" do
-    expect(described_class.instance_variable_get('@inheritance_test')).to be true
+    expect(described_class.instance_variable_get('@inheritance_test')).to be_truthy
+  end
+end
+
+class MixedPropertiesTest < Hashie::Dash
+  property :symbol
+  property 'string'
+end
+
+describe MixedPropertiesTest do
+  subject { MixedPropertiesTest.new('string' => 'string', symbol: 'symbol') }
+
+  it { should respond_to('string') }
+  it { should respond_to(:symbol) }
+
+  it 'property?' do
+    expect(described_class.property?('string')).to be_truthy
+    expect(described_class.property?(:symbol)).to be_truthy
+  end
+
+  it 'fetch' do
+    expect(subject['string']).to eq('string')
+    expect { subject[:string] }.to raise_error(NoMethodError)
+    expect(subject[:symbol]).to eq('symbol')
+    expect { subject['symbol'] }.to raise_error(NoMethodError)
+  end
+
+  it 'double define' do
+    klass = Class.new(MixedPropertiesTest) do
+      property 'symbol'
+    end
+    instance = klass.new(symbol: 'one', 'symbol' => 'two')
+    expect(instance[:symbol]).to eq('one')
+    expect(instance['symbol']).to eq('two')
+  end
+
+  it 'assign' do
+    subject['string'] = 'updated'
+    expect(subject['string']).to eq('updated')
+
+    expect { subject[:string] = 'updated' }.to raise_error(NoMethodError)
+
+    subject[:symbol] = 'updated'
+    expect(subject[:symbol]).to eq('updated')
+
+    expect { subject['symbol'] = 'updated' }.to raise_error(NoMethodError)
   end
 end

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

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Hashie::Extensions::Dash::IndifferentAccess do
+  class DashWithIndifferentAccess < Hashie::Dash
+    include Hashie::Extensions::Dash::IndifferentAccess
+    property :name
+  end
+
+  context 'initialized with' do
+    it 'string' do
+      instance = DashWithIndifferentAccess.new('name' => 'Name')
+      expect(instance.name).to eq('Name')
+      expect(instance['name']).to eq('Name')
+      expect(instance[:name]).to eq('Name')
+      expect(instance.inspect).to eq('#<DashWithIndifferentAccess name="Name">')
+      expect(instance.to_hash).to eq('name' => 'Name')
+    end
+
+    it 'key' do
+      instance = DashWithIndifferentAccess.new(name: 'Name')
+      expect(instance.name).to eq('Name')
+      expect(instance['name']).to eq('Name')
+      expect(instance[:name]).to eq('Name')
+      expect(instance.inspect).to eq('#<DashWithIndifferentAccess name="Name">')
+      expect(instance.to_hash).to eq('name' => 'Name')
+    end
+  end
+
+  it 'updates' do
+    instance = DashWithIndifferentAccess.new
+    instance['name'] = 'Updated String'
+    expect(instance.name).to eq('Updated String')
+    instance[:name] = 'Updated Symbol'
+    expect(instance.name).to eq('Updated Symbol')
+    instance.name = 'Updated Method'
+    expect(instance.name).to eq('Updated Method')
+  end
+
+  context 'initialized with both prefers last assignment' do
+    it 'string, then symbol' do
+      instance = DashWithIndifferentAccess.new('name' => 'First', name: 'Last')
+      expect(instance.name).to eq('Last')
+      expect(instance['name']).to eq('Last')
+      expect(instance[:name]).to eq('Last')
+      expect(instance.inspect).to eq('#<DashWithIndifferentAccess name="Last">')
+      expect(instance.to_hash).to eq('name' => 'Last')
+    end
+
+    it 'symbol then string' do
+      instance = DashWithIndifferentAccess.new(name: 'Last', 'name' => 'First')
+      expect(instance.name).to eq('First')
+      expect(instance['name']).to eq('First')
+      expect(instance[:name]).to eq('First')
+      expect(instance.inspect).to eq('#<DashWithIndifferentAccess name="First">')
+      expect(instance.to_hash).to eq('name' => 'First')
+    end
+  end
+end

data/spec/hashie/extensions/deep_fetch_spec.rb

@@ -11,6 +11,7 @@ module Hashie
               { title: 'Call of the Wild' },
               { title: 'Moby Dick' }
             ],
+            shelves: nil,
             location: {
               address: '123 Library St.'
             }
@@ -62,6 +63,32 @@ module Hashie
                 )
               end
             end
+
+            context 'when the nested object is missing' do
+              it 'raises an UndefinedPathError' do
+                expect do
+                  instance.deep_fetch(:library, :unknown_key, :books)
+                end.to(
+                  raise_error(
+                    DeepFetch::UndefinedPathError,
+                    'Could not fetch path (library > unknown_key > books) at unknown_key'
+                  )
+                )
+              end
+            end
+
+            context 'when the nested object is nil' do
+              it 'raises an UndefinedPathError' do
+                expect do
+                  instance.deep_fetch(:library, :shelves, :address)
+                end.to(
+                  raise_error(
+                    DeepFetch::UndefinedPathError,
+                    'Could not fetch path (library > shelves > address) at address'
+                  )
+                )
+              end
+            end
           end
         end
       end

data/spec/hashie/extensions/ignore_undeclared_spec.rb

@@ -1,23 +1,46 @@
 require 'spec_helper'
 
 describe Hashie::Extensions::IgnoreUndeclared do
-  class ForgivingTrash < Hashie::Trash
-    include Hashie::Extensions::IgnoreUndeclared
-    property :city
-    property :state, from: :provence
-  end
+  context 'included in Trash' do
+    class ForgivingTrash < Hashie::Trash
+      include Hashie::Extensions::IgnoreUndeclared
+      property :city
+      property :state, from: :provence
+    end
 
-  subject { ForgivingTrash }
+    subject { ForgivingTrash }
 
-  it 'silently ignores undeclared properties on initialization' do
-    expect { subject.new(city: 'Toronto', provence: 'ON', country: 'Canada') }.to_not raise_error
-  end
+    it 'silently ignores undeclared properties on initialization' do
+      expect { subject.new(city: 'Toronto', provence: 'ON', country: 'Canada') }.to_not raise_error
+    end
+
+    it 'works with translated properties (with symbol keys)' do
+      expect(subject.new(provence: 'Ontario').state).to eq('Ontario')
+    end
 
-  it 'works with translated properties (with symbol keys)' do
-    expect(subject.new(provence: 'Ontario').state).to eq('Ontario')
+    it 'works with translated properties (with string keys)' do
+      expect(subject.new(provence: 'Ontario').state).to eq('Ontario')
+    end
+
+    it 'requires properties to be declared on assignment' do
+      hash = subject.new(city: 'Toronto')
+      expect { hash.country = 'Canada' }.to raise_error(NoMethodError)
+    end
   end
 
-  it 'works with translated properties (with string keys)' do
-    expect(subject.new(provence: 'Ontario').state).to eq('Ontario')
+  context 'combined with DeepMerge' do
+    class ForgivingTrashWithMerge < Hashie::Trash
+      include Hashie::Extensions::DeepMerge
+      include Hashie::Extensions::IgnoreUndeclared
+      property :some_key
+    end
+
+    it 'deep merges' do
+      class ForgivingTrashWithMergeAndProperty < ForgivingTrashWithMerge
+        property :some_other_key
+      end
+      hash = ForgivingTrashWithMergeAndProperty.new(some_ignored_key: 17, some_key: 12)
+      expect(hash.deep_merge(some_other_key: 55, some_ignored_key: 18)).to eq(some_key: 12, some_other_key: 55)
+    end
   end
 end

data/spec/hashie/extensions/indifferent_access_spec.rb

@@ -103,12 +103,12 @@ describe Hashie::Extensions::IndifferentAccess do
       it 'removes old keys' do
         [:foo, 'foo'].each do |k|
           expect(h[k]).to be_nil
-          expect(h.key?(k)).to be false
+          expect(h.key?(k)).to be_falsy
         end
       end
 
       it 'creates new keys with indifferent access' do
-        [:bar, 'bar', :hi, 'hi'].each { |k| expect(h.key?(k)).to be true }
+        [:bar, 'bar', :hi, 'hi'].each { |k| expect(h.key?(k)).to be_truthy }
         expect(h[:bar]).to eq 'baz'
         expect(h['bar']).to eq 'baz'
         expect(h[:hi]).to eq 'bye'