dm-core 1.1.0.rc2 → 1.1.0.rc3

data/spec/unit/blank_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'dm-core/ext/blank'
+
+describe 'DataMapper::Ext.blank?', Object do
+  it 'should be blank if it is nil' do
+    object = Object.new
+    class << object
+      def nil?; true end
+    end
+    DataMapper::Ext.blank?(object).should == true
+  end
+
+  it 'should be blank if it is empty' do
+    DataMapper::Ext.blank?({}).should == true
+    DataMapper::Ext.blank?([]).should == true
+  end
+
+  it 'should not be blank if not nil or empty' do
+    DataMapper::Ext.blank?(Object.new).should == false
+    DataMapper::Ext.blank?([nil]).should == false
+    DataMapper::Ext.blank?({ nil => 0 }).should == false
+  end
+end
+
+describe 'DataMapper::Ext.blank?', Numeric do
+  it 'should never be blank' do
+    DataMapper::Ext.blank?(1).should == false
+  end
+end
+
+describe 'DataMapper::Ext.blank?', NilClass do
+  it 'should always be blank' do
+    DataMapper::Ext.blank?(nil).should == true
+  end
+end
+
+describe 'DataMapper::Ext.blank?', TrueClass do
+  it 'should never be blank' do
+    DataMapper::Ext.blank?(true).should == false
+  end
+end
+
+describe 'DataMapper::Ext.blank?', FalseClass do
+  it 'should always be blank' do
+    DataMapper::Ext.blank?(false).should == true
+  end
+end
+
+describe 'DataMapper::Ext.blank?', String do
+  it 'should be blank if empty' do
+    DataMapper::Ext.blank?('').should == true
+  end
+
+  it 'should be blank if it only contains whitespace' do
+     DataMapper::Ext.blank?(' ').should == true
+     DataMapper::Ext.blank?(" \r \n \t ").should == true
+  end
+
+  it 'should not be blank if it contains non-whitespace' do
+    DataMapper::Ext.blank?(' a ').should == false
+  end
+end

data/spec/unit/data_mapper/ordered_set/hash_spec.rb

@@ -8,5 +8,5 @@ describe 'DataMapper::OrderedSet#hash' do
   let(:ordered_set) { DataMapper::OrderedSet.new([ entry ]) }
 
   it { should be_kind_of(Integer) }
-  it { should == ordered_set.entries.hash }
+  it { should == ordered_set.class.hash ^ ordered_set.entries.hash }
 end

data/spec/unit/hash_spec.rb

@@ -1,25 +1,17 @@
 require 'spec_helper'
-require 'dm-core/core_ext/hash'
+require 'dm-core/ext/hash'
+require 'dm-core/support/mash'
 
-begin
-  require 'active_support/hash_with_indifferent_access'
-  unless defined?(Mash)
-    Mash = ActiveSupport::HashWithIndifferentAccess
-  end
-rescue LoadError
-  require 'extlib/mash'
-end
-
-describe Hash, "only" do
+describe DataMapper::Ext::Hash, "only" do
   before do
     @hash = { :one => 'ONE', 'two' => 'TWO', 3 => 'THREE', 4 => nil }
   end
 
   it "should return a hash with only the given key(s)" do
-    @hash.only(:not_in_there).should == {}
-    @hash.only(4).should == {4 => nil}
-    @hash.only(:one).should == { :one => 'ONE' }
-    @hash.only(:one, 3).should == { :one => 'ONE', 3 => 'THREE' }
+    DataMapper::Ext::Hash.only(@hash, :not_in_there).should == {}
+    DataMapper::Ext::Hash.only(@hash, 4).should == {4 => nil}
+    DataMapper::Ext::Hash.only(@hash, :one).should == { :one => 'ONE' }
+    DataMapper::Ext::Hash.only(@hash, :one, 3).should == { :one => 'ONE', 3 => 'THREE' }
   end
 end
 
@@ -30,7 +22,7 @@ describe Hash, 'to_mash' do
   end
 
   it "copies default Hash value to Mash" do
-    @mash = @hash.to_mash
+    @mash = DataMapper::Ext::Hash.to_mash(@hash)
     @mash[:merb].should == 10
   end
 end

data/spec/unit/lazy_array_spec.rb

@@ -6,15 +6,15 @@ require 'dm-core/support/lazy_array'
 module LazyArraySpec
   module GroupMethods
     def self.extended(base)
-      base.class_inheritable_accessor :loaded, :subject_block, :action_block
+      base.class_inheritable_accessor :loaded
     end
 
     def subject(&block)
-       self.subject_block = block
+      let(:subject, &block)
     end
 
     def action(&block)
-      self.action_block = block
+      let(:action, &block)
     end
 
     def should_respond_to(method)
@@ -111,22 +111,11 @@ module LazyArraySpec
       end
     end
   end
