flatter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f1e1af6544620264587af098834b94ddf548bac7
+  data.tar.gz: c48b5d92d0692cb453c84a84782dcfa77ea4c5f7
+SHA512:
+  metadata.gz: 05a93c13278b98f3eeb51f27095575d39a713c13c7933c6863a4f9b0cd800709b7de781afd6e36dc147021bfbd459a0977e194efc739d1a4fbec62e4c92cbce6
+  data.tar.gz: f9b66855aab233cd339eb94315abb527a81bd3cf188c8a05b679866ddf82c076264b2e906cc131cd174ea19c2a3223e2a06fcc1001c4f4c9ead9aa230df67dfd

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+.ruby-gemset
+.ruby-version

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in flatter.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Artem Kuzko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+# Flatter
+
+This gem supersedes [FlatMap](https://github.com/TMXCredit/flat_map) gem. With only it's core concepts in mind
+it has been written from complete scratch to provide more pure, clean, extensible code and reliable functionality.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'flatter'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install flatter
+
+## Usage
+
+Coming soon.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/akuzko/flatter.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "flatter"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "pry"
+Pry.start
+
+# require "irb"
+# IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/flatter.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'flatter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "flatter"
+  spec.version       = Flatter::VERSION
+  spec.authors       = ["Artem Kuzko"]
+  spec.email         = ["a.kuzko@gmail.com"]
+
+  spec.summary       = %q{Maps a deeply nested model graph to a single object with a flat set of attributes.}
+  spec.description   = %q{Flatter transforms a deeply nested graph of ActiveModel-like objects
+    to a single mapper object that handles all the nested attributes and has a very flexible behavior
+    for handling validation, saving routines with a DRY approach.}
+  spec.homepage      = "https://github.com/akuzko/flatter"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", ">= 3.2"
+  spec.add_dependency "activemodel", ">= 3.0"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov", ">= 0.9"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-nav"
+end

data/lib/flatter.rb

@@ -0,0 +1,19 @@
+require 'active_support'
+require 'active_support/core_ext'
+
+require 'active_model'
+
+require 'flatter/version'
+require 'flatter/mapping'
+require 'flatter/mapper'
+require 'flatter/extension'
+
+module Flatter
+  extend Extension::Registrar
+
+  use :scribe, require: 'flatter/mapping/scribe'
+
+  def self.configure
+    yield self
+  end
+end

data/lib/flatter/extension.rb

@@ -0,0 +1,73 @@
+module Flatter
+  module Extension
+    extend ActiveSupport::Autoload
+
+    autoload :Registrar
+    autoload :Builder
+    autoload :Mapping
+    autoload :Mapper
+    autoload :Factory
+
+    def register_as(name)
+      ::Flatter.extensions[name] = self
+    end
+    private :register_as
+
+    def depends_on(*extensions)
+      dependencies.concat extensions
+    end
+    private :depends_on
+
+    def dependencies
+      @dependencies ||= []
+    end
+
+    def hook!
+      return false if hooked?
+
+      use_dependencies
+
+      mapping.extend!
+      mapper.extend!
+      factory.extend!
+
+      hook_callback!
+
+      @hooked = true
+    end
+
+    def hooked(&block)
+      @hook_callback = block
+    end
+    private :hooked
+
+    def hook_callback!
+      instance_exec(&@hook_callback) if @hook_callback.present?
+    end
+    private :hook_callback!
+
+    def use_dependencies
+      dependencies.each{ |extension| ::Flatter.use extension }
+    end
+    private :use_dependencies
+
+    def hooked?
+      !!@hooked
+    end
+
+    def mapping
+      @mapping ||= Mapping.new(self)
+    end
+    private :mapping
+
+    def mapper
+      @mapper ||= Mapper.new(self)
+    end
+    private :mapper
+
+    def factory
+      @factory ||= Factory.new(self)
+    end
+    private :factory
+  end
+end

data/lib/flatter/extension/builder.rb

@@ -0,0 +1,70 @@
+module Flatter
+  class Extension::Builder
+    ExtensionBlockAlreadyDefined = Class.new(RuntimeError)
+
+    def self.extends(target_name)
+      @target_name = target_name
+    end
+
+    def self.target_name
+      @target_name
+    end
+
+    def initialize(ext)
+      @ext = ext
+      @new_options = []
+    end
+
+    def add_option(*options)
+      @new_options.concat options
+      extend(&Proc.new) if block_given?
+    end
+    alias_method :add_options, :add_option
+
+    def extend(&block)
+      fail ExtensionBlockAlreadyDefined if @extension_block.present?
+      @extension_block = block
+    end
+
+    def extends?
+      @new_options.present? || @extension_block.present?
+    end
+
+    def extension
+      extension = Module.new
+      extension.module_eval(new_option_helpers) if @new_options.present?
+      extension.module_eval(&@extension_block) if @extension_block.present?
+      @ext.const_set(self.class.target_name, extension)
+      extension
+    end
+    private :extension
+
+    def fail_if_options_defined!
+      options_method = self.class.target_name.underscore + '_options'
+      options = ::Flatter::Mapper.public_send(options_method)
+      already_defined = options & @new_options
+
+      if already_defined.present?
+        fail RuntimeError, "Cannot extend with #{@ext.name}: options #{already_defined} already defined"
+      end
+    end
+    private :fail_if_options_defined!
+
+    def new_option_helpers
+      code = @new_options.map do |option|
+        <<-RUBY
+          def #{option}
+            options[:#{option}]
+          end
+
+          def #{option}?
+            options.key?(:#{option})
+          end
+        RUBY
+      end
+
+      code.join("\n")
+    end
+    private :new_option_helpers
+  end
+end

data/lib/flatter/extension/factory.rb

@@ -0,0 +1,9 @@
+module Flatter
+  class Extension::Factory < Extension::Builder
+    extends 'Factory'
+
+    def extend!
+      ::Flatter::Mapper::Factory.send(:prepend, extension) if extends?
+    end
+  end
+end

data/lib/flatter/extension/mapper.rb

@@ -0,0 +1,12 @@
+module Flatter
+  class Extension::Mapper < Extension::Builder
+    extends 'Mapper'
+
+    def extend!
+      fail_if_options_defined!
+
+      ::Flatter::Mapper.mapper_options.concat @new_options
+      ::Flatter::Mapper.send(:include, extension) if extends?
+    end
+  end
+end

data/lib/flatter/extension/mapping.rb

@@ -0,0 +1,12 @@
+module Flatter
+  class Extension::Mapping < Extension::Builder
+    extends 'Mapping'
+
+    def extend!
+      fail_if_options_defined!
+
+      ::Flatter::Mapper.mapping_options.concat @new_options
+      ::Flatter::Mapping.send(:prepend, extension) if extends?
+    end
+  end
+end

data/lib/flatter/extension/registrar.rb

@@ -0,0 +1,19 @@
+module Flatter
+  module Extension::Registrar
+    UnknownExtensionError = Class.new(ArgumentError)
+
+    def extensions
+      @extensions ||= {}
+    end
+
+    def use(extension_name, **opts)
+      require opts[:require] if opts[:require].present?
+
+      extension = extensions[extension_name]
+
+      fail UnknownExtensionError, "Unknown extension #{extension_name}" if extension.nil?
+
+      extension.hook!
+    end
+  end
+end

data/lib/flatter/mapper.rb

@@ -0,0 +1,38 @@
+module Flatter
+  class Mapper
+    extend ActiveSupport::Autoload
+
+    autoload :Factory
+    autoload :Options
+    autoload :Target
+    autoload :Mapping
+    autoload :Mounting
+    autoload :Traits
+    autoload :AttributeMethods
+    autoload :Persistence
+    autoload :ModelName
+
+    include Options
+    include Target
+    include Mapping
+    include Mounting
+    include Traits
+    include AttributeMethods
+    include ActiveModel::Validations
+    include Persistence
+    prepend ModelName
+
+    def self.inherited(subclass)
+      subclass.mappings  = mappings.dup
+      subclass.mountings = mountings.dup
+    end
+
+    def inspect
+      to_s
+    end
+
+    def to_ary
+      nil
+    end
+  end
+end

data/lib/flatter/mapper/attribute_methods.rb

@@ -0,0 +1,28 @@
+module Flatter
+  module Mapper::AttributeMethods
+    def respond_to_missing?(name, *)
+      mapping_names.map{ |name| [name, :"#{name}="] }.flatten.include?(name) || super
+    end
+
+    def method_missing(name, *args, &block)
+      return super if @_attribute_methods_defined
+
+      extend attribute_methods
+      @_attribute_methods_defined = true
+
+      send(name, *args, &block)
+    end
+
+    def attribute_methods
+      names = mapping_names
+      Module.new do
+        names.each do |name|
+          define_method(name){ |*args| mapping(name).read(*args) }
+
+          define_method(:"#{name}="){ |value| mapping(name).write(value) }
+        end
+      end
+    end
+    private :attribute_methods
+  end
+end

data/lib/flatter/mapper/factory.rb

@@ -0,0 +1,35 @@
+module Flatter
+  class Mapper::Factory
+    prepend Flatter::Mapper::Target::FactoryMethods
+    prepend Flatter::Mapper::Mounting::FactoryMethods
+    prepend Flatter::Mapper::Traits::FactoryMethods
+    prepend Flatter::Mapper::Options::FactoryMethods
+
+    attr_reader :name, :options
+
+    def initialize(name, **options)
+      @name, @options = name.to_s, options
+    end
+
+    def mapper_class
+      options[:mapper_class] || mapper_class_name.constantize
+    end
+
+    def mapper_class_name
+      options[:mapper_class_name] || "#{name.to_s.camelize}Mapper"
+    end
+
+    def create(mapper)
+      mapper_class.new(fetch_target_from(mapper))
+    end
+
+    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)
+    end
+    private :default_target_from
+  end
+end

data/lib/flatter/mapper/mapping.rb

@@ -0,0 +1,76 @@
+module Flatter
+  module Mapper::Mapping
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def map(*args, **opts)
+        mappings            = opts.slice!(*mapping_options)
+        mappings_from_array = Hash[*args.zip(args).flatten]
+        mappings.merge!(mappings_from_array)
+
+        define_mappings(mappings, opts)
+      end
+
+      def define_mappings(mappings, options)
+        mappings.each do |name, target_attribute|
+          self.mappings[name.to_s] =
+            Flatter::Mapping::Factory.new(name, target_attribute, options)
+        end
+      end
+      private :define_mappings
+
+      def mapping_options
+        @@mapping_options ||= []
+      end
+
+      def mappings
+        @mappings ||= {}
+      end
+
+      def mappings=(val)
+        @mappings = val
+      end
+    end
+
+    def read
+      local_mappings.map(&:read_as_params).inject({}, :merge)
+    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
+
+    def mappings
+      local_mappings.each_with_object({}) do |mapping, res|
+        res[mapping.name] = mapping
+      end
+    end
+
+    def mapping_names
+      @_mapping_names ||= mappings.keys
+    end
+
+    def writable_mapping_names
+      mappings.select{ |_, v| !v.writer? || v.writer != false }.keys
+    end
+
+    def [](name)
+      mappings[name.to_s].try(:read)
+    end
+
+    def []=(name, value)
+      mappings[name.to_s].try(:write, value)
+    end
+
+    def mapping(name)
+      mappings[name.to_s]
+    end
+  end
+end

data/lib/flatter/mapper/model_name.rb

@@ -0,0 +1,8 @@
+module Flatter
+  module Mapper::ModelName
+    def model_name
+      target.class.respond_to?(:model_name) ?
+        target.class.model_name : super
+    end
+  end
+end

data/lib/flatter/mapper/mounting.rb

@@ -0,0 +1,84 @@
+module Flatter
+  module Mapper::Mounting
+    extend ActiveSupport::Concern
+
+    module FactoryMethods
+      def create(mapper)
+        super.tap do |mounting|
+          mounting.mounter = mapper
+          mounting.name = name
+        end
+      end
+    end
+
+    module ClassMethods
+      def mount(name, *args)
+        mountings[name.to_s] = Flatter::Mapper::Factory.new(name, *args)
+      end
+
+      def mountings
+        @mountings ||= {}
+      end
+
+      def mountings=(val)
+        @mountings = val
+      end
+    end
+
+    attr_accessor :mounter, :name
+
+    def full_name
+      [mounter.try(:name), name].compact.join('_')
+    end
+
+    def mappings
+      super.tap do |mappings|
+        inner_mountings.each do |mounting|
+          mounting.local_mappings.each do |mapping|
+            mappings[mapping.name] = mapping
+          end
+        end
+      end
+    end
+
+    def read
+      inner_mountings.map(&:read).inject(super, :merge)
+    end
+
+    def write(params)
+      super.tap do
+        inner_mountings.each{ |mapper| mapper.write(params) }
+      end
+    end
+
+    def local_mountings
+      class_mountings_for(self.class)
+    end
+    private :local_mountings
+
+    def class_mountings_for(klass)
+      class_mountings(klass).map{ |factory| factory.create(self) }
+    end
+    private :class_mountings_for
+
+    def class_mountings(klass)
+      klass.mountings.values
+    end
+    private :class_mountings
+
+    def mountings
+      @mountings ||= inner_mountings.each_with_object({}) do |mapper, res|
+        res[mapper.full_name] = mapper
+      end
+    end
+
+    def mounting(name)
+      mountings[name.to_s]
+    end
+
+    def inner_mountings
+      @_inner_mountings ||= local_mountings.map{ |mount| [mount, mount.inner_mountings] }.flatten
+    end
+    protected :inner_mountings
+  end
+end

data/lib/flatter/mapper/options.rb

@@ -0,0 +1,25 @@
+module Flatter
+  module Mapper::Options
+    extend ActiveSupport::Concern
+
+    module FactoryMethods
+      def create(*)
+        super.tap do |mapper|
+          mapper.options.merge! options.slice(*Mapper.mapper_options)
+        end
+      end
+    end
+
+    module ClassMethods
+      def mapper_options
+        @@mapper_options ||= []
+      end
+    end
+
+    attr_reader :options
+
+    def initialize(*, **options)
+      @options  = options
+    end
+  end
+end

data/lib/flatter/mapper/persistence.rb

@@ -0,0 +1,74 @@
+module Flatter
+  module Mapper::Persistence
+    extend ActiveSupport::Concern
+
+    included do
+      define_callbacks :save
+    end
+
+    delegate :persisted?, to: :target
+
+    def apply(params)
+      write(params)
+      valid? && save
+    end
+
+    def valid?(*)
+      mappers_chain(:validate).each(&:run_validations!)
+      consolidate_errors!
+      errors.empty?
+    end
+
+    def run_validations!
+      errors.clear
+      with_callbacks(:validate)
+    end
+
+    def save
+      results = mappers_chain(:save).map(&:run_save!)
+      results.all?
+    end
+
+    def run_save!
+      with_callbacks(:save){ save_target }
+    end
+
+    def mappers_chain(context)
+      root_mountings.dup.unshift(self)
+    end
+    private :mappers_chain
+
+    def save_target
+      target.respond_to?(:save) ? target.save : true
+    end
+    protected :save_target
+
+    def with_callbacks(type, chain = self_mountings, &block)
+      current = chain.shift
+      current.run_callbacks(type) do
+        chain.present? ? with_callbacks(type, chain, &block) : (yield if block_given?)
+      end
+    end
+
+    def root_mountings
+      inner_mountings.reject(&:trait?)
+    end
+    private :root_mountings
+
+    def self_mountings
+      local_mountings.select(&:trait?).unshift(self).reverse
+    end
+    private :self_mountings
+
+    def consolidate_errors!
+      root_mountings.map(&:errors).each do |errs|
+        errors.messages.merge!(errs.to_hash){ |key, old, new| old + new }
+      end
+    end
+    private :consolidate_errors!
+
+    def errors
+      trait? ? mounter.errors : super
+    end
+  end
+end

data/lib/flatter/mapper/target.rb

@@ -0,0 +1,38 @@
+module Flatter
+  module Mapper::Target
+    NoTargetError = Class.new(ArgumentError)
+
+    module FactoryMethods
+      def fetch_target_from(mapper)
+        return super unless options.key?(:target)
+
+        target = options[:target]
+
+        case target
+        when Proc then target.(mapper.target)
+        when String, Symbol
+          (mapper.private_methods + mapper.protected_methods + mapper.public_methods).include?(target.to_sym) ?
+            mapper.send(target) :
+            fail(ArgumentError, "Cannot use target #{target.inspect} with `#{mapper.name}`. Make sure #{target.inspect} is defined for #{mapper}")
+        else target
+        end
+      end
+    end
+
+    attr_reader :target
+
+    def initialize(target, *)
+      unless target.present?
+        fail NoTargetError, "Target object is required to initialize #{self.class.name}"
+      end
+
+      super
+
+      @target = target
+    end
+
+    def set_target(target)
+      @target = target
+    end
+  end
+end

data/lib/flatter/mapper/traits.rb

@@ -0,0 +1,155 @@
+module Flatter
+  module Mapper::Traits
+    extend ActiveSupport::Concern
+
+    module FactoryMethods
+      attr_accessor :extension
+
+      def traits
+        Array(options[:traits])
+      end
+
+      def trait?
+        !!options[:trait]
+      end
+
+      def create(*)
+        super.tap do |mounting|
+          mounting.set_traits(traits)
+          mounting.trait! if trait?
+          mounting.extend_with(extension) if extension.present?
+        end
+      end
+
+      def fetch_target_from(mapper)
+        trait? ? mapper.target : super
+      end
+    end
+
+    module ClassMethods
+      def mount(*, &block)
+        super.tap{ |f| f.extension = block }
+      end
+
+      def trait(name, &block)
+        trait_name   = "#{name}_trait"
+        mapper_class = Class.new(Flatter::Mapper, &block)
+
+        if self.name.present?
+          mapper_class_name = trait_name.camelize
+          const_set(mapper_class_name, mapper_class)
+
+          mount trait_name, mapper_class_name: "#{self.name}::#{mapper_class_name}", trait: true
+        else
+          mount trait_name, mapper_class: mapper_class, trait: true
+        end
+      end
+    end
+
+    def initialize(target, *traits, **, &block)
+      super
+
+      set_traits(traits)
+      extend_with(block) if block.present?
+    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
+    end
+    protected :set_target!
+
+    def full_name
+      if name == 'extension_trait'
+        super
+      else
+        name
+      end
+    end
+
+    def local_mountings
+      @local_mountings ||= class_mountings_for(singleton_class) + super
+    end
+    private :local_mountings
+
+    def class_mountings(klass)
+      mountings = super.reject do |factory|
+        factory.trait? &&
+          !(factory.name == 'extension_trait' || trait_names.include?(factory.name))
+      end
+
+      # For a given mountings list, it's trait factories are reordered according to
+      # order of the trait names specified for a given object. for example, list
+      # [m1, t1, m2, m3, t2, t3, m4] for traits list of [t2, t3, t1] will be
+      # transformed to [m1, t2, m2, m3, t3, t1, m4]
+      traits = trait_names.map{ |name| mountings.find{ |f| f.name == name } }.compact
+
+      traits.
+        map{ |t| mountings.index(t) }.
+        sort.
+        reverse.
+        each_with_index{ |index, i| mountings[index] = traits[i] }
+
+      mountings
+    end
+    private :class_mountings
+
+    def traits
+      @traits ||= []
+    end
+
+    def trait_names
+      traits.map{ |trait| "#{trait.to_s}_trait" }
+    end
+
+    def set_traits(traits)
+      @traits = traits
+    end
+
+    def trait?
+      !!@trait
+    end
+
+    def trait!
+      @trait = true
+    end
+
+    def trait_mountings
+      @_trait_mountings ||= local_mountings.select(&:trait?)
+    end
+    private :trait_mountings
+
+    def shared_methods
+      self.class.public_instance_methods(false)
+    end
+
+    def respond_to_missing?(name, *)
+      return false if trait?
+
+      trait_mountings.any? do |trait|
+        trait.shared_methods.include?(name)
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      if trait?
+        mounter.send(name, *args, &block)
+      else
+        trait = trait_mountings.detect{ |trait| trait.shared_methods.include?(name) }
+        trait ? trait.send(name, *args, &block) : super
+      end
+    end
+  end
+end

data/lib/flatter/mapping.rb

@@ -0,0 +1,43 @@
+module Flatter
+  class Mapping
+    extend ActiveSupport::Autoload
+
+    autoload :Factory
+    autoload :Scribe
+
+    attr_reader :mapper, :name, :target_attribute, :options
+
+    delegate :target, to: :mapper
+
+    def initialize(mapper, name, target_attribute, **options)
+      @mapper           = mapper
+      @name             = name.to_s
+      @target_attribute = target_attribute
+      @options          = options
+    end
+
+    def read
+      read!
+    end
+
+    def read!
+      target.public_send(target_attribute)
+    end
+
+    def write(value)
+      write!(value)
+    end
+
+    def write!(value)
+      target.public_send("#{target_attribute}=", value)
+    end
+
+    def read_as_params
+      {name => read}
+    end
+
+    def write_from_params(params)
+      write(params[name]) if params.key?(name)
+    end
+  end
+end

data/lib/flatter/mapping/factory.rb

@@ -0,0 +1,11 @@
+module Flatter
+  class Mapping::Factory
+    def initialize(*args)
+      @args = args
+    end
+
+    def create(mapper)
+      Mapping.new(mapper, *@args)
+    end
+  end
+end

data/lib/flatter/mapping/scribe.rb

@@ -0,0 +1,53 @@
+module Flatter
+  module Mapping::Scribe
+    extend Flatter::Extension
+
+    register_as :scribe
+
+    BadWriterError = Class.new(ArgumentError)
+
+    mapping.add_options :reader, :writer do
+      def read
+        return super unless reader?
+
+        case reader
+        when Proc, String, Symbol
+          args = Array((name if arity_of(reader) == 1))
+          exec_or_send(reader, args)
+        when false then nil
+        else reader
+        end
+      end
+
+      def write(value)
+        return super unless writer?
+
+        case writer
+        when Proc, String, Symbol
+          args = [value].tap{ |a| a << name if arity_of(writer) == 2 }
+          exec_or_send(writer, args)
+        when false then nil
+        else fail BadWriterError, "cannot use #{writer} for assigning values"
+        end
+      end
+
+      def read_as_params
+        reader == false ? {} : super
+      end
+
+      def arity_of(obj)
+        (obj.is_a?(Proc) ? obj : mapper.method(obj)).arity
+      end
+      private :arity_of
+
+      def exec_or_send(obj, args)
+        if obj.is_a?(Proc)
+          mapper.instance_exec(*args, &obj)
+        else
+          mapper.send(obj, *args)
+        end
+      end
+      private :exec_or_send
+    end
+  end
+end

data/lib/flatter/version.rb

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

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: flatter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Artem Kuzko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  Flatter transforms a deeply nested graph of ActiveModel-like objects
+      to a single mapper object that handles all the nested attributes and has a very flexible behavior
+      for handling validation, saving routines with a DRY approach.
+email:
+- a.kuzko@gmail.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- flatter.gemspec
+- lib/flatter.rb
+- lib/flatter/extension.rb
+- lib/flatter/extension/builder.rb
+- lib/flatter/extension/factory.rb
+- lib/flatter/extension/mapper.rb
+- lib/flatter/extension/mapping.rb
+- lib/flatter/extension/registrar.rb
+- lib/flatter/mapper.rb
+- lib/flatter/mapper/attribute_methods.rb
+- lib/flatter/mapper/factory.rb
+- lib/flatter/mapper/mapping.rb
+- lib/flatter/mapper/model_name.rb
+- lib/flatter/mapper/mounting.rb
+- lib/flatter/mapper/options.rb
+- lib/flatter/mapper/persistence.rb
+- lib/flatter/mapper/target.rb
+- lib/flatter/mapper/traits.rb
+- lib/flatter/mapping.rb
+- lib/flatter/mapping/factory.rb
+- lib/flatter/mapping/scribe.rb
+- lib/flatter/version.rb
+homepage: https://github.com/akuzko/flatter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Maps a deeply nested model graph to a single object with a flat set of attributes.
+test_files: []