composition 1.0.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 87b706985a087f9b5576f1cd7d4b59e21ce83636
+  data.tar.gz: 620c33e2f2c1bdb8502334bcd63768a79caa3aa6
+SHA512:
+  metadata.gz: f72b8800a0ee152194ee3e57aef74c9e076e11edb4526bcc6a370ac8e61a990a31585a25a556c2ece4029f472d54fd17cbe7313f69381cafadb87110d94ddbb3
+  data.tar.gz: 8979cd300b8dc32f81efb27aadd9fdee6e186b4671185ff94ee722578b69581f2e7242c77adc4ac0b99c47960f48b7e2a65824d42a623a174dfbaeddd113d24f

data/lib/composition.rb

@@ -0,0 +1,9 @@
+require 'composition/reflection'
+require 'composition/macros/compose'
+require 'composition/macros/composed_from'
+require 'composition/compositions/composition'
+require 'composition/compositions/compose'
+require 'composition/compositions/composed_from'
+require 'composition/builders/compose'
+require 'composition/builders/composed_from'
+require 'composition/base'

data/lib/composition/base.rb

@@ -0,0 +1,7 @@
+module Composition
+  class Base
+    include ActiveModel::Model
+    include Composition::Reflection
+    include Composition::Macros::ComposedFrom
+  end
+end

data/lib/composition/builders/compose.rb

@@ -0,0 +1,33 @@
+module Composition
+  module Builders
+    class Compose
+      attr_reader :object
+      delegate :_composition_reflections, to: :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      def def_composition_methods
+        _composition_reflections.each_value do |composition|
+          def_composition_getter(composition)
+          def_composition_setter(composition)
+        end
+      end
+
+      private
+
+      def def_composition_getter(composition)
+        define_method(composition.name) { composition.getter(self) }
+      end
+
+      def def_composition_setter(composition)
+        define_method("#{composition.name}=") { |setter_value| composition.setter(self, setter_value) }
+      end
+
+      def define_method(method_name, &block)
+        @object.class.send(:define_method, method_name, &block)
+      end
+    end
+  end
+end

data/lib/composition/builders/composed_from.rb

@@ -0,0 +1,39 @@
+module Composition
+  module Builders
+    class ComposedFrom
+      attr_reader :object
+      delegate :_composition_reflections, to: :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      # TODO: add documentation
+      def def_composition_setters
+        _composition_reflections.each_value do |composition|
+          composition.aliases.each do |attr|
+            def_attr_reader(attr)
+            define_method("#{attr}=") { |setter_value| composition.setter(self, attr, setter_value) }
+            define_method(:attributes) { composition.attributes(self) }
+            define_method(:to_h) { composition.attributes(self) }
+          end
+          def_attr_accessor(composition.name)
+        end
+      end
+
+      private
+
+      def define_method(method_name, &block)
+        @object.class.send(:define_method, method_name, &block)
+      end
+
+      def def_attr_accessor(*attr)
+        @object.class.send(:attr_accessor, *attr)
+      end
+
+      def def_attr_reader(*attr)
+        @object.class.send(:attr_reader, *attr)
+      end
+    end
+  end
+end

data/lib/composition/compositions/compose.rb

