schema_plus_foreign_keys 0.1.0

data/lib/schema_plus/foreign_keys/active_record/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,89 @@
+module SchemaPlus::ForeignKeys
+  module ActiveRecord
+    module ConnectionAdapters
+
+      # The Postgresql adapter implements the SchemaPlus::ForeignKeys extensions and
+      # enhancements
+      module PostgresqlAdapter
+
+        def rename_table(oldname, newname) #:nodoc:
+          super
+          rename_foreign_keys(oldname, newname)
+        end
+
+        def foreign_keys(table_name, name = nil) #:nodoc:
+          load_foreign_keys(<<-SQL, name)
+        SELECT f.conname, pg_get_constraintdef(f.oid), t.relname
+          FROM pg_class t, pg_constraint f
+         WHERE f.conrelid = t.oid
+           AND f.contype = 'f'
+           AND t.relname = '#{table_name_without_namespace(table_name)}'
+           AND t.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = #{namespace_sql(table_name)} )
+          SQL
+        end
+
+        def reverse_foreign_keys(table_name, name = nil) #:nodoc:
+          load_foreign_keys(<<-SQL, name)
+        SELECT f.conname, pg_get_constraintdef(f.oid), t2.relname
+          FROM pg_class t, pg_class t2, pg_constraint f
+         WHERE f.confrelid = t.oid
+           AND f.conrelid = t2.oid
+           AND f.contype = 'f'
+           AND t.relname = '#{table_name_without_namespace(table_name)}'
+           AND t.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = #{namespace_sql(table_name)} )
+          SQL
+        end
+
+        private
+
+        def unquote(name)
+          return name.map { |name| unquote(name) } if name.is_a?(Array)
+          name.sub(/^["`](.*)["`]$/, '\1')
+        end
+
+        def namespace_sql(table_name)
+          (table_name.to_s =~ /(.*)[.]/) ?  "'#{$1}'" : "ANY (current_schemas(false))"
+        end
+
+        def table_name_without_namespace(table_name)
+          table_name.to_s.sub /.*[.]/, ''
+        end
+
+        def load_foreign_keys(sql, name = nil) #:nodoc:
+          foreign_keys = []
+
+          query(sql, name).each do |row|
+            if row[1] =~ /^FOREIGN KEY \((.+?)\) REFERENCES (.+?)\((.+?)\)( ON UPDATE (.+?))?( ON DELETE (.+?))?( (DEFERRABLE|NOT DEFERRABLE)( (INITIALLY DEFERRED|INITIALLY IMMEDIATE))?)?$/
+              name = row[0]
+              from_table = unquote(row[2])
+              columns = unquote($1.split(', '))
+              to_table = unquote($2)
+              primary_keys = unquote($3.split(', '))
+              on_update = $5
+              on_delete = $7
+              deferrable = $9 == "DEFERRABLE"
+              deferrable = :initially_deferred if ($11 == "INITIALLY DEFERRED" )
+              on_update = ForeignKeyDefinition::ACTION_LOOKUP[on_update] || :no_action
+              on_delete = ForeignKeyDefinition::ACTION_LOOKUP[on_delete] || :no_action
+
+              options = { :name => name,
+                          :on_delete => on_delete,
+                          :on_update => on_update,
+                          :column => columns,
+                          :primary_key => primary_keys,
+                          :deferrable => deferrable }
+
+              foreign_keys << ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
+                from_table,
+                to_table.sub(/^"(.*)"$/, '\1'),
+                options)
+            end
+          end
+
+          foreign_keys
+        end
+
+      end
+    end
+  end
+end

data/lib/schema_plus/foreign_keys/active_record/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,77 @@
+module SchemaPlus::ForeignKeys
+  module ActiveRecord
+    module ConnectionAdapters
+
+      # SchemaPlus::ForeignKeys includes an Sqlite3 implementation of the AbstractAdapter
+      # extensions.
+      module Sqlite3Adapter
+
+        # :enddoc:
+
+        def add_foreign_key(table_name, to_table, options = {})
+          raise NotImplementedError, "Sqlite3 does not support altering a table to add foreign key constraints (table #{table_name.inspect} to #{to_table.inspect})"
+        end
+
+        def remove_foreign_key(table_name, *args)
+          raise NotImplementedError, "Sqlite3 does not support altering a table to remove foreign key constraints (table #{table_name.inspect} constraint #{args.inspect})"
+        end
+
+        def foreign_keys(table_name, name = nil)
+          get_foreign_keys(table_name, name)
+        end
+
+        def reverse_foreign_keys(table_name, name = nil)
+          get_foreign_keys(nil, name).select{|definition| definition.to_table == table_name}
+        end
+
+        protected
+
+        def get_foreign_keys(table_name = nil, name = nil)
+          results = execute(<<-SQL, name)
+            SELECT name, sql FROM sqlite_master
+            WHERE type='table' #{table_name && %" AND name='#{table_name}' "}
+          SQL
+
+          re = %r[
+            \b(CONSTRAINT\s+(\S+)\s+)?
+            FOREIGN\s+KEY\s* \(\s*[`"](.+?)[`"]\s*\)
+            \s*REFERENCES\s*[`"](.+?)[`"]\s*\((.+?)\)
+            (\s+ON\s+UPDATE\s+(.+?))?
+            (\s*ON\s+DELETE\s+(.+?))?
+            (\s*DEFERRABLE(\s+INITIALLY\s+DEFERRED)?)?
+            \s*[,)]
+          ]x
+
+          foreign_keys = []
+          results.each do |row|
+            from_table = row["name"]
+            row["sql"].scan(re).each do |d0, name, columns, to_table, primary_keys, d1, on_update, d2, on_delete, deferrable, initially_deferred|
+              columns = columns.gsub(/`/, '').split(', ')
+
+              primary_keys = primary_keys.gsub(/[`"]/, '').split(', ')
+              on_update = ForeignKeyDefinition::ACTION_LOOKUP[on_update] || :no_action
+              on_delete = ForeignKeyDefinition::ACTION_LOOKUP[on_delete] || :no_action
+              deferrable = deferrable ? (initially_deferred ? :initially_deferred : true) : false
+
+              options = { :name => name,
+                          :on_update => on_update,
+                          :on_delete => on_delete,
+                          :column => columns,
+                          :primary_key => primary_keys,
+                          :deferrable => deferrable }
+
+              foreign_keys << ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
+                from_table,
+                to_table,
+                options)
+            end
+          end
+
+          foreign_keys
+        end
+
+      end
+
+    end
+  end
+end

