flat_map 0.0.3

data/spec/flat_map/mapper/traits_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+module FlatMap
+  module TraitsSpec
+    TargetClass = Struct.new(:attr_a, :attr_b)
+    MountClass  = Struct.new(:attr_c, :attr_d)
+
+    class HostMapper < Mapper
+      map :attr_a
+
+      trait :trait_one do
+        map :attr_b
+
+        mount :spec_mount,
+          :mapper_class_name => 'FlatMap::TraitsSpec::MountMapper',
+          :target => lambda{ |_| TraitsSpec.mount_target }
+
+        def method_one
+          'one'
+        end
+
+        trait :trait_one_nested do
+          def method_one_nested
+            'nested_one'
+          end
+        end
+      end
+
+      trait :trait_two do
+        def method_two
+          method_one
+        end
+      end
+    end
+
+    class MountMapper < Mapper
+      map :attr_c, :attr_d
+    end
+
+    class EmptyMapper < Mapper; end
+
+    def self.mount_target
+      @mount_target ||= MountClass.new('c', 'd')
+    end
+
+    def self.reset_mount_target
+      @mount_target = nil
+    end
+  end
+
+  describe 'Traits' do
+    describe 'trait definition' do
+      it "should add a traited mapper factory to a class" do
+        TraitsSpec::EmptyMapper.should_receive(:mount).
+                                with(kind_of(Class), :trait_name => :a_trait).
+                                and_call_original
+        expect{ TraitsSpec::EmptyMapper.trait(:a_trait) }.
+          to change{ TraitsSpec::EmptyMapper.mountings.length }.by(1)
+        trait_mapper_class =
+          TraitsSpec::EmptyMapper.mountings.first.instance_variable_get('@identifier')
+        trait_mapper_class.name.should == 'FlatMap::TraitsSpec::EmptyMapperATraitTrait'
+      end
+    end
+
+    describe 'trait usage' do
+      let(:target){ TraitsSpec::TargetClass.new('a', 'b') }
+      let(:mount_target){ TraitsSpec.mount_target }
+      let(:mapper){ TraitsSpec::HostMapper.new(target, :trait_one) }
+      let(:trait){ mapper.trait(:trait_one) }
+
+      after{ TraitsSpec.reset_mount_target }
+
+      describe 'trait properties' do
+        subject{ trait }
+
+        it{ should_not be_extension }
+        it{ should be_owned }
+        its(:owner){ should == mapper }
+      end
+
+      it 'should be able to access trait by name' do
+        mapper.trait(:trait_one).should be_a(Mapper)
+        mapper.trait(:undefined).should be_nil
+      end
+
+      it 'should not contain unused trait' do
+        mapper.trait(:trait_two).should be_nil
+      end
+
+      it 'should have mountings of a trait' do
+        mapper.mounting(:spec_mount).should be_present
+      end
+
+      it '#read should read values with respect to trait' do
+        mapper.read.should == {
+          :attr_a => 'a',
+          :attr_b => 'b',
+          :attr_c => 'c',
+          :attr_d => 'd'
+        }
+      end
+
+      it '#write should properly distribute values' do
+        mapper.write \
+          :attr_a => 'A',
+          :attr_b => 'B',
+          :attr_c => 'C',
+          :attr_d => 'D'
+        target.attr_a.should == 'A'
+        target.attr_b.should == 'B'
+        mount_target.attr_c.should == 'C'
+        mount_target.attr_d.should == 'D'
+      end
+
+      specify 'mapper should be avle to call methods of enabled traits' do
+        mapper = TraitsSpec::HostMapper.new(target, :trait_one)
+        mapper.method_one.should == 'one'
+        expect{ mapper.method_two }.to raise_error(NoMethodError)
+      end
+
+      specify 'traits should be able to call methods of each other' do
+        mapper = TraitsSpec::HostMapper.new(target, :trait_one, :trait_two)
+        mapper.trait(:trait_two).method_two.should == 'one'
+      end
+
+      describe 'trait nesting' do
+        let(:mapper){ TraitsSpec::HostMapper.new(target, :trait_one_nested) }
+
+        it 'should still be able to have top-level trait definitions' do
+          mapper.mounting(:spec_mount).should be_present
+          mapper.method_one.should == 'one'
+        end
+
+        it 'should have new definitions' do
+          mapper.method_one_nested.should == 'nested_one'
+        end
+      end
+
+      describe 'extension trait' do
+        let(:mapper) do
+          TraitsSpec::HostMapper.new(target) do
+            map :attr_b
+
+            def writing_error=(value)
+              raise ArgumentError, 'cannot be foo' if value == 'foo'
+            rescue ArgumentError => e
+              errors.preserve :writing_error, e.message
+            end
+          end
+        end
+
+        it 'should behave like a normal trait' do
+          mapper.trait(:extension).should be_present
+          mapper.read.should include :attr_b => 'b'
+        end
+
+        it 'should be accessible' do
+          mapper.extension.should be_present
+        end
+
+        it 'should be_extension' do
+          mapper.extension.should be_extension
+        end
+
+        it "should be able to handle save exception of traits" do
+          expect{ mapper.apply(:writing_error => 'foo') }.not_to raise_error
+          mapper.errors[:writing_error].should include 'cannot be foo'
+        end
+      end
+    end
+  end
+end

