sbf-dm-core 1.3.0.beta

data/spec/unit/mash_spec.rb

@@ -0,0 +1,289 @@
+require_relative '../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)
+
+      expect(mash.keys.any? { |key| key.is_a?(Symbol) }).to be(false)
+    end
+
+    it 'converts all pure Hash values into Mashes if param is a Hash' do
+      mash = DataMapper::Mash.new :hash => @hash
+
+      expect(mash['hash']).to be_an_instance_of(DataMapper::Mash)
+      # sanity check
+      expect(mash['hash']['hash']).to eq 'different'
+    end
+
+      mash = DataMapper::Mash.new :sub => @sub
+    it 'does not convert Hash subclass values into Mashes' do
+      expect(mash['sub']).to be_an_instance_of(AwesomeHash)
+    end
+
+    it 'converts all value items if value is an Array' do
+      mash = DataMapper::Mash.new :arry => { :hash => [@hash] }
+
+      expect(mash['arry']).to be_an_instance_of(DataMapper::Mash)
+      # sanity check
+      expect(mash['arry']['hash'].first['hash']).to eq 'different'
+    end
+
+    it 'delegates to superclass constructor if param is not a Hash' do
+      mash = DataMapper::Mash.new("dash berlin")
+
+      expect(mash['unexisting key']).to eq '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")
+
+      expect(mash.keys.any? { |key| key.is_a?(Symbol) }).to 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" })
+
+      expect(mash['hash']).to 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" }
+
+      expect(mash.keys.any? { |key| key.is_a?(Symbol) }).to 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" }
+
+      expect(mash['hash']).to 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
+      expect(@mash.key?('mash')).to be(true)
+      expect(@mash.key?(:mash)).to be(true)
+
+      expect(@mash.key?('hash')).to be(true)
+      expect(@mash.key?(:hash)).to be(true)
+
+      expect(@mash.key?(:rainclouds)).to be(false)
+      expect(@mash.key?('rainclouds')).to be(false)
+    end
+
+    it 'is aliased as include?' do
+      expect(@mash.include?('mash')).to be(true)
+      expect(@mash.include?(:mash)).to be(true)
+
+      expect(@mash.include?('hash')).to be(true)
+      expect(@mash.include?(:hash)).to be(true)
+
+      expect(@mash.include?(:rainclouds)).to be(false)
+      expect(@mash.include?('rainclouds')).to be(false)
+    end
+
+    it 'is aliased as member?' do
+      expect(@mash.member?('mash')).to be(true)
+      expect(@mash.member?(:mash)).to be(true)
+
+      expect(@mash.member?('hash')).to be(true)
+      expect(@mash.member?(:hash)).to be(true)
+
+      expect(@mash.member?(:rainclouds)).to be(false)
+      expect(@mash.member?('rainclouds')).to be(false)
+    end
+  end
+
+  describe '#dup' do
+    it 'returns instance of Mash' do
+      expect(DataMapper::Mash.new(@hash).dup).to be_an_instance_of(DataMapper::Mash)
+    end
+
+    it 'preserves keys' do
+      mash = DataMapper::Mash.new(@hash)
+      dup  = mash.dup
+
+      expect(mash.keys.sort).to eq dup.keys.sort
+    end
+
+    it 'preserves value' do
+      mash = DataMapper::Mash.new(@hash)
+      dup  = mash.dup
+
+      expect(mash.values.sort).to eq dup.values.sort
+    end
+  end
+
+  describe '#to_hash' do
+    it 'returns instance of Mash' do
+      expect(DataMapper::Mash.new(@hash).to_hash).to be_an_instance_of(Hash)
+    end
+
+    it 'preserves keys' do
+      mash = DataMapper::Mash.new(@hash)
+      converted  = mash.to_hash
+
+      expect(mash.keys.sort).to eq converted.keys.sort
+    end
+
+    it 'preserves value' do
+      mash = DataMapper::Mash.new(@hash)
+      converted = mash.to_hash
+
+      expect(mash.values.sort).to eq converted.values.sort
+    end
+  end
+
+  describe '#symbolize_keys' do
+    it 'returns instance of Mash' do
+      expect(DataMapper::Mash.new(@hash).symbolize_keys).to 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}
+
+      expect(converted_keys).to eq orig_keys
+    end
+
+    it 'preserves value' do
+      mash = DataMapper::Mash.new(@hash)
+      converted = mash.symbolize_keys
+
+      expect(mash.values.sort).to eq 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)
+      expect(mash.key?('hash')).to be(false)
+    end
+
+    it 'works with String keys as well' do
+      mash = DataMapper::Mash.new(@hash)
+
+      mash.delete("mash")
+      expect(mash.key?('mash')).to 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)
+      expect(hashless_mash.key?('hash')).to be(false)
+    end
+
+    it 'works with String keys as well' do
+      mash = DataMapper::Mash.new(@hash)
+
+      mashless_mash = mash.except("mash")
+      expect(mashless_mash.key?('mash')).to be(false)
+    end
+
+    it 'works with multiple keys' do
+      mash = DataMapper::Mash.new(@hash)
+
+      mashless = mash.except("hash", :mash)
+      expect(mashless.key?(:hash)).to be(false)
+      expect(mashless.key?('mash')).to be(false)
+    end
+
+    it 'returns a mash' do
+      mash = DataMapper::Mash.new(@hash)
+
+      hashless_mash = mash.except(:hash)
+      expect(hashless_mash.class).to 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
+      expect(@mash).to be_an_instance_of(DataMapper::Mash)
+    end
+
+    it 'merges in give Hash' do
+      expect(@mash['no']).to eq '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
+      expect(@mash.fetch('no')).to eq 'in between'
+    end
+
+    it 'returns alternative value if key lookup fails' do
+      expect(@mash.fetch('flying', 'screwdriver')).to eq '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
+      expect(@mash.default('peak oil is now behind, baby')).to eq :yet_another_technical_revolution
+    end
+
+    it 'returns existing value if key is Symbol and exists in mash' do
+      @mash.update(:no => "in between")
+      expect(@mash.default(:no)).to eq '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
+      expect(@mash.values_at('hash', :mash, :no)).to eq ['different', 'indifferent', 'in between']
+    end
+  end
+
+  describe '#stringify_keys!' do
+    it 'returns the mash itself' do
+      mash = DataMapper::Mash.new(@hash)
+
+      expect(mash.stringify_keys!.object_id).to eq mash.object_id
+    end
+  end
+end