@@ -0,0 +1,84 @@
+module Composition
+  module Compositions
+    class Compose < ::Composition::Compositions::Composition
+
+      # For a composition defined like:
+      #
+      #   class User < ActiveRecord::Base
+      #     compose :credit_card,
+      #             mapping: {
+      #               credit_card_name: :name,
+      #               credit_card_brand: :brand
+      #             }
+      #   end
+      #
+      # The getter method will be in charge of implementing @user.credit_card.
+      #
+      # It is responsible for instantiating a new CreditCard object with the attributes
+      # from the de-normalized columns in User, and then return it.
+      def getter(ar)
+        attributes = attributes(ar)
+        klass.new(attributes.merge(composed_from.name => ar)).tap(&:valid?) unless all_blank?(attributes)
+      end
+
+      # For a composition defined like:
+      #
+      #   class User < ActiveRecord::Base
+      #     compose :credit_card,
+      #             mapping: {
+      #               credit_card_name: :name,
+      #               credit_card_brand: :brand
+      #             }
+      #   end
+      #
+      # The setter method will be in charge of implementing @user.credit_card=.
+      #
+      # setter_value can be either a credit_card instance or a hash of attributes
+      # and the setter will only set the @credit_card attributes that are included
+      # in the hash. This means that if a credit_card attribute is not given in the hash
+      # then we'll set it with the value from the @user de-normalized column. The reason
+      # behind this is to imitate how ActiveRecord assign_attributes method works.
+      def setter(ar, setter_value)
+        nil_columns(ar) and return if setter_value.nil?
+        attributes = setter_value.to_h.with_indifferent_access
+
+        mapping.each do |actual_column, composed_alias|
+          ar.send("#{actual_column}=", attributes[composed_alias]) if attributes.key?(composed_alias)
+        end
+
+        setter_value
+      end
+
+      def mapping
+        @options[:mapping]
+      end
+
+      def actual_column_for(aliased_attribute)
+        mapping.key(aliased_attribute)
+      end
+
+      private
+
+      # Returns the hash of attributes for instantiating the composition defined for a given
+      # class.
+      def attributes(ar)
+        mapping.each_with_object({}) do |(actual_column, composed_alias), memo|
+          memo[composed_alias] = ar.send(actual_column)
+        end
+      end
+
+      def all_blank?(attributes = {})
+        attributes.all? { |_, value| value.blank? }
+      end
+
+      def nil_columns(ar)
+        mapping.each { |actual_column, _| ar.send("#{actual_column}=", nil) }
+      end
+
+      # TODO: Add descriptive error if find returns nil. "composed_from is missing"
+      def composed_from
+        klass._composition_reflections.find { |_, composition| composition.class_name == inverse_of }.last
+      end
+    end
+  end
+end

data/lib/composition/compositions/composed_from.rb

@@ -0,0 +1,72 @@
+module Composition
+  module Compositions
+    class ComposedFrom < ::Composition::Compositions::Composition
+      delegate :mapping, to: :inverse_of_composition
+
+      # For a composition defined like:
+      #
+      #  class User < ActiveRecord::Base
+      #    compose :credit_card,
+      #            mapping: {
+      #              credit_card_name: :name,
+      #              credit_card_brand: :brand
+      #            }
+      #  end
+      #
+      #  class CreditCard < Composition::Base
+      #    composed_from :user
+      #  end
+      #
+      # The setter method will be in charge of implementing @credit_card.name= and @credit_card.brand=.
+      #
+      # If calling @credit_card.name= it will take care of updating the @name instance variable in
+      # @credit_card, but also will take care of keeping @user.credit_card_name in sync with it.
+      def setter(obj, setter_attr, setter_value)
+        set_instance_variable(obj, setter_attr, setter_value)
+        set_parent_attribute(obj, setter_attr, setter_value)
+        setter_value
+      end
+
+      #TODO: Add documentation
+      def attributes(obj)
+        aliases.each_with_object({}) do |attr, memo|
+          value = obj.send(attr)
+          if value.respond_to?(:attributes)
+            memo[attr] = value.send(:attributes)
+          else
+            memo[attr] = value
+          end
+        end
+      end
+
+      def aliases
+        mapping.values
+      end
+
+      private
+
+      def set_instance_variable(obj, setter_attr, setter_value)
+        obj.instance_variable_set("@#{setter_attr}", setter_value)
+      end
+
+      def set_parent_attribute(obj, setter_attr, setter_value)
+        parent = parent_for(obj)
+
+        if parent
+          parent_composition = parent._composition_reflections[inverse_of]
+          parent.send("#{parent_composition.actual_column_for(setter_attr)}=", setter_value)
+        end
+      end
+
+      def inverse_of_composition
+        klass._composition_reflections[inverse_of]
+      end
+
+      # A composition class can have more than one reference, but only one parent should be not nil
+      # at the same time.
+      def parent_for(obj)
+        obj._composition_reflections.map { |_, composition| obj.send(composition.name).presence }.compact.first
+      end
+    end
+  end
+end

