sbf-dm-core 1.3.0.beta

data/spec/support/core_ext/inheritable_attributes.rb

@@ -0,0 +1,46 @@
+class Class
+  def class_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if defined?(@#{ivar})
+          return nil      if self.object_id == #{self.object_id}
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil?
+          @#{ivar} = DataMapper::Ext.try_dup(ivar)
+        end
+      RUBY
+
+      unless instance_reader == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end
+    end
+  end
+
+  def class_inheritable_writer(*ivars)
+    instance_writer = ivars.pop[:instance_writer] if ivars.last.is_a?(Hash)
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}=(obj)
+          @#{ivar} = obj
+        end
+      RUBY
+      unless instance_writer == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}=(obj) self.class.#{ivar} = obj end
+        RUBY
+      end
+    end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+end

data/spec/support/properties/huge_integer.rb

@@ -0,0 +1,17 @@
+module DataMapper
+  class Property
+    class HugeInteger < DataMapper::Property::String
+      def load(value)
+        value&.to_i
+      end
+
+      def dump(value)
+        value&.to_s
+      end
+
+      def typecast(value)
+        load(value)
+      end
+    end
+  end
+end

data/spec/unit/array_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../spec_helper'
+require 'dm-core/support/ext/array'
+require 'dm-core/support/mash'
+
+describe DataMapper::Ext::Array do
+  before :all do
+    @array = [ [ :a, [ 1 ] ], [ :b, [ 2 ] ], [ :c, [ 3 ] ] ].freeze
+  end
+
+  describe '.to_mash' do
+    before :all do
+      @return = DataMapper::Ext::Array.to_mash(@array)
+    end
+
+    it 'returns a Mash' do
+      expect(@return).to be_kind_of(DataMapper::Mash)
+    end
+
+    it 'returns expected value' do
+      expect(@return).to eq({'a' => [1], 'b' => [2], 'c' => [3]})
+    end
+  end
+end

data/spec/unit/blank_spec.rb

@@ -0,0 +1,73 @@
+require_relative '../spec_helper'
+require 'dm-core/support/ext/blank'
+
+describe 'DataMapper::Ext.blank?', Object do
+  it 'is blank if it is nil' do
+    object = Object.new
+    class << object
+      def nil?; true end
+    end
+    expect(DataMapper::Ext.blank?(object)).to eq true
+  end
+
+  it 'is blank if it is empty' do
+    expect(DataMapper::Ext.blank?({})).to eq true
+    expect(DataMapper::Ext.blank?([])).to eq true
+  end
+
+  it 'is not blank if not nil or empty' do
+    expect(DataMapper::Ext.blank?(Object.new)).to eq false
+    expect(DataMapper::Ext.blank?([nil])).to eq false
+    expect(DataMapper::Ext.blank?({nil => 0})).to eq false
+  end
+end
+
+describe 'DataMapper::Ext.blank?', Numeric do
+  it 'is never be blank' do
+    expect(DataMapper::Ext.blank?(1)).to eq false
+  end
+end
+
+describe 'DataMapper::Ext.blank?', NilClass do
+  it 'is always blank' do
+    expect(DataMapper::Ext.blank?(nil)).to eq true
+  end
+end
+
+describe 'DataMapper::Ext.blank?', TrueClass do
+  it 'is never blank' do
+    expect(DataMapper::Ext.blank?(true)).to eq false
+  end
+end
+
+describe 'DataMapper::Ext.blank?', FalseClass do
+  it 'is always blank' do
+    expect(DataMapper::Ext.blank?(false)).to eq true
+  end
+end
+
+describe 'DataMapper::Ext.blank?', String do
+  it 'is blank if empty' do
+    expect(DataMapper::Ext.blank?('')).to eq true
+  end
+
+  it 'is blank if it only contains whitespace' do
+    expect(DataMapper::Ext.blank?(' ')).to eq true
+    expect(DataMapper::Ext.blank?(" \r \n \t ")).to eq true
+  end
+
+  it 'is not blank if it contains non-whitespace' do
+    expect(DataMapper::Ext.blank?(' a ')).to eq false
+  end
+end
+
+describe 'DataMapper::Ext.blank?', 'object with #blank?' do
+  subject { DataMapper::Ext.blank?(object) }
+
+  let(:return_value) { double('Return Value') }
+  let(:object) { double('Object', blank?: return_value) }
+
+  it 'returns the object#blank? result if supported' do
+    is_expected.to equal(return_value)
+  end
+end

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