data/spec/unit/module_spec.rb

@@ -0,0 +1,70 @@
+require_relative '../spec_helper'
+require 'dm-core/support/ext/module'
+
+describe DataMapper::Ext::Module do
+
+  before :all do
+    Object.send(:remove_const, :Foo) if defined?(Foo)
+    Object.send(:remove_const, :Baz) if defined?(Baz)
+    Object.send(:remove_const, :Bar) if defined?(Bar)
+
+    module ::Foo
+      module ModBar
+        module Noo
+          module Too
+            module Boo; end
+          end
+        end
+      end
+
+      class Zed; end
+    end
+
+    class ::Baz; end
+
+    class ::Bar; end
+  end
+
+  it 'raises NameError for a missing constant' do
+    expect { DataMapper::Ext::Module.find_const(Foo, 'Moo') }.to raise_error(NameError)
+    expect { DataMapper::Ext::Module.find_const(Object, 'MissingConstant') }.to raise_error(NameError)
+  end
+
+  it 'is able to get a recursive constant' do
+    expect(DataMapper::Ext::Module.find_const(Object, 'Foo::ModBar')).to eq Foo::ModBar
+  end
+
+  it 'ignores get Constants from the Kernel namespace correctly' do
+    expect(DataMapper::Ext::Module.find_const(Object, '::Foo::ModBar')).to eq ::Foo::ModBar
+  end
+
+  it 'finds relative constants' do
+    expect(DataMapper::Ext::Module.find_const(Foo, 'ModBar')).to eq Foo::ModBar
+    expect(DataMapper::Ext::Module.find_const(Foo, 'Baz')).to eq Baz
+  end
+
+  it 'finds sibling constants' do
+    expect(DataMapper::Ext::Module.find_const(Foo::ModBar, 'Zed')).to eq Foo::Zed
+  end
+
+  it 'finds nested constants on nested constants' do
+    expect(DataMapper::Ext::Module.find_const(Foo::ModBar, 'Noo::Too')).to eq Foo::ModBar::Noo::Too
+  end
+
+  it 'finds constants outside of nested constants' do
+    expect(DataMapper::Ext::Module.find_const(Foo::ModBar::Noo::Too, 'Zed')).to eq Foo::Zed
+  end
+
+  it 'is able to find past the second nested level' do
+    expect(DataMapper::Ext::Module.find_const(Foo::ModBar::Noo, 'Too')).to eq Foo::ModBar::Noo::Too
+    expect(DataMapper::Ext::Module.find_const(Foo::ModBar::Noo::Too, 'Boo')).to eq Foo::ModBar::Noo::Too::Boo
+  end
+
+  it 'is able to deal with constants being added and removed' do
+    DataMapper::Ext::Module.find_const(Object, 'Bar') # First we load Bar with find_const
+    Object.module_eval { remove_const('Bar') } # Now we delete it
+    module ::Bar; end; # Now we redefine it
+    expect(DataMapper::Ext::Module.find_const(Object, 'Bar')).to eq Bar
+  end
+
+end

