datamappify 0.10.1 → 0.20.0

data/lib/datamappify/repository/dsl.rb

@@ -5,6 +5,15 @@ module Datamappify
         self.entity_class = entity_class
       end
 
+      def default_provider(provider_name)
+        self.class_eval { require "datamappify/data/provider/#{provider_name.to_s.underscore}" }
+
+        provider_namespace = "Datamappify::Data::#{provider_name}"
+
+        self.default_provider_class_name = provider_name.to_s
+        self.default_data_class_name     = self.entity_class.name
+      end
+
       def map_attribute(attribute, source)
         self.custom_attributes_mapping[attribute] = source
       end

data/lib/datamappify/repository/mapping_hash.rb

@@ -0,0 +1,8 @@
+module Datamappify
+  module Repository
+    class MappingHash < Hash
+      alias :field_names :keys
+      alias :attribute_names :values
+    end
+  end
+end

data/lib/datamappify/repository.rb

@@ -1,20 +1,21 @@
 require 'singleton'
-require 'datamappify/repository/persistence'
+require 'datamappify/util'
+require 'datamappify/repository/mapping_hash'
 require 'datamappify/repository/dsl'
 require 'datamappify/repository/attributes_mapper'
 
 module Datamappify
   module Repository
-    include Persistence
-
     def self.included(klass)
       klass.class_eval do
         mattr_accessor :entity_class
+        mattr_accessor :default_provider_class_name
+        mattr_accessor :default_data_class_name
         mattr_accessor :custom_attributes_mapping
         mattr_accessor :data_mapping
 
         klass.custom_attributes_mapping = {}
-        klass.data_mapping = {}
+        klass.data_mapping              = {}
 
         include Singleton
         extend DSL
@@ -23,6 +24,97 @@ module Datamappify
 
     def initialize
       AttributesMapper.new(self).build_data_classes
+      self
+    end
+
+    def find(id_or_ids)
+      entities = Array.wrap(id_or_ids).map { |id| entity_class.new(:id => id) }
+
+      data_mapping_walker do |provider_class_name, data_class_name, data_fields_mapping|
+        persistence_class(provider_class_name).new(
+          provider_class_name, entities, data_class_name
+        ).find(data_fields_mapping)
+      end
+
+      id_or_ids.is_a?(Array) ? entities : entities[0]
+    end
+
+    def save(entity_or_entities)
+      Array.wrap(entity_or_entities).each do |entity|
+        create_or_update(entity)
+      end
+
+      entity_or_entities
+    rescue Datamappify::Data::EntityInvalid
+      false
+    end
+
+    def save!(entity_or_entities)
+      save(entity_or_entities) || raise(Datamappify::Data::EntityNotSaved)
+    end
+
+    def destroy(id_ids_or_entity_entities)
+      ids = Array.wrap(id_ids_or_entity_entities).map do |id_or_entity|
+        Util.extract_entity_id(id_or_entity)
+      end
+
+      default_persistence.destroy(ids)
+    end
+
+    def destroy!(id_ids_or_entity_entities)
+      destroy(id_ids_or_entity_entities) || raise(Datamappify::Data::EntityNotDestroyed)
+    end
+
+    def method_missing(symbol, *args)
+      default_persistence.send symbol, *args
+    end
+
+    private
+
+    def default_persistence
+      persistence_class(default_provider_class_name).new(
+        default_provider_class_name, [], default_data_class_name
+      )
+    end
+
+    def persistence_class(provider_class_name)
+      "Datamappify::Data::Provider::#{provider_class_name}::Persistence".constantize
+    end
+
+    def create_or_update(entity)
+      raise Datamappify::Data::EntityInvalid.new(entity) if entity.invalid?
+
+      default_persistence.exists?(entity.id) ? update(entity) : create(entity)
+    end
+
+    def create(entity)
+      data_mapping_walker do |provider_class_name, data_class_name, data_fields_mapping|
+        persistence_class(provider_class_name).new(
+          provider_class_name, [entity], data_class_name
+        ).create(data_fields_mapping)
+      end
+
+      entity
+    end
+
+    def update(entity)
+      data_mapping_walker do |provider_class_name, data_class_name, data_fields_mapping|
+        persistence_class(provider_class_name).new(
+          provider_class_name, [entity], data_class_name
+        ).update(data_fields_mapping)
+      end
+
+      entity
+    end
+
+    def data_mapping_walker
+      default_persistence.transaction do
+        data_mapping.each do |provider_class_name, data_class_mapping|
+          data_class_mapping.each do |data_class_name, data_fields_mapping|
+            yield(provider_class_name, data_class_name, data_fields_mapping)
+          end
+        end
+      end
     end
   end
 end