@@ -0,0 +1,26 @@
+require_relative '../../../spec_helper'
+require 'dm-core/support/ordered_set'
+require_relative 'shared/append_spec'
+
+describe 'DataMapper::OrderedSet#<<' do
+  subject { set << entry2 }
+
+  let(:set)    { DataMapper::OrderedSet.new([ entry1 ]) }
+  let(:entry1) { Object.new                             }
+
+  before do
+    @old_index = set.index(entry1)
+  end
+
+  context 'when appending a not yet included entry' do
+    let(:entry2) { Object.new }
+
+    it_behaves_like 'DataMapper::OrderedSet#<< when appending a not yet included entry'
+  end
+
+  context 'when updating an already included entry' do
+    let(:entry2) { entry1 }
+
+    it_behaves_like 'DataMapper::OrderedSet#<< when updating an already included entry'
+  end
+end

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

@@ -0,0 +1,24 @@
+require_relative '../../../spec_helper'
+require 'dm-core/support/ordered_set'
+require_relative 'shared/clear_spec'
+
+describe 'DataMapper::OrderedSet#clear' do
+  subject { ordered_set.clear }
+
+  let(:ordered_set) { DataMapper::OrderedSet.new(entries) }
+
+  let(:entry1) { 1 }
+  let(:entry2) { 2 }
+
+  context 'when no entries are present' do
+    let(:entries) { [] }
+
+    it_behaves_like 'DataMapper::OrderedSet#clear when no entries are present'
+  end
+
+  context 'when entries are present' do
+    let(:entries) { [ entry1, entry2 ] }
+
+    it_behaves_like 'DataMapper::OrderedSet#clear when entries are present'
+  end
+end

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

@@ -0,0 +1,28 @@
+require_relative '../../../spec_helper'
+require 'dm-core/support/ordered_set'
+require_relative 'shared/delete_spec'
+
+describe 'DataMapper::OrderedSet#delete' do
+  subject { ordered_set }
+
+  let(:ordered_set) { DataMapper::OrderedSet.new([ entry1, entry2, entry3 ]) }
+  let(:entry1)      { 1                                                      }
+  let(:entry2)      { 2                                                      }
+  let(:entry3)      { 3                                                      }
+
+  before do
+    ordered_set.delete(entry)
+  end
+
+  context 'when deleting an already included entry' do
+    let(:entry) { entry1 }
+
+    it_behaves_like 'DataMapper::OrderedSet#delete when deleting an already included entry'
+  end
+
+  context 'when deleting a not yet included entry' do
+    let(:entry) { 4 }
+
+    it_behaves_like 'DataMapper::OrderedSet#delete when deleting a not yet included entry'
+  end
+end

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

@@ -0,0 +1,19 @@
+require_relative '../../../spec_helper'
+require 'dm-core/support/ordered_set'
+require_relative 'shared/each_spec'
+
+describe 'DataMapper::OrderedSet' do
+  subject { DataMapper::OrderedSet.new }
+
+  it_behaves_like 'DataMapper::OrderedSet'
+end
+
+describe 'DataMapper::OrderedSet#each' do
+  subject { set.each { |entry| yields << entry } }
+
+  let(:set)    { DataMapper::OrderedSet.new([ entry ]) }
+  let(:entry)  { 1                                     }
+  let(:yields) { []                                    }
+
+  it_behaves_like 'DataMapper::OrderedSet#each'
+end

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

@@ -0,0 +1,20 @@
+require_relative '../../../spec_helper'
+require 'dm-core/support/ordered_set'
+require_relative 'shared/empty_spec'
+
+describe 'DataMapper::OrderedSet#empty?' do
+  subject { set.empty? }
+
+  context 'with no entries in it' do
+    let(:set) { DataMapper::OrderedSet.new }
+
+    it_behaves_like 'DataMapper::OrderedSet#empty? with no entries in it'
+  end
+
+  context 'with entries in it' do
+    let(:set)   { DataMapper::OrderedSet.new([ entry ]) }
+    let(:entry) { 1                                     }
+
+    it_behaves_like 'DataMapper::OrderedSet#empty? with entries in it'
+  end
+end

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

