datamappify 0.50.0 → 0.51.0

data/lib/datamappify/entity/composable.rb

@@ -12,14 +12,69 @@ module Datamappify
         #
         # @return [void]
         def attributes_from(entity_class, options = {})
-          entity_class.attribute_set.each do |attribute|
+          setup_attributes(entity_class, options)
+          setup_validators(entity_class, options)
+          run_validators
+        end
+
+        private
+
+        # @param (see #attributes_from)
+        #
+        # @return (see #attributes_from)
+        def setup_attributes(entity_class, options)
+          entity_class.attribute_set.dup.each do |attribute|
             unless excluded_attributes(entity_class).include?(attribute.name)
-              self.attribute_set << tweak_attribute!(attribute, options)
+              self.attribute_set << tweak_attribute(attribute, options)
             end
           end
         end
 
-        private
+        # @param (see #attributes_from)
+        #
+        # @return (see #attributes_from)
+        def setup_validators(entity_class, options)
+          if options[:prefix_with]
+            rename_validators(entity_class, options[:prefix_with])
+          else
+            entity_class._validators.each { |k, v| self._validators[k] = v.dup }
+          end
+        end
+
+        # @return [void]
+        def run_validators
+          self._validators.each do |_, validators|
+            validators.each do |validator|
+              validate(validator, validator.options)
+            end
+          end
+        end
+
+        # @param entity_class [Entity]
+        #
+        # @param prefix [Symbol]
+        #
+        # @return [void]
+        def rename_validators(entity_class, prefix)
+          entity_class._validators.each do |attribute_name, validators|
+            dup_validators = validators.dup
+
+            dup_validators.each do |validator|
+              rename_validator_attributes(validator, prefix)
+            end
+
+            self._validators[:"#{prefix}_#{attribute_name}"] = dup_validators
+          end
+        end
+
+        # @param validator [Validator]
+        #
+        # @param prefix (see #rename_validators)
+        #
+        # @return [void]
+        def rename_validator_attributes(validator, prefix)
+          validator.instance_variable_set :@attributes, validator.attributes.map { |name| :"#{prefix}_#{name}" }
+        end
 
         # @param entity_class [Entity]
         #
@@ -33,8 +88,8 @@ module Datamappify
         # @param options [Hash]
         #
         # @return [Virtus::Attribute]
-        def tweak_attribute!(attribute, options)
-          prefix_attribute_name!(attribute, options[:prefix_with]) if options[:prefix_with]
+        def tweak_attribute(attribute, options)
+          prefix_attribute_name(attribute, options[:prefix_with]) if options[:prefix_with]
 
           attribute
         end
@@ -44,8 +99,9 @@ module Datamappify
         # @param prefix [Symbol]
         #
         # @return [void]
-        def prefix_attribute_name!(attribute, prefix)
-          attribute.instance_variable_set :@name, :"#{prefix}_#{attribute.name}"
+        def prefix_attribute_name(attribute, prefix)
+          name = attribute.instance_variable_set :@name, :"#{prefix}_#{attribute.name}"
+          attribute.instance_variable_set :@instance_variable_name, "@#{name}".to_sym
         end
       end
     end

data/lib/datamappify/entity/relation.rb

@@ -33,7 +33,7 @@ module Datamappify
 
             def #{entity_name}=(entity)
               @#{entity_name}        = entity
-              self.#{entity_name}_id = entity.id
+              self.#{entity_name}_id = entity.nil? ? nil : entity.id
             end
           CODE
         end

data/lib/datamappify/repository/inheritable.rb

@@ -0,0 +1,28 @@
+module Datamappify
+  module Repository
+    module Inheritable
+      # @param klass [Repository]
+      #
+      # @return [void]
+      def inherited(klass)
+        klass.class_eval { include Repository }
+
+        setup_data_mapper(klass)
+
+        klass.data_mapper.default_source_class
+      end
+
+      private
+
+      # @param klass (see #inherited)
+      #
+      # @return [void]
+      def setup_data_mapper(klass)
+        klass.for_entity       self.data_mapper.entity_class
+        klass.default_provider self.data_mapper.default_provider_name
+
+        klass.data_mapper.custom_mapping = self.data_mapper.custom_mapping.dup
+      end
+    end
+  end
+end

