flatter 0.1.0 → 0.2.0

data/flatter.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-its"
   spec.add_development_dependency "simplecov", ">= 0.9"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-nav"

data/lib/flatter/mapper/attribute_methods.rb

@@ -1,7 +1,8 @@
 module Flatter
   module Mapper::AttributeMethods
     def respond_to_missing?(name, *)
-      mapping_names.map{ |name| [name, :"#{name}="] }.flatten.include?(name) || super
+      acceptable = mapping_names.map{ |name| [name, "#{name}="] }.flatten + mounting_names
+      acceptable.uniq.map(&:to_sym).include?(name) || super
     end
 
     def method_missing(name, *args, &block)
@@ -13,13 +14,79 @@ module Flatter
       send(name, *args, &block)
     end
 
+    def mounting(name)
+      find_mounting(name.to_s)
+    end
+
+    def find_mounting(name)
+      local_mountings.each do |mounting|
+        if mounting.name == name || (mounting.pluralized? && mounting.name.pluralize == name)
+          return mounting
+        end
+        nested = mounting.find_mounting(name)
+        return nested if nested.present?
+      end
+      nil
+    end
+    protected :find_mounting
+
+    def find_mounting_with(mapping_name)
+      mapping_name = mapping_name.to_s
+
+      match = local_mappings.any? do |mapping|
+        if collection? || pluralized?
+          mapping.name.pluralize == mapping_name
+        else
+          mapping.name == mapping_name
+        end
+      end
+
+      return self if match
+
+      local_mountings.each do |mounting|
+        nested = mounting.find_mounting_with(mapping_name)
+        return nested if nested.present?
+      end
+
+      nil
+    end
+    protected :find_mounting_with
+
     def attribute_methods
-      names = mapping_names
+      _mapping_names = mapping_names
+      _mounting_names = mounting_names - _mapping_names
+
       Module.new do
-        names.each do |name|
-          define_method(name){ |*args| mapping(name).read(*args) }
+        _mounting_names.each do |name|
+          define_method(name) do
+            mount = find_mounting(name)
+            if mount.collection?
+              mount.read[name.to_s]
+            elsif mount.pluralized?
+              Array(mountings[mount.name]).map(&:read)
+            else
+              mount.read
+            end
+          end
+        end
+
+        _mapping_names.each do |name|
+          define_method(name) do |*args|
+            mount = find_mounting_with(name)
+            if mount.collection? || mount.pluralized?
+              Array(mapping(name.singularize)).map{ |map| map.read(*args) }
+            else
+              mapping(name).read(*args)
+            end
+          end
 
-          define_method(:"#{name}="){ |value| mapping(name).write(value) }
+          define_method("#{name}=") do |value|
+            mount = find_mounting_with(name)
+            if mount.collection? || mount.pluralized?
+              fail RuntimeError, "Cannot directly write to a collection"
+            end
+            mapping(name).write(value)
+          end
         end
       end
     end

data/lib/flatter/mapper/collection.rb

