aspgems-foreign_key_migrations 2.0.0.beta1

data/lib/foreign_key_migrations/active_record/connection_adapters/table_definition.rb

@@ -0,0 +1,50 @@
+module ForeignKeyMigrations::ActiveRecord::ConnectionAdapters
+  module TableDefinition
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :column, :foreign_key_migrations
+        alias_method_chain :primary_key, :foreign_key_migrations
+      end
+    end
+
+    def primary_key_with_foreign_key_migrations(name, options = {})
+      column(name, :primary_key, options)
+    end
+
+    def indices
+      @indices ||= []
+    end
+
+    def column_with_foreign_key_migrations(name, type, options = {})
+      column_without_foreign_key_migrations(name, type, options)
+      references = ActiveRecord::Base.references(self.name, name, options)
+      if references
+        ForeignKeyMigrations.set_default_update_and_delete_actions!(options)
+        foreign_key(name, references.first, references.last, options)
+        if index = fkm_index_options(options)
+          # append [column_name, index_options] pair
+          self.indices << [name, ForeignKeyMigrations.options_for_index(index)]
+        end
+      elsif options[:index]
+        self.indices << [name, ForeignKeyMigrations.options_for_index(options[:index])]
+      end
+      self
+    end
+
+    # Some people liked this; personally I've decided against using it but I'll keep it nonetheless
+    def belongs_to(table, options = {})
+      options = options.merge(:references => table)
+      options[:on_delete] = options.delete(:dependent) if options.has_key?(:dependent)
+      column("#{table.to_s.singularize}_id".to_sym, :integer, options)
+    end
+
+    protected
+    def fkm_index_options(options)
+      options.fetch(:index, fkm_use_auto_index?)
+    end
+
+    def fkm_use_auto_index?
+      ForeignKeyMigrations.auto_index && !ActiveRecord::Schema.defining?
+    end
+  end
+end

data/lib/foreign_key_migrations/active_record/migration.rb

@@ -0,0 +1,62 @@
+module ForeignKeyMigrations::ActiveRecord
+  module Migration
+    def self.included(base) # :nodoc
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Overrides ActiveRecord#add_column and adds foreign key if column references other column
+      #
+      # add_column('comments', 'post_id', :integer)
+      #   # creates a column and adds foreign key on posts(id)
+      #
+      # add_column('comments', 'post_id', :integer, :on_update => :cascade, :on_delete => :cascade)
+      #   # creates a column and adds foreign key on posts(id) with cascade actions on update and on delete
+      #
+      # add_column('comments', 'post_id', :integer, :index => true)
+      #   # creates a column and adds foreign key on posts(id)
+      #   # additionally adds index on posts(id)
+      #
+      # add_column('comments', 'post_id', :integer, :index => { :unique => true, :name => 'comments_post_id_unique_index' }))
+      #   # creates a column and adds foreign key on posts(id)
+      #   # additionally adds unique index on posts(id) named comments_post_id_unique_index
+      #
+      # add_column('addresses', 'citizen_id', :integer, :references => :users
+      #   # creates a column and adds foreign key on users(id)
+      #
+      # add_column('addresses', 'citizen_id', :integer, :references => [:users, :uuid]
+      #   # creates a column and adds foreign key on users(uuid)
+      #
+      def add_column(table_name, column_name, type, options = {})
+        super
+        handle_column_options(table_name, column_name, options)
+      end
+
+      def change_column(table_name, column_name, type, options = {})
+        super
+        remove_foreign_key_if_exists(table_name, column_name)
+        handle_column_options(table_name, column_name, options)
+      end
+
+      protected
+      def handle_column_options(table_name, column_name, options)
+        references = ActiveRecord::Base.references(table_name, column_name, options)
+        if references
+          ForeignKeyMigrations.set_default_update_and_delete_actions!(options)
+          add_foreign_key(table_name, column_name, references.first, references.last, options)
+          if index = options.fetch(:index, ForeignKeyMigrations.auto_index)
+            add_index(table_name, column_name, ForeignKeyMigrations.options_for_index(index))
+          end
+        elsif options[:index]
+          add_index(table_name, column_name, ForeignKeyMigrations.options_for_index(options[:index]))
+        end
+      end
+
+      def remove_foreign_key_if_exists(table_name, column_name)
+        foreign_keys = ActiveRecord::Base.connection.foreign_keys(table_name.to_s)
+        fk = foreign_keys.detect { |fk| fk.table_name == table_name.to_s && fk.column_names == Array(column_name).collect(&:to_s) }
+        remove_foreign_key(table_name, fk.name) if fk
+      end
+    end
+  end
+end

