hashie 1.2.0 → 2.0.0

data/spec/hashie/extensions/key_conversion_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Hashie::Extensions::KeyConversion do
+  subject do
+    klass = Class.new(::Hash)
+    klass.send :include, Hashie::Extensions::KeyConversion
+    klass
+  end
+  let(:instance){ subject.new }
+
+  describe '#stringify_keys!' do
+    it 'should convert keys to strings' do
+      instance[:abc] = 'abc'
+      instance[123] = '123'
+      instance.stringify_keys!
+      (instance.keys & %w(abc 123)).size.should == 2
+    end
+
+    it 'should do deep conversion within nested hashes' do
+      instance[:ab] = subject.new
+      instance[:ab][:cd] = subject.new
+      instance[:ab][:cd][:ef] = 'abcdef'
+      instance.stringify_keys!
+      instance.should == {'ab' => {'cd' => {'ef' => 'abcdef'}}}
+    end
+
+    it 'should do deep conversion within nested arrays' do
+      instance[:ab] = []
+      instance[:ab] << subject.new
+      instance[:ab] << subject.new
+      instance[:ab][0][:cd] = 'abcd'
+      instance[:ab][1][:ef] = 'abef'
+      instance.stringify_keys!
+      instance.should == {'ab' => [{'cd' => 'abcd'}, {'ef' => 'abef'}]}
+    end
+
+    it 'should return itself' do
+      instance.stringify_keys!.should == instance
+    end
+  end
+
+  describe '#stringify_keys' do
+    it 'should convert keys to strings' do
+      instance[:abc] = 'def'
+      copy = instance.stringify_keys
+      copy['abc'].should == 'def'
+    end
+
+    it 'should not alter the original' do
+      instance[:abc] = 'def'
+      copy = instance.stringify_keys
+      instance.keys.should == [:abc]
+      copy.keys.should == %w(abc)
+    end
+  end
+
+  describe '#symbolize_keys!' do
+    it 'should convert keys to symbols' do
+      instance['abc'] = 'abc'
+      instance['def'] = 'def'
+      instance.symbolize_keys!
+      (instance.keys & [:abc, :def]).size.should == 2
+    end
+
+    it 'should do deep conversion within nested hashes' do
+      instance['ab'] = subject.new
+      instance['ab']['cd'] = subject.new
+      instance['ab']['cd']['ef'] = 'abcdef'
+      instance.symbolize_keys!
+      instance.should == {:ab => {:cd => {:ef => 'abcdef'}}}
+    end
+
+    it 'should do deep conversion within nested arrays' do
+      instance['ab'] = []
+      instance['ab'] << subject.new
+      instance['ab'] << subject.new
+      instance['ab'][0]['cd'] = 'abcd'
+      instance['ab'][1]['ef'] = 'abef'
+      instance.symbolize_keys!
+      instance.should == {:ab => [{:cd => 'abcd'}, {:ef => 'abef'}]}
+    end
+
+    it 'should return itself' do
+      instance.symbolize_keys!.should == instance
+    end
+  end
+
+  describe '#symbolize_keys' do
+    it 'should convert keys to symbols' do
+      instance['abc'] = 'def'
+      copy = instance.symbolize_keys
+      copy[:abc].should == 'def'
+    end
+
+    it 'should not alter the original' do
+      instance['abc'] = 'def'
+      copy = instance.symbolize_keys
+      instance.keys.should == ['abc']
+      copy.keys.should == [:abc]
+    end
+  end
+end

data/spec/hashie/extensions/merge_initializer_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Hashie::Extensions::MergeInitializer do
+  class MergeInitializerHash < Hash; include Hashie::Extensions::MergeInitializer end
+  subject{ MergeInitializerHash }
+
+  it 'should initialize fine with no arguments' do
+    subject.new.should == {}
+  end
+
+  it 'should initialize with a hash' do
+    subject.new(:abc => 'def').should == {:abc => 'def'}
+  end
+
+  it 'should initialize with a hash and a default' do
+    h = subject.new({:abc => 'def'}, 'bar')
+    h[:foo].should == 'bar'
+    h[:abc].should == 'def'
+  end
+end

data/spec/hashie/extensions/method_access_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Hashie::Extensions::MethodReader do
+  class ReaderHash < Hash
+    def initialize(hash = {}); self.update(hash) end
+    include Hashie::Extensions::MethodReader
+  end
+  subject{ ReaderHash }
+
+  it 'should read string keys from the method' do
+    subject.new('awesome' => 'sauce').awesome.should == 'sauce'
+  end
+
+  it 'should read symbol keys from the method' do
+    subject.new(:awesome => 'sauce').awesome.should == 'sauce'
+  end
+
+  it 'should read nil and false values out properly' do
+    h = subject.new(:nil => nil, :false => false)
+    h.nil.should == nil
+    h.false.should == false
+  end
+
+  it 'should raise a NoMethodError for undefined keys' do
+    lambda{ subject.new.awesome }.should raise_error(NoMethodError)
+  end
+
+  describe '#respond_to?' do
+    it 'should be true for string keys' do
+      subject.new('awesome' => 'sauce').should be_respond_to(:awesome)
+    end
+
+    it 'should be true for symbol keys' do
+      subject.new(:awesome => 'sauce').should be_respond_to(:awesome)
+    end
+
+    it 'should be false for non-keys' do
+      subject.new.should_not be_respond_to(:awesome)
+    end
+  end
+end
+
+describe Hashie::Extensions::MethodWriter do
+  class WriterHash < Hash
+    include Hashie::Extensions::MethodWriter
+  end
+  subject{ WriterHash.new }
+
+  it 'should write from a method call' do
+    subject.awesome = 'sauce'
+    subject['awesome'].should == 'sauce'
+  end
+
+  it 'should convert the key using the #convert_key method' do
+    subject.stub!(:convert_key).and_return(:awesome)
+    subject.awesome = 'sauce'
+    subject[:awesome].should == 'sauce'
+  end
+
+  it 'should still NoMethodError on non equals-ending methods' do
+    lambda{ subject.awesome }.should raise_error(NoMethodError)
+  end
+
+  it 'should #respond_to? properly' do
+    subject.should be_respond_to(:abc=)
+    subject.should_not be_respond_to(:abc)
+  end
+end
+
+describe Hashie::Extensions::MethodQuery do
+  class QueryHash < Hash
+    def initialize(hash = {}); self.update(hash) end
+    include Hashie::Extensions::MethodQuery
+  end
+  subject{ QueryHash }
+  
+  it 'should be true for non-nil string key values' do
+    subject.new('abc' => 123).should be_abc
+  end
+
+  it 'should be true for non-nil symbol key values' do
+    subject.new(:abc => 123).should be_abc
+  end
+
+  it 'should be false for nil key values' do
+    subject.new(:abc => false).should_not be_abc
+  end
+
+  it 'should raise a NoMethodError for non-set keys' do
+    lambda{ subject.new.abc? }.should raise_error(NoMethodError)
+  end
+
+  it 'should respond_to? for existing string keys' do
+    subject.new('abc' => 'def').should be_respond_to('abc?')
+  end
+
+  it 'should respond_to? for existing symbol keys' do
+    subject.new(:abc => 'def').should be_respond_to(:abc?)
+  end
+
+  it 'should not respond_to? for non-existent keys' do
+    subject.new.should_not be_respond_to('abc?')
+  end
+end
+
+describe Hashie::Extensions::MethodAccess do
+  it 'should include all of the other method mixins' do
+    klass = Class.new(Hash)
+    klass.send :include, Hashie::Extensions::MethodAccess
+    (klass.ancestors & [Hashie::Extensions::MethodReader, Hashie::Extensions::MethodWriter, Hashie::Extensions::MethodQuery]).size.should == 3
+  end
+end

data/spec/hashie/hash_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Hashie::Hash do
+describe Hash do
   it "should be convertible to a Hashie::Mash" do
     mash = Hashie::Hash[:some => "hash"].to_mash
     mash.is_a?(Hashie::Mash).should be_true
@@ -19,14 +19,4 @@ describe Hashie::Hash do
     hash.should == Hashie::Hash[:a => "hey", 123 => "bob"]
     stringified_hash.should == Hashie::Hash["a" => "hey", "123" => "bob"]
   end
-
-  describe '#to_hash' do
-    it 'should convert it to a hash with string keys by default' do
-      Hashie::Hash.new.merge(:a => 'hey', :b => 'foo').to_hash.should == {'a' => 'hey', 'b' => 'foo'}
-    end
-
-    it 'should convert to a hash with symbol keys if :symbolize_keys is passed in' do
-      Hashie::Hash.new.merge('a' => 'hey', 'b' => 'doo').to_hash(:symbolize_keys => true).should == {:a => 'hey', :b => 'doo'}
-    end
-  end
-end
+end

data/spec/hashie/mash_spec.rb

@@ -71,6 +71,15 @@ describe Hashie::Mash do
     @mash.name!.should == "Bob"
   end
 