@@ -0,0 +1,193 @@
+module Flatter
+  module Mapper::Collection
+    NonUniqKeysError = Class.new(RuntimeError)
+
+    def self.prepended(base)
+      base.send(:include, Concern)
+    end
+
+    module FactoryMethods
+      def create(*)
+        super.tap do |mapper|
+          mapper.options.merge!(collection: collection?)
+        end
+      end
+
+      def default_mapper_class_name
+        collection? ? "#{name.singularize.camelize}Mapper" : super
+      end
+
+      def collection?
+        options[:collection] == true ||
+          (options[:collection] != false && name == name.pluralize)
+      end
+    end
+
+    module Concern
+      extend ActiveSupport::Concern
+
+      included do
+        mapper_options.push(:collection, :item_index)
+        attr_accessor :item_index
+      end
+
+      module ClassMethods
+        def key(arg = nil)
+          args    = []
+          options = {writer: false}
+
+          case arg
+          when String, Symbol
+            options[:key] = arg.to_sym
+          when Proc
+            args << :key
+            options[:reader] = arg
+          else
+            fail ArgumentError, "Cannot use '#{arg}' as collection key"
+          end
+
+          map *args, **options
+        end
+      end
+
+      def remove_items(keys)
+        collection.reject! do |item|
+          (item[:key].nil? || keys.include?(item[:key])) &&
+            delete_target_item(item.target)
+        end
+      end
+      private :remove_items
+
+      def delete_target_item(item)
+        !!target.delete(item)
+      end
+
+      def update_item(key, params)
+        collection.find{ |item| item[:key] == key }.write(params)
+      end
+
+      def add_item(params)
+        collection << clone.tap do |mapper|
+          item = target_class.new
+          mapper.reset_locals!
+          mapper.set_target!(item)
+          mapper.item_index = collection.length
+          mapper.write(params)
+          add_target_item(item)
+        end
+      end
+
+      def add_target_item(item)
+        target << item
+      end
+    end
+
+    def read
+      return super unless collection?
+
+      values = collection.map(&:read)
+
+      assert_key_uniqueness!(values)
+
+      {name => values}
+    end
+
+    def write(params)
+      return super unless collection?
+      return unless params.key?(name)
+
+      data = params[name]
+      assert_collection!(data)
+
+      keys = collection.map(&:key)
+      remove_items(keys - data.map{ |p| p[:key] })
+
+      data.each do |params|
+        if params.key?(:key)
+          update_item(params[:key], params.except(:key))
+        else
+          add_item(params)
+        end
+      end
+    end
+
+    def pluralize!
+      @_pluralized = true
+    end
+
+    def pluralized?
+      !!@_pluralized
+    end
+
+    def mapping_names
+      super.map{ |name| collection? || pluralized? ? name.pluralize : name }
+    end
+
+    def mounting_names
+      super.map{ |name| pluralized? ? name.pluralize : name }
+    end
+
+    def local_mountings
+      super.each{ |mapper| mapper.pluralize! if collection? || pluralized? }
+    end
+    protected :local_mountings
+
+    def assert_key_uniqueness!(values)
+      keys = values.map{ |v| v['key'] }.compact
+      keys == keys.uniq or
+        fail NonUniqKeysError, "All keys in collection '#{name}' should be uniq, but were not"
+    end
+    private :assert_key_uniqueness!
+
+    def assert_collection!(data)
+      unless data.respond_to?(:each)
+        fail ArgumentError, "Cannot write to '#{name}': argument is not a collection"
+      end
+    end
+    private :assert_collection!
+
+    def collection
+      return nil unless collection?
+
+      @collection ||= target.each.with_index.map do |item, index|
+        clone.tap do |mapper|
+          mapper.reset_locals!
+          mapper.set_target! item
+          mapper.item_index = index
+        end
+      end
+    end
+
+    def prefix
+      return super if mounter.nil?
+
+      [mounter.prefix, item_name].compact.join(?.).presence
+    end
+    protected :prefix
+
+    def item_name
+      "#{name}.#{item_index}" if item_index.present?
+    end
+    protected :item_name
+
+    def as_inner_mountings
+      if collection?
+        ensure_target!
+        collection.map{ |item| item.as_inner_mountings }
+      else
+        super
+      end
+    end
+    protected :as_inner_mountings
+
+    def reset_locals!
+      @_local_mappings = nil
+      @_local_mountings = nil
+    end
+    protected :reset_locals!
+
+    def collection?
+      options[:collection] && item_index.nil?
+    end
+  end
+end

data/lib/flatter/mapper/factory.rb

@@ -4,6 +4,9 @@ module Flatter
     prepend Flatter::Mapper::Mounting::FactoryMethods
     prepend Flatter::Mapper::Traits::FactoryMethods
     prepend Flatter::Mapper::Options::FactoryMethods
+    prepend Flatter::Mapper::Collection::FactoryMethods
+
+    NoTargetError = Class.new(RuntimeError)
 
     attr_reader :name, :options
 
@@ -16,19 +19,36 @@ module Flatter
     end
 
     def mapper_class_name
-      options[:mapper_class_name] || "#{name.to_s.camelize}Mapper"
+      options[:mapper_class_name] || modulize(default_mapper_class_name)
+    end
+
+    def default_mapper_class_name
+      "#{name.camelize}Mapper"
+    end
+
+    def create(*)
+      mapper_class.new.tap{ |mapper| mapper.factory = self }
     end
 
-    def create(mapper)
-      mapper_class.new(fetch_target_from(mapper))
+    def modulize(class_name)
+      if i = options[:mounter_name].rindex('::')
+        "#{options[:mounter_name][0...i]}::#{class_name}"
+      else
+        class_name
+      end
     end
+    private :modulize
 
     def fetch_target_from(mapper)
       default_target_from(mapper)
     end
 
     def default_target_from(mapper)
-      mapper.target.public_send(name) if mapper.target.respond_to?(name)
+      if mapper.target.respond_to?(name)
+        mapper.target.public_send(name)
+      else
+        fail NoTargetError, "Unable to implicitly fetch target for '#{name}' from #{mapper}"
+      end
     end
     private :default_target_from
   end

data/lib/flatter/mapper/mapping.rb

@@ -37,15 +37,13 @@ module Flatter
     end
 
     def write(params)
-      params = params.with_indifferent_access
       local_mappings.each{ |mapping| mapping.write_from_params(params) }