data/lib/datamappify/repository/query_method/find_multiple.rb

@@ -14,7 +14,7 @@ module Datamappify
         # @return [Array<Entity>]
         def perform
           dispatch_criteria_to_default_source(
-            :FindMultiple, data_mapper.entity_class, @criteria, attributes
+            :FindMultiple, data_mapper.entity_class, @criteria, data_mapper.attributes
           )
         end
 
@@ -22,12 +22,6 @@ module Datamappify
         def reader?
           true
         end
-
-        private
-
-        def attributes
-          data_mapper.attributes_from_default_source
-        end
       end
     end
   end

data/lib/datamappify/repository/query_method/method.rb

@@ -73,10 +73,10 @@ module Datamappify
         # @param entity [Entity]
         #
         # @return [void]
-        def dispatch_criteria_to_providers(criteria_name, entity)
+        def dispatch_criteria_to_providers(criteria_name, entity, *args)
           attributes_walker(entity) do |provider_name, source_class, attributes|
             data_mapper.provider(provider_name).build_criteria(
-              criteria_name, source_class, entity, attributes
+              criteria_name, source_class, entity, attributes, *args
             )
           end
         end

data/lib/datamappify/repository/query_methods.rb

@@ -20,12 +20,16 @@ module Datamappify
         QueryMethod::Exists.new(query_options, entity).perform
       end
 
-      # @param id [Integer]
-      #   an entity id or a collection of entity ids
+      # @param criteria [Integer, Hash]
+      #   an entity id or a hash containing criteria
       #
       # @return [Entity, nil]
-      def find(id)
-        QueryMethod::Find.new(query_options, id).perform
+      def find(criteria)
+        if criteria.is_a?(Integer)
+          QueryMethod::Find.new(query_options, criteria).perform
+        else
+          QueryMethod::FindMultiple.new(query_options, criteria).perform
+        end
       end
 
       # Returns a collection of all the entities in the repository

data/lib/datamappify/repository.rb

@@ -2,6 +2,7 @@ require 'datamappify/repository/lazy_checking'
 require 'datamappify/repository/mapping_dsl'
 require 'datamappify/repository/unit_of_work'
 require 'datamappify/repository/query_methods'
+require 'datamappify/repository/inheritable'
 require 'datamappify/data'
 
 module Datamappify
@@ -22,6 +23,7 @@ module Datamappify
         include LazyChecking
         extend  MappingDSL
         include QueryMethods
+        extend  Inheritable
       end
     end
 

data/lib/datamappify/version.rb

@@ -1,3 +1,3 @@
 module Datamappify
-  VERSION = '0.50.0'
+  VERSION = '0.51.0'
 end

data/spec/entity/composable_spec.rb

@@ -1,25 +1,48 @@
 require 'spec_helper'
 
 describe Datamappify::Entity do
-  subject { Computer.new }
-
-  before do
-    subject.cpu                 = '286'
-    subject.ram                 = 8192
-    subject.hdd                 = 65536
-    subject.gfx                 = 'Voodoo'
-    subject.software_os         = 'OS X'
-    subject.software_osx_id     = 1
-    subject.software_windows_id = 2
-    subject.software_linux_id   = 3
+  subject do
+    Computer.new({
+      :brand               => 'Fruit',
+      :cpu                 => '286',
+      :ram                 => 8192,
+      :hdd                 => 65536,
+      :gfx                 => 'Voodoo',
+      :vendor              => 'Compaq',
+      :software_os         => 'OS X',
+      :software_osx_id     => 1,
+      :software_windows_id => 2,
+      :software_linux_id   => 3,
+      :software_vendor     => 'Lotus'
+    })
   end
 
   its(:cpu)                 { should == '286' }
   its(:ram)                 { should == 8192 }
   its(:hdd)                 { should == 65536 }
   its(:gfx)                 { should == 'Voodoo' }
+  its(:vendor)              { should == 'Compaq' }
   its(:software_os)         { should == 'OS X' }
   its(:software_osx_id)     { should == 1 }
   its(:software_windows_id) { should == 2 }
   its(:software_linux_id)   { should == 3 }
