activerecord-mti 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 244959ce054c69902aba2b4394e0b36d97fdf5ee
+  data.tar.gz: b495b7183d09b9559aae287cbb6cc380c63ead0e
+SHA512:
+  metadata.gz: 5aa32b7fae5c39a39a8541a1aa1f18a269ae3a1b41aa7af7639888021925a333df1d446c0e67acec56e714b7bc7a61599ffbc16eb4d83265fcd9a7bdfaea6353
+  data.tar.gz: 7b60164496b9b14a37ce13c3caae1421ce3c1766eb64427d43c97fe49ecbe11f02c7fe7ad849582f63b090223c2a4234c8433a2c45de1ce49611dd04e2fba079

data/.gitignore

@@ -0,0 +1,3 @@
+.rvmrc
+.idea
+mti_spec_db

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'rails', '>= 3.2'
+
+group :development, :test do
+  gem 'rspec-rails', '~> 2.14.0'
+  gem 'sqlite3'
+end

data/Gemfile.lock

@@ -0,0 +1,95 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (4.0.0)
+      actionpack (= 4.0.0)
+      mail (~> 2.5.3)
+    actionpack (4.0.0)
+      activesupport (= 4.0.0)
+      builder (~> 3.1.0)
+      erubis (~> 2.7.0)
+      rack (~> 1.5.2)
+      rack-test (~> 0.6.2)
+    activemodel (4.0.0)
+      activesupport (= 4.0.0)
+      builder (~> 3.1.0)
+    activerecord (4.0.0)
+      activemodel (= 4.0.0)
+      activerecord-deprecated_finders (~> 1.0.2)
+      activesupport (= 4.0.0)
+      arel (~> 4.0.0)
+    activerecord-deprecated_finders (1.0.3)
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    arel (4.0.0)
+    atomic (1.1.14)
+    builder (3.1.4)
+    diff-lcs (1.2.4)
+    erubis (2.7.0)
+    hike (1.2.3)
+    i18n (0.6.9)
+    mail (2.5.4)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.25.1)
+    minitest (4.7.5)
+    multi_json (1.8.2)
+    polyglot (0.3.3)
+    rack (1.5.2)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (4.0.0)
+      actionmailer (= 4.0.0)
+      actionpack (= 4.0.0)
+      activerecord (= 4.0.0)
+      activesupport (= 4.0.0)
+      bundler (>= 1.3.0, < 2.0)
+      railties (= 4.0.0)
+      sprockets-rails (~> 2.0.0)
+    railties (4.0.0)
+      actionpack (= 4.0.0)
+      activesupport (= 4.0.0)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (10.1.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.3)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+    rspec-rails (2.14.0)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      railties (>= 3.0)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    sprockets (2.10.0)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sprockets-rails (2.0.0)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      sprockets (~> 2.8)
+    sqlite3 (1.3.8)
+    thor (0.18.1)
+    thread_safe (0.1.3)
+      atomic
+    tilt (1.4.1)
+    treetop (1.4.15)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rails (>= 3.2)
+  rspec-rails (~> 2.14.0)
+  sqlite3

data/README.md

@@ -0,0 +1,70 @@
+# ActiveRecord MTI (Multiple Tables Inheritance)
+
+This gem allows you to make models which attributes are distributed by two tables.
+
+## Installation
+
+Add to your Gemfile:
+
+```gem 'activerecord-mti'```
+
+## Usage
+
+Consider the following DB schema:
+
+```ruby
+create_table :subjects do |t|
+  t.string :name
+end
+
+create_table :roles do |t|
+  t.integer :subject_id
+  # MTI fields
+  t.integer :role_id
+  t.integer :role_type
+end
+
+create_table :employees do |t|
+  t.string :appointment
+end
+
+create_table :clients do |t|
+  t.string :address
+end
+```
+
+and corresponding models: 
+
+```ruby
+class Subject < ActiveRecord::Base
+  has_many :roles
+end
+
+class Role < ActiveRecord::Base
+  mti_base  
+  belongs_to :subject
+end
+
+class Employee < ActiveRecord::Base
+  mti_implementation_of :role
+end
+
+class Client < ActiveRecord::Base
+  mti_implementation_of :role
+end
+```
+
+Have fun with roles as base and implementation objects at the same time:
+
+```ruby
+Subject.first.roles # => [#<Employee …>, #<Client …>]
+Employee.first.subject # => #<User …>
+Role.where(role_type: Client).first.address # => String
+Client.first.role # => #<Role …>
+Client.first.role_id == Client.first.role.id # => true
+Client.create!(:address => 'somewhere').role # => #<Role …>
+```
+
+## Testing
+
+```bundle exec rspec spec```