data/lib/schema_plus/foreign_keys/active_record/connection_adapters/table_definition.rb

@@ -0,0 +1,108 @@
+module SchemaPlus::ForeignKeys::ActiveRecord::ConnectionAdapters
+
+  #
+  # SchemaPlus::ForeignKeys adds several methods to TableDefinition, allowing indexes
+  # and foreign key constraints to be defined within a
+  # <tt>create_table</tt> block of a migration, allowing for better
+  # encapsulation and more DRY definitions.
+  #
+  # For example, without SchemaPlus::ForeignKeys you might define a table like this:
+  #
+  #    create_table :widgets do |t|
+  #       t.string :name
+  #    end
+  #    add_index :widgets, :name
+  #
+  # But with SchemaPlus::ForeignKeys, the index can be defined within the create_table
+  # block, so you don't need to repeat the table name:
+  #
+  #    create_table :widgets do |t|
+  #       t.string :name
+  #       t.index :name
+  #    end
+  #
+  # Even more DRY, you can define the index as part of the column
+  # definition, via:
+  #
+  #   create_table :widgets do |t|
+  #      t.string :name, :index => true
+  #   end
+  #
+  # For details about the :index option (including unique and multi-column indexes), see the
+  # documentation for Migration::ClassMethods#add_column
+  #
+  # SchemaPlus::ForeignKeys also supports creation of foreign key constraints analogously, using Migration::ClassMethods#add_foreign_key or TableDefinition#foreign_key or as part of the column definition, for example:
+  #
+  #    create_table :posts do |t|  # not DRY
+  #       t.integer :author_id
+  #    end
+  #    add_foreign_key :posts, :author_id, :references => :authors
+  #
+  #    create_table :posts do |t|  # DRYer
+  #       t.integer :author_id
+  #       t.foreign_key :author_id, :references => :authors
+  #    end
+  #
+  #    create_table :posts do |t|  # Dryest
+  #       t.integer :author_id, :foreign_key => true
+  #    end
+  #
+  # <b>NOTE:</b> In the standard configuration, SchemaPlus::ForeignKeys automatically
+  # creates foreign key constraints for columns whose names end in
+  # <tt>_id</tt>.  So the above examples are redundant, unless automatic
+  # creation was disabled at initialization in the global Config.
+  #
+  # SchemaPlus::ForeignKeys likewise by default automatically creates foreign key constraints for
+  # columns defined via <tt>t.references</tt>.   However, SchemaPlus::ForeignKeys does not create
+  # foreign key constraints if the <tt>:polymorphic</tt> option is true
+  #
+  # Finally, the configuration for foreign keys can be overriden on a per-table
+  # basis by passing Config options to Migration::ClassMethods#create_table, such as
+  #
+  #      create_table :students, :foreign_keys => {:auto_create => false} do
+  #         t.integer :student_id
+  #      end
+  #
+  module TableDefinition
+
+    attr_accessor :schema_plus_foreign_keys_config #:nodoc:
+
+    if ActiveRecord.version == Gem::Version.new("4.2.0")
+      def foreign_keys
+        @foreign_keys ||= []
+      end
+
+      def foreign_keys_for_table(*)
+        foreign_keys
+      end
+    else
+      def foreign_keys_for_table(table)
+        foreign_keys[table] ||= []
+      end
+    end
+
+    def foreign_key(*args) # (column_names, to_table, primary_key=nil, options=nil)
+      options = args.extract_options!
+      case args.length
+      when 1
+        to_table = args[0]
+        column_names = "#{to_table.to_s.singularize}_id"
+      when 2
+        column_names, to_table = args
+      when 3
+        ActiveSupport::Deprecation.warn "positional arg for foreign primary key is deprecated, use :primary_key option instead"
+        column_names, to_table, primary_key = args
+        options.merge!(:primary_key => primary_key)
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.length}) for foreign_key(column_names, table_name, options)"
+      end
+
+      options.merge!(:column => column_names)
+      options.reverse_merge!(:name => ForeignKeyDefinition.default_name(self.name, column_names))
+      fk = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(self.name, AbstractAdapter.proper_table_name(to_table), options)
+      foreign_keys_for_table(fk.to_table) << fk
+      self
+    end
+
+  end
+end