@@ -0,0 +1,22 @@
+require_relative '../../../spec_helper'
+require 'dm-core/support/ordered_set'
+require_relative 'shared/entries_spec'
+
+describe 'DataMapper::OrderedSet#entries' do
+  subject { ordered_set.entries }
+
+  let(:ordered_set) { set }
+
+  context 'with no entries' do
+    let(:set) { DataMapper::OrderedSet.new }
+
+    it_behaves_like 'DataMapper::OrderedSet#entries with no entries'
+  end
+
+  context 'with entries' do
+    let(:set)   { DataMapper::OrderedSet.new([ entry ]) }
+    let(:entry) { 1                                     }
+
+    it_behaves_like 'DataMapper::OrderedSet#entries with entries'
+  end
+end

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

@@ -0,0 +1,51 @@
+require_relative '../../../spec_helper'
+require 'dm-core/support/ordered_set'
+
+describe 'DataMapper::OrderedSet#eql?' do
+  subject { ordered_set.eql?(other) }
+
+  let(:original_entry)  { 1                                              }
+  let(:ordered_set)     { DataMapper::OrderedSet.new([ original_entry ]) }
+
+  context 'with the same ordered_set' do
+    let(:other) { ordered_set }
+
+    it { is_expected.to be(true) }
+
+    it 'is symmetric' do
+      is_expected.to eq other.eql?(ordered_set)
+    end
+  end
+
+  context 'with equivalent ordered_set' do
+    let(:other) { ordered_set.dup }
+
+    it { is_expected.to be(true) }
+
+    it 'is symmetric' do
+      is_expected.to eq other.eql?(ordered_set)
+    end
+  end
+
+  context 'with both containing no ordered_set' do
+    let(:ordered_set) { DataMapper::OrderedSet.new }
+    let(:other)       { DataMapper::OrderedSet.new }
+
+    it { is_expected.to be(true) }
+
+    it 'is symmetric' do
+      is_expected.to eq other.eql?(ordered_set)
+    end
+  end
+
+  context 'with different ordered_set' do
+    let(:different_entry) { 2                                               }
+    let(:other)           { DataMapper::OrderedSet.new([ different_entry ]) }
+
+    it { is_expected.to be(false) }
+
+    it 'is symmetric' do
+      is_expected.to eq other.eql?(ordered_set)
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require_relative '../../../spec_helper'
+require 'dm-core/support/ordered_set'
+
+module DataMapper::Specs
+
+  # Used to test duck typing behavior
+  class OrderedSetDuck
+    attr_reader :entries
+
+    def initialize(columns = [])
+      @entries = DataMapper::OrderedSet.new
+    end
+  end
+end
+
+describe 'DataMapper::OrderedSet#==' do
+  subject { ordered_set == other }
+
+  let(:original_entry)  { 1                                              }
+  let(:ordered_set)     { DataMapper::OrderedSet.new([ original_entry ]) }
+
+  context 'with the same ordered_set' do
+    let(:other) { ordered_set }
+
+    it { is_expected.to be(true) }
+
+    it 'is symmetric' do
+      is_expected.to eq(other == ordered_set)
+    end
+  end
+
+  context 'with equivalent ordered_set' do
+    let(:other) { ordered_set.dup }
+
+    it { is_expected.to be(true) }
+
+    it 'is symmetric' do
+      is_expected.to eq(other == ordered_set)
+    end
+  end
+
+  # TODO This probably needs more thought
+  context 'with a class that quacks like OrderedSet and is equivalent otherwise' do
+    let(:other) { DataMapper::Specs::OrderedSetDuck.new([ original_entry ]) }
+
+    it { is_expected.to be(false) }
+
+    it 'is symmetric' do
+      is_expected.to eq(other == ordered_set)
+    end
+  end
+
+  context 'with a subclass that is equivalent otherwise' do
+    let(:other) { Class.new(DataMapper::OrderedSet).new([ original_entry ]) }
+
+    it { is_expected.to be(true) }
+
+    it 'is symmetric' do
+      is_expected.to eq(other == ordered_set)
+    end
+  end
+
+  context 'with both containing no ordered_set' do
+    let(:ordered_set) { DataMapper::OrderedSet.new }
+    let(:other)       { DataMapper::OrderedSet.new }
+
+    it { is_expected.to be(true) }
+
+    it 'is symmetric' do
+      is_expected.to eq(other == ordered_set)
+    end
+  end
+
+  context 'with different ordered_set' do
+    let(:different_entry) { 2                                               }
+    let(:other)           { DataMapper::OrderedSet.new([ different_entry ]) }
+
+    it { is_expected.to be(false) }
+
+    it 'is symmetric' do
+      is_expected.to eq(other == ordered_set)
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require_relative '../../../spec_helper'
+require 'dm-core/support/ordered_set'
+
+describe 'DataMapper::OrderedSet#hash' do
+  subject { ordered_set.hash }
+
+  let(:entry)       { 1                                     }
+  let(:ordered_set) { DataMapper::OrderedSet.new([ entry ]) }
+
+  it { is_expected.to be_kind_of(Integer) }
+  it { is_expected.to eq ordered_set.class.hash ^ ordered_set.entries.hash }
+end

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

