HornsAndHooves-flat_map 0.2.0

data/lib/flat_map/open_mapper/skipping.rb

@@ -0,0 +1,66 @@
+module FlatMap
+  # This helper module provides helper functionality that allow to
+  # exclude specific mapper from a processing chain.
+  module OpenMapper::Skipping
+    extend ActiveSupport::Autoload
+
+    autoload :ActiveRecord
+
+    # Mark self as skipped, i.e. it will not be subject of
+    # validation and saving chain.
+    #
+    # @return [Object]
+    def skip!
+      @_skip_processing = true
+    end
+
+    # Remove "skip" mark from +self+ and "destroyed" flag from
+    # the target.
+    #
+    # @return [Object]
+    def use!
+      @_skip_processing = nil
+    end
+
+    # Return +true+ if +self+ was marked for skipping.
+    #
+    # @return [Boolean]
+    def skipped?
+      !!@_skip_processing
+    end
+
+    # Override {FlatMap::OpenMapper::Persistence#valid?} to
+    # force it to return +true+ if +self+ is marked for skipping.
+    #
+    # @param [Symbol] context useless context parameter to make it compatible with
+    #   ActiveRecord models.
+    #
+    # @return [Boolean]
+    def valid?(context = nil)
+      skipped? || super
+    end
+
+    # Override {FlatMap::OpenMapper::Persistence#save} method to
+    # force it to return +true+ if +self+ is marked for skipping.
+    #
+    # @return [Boolean]
+    def save
+      skipped? || super
+    end
+
+    # Override {FlatMap::OpenMapper::Persistence#shallow_save} method
+    # to make it possible to skip traits.
+    #
+    # @return [Boolean]
+    def shallow_save
+      skipped? || super
+    end
+
+    # Mark self as used and then delegated to original
+    # {FlatMap::OpenMapper::Persistence#write}.
+    def write(*)
+      use!
+      super
+    end
+  end
+end

data/lib/flat_map/open_mapper/traits.rb