data/lib/composition/compositions/composition.rb

@@ -0,0 +1,25 @@
+module Composition
+  module Compositions
+    class Composition
+
+      attr_reader :name
+
+      def initialize(name, options = {})
+        @name = name
+        @options = options
+      end
+
+      def class_name
+        @options[:class_name]
+      end
+
+      def klass
+        class_name.constantize
+      end
+
+      def inverse_of
+        @options[:inverse_of]
+      end
+    end
+  end
+end

data/lib/composition/macros/compose.rb

@@ -0,0 +1,49 @@
+module Composition
+  module Macros
+    module Compose
+      extend ActiveSupport::Concern
+
+      def method_missing(method_name, *args, &block)
+        if match_composition?(method_name)
+          Composition::Builders::Compose.new(self).def_composition_methods
+          send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to?(method_name, include_private = false)
+        if match_composition?(method_name)
+          Composition::Builders::Compose.new(self).def_composition_methods
+          true
+        else
+          super
+        end
+      end
+
+      private
+
+      def match_composition?(method_id)
+        composition_name = method_id.to_s.gsub(/=$/, '')
+        _composition_reflections.any? { |_, composition| composition_name == composition.name.to_s }
+      end
+
+      class_methods do
+        def compose(*args)
+          composed_attribute = args.shift
+          options = args.last || {}
+          options = {
+            composed_attribute: composed_attribute,
+            mapping: options[:mapping],
+            class_name: options[:class_name] || composed_attribute.to_s.camelize,
+            inverse_of: options[:inverse_of] || model_name.name
+          }
+          composition = Compositions::Compose.new(options[:composed_attribute], options)
+          add_composition_reflection(self, options[:class_name], composition)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Composition::Macros::Compose)

data/lib/composition/macros/composed_from.rb

@@ -0,0 +1,49 @@
+module Composition
+  module Macros
+    module ComposedFrom
+      extend ActiveSupport::Concern
+
+      def method_missing(method_name, *args, &block)
+        if match_attribute?(method_name)
+          Composition::Builders::ComposedFrom.new(self).def_composition_setters
+          send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to?(method_name, include_private = false)
+        if match_attribute?(method_name)
+          Composition::Builders::ComposedFrom.new(self).def_composition_setters
+          true
+        else
+          super
+        end
+      end
+
+      private
+
+      def match_attribute?(method_id)
+        if method_id.to_s.match(/=$/)
+          attribute = method_id.to_s.gsub(/=$/, '')
+          reflection = _composition_reflections.first.try(:last)
+          reflection.aliases.include?(attribute.to_sym)
+        end
+      end
+
+      class_methods do
+        def composed_from(*args)
+          composed_from = args.shift
+          options = args.last || {}
+          options = {
+            composed_from: composed_from,
+            class_name: options[:class_name] || composed_from.to_s.camelize,
+            inverse_of: options[:inverse_of] || model_name.name
+          }
+          composition = Compositions::ComposedFrom.new(options[:composed_from], options)
+          add_composition_reflection(self, options[:inverse_of], composition)
+        end
+      end
+    end
+  end
+end

data/lib/composition/reflection.rb

@@ -0,0 +1,19 @@
+module Composition
+  module Reflection
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_composition_reflections, instance_writer: false
+      self._composition_reflections = {}.with_indifferent_access
+    end
+
+    class_methods do
+      def add_composition_reflection(obj, name, reflection)
+        new_reflection = { name => reflection }.with_indifferent_access
+        obj._composition_reflections = obj._composition_reflections.merge(new_reflection)
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Composition::Reflection)