data/lib/schema_plus/foreign_keys/active_record/migration/command_recorder.rb

@@ -0,0 +1,29 @@
+module SchemaPlus::ForeignKeys
+  module ActiveRecord
+    module Migration
+      module CommandRecorder
+
+        attr_accessor :schema_plus_foreign_keys_config #:nodoc:
+
+        # seems like this is fixing a rails bug:
+        #   change_table foo, :bulk => true { |t| t.references :bar }
+        # results in an 'unknown method :add_reference_sql' (with mysql2)
+        #
+        # should track it down separately and submit a patch/fix to rails
+        #
+        def add_reference(table_name, ref_name, options = {}) #:nodoc:
+          polymorphic = options.delete(:polymorphic)
+          options[:references] = nil if polymorphic
+          # ugh.  copying and pasting code from ::ActiveRecord::ConnectionAdapters::SchemaStatements#add_reference
+          index_options = options.delete(:index)
+          add_column(table_name, "#{ref_name}_id", :integer, options)
+          add_column(table_name, "#{ref_name}_type", :string, polymorphic.is_a?(Hash) ? polymorphic : options) if polymorphic
+          add_index(table_name, polymorphic ? %w[id type].map{ |t| "#{ref_name}_#{t}" } : "#{ref_name}_id", index_options.is_a?(Hash) ? index_options : {}) if index_options
+
+          self
+        end
+
+      end
+    end
+  end
+end

