flat_map 0.0.3

data/spec/flat_map/mapper/mapping_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+module FlatMap
+  module MappingSpec
+    SpecTarget = Struct.new(:attr_a, :attr_b, :attr_c, :attr_d)
+
+    class SpecMapper < Mapper
+      # explicit mapping
+      map :mapped_attr_a => :attr_a
+
+      # implicit mapping
+      map :attr_b
+
+      # implicit and explicit with options in one call
+      map :attr_c, :mapped_attr_d => :attr_d,
+        :reader => :read_mappings,
+        :writer => :write_mappings
+
+      def read_mappings(mapping)
+        "#{mapping.name}-#{target.send(mapping.target_attribute)}"
+      end
+
+      def write_mappings(mapping, value)
+        target.send("#{mapping.target_attribute}=", value.upcase)
+      end
+    end
+
+    class EmptyMapper < Mapper; end
+  end
+
+  describe 'Mapping' do
+    context 'defining mappings' do
+      it "should use Factory for defining mappings" do
+        MappingSpec::EmptyMapper.should_receive(:define_mappings).once.
+          with({:attr_a => :attr_a, :mapped_attr_b => :attr_b}, {:writer => false}).
+          and_call_original
+        Mapping::Factory.should_receive(:new).
+                         with(:attr_a, :attr_a, :writer => false).
+                         and_call_original
+        Mapping::Factory.should_receive(:new).
+                         with(:mapped_attr_b, :attr_b, :writer => false).
+                         and_call_original
+
+        MappingSpec::EmptyMapper.class_eval do
+          map :attr_a, :mapped_attr_b => :attr_b, :writer => false
+        end
+      end
+    end
+
+    specify 'mapper class should have defined mappings' do
+      MappingSpec::SpecMapper.should have(4).mappings
+      MappingSpec::SpecMapper.mappings.all?{ |m| m.is_a?(Mapping::Factory) }.should be_true
+    end
+
+    context "for initialized mapper" do
+      let(:target){ MappingSpec::SpecTarget.new('a', 'b', 'c', 'd') }
+      let(:mapper){ MappingSpec::SpecMapper.new(target) }
+
+      it "should be able to access mapping by its name" do
+        mapper.mapping(:mapped_attr_a).should be_a(FlatMap::Mapping)
+        mapper.mapping(:not_defined).should be_nil
+      end
+
+      describe 'reading and writing' do
+        it "should be able to read from target via brackets" do
+          mapper[:mapped_attr_a].should == 'a'
+        end
+
+        it 'should be able to write to target via brackets' do
+          mapper[:attr_b] = 'B'
+          target.attr_b.should == 'B'
+        end
+
+        it '#read should read all mappings to a hash' do
+          mapper.read.should == {
+            :mapped_attr_a => 'a',
+            :attr_b        => 'b',
+            :attr_c        => 'attr_c-c',
+            :mapped_attr_d => 'mapped_attr_d-d'
+          }
+        end
+
+        it '#write should assign values using mappings, ignoring invalid ones' do
+          mapper.write \
+            :mapped_attr_a => 'A',
+            :attr_b        => 'B',
+            :attr_c        => 'new-c',
+            :mapped_attr_d => 'new-d'
+
+          target.attr_a.should == 'A'
+          target.attr_b.should == 'B'
+          target.attr_c.should == 'NEW-C'
+          target.attr_d.should == 'NEW-D'
+        end
+      end
+    end
+  end
+end