data/spec/unit/object_spec.rb

@@ -0,0 +1,38 @@
+require_relative '../spec_helper'
+require 'dm-core/support/ext/object'
+
+describe DataMapper::Ext::Object do
+  before :all do
+    Object.send(:remove_const, :HactiveSupport) if defined?(HactiveSupport)
+    module ::HactiveSupport
+      class MemoizeConsideredUseless; end
+    end
+
+    Object.send(:remove_const, :Foo) if defined?(Foo)
+    module ::Foo
+      class Bar; end
+    end
+
+    Object.send(:remove_const, :Oi) if defined?(Oi)
+    class ::Oi
+      attr_accessor :foo
+    end
+  end
+
+  describe ".full_const_get" do
+    it 'returns constant by FQ name in receiver namespace' do
+      expect(DataMapper::Ext::Object.full_const_get('Oi')).to eq Oi
+      expect(DataMapper::Ext::Object.full_const_get('Foo::Bar')).to eq Foo::Bar
+    end
+  end
+
+  describe ".full_const_set" do
+    it 'sets constant value by FQ name in receiver namespace' do
+      DataMapper::Ext::Object.full_const_set("HactiveSupport::MCU", HactiveSupport::MemoizeConsideredUseless)
+
+      expect(DataMapper::Ext::Object.full_const_get('HactiveSupport::MCU')).to eq HactiveSupport::MemoizeConsideredUseless
+      expect(DataMapper::Ext::Object.full_const_get(HactiveSupport, 'MCU')).to eq HactiveSupport::MemoizeConsideredUseless
+    end
+  end
+
+end

data/spec/unit/try_dup_spec.rb

@@ -0,0 +1,46 @@
+require_relative '../spec_helper'
+require 'dm-core/support/ext/try_dup'
+
+describe 'try_dup' do
+  it 'returns a duplicate version on regular objects' do
+    obj = Object.new
+    oth = DataMapper::Ext.try_dup(obj)
+    expect(obj).not_to eq oth
+  end
+
+  it 'returns self on Numerics' do
+    obj = 12
+    oth = DataMapper::Ext.try_dup(obj)
+    expect(obj).to eq oth
+  end
+
+  it 'returns self on Symbols' do
+    obj = :test
+    oth = DataMapper::Ext.try_dup(obj)
+    expect(obj).to eq oth
+  end
+
+  it 'returns self on true' do
+    obj = true
+    oth = DataMapper::Ext.try_dup(obj)
+    expect(obj).to eq oth
+  end
+
+  it 'returns self on false' do
+    obj = false
+    oth = DataMapper::Ext.try_dup(obj)
+    expect(obj).to eq oth
+  end
+
+  it 'returns self on nil' do
+    obj = nil
+    oth = DataMapper::Ext.try_dup(obj)
+    expect(obj).to eq oth
+  end
+
+  it 'returns self on modules' do
+    obj = Module.new
+    oth = DataMapper::Ext.try_dup(obj)
+    expect(obj.object_id).to eq oth.object_id
+  end
+end

data/tasks/ci.rake

@@ -0,0 +1 @@
+task :ci => [ :verify_measurements, 'spec' ]

data/tasks/spec.rake

@@ -0,0 +1,18 @@
+require 'rspec/core/rake_task'
+
+spec_defaults = lambda do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+
+begin
+  task(:default).clear
+  task(:spec).clear
+
+  RSpec::Core::RakeTask.new(:spec, &spec_defaults)
+rescue LoadError
+  task :spec do
+    abort 'rspec is not available. In order to run spec, you must: gem install rspec'
+  end
+end
+
+task :default => :spec

data/tasks/yard.rake

@@ -0,0 +1,9 @@
+begin
+  require 'yard'
+
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yard do
+    abort 'YARD is not available. In order to run yard, you must: gem install yard'
+  end
+end

data/tasks/yardstick.rake

@@ -0,0 +1,19 @@
+begin
+  require 'pathname'
+  require 'yardstick/rake/measurement'
+  require 'yardstick/rake/verify'
+
+  # yardstick_measure task
+  Yardstick::Rake::Measurement.new
+
+  # verify_measurements task
+  Yardstick::Rake::Verify.new do |verify|
+    verify.threshold = 84.3
+  end
+rescue LoadError
+  %w[ yardstick_measure verify_measurements ].each do |name|
+    task name.to_s do
+      abort "Yardstick is not available. In order to run #{name}, you must: gem install yardstick"
+    end
+  end
+end