+  its(:software_vendor)     { should == 'Lotus' }
+
+  describe "validation" do
+    context "valid" do
+      it { should be_valid }
+    end
+
+    context "invalid" do
+      after do
+        subject.should be_invalid
+      end
+
+      it('brand')       { subject.brand       = nil }
+      it('ram')         { subject.ram         = 42 }
+      it('hdd')         { subject.hdd         = 42 }
+      it('hdd')         { subject.hdd         = 65537 }
+      it('software_os') { subject.software_os = nil }
+    end
+  end
 end

data/spec/entity/inheritance_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+shared_examples_for "entity inheritance" do |data_provider|
+  context "#{data_provider}" do
+    let!(:admin_user_repository) { "AdminUserRepository#{data_provider}".constantize }
+    let(:admin_user)             { admin_user_repository.save!(AdminUser.new(:first_name => 'Batman', :driver_license => 'ARKHAMCITY', :level => 42)) }
+
+    describe "persistence" do
+      subject { admin_user }
+
+      it_behaves_like "entity inheritance attributes"
+    end
+
+    describe "finder" do
+      subject { admin_user_repository.find(admin_user.id) }
+
+      it_behaves_like "entity inheritance attributes"
+    end
+  end
+end
+
+shared_examples_for "entity inheritance attributes" do
+  its(:id)             { should be_kind_of(Integer) }
+  its(:first_name)     { should == 'Batman' }
+  its(:driver_license) { should == 'ARKHAMCITY' }
+  its(:level)          { should == 42 }
+end
+
+describe Datamappify::Entity do
+  DATA_PROVIDERS.each do |data_provider|
+    it_behaves_like "entity inheritance", data_provider
+  end
+end

data/spec/entity/relation_spec.rb

@@ -1,19 +1,21 @@
 require 'spec_helper'
 
 shared_examples_for "entity relations" do |data_provider|
-  include_context "user repository", data_provider
+  context "#{data_provider}" do
+    include_context "user repository", data_provider
 
-  let!(:comment_repository) { "CommentRepository#{data_provider}".constantize }
-  let(:comment)             { comment_repository.save!(Comment.new) }
+    let!(:comment_repository) { "CommentRepository#{data_provider}".constantize }
+    let(:comment)             { comment_repository.save!(Comment.new) }
 
-  subject { comment }
+    subject { comment }
 
-  before do
-    subject.user = existing_user
-  end
+    before do
+      subject.user = existing_user
+    end
 
-  its(:user_id) { should == existing_user.id }
-  its(:user)    { should == existing_user }
+    its(:user_id) { should == existing_user.id }
+    its(:user)    { should == existing_user }
+  end
 end
 
 describe Datamappify::Entity do

data/spec/repository/finders_spec.rb

@@ -7,17 +7,115 @@ shared_examples_for "finders" do |data_provider|
   let!(:existing_user_2) { user_repository.save(new_valid_user.dup) }
 
   context "#{data_provider}" do
-    describe "#all" do
-      it "finds all entities in a repository" do
-        user_repository.all.should have(3).users
+    describe "#find" do
+      describe "by id" do
+        subject { user_repository.find(existing_user.id) }
+
+        its(:id) { should == existing_user.id }
       end
 
