polymorpheus 0.2 → 1.0

data/README.md

@@ -0,0 +1,145 @@
+# Polymorpheus
+**Polymorphic relationships in Rails that keep your database happy with almost no setup**
+
+### Background
+* **What is polymorphism?** [Rails Guides has a great overview of what polymorphic relationships are and how Rails handles them](http://guides.rubyonrails.org/association_basics.html#polymorphic-associations)
+
+* **If you don't think database constraints are important** then [here is a presentation that might change your mind](http://bostonrb.org/presentations/databases-constraints-polymorphism). If you're still not convinced, this gem won't be relevant to you.
+
+* **What's wrong with Rails' built-in approach to polymorphism?** Using Rails, polymorphism is implemented in the database using a `type` column and an `id` column, where the `id` column references one of multiple other tables, depending on the `type`. This violates the basic principle that one column in a database should mean to one thing, and it prevents us from setting up any sort of database constraint on the `id` column.
+
+
+## Basic Use
+
+We'll outline the use case to mirror the example [outline in the Rails Guides](http://guides.rubyonrails.org/association_basics.html#polymorphic-associations):
+
+* You have a `Picture` object that can belong to an `Imageable`, where an `Imageable` is a polymorphic representation of either an `Employee` or a `Product`.
+
+With Polymorpheus, you would define this relationship as follows:
+
+**Database migration**
+
+```
+class SetUpPicturesTable < ActiveRecord::Migration
+  def self.up
+    create_table :pictures do |t|
+      t.integer :employee_id
+      t.integer :product_id
+    end
+
+    add_polymorphic_constraints 'pictures',
+      { 'employee_id' => 'employees.id',
+        'product_id' => 'products.id' }
+  end
+
+  def self.down
+    remove_polymorphic_constraints 'pictures',
+      { 'employee_id' => 'employees.id',
+        'product_id' => 'products.id' }
+
+    drop_table :pictures
+  end
+end
+```
+
+**ActiveRecord model definitions**
+
+```
+class Picture < ActiveRecord::Base
+  belongs_to_polymorphic :employee, :product, :as => :imageable
+  validates_polymorphic :imageable
+end
+
+class Employee < ActiveRecord::Base
+  has_many :pictures
+end
+
+class Product < ActiveRecord::Base
+  has_many :pictures
+end
+```
+
+That's it!
+
+Now let's review what we've done.
+
+
+## Database Migration
+
+* Instead of `imageable_type` and `imageable_id` columns in the pictures table, we've created explicit columns for the `employee_id` and `product_id`
+* The `add_polymorphic_constraints` call takes care of all of the database constraints you need, without you needing to worry about sql! Specifically it:
+  * Creates foreign key relationships in the database as specified. So in this example, we have specified that the `employee_id` column in the `pictures` table should have a foreign key constraint with the `id` column of the `employees` table.
+  * Creates appropriate triggers in our database that make sure that exactly on or the other of `employee_id` or `poduct_id` are specified for a given record. An exception will be raised if you try to save a database record that contains both or none of them.
+* **Options for migrations**: There are options to add uniqueness constraints, customize the foreign keys generated by Polymorpheus, and specify the name of generated database indexes. For more info on this, [read the wiki entry](https://github.com/wegowise/polymorpheus/wiki/Migration-options).
+
+## Model definitions
+
+* The `belongs_to_polymorphic` declaration in the `Picture` class specifies the polymorphic relationship. It provides all of the same methods that Rails does for it's built-in polymorphic relationships, plus a couple additional features. See the Interface section below.
+* `validates_polymorph` declaration: checks that exactly one of the possible polymorphic relationships is specified. In this example, either an `employee_id` or `product_id` must be specified -- if both are nil or if both are non-nil a validation error will be added to the object.
+* The `has_many` declarations are just normal Rails declarations.
+
+
+## Requirements / Support
+
+* Currently the gem only supports MySQL. Postgres support is planned; please feel free to fork and submit a (well-tested) pull request if you want to add Postgres support before then.
+* This gem is tested and has been tested for Rails 2.3.8, 3.0.x, 3.1.x and 3.2.x
+* For Rails 3.1+, you'll still need to use `up` and `down` methods in your migrations.
+
+## Interface
+
+The nice thing about Polymorpheus is that under the hood it builds on top of the Rails conventions you're already used to which means that you can interface with your polymorphic relationships in simple, familiar ways. There are also a number of helpful interface helpers that you can use.
+
+Let's use the example above to illustrate.
+
+```
+sam = Employee.create(name: 'Sam')
+nintendo = Product.create(name: 'Nintendo')
+
+pic = Picture.new
+ => #<Picture id: nil, employee_id: nil, product_id: nil>
+
+pic.imageable
+ => nil
+
+# the following two options are equivalent, just as they are normally with ActiveRecord:
+#   pic.employee = sam
+#   pic.employee_id = sam.id
+
+# if we specify an employee, the imageable getter method will return that employee:
+pic.employee = sam;
+pic.imageable
+ => #<Employee id: 1, name: "Sam">
+pic.employee
+ => #<Employee id: 1, name: "Sam">
+pic.product
+ => nil
+
+# if we specify a product, the imageable getting will return that product:
+Picture.new(product: nintendo).imageable
+ => #<Product id: 1, name: "Nintendo">
+
+# but if we specify an employee and a product, the getter will know this makes no sense and return nil for the imageable:
+Picture.new(employee: sam, product: nintendo).imageable
+ => nil
+
+# There are some useful helper methods:
+
+pic.imageable_active_key
+ => "employee_id"
+
+pic.imageable_query_condition
+ => {"employee_id"=>"1"}
+
+pic.imageable_types
+ => ["employee", "picture"]
+
+Picture::IMAGEABLE_KEYS
+ => ["employee_id", "picture_id"]
+```
+
+## Credits and License
+
+* This gem was written by [Barun Singh](https://github.com/barunio)
+* It uses the [Foreigner gem](https://github.com/matthuhiggins/foreigner) under the hood for a few things
+
+polymorpheus is Copyright © 2011-2012 Barun Singh and [WegoWise](http://wegowise.com). It is free software, and may be redistributed under the terms specified in the LICENSE file.

data/lib/polymorpheus.rb

@@ -1,6 +1,8 @@
 module Polymorpheus
   autoload :Adapter, 'polymorpheus/adapter'
   autoload :Interface, 'polymorpheus/interface'
+  autoload :Trigger, 'polymorpheus/trigger'
+  autoload :SchemaDumper, 'polymorpheus/schema_dumper'
 
   module ConnectionAdapters
     autoload :SchemaStatements, 'polymorpheus/schema_statements'

data/lib/polymorpheus/mysql_adapter.rb

@@ -5,75 +5,115 @@ module Polymorpheus
       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' }
+      # See the README for explanations regarding the use of these methods
       #
-      # UNIQUENESS CONSTRAINTS:
+      # table:    a string equal to the name of the db table
       #
-      # 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)
+      # columns:  a hash, with keys equal to the column names in the table we
+      #           are operating on, and values indicating the foreign key
+      #           association through the form "table.column". so,
+      #             { 'employee_id' => 'employees.ssn',
+      #               'product_id' => 'products.id' }
+      #           indicates that the `employee_id` column in `table` should have
+      #           a foreign key constraint connecting it to the `ssn` column
+      #           in the `employees` table, and the `product_id` column should
+      #           have a foreign key constraint with the `id` column in the
+      #           `products` table
+      #
+      # options:  a hash, corrently only accepts one option that allows us to
+      #           add an additional uniqueness constraint.
+      #           if the columns hash was specified as above, and we supplied
+      #           options of
+      #             { :unique => true }
+      #           then this would create a uniqueness constraint in the database
+      #           that would ensure that any given employee_id could only be in
+      #           the table once, and that any given product_id could only be in
+      #           the table once.
+      #
+      #           alternatively, the user can also supply a column name or array
+      #           of column names to the :unique option:
+      #             { :unique => 'picture_url' }
+      #           This would allow an employee_id (or product_id) to appear
+      #           multiple times in the table, but no two employee ids would
+      #           be able to have the same picture_url.
+
+      def add_polymorphic_constraints(table, columns, options={})
+        column_names = columns.keys.sort
+        add_polymorphic_triggers(table, column_names)
         options.symbolize_keys!
-        index_suffix = options[:index_suffix]
         if options[:unique].present?
-          poly_create_indexes(table, columns.keys, Array(options[:unique]), index_suffix)
+          poly_create_indexes(table, column_names, Array(options[:unique]))
         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')
+        column_names.each do |col_name|
+          ref_table, ref_col = columns[col_name].to_s.split('.')
+          add_foreign_key table, ref_table,
+                                 :column => col_name,
+                                 :primary_key => (ref_col || 'id')
         end
       end
 
       def remove_polymorphic_constraints(table, columns, options = {})
-        poly_drop_triggers(table)
-        index_suffix = options[:index_suffix]
+        poly_drop_triggers(table, columns.keys.sort)
         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)
+          poly_remove_indexes(table, columns.keys, Array(options[:unique]))
         end
       end
 
+      def triggers
+        execute("show triggers").collect {|t| Trigger.new(t) }
+      end
+
+      #
+      # DO NOT USE THIS METHOD DIRECTLY
+      #
+      # it will not create the foreign key relationships you want. the only
+      # reason it is here is because it is used by the schema dumper, since
+      # the schema dump will contains separate statements for foreign keys,
+      # and we don't want to duplicate those
+      def add_polymorphic_triggers(table, column_names)
+        column_names.sort!
+        poly_drop_triggers(table, column_names)
+        poly_create_triggers(table, column_names)
+      end
+
 
       ##########################################################################
       private
 
-      def poly_trigger_name(table, action)
-        "#{table}_unique_polyfk_on_#{action}"
+      def poly_trigger_name(table, action, columns)
+        prefix = "pfk#{action.first}_#{table}_".downcase
+        generate_name prefix, columns.sort
       end
 
-      def poly_drop_trigger(table, action)
-        execute %{DROP TRIGGER IF EXISTS #{poly_trigger_name(table, action)}}
+      def poly_drop_trigger(table, action, columns)
+        trigger_name = poly_trigger_name(table, action, columns)
+        execute %{DROP TRIGGER IF EXISTS #{trigger_name}}
       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"
+        trigger_name = poly_trigger_name(table, action, columns)
         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"
+
+        sql = %{
+          CREATE TRIGGER #{trigger_name} BEFORE #{action} ON #{table}
+            FOR EACH ROW
+            BEGIN
+              IF(#{colchecks}) <> 1 THEN
+                SET NEW = 'Error';
+              END IF;
+            END}
 
         execute sql
       end
 
-      def poly_drop_triggers(table)
-        poly_drop_trigger(table, 'INSERT')
-        poly_drop_trigger(table, 'UPDATE')
+      def poly_drop_triggers(table, columns)
+        poly_drop_trigger(table, 'INSERT', columns)
+        poly_drop_trigger(table, 'UPDATE', columns)
       end
 
       def poly_create_triggers(table, columns)
@@ -81,37 +121,53 @@ module Polymorpheus
         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)
+      def poly_create_index(table, column, unique_cols)
+        if unique_cols == [true]
+          unique_cols = [column]
+        else
+          unique_cols = [column] + unique_cols
+        end
+        name = poly_index_name(table, unique_cols)
         execute %{
-          CREATE UNIQUE INDEX #{name} ON #{table} (#{column},#{unique_cols.join(',')})
+          CREATE UNIQUE INDEX #{name} ON #{table} (#{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)
+      def poly_remove_index(table, column, unique_cols)
+        if unique_cols == [true]
+          unique_cols = [column]
+        else
+          unique_cols = [column] + unique_cols
+        end
+        name = poly_index_name(table, unique_cols)
         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}"
+      def poly_index_name(table, columns)
+        prefix = "pfk_#{table}_"
+        generate_name prefix, columns
       end
 
-      def poly_create_indexes(table, columns, unique_cols, index_suffix)
+      def poly_create_indexes(table, columns, unique_cols)
         columns.each do |column|
-          poly_create_index(table, column, unique_cols, index_suffix)
+          poly_create_index(table, column, unique_cols)
         end
       end
 
-      def poly_remove_indexes(table, columns, unique_cols, index_suffix)
+      def poly_remove_indexes(table, columns, unique_cols)
         columns.each do |column|
-          poly_remove_index(table, column, unique_cols, index_suffix)
+          poly_remove_index(table, column, unique_cols)
         end
       end
 
+      def generate_name(prefix, columns)
+        # names can be at most 64 characters long
+        col_length = (64 - prefix.length) / columns.length
+
+        prefix +
+          columns.map { |c| c.to_s.gsub('_','').first(col_length-1) }.join('_')
+      end
+
     end
   end
 end

data/lib/polymorpheus/railtie.rb

@@ -11,6 +11,10 @@ module Polymorpheus
           include Polymorpheus::ConnectionAdapters::SchemaStatements
         end
 
+        ActiveRecord::SchemaDumper.class_eval do
+          include Polymorpheus::SchemaDumper
+        end
+
         Polymorpheus::Adapter.load!
       end
     end

data/lib/polymorpheus/schema_dumper.rb

@@ -0,0 +1,19 @@
+module Polymorpheus
+  module SchemaDumper
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method_chain :tables, :triggers
+    end
+
+    def tables_with_triggers(stream)
+      tables_without_triggers(stream)
+
+      @connection.triggers.collect(&:schema_statement).each do |statement|
+        stream.puts statement
+      end
+      stream.puts
+    end
+  end
+ end
+

data/lib/polymorpheus/trigger.rb

@@ -0,0 +1,29 @@
+class Trigger
+
+  attr_accessor :name, :event, :table, :statement, :timing, :created, :sql_mode,
+                :definer, :charset, :collation_connection, :db_collation
+
+  def initialize(arr)
+    raise ArgumentError unless arr.is_a?(Array) && arr.length == 11
+    [:name, :event, :table, :statement, :timing, :created, :sql_mode,
+      :definer, :charset, :collation_connection, :db_collation].
+    each_with_index do |attr, ind|
+      self.send("#{attr}=", arr[ind])
+    end
+  end
+
+  def columns
+    /IF\((.*)\) \<\> 1/.match(self.statement) do |match|
+      match[1].split(' + ').collect do |submatch|
+        /NEW\.([^ ]*)/.match(submatch)[1]
+      end
+    end
+  end
+
+  def schema_statement
+    # note that we don't need to worry about unique indices or foreign keys
+    # because separate schema statements will be generated for them
+    "add_polymorphic_triggers(#{table}, #{columns})"
+  end
+
+end

data/lib/polymorpheus/version.rb

@@ -1,3 +1,3 @@
 module Polymorpheus
-  VERSION = '0.2'
+  VERSION = '1.0'
 end

data/spec/mysql2_adapter_spec.rb

@@ -4,49 +4,213 @@ require 'sql_logger'
 require 'foreigner'
 require 'foreigner/connection_adapters/mysql2_adapter'
 require 'polymorpheus'
+require 'polymorpheus/trigger'
 
 Polymorpheus::Adapter.load!
 
-describe "Polymorpheus" do
-  class << ActiveRecord::Base.connection
-    include Polymorpheus::SqlLogger
+describe Polymorpheus::ConnectionAdapters::MysqlAdapter do
+
+  before(:all) do
+    class << ActiveRecord::Base.connection
+      include Polymorpheus::SqlLogger
+      alias_method :original_execute, :execute
+      alias_method :execute, :log_sql_statements
+    end
+  end
+
+  after(:all) do
+    class << ActiveRecord::Base.connection
+      alias_method :execute, :original_execute
+    end
   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' }
+  before do
+    connection.clear_sql_history
+    subject
+  end
+
+  shared_examples_for "migration statements" do
+    describe "#add_polymorphic_constraints" do
+      before { connection.add_polymorphic_constraints(table, columns, options) }
+
+      specify do
+        clean_sql(sql.join("\n")).should == clean_sql(full_constraints_sql)
+      end
+    end
+
+    describe "#add_polymorphic_triggers" do
+      before { connection.add_polymorphic_triggers(table, columns.keys) }
+
+      specify do
+        clean_sql(sql.join("\n")).should == clean_sql(trigger_sql)
+      end
     end
+  end
+
+  context "when the table and column names are not too long" do
+    let(:table) { 'pets' }
+    let(:columns) { { 'kitty_id' => 'cats.name', 'dog_id' => 'dogs.id' } }
+    let(:options) { {} }
 
-    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
+    let(:trigger_sql) do
+      %{
+        DROP TRIGGER IF EXISTS pfki_pets_dogid_kittyid
+        DROP TRIGGER IF EXISTS pfku_pets_dogid_kittyid
+        CREATE TRIGGER pfki_pets_dogid_kittyid 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
+        CREATE TRIGGER pfku_pets_dogid_kittyid 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
+      }
+    end
 
+    let(:fkey_sql) do
+      %{
         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
+
+    let(:full_constraints_sql) { trigger_sql + fkey_sql }
+
+    it_behaves_like "migration statements"
+
+    context "and we specify a uniqueness constraint as true" do
+      let(:options) { { :unique => true } }
+      let(:unique_key_sql) do
+        %{
+          CREATE UNIQUE INDEX pfk_pets_dogid ON pets (dog_id)
+          CREATE UNIQUE INDEX pfk_pets_kittyid ON pets (kitty_id)
+        }
+      end
+
+      let(:full_constraints_sql) { trigger_sql + unique_key_sql + fkey_sql }
+
+      it_behaves_like "migration statements"
+    end
+
+    context "and we specify a uniqueness constraint as a string" do
+      let(:options) { { :unique => 'field1' } }
+      let(:unique_key_sql) do
+        %{
+          CREATE UNIQUE INDEX pfk_pets_dogid_field1 ON pets (dog_id, field1)
+          CREATE UNIQUE INDEX pfk_pets_kittyid_field1 ON pets (kitty_id, field1)
+        }
+      end
+
+      let(:full_constraints_sql) { trigger_sql + unique_key_sql + fkey_sql }
+
+      it_behaves_like "migration statements"
+    end
+
+    context "and we specify a uniqueness constraint as an array" do
+      let(:options) { { :unique => [:foo, :bar] } }
+      let(:unique_key_sql) do
+        %{
+          CREATE UNIQUE INDEX pfk_pets_dogid_foo_bar ON pets (dog_id, foo, bar)
+          CREATE UNIQUE INDEX pfk_pets_kittyid_foo_bar ON pets (kitty_id, foo, bar)
+        }
+      end
+
+      let(:full_constraints_sql) { trigger_sql + unique_key_sql + fkey_sql }
+
+      it_behaves_like "migration statements"
     end
 
+    context "and we specify a uniqueness constraint on fields with really long names" do
+      let(:options) do
+        { :unique => [:fee_was_a_buddhist_prodigy, :ground_control_to_major_tom] }
+      end
+      let(:unique_key_sql) do
+        %{
+          CREATE UNIQUE INDEX pfk_pets_dogid_feewasabuddhistpr_groundcontroltoma ON pets (dog_id, fee_was_a_buddhist_prodigy, ground_control_to_major_tom)
+          CREATE UNIQUE INDEX pfk_pets_kittyid_feewasabuddhistpr_groundcontroltoma ON pets (kitty_id, fee_was_a_buddhist_prodigy, ground_control_to_major_tom)
+        }
+      end
+
+      let(:full_constraints_sql) { trigger_sql + unique_key_sql + fkey_sql }
+
+      it_behaves_like "migration statements"
+    end
   end
 
+  context "when the table and column names combined are very long" do
+    let(:table) { 'bicycles' }
+    let(:columns) do
+       { 'im_too_cool_to_vote_and_ill_only_ride_a_fixie' => 'hipster.id',
+         'really_im_not_doping_i_just_practice_a_lot' => 'professional.id' }
+    end
+    let(:options) { {} }
+
+    let(:trigger_sql) do
+      %{
+        DROP TRIGGER IF EXISTS pfki_bicycles_imtoocooltovoteandillonl_reallyimnotdopingijustpr
+        DROP TRIGGER IF EXISTS pfku_bicycles_imtoocooltovoteandillonl_reallyimnotdopingijustpr
+        CREATE TRIGGER pfki_bicycles_imtoocooltovoteandillonl_reallyimnotdopingijustpr BEFORE INSERT ON bicycles
+          FOR EACH ROW
+            BEGIN
+              IF(IF(NEW.im_too_cool_to_vote_and_ill_only_ride_a_fixie IS NULL, 0, 1) + IF(NEW.really_im_not_doping_i_just_practice_a_lot IS NULL, 0, 1)) <> 1 THEN
+                SET NEW = 'Error';
+              END IF;
+            END
+        CREATE TRIGGER pfku_bicycles_imtoocooltovoteandillonl_reallyimnotdopingijustpr BEFORE UPDATE ON bicycles
+          FOR EACH ROW
+            BEGIN
+              IF(IF(NEW.im_too_cool_to_vote_and_ill_only_ride_a_fixie IS NULL, 0, 1) + IF(NEW.really_im_not_doping_i_just_practice_a_lot IS NULL, 0, 1)) <> 1 THEN
+                SET NEW = 'Error';
+              END IF;
+            END
+      }
+    end
+
+    let(:fkey_sql) do
+      %{
+        ALTER TABLE `bicycles` ADD CONSTRAINT `bicycles_im_too_cool_to_vote_and_ill_only_ride_a_fixie_fk` FOREIGN KEY (`im_too_cool_to_vote_and_ill_only_ride_a_fixie`) REFERENCES `hipster`(id)
+        ALTER TABLE `bicycles` ADD CONSTRAINT `bicycles_really_im_not_doping_i_just_practice_a_lot_fk` FOREIGN KEY (`really_im_not_doping_i_just_practice_a_lot`) REFERENCES `professional`(id)
+      }
+    end
+
+    let(:unique_key_sql) do
+      %{
+        CREATE UNIQUE INDEX pfk_blah
+      }
+    end
+
+    let(:full_constraints_sql) { trigger_sql + fkey_sql }
+
+    it_behaves_like "migration statements"
+  end
+
+
+
+  describe "#triggers" do
+    let(:trigger1) { stub(Trigger, :name => '1') }
+    let(:trigger2) { stub(Trigger, :name => '2') }
+
+    before do
+      connection.stub_sql('show triggers', [:trigger1, :trigger2])
+      Trigger.stub(:new).with(:trigger1).and_return(trigger1)
+      Trigger.stub(:new).with(:trigger2).and_return(trigger2)
+    end
+
+    specify do
+      connection.triggers.should == [trigger1, trigger2]
+    end
+  end
+
+
   def clean_sql(sql_string)
     sql_string.gsub(/^\n\s*/,'').gsub(/\s*\n\s*$/,'').gsub(/\n\s*/,"\n")
   end

data/spec/schema_dumper_spec.rb

@@ -0,0 +1,48 @@
+require 'active_record'
+require 'spec_helper'
+require 'sql_logger'
+require 'foreigner'
+require 'foreigner/connection_adapters/mysql2_adapter'
+require 'polymorpheus'
+require 'polymorpheus/trigger'
+require 'stringio'
+
+# this is normally done via a Railtie in non-testing situations
+ActiveRecord::SchemaDumper.class_eval { include Polymorpheus::SchemaDumper }
+
+describe Polymorpheus::SchemaDumper do
+
+  let(:connection) { ActiveRecord::Base.connection }
+  let(:stream) { StringIO.new }
+
+  before do
+    # pretend like we have a trigger defined
+    connection.stub(:triggers).and_return(
+      [Trigger.new(["trigger_name", "INSERT", "pets",
+        %{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},
+        "BEFORE", nil, "", "production@%", "utf8", "utf8_general_ci",
+        "utf8_unicode_ci"])]
+    )
+
+    ActiveRecord::SchemaDumper.dump(connection, stream)
+  end
+
+  subject { stream.string }
+
+  let(:schema_statement) do
+    %{add_polymorphic_triggers(pets, ["dog_id", "kitty_id"])}
+  end
+
+  specify "the schema statement is part of the dump" do
+    subject.index(schema_statement).should be_a(Integer)
+  end
+
+  specify "there is exactly one instance of the schema statement" do
+    subject.index(schema_statement).should == subject.rindex(schema_statement)
+  end
+
+end

data/spec/sql_logger.rb

@@ -5,11 +5,24 @@ module Polymorpheus
       @sql_statements ||= []
     end
 
+    def clear_sql_history
+      @sql_statements = nil
+    end
+
+    def stub_sql(statement, response)
+      @stubbed ||= {}
+      @stubbed[statement] = response
+    end
+
     private
 
-    def execute(sql, name = nil)
-      sql_statements << sql
-      sql
+    def log_sql_statements(sql, name = nil)
+      if @stubbed && @stubbed.has_key?(sql)
+        @stubbed[sql]
+      else
+        sql_statements << sql
+        sql
+      end
     end
 
   end

data/spec/trigger_spec.rb

@@ -0,0 +1,46 @@
+require 'polymorpheus'
+require 'polymorpheus/trigger'
+
+describe Trigger do
+
+  let(:name) { "pets_unique_polyfk_on_INSERT" }
+  let(:event) { "INSERT" }
+  let(:table) { "pets"}
+  let(:statement) do
+    %{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}
+  end
+  let(:timing) { "BEFORE" }
+  let(:created) { nil }
+  let(:sql_mode) { "" }
+  let(:definer) { "production@%" }
+  let(:charset) { "utf8" }
+  let(:collation_connection) { "utf8_general_ci" }
+  let(:db_collation) { "utf8_unicode_ci" }
+
+  subject do
+    Trigger.new([name, event, table, statement, timing, created, sql_mode,
+                 definer, charset, collation_connection, db_collation])
+  end
+
+  its(:name) { should == name }
+  its(:event) { should == event }
+  its(:table) { should == table }
+  its(:statement) { should == statement }
+  its(:timing) { should == timing }
+  its(:created) { should == created }
+  its(:sql_mode) { should == sql_mode }
+  its(:definer) { should == definer }
+  its(:charset) { should == charset }
+  its(:collation_connection) { should == collation_connection }
+  its(:db_collation) { should == db_collation }
+
+  its(:columns) { should == %w{dog_id kitty_id} }
+
+  its(:schema_statement) do
+    should == %{add_polymorphic_triggers(pets, ["dog_id", "kitty_id"])}
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: polymorpheus
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '1.0'
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-23 00:00:00.000000000Z
+date: 2012-02-21 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: foreigner
-  requirement: &70363112837300 !ruby/object:Gem::Requirement
+  requirement: &2151832820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70363112837300
+  version_requirements: *2151832820
 description: Provides a database-friendly method for polymorphic relationships
 email: bsingh@wegowise.com
 executables: []
@@ -34,13 +34,17 @@ files:
 - lib/polymorpheus/interface.rb
 - lib/polymorpheus/mysql_adapter.rb
 - lib/polymorpheus/railtie.rb
+- lib/polymorpheus/schema_dumper.rb
 - lib/polymorpheus/schema_statements.rb
+- lib/polymorpheus/trigger.rb
 - lib/polymorpheus/version.rb
 - lib/polymorpheus.rb
 - spec/interface_spec.rb
 - spec/mysql2_adapter_spec.rb
+- spec/schema_dumper_spec.rb
 - spec/spec_helper.rb
 - spec/sql_logger.rb
+- spec/trigger_spec.rb
 - LICENSE.txt
 - README.md
 - polymorpheus.gemspec
@@ -58,6 +62,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 2769054126994398138
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: