flat_map 0.0.3 → 0.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NjNmMzU5MGI0NjIwZGQyZmY4YzBlM2RhYzFmYTMzNGJmM2ZiMzIzMA==
+    NmZiN2RlYjcwY2U5YmIzMzAyYWM3ZGE3NzA4NDQyMDI2OGE0MDFhYw==
   data.tar.gz: !binary |-
-    NjAxZjRjYThiNWMxN2QwN2NkMWNkODFhZDg0NjEzZDQ0MGE5YWM5ZQ==
-SHA512:
+    MTYwMjllODAzY2IwNDQ4ZGNiNTJmZDA2NzgxMDU0N2ZkZDEzN2EwMA==
+!binary "U0hBNTEy":
   metadata.gz: !binary |-
-    N2M2NmQzZmFkMjZjMjg3NThmZjhjN2I0YmI2NGMyMWQxZTcyNTYwYTFmNzJj
-    NmM0Yzc1NDg4YWM1MmM1ZGE3ZTA3MTUzZTNmNjgwZGZkZDYxN2ViMzliNDVl
-    NWQ4Yjg3ZDI5NTg2MmZiOTQ2ZjQ5ODk1YTUwODQyN2JmNzIxNDQ=
+    ZDU4ZDYzYzAzYTBhMDkwZDRlODliODc3ODcyMWM3ODE2YzZkYWVhMmMwN2Nj
+    NWJkNDdhOTc1N2RiMTkwZjFlOGYzOGVlZWY4ZjlhZDliZjQ3YmEwYWY2YjU0
+    YTJiMDA0ZjdiMWQ4NGQzYjQwZGEyMzIyNzAwNWYzZjBmMWUxNjQ=
   data.tar.gz: !binary |-
-    ZTg1ZmI2NzY1NjA3ZGYyYzQ1NTAwYzFlMDUxODY2Y2M5YmNlMWI5YTNkNWYx
-    MTI5NGQwNDA5YmQwOTNjOTJiYmRhZDdjYWY0YTkwMzU4MzQxM2FlYjU5Nzgy
-    YzlkYmEzNmNlM2ExNTA5M2E5Y2E1OGFlNDViYmU1MGVmYzg5M2U=
+    N2UyMjkzNmRkNjQ0OWI0YmYyOGEwMDE2ZjFjYzc2MWFkN2MxMjZlZTM4MDQ2
+    YThhYzUyYzkwZDcxMzFmODI5MzQ0MDQ2M2M5MmQzY2UzMzljODYzMmI2NmUw
+    OTQ2MmNkNTljMjgyYmEwN2NhMzJhYTBjZjhlMDgzMDZkOTJmOTA=

data/lib/flat_map.rb

@@ -1,9 +1,14 @@
+require 'ostruct'
 require 'active_support/core_ext'
 require 'active_record'
 
 require "flat_map/version"
 require 'flat_map/mapping'
 require 'flat_map/errors'
-require 'flat_map/base_mapper'
-require 'flat_map/mapper'
-require 'flat_map/empty_mapper'
+require 'flat_map/open_mapper'
+require 'flat_map/model_mapper'
+
+module FlatMap
+  # for backwards compatability
+  Mapper = ModelMapper
+end

data/lib/flat_map/{mapper.rb → model_mapper.rb}

@@ -180,34 +180,15 @@ module FlatMap
   #   mapper.read[:first_name] # => John
   #   mapper.first_name # => 'John'
   #   mapper.last_name = 'Smith'
-  class Mapper < BaseMapper
+  class ModelMapper < OpenMapper
     extend ActiveSupport::Autoload
 
-    autoload :Targeting
+    autoload :Persistence
     autoload :Skipping
 
-    include Targeting
+    include Persistence
     include Skipping
 
-    attr_reader :target
-
     delegate :logger, :to => :target
-
-    # Initializes +mapper+ with +target+ and +traits+, which are
-    # used to fetch proper list of mounted mappers. Raises error
-    # if target is not specified.
-    #
-    # @param [Object] target Target of mapping
-    # @param [*Symbol] traits List of traits
-    # @raise [FlatMap::Mapper::NoTargetError]
-    def initialize(target, *traits)
-      raise Targeting::NoTargetError.new(self.class) unless target.present?
-
-      @target, @traits = target, traits
-
-      if block_given?
-        singleton_class.trait :extension, &Proc.new
-      end
-    end
   end
 end

data/lib/flat_map/{mapper/targeting.rb → model_mapper/persistence.rb}

@@ -1,23 +1,10 @@
 module FlatMap
