flat_map 0.0.3 → 0.1.0

data/lib/flat_map/{base_mapper → open_mapper}/mapping.rb

@@ -2,7 +2,7 @@ module FlatMap
   # This module hosts all definitions required to define and use mapping
   # functionality within mapper classes. This includes mapping definition
   # methods and basic reading and writing methods.
-  module BaseMapper::Mapping
+  module OpenMapper::Mapping
     extend ActiveSupport::Concern
 
     # Mapping class macros
@@ -65,7 +65,7 @@ module FlatMap
     # Send passed +params+ +write_from_params+ method of each
     # of the mappings of +self+.
     #
-    # Overloaded in {BaseMapper::Mounting}.
+    # Overloaded in {OpenMapper::Mounting}.
     #
     # @param [Hash] params
     # @return [Hash] params
@@ -109,7 +109,7 @@ module FlatMap
     # @param [Symbol] name
     # @return [FlatMap::Mapping]
     def mapping(name)
-      mappings.find{ |_mapping| _mapping.name == name }
+      mappings.find{ |mapping| mapping.name == name }
     end
 
     # Return a list of mappings associated to +self+.

data/lib/flat_map/{base_mapper → open_mapper}/mounting.rb

@@ -6,7 +6,7 @@ module FlatMap
   #
   # Also, the +method_missing+ method is defined here to delegate the missing
   # method to the very first mounted mapper that responds to it.
-  module BaseMapper::Mounting
+  module OpenMapper::Mounting
     extend ActiveSupport::Concern
 
     included do
@@ -21,14 +21,14 @@ module FlatMap
       # mapper.
       #
       # @param [*Object] args
-      # @return [Array<FlatMap::BaseMapper::Factory>]
+      # @return [Array<FlatMap::OpenMapper::Factory>]
       def mount(*args, &block)
-        mountings << FlatMap::BaseMapper::Factory.new(*args, &block)
+        mountings << FlatMap::OpenMapper::Factory.new(*args, &block)
       end
 
       # List of mountings (factories) of a class.
       #
-      # @return [Array<FlatMap::BaseMapper>]
+      # @return [Array<FlatMap::OpenMapper>]
       def mountings
         @mountings ||= []
       end
@@ -68,14 +68,14 @@ module FlatMap
 
     # Return list of mappings to be saved before saving target of +self+
     #
-    # @return [Array<FlatMap::BaseMapper>]
+    # @return [Array<FlatMap::OpenMapper>]
     def before_save_mountings
       nearest_mountings.select{ |mount| mount.save_order == :before }
     end
 
     # Return list of mappings to be saved after target of +self+ was saved
     #
-    # @return [Array<FlatMap::BaseMapper>]
+    # @return [Array<FlatMap::OpenMapper>]
     def after_save_mountings
       nearest_mountings.reject{ |mount| mount.save_order == :before }
     end
@@ -83,16 +83,16 @@ module FlatMap
     # Return all mountings that are mouted on +self+ directly or through
     # traits.
     #
-    # @return [Array<FlatMap::BaseMapper>]
+    # @return [Array<FlatMap::OpenMapper>]
     def nearest_mountings
       mountings.map{ |mount| mount.owned? ? mount.nearest_mountings : mount }.flatten
     end
 
     # Return a list of all mountings (mapper objects) associated with +self+.
     #
-    # Overridden in {Traits}.
+    # Overridden in {Traits}. Left here for consistency.
     #
-    # @return [Array<FlatMap::BaseMapper>]
+    # @return [Array<FlatMap::OpenMapper>]
     def mountings
       @mountings ||= self.class.mountings.map{ |factory| factory.create(self) }
     end
@@ -110,7 +110,7 @@ module FlatMap
     # list of all mountings of the owner. This will allow separate traits
     # to share methods via method_missing pattern.
     #
-    # @return [Array<FlatMap::BaseMapper>] mounted mappers (including traits)
+    # @return [Array<FlatMap::OpenMapper>] mounted mappers (including traits)
     def all_mountings
       return all_nested_mountings.unshift(self) unless owned?
       owner.all_mountings
@@ -119,7 +119,7 @@ module FlatMap
 
     # Return a list of mountings that are accessible by a named mapper.
     #
-    # @return [Array<FlatMap::BaseMapper>]
+    # @return [Array<FlatMap::OpenMapper>]
     def all_nested_mountings
       mountings.dup.concat(mountings.map{ |mount| mount.send(:all_nested_mountings) }).flatten
     end
@@ -149,20 +149,20 @@ module FlatMap
     protected :all_nested_mappings
 
     # Delegate missing method to any mounted mapping that respond to it,
-    # unless those methods are protected methods of FlatMap::BaseMapper.
+    # unless those methods are protected methods of FlatMap::OpenMapper.
     #
     # NOTE: :to_ary method is called internally by Ruby 1.9.3 when we call
     # something like [mapper].flatten. And we DO want default behavior
     # for handling this missing method.
     def method_missing(name, *args, &block)
       return super if name == :to_ary ||