@@ -0,0 +1,95 @@
+module FlatMap
+  # This small module allows mappers to define traits, which technically
+  # means mounting anonymous mappers, attached to host one.
+  #
+  # Also, FlatMap::OpenMapper::Mounting#mountings completely overridden
+  # here to support special trait behavior.
+  module OpenMapper::Traits
+    extend ActiveSupport::Concern
+
+    # Traits class macros
+    module ClassMethods
+      # Define a trait for a mapper class. In implementation terms, a trait
+      # is nothing more than a mounted mapper, owned by a host mapper.
+      # It shares all mappings with it.
+      # The block is passed as a body of the anonymous mapper class.
+      #
+      # @param [Symbol] name
+      def trait(name, &block)
+        base_class        = self < FlatMap::Mapper ? FlatMap::Mapper : FlatMap::OpenMapper
+        mapper_class      = Class.new(base_class, &block)
+        mapper_class_name = "#{ancestors.first.name}#{name.to_s.camelize}Trait"
+        mapper_class.singleton_class.send(:define_method, :name){ mapper_class_name }
+        mount mapper_class, :trait_name => name
+      end
+    end
+
+    # Override the original {FlatMap::OpenMapper::Mounting#mountings}
+    # method to filter out those traited mappers that are not required for
+    # trait setup of +self+. Also, handle any inline extension that may be
+    # defined on the mounting mapper, which is attached as a singleton trait.
+    #
+    # @return [Array<FlatMap::OpenMapper>]
+    def mountings
+      @mountings ||= begin
+        mountings = self.class.mountings.reject do |factory|
+          factory.traited? && !factory.required_for_any_trait?(traits)
+        end
+        mountings.concat(singleton_class.mountings)
+        mountings.map{ |factory| factory.create(self, *traits) }
+      end
+    end
+
+    # Return a list of all mountings that represent full picture of +self+, i.e.
+    # +self+ and all traits, including deeply nested, that are mounted on self
+    #
+    # @return [Array<FlatMap::OpenMapper>]
+    def self_mountings
+      mountings.select(&:owned?).map{ |mount| mount.self_mountings }.flatten.concat [self]
+    end
+
+    # Try to find trait mapper with name that corresponds to +trait_name+
+    # Used internally to manipulate such mappers (for example, skip some traits)
+    # in some scenarios.
+    #
+    # @param [Symbol] trait_name
+    # @return [FlatMap::OpenMapper, nil]
+    def trait(trait_name)
+      self_mountings.find{ |mount| mount.class.name.underscore =~ /#{trait_name}_trait$/ }
+    end
+
+    # Return :extension trait, if present
+    #
+    # @return [FlatMap::OpenMapper]
+    def extension
+      trait(:extension)
+    end
+
+    # Return only mountings that are actually traits for host mapper.
+    #
+    # @return [Array<FlatMap::OpenMapper>]
+    def trait_mountings
+      result = mountings.select{ |mount| mount.owned? }
+      # mapper extension has more priority then traits, and
+      # has to be processed first.
+      result.unshift(result.pop) if result.length > 1 && result[-1].extension?
+      result
+    end
+    protected :trait_mountings
+
+    # Return only mountings that correspond to external mappers.
+    #
+    # @return [Array<FlatMap::OpenMapper>]
+    def mapper_mountings
+      mountings.select{ |mount| !mount.owned? }
+    end
+    protected :mapper_mountings
+
+    # Return +true+ if +self+ is extension of host mapper.
+    #
+    # @return [Boolean]
+    def extension?
+      owned? && self.class.name =~ /ExtensionTrait$/
+    end
+  end
+end

data/lib/flat_map/version.rb

@@ -0,0 +1,3 @@
+module FlatMap # :nodoc:
+  VERSION = "0.2.0" # :nodoc:
+end

data/spec/flat_map/errors_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe FlatMap::Errors do
+  let(:errors) {
+    described_class.new(
+      double( 'mapper', :suffixed? => true,
+                        :suffix    => 'foo',
+                        'attr_foo' => 2)
+    )
+  }
+
+  it "preserved errors should appear on #empty? call exactly once" do
+    errors.preserve :base, 'an error'
+    errors.should_not be_empty
+    errors[:base].should == ['an error']
+    expect{ errors.empty? }.not_to change{ errors[:base].length }
+  end
+
+  it "should add error to mapper with suffix" do
+    errors.add(:attr, 'an error')
+    errors[:attr_foo].should == ['an error']
+  end
+end

data/spec/flat_map/mapper/attribute_methods_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module FlatMap
+  module AttributeMethodsSpec
+    class SpecMapper < Mapper
+      map :attr_a, :attr_b
+    end
+  end
+
+  describe 'Attribute Methods' do
+    let(:target){ OpenStruct.new }
+    let(:mapper){ AttributeMethodsSpec::SpecMapper.new(target) }
+
+    before do
+      target.attr_a = 'a'
+      target.attr_b = 'b'
+    end
+
+    it 'should be able to read values via method calls' do
+      mapper.attr_a.should == 'a'
+      mapper.attr_b.should == 'b'
+    end
+
+    it 'should be able to write values via method calls' do
+      mapper.attr_a = 'A'
+      mapper.attr_b = 'B'
+      target.attr_a.should == 'A'
+      target.attr_b.should == 'B'
+    end
+
+    it 'should still raise for unknown or private method calls' do
+      expect{ mapper.undefined_method }.to raise_error(NoMethodError)
+      expect{ mapper.attribute_methods }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/flat_map/mapper/callbacks_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+module FlatMap
+  module CallbacksSpec
+    class MountMapper < Mapper
+      map :attr_c
+
+      set_callback :validate, :before, :set_c
+
+      def set_c
+        self.attr_c = 'mounted before validate'
+      end
+    end
+
+    class SpecMapper < Mapper
+      map :attr_a
+
+      set_callback :save, :before, :set_a
+
+      trait :with_b do
+        map :attr_b
+
+        set_callback :validate, :before, :set_b
+
+        def set_b
+          self.attr_b = 'before validate'
+        end
+      end
+
+      def set_a
+        self.attr_a = 'before save'
+      end
+
+      mount :mount,
+        :mapper_class_name => 'FlatMap::CallbacksSpec::MountMapper',
+        :target            => lambda{ |_| OpenStruct.new }
+    end
+  end
+
+  describe 'Callbacks' do
+    let(:mapper) do
+      CallbacksSpec::SpecMapper.new(OpenStruct.new, :with_b) do
+        set_callback :validate, :before, :extension_set_b
+
+        def extension_set_b
+          self.attr_b = 'extension value'
+        end
+      end
+    end
+
+    it 'should call callbacks once' do
+      mapper.should_receive(:set_a).once
+      mapper.save
+    end
+
+    specify 'validation callbacks' do
+      mapper.valid?
+      mapper.attr_a.should be_nil
+      mapper.attr_b.should == 'before validate'
+      mapper.attr_c.should == 'mounted before validate'
+    end
+
+    specify 'save callbacks' do
+      mapper.save
+      mapper.attr_a.should == 'before save'
+    end
+
+    context 'extension trait and named traits' do
+      it 'should process extension first' do
+        mapper.extension.should_receive(:extension_set_b).once.and_call_original
+        mapper.valid?
+        mapper.attr_b.should == 'before validate'
+      end
+    end
+  end
+end

data/spec/flat_map/mapper/factory_spec.rb

@@ -0,0 +1,285 @@
+require 'spec_helper'
+
+module FlatMap
+  describe OpenMapper::Factory do
+    let(:trait_class){ Class.new(FlatMap::OpenMapper) }
+    let(:mapper){ OpenMapper.build }
+
+    let(:mount_factory){ OpenMapper::Factory.new(:spec_mount, :traits => :used_traits) }
+    let(:trait_factory){ OpenMapper::Factory.new(trait_class, :trait_name => :a_trait) }
+    let(:open_factory){ OpenMapper::Factory.new(:some_mount, :open => true) }
+
+    context 'when used for a trait' do
+      subject{ trait_factory }
+
+      it{ should be_traited }
+      its(:name){ should be_nil }
+      its(:trait_name){ should == :a_trait }
+      its(:mapper_class){ should == trait_class }
+    end
+
+    context 'when used for a mounted mapper' do
+      subject{ mount_factory }
+
+      it{ should_not be_traited }
+      its(:name){ should == :spec_mount }
+      its(:trait_name){ should be_nil }
+      its(:traits){ should == [:used_traits] }
+    end
+
+    context 'when used for an open mapper' do
+      it "should have descendant of OpenMapper as mapper_class" do
+        open_factory.mapper_class.should < OpenMapper
+        open_factory.mapper_class.name.should == 'SomeMountMapper'
+      end
+
+      it "should create and instance of OpenMapper with open struct as a target" do
+        mounted = open_factory.create(mapper)
+        mounted.target.should be_a(OpenStruct)
+      end
+    end
+
+    describe 'behavior' do
+      let(:target)       { mapper.target }
+      let(:other_target) { Object.new }
+
+      describe '#mapper_class for mounted mappers' do
+        class ::SpecMountMapper < FlatMap::ModelMapper; end
+        class OpenMapper::Factory::SpecMountMapper < FlatMap::OpenMapper; end
+
+        it "should be able to fetch class name from name" do
+          mount_factory.mapper_class.should == ::SpecMountMapper
+        end
+
+        it "should be able to fetch class from mapper_class" do
+          factory = OpenMapper::Factory.new(
+                      :spec_mount,
+                      :mapper_class => FlatMap::OpenMapper::Factory::SpecMountMapper
+                    )
+          factory.mapper_class.should == ::FlatMap::OpenMapper::Factory::SpecMountMapper
+        end
+
+        it "should use options if specified" do
+          factory = OpenMapper::Factory.new(
+                      :spec_mount,
+                      :mapper_class_name => 'FlatMap::OpenMapper::Factory::SpecMountMapper'
+                    )
+          factory.mapper_class.should == ::FlatMap::OpenMapper::Factory::SpecMountMapper
+        end
+      end
+
+      describe '#fetch_target_from' do
+        it "should return owner's target for traited factory" do
+          trait_factory.fetch_target_from(mapper).should == target
+        end
+
+        context 'explicit target' do
+          it "should use explicitly specified if applicable" do
+            factory = OpenMapper::Factory.new(:spec_mount, :target => other_target)
+            factory.fetch_target_from(mapper).should == other_target
+          end
+
+          it "should call Proc and pass owner target to it if Proc is specified as :target" do
+            factory = OpenMapper::Factory.new(:spec_mount, :target => lambda{ |obj| obj.foo })
+            target.should_receive(:foo).and_return(other_target)
+            factory.fetch_target_from(mapper).should == other_target
+          end
+
+          it "should call a method if Symbol is used" do
+            factory = OpenMapper::Factory.new(:spec_mount, :target => :foo)
+            mapper.should_receive(:foo).and_return(other_target)
+            factory.fetch_target_from(mapper).should == other_target
+          end
+        end
+
+        context 'target from association' do
+          before do
+            target.stub(:is_a?).and_call_original
+            target.stub(:is_a?).with(ActiveRecord::Base).and_return(true)
+          end
+
+          let(:has_one_current_reflection) {
+            double('reflection', :macro => :has_one, :options => {:is_current => true})
+          }
+          let(:has_one_reflection) {
+            double('reflection', :macro => :has_one, :options => {})
+          }
+          let(:belongs_to_reflection) {
+            double('reflection', :macro => :belongs_to)
+          }
+          let(:has_many_reflection) {
+            double('reflection', :macro => :has_many, :name => :spec_mounts)
+          }
+
+          it "should refer to effective name for has_one_current association" do
+            # Note: has_one_current is not part of Rails
+            mount_factory.should_receive(:reflection_from_target).
+                          with(target).
+                          and_return(has_one_current_reflection)
+            target.should_receive(:effective_spec_mount).and_return(other_target)
+            mount_factory.fetch_target_from(mapper).should == other_target
+          end
+
+          it "should refer to existing association object if possible, " \
+             "and build it if it is absent for :has_one" do
+            mount_factory.should_receive(:reflection_from_target).
+                          with(target).
+                          and_return(has_one_reflection)
+            target.should_receive(:spec_mount).and_return(nil)
+            target.should_receive(:build_spec_mount).and_return(other_target)
+            mount_factory.fetch_target_from(mapper).should == other_target
+          end
+
+          it "should refer to existing association object if possible, " \
+             "and build it if it is absent for :belongs_to" do
+            mount_factory.should_receive(:reflection_from_target).
+                          with(target).
+                          and_return(belongs_to_reflection)
+            target.should_receive(:spec_mount).and_return(nil)
+            target.should_receive(:build_spec_mount).and_return(other_target)
+            mount_factory.fetch_target_from(mapper).should == other_target
+          end
+
+          it "should always build a new record for :has_many association" do
+            mount_factory.should_receive(:reflection_from_target).
+                          with(target).
+                          and_return(has_many_reflection)
+            target.should_receive(:association).with(:spec_mounts)
+            target.stub_chain(:association, :build).and_return(other_target)
+            mount_factory.fetch_target_from(mapper).should == other_target
+          end
+
+          describe 'reflection_from_target' do
+            before{ target.stub(:is_a?).with(ActiveRecord::Base).and_return(true) }
+
+            it 'should first refer to singular association' do
+              target.stub_chain(:class, :reflect_on_association).
+                     with(:spec_mount).
+                     and_return(has_one_reflection)
+              mount_factory.reflection_from_target(target).should == has_one_reflection
+            end
+
+            it 'should use collection association if singular does not exist' do
+              target.stub_chain(:class, :reflect_on_association).
+                     with(:spec_mount).
+                     and_return(nil)
+              target.stub_chain(:class, :reflect_on_association).
+                     with(:spec_mounts).
+                     and_return(has_many_reflection)
+              mount_factory.reflection_from_target(target).should == has_many_reflection
+            end
+          end
+        end
+
+        context 'target from name' do
+          it 'should simply send method to owner target' do
+            target.should_receive(:spec_mount).and_return(other_target)
+            mount_factory.fetch_target_from(mapper).should == other_target
+          end
+        end
+      end
+
+      describe '#create' do
+        specify 'traited factory should create an owned mapper' do
+          new_one = trait_factory.create(mapper)
+          new_one.owner.should == mapper
+        end
+
+        context 'mounted mapper' do
+          let(:mount_class){ Class.new(Mapper) }
+          let(:factory){ mount_factory }
+
+          before do
+            factory.stub(:mapper_class).and_return(mount_class)
+            factory.stub(:fetch_target_from).and_return(other_target)
+          end
+
+          it 'should combine traits' do
+            mount_class.should_receive(:new).
+                        with(other_target, :used_traits, :another_trait).
+                        and_call_original
+            factory.create(mapper, :another_trait)
+          end
+
+          it 'should properly set properties' do
+            new_one = factory.create(mapper)
+            new_one.host      .should == mapper
+            new_one.name      .should == :spec_mount
+            new_one.save_order.should == :after
+            new_one.suffix.should be_nil
+          end
+
+          context 'when suffix is defined' do
+            let(:factory){ OpenMapper::Factory.new(:spec_mount, :suffix => :foo) }
+
+            it "should adjust properties with suffix" do
+              new_one = factory.create(mapper)
+              new_one.name  .should == :spec_mount_foo
+              new_one.suffix.should == :foo
+            end
+          end
+
+          context 'when extension is present' do
+            let(:extension){ Proc.new{} }
+            let(:factory){ OpenMapper::Factory.new(:spec_mount, &extension) }
+
+            it "should pass it to mapper initialization" do
+              mount_class.should_receive(:new).
+                          with(other_target, &extension).
+                          and_call_original
+              new_one = factory.create(mapper)
+            end
+          end
+
+          describe 'save order' do
+            before do
+              mapper.stub(:is_a?).and_call_original
+              mapper.stub(:is_a?).with(ModelMapper).and_return(true)
+            end
+
+            it 'should be :before for belongs_to association' do
+              factory.stub(:reflection_from_target).
+                      and_return(double('reflection', :macro => :belongs_to))
+              factory.fetch_save_order(mapper).should == :before
+            end
+
+            it 'should be :after for other cases' do
+              factory.stub(:reflection_from_target).
+                      and_return(double('reflection', :macro => :has_one))
+              factory.fetch_save_order(mapper).should == :after
+            end
+
+            context 'when explicitly set' do
+              let(:factory){ OpenMapper::Factory.new(:spec_mount, :save => :before) }
+
+              it 'should fetch from options, if possible' do
+                new_one = factory.create(mapper)
+                new_one.save_order.should == :before
+              end
+            end
+          end
+        end
+      end
+
+      describe '#required_for_any_trait?' do
+        let(:mapper_class) do
+          Class.new(FlatMap::Mapper) do
+            trait(:trait_a) {
+              trait(:trait_b) {
+                trait(:trait_c) {
+            } } }
+          end
+        end
+        let(:factory_for_b){ mapper_class.mountings.first.mapper_class.mountings.first }
+
+        it "should be required for nested trait" do
+          factory_for_b.required_for_any_trait?([:trait_c]).should be true
+        end
+
+        it "should not be required for top trait" do
+          factory_for_b.required_for_any_trait?([:trait_a]).should be false
+        end
+      end
+    end
+  end
+end