data/lib/datamappify/util.rb

@@ -0,0 +1,13 @@
+module Datamappify
+  class Util
+    class << self
+      def attributes_filtered_by(entity, attribute_names)
+        entity.attributes.select { |attr| attribute_names.include?(attr) }
+      end
+
+      def extract_entity_id(id_or_entity)
+        id_or_entity.is_a?(Integer) ? id_or_entity : id_or_entity.id
+      end
+    end
+  end
+end

data/lib/datamappify/version.rb

@@ -1,3 +1,3 @@
 module Datamappify
-  VERSION = '0.10.1'
+  VERSION = '0.20.0'
 end

data/spec/entity_spec.rb

@@ -7,32 +7,33 @@ describe Datamappify::Entity do
 
   describe "attributes" do
     it "has defined attributes" do
-      user.first_name.must_be_nil
+      user.first_name.should be_nil
+      user.last_name.should be_nil
     end
 
     it "raises error on undefined attributes" do
-      -> { user.attribute_that_does_not_exist }.must_raise NoMethodError
+      -> { user.surname }.should raise_error(NoMethodError)
     end
 
     it "assigns an attribute" do
       user.first_name = 'Fred'
-      user.first_name.must_equal 'Fred'
+      user.first_name.should == 'Fred'
     end
 
     it "coerces an attribute" do
       user.age = '42'
-      user.age.must_be_kind_of Fixnum
-      user.age.must_equal 42
+      user.age.should be_kind_of(Fixnum)
+      user.age.should == 42
     end
   end
 
   describe "validations" do
     it "validates attributes" do
-      user.valid?.must_equal false
+      user.valid?.should == false
 
       user.first_name = 'Fred'
-      user.passport = 'FREDWU42'
-      user.valid?.must_equal true
+      user.driver_license = 'FREDWU42'
+      user.valid?.should == true
     end
   end
 end

data/spec/repository/persistence_spec.rb

@@ -1,95 +1,195 @@
 require_relative '../spec_helper'
 
-describe Datamappify::Repository do
-  let(:user_repository) { UserRepository.instance }
-  let(:user)            { User.new(:id => 1, :first_name => 'Fred', :gender => 'male', :passport => 'FREDWU42') }
-  let(:user_valid)      { User.new(:first_name => 'Batman', :gender => 'male', :passport => 'ARKHAMCITY') }
-  let(:user_invalid)    { User.new(:first_name => 'a') }
-
-  let(:has_db_user) do
-    Datamappify::Data::User.create!(:first_name => 'Fred', :sex => 'male')
-    Datamappify::Data::UserPassport.create!(:number => 'FREDWU42', :user_id => 1)
-  end
+shared_examples_for "repository persistence" do |data_provider|
+  let!(:user_repository)     { "UserRepository#{data_provider}".constantize.instance }
+  let(:existing_user)        { User.new(:id => 1, :first_name => 'Fred', :driver_license => 'FREDWU42') }
+  let(:new_valid_user)       { User.new(:first_name => 'Batman', :driver_license => 'ARKHAMCITY') }
+  let(:new_valid_user2)      { User.new(:first_name => 'Ironman', :driver_license => 'NEWYORKCITY') }
+  let(:new_invalid_user)     { User.new(:first_name => 'a') }
+  let(:new_invalid_user2)    { User.new(:first_name => 'b') }
+  let(:data_passports)       { "Datamappify::Data::#{data_provider}::UserPassport".constantize }
+  let(:data_driver_licenses) { "Datamappify::Data::#{data_provider}::UserDriverLicense".constantize }
 
   before do
-    user_repository
+    user_repository.save(existing_user)
   end
 
   describe "#find" do
-    it "found" do
-      has_db_user
+    describe "resource" do
+      let!(:user) { user_repository.save(existing_user) }
 
-      user_repository.find(1).must_equal user
-      user_repository.find([1]).must_equal [user]
-    end
+      it "found" do
+        user_repository.find(user.id).should == existing_user
+        user_repository.find([user.id]).should == [existing_user]
+      end
 
-    it "not found" do
-      user_repository.find(1).must_equal nil
+      it "not found" do
+        user_repository.find(42).should == nil
+      end
     end
 
-    it "partial found collection" do
-      has_db_user
+    describe "collection" do
+      let!(:user) { user_repository.save(existing_user) }
+
+      it "found" do
+        user_repository.find([user.id]).should == [existing_user]
+      end
+
+      it "partial found" do
+        user_repository.find([user.id, 42]).should == [existing_user]
+      end
 