data/lib/schema_plus/foreign_keys/middleware/dumper.rb

@@ -0,0 +1,88 @@
+module SchemaPlus::ForeignKeys
+  module Middleware
+    module Dumper
+
+      # index and foreign key constraint definitions are dumped
+      # inline in the create_table block.  (This is done for elegance, but
+      # also because Sqlite3 does not allow foreign key constraints to be
+      # added to a table after it has been defined.)
+
+      module Tables
+
+        def before(env)
+
+          @inline_fks = Hash.new{ |h, k| h[k] = [] }
+          @backref_fks = Hash.new{ |h, k| h[k] = [] }
+
+          env.connection.tables.each do |table|
+            if (fks = env.connection.foreign_keys(table)).any?
+              env.dump.data.has_fks = true
+              @inline_fks[table] = fks
+              env.dump.depends(table, fks.collect(&:to_table))
+            end
+          end
+
+          # Normally we dump foreign key constraints inline in the table
+          # definitions, both for visual cleanliness and because sqlite3
+          # doesn't allow foreign key constraints to be added afterwards.
+          # But in case there's a cycle in the constraint references, some
+          # constraints will need to be broken out then added later.  (Adding
+          # constraints later won't work with sqlite3, but that means sqlite3
+          # won't let you create cycles in the first place.)
+          break_fk_cycles(env) while env.dump.strongly_connected_components.any?{|component| component.size > 1}
+
+          env.dump.data.inline_fks = @inline_fks
+          env.dump.data.backref_fks = @backref_fks
+        end
+
+        # Ignore the foreign key dumps at the end of the schema; we'll put them in/near their tables
+        def after(env)
+          env.dump.final.reject!(&it =~/foreign_key/)
+        end
+
+        private
+
+        def break_fk_cycles(env) #:nodoc:
+          env.dump.strongly_connected_components.select{|component| component.size > 1}.each do |tables|
+            table = tables.sort.last
+            backref_fks = @inline_fks[table].select{|fk| tables.include?(fk.to_table)}
+            @inline_fks[table] -= backref_fks
+            env.dump.dependencies[table] -= backref_fks.collect(&:to_table)
+            backref_fks.each do |fk|
+              @backref_fks[fk.to_table] << fk
+            end
+          end
+        end
+
+        module SQLite3
+          def after(env)
+            env.dump.initial << "  PRAGMA FOREIGN_KEYS = ON;\n" if env.dump.data.has_fks
+          end
+        end
+
+      end
+
+      module Table
+        def after(env)
+          dumped = {}
+          env.table.columns.each do |column|
+            if (foreign_key = env.dump.data.inline_fks[env.table.name].find(&its.column.to_s == column.name))
+              column.add_option foreign_key.to_dump(column: true)
+              dumped[foreign_key] = true
+            end
+            if (foreign_key = env.dump.data.backref_fks.values.flatten.find{|fk| fk.from_table.to_s == env.table.name && fk.column.to_s == column.name})
+              column.add_comment "foreign key references #{foreign_key.to_table.inspect} (below)"
+            end
+          end
+          env.table.trailer += env.dump.data.inline_fks[env.table.name].map { |foreign_key|
+            foreign_key.to_dump unless dumped[foreign_key] # just in case we missed any.  don't think it can happen
+          }.compact.sort
+          env.table.trailer += env.dump.data.backref_fks[env.table.name].map { |foreign_key|
+            foreign_key.to_dump
+          }.sort
+        end
+      end
+    end
+
+  end
+end

data/lib/schema_plus/foreign_keys/middleware/migration.rb