+  it "should return a Hashie::Mash when passed an under bang method to a non-existenct key" do
+    @mash.abc_.is_a?(Hashie::Mash).should be_true
+  end
+
+  it "should return the existing value when passed an under bang method for an existing key" do
+    @mash.name = "Bob"
+    @mash.name_.should == "Bob"
+  end
+
   it "#initializing_reader should return a Hashie::Mash when passed a non-existent key" do
     @mash.initializing_reader(:abc).is_a?(Hashie::Mash).should be_true
   end
@@ -82,9 +91,33 @@ describe Hashie::Mash do
     @mash.author.website.should == Hashie::Mash.new(:url => "http://www.mbleigh.com/")
   end
 
-  # it "should call super if type is not a key" do
-  #   @mash.type.should == Hashie::Mash
-  # end
+  it "should allow for multi-level under bang testing" do
+    @mash.author_.website_.url.should be_nil
+    @mash.author_.website_.url?.should == false
+    @mash.author.should be_nil
+  end
+
+  it "should not call super if object_id is not a key" do
+    @mash.object_id.should == nil
+  end
+
+  it "should return the value if object_id is a key" do
+    @mash.object_id = "Steve"
+    @mash.object_id.should == "Steve"
+  end
+
+  it "should not call super if id is not a key" do
+    @mash.id.should == nil
+  end
+
+  it "should return the value if id is a key" do
+    @mash.id = "Steve"
+    @mash.id.should == "Steve"
+  end
+
+  it "should not call super if type is not a key" do
+    @mash.type.should == nil
+  end
 
   it "should return the value if type is a key" do
     @mash.type = "Steve"
@@ -126,6 +159,12 @@ describe Hashie::Mash do
         duped.details.email.should == "michael@intridea.com"
         duped.details.address.should == "Nowhere road"
       end
+
+      # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-update
+      it "accepts a block" do
+        duped = subject.merge(:details => {:address => "Pasadena CA"}) {|key, oldv, newv| [oldv, newv].join(', ')}
+        duped.details.address.should == 'Nowhere road, Pasadena CA'
+      end
     end
 
     describe "shallow update" do
@@ -204,20 +243,35 @@ describe Hashie::Mash do
     son.non_existent!.should be_kind_of(SubMash)
   end
 
+  it "should respect the class when passed an under bang method for a non-existent key" do
+    record = Hashie::Mash.new
+    record.non_existent_.should be_kind_of(Hashie::Mash)
+
+    class SubMash < Hashie::Mash
+    end
+
+    son = SubMash.new
+    son.non_existent_.should be_kind_of(SubMash)
+  end
+
   it "should respect the class when converting the value" do
     record = Hashie::Mash.new
     record.details = Hashie::Mash.new({:email => "randy@asf.com"})
     record.details.should be_kind_of(Hashie::Mash)
+  end
+
+  it "should respect another subclass when converting the value" do
+    record = Hashie::Mash.new
 
     class SubMash < Hashie::Mash
     end
 
-    son = SubMash.new
-    son.details = Hashie::Mash.new({:email => "randyjr@asf.com"})
-    son.details.should be_kind_of(SubMash)
+    son = SubMash.new({:email => "foo@bar.com"})
+    record.details = son
+    record.details.should be_kind_of(SubMash)
   end
 
-  describe '#respond_to?' do
+  describe "#respond_to?" do
     it 'should respond to a normal method' do
       Hashie::Mash.new.should be_respond_to(:key?)
     end
@@ -251,11 +305,11 @@ describe Hashie::Mash do
       initial = Hashie::Mash.new(:name => 'randy', :address => {:state => 'TX'})
       copy = Hashie::Mash.new(initial)
       initial.name.should == copy.name
-      initial.object_id.should_not == copy.object_id
+      initial.__id__.should_not == copy.__id__
       copy.address.state.should == 'TX'
       copy.address.state = 'MI'
       initial.address.state.should == 'TX'
-      copy.address.object_id.should_not == initial.address.object_id
+      copy.address.__id__.should_not == initial.address.__id__
     end
 
     it "should accept a default block" do
@@ -266,15 +320,49 @@ describe Hashie::Mash do
       initial.test?.should be_true
     end
 
