datamappify 0.30.0 → 0.40.0

data/lib/datamappify/repository/unit_of_work/persistent_states/object.rb

@@ -0,0 +1,122 @@
+module Datamappify
+  module Repository
+    module UnitOfWork
+      class PersistentStates
+        # an object that mirrors an entity's attributes and their initial (clean) values
+        class Object
+          include ActiveModel::Dirty
+
+          # @param entity [Entity]
+          def initialize(entity)
+            @entity = entity
+
+            attributes = attributes_for(@entity)
+            attributes.each do |name, value|
+              construct_attribute(name)
+              set_value(name, value)
+            end
+
+            self.class.define_attribute_methods(attributes.keys)
+
+            mark_as_dirty if new?
+          end
+
+          # Updates all the attribute values according to the entity
+          #
+          # @param entity [Entity]
+          #
+          # @return [void]
+          def update_values(entity)
+            attributes_for(entity).each do |name, value|
+              construct_attribute(name)
+              send("#{name}=", value)
+            end
+          end
+
+          # Is the object new (not persisted yet)?
+          #
+          # @return [Boolean]
+          def new?
+            @entity.id.nil?
+          end
+
+          private
+
+          # Constructs an attribute with a getter, setter and '_changed?' method
+          #
+          # @return [void]
+          def construct_attribute(name)
+            construct_getter(name)
+            construct_setter(name)
+            construct_changed(name)
+          end
+
+          # Constructs an attribute getter
+          #
+          # @param name [Symbol]
+          #
+          # @return [void]
+          def construct_getter(name)
+            define_singleton_method name do
+              instance_variable_get "@#{name}"
+            end
+          end
+
+          # Constructs an attribute setter, the setter itself does NOT need
+          # to set the value as the value is never going to be used.
+          #
+          # The setter sets the `attr_will_change!` flag when necessary.
+          #
+          # @param name [Symbol]
+          #
+          # @return [void]
+          def construct_setter(name)
+            define_singleton_method "#{name}=" do |value|
+              send(:attribute_will_change!, name) unless send(name) == value
+            end
+          end
+
+          # Constructs the `attr_changed?` method
+          #
+          # @param name [Symbol]
+          #
+          # @return [void]
+          def construct_changed(name)
+            define_singleton_method "#{name}_changed?" do
+              changed_attributes.include?(name)
+            end
+          end
+
+          # Sets an attribute value by making a copy of the data
+          #
+          # @param name [Symbol]
+          #
+          # @param value [any]
+          #
+          # @return [any]
+          def set_value(name, value)
+            instance_variable_set "@#{name}", Marshal.load(Marshal.dump(value))
+          end
+
+          # Mark all attributes as dirty, useful for a non-persisted object
+          #
+          # @return [void]
+          def mark_as_dirty
+            attributes_for(@entity).each do |name, _|
+              send(:attribute_will_change!, name)
+            end
+          end
+
+          # Entity attributes, based on whether the entity is lazy loaded
+          #
+          # @param entity [Entity]
+          #
+          # @return [Hash]
+          def attributes_for(entity)
+            entity.lazy_loaded? ? entity.cached_attributes : entity.attributes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/repository/unit_of_work/persistent_states.rb

@@ -0,0 +1,54 @@
+require 'datamappify/repository/unit_of_work/persistent_states/object'
+
+module Datamappify
+  module Repository
+    module UnitOfWork
+      # Tracks dirty entity attributes
+      class PersistentStates
+        def initialize
+          @pool = {}
+        end
+
+        # Finds or attaches an entity
+        #
+        # @param entity [Entity]
+        #
+        # @return [Entity]
+        def find(entity)
+          @pool.has_key?(entity.object_id) ? refresh(entity) : attach(entity)
+        end
+
+        # Refreshes the states stored for an entity
+        #
+        # @param entity [Entity]
+        #
+        # @return [Entity]
+        def refresh(entity)
+          @pool[entity.object_id].tap { |o| o.update_values(entity) }
+        end
+
+        # Attaches an entity
+        #
+        # @param entity [Entity]
+        #
+        # @return [Entity]
+        def attach(entity)
+          @pool[entity.object_id] = Object.new(entity)
+        end
+
+        # Executes a block then reattaches the entity
+        #
+        # @param entity [Entity]
+        #
+        # @return [Entity]
+        def update(entity, &block)
+          find(entity)
+
+          block.call
+
+          attach(entity)
+        end
+      end
+    end
+  end
+end