-  # 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.
-  module Mapper::Targeting
-    # Raised when mapper is initialized with no target defined
-    class NoTargetError < ArgumentError
-      # Initializes exception with a name of mapper class.
-      #
-      # @param [Class] mapper_class class of mapper being initialized
-      def initialize(mapper_class)
-        super("Target object is required to initialize #{mapper_class.name}")
-      end
-    end
-
+  # This module enhances and modifies original FlatMap::OpenMapper::Persistance
+  # functionality for ActiveRecord models as targets.
+  module ModelMapper::Persistence
     extend ActiveSupport::Concern
 
     included do
-      define_callbacks :save
-
       # Writer of the target class name. Allows manual control over target
       # class of the mapper, for example:
       #
@@ -29,15 +16,6 @@ module FlatMap
 
     # 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::Mapper] mapper
-      def build(*traits, &block)
-        new(target_class.new, *traits, &block)
-      end
-
       # Find a record of the +target_class+ by +id+ and use it as a
       # target for a new mapper, with a list of passed +traits+ applied
       # to it.
@@ -71,8 +49,8 @@ module FlatMap
       #
       # @return [String]
       def default_target_class_name
-        ancestor_classes = ancestors.select{ |ancestor| ancestor.is_a? Class }
-        base_mapper_index = ancestor_classes.index(::FlatMap::Mapper)
+        ancestor_classes  = ancestors.select{ |ancestor| ancestor.is_a? Class }
+        base_mapper_index = ancestor_classes.index(::FlatMap::ModelMapper)
         ancestor_classes[base_mapper_index - 1].name[/^([\w:]+)Mapper.*$/, 1]
       end
     end

data/lib/flat_map/{mapper → model_mapper}/skipping.rb

@@ -1,8 +1,8 @@
 module FlatMap
-  # This helper module slightly enhances functionality of the
-  # {BaseMapper::Skipping} module for most commonly used +ActiveRecord+ targets.
-  # This is done to improve modularity of the {FlatMap} mappers.
-  module Mapper::Skipping
+  # This helper module slightly enhances ofunctionality of the
+  # {FlatMap::OpenMapper::Skipping} module for most commonly
+  # used +ActiveRecord+ targets.
+  module ModelMapper::Skipping
     # Extend original #skip! method for Rails-models-based targets
     #
     # Note that this will mark the target record as

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

@@ -1,9 +1,17 @@
 module FlatMap
-  # +BaseMapper+ is an abstract class that hosts overwhelming majority
-  # of common functionality of {EmptyMapper EmptyMappers} and {Mapper Mappers}.
-  #
-  # For more detailed information on what mappers are, refer to {Mapper} documentation.
-  class BaseMapper
+  # Base Mapper that can be used for mounting other mappers, handling business logic,
+  # etc. For the intentional usage of mappers, pleas see {ModelMapper}
+  class OpenMapper
+    # Raised when mapper is initialized with no target defined
+    class NoTargetError < ArgumentError
+      # Initializes exception with a name of mapper class.
+      #
+      # @param [Class] mapper_class class of mapper being initialized
+      def initialize(mapper_class)
+        super("Target object is required to initialize #{mapper_class.name}")
+      end
+    end
+
     extend ActiveSupport::Autoload
 
     autoload :Mapping
@@ -22,8 +30,8 @@ module FlatMap
     include Persistence
     include Skipping
 
-    attr_reader :traits
     attr_writer :host, :suffix
+    attr_reader :target, :traits
     attr_accessor :owner, :name
 
     # Callback to dup mappings and mountings on inheritance.
@@ -38,11 +46,21 @@ module FlatMap
       subclass.mountings = mountings.dup
     end
 
-    # Raise exception on trying to initialize an instance.
+    # Initializes +mapper+ with +target+ and +traits+, which are
+    # used to fetch proper list of mounted mappers. Raises error
+    # if target is not specified.
     #
-    # @raise [RuntimeError]
-    def initialize
-      raise 'BaseMapper is abstract class and cannot be initialized'
+    # @param [Object] target Target of mapping
+    # @param [*Symbol] traits List of traits
+    # @raise [FlatMap::Mapper::NoTargetError]
+    def initialize(target, *traits)
+      raise NoTargetError.new(self.class) unless target.present?
+
+      @target, @traits = target, traits
+
+      if block_given?
+        singleton_class.trait :extension, &Proc.new
+      end
     end
 
     # Return a simple string representation of +mapper+. Done so to

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

@@ -8,22 +8,22 @@ module FlatMap
   # 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.