data/spec/flat_map/mapper/validations_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+class SpecFooValidator < ActiveModel::EachValidator
+  def validate_each(object, attribute, value)
+    object.errors.add(attribute, "can't be foo") if value == "foo"
+  end
+end
+
+module FlatMap
+  module ValidationsSpec
+    class TargetClass < Struct.new(:attr_a, :attr_b, :attr_c)
+    end
+
+    class MountTargetClass < Struct.new(:attr_d)
+    end
+
+    class MountMapper < Mapper
+      map :attr_d
+
+      validates :attr_d, :presence => true
+    end
+
+    class HostMapper < Mapper
+      map :attr_a
+
+      validates_presence_of :attr_a
+
+      trait :with_trait do
+        map :attr_b
+
+        validates :attr_b, :spec_foo => true
+
+        set_callback :validate, :before, :set_default_attr_b, :prepend => true
+
+        def set_default_attr_b
+          self.attr_b = 'foo' if attr_b.blank?
+        end
+      end
+
+      mount :mounted,
+        :target            => lambda{ |_| ValidationsSpec::MountTargetClass.new },
+        :mapper_class_name => 'FlatMap::ValidationsSpec::MountMapper'
+    end
+  end
+
+  describe 'Validations' do
+    let(:mapper) do
+      ValidationsSpec::HostMapper.new(ValidationsSpec::TargetClass.new, :with_trait) do
+        map :attr_c
+        validates_presence_of :attr_c
+      end
+    end
+
+    it 'should not be valid' do
+      mapper.should_not be_valid
+    end
+
+    it 'should call callbacks' do
+      mapper.trait(:with_trait).should_receive(:set_default_attr_b).and_call_original
+      mapper.valid?
+      mapper.attr_b.should == 'foo'
+    end
+
+    it 'should have all the errors' do
+      mapper.valid?
+      mapper.errors[:attr_a].should == ["can't be blank"]
+      mapper.errors[:attr_b].should == ["can't be foo"]
+      mapper.errors[:attr_c].should == ["can't be blank"]
+      mapper.errors[:attr_d].should == ["can't be blank"]
+    end
+  end
+end

data/spec/flat_map/mapper_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+module FlatMap
+  describe Mapper do
+    # Place some complex behavior specs here.
+    # All specs responsible for basic modular behavior
+    # are located under spec/flat_map/mapper.
+  end
+end

data/spec/flat_map/mapping/factory_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe FlatMap::Mapping::Factory do
+  let(:factory){ described_class.new(:foo, :bar, :baz) }
+
+  specify('#create should delegate all initialization params to new mapping') do
+    mapper_stub = double('mapper')
+    FlatMap::Mapping.should_receive(:new).with(mapper_stub, :foo, :bar, :baz)
+
+    factory.create(mapper_stub)
+  end
+end

data/spec/flat_map/mapping/reader/basic_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe FlatMap::Mapping::Reader::Basic do
+  let(:target){ double('target') }
+  let(:mapping){ double('mapping') }
+  let(:reader){ described_class.new(mapping) }
+
+  specify("#read should fetch value from mapping's target_attribute") do
+    mapping.should_receive(:target).and_return(target)
+    mapping.should_receive(:target_attribute).and_return(:foo)
+    target.should_receive(:foo).and_return(:bar)
+
+    reader.read.should == :bar
+  end
+end