-                      FlatMap::BaseMapper.protected_instance_methods.include?(name)
+                              self.class.protected_instance_methods.include?(name)
 
       return self[name] if mapping(name).present?
 
-      mount = all_mountings.find{ |_mount| _mount.respond_to?(name) }
-      return super if mount.nil?
-      mount.send(name, *args, &block)
+      mounting = all_mountings.find{ |mount| mount.respond_to?(name) }
+      return super if mounting.nil?
+      mounting.send(name, *args, &block)
     end
   end
 end

data/lib/flat_map/{base_mapper → open_mapper}/persistence.rb

@@ -1,18 +1,37 @@
 module FlatMap
-  # This module provides persistence functionality for mappers. Note
-  # that term of persistence here does not imply storing information
-  # in database or other place. This module provides methods for
-  # saving operation as a work flow of applying parameters to mapper
-  # and all of its mounted mappers in a right way, running callbacks,
-  # etc.
-  #
-  # See {Mapper::Targeting} for a place where mapper targets are
-  # actually get persisted / updated.
+  # This module provides some integration between mapper and its target,
+  # which is usually an ActiveRecord model, as well as some integration
+  # between mapper and Rails forms.
   #
   # In particular, validation and save methods are defined here. And
   # the <tt>save</tt> method itself is defined as a callback. Also, Rails
   # multiparam attributes extraction is defined within this module.
-  module BaseMapper::Persistence
+  module OpenMapper::Persistence
+    extend ActiveSupport::Concern
+
+    included do
+      define_callbacks :save
+    end
+
+    # ModelMethods class macros
+    module ClassMethods
+      # Create a new mapper object wrapped around new instance of its
+      # +target_class+, with a list of passed +traits+ applied to it.
+      #
+      # @param [*Symbol] traits
+      # @return [FlatMap::OpenMapper] mapper
+      def build(*traits, &block)
+        new(target_class.new, *traits, &block)
+      end
+
+      # Default target class for OpenMapper is OpenStruct.
+      #
+      # @return [Class] class
+      def target_class
+        OpenStruct
+      end
+    end
+
     # Write a passed set of +params+. Then try to save the model if +self+
     # passes validation. Saving is performed in a transaction.
     #
@@ -63,6 +82,13 @@ module FlatMap
       before_res && target_res && after_res
     end
 
+    # Return +true+ since OpenStruct is always 'saved'.
+    #
+    # @return [true]
+    def save_target
+      true
+    end
+
     # Perform target save with callbacks call
     #
     # @return [Boolean]
@@ -70,10 +96,17 @@ module FlatMap
       run_callbacks(:save){ save_target }
     end
 
+    # Return +true+ if target was updated.
+    #
+    # @return [Boolean]
+    def persisted?
+      target != OpenStruct.new
+    end
+
     # Send <tt>:save</tt> method to all mountings in list. Will return +true+
     # only if all savings are positive.
     #
-    # @param [Array<FlatMap::BaseMapper>] mountings
+    # @param [Array<FlatMap::OpenMapper>] mountings
     # @return [Boolean]
     def save_mountings(mountings)
       mountings.map{ |mount| mount.save }.all?
@@ -128,9 +161,9 @@ module FlatMap
 
         next if param_keys.empty?
 
-        args = param_keys.inject([]) do |values, _key|
-          value = params.delete _key
-          type  = _key[/\(\d+(\w*)\)/, 1]
+        args = param_keys.inject([]) do |values, key|
+          value = params.delete key
+          type  = key[/\(\d+(\w*)\)/, 1]
           value = value.send("to_#{type}") unless type.blank?
 
           values.push value

data/lib/flat_map/{base_mapper → open_mapper}/skipping.rb

@@ -1,7 +1,11 @@
 module FlatMap
   # This helper module provides helper functionality that allow to
   # exclude specific mapper from a processing chain.
-  module BaseMapper::Skipping
+  module OpenMapper::Skipping
+    extend ActiveSupport::Autoload
+
+    autoload :ActiveRecord
+
     # Mark self as skipped, i.e. it will not be subject of
     # validation and saving chain.
     #
@@ -25,7 +29,7 @@ module FlatMap
       !!@_skip_processing
     end
 
-    # Override {FlatMap::BaseMapper::Persistence#valid?} to
+    # 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
@@ -36,7 +40,7 @@ module FlatMap
       skipped? || super
     end
 
-    # Override {FlatMap::BaseMapper::Persistence#save} method to
+    # Override {FlatMap::OpenMapper::Persistence#save} method to
     # force it to return +true+ if +self+ is marked for skipping.
     #
     # @return [Boolean]
@@ -44,7 +48,7 @@ module FlatMap
       skipped? || super
     end
 
-    # Override {FlatMap::BaseMapper::Persistence#shallow_save} method
+    # Override {FlatMap::OpenMapper::Persistence#shallow_save} method
     # to make it possible to skip traits.
     #
     # @return [Boolean]
@@ -53,7 +57,7 @@ module FlatMap
     end
 
     # Mark self as used and then delegated to original