-      it "finds first entity" do
-        user_repository.all.first.should == existing_user
+      describe "by criteria" do
+        before do
+          user_repository.save!(User.new(:first_name => 'Mary', :driver_license => 'IDONTCARE'))
+          user_repository.save!(User.new(:first_name => 'Bob', :driver_license => 'IDONTCARE'))
+          user_repository.save!(User.new(:first_name => 'Jane', :driver_license => 'NO_LICENSE'))
+          user_repository.save!(User.new(:first_name => 'Bob', :driver_license => 'NO_LICENSE'))
+          user_repository.save!(User.new(:first_name => 'Bob', :driver_license => 'IDONTCARE'))
+          user_repository.save!(User.new(:first_name => 'Bobb', :driver_license => 'IDONTCARE'))
+          user_repository.save!(User.new(:first_name => 'John', :driver_license => 'IDONTCARE'))
+        end
+
+        describe "by attribute that does not exist" do
+          let(:records) { user_repository.find(:blah => 'Bob') }
+
+          it { expect { records }.to raise_exception(Datamappify::Data::EntityAttributeInvalid) }
+        end
+
+        describe "by primary attribute" do
+          let(:records) { user_repository.find(:first_name => 'Bob') }
+          subject       { records }
+
+          it { should have(3).users }
+
+          describe "record" do
+            subject { records.first }
+
+            its(:first_name)     { should == 'Bob' }
+            its(:driver_license) { should == 'IDONTCARE' }
+          end
+        end
+
+        describe "by secondary attribute" do
+          let(:records) { user_repository.find(:driver_license => 'NO_LICENSE') }
+          subject       { records }
+
+          it { should have(2).user }
+
+          describe "record" do
+            subject { records.first }
+
+            its(:first_name)     { should == 'Jane' }
+            its(:driver_license) { should == 'NO_LICENSE' }
+          end
+        end
+
+        describe "by primary and secondary attributes" do
+          context "example 1" do
+            let(:records) { user_repository.find(:first_name => 'Bob', :driver_license => 'NO_LICENSE') }
+            subject       { records }
+
+            it { should have(1).user }
+
+            describe "record" do
+              subject { records.first }
+
+              its(:first_name)     { should == 'Bob' }
+              its(:driver_license) { should == 'NO_LICENSE' }
+            end
+          end
+
+          context "example 2" do
+            let(:records) { user_repository.find(:first_name => 'Bob', :driver_license => 'IDONTCARE') }
+            subject       { records }
+
+            it { should have(2).users }
+
+            describe "record" do
+              subject { records.first }
+
+              its(:first_name)     { should == 'Bob' }
+              its(:driver_license) { should == 'IDONTCARE' }
+            end
+          end
+
+          context "example 3" do
+            subject { user_repository.find(:first_name => 'Nope', :driver_license => 'IDONTCARE') }
+
+            it { should be_empty }
+          end
+
+          context "example 4" do
+            subject { user_repository.find(:first_name => 'Bob', :driver_license => 'NOPE') }
+
+            it { should be_empty }
+          end
+        end
       end
+    end
+
+    describe "#all" do
+      let(:records) { user_repository.all }
+      subject       { records }
+
+      it { should have(3).users }
 
-      it "finds last entity" do
-        user_repository.all.last.should == existing_user_2
+      its(:first) { should == existing_user }
+      its(:last)  { should == existing_user_2 }
+
+      describe "record" do
+        subject { records.first }
+
+        its(:first_name) { should == existing_user.first_name }
       end
     end
   end
@@ -28,3 +126,83 @@ describe Datamappify::Repository do
     it_behaves_like "finders", data_provider
   end
 end
+
+describe "attributes from different data providers" do
+  before do
+    pending
+
+    HeroUserRepository.save!(HeroUser.new(:first_name => 'Fred', :last_name => 'Wu'))
+    HeroUserRepository.save!(HeroUser.new(:first_name => 'Sheldon', :last_name => 'Cooper'))
+    HeroUserRepository.save!(HeroUser.new(:first_name => 'Fred', :last_name => 'Cooper'))
+  end
+
+  context "example 1" do
+    let(:records) { HeroUserRepository.find(:first_name => 'Fred') }
+    subject       { records }
+
+    it { should have(2).users }
+
+    describe "record" do
+      subject { records.first }
+
+      its(:first_name) { should == 'Fred' }
+      its(:last_name)  { should == 'Wu' }
+    end
+  end
+
+  context "example 2" do
+    let(:records) { HeroUserRepository.find(:first_name => 'Sheldon') }
+    subject       { records }
+
+    it { should have(1).user }
+
+    describe "record" do
+      subject { records.first }
+
+      its(:first_name) { should == 'Sheldon' }
+      its(:last_name)  { should == 'Cooper' }
+    end
+  end
+
+  context "example 3" do
+    let(:records) { HeroUserRepository.find(:last_name => 'Cooper') }
+    subject       { records }
+
+    it { should have(2).users }
+
+    describe "record" do
+      subject { records.first }
+
+      its(:first_name) { should == 'Sheldon' }
+      its(:last_name)  { should == 'Cooper' }
+    end
+  end
+
+  context "example 4" do
+    let(:records) { HeroUserRepository.find(:first_name => 'Sheldon', :last_name => 'Cooper') }
+    subject       { records }
+
+    it { should have(1).user }
+
+    describe "record" do
+      subject { records.first }
+
+      its(:first_name) { should == 'Sheldon' }
+      its(:last_name)  { should == 'Cooper' }
+    end
+  end
+
+  context "example 5" do
+    let(:records) { HeroUserRepository.find(:first_name => 'Leonard', :last_name => 'Cooper') }
+    subject       { records }
+
+    it { should be_empty }
+  end
+
+  context "example 6" do
+    let(:records) { HeroUserRepository.find(:first_name => 'Fred', :last_name => 'Woo') }
+    subject       { records }
+
+    it { should be_empty }
+  end
+end