data/spec/flat_map/mapping/reader/formatted_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe FlatMap::Mapping::Reader::Formatted do
+  let(:value){ 'fOoBaR' }
+  let(:target){ double('target', :attr => value) }
+  let(:mapping){ double('mapping', :target => target, :target_attribute => :attr) }
+
+  context 'generic behavior' do
+    let(:reader){ described_class.new(mapping, :spec_format).extend(spec_extension) }
+    let(:spec_extension) do
+      Module.new do
+        def spec_format(value, transformation = :upcase)
+          case transformation
+          when :upcase then value.upcase
+          when :downcase then value.downcase
+          else value
+          end
+        end
+      end
+    end
+
+    specify "#read should use formatting method for fetching a value" do
+      reader.read.should == 'FOOBAR'
+      reader.read(:downcase).should == 'foobar'
+      reader.read(:unknown).should == 'fOoBaR'
+    end
+  end
+
+  context 'default formats' do
+    describe "i18n_1" do
+      let(:reader){ described_class.new(mapping, :i18n_l) }
+
+      it "should use I18n_l to format value" do
+        formatted_value = "le FooBar"
+        I18n.should_receive(:l).with(value).and_return(formatted_value)
+
+        reader.read.should == formatted_value
+      end
+    end
+
+    describe "enum" do
+      unless defined? PowerEnum
+        module ::PowerEnum; end
+        load 'flat_map/mapping/reader/formatted/formats.rb'
+      end
+
+      let(:enum){ Object.new }
+      let(:target){ double('target', :attr => enum) }
+      let(:reader){ described_class.new(mapping, :enum) }
+
+      it "should use the name property of the target object for value" do
+        enum.should_receive(:name).and_return(value)
+        reader.read.should == value
+      end
+
+      it "should be able to use the desired method to get enum's property" do
+        enum.should_receive(:description).and_return(value)
+        reader.read(:description).should == value
+      end
+    end
+  end
+end

data/spec/flat_map/mapping/reader/method_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe FlatMap::Mapping::Reader::Method do
+  let(:mapper){ double('mapper') }
+  let(:mapping){ double('mapping', :mapper => mapper) }
+  let(:reader){ described_class.new(mapping, :read_with_method) }
+
+  specify("#read delegates to mapper-defined method and passes mapping to it") do
+    mapper.should_receive(:read_with_method).with(mapping).and_return(:bar)
+
+    reader.read.should == :bar
+  end
+end

data/spec/flat_map/mapping/reader/proc_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe FlatMap::Mapping::Reader::Proc do
+  let(:target){ double('target') }
+  let(:mapping){ double('mapping', :target => target) }
+  let(:reader){ described_class.new(mapping, lambda{ |t| t.foo }) }
+
+  specify("#read should pass target to Proc object to fetch value") do
+    target.should_receive(:foo).and_return(:bar)
+
+    reader.read.should == :bar
+  end
+end

data/spec/flat_map/mapping/writer/basic_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe FlatMap::Mapping::Writer::Basic do
+  let(:target){ double('target') }
+  let(:mapping){ double('mapping') }
+  let(:writer){ described_class.new(mapping) }
+
+  specify("#write use target_attribute as writer to assign value to target") do
+    mapping.should_receive(:target).and_return(target)
+    mapping.should_receive(:target_attribute).and_return(:foo)
+    target.should_receive(:foo=).with(:bar)
+
+    writer.write(:bar)
+  end
+end

data/spec/flat_map/mapping/writer/method_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe FlatMap::Mapping::Writer::Method do
+  let(:mapper){ double('mapper') }
+  let(:mapping){ double('mapping', :mapper => mapper) }
+  let(:writer){ described_class.new(mapping, :write_with_method) }
+
+  specify("#write delegates to mapper-defined method and passes mapping and value to it") do
+    mapper.should_receive(:write_with_method).with(mapping, :foo)
+
+    writer.write(:foo)
+  end
+end