data/lib/datamappify/repository/unit_of_work/transaction.rb

@@ -0,0 +1,18 @@
+module Datamappify
+  module Repository
+    module UnitOfWork
+      class Transaction
+        # @param data_mapper (see QueryMethod::Method#initialize)
+        #
+        # @yield
+        #   queries to be performed in the transaction
+        #
+        # @return [void]
+        def initialize(data_mapper, &block)
+          data_mapper.default_provider.build_criteria(:Transaction, data_mapper.default_source_class, &block)
+        end
+      end
+    end
+  end
+end
+

data/lib/datamappify/repository/unit_of_work.rb

@@ -0,0 +1 @@
+Dir[Datamappify.root.join('repository/unit_of_work/*')].each { |file| require file }

data/lib/datamappify/repository.rb

@@ -1,70 +1,34 @@
+require 'datamappify/repository/lazy_checking'
 require 'datamappify/repository/mapping_dsl'
-require 'datamappify/repository/query_method'
+require 'datamappify/repository/unit_of_work'
+require 'datamappify/repository/query_methods'
 require 'datamappify/data'
 
 module Datamappify
   module Repository
+    # @return [Data::Mapper]
+    attr_accessor :data_mapper
+
+    # @return [UnitOfWork::PersistentStates]
+    attr_reader :states
+
     def self.included(klass)
       klass.class_eval do
         include Singleton
         extend  SingletonWrapper
 
-        cattr_accessor :data_mapper
-
         self.data_mapper = Data::Mapper.new
 
+        include LazyChecking
         extend  MappingDSL
-        include InstanceMethods
+        include QueryMethods
       end
     end
 
-    module InstanceMethods
-      # @param id_or_ids [Integer, Array<Integer>]
-      #   an entity id or a collection of entity ids
-      #
-      # @return [Entity, Array<Entity>, nil]
-      def find(id_or_ids)
-        QueryMethod::Find.new(data_mapper, id_or_ids).result
-      end
+    private
 
-      # @param entity_or_entities [Entity, Array<Entity>]
-      #   an entity or a collection of entities
-      #
-      # @return [Entity, Array<Entity>, false]
-      def save(entity_or_entities)
-        QueryMethod::Save.new(data_mapper, entity_or_entities).result
-      end
-
-      # @param (see #save)
-      #
-      # @raise [Data::EntityNotSaved]
-      #
-      # @return [Entity, Array<Entity>]
-      def save!(entity_or_entities)
-        save(entity_or_entities) || raise(Data::EntityNotSaved)
-      end
-
-      # @param id_or_ids_or_entity_or_entities [Entity, Array<Entity>]
-      #   an entity or a collection of ids or entities
-      #
-      # @return [void, false]
-      def destroy(id_or_ids_or_entity_or_entities)
-        QueryMethod::Destroy.new(data_mapper, id_or_ids_or_entity_or_entities).result
-      end
-
-      # @param (see #destroy)
-      #
-      # @raise [Data::EntityNotDestroyed]
-      #
-      # @return [void]
-      def destroy!(id_or_ids_or_entity_or_entities)
-        destroy(id_or_ids_or_entity_or_entities) || raise(Data::EntityNotDestroyed)
-      end
-
-      # @return [Integer]
-      def count
-        QueryMethod::Count.new(data_mapper).result
-      end
+    def initialize
+      @states = UnitOfWork::PersistentStates.new
     end
 
     # Wraps a ruby Singleton class so that calling `instance` is no longer necessary.
@@ -78,7 +42,8 @@ module Datamappify
       def self.extended(klass)
         class << klass
           extend Forwardable
-          def_delegators :instance, *InstanceMethods.instance_methods
+          def_delegators :instance, :data_mapper, :data_mapper=, :states
+          def_delegators :instance, *QueryMethods.instance_methods
         end
       end
     end

data/lib/datamappify/version.rb