@@ -0,0 +1,147 @@
+module SchemaPlus::ForeignKeys
+  module Middleware
+    module Migration
+
+      module CreateTable
+        def around(env)
+          if (original_block = env.block)
+            config_options = env.options.delete(:foreign_keys) || {}
+            env.block = -> (table_definition) {
+              table_definition.schema_plus_foreign_keys_config = SchemaPlus::ForeignKeys.config.merge(config_options)
+              original_block.call table_definition
+            }
+          end
+          yield env
+        end
+      end
+
+      module Column
+
+        #
+        # Column option shortcuts
+        #
+        def before(env)
+          opts = env.options[:foreign_key]
+
+          return if opts == false
+
+          opts = {} if opts == true
+
+          [:references, :on_update, :on_delete, :deferrable].each do |key|
+            (opts||={}).reverse_merge!(key => env.options[key]) if env.options.has_key? key
+          end
+
+          return if opts.nil?
+
+          if opts.has_key?(:references) && !opts[:references]
+            env.options[:foreign_key] = false
+            return
+          end
+
+          case opts[:references]
+          when nil
+          when Array
+            table, primary_key = opts[:references]
+            opts[:references] = table
+            opts[:primary_key] ||= primary_key
+          end
+
+          env.options[:foreign_key] = opts
+        end
+
+        #
+        # Add the foreign keys
+        #
+        def around(env)
+          original_options = env.options
+          env.options = original_options.dup
+
+          is_reference = (env.type == :reference)
+          is_polymorphic = is_reference && env.options[:polymorphic]
+
+          # usurp foreign key creation from AR, since it doesn't support
+          # all our features
+          env.options[:foreign_key] = false 
+
+          yield env
+
+          return if is_polymorphic or env.implements_reference
+
+          env.options = original_options
+
+          add_foreign_keys(env)
+
+        end
+
+        private
+
+        def add_foreign_keys(env)
+
+          if (reverting = env.caller.is_a?(::ActiveRecord::Migration::CommandRecorder) && env.caller.reverting)
+            commands_length = env.caller.commands.length
+          end
+
+          config = (env.caller.try(:schema_plus_foreign_keys_config) || SchemaPlus::ForeignKeys.config)
+          fk_opts = get_fk_opts(env, config)
+
+          # remove existing fk in case of change of fk on existing column
+          if env.operation == :change and fk_opts # includes :none for explicitly off
+            remove_foreign_key_if_exists(env)
+          end
+
+          fk_opts = nil if fk_opts == :none
+
+          create_fk(env, fk_opts) if fk_opts
+
+          if reverting
+            rev = []
+            while env.caller.commands.length > commands_length
+              cmd = env.caller.commands.pop
+              rev.unshift cmd unless cmd[0].to_s =~ /^add_/
+            end
+            env.caller.commands.concat rev
+          end
+
+        end
+
+        def create_fk(env, fk_opts)
+          references = fk_opts.delete(:references)
+          case env.caller
+          when ::ActiveRecord::ConnectionAdapters::TableDefinition
+            env.caller.foreign_key(env.column_name, references, fk_opts)
+          else
+            env.caller.add_foreign_key(env.table_name, references, fk_opts.merge(:column => env.column_name))
+          end
+        end
+
+        def get_fk_opts(env, config)
+          opts = env.options[:foreign_key]
+          return nil if opts.nil?
+          return :none if opts == false
+          opts = {} if opts == true
+          opts[:references] ||= default_table_name(env)
+          opts[:on_update] ||= config.on_update
+          opts[:on_delete] ||= config.on_delete
+          opts
+        end
+
+        def remove_foreign_key_if_exists(env)
+          env.caller.remove_foreign_key(env.table_name.to_s, column: env.column_name.to_s, :if_exists => true)
+        end
+
+        def default_table_name(env)
+          if env.column_name.to_s == 'parent_id'
+            env.table_name
+          else
+            name = env.column_name.to_s.sub(/_id$/, '')
+            name = name.pluralize if ::ActiveRecord::Base.pluralize_table_names
+            name
+          end
+        end
+
+      end
+
+    end
+  end
+end
+