data/lib/composition/version.rb

@@ -0,0 +1,3 @@
+module Composition
+  VERSION = '1.0.0.beta1'.freeze
+end

data/spec/macros/compose_spec.rb

@@ -0,0 +1,251 @@
+describe Composition::Macros::Compose do
+
+  describe 'compose getter' do
+    context 'when there is at least 1 value in the composed object' do
+      let(:user) { User.new(credit_card_name: 'Jon Snow', credit_card_brand: 'Visa') }
+
+      before do
+        create_table(:users) do |t|
+          t.string :credit_card_name
+          t.string :credit_card_brand
+        end
+
+        spawn_model(:User) do
+          compose :credit_card,
+                  mapping: {
+                    credit_card_name: :name,
+                    credit_card_brand: :brand
+                  }
+        end
+
+        spawn_composition(:CreditCard) do
+          composed_from :user
+        end
+      end
+
+      it { expect(user.credit_card).to be_an_instance_of(CreditCard) }
+      it { expect(user.credit_card.name).to eq 'Jon Snow' }
+      it { expect(user.credit_card.brand).to eq 'Visa' }
+      it { expect(user.credit_card.user).to eq user }
+    end
+
+    context 'when every attribute is nil' do
+      let(:user) { User.new(credit_card_name: nil, credit_card_brand: nil) }
+
+      before do
+        create_table(:users) do |t|
+          t.string :credit_card_name
+          t.string :credit_card_brand
+        end
+
+        spawn_model(:User) do
+          compose :credit_card,
+                  mapping: {
+                    credit_card_name: :name,
+                    credit_card_brand: :brand
+                  }
+        end
+
+        spawn_composition(:CreditCard) do
+          composed_from :user
+        end
+      end
+
+      it { expect(user.credit_card).to be_nil }
+    end
+
+    context 'when using class_name' do
+      let(:user) { AdminUser.new(credit_card_name: 'Jon Snow', credit_card_brand: 'Visa') }
+
+      before do
+        create_table(:admin_users) do |t|
+          t.string :credit_card_name
+          t.string :credit_card_brand
+        end
+
+        spawn_model(:AdminUser) do
+          compose :credit_card,
+                  mapping: {
+                    credit_card_name: :name,
+                    credit_card_brand: :brand
+                  }, class_name: 'CCard'
+        end
+
+        spawn_composition(:CCard) do
+          composed_from :user, class_name: 'AdminUser'
+        end
+      end
+
+      it { expect(user.credit_card).to be_an_instance_of(CCard) }
+      it { expect(user.credit_card.name).to eq 'Jon Snow' }
+      it { expect(user.credit_card.brand).to eq 'Visa' }
+      it { expect(user.credit_card.user).to eq user }
+    end
+  end
+
+  describe 'compose setter' do
+    let(:user) { User.new(credit_card_name: 'Jon Snow', credit_card_brand: 'Visa') }
+
+    before do
+      create_table(:users) do |t|
+        t.string :credit_card_name
+        t.string :credit_card_brand
+      end
+
+      spawn_model(:User) do
+        compose :credit_card,
+                mapping: {
+                  credit_card_name: :name,
+                  credit_card_brand: :brand
+                }
+      end
+
+      spawn_composition(:CreditCard) do
+        composed_from :user
+      end
+    end
+
+    context 'when setting attributes separately' do
+      before do
+        user.credit_card.name = 'Arya Stark'
+        user.credit_card.brand = 'MasterCard'
+      end
+
+      it { expect(user.credit_card.name).to eq 'Arya Stark' }
+      it { expect(user.credit_card_name).to eq 'Arya Stark' }
+      it { expect(user.credit_card.brand).to eq 'MasterCard' }
+      it { expect(user.credit_card_brand).to eq 'MasterCard' }
+
+      context 'and saving' do
+        before { user.save! && user.reload }
+        it { expect(user.credit_card.name).to eq 'Arya Stark' }
+        it { expect(user.credit_card_name).to eq 'Arya Stark' }
+        it { expect(user.credit_card.brand).to eq 'MasterCard' }
+        it { expect(user.credit_card_brand).to eq 'MasterCard' }
+      end
+    end
+
+    context 'when setting attributes through assign_attributes' do
+      before do
+        user.update_attributes(credit_card: { name: 'Arya Stark', brand: 'MasterCard' })
+      end
+
+      it { expect(user.credit_card.name).to eq 'Arya Stark' }
+      it { expect(user.credit_card_name).to eq 'Arya Stark' }
+      it { expect(user.credit_card.brand).to eq 'MasterCard' }
+      it { expect(user.credit_card_brand).to eq 'MasterCard' }
+    end
+
+    context 'when setting attributes (partially) through assign_attributes' do
+      before do
+        user.update_attributes(credit_card: { brand: 'MasterCard' })
+      end
+
+      it { expect(user.credit_card.name).to eq 'Jon Snow' }
+      it { expect(user.credit_card_name).to eq 'Jon Snow' }
+      it { expect(user.credit_card.brand).to eq 'MasterCard' }
+      it { expect(user.credit_card_brand).to eq 'MasterCard' }
+    end
+
+    context 'when setting attributes using a new object' do
+      before do
+        user.credit_card = CreditCard.new(name: 'Arya Stark', brand: 'MasterCard')
+      end
+
+      it { expect(user.credit_card.name).to eq 'Arya Stark' }
+      it { expect(user.credit_card_name).to eq 'Arya Stark' }
+      it { expect(user.credit_card.brand).to eq 'MasterCard' }
+      it { expect(user.credit_card_brand).to eq 'MasterCard' }
+    end
+
+    context 'when setting attribute through the base class' do
+      before do
+        user.credit_card_name = 'Arya Stark'
+        user.credit_card_brand = 'MasterCard'
+      end
+
+      it { expect(user.credit_card.name).to eq 'Arya Stark' }
+      it { expect(user.credit_card_name).to eq 'Arya Stark' }
+      it { expect(user.credit_card.brand).to eq 'MasterCard' }
+      it { expect(user.credit_card_brand).to eq 'MasterCard' }
+    end
+
+    context 'when setting to nil using =' do
+      before { user.credit_card = nil }
+
+      it { expect(user.credit_card).to be_nil }
+      it { expect(user.credit_card_name).to be_nil }
+      it { expect(user.credit_card_brand).to be_nil }
+    end
+
+    context 'when setting to nil using {}' do
+      before { user.update_attributes(credit_card: nil) }
+
+      it { expect(user.credit_card).to be_nil }
+      it { expect(user.credit_card_name).to be_nil }
+      it { expect(user.credit_card_brand).to be_nil }
+    end
+  end
+
+  describe 'validations' do
+    let(:user) { User.new(credit_card_name: 'Jon Snow', credit_card_brand: 'Visa') }
+
+    before do
+      create_table(:users) do |t|
+        t.string :credit_card_name
+        t.string :credit_card_brand
+      end
+
+      spawn_model(:User) do
+        compose :credit_card,
+                mapping: {
+                  credit_card_name: :name,
+                  credit_card_brand: :brand
+                }
+      end
+
+      spawn_composition(:CreditCard) do
+        composed_from :user
+
+        validates :name, presence: true
+      end
+    end
+
+    context 'when credit_card is valid' do
+      it { expect(user.credit_card).to be_valid }
+    end
+
+    context 'when credit_card is not valid' do
+      before { user.credit_card.name = '' }
+
+      it { expect(user.credit_card).not_to be_valid }
+    end
+  end
+
+  describe '#attributes' do
+    let(:user) { User.new(credit_card_name: 'Jon Snow', credit_card_brand: 'Visa') }
+
+    before do
+      create_table(:users) do |t|
+        t.string :credit_card_name
+        t.string :credit_card_brand
+      end
+
+      spawn_model(:User) do
+        compose :credit_card,
+                mapping: {
+                  credit_card_name: :name,
+                  credit_card_brand: :brand
+                }
+      end
+
+      spawn_composition(:CreditCard) do
+        composed_from :user
+
+        validates :name, presence: true
+      end
+    end
+
+    it { expect(user.credit_card.attributes).to eq(name: 'Jon Snow', brand: 'Visa') }
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'rspec/rails'
+
+RSpec.configure do |config|
+  config.infer_spec_type_from_file_location!
+  config.filter_rails_from_backtrace!
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+ENV['RAILS_ENV'] = 'test'
+ENV['DATABASE_URL'] = 'sqlite3://localhost/tmp/composition_test'
+
+require 'bundler/setup'
+require 'rails'
+case Rails.version
+  when '4.2.7.1'
+    require 'support/apps/rails4_2'
+  when '5.0.2'
+    require 'support/apps/rails5_0'
+end
+require 'support/model_macros'
+require 'composition'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  config.include Composition::Testing::ModelMacros
+
+  config.before :each do
+    @spawned_models = []
+    @spawned_compositions = []
+  end
+
+  config.after :each do
+    @spawned_models.each do |model|
+      Object.instance_eval { remove_const model } if Object.const_defined?(model)
+    end
+
+    @spawned_compositions.each do |model|
+      Object.instance_eval { remove_const model } if Object.const_defined?(model)
+    end
+  end
+end

