pg_morph 0.3.0

data/.gitignore

@@ -0,0 +1,4 @@
+spec/dummy/log
+spec/dummy/config/*.yml
+tags
+*.gem

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,119 @@
+PATH
+  remote: .
+  specs:
+    pg_morph (0.1.0)
+      activerecord (~> 3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (3.2.19)
+      actionpack (= 3.2.19)
+      mail (~> 2.5.4)
+    actionpack (3.2.19)
+      activemodel (= 3.2.19)
+      activesupport (= 3.2.19)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.4)
+      rack (~> 1.4.5)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.2.1)
+    activemodel (3.2.19)
+      activesupport (= 3.2.19)
+      builder (~> 3.0.0)
+    activerecord (3.2.19)
+      activemodel (= 3.2.19)
+      activesupport (= 3.2.19)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.19)
+      activemodel (= 3.2.19)
+      activesupport (= 3.2.19)
+    activesupport (3.2.19)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    arel (3.0.3)
+    awesome_print (1.2.0)
+    builder (3.0.4)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    erubis (2.7.0)
+    hike (1.2.3)
+    i18n (0.6.11)
+    journey (1.0.4)
+    json (1.8.1)
+    mail (2.5.4)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    method_source (0.8.2)
+    mime-types (1.25.1)
+    multi_json (1.10.1)
+    pg (0.17.0)
+    polyglot (0.3.5)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rack (1.4.5)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.4)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (3.2.19)
+      actionmailer (= 3.2.19)
+      actionpack (= 3.2.19)
+      activerecord (= 3.2.19)
+      activeresource (= 3.2.19)
+      activesupport (= 3.2.19)
+      bundler (~> 1.0)
+      railties (= 3.2.19)
+    railties (3.2.19)
+      actionpack (= 3.2.19)
+      activesupport (= 3.2.19)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (>= 0.14.6, < 2.0)
+    rake (10.3.2)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    rspec-core (2.14.8)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
+    rspec-rails (2.14.2)
+      actionpack (>= 3.0)
+      activemodel (>= 3.0)
+      activesupport (>= 3.0)
+      railties (>= 3.0)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    slop (3.6.0)
+    sprockets (2.2.2)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    thor (0.19.1)
+    tilt (1.4.1)
+    treetop (1.4.15)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.41)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print (~> 1.2)
+  pg (~> 0.17)
+  pg_morph!
+  pry (~> 0.10)
+  rails (~> 3)
+  rake (~> 10.3)
+  rspec-rails

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Lunar Logic
+
+MIT License
+
+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,62 @@
+# PgMorph
+# ![PgMorph logo](docs/pg_morph.png)
+
+PgMorph gives you a way to handle DB consistency for polymorphic relations and is based on postgreSQL inheritance and partitioning features.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pg_morph'
+```
+
+And then execute:
+
+```console
+$ bundle
+```
+
+Or install it yourself as:
+
+```console
+$ gem install pg_morph
+```
+
+## Usage
+
+Let's say you have a `Like` class and it's in polymorphic relation with `Post` and `Comment` classes. You can't add foreign keys for those relations, and there's where PgMorph comes.
+
+By adding migration:
+
+```ruby
+add_polymorphic_foreign_key :likes, :comments, column: :likeable
+```
+
+PgMorph creates a partition table named `likes_comments` which inherits from `likes` table, sets foreign key on it and redirects all inserts to `likes` to this partition table if `likeable_type` is `Like`. It's done by using before insert trigger.
+
+You will have to add polymorphic foreign key on all related tables and each time new relation is added, before insert trigger function will be updated to reflect all defined relations and redirect new records to proper partitions.
+
+From the Rails point of view it's totally transparent, so all inserts, updates and selections work as they were on original `likes` table.
+
+You can remove polymorphic foreign keys with below migration:
+
+```ruby
+remove_polymorphic_foreign_key :likes, :comments, column: :likeable
+```
+
+Because it means that whole partition table would be removed, you will be forbidden to do that if partition table contains any data.
+
+## Issues
+
+ActiveRecord uses `INSERT ... RETURNING id` query which was impossible to keep while while using regular tables without some trick. In ideal situation there should be inly one insert to partition table, omitting main table, but than `id` of newly created record would become `nil` which would frustrate most of us. To preserve `id` of new record main table is not omitted, two records are being made and in after insert trigger duplicated record from master table is removed.
+
+This extra database operations may be skipped by using view for main table, however it requires more work to make it so transparent for ActiveRecord as it is now, and is going to be done in next release.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+desc 'test pg_morph'
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/lib/pg_morph/adapter.rb

@@ -0,0 +1,39 @@
+module PgMorph
+
+  module Adapter
+
+    def add_polymorphic_foreign_key(parent_table, child_table, options = {})
+      raise_unless_postgres
+
+      polymorphic = PgMorph::Polymorphic.new(parent_table, child_table, options)
+
+      sql = polymorphic.create_proxy_table_sql
+      sql << polymorphic.create_before_insert_trigger_fun_sql
+      sql << polymorphic.create_before_insert_trigger_sql
+      sql << polymorphic.create_after_insert_trigger_fun_sql
+      sql << polymorphic.create_after_insert_trigger_sql
+
+      execute(sql)
+    end
+
+    def remove_polymorphic_foreign_key(parent_table, child_table, options = {})
+      raise_unless_postgres
+
+      polymorphic = PgMorph::Polymorphic.new(parent_table, child_table, options)
+
+      sql = polymorphic.remove_before_insert_trigger_sql
+      sql << polymorphic.remove_partition_table
+      sql << polymorphic.remove_after_insert_trigger_sql
+
+      execute(sql)
+    end
+
+    private
+
+    def raise_unless_postgres
+      raise PgMorph::Exception.new("This functionality is supported only by PostgreSQL") unless self.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+    end
+
+  end
+
+end

data/lib/pg_morph/naming.rb

@@ -0,0 +1,37 @@
+module PgMorph
+  module Naming
+
+    def type
+      child_table.to_s.singularize.camelize
+    end
+
+    def column_name_type
+      "#{column_name}_type"
+    end
+
+    def column_name_id
+      "#{column_name}_id"
+    end
+
+    def proxy_table
+      "#{parent_table}_#{child_table}"
+    end
+
+    def before_insert_fun_name
+      "#{parent_table}_#{column_name}_fun"
+    end
+
+    def before_insert_trigger_name
+      "#{parent_table}_#{column_name}_insert_trigger"
+    end
+
+    def after_insert_fun_name
+      "delete_from_#{parent_table}_master_fun"
+    end
+
+    def after_insert_trigger_name
+      "#{parent_table}_after_insert_trigger"
+    end
+
+  end
+end

data/lib/pg_morph/polymorphic.rb

@@ -0,0 +1,158 @@
+module PgMorph
+
+  class Polymorphic
+    include PgMorph::Naming
+    attr_reader :parent_table, :child_table, :column_name
+
+    def initialize(parent_table, child_table, options)
+      @parent_table = parent_table
+      @child_table = child_table
+      @column_name = options[:column]
+
+      raise PgMorph::Exception.new("Column not specified") unless @column_name
+    end
+
+    def create_proxy_table_sql
+      %Q{
+      CREATE TABLE #{proxy_table} (
+        CHECK (#{column_name_type} = '#{type}'),
+        PRIMARY KEY (id),
+        FOREIGN KEY (#{column_name_id}) REFERENCES #{child_table}(id)
+      ) INHERITS (#{parent_table});
+      }
+    end
+
+    def create_before_insert_trigger_fun_sql
+      before_insert_trigger_content do
+        create_trigger_body.strip
+      end
+    end
+
+    def create_before_insert_trigger_sql
+      fun_name = before_insert_fun_name
+      trigger_name = before_insert_trigger_name
+
+      create_trigger_sql(parent_table, trigger_name, fun_name, 'BEFORE INSERT')
+    end
+
+    def create_after_insert_trigger_sql
+      fun_name = after_insert_fun_name
+      trigger_name = after_insert_trigger_name
+
+      create_trigger_sql(parent_table, trigger_name, fun_name, 'AFTER INSERT')
+    end
+
+    def create_after_insert_trigger_fun_sql
+      fun_name = after_insert_fun_name
+      create_trigger_fun(fun_name) do
+        %Q{DELETE FROM ONLY #{parent_table} WHERE id = NEW.id;}
+      end
+    end
+
+    def remove_before_insert_trigger_sql
+      trigger_name = before_insert_trigger_name
+      fun_name = before_insert_fun_name
+
+      prosrc = get_function(fun_name)
+      raise PG::Error.new("There is no such function #{fun_name}()\n") unless prosrc
+
+      scan =  prosrc.scan(/(( +(ELS)?IF.+\n)(\s+INSERT INTO.+;\n))/)
+      cleared = scan.reject { |x| x[0].match("#{proxy_table}") }
+
+      if cleared.present?
+        cleared[0][0].sub!('ELSIF', 'IF')
+        before_insert_trigger_content do
+          cleared.map { |m| m[0] }.join('').strip
+        end
+      else
+        drop_trigger_and_fun_sql(trigger_name, parent_table, fun_name)
+      end
+    end
+
+    def remove_partition_table
+      table_empty = ActiveRecord::Base.connection.select_value("SELECT COUNT(*) FROM #{parent_table}_#{child_table}").to_i.zero?
+      if table_empty
+        %Q{ DROP TABLE IF EXISTS #{proxy_table}; }
+      else
+        raise PG::Error.new("Partition table #{proxy_table} contains data.\nRemove them before if you want to drop that table.\n")
+      end
+    end
+
+    def remove_after_insert_trigger_sql
+      prosrc = get_function(before_insert_fun_name)
+      scan =  prosrc.scan(/(( +(ELS)?IF.+\n)(\s+INSERT INTO.+;\n))/)
+      cleared = scan.reject { |x| x[0].match("#{proxy_table}") }
+
+      return '' if cleared.present?
+      fun_name = after_insert_fun_name
+      trigger_name = after_insert_trigger_name
+
+      drop_trigger_and_fun_sql(trigger_name, parent_table, fun_name)
+    end
+
+    private
+
+    def create_trigger_fun(fun_name, &block)
+      %Q{
+        CREATE OR REPLACE FUNCTION #{fun_name}() RETURNS TRIGGER AS $$
+        BEGIN
+          #{block.call}
+          RETURN NEW;
+        END; $$ LANGUAGE plpgsql;
+      }
+    end
+
+    def before_insert_trigger_content( &block)
+      create_trigger_fun(before_insert_fun_name) do
+        %Q{#{block.call}
+          ELSE
+            RAISE EXCEPTION 'Wrong "#{column_name}_type"="%" used. Create proper partition table and update #{before_insert_fun_name} function', NEW.#{column_name}_type;
+          END IF;}
+      end
+    end
+
+    def create_trigger_body
+      prosrc = get_function(before_insert_fun_name)
+
+      if prosrc
+        scan =  prosrc.scan(/(( +(ELS)?IF.+\n)(\s+INSERT INTO.+;\n))/)
+        raise PG::Error.new("Condition for #{proxy_table} table already exists in trigger function") if scan[0][0].match proxy_table
+        %Q{
+          #{scan.map { |m| m[0] }.join.strip}
+          ELSIF (NEW.#{column_name}_type = '#{child_table.to_s.singularize.camelize}') THEN
+            INSERT INTO #{parent_table}_#{child_table} VALUES (NEW.*);
+        }
+      else
+        %Q{
+          IF (NEW.#{column_name}_type = '#{child_table.to_s.singularize.camelize}') THEN
+            INSERT INTO #{parent_table}_#{child_table} VALUES (NEW.*);
+        }
+      end
+    end
+
+    def create_trigger_sql(parent_table, trigger_name, fun_name, when_to_call)
+      %Q{
+      DROP TRIGGER IF EXISTS #{trigger_name} ON #{parent_table};
+      CREATE TRIGGER #{trigger_name}
+        #{when_to_call} ON #{parent_table}
+        FOR EACH ROW EXECUTE PROCEDURE #{fun_name}();
+      }
+    end
+
+    def drop_trigger_and_fun_sql(trigger_name, parent_table, fun_name)
+      %Q{
+      DROP TRIGGER #{trigger_name} ON #{parent_table};
+      DROP FUNCTION #{fun_name}();
+      }
+    end
+
+    def get_function(fun_name)
+      run("SELECT prosrc FROM pg_proc WHERE proname = '#{fun_name}'")
+    end
+
+    def run(query)
+      ActiveRecord::Base.connection.select_value(query)
+    end
+  end
+
+end

data/lib/pg_morph/railtie.rb

@@ -0,0 +1,11 @@
+module PgMorph
+  class Railtie < Rails::Railtie
+    initializer 'PgMorph.active_record' do
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+          include PgMorph::Adapter
+        end
+      end
+    end
+  end
+end

data/lib/pg_morph/version.rb

@@ -0,0 +1,3 @@
+module PgMorph
+  VERSION = "0.3.0"
+end

data/lib/pg_morph.rb

@@ -0,0 +1,16 @@
+require 'bundler/setup'
+Bundler.require :default, :test
+
+require 'active_support'
+require 'active_record'
+
+require File.join(File.dirname(__FILE__), %w{ pg_morph naming })
+require File.join(File.dirname(__FILE__), %w{ pg_morph polymorphic })
+require File.join(File.dirname(__FILE__), %w{ pg_morph adapter })
+
+require File.join(File.dirname(__FILE__), %w{ pg_morph railtie }) if defined?(Rails)
+
+module PgMorph
+  class Exception < RuntimeError
+  end
+end

data/pg_morph.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pg_morph/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pg_morph"
+  spec.version       = PgMorph::VERSION
+  spec.authors       = ["Hanka Seweryn"]
+  spec.email         = ["hanka@lunarlogic.io"]
+  spec.summary       = %q{Takes care of postgres DB consistency for ActiveRecord polymorphic associations}
+  spec.description   = %q{Takes care of postgres DB consistency for ActiveRecord polymorphic associations via partitioning and inheritance}
+  spec.homepage      = "https://github.com/LunarLogic/pg_morph"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", "~> 3"
+
+  spec.add_development_dependency "rails", "~> 3"
+  spec.add_development_dependency "pg", "~> 0.17"
+
+  spec.add_development_dependency 'rspec-rails'
+
+  spec.add_development_dependency "rake", "~> 10.3"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "awesome_print", "~> 1.2"
+end

data/spec/dummy/.rspec

@@ -0,0 +1 @@
+--color

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/spec/dummy/app/models/comment.rb

@@ -0,0 +1,3 @@
+class Comment < ActiveRecord::Base
+  has_many :likes, as: :likeable
+end

data/spec/dummy/app/models/like.rb

@@ -0,0 +1,3 @@
+class Like < ActiveRecord::Base
+  belongs_to :likeable, polymorphic: true
+end

data/spec/dummy/app/models/post.rb

@@ -0,0 +1,3 @@
+class Post < ActiveRecord::Base
+  has_many :likes, as: :likeable
+end

data/spec/dummy/bin/bundle

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+load Gem.bin_path('bundler', 'bundle')

data/spec/dummy/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require_relative '../config/boot'
+require 'rails/commands'

data/spec/dummy/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../config/boot'
+require 'rake'
+Rake.application.run

data/spec/dummy/config/application.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../boot', __FILE__)
+
+require 'rails/all'
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+require 'pg_morph'
+
+module Dummy
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
+    # config.time_zone = 'Central Time (US & Canada)'
+
+    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
+    # config.i18n.default_locale = :de
+  end
+end

data/spec/dummy/config/boot.rb

@@ -0,0 +1,4 @@
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])

data/spec/dummy/config/database.yml

@@ -0,0 +1,8 @@
+test:
+  adapter: postgresql
+  encoding: unicode
+  database: pg_morph_test
+  pool: 5
+  username: postgres
+  password: test123
+  host: localhost

data/spec/dummy/config/database.yml.example

@@ -0,0 +1,8 @@
+test:
+  adapter: postgresql
+  encoding: unicode
+  database: pg_morph_test
+  pool: 5
+  username: postgres
+  password: test123
+  host: localhost

data/spec/dummy/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the Rails application.
+require File.expand_path('../application', __FILE__)
+
+# Initialize the Rails application.
+Dummy::Application.initialize!

data/spec/dummy/config/environments/test.rb

@@ -0,0 +1,36 @@
+Dummy::Application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # 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 static asset server for tests with Cache-Control for performance.
+  config.serve_static_assets  = true
+  config.static_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
+
+  # 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
+end