@@ -1,3 +1,3 @@
 module Datamappify
-  VERSION = '0.30.0'
+  VERSION = '0.40.0'
 end

data/lib/datamappify.rb

@@ -1,4 +1,4 @@
-require 'active_support'
+require 'active_model'
 require 'datamappify/version'
 
 module Datamappify
@@ -8,6 +8,8 @@ module Datamappify
   end
 end
 
+require 'datamappify/logger'
 require 'datamappify/entity'
 require 'datamappify/data'
 require 'datamappify/repository'
+require 'datamappify/lazy'

data/spec/lazy_spec.rb

@@ -0,0 +1,73 @@
+require_relative 'spec_helper'
+
+describe Datamappify::Lazy do
+  let!(:user_repository) { HeroUserRepository }
+  let!(:existing_user)   { user_repository.save(HeroUser.new(:first_name => 'Fred', :last_name => 'Wu', :gender => 'm')) }
+  let(:user)             { user_repository.find(existing_user.id) }
+
+  it "eager loads default attributes" do
+    Datamappify::Logger.should_not_receive(:performed).with(:override_attribute, :last_name)
+    Datamappify::Logger.should_not_receive(:performed).with(:override_attribute, :gender)
+
+    user.id.should == 1
+    user.first_name.should == 'Fred'
+  end
+
+  describe "loader" do
+    before do
+      Datamappify::Logger.should_receive(:performed).with(:override_attribute, :last_name).once
+      Datamappify::Logger.should_not_receive(:performed).with(:override_attribute, :gender)
+    end
+
+    it "loads lazy attribute" do
+      user.last_name.should == 'Wu'
+    end
+
+    it "loads lazy attribute with eager attribute" do
+      user.first_name.should == 'Fred'
+      user.last_name.should == 'Wu'
+    end
+
+    it "loads lazy attribute twice with eager attribute" do
+      user.first_name.should == 'Fred'
+      user.last_name.should == 'Wu'
+      user.last_name.should == 'Wu'
+    end
+
+    it "loads lazy attributes from the same source" do
+      user.first_name.should == 'Fred'
+      user.last_name.should == 'Wu'
+      user.gender.should == 'm'
+    end
+  end
+
+  describe "simple setter" do
+    before do
+      Datamappify::Logger.should_not_receive(:performed).with(:override_attribute, :last_name)
+    end
+
+    it "doesn't need lazy loading when the attribute is being set" do
+      user.first_name.should == 'Fred'
+      user.last_name = 'Cooper'
+      user.last_name.should == 'Cooper'
+    end
+
+    it "loads only the non-set attribute" do
+      Datamappify::Logger.should_receive(:performed).with(:override_attribute, :gender).once
+
+      user.first_name.should == 'Fred'
+      user.last_name = 'Cooper'
+      user.last_name.should == 'Cooper'
+      user.gender.should == 'm'
+    end
+  end
+
+  describe "complex setter" do
+    it "handles complex values" do
+      user.first_name.should == 'Fred'
+      user.last_name << 'Cooper'
+      user.last_name.should == 'WuCooper'
+    end
+  end
+end
+