data/activerecord-mti.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name        = 'activerecord-mti'
+  s.version     = '0.0.0'
+  s.date        = '2014-06-25'
+  s.summary     = 'ActiveRecord MTI'
+  s.description = 'Multiple Tables Inheritance for ActiveRecord'
+  s.authors     = ['Timofey Martynov']
+  s.email       = 'feymartynov@gmail.com'
+  s.homepage    = 'http://rubygems.org/gems/activerecord-mti'
+  s.license     = 'MIT'
+
+  s.require_paths = ['lib']
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+
+  s.add_dependency 'rails', '>= 3.2'
+  s.add_development_dependency 'rspec-rails', '~> 2.14.0'
+end

data/lib/activerecord-mti.rb

@@ -0,0 +1,9 @@
+require 'delegate_missing_to'
+require 'mti'
+
+module ActiveRecord
+  class Base
+    include DelegateMissingTo
+    include ActiveRecord::Mti
+  end
+end

data/lib/delegate_missing_to.rb

@@ -0,0 +1,46 @@
+# Delegates missing methods to another object(s).
+# May be useful for inheritance mechanisms, decorator pattern or graceful object replacement for refactoring.
+#
+# Example with delegation of missing methods to an association:
+#
+#   class A < ActiveRecord::Base
+#     def qwe
+#       123
+#     end
+#   end
+#
+#   class B < ActiveRecord::Base
+#     include ActiveRecord::DelegateMissingTo
+#
+#     belongs_to :a
+#     delegate_missing_to :a
+#   end
+#
+#   b = B.new
+#   b.qwe # => 123
+#
+# Additionally you may specify a delegation chain:
+#
+#   delegate_missing_to :first_priority, :second_priority, :third_priority
+#
+module DelegateMissingTo
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def delegate_missing_to(*object_names)
+      object_names.reverse_each do |object_name|
+        define_method "method_missing_with_delegation_to_#{object_name}" do |method, *args, &block|
+          object = send(object_name)
+
+          if object.respond_to?(method)
+            object.public_send(method, *args, &block)
+          else
+            send("method_missing_without_delegation_to_#{object_name}", method, *args, &block)
+          end
+        end
+
+        alias_method_chain :method_missing, "delegation_to_#{object_name}"
+      end
+    end
+  end
+end

data/lib/mti.rb