-      user_repository.find([1, 2]).must_equal [user]
+      it "not found" do
+        user_repository.find([42, 255]).should == []
+      end
     end
   end
 
   describe "#save" do
     it "success" do
-      user_repository.save(user_valid)
-      user_repository.count.must_equal 1
+      new_user = nil
 
-      new_user = user_repository.find(1)
-      new_user.must_be_kind_of User
-      new_user.first_name.must_equal 'Batman'
-      new_user.passport.must_equal 'ARKHAMCITY'
+      expect { new_user = user_repository.save(new_valid_user) }.to change { user_repository.count }.by(1)
+
+      new_user.should be_kind_of(User)
+      new_user.first_name.should == 'Batman'
+      new_user.driver_license.should == 'ARKHAMCITY'
     end
 
     it "failure" do
-      -> { user_repository.save!(user_invalid) }.must_raise Datamappify::Data::EntityNotSaved
+      -> { user_repository.save!(new_invalid_user) }.should raise_error(Datamappify::Data::EntityNotSaved)
     end
 
     it "transaction" do
-      user_valid.driver_license = 'DEVOPS'
-      -> { user_repository.save(user_valid) }.must_raise ActiveRecord::StatementInvalid
+      new_valid_user.passport = 'DEVOPS'
+
+      save_action = Proc.new { -> { user_repository.save(new_valid_user) }.should raise_error }
 
-      user_repository.count.must_equal 0
-      Datamappify::Data::UserPassport.count.must_equal 0
-      Datamappify::Data::UserDriverLicense.count.must_equal 0
+      expect { save_action.call }.to change { user_repository.count }.by(0)
+      expect { save_action.call }.to change { data_passports.count }.by(0)
+      expect { save_action.call }.to change { data_driver_licenses.count }.by(0)
     end
-  end
 
-  it "updates an existing record" do
-    has_db_user
+    describe "update multiple entities" do
+      describe "#save" do
+        it "all successes" do
+          expect { user_repository.save([new_valid_user, new_valid_user2]) }.to change { user_repository.count }.by(2)
+        end
+
+        it "successes + failures" do
+          expect { user_repository.save([new_valid_user, new_invalid_user]) }.to change { user_repository.count }.by(1)
+        end
+
+        it "all failures" do
+          expect { user_repository.save([new_invalid_user, new_invalid_user2]) }.to change { user_repository.count }.by(0)
+        end
+      end
+
+      describe "#save!" do
+        it "all successes" do
+          expect { user_repository.save!([new_valid_user, new_valid_user2]) }.to change { user_repository.count }.by(2)
+        end
+
+        it "successes + failures" do
+          expect { -> { user_repository.save!([new_valid_user, new_invalid_user]) }.should raise_error(Datamappify::Data::EntityNotSaved) }.to change { user_repository.count }.by(1)
+        end
+
+        it "all failures" do
+          expect { -> { user_repository.save!([new_invalid_user, new_invalid_user2]) }.should raise_error(Datamappify::Data::EntityNotSaved) }.to change { user_repository.count }.by(0)
+        end
+      end
+    end
+
+    describe "update an existing entity" do
+      it "updates existing records" do
+        user = user_repository.find(1)
+
+        user.first_name = 'Vivian'
+        user.driver_license = 'LOCOMOTE'
+
+        updated_user = nil
+
+        expect { updated_user = user_repository.save(user) }.to change { user_repository.count }.by(0)
+
+        updated_user.first_name.should == 'Vivian'
+        updated_user.driver_license.should == 'LOCOMOTE'
+
+        persisted_user = user_repository.find(updated_user.id)
+
+        persisted_user.first_name.should == 'Vivian'
+        persisted_user.driver_license.should == 'LOCOMOTE'
+      end
+
+      it "updates existing and new records" do
+        user = user_repository.find(1)
 
-    user.first_name = 'Vivian'
-    user.gender = 'female'
-    user.passport = 'LOCOMOTE'
+        user.first_name = 'Vivian'
+        user.health_care = 'BATMANCAVE'
 
-    updated_user = user_repository.save(user)
-    updated_user.first_name.must_equal 'Vivian'
-    updated_user.gender.must_equal 'female'
-    updated_user.passport.must_equal 'LOCOMOTE'
+        updated_user = nil
 
-    persisted_user = user_repository.find(user.id)
-    persisted_user.first_name.must_equal 'Vivian'
-    persisted_user.gender.must_equal 'female'
-    persisted_user.passport.must_equal 'LOCOMOTE'
+        expect { updated_user = user_repository.save(user) }.to change { user_repository.count }.by(0)
 