-  module BaseMapper::AttributeMethods
+  module OpenMapper::AttributeMethods
     # Lazily define reader and writer methods for all mappings available
     # to the mapper, and extend +self+ with it.
     def method_missing(name, *args, &block)
       if name == :to_ary ||
           @attribute_methods_defined ||
-          FlatMap::BaseMapper.protected_instance_methods.include?(name)
+          self.class.protected_instance_methods.include?(name)
         return super
       end
 
       mappings    = all_mappings
-      valid_names = mappings.map{ |_mapping|
-                      mapping_full_name = _mapping.full_name
-                      [ mapping_full_name,
-                        "#{mapping_full_name}=".to_sym ]
-                    }.flatten
+      valid_names = mappings.map do |mapping|
+        full_name = mapping.full_name
+        [full_name, "#{full_name}=".to_sym]
+      end
+      valid_names.flatten!
 
       return super unless valid_names.include?(name)
 
@@ -39,12 +39,13 @@ module FlatMap
     # @return [Module] module with method definitions
     def attribute_methods(mappings)
       Module.new do
-        mappings.each do |_mapping|
-          mapping_full_name = _mapping.full_name
-          define_method(mapping_full_name){ |*args| _mapping.read(*args) }
+        mappings.each do |mapping|
+          full_name = mapping.full_name
+
+          define_method(full_name){ |*args| mapping.read(*args) }
 
-          define_method("#{mapping_full_name}=") do |value|
-            _mapping.write(value)
+          define_method("#{full_name}=") do |value|
+            mapping.write(value)
           end
         end
       end

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

@@ -3,7 +3,7 @@ module FlatMap
   # and to instantiate and setup corresponding mapper objects thereafter.
   # Factory objects are stored by mapper classes in opposite to actual
   # mounted mappers that are stored by mapper objects themselves.
-  class BaseMapper::Factory
+  class OpenMapper::Factory
     # Initializes factory with an identifier (name of a mounted mapper,
     # or the actual class for a trait) and a set of options. Those args
     # are used to create actual mapper object for the host mapper.
@@ -46,69 +46,83 @@ module FlatMap
     # Return the anonymous trait class if the factory defines a trait.
     # Fetch and return the class of a mapper defined by a symbol.
     #
-    # @return [Class] ancestor of {FlatMap::BaseMapper}
+    # @return [Class] ancestor of {FlatMap::OpenMapper}
     def mapper_class
-      return @identifier if traited?
+      @mapper_class ||= begin
+        case
+        when traited?        then @identifier
+        when @options[:open] then open_mapper_class
+        else
+          class_name = @options[:mapper_class_name] || "#{name.to_s.camelize}Mapper"
+          class_name.constantize
+        end
+      end
+    end
 
-      class_name = @options[:mapper_class_name] || "#{name.to_s.camelize}Mapper"
-      class_name.constantize
+    # Return descendant of +OpenMapper+ class to be used when mounting
+    # open mappers.
+    #
+    # @return [Class]
+    def open_mapper_class
+      klass = Class.new(OpenMapper)
+      klass_name = "#{name.to_s.camelize}Mapper"
+      klass.singleton_class.send(:define_method, :name){ klass_name }
+      klass
     end
 
-    # Return +true+ if factory should create targeted mapper.
+    # Return +true+ if mapper to me mounted is +ModelMapper+
     #
     # @return [Boolean]
-    def targeted_mount?
-      mapper_class < Mapper
+    def model_mount?
+      mapper_class < ModelMapper
+    end
+
+    # Return +true+ if mapper to me mounted is not +ModelMapper+, i.e. +OpenMapper+.
+    #
+    # @return [Boolean]
+    def open_mount?
+      !model_mount?
     end
 
     # Fetch the target for the mapper being created based on target of a host mapper.
     #
-    # @param [FlatMap::BaseMapper] mapper Host mapper
+    # @param [FlatMap::OpenMapper] mapper Host mapper
     # @return [Object] target for new mapper
     def fetch_target_from(mapper)
-      return explicit_target!(mapper) if mapper.is_a?(EmptyMapper) && targeted_mount?
-
       owner_target = mapper.target
 
       return owner_target if traited?
 
-      explicit_target(owner_target)         ||
-      target_from_association(owner_target) ||
-      target_from_name(owner_target)
+      if open_mount?
+        explicit_target(mapper) || new_target
+      else
+        explicit_target(mapper) ||
+          target_from_association(owner_target) ||
+          target_from_name(owner_target) ||
+          new_target
+      end
     end
 
