sparkfly-foreigner 0.5.4

data/lib/foreigner/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,48 @@
+module Foreigner
+  module ConnectionAdapters
+    module MysqlAdapter
+      include Foreigner::Semantics::Sql2003
+      
+      
+      # Override SQL2003 Semantics for MySQL
+      def sql_for_remove_foreign_key(table, foreign_key_name)
+        "ALTER TABLE #{quote_table_name(table)} DROP FOREIGN KEY #{quote_column_name(foreign_key_name)}"
+      end
+
+      def foreign_keys(table_name)
+        fk_info = select_all %{
+          SELECT fk.referenced_table_name as 'to_table'
+                ,fk.referenced_column_name as 'primary_key'
+                ,fk.column_name as 'column'
+                ,fk.constraint_name as 'name'
+          FROM information_schema.key_column_usage fk
+          WHERE fk.referenced_column_name is not null
+            AND fk.table_schema = '#{@config[:database]}'
+            AND fk.table_name = '#{table_name}'
+        }
+
+        create_table_info = select_one("SHOW CREATE TABLE #{quote_table_name(table_name)}")["Create Table"]
+
+        fk_info.map do |row|
+          options = {:column => row['column'], :name => row['name'], :primary_key => row['primary_key']}
+
+          if create_table_info =~ /CONSTRAINT #{quote_column_name(row['name'])} FOREIGN KEY .* REFERENCES .* ON DELETE (CASCADE|SET NULL)/
+            options[:dependent] = case $1
+              when 'CASCADE'  then :delete
+              when 'SET NULL' then :nullify
+              end
+          end
+          ForeignKeyDefinition.new(table_name.to_s, row['to_table'], options)
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    MysqlAdapter.class_eval do
+      include Foreigner::ConnectionAdapters::MysqlAdapter
+    end
+  end
+end

data/lib/foreigner/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,47 @@
+module Foreigner
+  module ConnectionAdapters
+    module PostgreSQLAdapter
+      include Foreigner::Semantics::Sql2003
+
+      
+      def foreign_keys(table_name)
+        fk_info = select_all %{
+          SELECT tc.constraint_name as name
+                ,ccu.table_name as to_table
+                ,ccu.column_name as primary_key
+                ,kcu.column_name as column
+                ,rc.delete_rule as dependency
+          FROM information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+          USING (constraint_catalog, constraint_schema, constraint_name)
+          JOIN information_schema.referential_constraints rc
+          USING (constraint_catalog, constraint_schema, constraint_name)
+          JOIN information_schema.constraint_column_usage ccu
+          USING (constraint_catalog, constraint_schema, constraint_name)
+          WHERE tc.constraint_type = 'FOREIGN KEY'
+            AND tc.constraint_catalog = '#{@config[:database]}'
+            AND tc.table_name = '#{table_name}'
+        }
+        
+        fk_info.map do |row|
+          options = {:column => row['column'], :name => row['name'], :primary_key => row['primary_key']}
+
+          options[:dependent] = case row['dependency']
+            when 'CASCADE'  then :delete
+            when 'SET NULL' then :nullify
+            end
+
+          ForeignKeyDefinition.new(table_name.to_s, row['to_table'], options)
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    PostgreSQLAdapter.class_eval do
+      include Foreigner::ConnectionAdapters::PostgreSQLAdapter
+    end
+  end
+end