-    user_repository.count.must_equal 1
+        updated_user.first_name.should == 'Vivian'
+        updated_user.health_care.should == 'BATMANCAVE'
+
+        persisted_user = user_repository.find(updated_user.id)
+
+        persisted_user.first_name.should == 'Vivian'
+        persisted_user.health_care.should == 'BATMANCAVE'
+      end
+    end
   end
 
-  it "#destroy via id" do
-    has_db_user
+  describe "#destroy" do
+    describe "resource" do
+      let!(:user) { user_repository.save(new_valid_user) }
 
-    user_repository.destroy!(1)
-    user_repository.count.must_equal 0
+      it "via id" do
+        expect { user_repository.destroy!(user.id) }.to change { user_repository.count }.by(-1)
+      end
+
+      it "via entity" do
+        expect { user_repository.destroy!(user) }.to change { user_repository.count }.by(-1)
+      end
+    end
+
+    describe "collection" do
+      let!(:users) { user_repository.save([new_valid_user, new_valid_user2]) }
+
+      it "via id" do
+        expect { user_repository.destroy!(users.map(&:id)) }.to change { user_repository.count }.by(-2)
+      end
+
+      it "via entity" do
+        expect { user_repository.destroy!(users) }.to change { user_repository.count }.by(-2)
+      end
+    end
+  end
+end
+
+describe Datamappify::Repository do
+  DATA_PROVIDERS.each do |data_provider|
+    it_behaves_like "repository persistence", data_provider
   end
 
-  it "#destroy via entity" do
-    has_db_user
+  describe "entity composed from multiple data providers" do
+    let!(:hero_repository) { HeroUserRepository.instance }
+    let!(:hero)            { HeroUser.new :first_name => 'Aaron', :last_name => 'Patterson' }
 
-    user_repository.destroy!(user)
-    user_repository.count.must_equal 0
+    it "#find" do
+      saved_hero = nil
+
+      expect { saved_hero = hero_repository.save!(hero) }.to change { hero_repository.count }.by(1)
+
+      saved_hero.first_name.should == 'Aaron'
+      saved_hero.last_name.should == 'Patterson'
+      saved_hero.nickname = 'unsaved nickname'
+
+      persisted_hero = hero_repository.find(saved_hero.id)
+      persisted_hero.first_name.should == 'Aaron'
+      persisted_hero.last_name.should == 'Patterson'
+      persisted_hero.nickname.should be_nil
+    end
   end
 end

data/spec/repository_spec.rb

@@ -1,40 +1,17 @@
 require_relative 'spec_helper'
 
-describe Datamappify::Repository do
-  let(:user_repository)    { UserRepository.instance }
-  let(:comment_repository) { CommentRepository.instance }
-  let(:role_repository)    { RoleRepository.instance }
-  let(:group_repository)   { GroupRepository.instance }
+shared_examples_for "a repository" do |data_provider|
+  let(:data_provider_module) { "Datamappify::Data::#{data_provider}".constantize }
+  let!(:user_repository)     { "UserRepository#{data_provider}".constantize.instance }
+  subject                    { data_provider_module }
 
-  before do
-    user_repository
-    comment_repository
-    role_repository
-    group_repository
+  it "defines the data class after the repository is initialised" do
+    subject.const_defined?(:User, false).should == true
   end
+end
 
-  describe "ActiveRecord data objects" do
-    it "defines the Data::User class after the repository is initialised" do
-      Datamappify::Data.const_defined?(:User, false).must_equal true
-    end
-
-    describe "data objects" do
-      subject { Datamappify::Data::User }
-
-      it "inherites from Datamappify::Data::Base" do
-        subject.superclass.must_equal Datamappify::Data::Base
-        subject.ancestors.must_include ActiveRecord::Base
-      end
-
-      it "has 'users' as the table name" do
-        subject.table_name.must_equal 'users'
-      end
-    end
-
-    def assert_correct_associated_data_class_name(klass, association_name, data_class_name)
-      klass.class.reflect_on_all_associations.find { |a|
-        a.name == association_name
-      }.klass.name.must_equal data_class_name
-    end
+describe Datamappify::Repository do
+  DATA_PROVIDERS.each do |data_provider|
+    it_behaves_like "a repository", data_provider
   end
 end

data/spec/spec_helper.rb

@@ -1,11 +1,13 @@
+require 'coveralls'
 require 'simplecov'
 require 'pry'