data/spec/flat_map/mapper/mounting_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+module FlatMap
+  module MountingSpec
+    MountTarget = Struct.new(:attr_a, :attr_b)
+
+    class MountMapper < Mapper
+      map :attr_a
+
+      trait :with_b do
+        map :mapped_attr_b => :attr_b
+      end
+
+      def a_method
+        'a value'
+      end
+    end
+
+    class HostMapper < Mapper
+      map :host_attr, :reader => :attr_value, :writer => false
+
+      mount :spec_mount,
+        :traits            => :with_b,
+        :target            => lambda{ |obj| MountingSpec.mount_target },
+        :mapper_class_name => 'FlatMap::MountingSpec::MountMapper'
+
+      mount :spec_mount_before,
+        :target            => lambda{ |obj| MountingSpec.mount_target },
+        :mapper_class_name => 'FlatMap::MountingSpec::MountMapper',
+        :save              => :before
+
+      def attr_value(*)
+        'attr'
+      end
+    end
+
+    class EmptyMapper < Mapper; end
+
+    def self.mount_target
+      @mount_target ||= MountTarget.new('a', 'b')
+    end
+
+    def self.reset_mount_target
+      @mount_target = nil
+    end
+  end
+
+  module MountingSuffixSpec
+    class SpecMapper < Mapper
+      mount_options = {
+        :suffix            => 'foo',
+        :mapper_class_name => 'FlatMap::MountingSuffixSpec::MountMapper',
+        :target            => lambda{ |_| OpenStruct.new } }
+      mount :mount, mount_options do
+        mount :nested,
+          :mapper_class_name => 'FlatMap::MountingSuffixSpec::NestedMapper',
+          :target            => lambda{ |_| OpenStruct.new }
+      end
+    end
+
+    class MountMapper < Mapper
+      map :attr_mount
+    end
+
+    class NestedMapper < Mapper
+      map :attr_nested
+    end
+  end
+
+  describe 'Mounting' do
+    let(:mapper){ MountingSpec::HostMapper.new(Object.new) }
+    let(:mounting){ mapper.mounting(:spec_mount) }
+
+    after{ MountingSpec.reset_mount_target }
+
+    context 'defining mountings' do
+      it "should use Factory for defining mappings" do
+        Mapper::Factory.should_receive(:new).
+                        with(:foo, :mapper_class_name => 'FooMapper').
+                        and_call_original
+
+        expect{ MountingSpec::EmptyMapper.mount(:foo, :mapper_class_name => 'FooMapper') }.
+          to change{ MountingSpec::EmptyMapper.mountings.length }.from(0).to(1)
+      end
+    end
+
+    describe 'properties' do
+      it{ mapper.hosted?.should be_false }
+      it{ mounting.hosted?.should be_true }
+      it{ mounting.host.should == mapper }
+    end
+
+    it 'should be able to access mapping by name' do
+      mapper.mounting(:spec_mount).should be_a(FlatMap::Mapper)
+      mapper.mounting(:undefined_mount).should be_nil
+    end
+
+    it '#read should add mounted mappers to a result' do
+      mapper.read.should == {
+        :host_attr     => 'attr',
+        :attr_a        => 'a',
+        :mapped_attr_b => 'b'
+      }
+    end
+
+    it '#write should pass values to mounted mappers' do
+      target = MountingSpec.mount_target
+      mapper.write :attr_a => 'A', :mapped_attr_b => 'B'
+      target.attr_a.should == 'A'
+      target.attr_b.should == 'B'
+    end
+
+    it 'should delegate missing methods to mounted mappers' do
+      expect{ mapper.a_method.should == 'a value' }.not_to raise_error
+    end
+
+    specify '#before_save_mountings' do
+      mapper.before_save_mountings.should == [mapper.mounting(:spec_mount_before)]
+    end
+
+    specify '#after_save_mountings' do
+      mapper.after_save_mountings.should == [mapper.mounting(:spec_mount)]
+    end
+
+    context 'with suffix' do
+      let(:mapper){ MountingSuffixSpec::SpecMapper.new(OpenStruct.new) }
+      let(:mounting){ mapper.mounting(:mount_foo) }
+
+      it{ mapper.should_not be_suffixed }
+      it{ mounting.should be_suffixed }
+
+      it 'should cascade to nested mappings' do
+        mapper.attr_mount_foo  = 'foo'
+        mapper.attr_nested_foo = 'bar'
+
+        mapper.read.should include({
+          :attr_mount_foo  => 'foo',
+          :attr_nested_foo => 'bar' })
+      end
+    end
+  end
+end