-
-  module Methods
-    def subject
-      @subject ||= instance_eval(&self.class.subject_block)
-    end
-
-    def action
-      instance_eval(&self.class.action_block)
-    end
-  end
 end
 
 [ false, true ].each do |loaded|
   describe LazyArray do
     extend LazyArraySpec::GroupMethods
-    include LazyArraySpec::Methods
 
     self.loaded = loaded
 

data/spec/unit/mash_spec.rb

@@ -0,0 +1,312 @@
+require 'spec_helper'
+require 'dm-core/support/mash'
+
+class AwesomeHash < Hash
+end
+
+describe DataMapper::Mash do
+  before(:each) do
+    @hash = { "mash" => "indifferent", :hash => "different" }
+    @sub  = AwesomeHash.new("mash" => "indifferent", :hash => "different")
+  end
+
+  describe "#initialize" do
+    it 'converts all keys into strings when param is a Hash' do
+      mash = DataMapper::Mash.new(@hash)
+
+      mash.keys.any? { |key| key.is_a?(Symbol) }.should be(false)
+    end
+
+    it 'converts all pure Hash values into Mashes if param is a Hash' do
+      mash = DataMapper::Mash.new :hash => @hash
+
+      mash["hash"].should be_an_instance_of(DataMapper::Mash)
+      # sanity check
+      mash["hash"]["hash"].should == "different"
+    end
+
+    it 'doesn not convert Hash subclass values into Mashes' do
+      mash = DataMapper::Mash.new :sub => @sub
+      mash["sub"].should be_an_instance_of(AwesomeHash)
+    end
+
+    it 'converts all value items if value is an Array' do
+      mash = DataMapper::Mash.new :arry => { :hash => [@hash] }
+
+      mash["arry"].should be_an_instance_of(DataMapper::Mash)
+      # sanity check
+      mash["arry"]["hash"].first["hash"].should == "different"
+
+    end
+
+    it 'delegates to superclass constructor if param is not a Hash' do
+      mash = DataMapper::Mash.new("dash berlin")
+
+      mash["unexisting key"].should == "dash berlin"
+    end
+  end # describe "#initialize"
+
+
+
+  describe "#update" do
+    it 'converts all keys into strings when param is a Hash' do
+      mash = DataMapper::Mash.new(@hash)
+      mash.update("starry" => "night")
+
+      mash.keys.any? { |key| key.is_a?(Symbol) }.should be(false)
+    end
+
+    it 'converts all Hash values into Mashes if param is a Hash' do
+      mash = DataMapper::Mash.new :hash => @hash
+      mash.update(:hash => { :hash => "is buggy in Ruby 1.8.6" })
+
+      mash["hash"].should be_an_instance_of(DataMapper::Mash)
+    end
+  end # describe "#update"
+
+
+
+  describe "#[]=" do
+    it 'converts key into string' do
+      mash = DataMapper::Mash.new(@hash)
+      mash[:hash] = { "starry" => "night" }
+
+      mash.keys.any? { |key| key.is_a?(Symbol) }.should be(false)
+    end
+
+    it 'converts all Hash value into Mash' do
+      mash = DataMapper::Mash.new :hash => @hash
+      mash[:hash] = { :hash => "is buggy in Ruby 1.8.6" }
+
+      mash["hash"].should be_an_instance_of(DataMapper::Mash)
+    end
+  end # describe "#[]="
+
+
+
+  describe "#key?" do
+    before(:each) do
+      @mash = DataMapper::Mash.new(@hash)
+    end
+
+    it 'converts key before lookup' do
+      @mash.key?("mash").should be(true)
+      @mash.key?(:mash).should be(true)
+
+      @mash.key?("hash").should be(true)
+      @mash.key?(:hash).should be(true)
+
+      @mash.key?(:rainclouds).should be(false)
+      @mash.key?("rainclouds").should be(false)
+    end
+
+    it 'is aliased as include?' do
+      @mash.include?("mash").should be(true)
+      @mash.include?(:mash).should be(true)
+
+      @mash.include?("hash").should be(true)
+      @mash.include?(:hash).should be(true)
+
+      @mash.include?(:rainclouds).should be(false)
+      @mash.include?("rainclouds").should be(false)
+    end
+
+    it 'is aliased as member?' do
+      @mash.member?("mash").should be(true)
+      @mash.member?(:mash).should be(true)
+
+      @mash.member?("hash").should be(true)
+      @mash.member?(:hash).should be(true)
+
+      @mash.member?(:rainclouds).should be(false)
+      @mash.member?("rainclouds").should be(false)
+    end
+  end # describe "#key?"
+
+
+  describe "#dup" do
+    it 'returns instance of Mash' do
+      DataMapper::Mash.new(@hash).dup.should be_an_instance_of(DataMapper::Mash)
+    end
+
+    it 'preserves keys' do
+      mash = DataMapper::Mash.new(@hash)
+      dup  = mash.dup
+
+      mash.keys.sort.should == dup.keys.sort
+    end
+
+    it 'preserves value' do
+      mash = DataMapper::Mash.new(@hash)
+      dup  = mash.dup
+
+      mash.values.sort.should == dup.values.sort
+    end
+  end
+
+
+
+  describe "#to_hash" do
+    it 'returns instance of Mash' do
+      DataMapper::Mash.new(@hash).to_hash.should be_an_instance_of(Hash)
+    end
+
+    it 'preserves keys' do
+      mash = DataMapper::Mash.new(@hash)
+      converted  = mash.to_hash
+
+      mash.keys.sort.should == converted.keys.sort
+    end
+
+    it 'preserves value' do
+      mash = DataMapper::Mash.new(@hash)
+      converted = mash.to_hash
+
+      mash.values.sort.should == converted.values.sort
+    end
+  end
+
+
+
+  describe "#symbolize_keys" do
+    it 'returns instance of Mash' do
+      DataMapper::Mash.new(@hash).symbolize_keys.should be_an_instance_of(Hash)
+    end
+
+    it 'converts keys to symbols' do
+      mash = DataMapper::Mash.new(@hash)
+      converted  = mash.symbolize_keys
+
+      converted_keys = converted.keys.sort{|k1, k2| k1.to_s <=> k2.to_s}
+      orig_keys = mash.keys.map{|k| k.to_sym}.sort{|i1, i2| i1.to_s <=> i2.to_s}
+
+      converted_keys.should == orig_keys
+    end
+
+    it 'preserves value' do
+      mash = DataMapper::Mash.new(@hash)
+      converted = mash.symbolize_keys
+
+      mash.values.sort.should == converted.values.sort
+    end
+  end
+
+
+
+  describe "#delete" do
+    it 'converts Symbol key into String before deleting' do
+      mash = DataMapper::Mash.new(@hash)
+
+      mash.delete(:hash)
+      mash.key?("hash").should be(false)
+    end
+
+    it 'works with String keys as well' do
+      mash = DataMapper::Mash.new(@hash)
+
+      mash.delete("mash")
+      mash.key?("mash").should be(false)
+    end
+  end
+
+
+
+  describe "#except" do
+    it "converts Symbol key into String before calling super" do
+      mash = DataMapper::Mash.new(@hash)
+
+      hashless_mash = mash.except(:hash)
+      hashless_mash.key?("hash").should be(false)
+    end
+
+    it "works with String keys as well" do
+      mash = DataMapper::Mash.new(@hash)
+
+      mashless_mash = mash.except("mash")
+      mashless_mash.key?("mash").should be(false)
+    end
+
+    it "works with multiple keys" do
+      mash = DataMapper::Mash.new(@hash)
+
+      mashless = mash.except("hash", :mash)
+      mashless.key?(:hash).should be(false)
+      mashless.key?("mash").should be(false)
+    end
+
+    it "should return a mash" do
+      mash = DataMapper::Mash.new(@hash)
+
+      hashless_mash = mash.except(:hash)
+      hashless_mash.class.should be(DataMapper::Mash)
+    end
+  end
+
+
+
+  describe "#merge" do
+    before(:each) do
+      @mash = DataMapper::Mash.new(@hash).merge(:no => "in between")
+    end
+
+    it 'returns instance of Mash' do
+      @mash.should be_an_instance_of(DataMapper::Mash)
+    end
+
+    it 'merges in give Hash' do
+      @mash["no"].should == "in between"
+    end
+  end
+
+
+
+  describe "#fetch" do
+    before(:each) do
+      @mash = DataMapper::Mash.new(@hash).merge(:no => "in between")
+    end
+
+    it 'converts key before fetching' do
+      @mash.fetch("no").should == "in between"
+    end
+
+    it 'returns alternative value if key lookup fails' do
+      @mash.fetch("flying", "screwdriver").should == "screwdriver"
+    end
+  end
+
+
+  describe "#default" do
+    before(:each) do
+      @mash = DataMapper::Mash.new(:yet_another_technical_revolution)
+    end
+
+    it 'returns default value unless key exists in mash' do
+      @mash.default("peak oil is now behind, baby").should == :yet_another_technical_revolution
+    end
+
+    it 'returns existing value if key is Symbol and exists in mash' do
+      @mash.update(:no => "in between")
+      @mash.default(:no).should == "in between"
+    end
+  end
+
+
+  describe "#values_at" do
+    before(:each) do
+      @mash = DataMapper::Mash.new(@hash).merge(:no => "in between")
+    end
+
+    it 'is indifferent to whether keys are strings or symbols' do
+      @mash.values_at("hash", :mash, :no).should == ["different", "indifferent", "in between"]
+    end
+  end
+
+
+  describe "#stringify_keys!" do
+    it 'returns the mash itself' do
+      mash = DataMapper::Mash.new(@hash)
+
+      mash.stringify_keys!.object_id.should == mash.object_id
+    end
+  end
+end