polymorpheus 0.1

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2011 Wegowise Inc.
+
+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/Rakefile

@@ -0,0 +1,39 @@
+require 'rake'
+require 'fileutils'
+
+def gemspec_name
+  @gemspec_name ||= Dir['*.gemspec'][0]
+end
+
+def gemspec
+  @gemspec ||= eval(File.read(gemspec_name), binding, gemspec_name)
+end
+
+desc "Build the gem"
+task :gem=>:gemspec do
+  sh "gem build #{gemspec_name}"
+  FileUtils.mkdir_p 'pkg'
+  FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", 'pkg'
+end
+
+desc "Install the gem locally"
+task :install => :gem do
+  sh %{gem install pkg/#{gemspec.name}-#{gemspec.version}}
+end
+
+desc "Generate the gemspec"
+task :generate do
+  puts gemspec.to_ruby
+end
+
+desc "Validate the gemspec"
+task :gemspec do
+  gemspec.validate
+end
+
+desc 'Run tests'
+task :test do |t|
+  sh 'rspec spec'
+end
+
+task :default => :test

data/lib/polymorpheus/adapter.rb

@@ -0,0 +1,23 @@
+module Polymorpheus
+  class Adapter
+
+    class << self
+      @@registered_adapters = {}
+
+      def register(adapter_name, file_name)
+        @@registered_adapters[adapter_name] = file_name
+      end
+
+      def load!
+        if file = @@registered_adapters[configured_adapter]
+          require file
+        end
+      end
+
+      def configured_adapter
+        ActiveRecord::Base.connection_pool.spec.config[:adapter]
+      end
+    end
+
+  end
+end

data/lib/polymorpheus/interface.rb

@@ -0,0 +1,97 @@
+module Polymorpheus
+  module Interface
+    class PolymorphicError < ::StandardError; end
+
+    class InvalidTypeError < PolymorphicError
+      def initialize(*accepted_classes)
+        error = "Invalid type."
+        error += " Must be one of {#{accepted_classes.join(', ')}}"
+        super(error)
+      end
+    end
+
+    class AmbiguousTypeError < PolymorphicError
+      def initialize
+        super("Ambiguous polymorphic interface or object type")
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def belongs_to_polymorphic(*args)
+        options = args.extract_options!
+        polymorphic_api = options[:as]
+        associations = args.collect(&:to_s).collect(&:downcase)
+        association_keys = associations.collect{|association| "#{association}_id"}
+
+        # Set belongs_to assocaitions
+        associations.each do |associated_model|
+          belongs_to associated_model.to_sym
+        end
+
+        # Class constant defining the keys
+        const_set "#{polymorphic_api}_keys".upcase, association_keys
+
+        # Helper methods and constants
+        define_method "#{polymorphic_api}_types" do
+          associations
+        end
+
+        define_method "#{polymorphic_api}_active_key" do
+          keys = association_keys.select { |key| self.send(key).present? }
+          keys.first if keys.length == 1
+        end
+
+        define_method "#{polymorphic_api}_query_condition" do
+          fk = self.send("#{polymorphic_api}_active_key")
+          { fk.to_s => self.send(fk) } if fk
+        end
+
+        # Getter method
+        define_method polymorphic_api do
+          if key = self.send("#{polymorphic_api}_active_key")
+            self.send key.gsub(/_id$/,'')
+          end
+        end
+
+        # Setter method
+        define_method "#{polymorphic_api}=" do |polymorphic_obj|
+          possible_associations = [ polymorphic_obj.class.name.underscore,
+                                    polymorphic_obj.class.superclass.name.underscore ]
+          match = associations & possible_associations
+          if match.blank?
+            raise Polymorpheus::Interface::PolymorphicError, associations
+          elsif match.length > 1
+            raise Polymorpheus::Interface::AmbiguousTypeError
+          else
+            self.send("#{match[0]}_id=", polymorphic_obj.id)
+            (associations - match).each do |association_to_reset|
+              self.send("#{association_to_reset}_id=", nil)
+            end
+          end
+        end
+
+        # Private method called as part of validation
+        # Validate that there is exactly one associated object
+        define_method "polymorphic_#{polymorphic_api}_relationship_is_valid" do
+          if !self.send(polymorphic_api)
+            self.errors.add(:base,
+              "You must specify exactly one of the following: {#{associations.join(', ')}}")
+          end
+        end
+        private "polymorphic_#{polymorphic_api}_relationship_is_valid"
+
+      end
+
+      def validates_polymorph(polymorphic_api)
+        validate "polymorphic_#{polymorphic_api}_relationship_is_valid"
+      end
+
+    end
+
+  end
+end

data/lib/polymorpheus/mysql_adapter.rb

@@ -0,0 +1,127 @@
+module Polymorpheus
+  module ConnectionAdapters
+    module MysqlAdapter
+
+      INSERT = 'INSERT'
+      UPDATE = 'UPDATE'
+
+      # Suppose I have a table named "pets" with columns dog_id and kitty_id, and I want them to
+      # have a polymorphic database constraint such that dog_id references the "id" column of the
+      # dogs table, and kitty_id references the "name" column of the "cats" table. then my inputs
+      # to this method would be:
+      #   table:    'pets'
+      #   columns:  { 'dog_id' => 'dogs.id', 'kitty_id' => 'cats.name' }
+      #
+      # UNIQUENESS CONSTRAINTS:
+      #
+      # Suppose the pets table also has a 'person_id' column, and we want to impose a uniqueness
+      # constraint such that a given cat or dog can only be associated with the person one time
+      # We can specify this in the options as follows:
+      #   options:  :unique => 'person_id'
+
+      def add_polymorphic_constraints(table, columns, options = {})
+        poly_drop_triggers(table)
+        poly_create_triggers(table, columns.keys)
+        options.symbolize_keys!
+        index_suffix = options[:index_suffix]
+        if options[:unique].present?
+          poly_create_indexes(table, columns.keys, Array(options[:unique]), index_suffix)
+        end
+        columns.each do |(col, reference)|
+          ref_table, ref_col = reference.to_s.split('.')
+          add_foreign_key table, ref_table, :column => col, :primary_key => (ref_col || 'id')
+        end
+      end
+
+      def remove_polymorphic_constraints(table, columns, options = {})
+        poly_drop_triggers(table)
+        index_suffix = options[:index_suffix]
+        columns.each do |(col, reference)|
+          ref_table, ref_col = reference.to_s.split('.')
+          remove_foreign_key table, ref_table
+        end
+        if options[:unique].present?
+          poly_remove_indexes(table, columns.keys, Array(options[:unique]), index_suffix)
+        end
+      end
+
+
+      ##########################################################################
+      private
+
+      def poly_trigger_name(table, action)
+        "#{table}_unique_polyfk_on_#{action}"
+      end
+
+      def poly_drop_trigger(table, action)
+        execute %{DROP TRIGGER IF EXISTS #{poly_trigger_name(table, action)}}
+      end
+
+      def poly_create_trigger(table, action, columns)
+        sql = "CREATE TRIGGER #{poly_trigger_name(table, action)} BEFORE #{action} ON #{table}\n" +
+              "FOR EACH ROW\n" +
+              "BEGIN\n"
+        colchecks = columns.collect { |col| "IF(NEW.#{col} IS NULL, 0, 1)" }.
+                            join(' + ')
+        sql += "IF(#{colchecks}) <> 1 THEN\n" +
+                "SET NEW = 'Error';\n" +
+                "END IF;\n" +
+                "END"
+
+        execute sql
+      end
+
+      def poly_drop_triggers(table)
+        poly_drop_trigger(table, 'INSERT')
+        poly_drop_trigger(table, 'UPDATE')
+      end
+
+      def poly_create_triggers(table, columns)
+        poly_create_trigger(table, 'INSERT', columns)
+        poly_create_trigger(table, 'UPDATE', columns)
+      end
+
+      def poly_create_index(table, column, unique_cols, index_suffix)
+        unique_cols = unique_cols.collect(&:to_s)
+        name = poly_index_name(table, column, unique_cols, index_suffix)
+        execute %{
+          CREATE UNIQUE INDEX #{name} ON #{table} (#{column},#{unique_cols.join(',')})
+        }
+      end
+
+      def poly_remove_index(table, column, unique_cols, index_suffix)
+        unique_cols = unique_cols.collect(&:to_s)
+        name = poly_index_name(table, column, unique_cols, index_suffix)
+        execute %{ DROP INDEX #{name} ON #{table} }
+      end
+
+      def poly_index_name(table, column, unique_cols, index_suffix)
+        index_suffix ||= unique_cols.join('_and_')
+        "index_#{table}_on_#{column}_and_#{index_suffix}"
+      end
+
+      def poly_create_indexes(table, columns, unique_cols, index_suffix)
+        columns.each do |column|
+          poly_create_index(table, column, unique_cols, index_suffix)
+        end
+      end
+
+      def poly_remove_indexes(table, columns, unique_cols, index_suffix)
+        columns.each do |column|
+          poly_remove_index(table, column, unique_cols, index_suffix)
+        end
+      end
+
+    end
+  end
+end
+
+[:MysqlAdapter, :Mysql2Adapter].each do |adapter|
+  begin
+    ActiveRecord::ConnectionAdapters.const_get(adapter).class_eval do
+      include Polymorpheus::ConnectionAdapters::MysqlAdapter
+    end
+  rescue
+  end
+end
+

data/lib/polymorpheus/railtie.rb

@@ -0,0 +1,20 @@
+# Thanks to matthuhiggins/foreigner gem for the template used here
+module Polymorpheus
+  class Railtie < Rails::Railtie
+
+    initializer 'polymorpheus.load_adapter' do
+      ActiveSupport.on_load :active_record do
+
+        ActiveRecord::Base.send :include, Polymorpheus::Interface
+
+        ActiveRecord::ConnectionAdapters.module_eval do
+          include Polymorpheus::ConnectionAdapters::SchemaStatements
+        end
+
+        Polymorpheus::Adapter.load!
+      end
+    end
+
+  end
+end
+

data/lib/polymorpheus/schema_statements.rb

@@ -0,0 +1,17 @@
+module Polymorpheus
+  module ConnectionAdapters
+    module SchemaStatements
+      def self.included(base)
+        base::AbstractAdapter.class_eval do
+          include Polymorpheus::ConnectionAdapters::AbstractAdapter
+        end
+      end
+    end
+
+    module AbstractAdapter
+      def add_polymorphic_constraints(table, columns, options = {})
+      end
+    end
+  end
+end
+

data/lib/polymorpheus/version.rb

@@ -0,0 +1,3 @@
+module Polymorpheus
+  VERSION = '0.1'
+end

data/lib/polymorpheus.rb

@@ -0,0 +1,12 @@
+module Polymorpheus
+  autoload :Adapter, 'polymorpheus/adapter'
+  autoload :Interface, 'polymorpheus/interface'
+
+  module ConnectionAdapters
+    autoload :SchemaStatements, 'polymorpheus/schema_statements'
+  end
+end
+
+Polymorpheus::Adapter.register 'mysql2', 'polymorpheus/mysql_adapter'
+
+require 'polymorpheus/railtie' if defined?(Rails)

data/polymorpheus.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require 'rubygems' unless defined? Gem
+require File.dirname(__FILE__) + "/lib/polymorpheus/version"
+
+Gem::Specification.new do |s|
+  s.name        = "polymorpheus"
+  s.version     = Polymorpheus::VERSION
+  s.authors     = ["Barun Singh"]
+  s.email       = "bsingh@wegowise.com"
+  s.homepage    = "http://github.com/wegowise/polymorpheus"
+  s.summary     = "Provides a database-friendly method for polymorphic relationships"
+  s.description = "Provides a database-friendly method for polymorphic relationships"
+  s.required_rubygems_version = ">= 1.3.6"
+  s.files = Dir.glob(%w[{lib,spec}/**/*.rb [A-Z]*.{txt,rdoc,md} *.gemspec]) + %w{Rakefile}
+  s.extra_rdoc_files = ["README.md", "LICENSE.txt"]
+  s.license = 'MIT'
+  s.add_dependency('foreigner')
+end

data/spec/interface_spec.rb

@@ -0,0 +1,75 @@
+require 'active_record'
+require 'polymorpheus'
+require 'spec_helper'
+
+# this is normally done via a Railtie in non-testing situations
+ActiveRecord::Base.send :include, Polymorpheus::Interface
+
+class Shoe < ActiveRecord::Base
+  belongs_to_polymorphic :man, :woman, :as => :wearer
+  validates_polymorph :wearer
+end
+
+class Man < ActiveRecord::Base
+end
+
+class Woman < ActiveRecord::Base
+end
+
+describe Shoe do
+
+  let(:shoe) { Shoe.new(attributes) }
+  let(:man) { Man.create! }
+  let(:woman) { Woman.create! }
+
+  describe "class level constant" do
+    specify { Shoe::WEARER_KEYS.should == ["man_id", "woman_id"] }
+  end
+
+  describe "helper methods" do
+    specify { Shoe.new.wearer_types.should == ["man", "woman"] }
+  end
+
+  it "make the dynamically defined validation method private" do
+    Shoe.private_instance_methods.
+      include?(:polymorphic_wearer_relationship_is_valid).should be_true
+  end
+
+  shared_examples_for "invalid polymorphic relationship" do
+    specify { shoe.wearer.should == nil }
+    specify { shoe.wearer_active_key.should == nil }
+    specify { shoe.wearer_query_condition.should == nil }
+    it "validates appropriately" do
+      shoe.valid?.should be_false
+      shoe.errors[:base].should ==
+        ["You must specify exactly one of the following: {man, woman}"]
+    end
+  end
+
+  context "when there is no relationship defined" do
+    let(:attributes) { {} }
+    it_should_behave_like "invalid polymorphic relationship"
+  end
+
+  context "when there are multiple relationships defined" do
+    let(:attributes) { { man_id: man.id, woman_id: woman.id } }
+    it_should_behave_like "invalid polymorphic relationship"
+  end
+
+  context "when there is exactly one relationship defined" do
+    shared_examples_for "valid polymorphic relationship" do
+      specify { shoe.wearer.should == man }
+      specify { shoe.wearer_active_key.should == 'man_id' }
+      specify { shoe.wearer_query_condition.should == { 'man_id' => man.id } }
+    end
+    context "and we have specified it via the id value" do
+      let(:attributes) { { man_id: man.id } }
+      it_should_behave_like "valid polymorphic relationship"
+    end
+    context "and we have specified it via the id value" do
+      let(:attributes) { { man: man } }
+      it_should_behave_like "valid polymorphic relationship"
+    end
+  end
+
+end

data/spec/mysql2_adapter_spec.rb

@@ -0,0 +1,54 @@
+require 'active_record'
+require 'spec_helper'
+require 'sql_logger'
+require 'foreigner'
+require 'foreigner/connection_adapters/mysql2_adapter'
+require 'polymorpheus'
+
+Polymorpheus::Adapter.load!
+
+describe "Polymorpheus" do
+  class << ActiveRecord::Base.connection
+    include Polymorpheus::SqlLogger
+  end
+
+  let(:connection) { ActiveRecord::Base.connection }
+  let(:sql) { connection.sql_statements }
+
+  describe "add_polymorphic_constraints" do
+    before do
+      connection.add_polymorphic_constraints 'pets',
+        { 'dog_id' => 'dogs.id', 'kitty_id' => 'cats.name' }
+    end
+
+    it "executes the correct sql statements" do
+      clean_sql(sql.join("\n")).should == clean_sql(%{
+        DROP TRIGGER IF EXISTS pets_unique_polyfk_on_INSERT
+        DROP TRIGGER IF EXISTS pets_unique_polyfk_on_UPDATE
+        CREATE TRIGGER pets_unique_polyfk_on_INSERT BEFORE INSERT ON pets
+          FOR EACH ROW
+            BEGIN
+              IF(IF(NEW.dog_id IS NULL, 0, 1) + IF(NEW.kitty_id IS NULL, 0, 1)) <> 1 THEN
+                SET NEW = 'Error';
+              END IF;
+            END
+        CREATE TRIGGER pets_unique_polyfk_on_UPDATE BEFORE UPDATE ON pets
+          FOR EACH ROW
+            BEGIN
+              IF(IF(NEW.dog_id IS NULL, 0, 1) + IF(NEW.kitty_id IS NULL, 0, 1)) <> 1 THEN
+                SET NEW = 'Error';
+              END IF;
+            END
+
+        ALTER TABLE `pets` ADD CONSTRAINT `pets_dog_id_fk` FOREIGN KEY (`dog_id`) REFERENCES `dogs`(id)
+        ALTER TABLE `pets` ADD CONSTRAINT `pets_kitty_id_fk` FOREIGN KEY (`kitty_id`) REFERENCES `cats`(name)
+      })
+    end
+
+  end
+
+  def clean_sql(sql_string)
+    sql_string.gsub(/^\n\s*/,'').gsub(/\s*\n\s*$/,'').gsub(/\n\s*/,"\n")
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+ActiveRecord::Base.establish_connection({
+  adapter: 'mysql2',
+  username: 'root',
+  password: '',
+  host: 'localhost',
+  database: 'polymorphicTest'
+})
+
+ActiveRecord::Base.connection.tables.each do |table|
+  ActiveRecord::Base.connection.drop_table table
+end
+
+ActiveRecord::Schema.define do
+  create_table :shoes do |t|
+    t.integer :man_id
+    t.integer :woman_id
+  end
+  create_table :men
+  create_table :women
+end
+

data/spec/sql_logger.rb

@@ -0,0 +1,17 @@
+module Polymorpheus
+  module SqlLogger
+
+    def sql_statements
+      @sql_statements ||= []
+    end
+
+    private
+
+    def execute(sql, name = nil)
+      sql_statements << sql
+      sql
+    end
+
+  end
+end
+

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: polymorpheus
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Barun Singh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-13 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: foreigner
+  requirement: &70170816060540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70170816060540
+description: Provides a database-friendly method for polymorphic relationships
+email: bsingh@wegowise.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE.txt
+files:
+- lib/polymorpheus/adapter.rb
+- lib/polymorpheus/interface.rb
+- lib/polymorpheus/mysql_adapter.rb
+- lib/polymorpheus/railtie.rb
+- lib/polymorpheus/schema_statements.rb
+- lib/polymorpheus/version.rb
+- lib/polymorpheus.rb
+- spec/interface_spec.rb
+- spec/mysql2_adapter_spec.rb
+- spec/spec_helper.rb
+- spec/sql_logger.rb
+- LICENSE.txt
+- README.md
+- polymorpheus.gemspec
+- Rakefile
+homepage: http://github.com/wegowise/polymorpheus
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Provides a database-friendly method for polymorphic relationships
+test_files: []