data/spec/support/apps/rails4_2.rb

@@ -0,0 +1,50 @@
+require 'rails/all'
+
+module Rails42
+  class Application < Rails::Application
+    config.active_record.raise_in_transactional_callbacks = true
+    # Settings specified here will take precedence over those in config/application.rb.
+
+    # In the development environment your application's code is reloaded on
+    # every request. This slows down response time but is perfect for development
+    # since you don't have to restart the web server when you make code changes.
+    config.cache_classes = false
+
+    # Do not eager load code on boot.
+    config.eager_load = false
+
+    # Show full error reports and disable caching.
+    config.consider_all_requests_local       = true
+    config.action_controller.perform_caching = false
+
+    # Don't care if the mailer can't send.
+    config.action_mailer.raise_delivery_errors = false
+
+    # Print deprecation notices to the Rails logger.
+    config.active_support.deprecation = :log
+
+    # Raise an error on page load if there are pending migrations.
+    config.active_record.migration_error = :page_load
+
+    # Debug mode disables concatenation and preprocessing of assets.
+    # This option may cause significant delays in view rendering with a large
+    # number of complex assets.
+    config.assets.debug = true
+
+    # Asset digests allow you to set far-future HTTP expiration dates on all assets,
+    # yet still be able to expire them through the digest params.
+    config.assets.digest = true
+
+    # Adds additional error checking when serving assets at runtime.
+    # Checks for improperly declared sprockets dependencies.
+    # Raises helpful error messages.
+    config.assets.raise_runtime_errors = true
+
+    # Raises error for missing translations
+    # config.action_view.raise_on_missing_translations = true
+
+    config.secret_key_base = '49837489qkuweoiuoqwehisuakshdjksadhaisdy78o34y138974xyqp9rmye8yrpiokeuioqwzyoiuxftoyqiuxrhm3iou1hrzmjk'
+  end
+end
+
+Rails.application.initialize!