data/spec/repository/callbacks_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+shared_examples_for "callbacks" do |query_method, *performed_callbacks|
+  subject { HeroUserRepository.instance }
+
+  after do
+    subject.send(query_method, entity)
+  end
+
+  all_callbacks = [
+    :before_create,  :after_create,
+    :before_update,  :after_update,
+    :before_save,    :after_save,
+    :before_destroy, :after_destroy
+  ]
+
+  non_performed_callbacks = all_callbacks - performed_callbacks
+
+  it "doesn't perform callbacks on #{query_method}" do
+    non_performed_callbacks.each do |callback|
+      subject.should_not_receive(:performed).with(callback, entity)
+    end
+  end
+
+  it "performs callbacks on #{query_method} in order" do
+    performed_callbacks.each do |callback|
+      subject.should_receive(:performed).with(callback, entity).ordered
+    end
+  end
+end
+
+describe Datamappify::Repository do
+  let(:valid_user)   { HeroUser.new(:first_name => 'Fred', :last_name => 'Wu', :gender => 'm') }
+  let(:invalid_user) { HeroUser.new(:first_name => 'F') }
+
+  it { valid_user.valid?.should == true }
+  it { invalid_user.valid?.should == false }
+
+  context "non-persisted" do
+    context "on valid entity" do
+      let(:entity) { valid_user }
+
+      it_behaves_like "callbacks", :create,  :before_save, :before_create, :before_create_2, :before_create_block, :after_create, :after_save
+      it_behaves_like "callbacks", :update,  :before_save, :before_update, :after_update, :after_save
+      it_behaves_like "callbacks", :save,    :before_save, :before_create, :before_create_2, :before_create_block, :after_create, :after_save
+    end
+
+    context "on invalid entity" do
+      let(:entity) { invalid_user }
+
+      it_behaves_like "callbacks", :create,  :before_save, :before_create, :before_create_2, :before_create_block
+      it_behaves_like "callbacks", :update,  :before_save, :before_update
+      it_behaves_like "callbacks", :save,    :before_save, :before_create, :before_create_2, :before_create_block
+    end
+  end
+
+  context "persisted" do
+    let!(:persisted_user) { HeroUserRepository.save(valid_user.dup) }
+
+    context "on valid entity" do
+      let(:entity) { persisted_user }
+
+      it_behaves_like "callbacks", :create,  :before_save, :before_create, :before_create_2, :before_create_block, :after_create, :after_save
+      it_behaves_like "callbacks", :update,  :before_save, :before_update, :after_update, :after_save
+      it_behaves_like "callbacks", :save,    :before_save, :before_update, :after_update, :after_save
+      it_behaves_like "callbacks", :destroy, :before_destroy, :after_destroy
+    end
+
+    context "on invalid entity" do
+      let(:entity) { persisted_user.tap { |u| u.first_name = 'f' } }
+
+      it_behaves_like "callbacks", :create,  :before_save, :before_create, :before_create_2, :before_create_block
+      it_behaves_like "callbacks", :update,  :before_save, :before_update
+      it_behaves_like "callbacks", :save,    :before_save, :before_update
+      it_behaves_like "callbacks", :destroy, :before_destroy, :after_destroy
+    end
+  end
+
+  describe "callbacks chaining" do
+    subject { repository.instance }
+
+    describe "chaining breaks before or during saving an entity" do
+      after do
+        repository.save(entity)
+
+        entity.id.should be_nil
+      end
+
+      context "pause at action" do
+        let(:entity)     { invalid_user }
+        let(:repository) { CallbacksChainingRepository }
+
+        it do
+          subject.should_receive(:performed).with(:before_save_1, entity).ordered
+          subject.should_receive(:performed).with(:before_save_2, entity).ordered
+          subject.should_receive(:performed).with(:before_save_3, entity).ordered
+          subject.should_not_receive(:performed).with(:after_save_1, entity)
+          subject.should_not_receive(:performed).with(:after_save_2, entity)
+          subject.should_not_receive(:performed).with(:after_save_3, entity)
+        end
+      end
+
+      context "pause at before callbacks" do
+        let(:entity)     { valid_user }
+        let(:repository) { CallbacksChainingPauseBeforeRepository }
+
+        it do
+          subject.should_receive(:performed).with(:before_save_1, entity).ordered
+          subject.should_receive(:performed).with(:before_save_2, entity).ordered
+          subject.should_not_receive(:performed).with(:before_save_3, entity)
+          subject.should_not_receive(:performed).with(:after_save_1, entity)
+          subject.should_not_receive(:performed).with(:after_save_2, entity)
+          subject.should_not_receive(:performed).with(:after_save_3, entity)
+        end
+      end
+    end
+
+    describe "chaining breaks after saving an entity" do
+      after do
+        repository.save(entity)
+
+        entity.id.should_not be_nil
+      end
+
+      context "pause at after callbacks" do
+        let(:entity)     { valid_user }
+        let(:repository) { CallbacksChainingPauseAfterRepository }
+
+        it do
+          subject.should_receive(:performed).with(:before_save_1, entity).ordered
+          subject.should_receive(:performed).with(:before_save_2, entity).ordered
+          subject.should_receive(:performed).with(:before_save_3, entity).ordered
+          subject.should_receive(:performed).with(:after_save_1, entity).ordered
+          subject.should_receive(:performed).with(:after_save_2, entity).ordered
+          subject.should_not_receive(:performed).with(:after_save_3, entity)
+        end
+      end
+    end
+  end
+end