-    describe '.subkey_class' do
-      it 'should be able to define a subkey class different from itself' do
-        class CustomSubkeyHash < Hashie::Mash
-          def self.subkey_class; Hashie::Mash end
+    it "should convert Hashie::Mashes within Arrays back to Hashes" do
+      initial_hash = {"a" => [{"b" => 12, "c" =>["d" => 50, "e" => 51]}, 23]}
+      converted = Hashie::Mash.new(initial_hash)
+      converted.to_hash["a"].first.is_a?(Hashie::Mash).should be_false
+      converted.to_hash["a"].first.is_a?(Hash).should be_true
+      converted.to_hash["a"].first["c"].first.is_a?(Hashie::Mash).should be_false
+    end
+  end
+  
+  describe "#fetch" do
+    let(:hash) { {:one => 1} }
+    let(:mash) { Hashie::Mash.new(hash) }
+    
+    context "when key exists" do
+      it "returns the value" do
+        mash.fetch(:one).should eql(1)
+      end
+      
+      context "when key has other than original but acceptable type" do
+        it "returns the value" do
+          mash.fetch('one').should eql(1)
+        end
+      end
+    end
+    
+    context "when key does not exist" do
+      it "should raise KeyError" do
+        error = RUBY_VERSION =~ /1.8/ ? IndexError : KeyError
+        expect { mash.fetch(:two) }.to raise_error(error)
+      end
+      
+      context "with default value given" do
+        it "returns default value" do
+          mash.fetch(:two, 8).should eql(8)
+        end
+      end
+      
+      context "with block given" do
+        it "returns default value" do
+          mash.fetch(:two) {|key|
+            "block default value"
+          }.should eql("block default value")
         end
-
-        subhash = CustomSubkeyHash.new(:subhash => {:abc => :def})[:subhash]
-        subhash.should_not be_kind_of(CustomSubkeyHash)
-        subhash.should be_kind_of(Hashie::Mash)
       end
     end
   end

data/spec/hashie/trash_spec.rb

@@ -63,8 +63,83 @@ describe Hashie::Trash do
       TrashTest.new(:first_name => 'Michael').first_name.should == 'Michael'
     end
 
+    context "with both the translated property and the property" do
+      it 'sets the desired properties' do
+        TrashTest.new(:first_name => 'Michael', :firstName=>'Maeve').first_name.should == 'Michael'
+      end
+    end
+
     it 'sets the translated properties' do
       TrashTest.new(:firstName => 'Michael').first_name.should == 'Michael'
     end
   end
+
+  describe 'translating properties using a proc' do
+    class TrashLambdaTest < Hashie::Trash
+      property :first_name, :from => :firstName, :with => lambda { |value| value.reverse }
+    end
+
+    let(:lambda_trash) { TrashLambdaTest.new }
+
+    it 'should translate the value given on initialization with the given lambda' do
+      TrashLambdaTest.new(:firstName => 'Michael').first_name.should == 'Michael'.reverse
+    end
+
+    it 'should not translate the value if given with the right property' do
+      TrashTest.new(:first_name => 'Michael').first_name.should == 'Michael'
+    end
+
+    it 'should translate the value given as property with the given lambda' do
+      lambda_trash.firstName = 'Michael'
+      lambda_trash.first_name.should == 'Michael'.reverse
+    end
+
+    it 'should not translate the value given as right property' do
+      lambda_trash.first_name = 'Michael'
+      lambda_trash.first_name.should == 'Michael'
+    end
+  end
+
+  describe 'translating properties without from option using a proc' do
+
+    class TrashLambdaTest2 < Hashie::Trash
+      property :first_name, :transform_with => lambda { |value| value.reverse }
+    end
+
+    let(:lambda_trash) { TrashLambdaTest2.new }
+
+    it 'should translate the value given as property with the given lambda' do
+      lambda_trash.first_name = 'Michael'
+      lambda_trash.first_name.should == 'Michael'.reverse
+    end
+
+    it 'should transform the value when given in constructor' do
+      TrashLambdaTest2.new(:first_name => 'Michael').first_name.should == 'Michael'.reverse
+    end
+
+    context "when :from option is given" do
+      class TrashLambdaTest3 < Hashie::Trash
+        property :first_name, :from => :firstName, :transform_with => lambda { |value| value.reverse }
+      end
+
+      it 'should not override the :from option in the constructor' do
+        TrashLambdaTest3.new(:first_name => 'Michael').first_name.should == 'Michael'
+      end
+
+      it 'should not override the :from option when given as property' do
+        t = TrashLambdaTest3.new
+        t.first_name = 'Michael'
+        t.first_name.should == 'Michael'
+      end
+
+    end
+  end
+
+  it "should raise an error when :from have the same value as property" do
+    expect {
+      class WrongTrash < Hashie::Trash
+        property :first_name, :from => :first_name
+      end
+    }.to raise_error(ArgumentError)
+  end
 end