data/spec/support/apps/rails5_0.rb

@@ -0,0 +1,48 @@
+require 'rails/all'
+
+module Rails50
+  class Application < Rails::Application
+    # The test environment is used exclusively to run your application's
+    # test suite. You never need to work with it otherwise. Remember that
+    # your test database is "scratch space" for the test suite and is wiped
+    # and recreated between test runs. Don't rely on the data there!
+    config.cache_classes = true
+
+    # Do not eager load code on boot. This avoids loading your whole application
+    # just for the purpose of running a single test. If you are using a tool that
+    # preloads Rails for running tests, you may have to set it to true.
+    config.eager_load = false
+
+    # Configure public file server for tests with Cache-Control for performance.
+    config.public_file_server.enabled = true
+    config.public_file_server.headers = {
+      'Cache-Control' => 'public, max-age=3600'
+    }
+
+    # Show full error reports and disable caching.
+    config.consider_all_requests_local       = true
+    config.action_controller.perform_caching = false
+
+    # Raise exceptions instead of rendering exception templates.
+    config.action_dispatch.show_exceptions = false
+
+    # Disable request forgery protection in test environment.
+    config.action_controller.allow_forgery_protection = false
+    config.action_mailer.perform_caching = false
+
+    # Tell Action Mailer not to deliver emails to the real world.
+    # The :test delivery method accumulates sent emails in the
+    # ActionMailer::Base.deliveries array.
+    config.action_mailer.delivery_method = :test
+
+    # Print deprecation notices to the stderr.
+    config.active_support.deprecation = :stderr
+
+    # Raises error for missing translations
+    # config.action_view.raise_on_missing_translations = true
+
+    config.secret_key_base = '49837489qkuweoiuoqwehisuakshdjksadhaisdy78o34y138974xyqp9rmye8yrpiokeuioqwzyoiuxftoyqiuxrhm3iou1hrzmjk'
+  end
+end
+
+Rails.application.initialize!