-require 'minitest/autorun'
-require 'minitest/spec'
-require 'minitest/colorize'
+require 'rspec/autorun'
 require 'database_cleaner'
 
-SimpleCov.start
+case ENV['COV'].to_i
+when 1 then SimpleCov.start
+when 2 then Coveralls.wear!
+end
 
 SimpleCov.configure do
   add_filter "/spec/"
@@ -13,12 +15,16 @@ end
 
 require File.expand_path('../../lib/datamappify', __FILE__)
 
-Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |f| require f }
+%w{tables entities repositories}.each do |sub_dir|
+  Dir[File.expand_path("../support/#{sub_dir}/**/*.rb", __FILE__)].each { |f| require f }
+end
+
+DATA_PROVIDERS = %w{ActiveRecord Sequel}
 
-DatabaseCleaner.strategy = :truncation
+RSpec.configure do |config|
+  DatabaseCleaner.strategy = :truncation
 
-class MiniTest::Spec
-  before do
+  config.before do
     DatabaseCleaner.clean
   end
 end

data/spec/support/entities/hero_user.rb

@@ -0,0 +1,11 @@
+class HeroUser
+  include Datamappify::Entity
+
+  attribute :first_name, String
+  attribute :last_name,  String
+  attribute :nickname,   String
+
+  def full_name
+    "#{first_name} #{last_name}"
+  end
+end

data/spec/support/entities/user.rb

@@ -3,15 +3,15 @@ class User
 
   attribute :first_name,     String
   attribute :last_name,      String
-  attribute :gender,         String
   attribute :age,            Integer
   attribute :passport,       String
   attribute :driver_license, String
+  attribute :health_care,    String
 
-  validates :first_name, :presence => true,
-                         :length   => { :minimum => 2 }
-  validates :passport,   :presence => true,
-                         :length   => { :minimum => 8 }
+  validates :first_name,     :presence => true,
+                             :length   => { :minimum => 2 }
+  validates :driver_license, :presence => true,
+                             :length   => { :minimum => 8 }
 
   def full_name
     "#{first_name} #{last_name}"

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

@@ -0,0 +1,6 @@
+class CommentRepositoryActiveRecord
+  include Datamappify::Repository
+
+  for_entity Comment
+  default_provider :ActiveRecord
+end

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

@@ -0,0 +1,6 @@
+class GroupRepositoryActiveRecord
+  include Datamappify::Repository
+
+  for_entity Group
+  default_provider :ActiveRecord
+end

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

@@ -0,0 +1,6 @@
+class RoleRepositoryActiveRecord
+  include Datamappify::Repository
+
+  for_entity Role
+  default_provider :ActiveRecord
+end

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

@@ -0,0 +1,11 @@
+class UserRepositoryActiveRecord
+  include Datamappify::Repository
+
+  for_entity User
+  default_provider :ActiveRecord
+
+  map_attribute :last_name,      'ActiveRecord::User#surname'
+  map_attribute :driver_license, 'ActiveRecord::UserDriverLicense#number'
+  map_attribute :passport,       'ActiveRecord::UserPassport#number'
+  map_attribute :health_care,    'ActiveRecord::UserHealthCare#number'
+end

data/spec/support/repositories/hero_user_repository.rb

@@ -0,0 +1,9 @@
+class HeroUserRepository
+  include Datamappify::Repository
+
+  for_entity HeroUser
+  default_provider :ActiveRecord
+
+  map_attribute :first_name, 'ActiveRecord::HeroUser#first_name'
+  map_attribute :last_name,  'Sequel::HeroUserLastName#last_name'
+end

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

@@ -0,0 +1,6 @@
+class CommentRepositorySequel
+  include Datamappify::Repository
+
+  for_entity Comment
+  default_provider :Sequel
+end

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

@@ -0,0 +1,6 @@
+class GroupRepositorySequel
+  include Datamappify::Repository
+
+  for_entity Group
+  default_provider :Sequel
+end

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

@@ -0,0 +1,6 @@
+class RoleRepositorySequel
+  include Datamappify::Repository
+
+  for_entity Role
+  default_provider :Sequel
+end

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

@@ -0,0 +1,11 @@
+class UserRepositorySequel
+  include Datamappify::Repository
+
+  for_entity User
+  default_provider :Sequel
+
+  map_attribute :last_name,      'Sequel::User#surname'
+  map_attribute :driver_license, 'Sequel::UserDriverLicense#number'
+  map_attribute :passport,       'Sequel::UserPassport#number'
+  map_attribute :health_care,    'Sequel::UserHealthCare#number'
+end