-    # When creating mappers mounted on top of EmptyMapper, target cannot be implicitly
-    # fetched from it and should be specified explicitly.
+    # Return new instance of +target_class+ of the mapper.
     #
-    # @param [FlatMap::EmptyMapper] mapper Host empty mapper
-    # @return [Object] target for new mapper
-    def explicit_target!(mapper)
-      target = @options[:target]
-
-      if target.present?
-        case target
-        when Proc   then target.call
-        when Symbol then mapper.send(target)
-        else target
-        end
-      else
-        raise Mapper::Targeting::NoTargetError.new(mapper_class)
-      end
+    # @return [Object]
+    def new_target
+      mapper_class.target_class.new
     end
 
     # Try to use explicit target definition passed in options to fetch a
     # target. If this value is a +Proc+, will call it with owner target as
     # argument.
     #
-    # @param [Object] owner_target
+    # @param [FlatMap::OpenMapper] mapper
     # @return [Object, nil] target for new mapper.
-    def explicit_target(owner_target)
+    def explicit_target(mapper)
       if @options.key?(:target)
         target = @options[:target]
-        if target.is_a? Proc
-          target.call(owner_target)
-        else
-          target
+        case target
+        when Proc   then target.call(mapper.target)
+        when Symbol then mapper.send(target)
+        else target
         end
       end
     end
@@ -132,7 +146,7 @@ module FlatMap
     #                # it based on :has_many association, i.e. foo.bars.build
     #   end
     def target_from_association(owner_target)
-      return unless owner_target.kind_of?(ActiveRecord::Base)
+      return unless owner_target.is_a?(ActiveRecord::Base)
 
       reflection = reflection_from_target(owner_target)
       return unless reflection.present?
@@ -145,7 +159,6 @@ module FlatMap
         owner_target.send(name) || owner_target.send("build_#{name}")
       when reflection_macro == :has_many
         owner_target.association(reflection.name).build
-      else # nil
       end
     end
 
@@ -157,8 +170,8 @@ module FlatMap
     def reflection_from_target(target)
       return unless name.present? && target.is_a?(ActiveRecord::Base)
       target_class = target.class
-      reflection   = target_class.reflect_on_association(name)
-      reflection  || target_class.reflect_on_association(name.to_s.pluralize.to_sym)
+      reflection  = target_class.reflect_on_association(name)
+      reflection || target_class.reflect_on_association(name.to_s.pluralize.to_sym)
     end
 
     # Send the name of the mounting to the target of the host mapper, and use
@@ -173,10 +186,10 @@ module FlatMap
     # be created should be saved. In particular, targets of <tt>:belongs_to</tt>
     # associations should be saved before target of +mapper+ is saved.
     #
-    # @param [FlatMap::BaseMapper] mapper
+    # @param [FlatMap::OpenMapper] mapper
     # @return [Symbol]
     def fetch_save_order(mapper)
-      return :after if mapper.is_a?(EmptyMapper)
+      return :after unless mapper.is_a?(ModelMapper)
 
       reflection = reflection_from_target(mapper.target)
       return unless reflection.present?
@@ -188,24 +201,16 @@ module FlatMap
     # Otherwise, assign the name of the factory to it to be able to find it
     # later on.
     #
-    # @param [FlatMap::BaseMapper] mapper Host mapper
+    # @param [FlatMap::OpenMapper] mapper Host mapper
     # @param [*Symbol] owner_traits List of traits to be applied to a newly created mapper
     def create(mapper, *owner_traits)
       save_order = @options[:save] || fetch_save_order(mapper) || :after
-      all_traits = (traits + owner_traits).uniq
-
-      new_one =
-        if targeted_mount? then
-          mapper_class.new(fetch_target_from(mapper), *all_traits, &@extension)
-        else
-          mapper_class.new(*all_traits, &@extension)
-        end
-
+      new_one = mapper_class.new(fetch_target_from(mapper), *(traits + owner_traits).uniq, &@extension)
       if traited?
         new_one.owner = mapper
       else
-        new_one.host       = mapper
-        new_one.name       = @identifier
+        new_one.host = mapper
+        new_one.name = @identifier
         new_one.save_order = save_order
 
         if (suffix = @options[:suffix] || mapper.suffix).present?
@@ -229,10 +234,10 @@ module FlatMap
       return true unless traited?
 
       traits.include?(trait_name) ||
-        mapper_class.mountings.any?{ |factory|
+        mapper_class.mountings.any? do |factory|
           factory.traited? &&
-          factory.required_for_any_trait?(traits)
-        }
+            factory.required_for_any_trait?(traits)
+        end
     end
   end
 end