data/spec/support/model_macros.rb

@@ -0,0 +1,29 @@
+module Composition
+  module Testing
+    module ModelMacros
+      def spawn_model(klass, &block)
+        Object.instance_eval { remove_const klass } if Object.const_defined?(klass)
+        Object.const_set klass, Class.new(ActiveRecord::Base)
+        Object.const_get(klass).class_eval(&block) if block_given?
+        @spawned_models << klass.to_sym
+      end
+
+      def spawn_composition(klass, &block)
+        Object.instance_eval { remove_const klass } if Object.const_defined?(klass)
+        Object.const_set klass, Class.new(Composition::Base)
+        Object.const_get(klass).class_eval(&block) if block_given?
+        @spawned_compositions << klass.to_sym
+      end
+
+      def create_table(table_name)
+        ActiveRecord::Migration.suppress_messages do
+          ActiveRecord::Schema.define do
+            create_table table_name, force: true do |t|
+              yield(t)
+            end
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: composition
+version: !ruby/object:Gem::Version
+  version: 1.0.0.beta1
+platform: ruby
+authors:
+- Marcelo Casiraghi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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: 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: bundler
+  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: rspec-rails
+  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: byebug
+  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: appraisal
+  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: rails
+  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: sqlite3
+  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: Composition for ActiveRecord models
+email: marcelo@paragon-labs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/composition.rb
+- lib/composition/base.rb
+- lib/composition/builders/compose.rb
+- lib/composition/builders/composed_from.rb
+- lib/composition/compositions/compose.rb
+- lib/composition/compositions/composed_from.rb
+- lib/composition/compositions/composition.rb
+- lib/composition/macros/compose.rb
+- lib/composition/macros/composed_from.rb
+- lib/composition/reflection.rb
+- lib/composition/version.rb
+- spec/macros/compose_spec.rb
+- spec/rails_helper.rb
+- spec/spec_helper.rb
+- spec/support/apps/rails4_2.rb
+- spec/support/apps/rails5_0.rb
+- spec/support/model_macros.rb
+homepage: https://github.com/marceloeloelo/composition
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: Composition for ActiveRecord models
+test_files:
+- spec/macros/compose_spec.rb
+- spec/rails_helper.rb
+- spec/spec_helper.rb
+- spec/support/apps/rails4_2.rb
+- spec/support/apps/rails5_0.rb
+- spec/support/model_macros.rb