-
-      params
     end
 
     def local_mappings
       @_local_mappings ||= self.class.mappings.values.map{ |factory| factory.create(self) }
     end
+    protected :local_mappings
 
     def mappings
       local_mappings.each_with_object({}) do |mapping, res|
@@ -54,7 +52,7 @@ module Flatter
     end
 
     def mapping_names
-      @_mapping_names ||= mappings.keys
+      local_mappings.map(&:name)
     end
 
     def writable_mapping_names

data/lib/flatter/mapper/mounting.rb

@@ -11,9 +11,14 @@ module Flatter
       end
     end
 
+    included do
+      class_attribute :label
+    end
+
     module ClassMethods
-      def mount(name, *args)
-        mountings[name.to_s] = Flatter::Mapper::Factory.new(name, *args)
+      def mount(name, **opts)
+        factory_options = opts.reverse_merge(mounter_name: self.name || label)
+        mountings[name.to_s] = Flatter::Mapper::Factory.new(name, **factory_options)
       end
 
       def mountings
@@ -35,26 +40,30 @@ module Flatter
       super.tap do |mappings|
         inner_mountings.each do |mounting|
           mounting.local_mappings.each do |mapping|
-            mappings[mapping.name] = mapping
+            mappings.merge!(mapping.name => mapping, &merging_proc)
           end
         end
       end
     end
 
+    def mapping_names
+      super + local_mountings.map(&:mapping_names).flatten
+    end
+
     def read
-      inner_mountings.map(&:read).inject(super, :merge)
+      local_mountings.map(&:read).inject(super, :merge)
     end
 
     def write(params)
-      super.tap do
-        inner_mountings.each{ |mapper| mapper.write(params) }
-      end
+      super
+      local_mountings.each{ |mapper| mapper.write(params) }
+      @_inner_mountings = nil
     end
 
     def local_mountings
       class_mountings_for(self.class)
     end
-    private :local_mountings
+    protected :local_mountings
 
     def class_mountings_for(klass)
       class_mountings(klass).map{ |factory| factory.create(self) }
@@ -67,18 +76,33 @@ module Flatter
     private :class_mountings
 
     def mountings
-      @mountings ||= inner_mountings.each_with_object({}) do |mapper, res|
-        res[mapper.full_name] = mapper
+      @mountings ||= inner_mountings.inject({}) do |res, mapper|
+        res.merge(mapper.full_name => mapper, &merging_proc)
       end
     end
 
-    def mounting(name)
-      mountings[name.to_s]
+    def mounting_names
+      local_mounting_names + local_mountings.map(&:mounting_names).flatten
     end
 
+    def local_mounting_names
+      local_mountings.map(&:name)
+    end
+    private :local_mounting_names
+
     def inner_mountings
-      @_inner_mountings ||= local_mountings.map{ |mount| [mount, mount.inner_mountings] }.flatten
+      @_inner_mountings ||= local_mountings.map{ |mount| mount.as_inner_mountings }.flatten
     end
     protected :inner_mountings
+
+    def as_inner_mountings
+      [self, inner_mountings]
+    end
+    protected :as_inner_mountings
+
+    def merging_proc
+      proc { |_, old, new| Array(old).push(new) }
+    end
+    private :merging_proc
   end
 end

data/lib/flatter/mapper/options.rb

@@ -19,7 +19,7 @@ module Flatter
     attr_reader :options
 
     def initialize(*, **options)
-      @options  = options
+      @options = options
     end
   end
 end

data/lib/flatter/mapper/persistence.rb

@@ -61,12 +61,21 @@ module Flatter
     private :self_mountings
 
     def consolidate_errors!
-      root_mountings.map(&:errors).each do |errs|
-        errors.messages.merge!(errs.to_hash){ |key, old, new| old + new }
+      root_mountings.each do |mounting|
+        prefix = mounting.prefix
+        mounting.errors.to_hash.each do |name, errs|
+          error_key = [prefix, name].compact.join('.')
+          errors.messages.merge!(error_key.to_sym => errs){ |key, old, new| old + new }
+        end
       end
     end
     private :consolidate_errors!
 
+    def prefix
+      nil
+    end
+    protected :prefix
+
     def errors
       trait? ? mounter.errors : super
     end

data/lib/flatter/mapper/target.rb

@@ -1,7 +1,13 @@
 module Flatter
   module Mapper::Target
+    extend ActiveSupport::Concern
+
     NoTargetError = Class.new(ArgumentError)
 
+    included do
+      mapper_options << :target_class_name
+    end
+
     module FactoryMethods
       def fetch_target_from(mapper)
         return super unless options.key?(:target)
@@ -19,20 +25,60 @@ module Flatter
       end
     end
 