@@ -0,0 +1,118 @@
+# Multiple Table Inheritance (MTI)
+#
+# Say, you have a base model (Fruit) and its implementations (Apple & Banana).
+# STI is not suitable because you have to keep Apple's & Banana's specific fields in one table (fruits).
+# MTI enables you to keep a clear database schema with a table for common fields only (fruits)
+# and two tables for specific fields only (apples & bananas).
+# This implementation is based on delegation pattern and doesn't use class inheritance.
+#
+# Example:
+#
+#   class Fruit < ActiveRecord::Base
+#     mti_base
+#   end
+#
+#   class Apple < ActiveRecord::Base
+#     mti_implementation_of :fruit
+#   end
+#
+#   class Banana < ActiveRecord::Base
+#     mti_implementation_of :fruit
+#   end
+#
+module ActiveRecord::Mti
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def mti_base
+      class_attribute :mti_name
+      self.mti_name = self.to_s.underscore.to_sym
+
+      @@base_instance_mode = false
+      @@base_instance_mode_lock = Mutex.new
+
+      # Always fetch with the implementation
+      default_scope lambda { includes(mti_name) }
+
+      # Implementation model association
+      belongs_to mti_name,
+                 polymorphic: true,
+                 inverse_of: mti_name
+
+      # Override ActiveRecord's instantiation method
+      # which builds an object from a record
+      # Return the base class object when in "base instance mode"
+      # and the implementation object otherwise
+      def self.instantiate(*_)
+        if @@base_instance_mode
+          super
+        else
+          super.public_send(mti_name)
+        end
+      end
+
+      # Thread safe execution of a block in a "base instance mode"
+      def self.as_base_instance
+        @@base_instance_mode_lock.synchronize do
+          @@base_instance_mode = true
+          result = yield
+          @@base_instance_mode = false
+          result
+        end
+      end
+    end
+
+    def mti_implementation_of(mti_base_name)
+      class_attribute :mti_base
+      self.mti_base = mti_base_name.to_s.classify.constantize
+
+      # Base model association
+      has_one mti_base_name.to_sym,
+              :as => mti_base_name.to_sym,
+              :autosave => true,
+              :dependent => :destroy,
+              :validate => true,
+              :inverse_of => mti_base_name.to_sym
+
+      # When calling the base object from the implementation
+      # switch the base's class to the "base instance mode"
+      # to receive the base class object instead of another
+      # implementation object and avoid an infinite loop
+      define_method "#{mti_base_name}_with_reverse" do          # def role_with_reverse
+        mti_base.as_base_instance do                            #   Role.as_base_instance do
+          send("#{mti_base_name}_without_reverse")              #     role_without_reverse
+        end                                                     #   end
+      end                                                       # end
+      alias_method_chain mti_base_name, :reverse                # alias_method_chain :role, :reverse
+
+      # Auto build base model
+      define_method "#{mti_base_name}_with_autobuild" do        # def role_with_autobuild
+        public_send("#{mti_base_name}_without_autobuild") ||    #   role_without_autobuild ||
+            public_send("build_#{mti_base_name}")               #     build_role
+      end                                                       # end
+      alias_method_chain mti_base_name, :autobuild              # alias_method_chain :role, :autobuild
+
+      # Delegate attributes
+      mti_base.content_columns.map(&:name).each do |attr|
+        delegate attr, "#{attr}=", "#{attr}?",
+                 :to => mti_base_name.to_sym
+      end
+
+      # Delegate associations
+      mti_base.reflections.keys
+              .tap { |k| k.delete(mti_base_name.to_sym) }
+              .each do |association|
+        delegate association, "#{association}=",
+                 :to => mti_base_name.to_sym
+      end
+
+      delegate_missing_to mti_base_name
+
+      accepts_nested_attributes_for mti_base_name
+
+      define_method "#{mti_base_name}_id" do
+        public_send(mti_base_name).id
+      end
+    end
+  end
+end

data/spec/delegate_missing_to_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe '.delegate_missing_to' do
+  before :all do
+    class DummyWorker
+      def do_work(*_)
+      end
+    end
+
+    class DummyDelegator
+      include DelegateMissingTo
+
+      delegate_missing_to :worker
+
+      def worker
+        @worker ||= DummyWorker.new
+      end
+    end
+  end
+
+  subject(:delegator) { DummyDelegator.new }
+  let(:params) { [:some, :params] }
+
+  it 'should delegate missing method call' do
+    expect(delegator.worker).to receive(:do_work).with(*params)
+    delegator.do_work(*params)
+  end
+end