data/spec/repository/dirty_persistence_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+shared_examples_for "dirty persistence" do |data_provider|
+  include_context "user repository", data_provider
+
+  context "#{data_provider}" do
+    describe "#find" do
+      it "finds a persisted entity" do
+        persisted_user = user_repository.find(existing_user.id)
+        persisted_user.first_name.should == existing_user.first_name
+      end
+    end
+
+    describe "#save" do
+      let(:create_method) { Datamappify::Repository::QueryMethod::Create }
+      let(:update_method) { Datamappify::Repository::QueryMethod::Update }
+
+      it "does not perform when there are no dirty attributes" do
+        Datamappify::Logger.should_not_receive(:performed).with(update_method)
+
+        user_repository.save(existing_user)
+      end
+
+      it "performs when there are dirty attributes" do
+        Datamappify::Logger.should_receive(:performed).with(update_method).once
+
+        existing_user.first_name = 'Dirty'
+        user_repository.save(existing_user)
+      end
+
+      it "performs when the entity is new" do
+        Datamappify::Logger.should_receive(:performed).with(create_method).at_least(:twice)
+
+        user_repository.save(new_valid_user)
+      end
+    end
+  end
+end
+
+describe Datamappify::Repository do
+  DATA_PROVIDERS.each do |data_provider|
+    it_behaves_like "dirty persistence", data_provider
+  end
+end

data/spec/repository/dirty_tracking_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+shared_examples_for "dirty tracking" do |data_provider|
+  include_context "user repository", data_provider
+
+  context "#{data_provider}" do
+    describe "entity attribute (simple)" do
+      after do
+        user_repository.save(existing_user)
+        user_repository.states.find(existing_user).first_name_changed?.should == false
+      end
+
+      it "clean slate" do
+        user_repository.states.find(existing_user).first_name_changed?.should == false
+      end
+
+      it "changed" do
+        existing_user.first_name = 'ChangedName'
+        user_repository.states.find(existing_user).first_name_changed?.should == true
+        user_repository.states.find(existing_user).last_name_changed?.should == false
+      end
+
+      it "not changed" do
+        first_name = existing_user.first_name
+        existing_user.first_name = 'ChangedName'
+        existing_user.first_name = first_name
+        user_repository.states.find(existing_user).first_name_changed?.should == false
+        user_repository.states.find(existing_user).last_name_changed?.should == false
+      end
+    end
+
+    describe "entity attribute (complex)" do
+      after do
+        user_repository.save(existing_user)
+        user_repository.states.find(existing_user).first_name_changed?.should == false
+      end
+
+      it "changed" do
+        existing_user.first_name << 'super'
+        user_repository.states.find(existing_user).first_name_changed?.should == true
+        user_repository.states.find(existing_user).last_name_changed?.should == false
+      end
+
+      it "not changed" do
+        first_name = existing_user.first_name.dup
+        existing_user.first_name << 'super'
+        existing_user.first_name = first_name
+        user_repository.states.find(existing_user).first_name_changed?.should == false
+        user_repository.states.find(existing_user).last_name_changed?.should == false
+      end
+    end
+
+    describe "entity" do
+      after do
+        user_repository.save(existing_user)
+        user_repository.states.find(existing_user).changed?.should == false
+      end
+
+      it "clean slate" do
+        user_repository.states.find(existing_user).changed?.should == false
+      end
+
+      it "changed" do
+        existing_user.first_name = 'ChangedName'
+        user_repository.states.find(existing_user).changed?.should == true
+      end
+
+      it "not changed" do
+        first_name = existing_user.first_name
+        existing_user.first_name = 'ChangedName'
+        existing_user.first_name = first_name
+        user_repository.states.find(existing_user).changed?.should == false
+      end
+    end
+  end
+end
+
+describe Datamappify::Repository do
+  DATA_PROVIDERS.each do |data_provider|
+    it_behaves_like "dirty tracking", data_provider
+  end
+end