data/spec/flat_map/mapping/writer/proc_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe FlatMap::Mapping::Writer::Proc do
+  let(:target){ double('target') }
+  let(:mapping){ double('mapping', :target => target) }
+  let(:writer){ described_class.new(mapping, lambda{ |t, v| t.foo(v) }) }
+
+  specify("#write should pass target and value to Proc object for assignment") do
+    target.should_receive(:foo).with(:bar)
+
+    writer.write(:bar)
+  end
+end

data/spec/flat_map/mapping_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+module FlatMap
+  describe Mapping do
+    let(:mapper){ double('mapper', :suffixed? => false) }
+    let(:mapping){ Mapping.new(mapper, :name, :attr) }
+
+    describe "initialization" do
+      it "should be initializable" do
+        expect{ mapping }.not_to raise_error
+      end
+
+      it 'should delegate #read to reader' do
+        mapping.reader.should_receive(:read)
+        mapping.read
+      end
+
+      it 'should delegate #write to writer' do
+        mapping.writer.should_receive(:write).with(:foo)
+        mapping.write(:foo)
+      end
+
+      context "properties" do
+        let(:mapper){ double('mapper', :suffixed? => true, :suffix => 'foo') }
+
+        subject{ Mapping.new(mapper, :name, :attr, :multiparam => Date) }
+
+        its(:mapper){ should == mapper }
+        its(:name){ should == :name }
+        its(:target_attribute){ should == :attr }
+        its(:full_name){ should == :name_foo }
+        its(:multiparam){ should == Date }
+        its(:multiparam?){ should be_true }
+      end
+
+      describe "#fetch_reader" do
+        context 'default' do
+          subject{ Mapping.new(mapper, :name, :attr) }
+
+          its(:reader){ should be_a(Mapping::Reader::Basic) }
+        end
+
+        context 'method' do
+          subject{ Mapping.new(mapper, :name, :attr, :reader => :method_name) }
+
+          its(:reader){ should be_a(Mapping::Reader::Method) }
+        end
+
+        context 'proc' do
+          subject{ Mapping.new(mapper, :name, :attr, :reader => lambda{ |t| t.foo }) }
+
+          its(:reader){ should be_a(Mapping::Reader::Proc) }
+        end
+
+        context 'formatted' do
+          subject{ Mapping.new(mapper, :name, :attr, :format => :i18n_l) }
+
+          its(:reader){ should be_a(Mapping::Reader::Formatted) }
+        end
+
+        context 'blank' do
+          subject{ Mapping.new(mapper, :name, :attr, :reader => false) }
+
+          its(:reader){ should be_nil }
+        end
+      end
+    end
+
+    describe "#fetch_writer" do
+      context 'default' do
+        subject{ Mapping.new(mapper, :name, :attr) }
+
+        its(:writer){ should be_a(Mapping::Writer::Basic) }
+      end
+
+      context 'method' do
+        subject{ Mapping.new(mapper, :name, :attr, :writer => :method_name) }
+
+        its(:writer){ should be_a(Mapping::Writer::Method) }
+      end
+
+      context 'proc' do
+        subject{ Mapping.new(mapper, :name, :attr, :writer => lambda{ |t| t.foo }) }
+
+        its(:writer){ should be_a(Mapping::Writer::Proc) }
+      end
+
+      context 'blank' do
+        subject{ Mapping.new(mapper, :name, :attr, :writer => false) }
+
+        its(:writer){ should be_nil }
+      end
+    end
+
+    describe "read_as_params" do
+      it "should return mapping as key value pair" do
+        stub_target
+        mapping.read_as_params.should == {:name => "target_foo"}
+      end
+    end
+
+    describe "write_from_params" do
+      it "should set the correct value on the target from params" do
+        stub_target('value')
+        mapping.write_from_params(:name => "value")
+      end
+
+      it "should set no value on the target from params" do
+        target = stub_target
+        target.should_not_receive(:attr=)
+        mapping.write_from_params(:not_mapping_name => "value")
+        target.attr.should == 'target_foo'
+      end
+    end
+
+    def stub_target(assignment = nil)
+      target = double('target', :attr => 'target_foo')
+      mapper.stub(:target).and_return(target)
+      target.should_receive(:attr=).with(assignment) if assignment.present?
+      target
+    end
+  end
+end