data/spec/mti_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+describe 'MTI' do
+  before :all do
+    ActiveRecord::Base.establish_connection(:adapter => :sqlite3, :database => 'mti_spec_db')
+
+    ActiveRecord::Schema.define do
+      self.verbose = false
+
+      create_table :owners, force: true do |t|
+        t.string :name
+      end
+
+      create_table :devices, force: true do |t|
+        t.string :name
+        t.integer :owner_id
+        t.integer :device_id
+        t.string :device_type
+      end
+
+      create_table :computers, force: true do |t|
+        t.string :cpu_model
+      end
+
+      create_table :cameras, force: true do |t|
+        t.float :matrix_size
+      end
+    end
+
+    ActiveRecord::Base.transaction do
+      ActiveRecord::Base.connection.execute(<<-SQL)
+        INSERT INTO owners (id, name)
+        VALUES (1, 'john doe');
+      SQL
+
+      ActiveRecord::Base.connection.execute(<<-SQL)
+        INSERT INTO devices (id, name, owner_id, device_id, device_type)
+        VALUES (1, 'mac book pro', 1, 1, 'Computer');
+      SQL
+
+      ActiveRecord::Base.connection.execute(<<-SQL)
+        INSERT INTO computers (id, cpu_model)
+        VALUES (1, 'core i7');
+      SQL
+
+      ActiveRecord::Base.connection.execute(<<-SQL)
+        INSERT INTO devices (id, name, owner_id, device_id, device_type)
+        VALUES (2, 'canon 550d', 1, 1, 'Camera');
+      SQL
+
+      ActiveRecord::Base.connection.execute(<<-SQL)
+        INSERT INTO cameras (id, matrix_size)
+        VALUES (1, 18.7);
+      SQL
+    end
+
+    class Owner < ActiveRecord::Base; end
+
+    class Device < ActiveRecord::Base
+      mti_base
+
+      belongs_to :owner
+
+      def switch_on
+        :on
+      end
+    end
+
+    class Computer < ActiveRecord::Base
+      mti_implementation_of :device
+
+      def run_program
+        :done
+      end
+    end
+
+    class Camera < ActiveRecord::Base
+      mti_implementation_of :device
+
+      def make_shot
+        :click
+      end
+    end
+  end
+
+  after(:all) do
+    ActiveRecord::Schema.define do
+      drop_table :devices
+      drop_table :computers
+      drop_table :cameras
+    end
+  end
+
+  describe 'base' do
+    it 'finders should return the implementation' do
+      computer = Device.find_by_name('mac book pro')
+      expect(computer).to be_kind_of(Computer)
+    end
+  end
+
+  describe 'implementation' do
+    subject(:camera) { Camera.find(1) }
+
+    it 'should have attributes of the implementation' do
+      expect(camera.matrix_size).to eq(18.7)
+    end
+
+    it 'should have attributes of the base object' do
+      expect(camera.name).to eq('canon 550d')
+    end
+
+    it 'should act as an implementation' do
+      expect(camera.make_shot).to eq(:click)
+    end
+
+    it 'should act as a base object' do
+      expect(camera.switch_on).to eq(:on)
+    end
+
+    it 'should return the base object on demand' do
+      expect(camera.device).to be_kind_of(Device)
+    end
+
+    it 'should respond to base object\'s associations' do
+      expect(camera.owner.name).to eq('john doe')
+    end
+  end
+
+  describe 'building a model' do
+    before do
+      Computer.create! do |c|
+        c.name = 'mac book air'
+        c.cpu_model = 'core i3'
+      end
+    end
+
+    it 'should build both base and implementation' do
+      expect(Device.where(name: 'mac book air').first.cpu_model).to eq('core i3')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rails/all'
+require 'rspec/rails'
+require 'activerecord-mti'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.tty = true
+  config.formatter = :documentation
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-mti
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Timofey Martynov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  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: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+description: Multiple Tables Inheritance for ActiveRecord
+email: feymartynov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- activerecord-mti.gemspec
+- lib/activerecord-mti.rb
+- lib/delegate_missing_to.rb
+- lib/mti.rb
+- spec/delegate_missing_to_spec.rb
+- spec/mti_spec.rb
+- spec/spec_helper.rb
+homepage: http://rubygems.org/gems/activerecord-mti
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: ActiveRecord MTI
+test_files:
+- spec/delegate_missing_to_spec.rb
+- spec/mti_spec.rb
+- spec/spec_helper.rb