-    # {FlatMap::BaseMapper::Persistence#write}.
+    # {FlatMap::OpenMapper::Persistence#write}.
     def write(*)
       use!
       super

data/lib/flat_map/{base_mapper → open_mapper}/traits.rb

@@ -1,7 +1,10 @@
 module FlatMap
   # This small module allows mappers to define traits, which technically
   # means mounting anonymous mappers, attached to host one.
-  module BaseMapper::Traits
+  #
+  # Also, FlatMap::OpenMapper::Mounting#mountings completely overridden
+  # here to support special trait behavior.
+  module OpenMapper::Traits
     extend ActiveSupport::Concern
 
     # Traits class macros
@@ -13,7 +16,7 @@ module FlatMap
       #
       # @param [Symbol] name
       def trait(name, &block)
-        base_class        = self < FlatMap::Mapper ? FlatMap::Mapper : FlatMap::EmptyMapper
+        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 }
@@ -21,19 +24,17 @@ module FlatMap
       end
     end
 
-    # Override the original {FlatMap::BaseMapper::Mounting#mountings}
+    # 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::BaseMapper>]
+    # @return [Array<FlatMap::OpenMapper>]
     def mountings
       @mountings ||= begin
-        mountings = self.class.mountings.
-                               reject{ |factory|
-                                 factory.traited? &&
-                                 !factory.required_for_any_trait?(traits)
-                               }
+        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
@@ -42,7 +43,7 @@ module FlatMap
     # 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::BaseMapper>]
+    # @return [Array<FlatMap::OpenMapper>]
     def self_mountings
       mountings.select(&:owned?).map{ |mount| mount.self_mountings }.flatten.concat [self]
     end
@@ -52,21 +53,21 @@ module FlatMap
     # in some scenarios.
     #
     # @param [Symbol] trait_name
-    # @return [FlatMap::BaseMapper, nil]
+    # @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::BaseMapper]
+    # @return [FlatMap::OpenMapper]
     def extension
       trait(:extension)
     end
 
     # Return only mountings that are actually traits for host mapper.
     #
-    # @return [Array<FlatMap::BaseMapper>]
+    # @return [Array<FlatMap::OpenMapper>]
     def trait_mountings
       result = mountings.select{ |mount| mount.owned? }
       # mapper extension has more priority then traits, and
@@ -78,7 +79,7 @@ module FlatMap
 
     # Return only mountings that correspond to external mappers.
     #
-    # @return [Array<FlatMap::BaseMapper>]
+    # @return [Array<FlatMap::OpenMapper>]
     def mapper_mountings
       mountings.select{ |mount| !mount.owned? }
     end

data/lib/flat_map/version.rb

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

data/spec/flat_map/mapper/factory_spec.rb

@@ -1,13 +1,13 @@
 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) }
+  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 }
@@ -27,21 +27,36 @@ module FlatMap
       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 < Mapper; end
-        class BaseMapper::Factory::SpecMountMapper; end
+        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 use options if specified" do
-          factory = BaseMapper::Factory.new(
+          factory = OpenMapper::Factory.new(
                       :spec_mount,
-                      :mapper_class_name => 'FlatMap::BaseMapper::Factory::SpecMountMapper'
+                      :mapper_class_name => 'FlatMap::OpenMapper::Factory::SpecMountMapper'
                     )
-          factory.mapper_class.should == ::FlatMap::BaseMapper::Factory::SpecMountMapper
+          factory.mapper_class.should == ::FlatMap::OpenMapper::Factory::SpecMountMapper
         end
       end
 
@@ -52,19 +67,28 @@ module FlatMap
 
         context 'explicit target' do
           it "should use explicitly specified if applicable" do
-            factory = BaseMapper::Factory.new(:mount, :target => other_target)
+            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 = BaseMapper::Factory.new(:mount, :target => lambda{ |obj| obj.foo })
+            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{ target.stub(:kind_of?).with(ActiveRecord::Base).and_return(true) }
+          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})
@@ -153,16 +177,6 @@ module FlatMap
           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 }
@@ -188,7 +202,7 @@ module FlatMap
           end
 
           context 'when suffix is defined' do
-            let(:factory){ BaseMapper::Factory.new(:spec_mount, :suffix => :foo) }
+            let(:factory){ OpenMapper::Factory.new(:spec_mount, :suffix => :foo) }
 
             it "should adjust properties with suffix" do
               new_one = factory.create(mapper)
@@ -199,7 +213,7 @@ module FlatMap
 
           context 'when extension is present' do
             let(:extension){ Proc.new{} }
-            let(:factory){ BaseMapper::Factory.new(:spec_mount, &extension) }
+            let(:factory){ OpenMapper::Factory.new(:spec_mount, &extension) }
 
             it "should pass it to mapper initialization" do
               mount_class.should_receive(:new).
@@ -210,26 +224,31 @@ module FlatMap
           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
+            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
-              mount_factory.stub(:reflection_from_target).
-                            and_return(double('reflection', :macro => :belongs_to))
+              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.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