flat_map 0.0.3

data/lib/flat_map/mapping/reader/proc.rb

@@ -0,0 +1,15 @@
+module FlatMap
+  module Mapping::Reader
+    # Proc reader accepts a lambda and calls it with the target
+    # as an argument for reading.
+    class Proc < Method
+      # Call a <tt>@method</tt>, which is a {Proc} object,
+      # passing the +target+ object to it.
+      #
+      # @return [Object] value returned by reader's lambda
+      def read
+        @method.call(target)
+      end
+    end
+  end
+end

data/lib/flat_map/mapping/writer.rb

@@ -0,0 +1,11 @@
+module FlatMap
+  # Writer module hosts various writer classes that are used
+  # by mappings to assign values to the target of an associated mapper.
+  module Mapping::Writer
+    extend ActiveSupport::Autoload
+
+    autoload :Basic
+    autoload :Method
+    autoload :Proc
+  end
+end

data/lib/flat_map/mapping/writer/basic.rb

@@ -0,0 +1,25 @@
+module FlatMap
+  module Mapping::Writer
+    # Basic writer simply calls the target's attribute assignment method
+    # passing to it the value being written.
+    class Basic
+      attr_reader :mapping
+
+      delegate :target, :target_attribute, :to => :mapping
+
+      # Initialize writer by passing +mapping+ to it.
+      def initialize(mapping)
+        @mapping = mapping
+      end
+
+      # Call the assignment method of the target, passing
+      # the +value+ to it.
+      #
+      # @param [Object] value
+      # @return [Object] result of assignment
+      def write(value)
+        target.send("#{target_attribute}=", value)
+      end
+    end
+  end
+end

data/lib/flat_map/mapping/writer/method.rb

@@ -0,0 +1,28 @@
+module FlatMap
+  module Mapping::Writer
+    # Method writer calls a method defined by mapper and sends mapping
+    # and value to it as arguments.
+    #
+    # Note that this doesn't set anything on the target itself.
+    class Method < Basic
+      delegate :mapper, :to => :mapping
+
+      # Initialize the writer with a +mapping+ and +method+ name
+      # that should be called on the mapping's mapper.
+      #
+      # @param [FlatMap::Mapping] mapping
+      # @param [Symbol] method
+      def initialize(mapping, method)
+        @mapping, @method = mapping, method
+      end
+
+      # Write a +value+ by sending it, along with the mapping itself.
+      #
+      # @param [Object] value
+      # @return [Object] result of writing
+      def write(value)
+        mapper.send(@method, mapping, value)
+      end
+    end
+  end
+end

data/lib/flat_map/mapping/writer/proc.rb

@@ -0,0 +1,18 @@
+module FlatMap
+  module Mapping::Writer
+    # Proc writer calls a lambda passed on the mapping definition and
+    # sends the mapper's target and value to it.
+    #
+    # Note that this doesn't set anything on the target itself.
+    class Proc < Method
+      # Call a <tt>@method</tt>, which is a +Proc+ object,
+      # passing it the mapping's +target+ and +value+.
+      #
+      # @param [Object] value
+      # @return [Object] result of writing
+      def write(value)
+        @method.call(target, value)
+      end
+    end
+  end
+end

data/lib/flat_map/version.rb

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

data/spec/flat_map/empty_mapper_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module EmptyMapperSpec
+  class MountedMapper < ::FlatMap::Mapper
+  end
+
+  class Mapper < ::FlatMap::EmptyMapper
+    mount :mounted,
+      :mapper_class_name => 'EmptyMapperSpec::MountedMapper',
+      :target => Object.new
+
+    trait :some_trait do
+    end
+  end
+end
+
+module FlatMap
+  describe EmptyMapper do
+    let(:mapper){ EmptyMapperSpec::Mapper.new(:some_trait){} }
+
+    it 'should be normally initialized' do
+      mapper.mounting(:mounted).should be_present
+      mapper.trait(:some_trait).should be_present
+      mapper.extension.should be_present
+    end
+
+    it 'should raise error for malounted mapper when target is not specified' do
+      mapper_class = Class.new(::FlatMap::EmptyMapper) do
+        mount :mounted, :mapper_class_name => 'EmptyMapperSpec::MountedMapper'
+      end
+
+      expect{ mapper_class.new.mounting(:mounted) }.
+        to raise_error(::FlatMap::Mapper::Targeting::NoTargetError)
+    end
+  end
+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,258 @@
+require 'spec_helper'
+
+module FlatMap
+  describe BaseMapper::Factory do
+    let(:trait_class){ Class.new(Mapper) }
+    let(:target){ Object.new }
+    let(:other_target){ Object.new }
+    let(:mapper){ Class.new(Mapper).new(target) }
+    let(:mount_factory){ BaseMapper::Factory.new(:spec_mount, :traits => :used_traits) }
+    let(:trait_factory){ BaseMapper::Factory.new(trait_class, :trait_name => :a_trait) }
+
+    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
+
+    describe 'behavior' do
+      describe '#mapper_class for mounted mappers' do
+        class ::SpecMountMapper < Mapper; end
+        class BaseMapper::Factory::SpecMountMapper; end
+
+        it "should be able to fetch class name from name" do
+          mount_factory.mapper_class.should == ::SpecMountMapper
+        end
+
+        it "should use options if specified" do
+          factory = BaseMapper::Factory.new(
+                      :spec_mount,
+                      :mapper_class_name => 'FlatMap::BaseMapper::Factory::SpecMountMapper'
+                    )
+          factory.mapper_class.should == ::FlatMap::BaseMapper::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 = BaseMapper::Factory.new(: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 = BaseMapper::Factory.new(:mount, :target => lambda{ |obj| obj.foo })
+            target.should_receive(:foo).and_return(other_target)
+            factory.fetch_target_from(mapper).should == other_target
+          end
+        end
+
+        context 'target from association' do
+          before{ target.stub(:kind_of?).with(ActiveRecord::Base).and_return(true) }
+
+          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 empty mapper' do
+          class ::SpecEmptyMountMapper < EmptyMapper; end
+          let(:factory){ BaseMapper::Factory.new(:spec_empty_mount) }
+
+          it 'should not call fetch_target_from' do
+            factory.should_not_receive(:fetch_target_from)
+            factory.create(mapper)
+          end
+        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){ BaseMapper::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){ BaseMapper::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
+            context 'when explicitly set' do
+              let(:factory){ BaseMapper::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
+
+            it 'should be :before for belongs_to association' do
+              mount_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
+              mount_factory.stub(:reflection_from_target).
+                            and_return(double('reflection', :macro => :has_one))
+              factory.fetch_save_order(mapper).should == :after
+            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