data/lib/foreigner/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,46 @@
+require 'foreigner/connection_adapters/sql_2003'
+
+module Foreigner
+  module ConnectionAdapters
+    module SQLite3Adapter
+      include Foreigner::Semantics::Sql2003
+
+      def foreign_keys(table_name)
+        foreign_keys = []
+        create_table_info = select_value %{
+SELECT sql
+FROM sqlite_master
+WHERE sql LIKE '%FOREIGN KEY%'
+AND name = '#{table_name}'
+}
+      unless create_table_info.nil?
+        fk_columns = create_table_info.scan(/FOREIGN KEY\s*\(\"([^\"]+)\"\)/)
+        fk_tables = create_table_info.scan(/REFERENCES\s*\"([^\"]+)\"/)
+        fk_references = create_table_info.scan(/REFERENCES[^\,]+/)
+        if fk_columns.size == fk_tables.size && fk_references.size == fk_columns.size
+          fk_columns.each_with_index do |fk_column, index|
+            if fk_references[index] =~ /ON DELETE CASCADE/
+              fk_references[index] = :delete
+            elsif fk_references[index] =~ /ON DELETE SET NULL/
+              fk_references[index] = :nullify
+            else
+              fk_references[index] = nil
+            end
+            foreign_keys << ForeignKeyDefinition.new(table_name, fk_tables[index][0], :column => fk_column[0], :dependent => fk_references[index])
+          end
+        end
+      end
+      foreign_keys
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    SQLite3Adapter.class_eval do
+      include Foreigner::ConnectionAdapters::SQLite3Adapter
+    end
+  end
+end
+

data/lib/foreigner/schema_dumper.rb

@@ -0,0 +1,47 @@
+module Foreigner
+  module SchemaDumper
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        alias_method_chain :tables, :foreign_keys
+      end
+    end
+    
+    module InstanceMethods
+      def tables_with_foreign_keys(stream)
+        tables_without_foreign_keys(stream)
+        @connection.tables.sort.each do |table|
+          next unless foreign_keys = @connection.foreign_keys(table)
+          stream.puts generate_foreign_keys_statements(foreign_keys).join("\n")
+        end
+      end
+      
+      private
+
+      # Generates a string for a given list of ForeignKeyDefinition
+      # Has no concept of streams or connections, so this can be tested in isolation.
+      def generate_foreign_keys_statements(foreign_keys)
+        decorator = [
+        # [ :option_name, lambda { |fk| filter } ],
+          [ :name,        lambda { |fk| fk.options[:name] } ],
+          [ :column,      lambda { |fk| fk.options[:column] && fk.options[:column] != "#{fk.to_table.singularize}_id" } ],
+          [ :primary_key, lambda { |fk| fk.options[:primary_key] && fk.options[:primary_key] != 'id' } ],
+          [ :dependent,   lambda { |fk| fk.options[:dependent].present? } ]
+        ] 
+
+        foreign_keys.map do |foreign_key|
+          statement_parts = [[ ' ', 'add_foreign_key', foreign_key.from_table.to_sym.inspect].join(' ') ]
+          statement_parts << foreign_key.to_table.to_sym.inspect
+
+          if foreign_key.options
+            statement_parts << decorator.map do |option, guard|
+              [ ':', option, ' => ', foreign_key.options[option].inspect ].join if guard.call(foreign_key)
+            end - [nil]
+          end
+          '  ' + statement_parts.join(', ')
+        end
+      end
+    end # InstanceMethods
+
+  end
+end

data/lib/foreigner/semantics/sql_2003.rb

@@ -0,0 +1,78 @@
+module Foreigner
+  module Semantics
+    module Sql2003
+      def supports_foreign_keys?
+        true
+      end
+
+      def foreign_key_definition(to_table, options = {})
+        column  = options[:column] || "#{to_table.to_s.singularize}_id"
+        dependency = sql_for_dependency(options[:dependent])
+
+        sql = "FOREIGN KEY (#{quote_column_name(column)}) REFERENCES #{quote_table_name(to_table)}(id)"
+        sql << " #{dependency}" unless dependency.blank?
+        sql
+      end
+
+      def add_foreign_key(from_table, to_table, options = {})
+        column  = options[:column] || "#{to_table.to_s.singularize}_id"
+        foreign_key_name = foreign_key_name(from_table, column, options)
+        primary_key = options[:primary_key] || "id"
+        reference = sql_for_reference(to_table, primary_key)
+        dependency = sql_for_dependency(options[:dependent])
+
+        execute(sql_for_add_foreign_key(from_table, foreign_key_name, column, reference, dependency))
+      end
+
+      def remove_foreign_key(table, options)
+        # If the second argument is table name (String/Symbol) then convert that to the
+        # to the full options hash
+        options = { :column => column_name(options) } if String === options || Symbol === options
+        execute(sql_for_remove_foreign_key(table, foreign_key_name(table, options[:column], options)))
+      end
+
+      private
+      
+      def foreign_key_name(table, column, options = {})
+        return options[:name] if options[:name]
+        "fk_#{table}_#{column}"
+      end
+
+      def column_name(column)
+        "#{column.to_s.singularize}_id"
+      end
+      
+      # Generates SQL and returns it. 
+      def sql_for_add_foreign_key(from_table, foreign_key_name, column, reference, dependent = nil)
+        sql = [
+          "ALTER TABLE #{quote_table_name(from_table)}",
+          "ADD CONSTRAINT #{quote_column_name(foreign_key_name)}",
+          "FOREIGN KEY (#{quote_column_name(column)})",
+          "REFERENCES #{reference}"
+        ]
+
+        sql << "#{dependent}" unless dependent.blank?
+        sql.join(' ')
+      end
+
+      def sql_for_remove_foreign_key(table, foreign_key_name)
+        "ALTER TABLE #{quote_table_name(table)} DROP CONSTRAINT #{quote_column_name(foreign_key_name)}"
+      end
+
+      def sql_for_reference(to_table, primary_key)
+        "#{quote_table_name(ActiveRecord::Migrator.proper_table_name(to_table))}(#{primary_key})"
+      end
+
+
+      def sql_for_dependency(dependency)
+        case dependency
+          when :nullify then 'ON DELETE SET NULL'
+          when :delete  then 'ON DELETE CASCADE'
+          else ''
+        end
+      end
+
+    end
+  end
+end
+

data/spec/adapter_helper.rb

@@ -0,0 +1,100 @@
+
+# CONFIGURATIONS is defined in spec_helper
+
+module AdapterHelper
+  module AdapterTestHarness
+    def recreate_test_environment(env)
+      ActiveRecord::Base.establish_connection(CONFIGURATIONS[env])
+
+      @database = CONFIGURATIONS[env][:database]
+      ActiveRecord::Base.connection.drop_database(@database)
+      ActiveRecord::Base.connection.create_database(@database)
+      ActiveRecord::Base.connection.reset!
+
+      FactoryHelpers::CreateCollection.up
+    end
+
+    def schema(table_name)
+      raise 'This method must be overridden'
+    end
+
+    def foreign_keys(table)
+      ActiveRecord::Base.connection.foreign_keys(table)
+    end
+
+    private
+
+    def execute(sql, name = nil)
+      sql
+    end
+
+    def quote_column_name(name)
+      "`#{name}`"
+    end
+
+    def quote_table_name(name)
+      quote_column_name(name).gsub('.', '`.`')
+    end
+
+  end
+
+  class PostgreSQLTestAdapter
+    include Foreigner::ConnectionAdapters::PostgreSQLAdapter
+    include AdapterTestHarness
+
+    def recreate_test_environment
+      ActiveRecord::Base.establish_connection(CONFIGURATIONS[:postgresql_admin])
+      @database = CONFIGURATIONS[:postgresql][:database]
+
+      ActiveRecord::Base.connection.drop_database(@database)
+      ActiveRecord::Base.connection.create_database(@database)
+
+      ActiveRecord::Base.connection.disconnect!
+      ActiveRecord::Base.establish_connection(CONFIGURATIONS[:postgresql])
+
+      FactoryHelpers::CreateCollection.up
+    end
+  end
+
+  class MySQLTestAdapter 
+    include Foreigner::ConnectionAdapters::MysqlAdapter
+    include AdapterTestHarness
+
+    def schema(table_name)
+      ActiveRecord::Base.connection.select_one("SHOW CREATE TABLE #{quote_table_name(table_name)}")["Create Table"]
+    end
+
+    def recreate_test_environment
+      super(:mysql)
+    end
+  end
+
+  class SQLite3TestAdapter 
+    include Foreigner::ConnectionAdapters::SQLite3Adapter
+    include AdapterTestHarness
+
+    def schema(table_name) ActiveRecord::Base.connection.select_value %{
+        SELECT sql
+        FROM sqlite_master
+        WHERE name = '#{table_name}'
+      }
+    end
+
+    def foreign_keys(table)
+      raise "Unimplemented"
+    end
+
+    def recreate_test_environment
+      ActiveRecord::Base.establish_connection(CONFIGURATIONS[:sqlite3])
+
+      @database = CONFIGURATIONS[:sqlite3][:database]
+      #ActiveRecord::Base.connection.drop_database(@database)
+      #ActiveRecord::Base.connection.create_database(@database)
+      ActiveRecord::Base.connection.reset!
+
+      FactoryHelpers::CreateCollection.up
+    end
+  end
+
+
+end

data/spec/factory_helper.rb

@@ -0,0 +1,70 @@
+module FactoryHelpers
+  class CreateCollection < ActiveRecord::Migration
+    def self.up
+      create_table :collections do |t|
+        t.string :name
+      end
+    end
+
+    def self.down
+      drop_table :collections
+    end
+  end
+end
+
+module MigrationFactory
+
+  # Creates a new anonymous migration and puts something into self.up
+  # Example:
+  #   migration = create_migration do
+  #     create_table :items do |t|
+  #       t.string :name
+  #     end
+  #   end
+  def create_migration(&blk)
+    migration = Class.new(ActiveRecord::Migration)
+
+    # This is the equivalent of 
+    # class Foo
+    #   def self.up 
+    #   end
+    # end
+    migration.metaclass.class_eval do
+      define_method(:up, &blk)
+    end
+    migration
+  end
+
+  # Creates a new, anonymous table migration and activates it
+  # Example:
+  #   migration = create_table do |t|
+  #     t.string :name
+  #   end
+  def create_table(table = :items, opts = {}, &blk)
+    migration = create_migration do
+      create_table(table, opts, &blk)
+    end
+    migration.up 
+  end
+
+end
+
+module ForeignKeyDefinitionFactory
+  def valid_foreign_key_definition(opt = {})
+    options = {
+      :from_table => 'items',
+      :to_table => 'collections'
+    }.merge(opt)
+  end
+
+  def valid_foreign_key_args(definition)
+    from_table = definition.delete(:from_table)
+    to_table = definition.delete(:to_table)
+    [from_table, to_table, definition]
+  end
+
+  def new_foreign_key(opt = {})
+    args = valid_foreign_key_args(valid_foreign_key_definition(opt))
+    Foreigner::ConnectionAdapters::ForeignKeyDefinition.new(*args)
+  end
+end

data/spec/mysql/schema_extractor_spec.rb

@@ -0,0 +1,143 @@
+require File.expand_path('../spec_helper.rb', File.dirname(__FILE__))
+
+describe Foreigner::ConnectionAdapters::MysqlAdapter do
+  include MigrationFactory
+
+  before(:each) do 
+    @adapter = AdapterHelper::MySQLTestAdapter.new
+    @adapter.recreate_test_environment
+  end
+
+  describe 'when extracting foreign keys from a table' do 
+    it 'should extract single foreign key'  do
+      create_table :items do |t|
+        t.string :name
+        t.references :collection, :null => false
+        t.foreign_key :collection
+      end
+
+      @adapter.foreign_keys(:items).length.should eql(1)
+      foreign_key = @adapter.foreign_keys(:items)[0]
+
+      # Duck Typing
+      foreign_key.should be_respond_to(:from_table)
+      foreign_key.should be_respond_to(:to_table)
+      foreign_key.should be_respond_to(:options)
+    end
+
+    it 'should extract multiple foreign keys' do
+      create_table :owners do |t|
+        t.string :name
+      end
+
+      create_table :items do |t|
+        t.string :name
+        t.references :collection, :null => false
+        t.foreign_key :collection
+        t.references :owner, :null => false
+        t.foreign_key :owner
+      end
+
+      @adapter.foreign_keys(:items).length.should eql(2)
+      foreign_key_names = @adapter.foreign_keys(:items).map(&:to_table)
+      foreign_key_names.should be_include('collections')
+      foreign_key_names.should be_include('owners')
+    end
+
+    it 'should extract referencing table' do
+      create_table :items do |t|
+        t.string :name
+        t.references :collection, :null => false
+        t.foreign_key :collection
+      end
+
+      @adapter.foreign_keys(:items).length.should eql(1)
+      foreign_key = @adapter.foreign_keys(:items)[0]
+      foreign_key.from_table.should eql('items')
+    end
+
+    it 'should extract foreign table' do
+      create_table :items do |t|
+        t.string :name
+        t.references :collection, :null => false
+        t.foreign_key :collection
+      end
+
+      @adapter.foreign_keys(:items).length.should eql(1)
+      foreign_key = @adapter.foreign_keys(:items)[0]
+      foreign_key.to_table.should eql('collections')
+    end
+
+    it 'should extract foreign key name' do
+      fk_name = 'custom_foreign_key'
+
+      create_migration do 
+        create_table :items do |t|
+          t.string :name
+          t.references :collection, :null => false
+        end
+        add_foreign_key :items, :collections, :name => fk_name
+      end.up
+
+      @adapter.foreign_keys(:items).length.should eql(1)
+      foreign_key = @adapter.foreign_keys(:items)[0]
+      foreign_key.options[:name].should eql(fk_name)
+    end
+
+    it 'should extract foreign column' do
+      create_table :items do |t|
+        t.string :name
+        t.references :collection, :null => false
+        t.foreign_key :collection
+      end
+
+      @adapter.foreign_keys(:items).length.should eql(1)
+      foreign_key = @adapter.foreign_keys(:items)[0]
+      foreign_key.options[:column].should eql('collection_id')
+    end
+
+    it 'should extract primary key' do
+      primary_key = 'acctno'
+      create_table :accounts, :primary_key => primary_key do |t|
+        t.integer primary_key, :null => false
+        t.string :name
+      end
+
+      create_migration do 
+        create_table :items do |t|
+          t.string :name
+          t.integer primary_key, :null => false
+        end
+        add_foreign_key :items, :accounts, :column => primary_key, :primary_key => primary_key
+      end.up
+
+      @adapter.foreign_keys(:items).length.should eql(1)
+      foreign_key = @adapter.foreign_keys(:items)[0]
+      foreign_key.options[:primary_key].should eql(primary_key)
+    end
+
+    it 'should extract :dependent => :nullify' do
+      @dependent = :nullify
+      create_table :items do |t|
+        t.string :name
+        t.references :collection, :foreign_key => {:dependent => @dependent}
+      end
+
+      foreign_key = @adapter.foreign_keys(:items)[0]
+      foreign_key.options[:dependent].should eql(@dependent)
+    end
+
+    it 'should extract :dependent => :delete' do
+      @dependent = :delete
+      create_table :items do |t|
+        t.string :name
+        t.references :collection, :foreign_key => {:dependent => @dependent}
+      end
+
+      foreign_key = @adapter.foreign_keys(:items)[0]
+      foreign_key.options[:dependent].should eql(@dependent)
+    end
+  end
+
+end
+