@@ -0,0 +1,23 @@
+require_relative '../../../spec_helper'
+require 'dm-core/support/ordered_set'
+require_relative 'shared/include_spec'
+
+describe 'DataMapper::OrderedSet#include?' do
+  subject { ordered_set.include?(entry) }
+
+  let(:ordered_set) { set }
+
+  context 'when the entry is present' do
+    let(:set)   { DataMapper::OrderedSet.new([ entry ]) }
+    let(:entry) { 1                                     }
+
+    it_behaves_like 'DataMapper::OrderedSet#include? when the entry is present'
+  end
+
+  context 'when the entry is not present' do
+    let(:set)   { DataMapper::OrderedSet.new }
+    let(:entry) { 1                          }
+
+    it_behaves_like 'DataMapper::OrderedSet#include? when the entry is not present'
+  end
+end

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

@@ -0,0 +1,28 @@
+require_relative '../../../spec_helper'
+require 'dm-core/support/ordered_set'
+require_relative 'shared/index_spec'
+
+describe 'DataMapper::OrderedSet#index' do
+  subject { ordered_set.index(entry) }
+
+  context 'when the entry is not present' do
+    let(:ordered_set) { DataMapper::OrderedSet.new }
+    let(:entry)       { 1                          }
+
+    it_behaves_like 'DataMapper::OrderedSet#index when the entry is not present'
+  end
+
+  context 'when 1 entry is present' do
+    let(:ordered_set) { DataMapper::OrderedSet.new([ entry ]) }
+    let(:entry)       { 1                                     }
+
+    it_behaves_like 'DataMapper::OrderedSet#index when 1 entry is present'
+  end
+
+  context 'when 2 entries are present' do
+    let(:ordered_set) { DataMapper::OrderedSet.new([ 2, entry ]) }
+    let(:entry)       { 1                                        }
+
+    it_behaves_like 'DataMapper::OrderedSet#index when 2 entries are present'
+  end
+end

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

@@ -0,0 +1,32 @@
+require_relative '../../../spec_helper'
+require 'dm-core/support/ordered_set'
+require_relative 'shared/initialize_spec'
+
+describe 'DataMapper::OrderedSet#initialize' do
+
+  context 'when no entries are given' do
+    subject { DataMapper::OrderedSet.new }
+
+    it_behaves_like 'DataMapper::OrderedSet#initialize when no entries are given'
+  end
+
+  context 'when entries are given' do
+    subject { DataMapper::OrderedSet.new(entries) }
+
+    context 'and they do not contain duplicates' do
+      let(:entries) { [ entry1, entry2 ] }
+      let(:entry1)  { 1                  }
+      let(:entry2)  { 2                  }
+
+      it_behaves_like 'DataMapper::OrderedSet#initialize when entries are given and they do not contain duplicates'
+    end
+
+    context 'and they contain duplicates' do
+      let(:entries) { [ entry1, entry2 ] }
+      let(:entry1)  { 1                  }
+      let(:entry2)  { 1                  }
+
+      it_behaves_like 'DataMapper::OrderedSet#initialize when entries are given and they contain duplicates'
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require_relative '../../../spec_helper'
+require 'dm-core/support/ordered_set'
+require_relative 'shared/merge_spec'
+
+describe 'DataMapper::OrderedSet#merge' do
+
+  context 'when merging two empty sets' do
+    subject { ordered_set.merge([]) }
+
+    let(:ordered_set) { set                        }
+    let(:set)         { DataMapper::OrderedSet.new }
+
+    it_behaves_like 'DataMapper::OrderedSet#merge when merging two empty sets'
+  end
+
+  context 'when merging a set with already present entries' do
+    subject { ordered_set.merge([ entry ]) }
+
+    let(:ordered_set) { set                                   }
+    let(:set)         { DataMapper::OrderedSet.new([ entry ]) }
+    let(:entry)       { 1                                     }
+
+    it_behaves_like 'DataMapper::OrderedSet#merge when merging a set with already present entries'
+  end
+
+  context 'when merging a set with not yet present entries' do
+    subject { ordered_set.merge([ entry2 ]) }
+
+    let(:ordered_set) { set                                    }
+    let(:set)         { DataMapper::OrderedSet.new([ entry1 ]) }
+    let(:entry1)      { 1                                      }
+    let(:entry2)      { 2                                      }
+
+    it_behaves_like 'DataMapper::OrderedSet#merge when merging a set with not yet present entries'
+  end
+end