data/lib/foreign_key_migrations/version.rb

@@ -0,0 +1,3 @@
+module ForeignKeyMigrations
+  VERSION = "2.0.0.beta1"
+end

data/lib/generators/foreign_key_migrations/migration_generator.rb

@@ -0,0 +1,38 @@
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module ForeignKeyMigrations
+  module Generators
+    class MigrationGenerator < ::ActiveRecord::Generators::Base
+      argument :name, :default => 'create_foreign_keys'
+
+      def self.source_root
+        File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+      end
+
+      def create_migration_file
+        set_local_assigns!
+        migration_template 'migration.rb', "db/migrate/#{file_name}"
+      end
+
+      protected
+      attr_reader :foreign_keys
+
+      def set_local_assigns!
+        @foreign_keys = determine_foreign_keys
+      end
+
+      def determine_foreign_keys
+        foreign_keys = []
+        connection = ::ActiveRecord::Base.connection
+        connection.tables.each do |table_name|
+          connection.columns(table_name).each do |column|
+            references = ::ActiveRecord::Base.references(table_name, column.name)
+            foreign_keys << ::RedhillonrailsCore::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(nil, table_name, column.name, references.first, references.last) if references
+          end
+        end
+        foreign_keys
+      end
+    end
+  end
+end

data/lib/generators/foreign_key_migrations/templates/migration.rb

@@ -0,0 +1,10 @@
+class <%= migration_name %> < ActiveRecord::Migration
+  def self.up
+<% foreign_keys.each do |foreign_key| -%>
+    <%= foreign_key.to_dump %>
+<% end -%>
+  end
+
+  def self.down
+  end
+end

data/spec/aaa_create_tables_spec.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+# This is not a test really. It just here to create schema
+# The filename begins with "aaa" to ensure this is executed initially
+
+ActiveRecord::Migration.suppress_messages do
+  load_schema
+end

data/spec/connections/mysql/connection.rb

@@ -0,0 +1,16 @@
+print "Using MySQL\n"
+require 'logger'
+
+ActiveRecord::Base.configurations = {
+  'fkm' => {
+    :adapter => 'mysql',
+    :database => 'fkm_unittest',
+    :username => 'fkm',
+    :encoding => 'utf8',
+    :socket => '/var/run/mysqld/mysqld.sock',
+    :min_messages => 'warning'
+  }
+
+}
+
+ActiveRecord::Base.establish_connection 'fkm'

data/spec/connections/mysql2/connection.rb

@@ -0,0 +1,16 @@
+print "Using MySQL2\n"
+require 'logger'
+
+ActiveRecord::Base.configurations = {
+  'fkm' => {
+    :adapter => 'mysql2',
+    :database => 'fkm_unittest',
+    :username => 'fkm',
+    :encoding => 'utf8',
+    :socket => '/var/run/mysqld/mysqld.sock',
+    :min_messages => 'warning'
+  }
+
+}
+
+ActiveRecord::Base.establish_connection 'fkm'

data/spec/connections/postgresql/connection.rb

@@ -0,0 +1,13 @@
+print "Using PostgreSQL\n"
+require 'logger'
+
+ActiveRecord::Base.configurations = {
+  'fkm' => {
+    :adapter => 'postgresql',
+    :database => 'fkm_unittest',
+    :min_messages => 'warning'
+  }
+
+}
+
+ActiveRecord::Base.establish_connection 'fkm'