data/spec/flat_map/mapper/skipping_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+module FlatMap
+  module SkippingSpec
+    class SpecMapper < Mapper
+      trait :with_trait do
+        map :attr_a, :attr_b
+
+        set_callback :validate, :before, :set_attr_a, :prepend => true
+        set_callback :save, :before, :set_attr_b
+
+        validates_numericality_of :attr_a
+
+        def set_attr_a
+          self.attr_a = 'a'
+        end
+
+        def set_attr_b
+          self.attr_b = 'b'
+        end
+      end
+    end
+  end
+
+  describe 'Skipping' do
+    let(:mapper){ SkippingSpec::SpecMapper.new(OpenStruct.new, :with_trait) }
+
+    before{ mapper.trait(:with_trait).skip! }
+
+    it 'should completely ignore skipped mounting' do
+      mapper.should be_valid
+      mapper.save.should be_true
+      mapper.attr_a.should be_nil
+      mapper.attr_b.should be_nil
+    end
+
+    it '#use! should enable skipped mounting' do
+      mapper.trait(:with_trait).use!
+
+      mapper.should_not be_valid
+      mapper.attr_a.should == 'a'
+      mapper.errors[:attr_a].should be_present
+
+      mapper.attr_a = 5
+      mapper.save
+      mapper.attr_b.should == 'b'
+    end
+  end
+
+  describe 'Skipping ActiveRecord' do
+    let(:target){ OpenStruct.new }
+    let(:mapper){ SkippingSpec::SpecMapper.new(target, :with_trait) }
+
+    before{ target.stub(:is_a?).with(ActiveRecord::Base).and_return(true) }
+
+    context 'for new record' do
+      before do
+        target.stub(:new_record?).and_return(true)
+        mapper.trait(:with_trait).skip!
+      end
+
+      specify '#skip! should set ivar @destroyed to true' do
+        target.instance_variable_get('@destroyed').should be_true
+      end
+
+      specify '#use! should set ivar @destroyed to true' do
+        mapper.trait(:with_trait).use!
+        target.instance_variable_get('@destroyed').should be_false
+      end
+    end
+
+    context 'for persisted record' do
+      before do
+        target.stub(:new_record?).and_return(false)
+      end
+
+      specify '#skip! should reload persisted record' do
+        target.should_receive(:reload)
+        mapper.trait(:with_trait).skip!
+      end
+
+      specify '#use! should use all nested mountings' do
+        mapper.trait(:with_trait).skip!
+        mock = double('mounting')
+        mock.should_receive(:use!)
+        mapper.trait(:with_trait).stub(:all_nested_mountings).and_return([mock])
+        mapper.trait(:with_trait).use!
+      end
+    end
+  end
+end

data/spec/flat_map/mapper/targeting_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+module FlatMap
+  module ModelMethodsSpec
+    class TargetClass < Struct.new(:attr_a, :attr_b)
+    end
+
+    class OtherTargetClass < Struct.new(:attr_c, :attr_d)
+    end
+
+    module ArbitraryModule
+    end
+
+    class TargetClassMapper < Mapper
+      include ArbitraryModule
+
+      map :attr_a
+      map :dob => :attr_b, :multiparam => Date
+    end
+
+    class InheritedClassMapper < TargetClassMapper
+    end
+
+    class ExplicitNameMapper < Mapper
+      self.target_class_name = 'FlatMap::ModelMethodsSpec::OtherTargetClass'
+    end
+  end
+
+  describe 'Working with Target' do
+    describe '#target_class' do
+      it 'should detect target_class from mapper class name' do
+        ModelMethodsSpec::TargetClassMapper.target_class.should == ModelMethodsSpec::TargetClass
+      end
+
+      it 'should detect target_class from nearest ancestor when inherited' do
+        ModelMethodsSpec::InheritedClassMapper.target_class.
+                                               should == ModelMethodsSpec::TargetClass
+      end
+
+      it 'should use explicit class name if specified' do
+        ModelMethodsSpec::ExplicitNameMapper.target_class.
+                                             should == ModelMethodsSpec::OtherTargetClass
+      end
+    end
+
+    describe '.build' do
+      it 'should use target class to build a new object for mapper' do
+        ModelMethodsSpec::TargetClassMapper.
+          should_receive(:new).
+          with(kind_of(ModelMethodsSpec::TargetClass), :used_trait)
+        ModelMethodsSpec::TargetClassMapper.build(:used_trait)
+      end
+    end
+
+    describe '.find' do
+      let(:target){ ModelMethodsSpec::TargetClass.new('a', 'b') }
+
+      it 'should delegate to target class to find object for mapper' do
+        ModelMethodsSpec::TargetClass.should_receive(:find).with(1).and_return(target)
+        ModelMethodsSpec::TargetClassMapper.should_receive(:new).with(target, :used_trait)
+        ModelMethodsSpec::TargetClassMapper.find(1, :used_trait)
+      end
+    end
+
+    describe 'behavior' do
+      let(:target){ ModelMethodsSpec::TargetClass.new('a', 'b') }
+      let(:mapper){ ModelMethodsSpec::TargetClassMapper.new(target){} }
+
+      specify '#model_name' do
+        mapper.model_name.should == 'mapper'
+      end
+
+      specify '#to_key should delegate to target' do
+        target.should_receive(:to_key).and_return(1)
+        mapper.to_key.should == 1
+      end
+
+      specify '#persisted? when target does not respond to :persised?' do
+        mapper.should_not be_persisted
+      end
+
+      specify '#persisted? when target responds to :persisted?' do
+        target.stub(:persisted?).and_return(true)
+        mapper.should be_persisted
+      end
+
+      specify '#id when target does not respond to :id' do
+        mapper.id.should be_nil
+      end
+
+      specify '#id when target responds to :id' do
+        target.stub(:id).and_return(1)
+        mapper.id.should == 1
+      end
+
+      describe '#write with multiparams' do
+        let(:params) {{
+          'attr_a'     => 'A',
+          'dob(0i)' => '1999',
+          'dob(1i)' => '01',
+          'dob(2i)' => '02'
+        }}
+
+        it 'should assign values properly' do
+          mapper.write(params)
+          target.attr_a.should == 'A'
+          target.attr_b.should == Date.new(1999, 1, 2)
+        end
+      end
+
+      describe '#save_target' do
+        it 'should return true for owned mappers' do
+          mapper.extension.save_target.should be_true
+        end
+
+        it 'should return true if target does not respond to #save' do
+          mapper.save_target.should be_true
+        end
+
+        it 'should save with no validation if target responds to #save' do
+          target.should_receive(:save).with(:validate => false).and_return(true)
+          mapper.save_target.should be_true
+        end
+      end
+
+      describe '#apply' do
+        let(:params){{ :attr_a => 'A' }}
+
+        it 'should write params first' do
+          mapper.should_receive(:write).with(params)
+          ActiveRecord::Base.should_receive(:transaction).and_yield
+          mapper.apply(params)
+        end
+
+        it 'should not save if not valid' do
+          mapper.stub(:valid?).and_return(false)
+          mapper.should_not_receive(:save)
+          mapper.apply(params)
+        end
+
+        it 'should save if valid' do
+          mapper.stub(:valid?).and_return(true)
+          ActiveRecord::Base.should_receive(:transaction).and_yield
+          mapper.should_receive(:save)
+          mapper.apply(params)
+        end
+      end
+
+      specify '#shallow_save saves target in a save callbacks' do
+        mapper.should_receive(:run_callbacks).with(:save).and_yield
+        mapper.should_receive(:save_target)
+        mapper.shallow_save
+      end
+    end
+  end
+end