data/spec/unit/data_mapper/ordered_set/shared/append_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../../../../spec_helper'
+
+shared_examples 'DataMapper::OrderedSet#<< when appending a not yet included entry' do
+  its(:size) { is_expected.to eq 2 }
+  its(:entries) { is_expected.to include(entry1) }
+  its(:entries) { is_expected.to include(entry2) }
+
+  it 'does not alter the position of the existing entry' do
+    expect(subject.entries.index(entry1)).to eq @old_index
+  end
+
+  it 'appends columns at the end of the set' do
+    expect(subject.entries.index(entry2)).to eq @old_index + 1
+  end
+end
+
+shared_examples 'DataMapper::OrderedSet#<< when updating an already included entry' do
+  its(:size) { is_expected.to eq 1 }
+  its(:entries) { is_expected.to include(entry2) }
+
+  it 'does not alter the position of the existing entry' do
+    expect(subject.entries.index(entry2)).to eq @old_index
+  end
+end

data/spec/unit/data_mapper/ordered_set/shared/clear_spec.rb

@@ -0,0 +1,9 @@
+require_relative '../../../../spec_helper'
+
+shared_examples 'DataMapper::OrderedSet#clear when no entries are present' do
+  it { is_expected.to be_empty }
+end
+
+shared_examples 'DataMapper::OrderedSet#clear when entries are present' do
+  it { is_expected.to be_empty }
+end

data/spec/unit/data_mapper/ordered_set/shared/delete_spec.rb

@@ -0,0 +1,25 @@
+require_relative '../../../../spec_helper'
+
+shared_examples 'DataMapper::OrderedSet#delete when deleting an already included entry' do
+  its(:entries) { is_expected.not_to include(entry1) }
+  its(:entries) { is_expected.to include(entry2) }
+  its(:entries) { is_expected.to include(entry3) }
+
+  it 'corrects the index' do
+    expect(ordered_set.index(entry1)).to be_nil
+    expect(ordered_set.index(entry2)).to eq 0
+    expect(ordered_set.index(entry3)).to eq 1
+  end
+end
+
+shared_examples 'DataMapper::OrderedSet#delete when deleting a not yet included entry' do
+  its(:entries) { is_expected.to include(entry1) }
+  its(:entries) { is_expected.to include(entry2) }
+  its(:entries) { is_expected.to include(entry3) }
+
+  it 'does not alter the index' do
+    expect(ordered_set.index(entry1)).to eq 0
+    expect(ordered_set.index(entry2)).to eq 1
+    expect(ordered_set.index(entry3)).to eq 2
+  end
+end

data/spec/unit/data_mapper/ordered_set/shared/each_spec.rb

@@ -0,0 +1,17 @@
+require_relative '../../../../spec_helper'
+
+shared_examples 'DataMapper::OrderedSet' do
+  it { is_expected.to be_kind_of(Enumerable) }
+
+  it 'case matches Enumerable' do
+    expect(subject.is_a?(Enumerable)).to be(true)
+  end
+end
+
+shared_examples 'DataMapper::OrderedSet#each' do
+  it { is_expected.to equal(set) }
+
+  it 'yields each column' do
+    expect { subject }.to change { yields.dup }.from([]).to([entry])
+  end
+end

data/spec/unit/data_mapper/ordered_set/shared/empty_spec.rb

@@ -0,0 +1,9 @@
+require_relative '../../../../spec_helper'
+
+shared_examples 'DataMapper::OrderedSet#empty? with no entries in it' do
+  it { is_expected.to be(true) }
+end
+
+shared_examples 'DataMapper::OrderedSet#empty? with entries in it' do
+  it { is_expected.to be(false) }
+end