data/spec/migration_spec.rb

@@ -0,0 +1,257 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'models/post'
+require 'models/comment'
+
+describe ActiveRecord::Base do
+
+  it "should respond to references" do
+    ActiveRecord::Base.should respond_to :references
+  end
+
+end
+
+describe ActiveRecord::Migration do
+  include ForeignKeyMigrationsHelpers
+
+  context "when table is created" do
+
+    before(:each) do
+      @model = Post
+    end
+
+    it "should create foreign keys" do
+      create_table(@model,  :user_id => {}, 
+                          :author_id => { :references => :users },
+                          :member_id => { :references => nil } )
+      @model.should reference(:users, :id).on(:user_id)
+      @model.should reference(:users, :id).on(:author_id)
+      @model.should_not reference.on(:member_id)
+    end
+
+    it "should use default on_cascade action" do
+      ForeignKeyMigrations.on_update = :cascade
+      create_table(@model, :user_id => {})
+      ForeignKeyMigrations.on_update = nil
+      @model.should reference.on(:user_id).on_update(:cascade)
+    end
+
+    it "should use default on_cascade action" do
+      ForeignKeyMigrations.on_delete = :cascade
+      create_table(@model, :user_id => {})
+      ForeignKeyMigrations.on_delete = nil
+      @model.should reference.on(:user_id).on_delete(:cascade) 
+    end
+
+    it "should create an index if specified" do
+      create_table(@model, :state => { :index => true })
+      @model.should have_index.on(:state)
+    end
+
+    it "should create a multiple-column index if specified" do
+      create_table(@model, :city => {},
+                   :state => { :index => {:with => :city} } ) 
+      @model.should have_index.on([:state, :city])
+    end
+    
+    it "should auto-index foreign keys only" do
+      ForeignKeyMigrations.auto_index = true
+      create_table(@model,  :user_id => {},
+                            :application_id => { :references => nil },
+                            :state => {})
+      @model.should have_index.on(:user_id)
+      @model.should_not have_index.on(:application_id)
+      @model.should_not have_index.on(:state)
+      ForeignKeyMigrations.auto_index = nil
+    end
+
+  end
+
+  context "when column is added" do
+
+    before(:each) do
+      @model = Comment
+    end
+
+    it "should create foreign key" do
+      add_column(:post_id, :integer) do
+        @model.should reference(:posts, :id).on(:post_id)
+      end
+    end
+
+    it "should create foreign key to explicity given table" do
+      add_column(:author_id, :integer, :references => :users) do
+        @model.should reference(:users, :id).on(:author_id)
+      end
+    end
+
+    it "should create foreign key to explicity given table and column name" do
+      add_column(:author_login, :string, :references => [:users, :login]) do 
+        @model.should reference(:users, :login).on(:author_login) 
+      end
+    end
+
+    it "should create foreign key to the same table on parent_id" do
+      add_column(:parent_id, :integer) do
+        @model.should reference(@model.table_name, :id).on(:parent_id)
+      end
+    end
+
+    it "shouldn't create foreign key if column doesn't look like foreign key" do
+      add_column(:views_count, :integer) do
+        @model.should_not reference.on(:views_count)
+      end
+    end
+
+    it "shouldnt't create foreign key if specified explicity" do
+      add_column(:post_id, :integer, :references => nil) do
+        @model.should_not reference.on(:post_id)
+      end
+    end
+
+    it "should create an index if specified" do
+      add_column(:post_id, :integer, :index => true) do
+        @model.should have_index.on(:post_id)
+      end
+    end
+
+    it "should create a unique index if specified" do
+      add_column(:post_id, :integer, :index => { :unique => true }) do
+        @model.should have_unique_index.on(:post_id)
+      end
+    end
+
+    it "should allow custom name for index" do
+      index_name = 'comments_post_id_unique_index'
+      add_column(:post_id, :integer, :index => { :unique => true, :name => index_name }) do
+        @model.should have_unique_index(:name => index_name).on(:post_id)
+      end
+    end
+
+    it "should auto-index if specified in global options" do
+      ForeignKeyMigrations.auto_index = true
+      add_column(:post_id, :integer) do
+        @model.should have_index.on(:post_id)
+      end
+      ForeignKeyMigrations.auto_index = false
+    end
+
+    it "should auto-index foreign keys only" do
+      ForeignKeyMigrations.auto_index = true
+      add_column(:state, :integer) do
+        @model.should_not have_index.on(:state)
+      end
+      ForeignKeyMigrations.auto_index = false
+    end
+
+    it "should allow to overwrite auto_index options in column definition" do
+      ForeignKeyMigrations.auto_index = true
+      add_column(:post_id, :integer, :index => false) do
+        # MySQL creates an index on foreign by default
+        # and we can do nothing with that
+        unless mysql?
+          @model.should_not have_index.on(:post_id)
+        end
+      end
+      ForeignKeyMigrations.auto_index = false
+    end
+
+    it "should use default on_update action" do
+      ForeignKeyMigrations.on_update = :cascade
+      add_column(:post_id, :integer) do
+        @model.should reference.on(:post_id).on_update(:cascade)
+      end
+      ForeignKeyMigrations.on_update = nil
+    end
+
+    it "should use default on_delete action" do
+      ForeignKeyMigrations.on_delete = :cascade
+      add_column(:post_id, :integer) do
+        @model.should reference.on(:post_id).on_delete(:cascade) 
+      end
+      ForeignKeyMigrations.on_delete = nil
+    end
+
+    it "should allow to overwrite default actions" do
+      ForeignKeyMigrations.on_delete = :cascade
+      ForeignKeyMigrations.on_update = :restrict
+      add_column(:post_id, :integer, :on_update => :set_null, :on_delete => :set_null) do
+        @model.should reference.on(:post_id).on_delete(:set_null).on_update(:set_null)
+      end
+      ForeignKeyMigrations.on_delete = nil
+    end
+
+    protected
+    def add_column(column_name, *args)
+      table = @model.table_name
+      ActiveRecord::Migration.suppress_messages do
+        ActiveRecord::Migration.add_column(table, column_name, *args)
+        @model.reset_column_information
+        yield if block_given?
+        ActiveRecord::Migration.remove_column(table, column_name)
+      end
+    end
+
+  end
+
+  context "when column is changed" do
+
+    before(:each) do
+      @model = Comment
+    end
+
+    it "should create foreign key" do
+      change_column :user, :string, :references => [:users, :login]
+      @model.should reference(:users, :login).on(:user)
+      change_column :user, :string, :references => nil
+    end
+
+    context "and initially references to users table" do
+
+      it "should have foreign key" do
+        @model.should reference(:users)
+      end
+
+      it "should drop foreign key afterwards" do
+        change_column :user_id, :integer, :references => :members
+        @model.should_not reference(:users)
+        change_column :user_id, :integer, :references => :users
+      end
+
+      it "should reference pointed table afterwards" do
+        change_column :user_id, :integer, :references => :members
+        @model.should reference(:members)
+      end
+
+    end
+    
+    protected
+    def change_column(column_name, *args)
+      table = @model.table_name
+      ActiveRecord::Migration.suppress_messages do
+        ActiveRecord::Migration.change_column(table, column_name, *args)
+        @model.reset_column_information
+      end
+    end
+
+  end
+    
+  def foreign_key(model, column)
+    columns = Array(column).collect(&:to_s)
+    model.foreign_keys.detect { |fk| fk.table_name == model.table_name && fk.column_names == columns } 
+  end
+
+  def create_table(model, columns_with_options)
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Migration.create_table model.table_name, :force => true do |t|
+        columns_with_options.each_pair do |column, options|
+          t.integer column, options
+        end
+      end
+      model.reset_column_information
+    end
+  end
+
+end
+