data/spec/support/entities/admin_user.rb

@@ -0,0 +1,5 @@
+require_relative 'user'
+
+class AdminUser < User
+  attribute :level, Integer
+end

data/spec/support/entities/computer.rb

@@ -8,4 +8,6 @@ class Computer
 
   attributes_from ComputerHardware
   attributes_from ComputerSoftware, :prefix_with => :software
+
+  validates :brand, :presence => true
 end

data/spec/support/entities/computer_hardware.rb

@@ -5,4 +5,8 @@ class ComputerHardware
   attribute :ram, Integer
   attribute :hdd, Integer
   attribute :gfx, String
+  attribute :vendor, String
+
+  validates :ram, :hdd, :numericality => { :greater_than_or_equal_to => 4096 }
+  validates :hdd,       :numericality => { :less_than_or_equal_to => 65536 }
 end

data/spec/support/entities/computer_software.rb

@@ -2,8 +2,11 @@ class ComputerSoftware
   include Datamappify::Entity
 
   attribute :os, String
+  attribute :vendor, String
 
   references :osx
   references :windows
   references :linux
+
+  validates_presence_of :os
 end

data/spec/support/repositories/active_record/admin_user_repository.rb

@@ -0,0 +1,5 @@
+require_relative 'user_repository'
+
+class AdminUserRepositoryActiveRecord < UserRepositoryActiveRecord
+  for_entity AdminUser
+end

data/spec/support/repositories/sequel/admin_user_repository.rb

@@ -0,0 +1,5 @@
+require_relative 'user_repository'
+
+class AdminUserRepositorySequel < UserRepositorySequel
+  for_entity AdminUser
+end

data/spec/support/tables/active_record.rb

@@ -17,6 +17,7 @@ ActiveRecord::Migration.suppress_messages do
       t.string :first_name, :null => false
       t.string :surname
       t.integer :age
+      t.integer :level
       t.references :role
       t.timestamps
     end

data/spec/support/tables/sequel.rb

@@ -16,6 +16,7 @@ DB.create_table :users do
   String :first_name, :null => false
   String :surname
   Integer :age
+  Integer :level
   foreign_key :role_id
   DateTime :created_at
   DateTime :updated_at

data/spec/unit/entity/relation_spec.rb

@@ -15,14 +15,14 @@ module Datamappify::Entity
     subject { DummyEntity.new }
 
     describe "#references" do
+      let(:another_entity) { AnotherEntity.new.tap { |e| e.id = 42 } }
+
       it { should respond_to(:another_entity_id) }
       it { should respond_to(:another_entity_id=) }
       it { should respond_to(:another_entity) }
       it { should respond_to(:another_entity=) }
 
       describe "assigns the correct attribute" do
-        let(:another_entity) { AnotherEntity.new.tap { |e| e.id = 42 } }
-
         before do
           subject.another_entity = another_entity
         end
@@ -31,6 +31,16 @@ module Datamappify::Entity
         its(:another_entity)    { should == another_entity }
         its(:reference_keys)    { should include(:another_entity_id) }
       end
+
+      describe "assigns nil" do
+        before do
+          subject.another_entity = nil
+        end
+
+        its(:another_entity_id) { should be_nil }
+        its(:another_entity)    { should be_nil }
+        its(:reference_keys)    { should include(:another_entity_id) }
+      end
     end
   end
 end