-    attr_reader :target
-
-    def initialize(target, *)
-      unless target.present?
-        fail NoTargetError, "Target object is required to initialize #{self.class.name}"
-      end
+    attr_accessor :factory
 
+    def initialize(target = nil, *)
       super
+      set_target!(target) if target.present?
+    end
 
-      @target = target
+    def target
+      ensure_target!
+      @target
+    end
+
+    def ensure_target!
+      initialize_target unless target_initialized?
+    end
+    protected :ensure_target!
+
+    def initialize_target
+      return set_target!(mounter.target) if trait?
+
+      _mounter = mounter.trait? ? mounter.mounter : mounter
+      set_target!(factory.fetch_target_from(_mounter))
     end
+    private :initialize_target
 
     def set_target(target)
+      if trait?
+        mounter.set_target!(target)
+      else
+        set_target!(target)
+        trait_mountings.each{ |trait| trait.set_target!(target) }
+      end
+    end
+
+    def set_target!(target)
+      fail NoTargetError, "Cannot set nil target for #{self.class.name}" if target.nil?
+      @_target_initialized = true
       @target = target
     end
+
+    def target_initialized?
+      !!@_target_initialized
+    end
+
+    def target_class
+      target_class_name.constantize
+    end
+
+    def target_class_name
+      options[:target_class_name] || default_target_class_name
+    end
+
+    def default_target_class_name
+      self.class.name.sub 'Mapper', ''
+    end
   end
 end

data/lib/flatter/mapper/traits.rb

@@ -20,10 +20,6 @@ module Flatter
           mounting.extend_with(extension) if extension.present?
         end
       end
-
-      def fetch_target_from(mapper)
-        trait? ? mapper.target : super
-      end
     end
 
     module ClassMethods
@@ -31,9 +27,11 @@ module Flatter
         super.tap{ |f| f.extension = block }
       end
 
-      def trait(name, &block)
+      def trait(name, label = nil, &block)
         trait_name   = "#{name}_trait"
-        mapper_class = Class.new(Flatter::Mapper, &block)
+        mapper_class = Class.new(Flatter::Mapper)
+        mapper_class.label = self.name || label
+        mapper_class.class_eval(&block)
 
         if self.name.present?
           mapper_class_name = trait_name.camelize
@@ -46,7 +44,7 @@ module Flatter
       end
     end
 
-    def initialize(target, *traits, **, &block)
+    def initialize(_, *traits, **, &block)
       super
 
       set_traits(traits)
@@ -54,22 +52,8 @@ module Flatter
     end
 
     def extend_with(extension)
-      singleton_class.trait :extension, &extension
-    end
-
-    def set_target(target)
-      if trait?
-        mounter.set_target(target)
-      else
-        super
-        trait_mountings.each{ |trait| trait.set_target!(target) }
-      end
-    end
-
-    def set_target!(target)
-      @target = target
+      singleton_class.trait :extension, self.class.name, &extension
     end
-    protected :set_target!
 
     def full_name
       if name == 'extension_trait'
@@ -80,7 +64,7 @@ module Flatter
     end
 
     def local_mountings
-      @local_mountings ||= class_mountings_for(singleton_class) + super
+      @_local_mountings ||= class_mountings_for(singleton_class) + super
     end
     private :local_mountings
 
@@ -126,6 +110,11 @@ module Flatter
       @trait = true
     end
 
+    def local_mounting_names
+      super.reject{ |name| trait_mountings.any?{ |mount| mount.name == name } }
+    end
+    private :local_mounting_names
+
     def trait_mountings
       @_trait_mountings ||= local_mountings.select(&:trait?)
     end

data/lib/flatter/mapper/write_with_indifferent_access.rb

@@ -0,0 +1,8 @@
+module Flatter
+  module Mapper::WriteWithIndifferentAccess
+    def write(params)
+      super(params.with_indifferent_access)
+      params
+    end
+  end
+end

data/lib/flatter/mapper.rb

@@ -4,23 +4,27 @@ module Flatter
 
     autoload :Factory
     autoload :Options
-    autoload :Target
     autoload :Mapping
     autoload :Mounting
     autoload :Traits
+    autoload :Target
     autoload :AttributeMethods
     autoload :Persistence
     autoload :ModelName
+    autoload :Collection
+    autoload :WriteWithIndifferentAccess
 
     include Options
-    include Target
     include Mapping
     include Mounting
     include Traits
+    include Target
     include AttributeMethods
     include ActiveModel::Validations
     include Persistence
     prepend ModelName
+    prepend Collection
+    prepend WriteWithIndifferentAccess
 
     def self.inherited(subclass)
       subclass.mappings  = mappings.dup

data/lib/flatter/version.rb

@@ -1,3 +1,3 @@
 module Flatter
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end