schema_plus 2.0.0.pre15 → 2.0.0.pre16

data/lib/schema_plus/foreign_keys.rb

@@ -1,93 +0,0 @@
-require 'schema_plus/core'
-require 'valuable'
-
-require_relative 'foreign_keys/version'
-require_relative 'foreign_keys/active_record/base'
-require_relative 'foreign_keys/active_record/connection_adapters/abstract_adapter'
-require_relative 'foreign_keys/active_record/connection_adapters/table_definition'
-require_relative 'foreign_keys/active_record/connection_adapters/foreign_key_definition'
-require_relative 'foreign_keys/active_record/migration/command_recorder'
-require_relative 'foreign_keys/middleware/dumper'
-require_relative 'foreign_keys/middleware/migration'
-require_relative 'foreign_keys/middleware/model'
-require_relative 'foreign_keys/middleware/mysql'
-require_relative 'foreign_keys/middleware/schema'
-require_relative 'foreign_keys/middleware/sql'
-
-module SchemaPlus::ForeignKeys
-  module ActiveRecord
-    module ConnectionAdapters
-      autoload :Mysql2Adapter, 'schema_plus/foreign_keys/active_record/connection_adapters/mysql2_adapter'
-      autoload :PostgresqlAdapter, 'schema_plus/foreign_keys/active_record/connection_adapters/postgresql_adapter'
-      autoload :Sqlite3Adapter, 'schema_plus/foreign_keys/active_record/connection_adapters/sqlite3_adapter'
-    end
-  end
-
-  # This global configuation options for SchemaPlus::ForeignKeys.
-  # Set them in +config/initializers/schema_plus_foreign_keys.rb+ using:
-  #
-  #    SchemaPlus::ForeignKeys.setup do |config|
-  #       ...
-  #    end
-  #
-  class Config < Valuable
-
-    ##
-    # :attr_accessor: auto_create
-    #
-    # Whether to automatically create foreign key constraints for columns
-    # suffixed with +_id+.  Boolean, default is +true+.
-    has_value :auto_create, :klass => :boolean, :default => true
-
-    ##
-    # :attr_accessor: auto_index
-    #
-    # Whether to automatically create indexes when creating foreign key constraints for columns.
-    # Boolean, default is +true+.
-    has_value :auto_index, :klass => :boolean, :default => true
-
-    ##
-    # :attr_accessor: on_update
-    #
-    # The default value for +:on_update+ when creating foreign key
-    # constraints for columns.  Valid values are as described in
-    # ForeignKeyDefinition, or +nil+ to let the database connection use
-    # its own default.  Default is +nil+.
-    has_value :on_update
-
-    ##
-    # :attr_accessor: on_delete
-    #
-    # The default value for +:on_delete+ when creating foreign key
-    # constraints for columns.  Valid values are as described in
-    # ForeignKeyDefinition, or +nil+ to let the database connection use
-    # its own default.  Default is +nil+.
-    has_value :on_delete
-
-    def merge(opts)
-      dup.update_attributes(opts)
-    end
-  end
-
-
-  # Returns the global configuration, i.e., the singleton instance of Config
-  def self.config
-    @config ||= Config.new
-  end
-
-  # Initialization block is passed a global Config instance that can be
-  # used to configure SchemaPlus::ForeignKeys behavior.  E.g., if you want to disable
-  # automation creation of foreign key constraints for columns name *_id,
-  # put the following in config/initializers/schema_plus_foreign_keys.rb :
-  #
-  #    SchemaPlus::ForeignKeys.setup do |config|
-  #       config.auto_create = false
-  #    end
-  #
-  def self.setup # :yields: config
-    yield config
-  end
-
-end
-
-SchemaMonkey.register SchemaPlus::ForeignKeys

data/lib/schema_plus/foreign_keys/active_record/base.rb

@@ -1,33 +0,0 @@
-module SchemaPlus::ForeignKeys
-  module ActiveRecord
-
-    #
-    # SchemaPlus::ForeignKeys adds several methods to ActiveRecord::Base
-    #
-    module Base
-      module ClassMethods #:nodoc:
-
-        public
-
-        # Returns a list of ForeignKeyDefinition objects, for each foreign
-        # key constraint defined in this model's table
-        #
-        # (memoized result gets reset in Middleware::Model::ResetColumnInformation)
-        def foreign_keys
-          @foreign_keys ||= connection.foreign_keys(table_name, "#{name} Foreign Keys")
-        end
-
-        def reset_foreign_key_information
-          @foreign_keys = @reverse_foreign_keys = nil
-        end
-
-        # Returns a list of ForeignKeyDefinition objects, for each foreign
-        # key constraint of other tables that refer to this model's table
-        def reverse_foreign_keys
-          @reverse_foreign_keys ||= connection.reverse_foreign_keys(table_name, "#{name} Reverse Foreign Keys")
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,168 +0,0 @@
-module SchemaPlus::ForeignKeys
-  module ActiveRecord
-    # SchemaPlus::ForeignKeys adds several methods to the connection adapter (as returned by ActiveRecordBase#connection).  See AbstractAdapter for details.
-    module ConnectionAdapters
-
-      #
-      # SchemaPlus::ForeignKeys adds several methods to
-      # ActiveRecord::ConnectionAdapters::AbstractAdapter.  In most cases
-      # you don't call these directly, but rather the methods that define
-      # things are called by schema statements, and methods that query
-      # things are called by ActiveRecord::Base.
-      #
-      module AbstractAdapter
-
-        # Define a foreign key constraint.  Valid options are :on_update,
-        # :on_delete, and :deferrable, with values as described at
-        # ConnectionAdapters::ForeignKeyDefinition
-        #
-        # (NOTE: Sqlite3 does not support altering a table to add foreign-key
-        # constraints; they must be included in the table specification when
-        # it's created.  If you're using Sqlite3, this method will raise an
-        # error.)
-        def add_foreign_key(*args) # (table_name, column, to_table, primary_key, options = {})
-          options = args.extract_options!
-          case args.length
-          when 2
-            from_table, to_table = args
-          when 4
-            ActiveSupport::Deprecation.warn "4-argument form of add_foreign_key is deprecated.  use add_foreign_key(from_table, to_table, options)"
-            (from_table, column, to_table, primary_key) = args
-            options.merge!(column: column, primary_key: primary_key)
-          end
-
-          options = options.dup
-          options[:column] ||= foreign_key_column_for(to_table)
-          options[:name]   ||= ForeignKeyDefinition.default_name(from_table, options[:column])
-
-          foreign_key_sql = add_foreign_key_sql(from_table, to_table, options)
-          execute "ALTER TABLE #{quote_table_name(from_table)} #{foreign_key_sql}"
-        end
-
-        # called directly by AT's bulk_change_table, for migration
-        # change_table :name, :bulk => true { ... }
-        def add_foreign_key_sql(from_table, to_table, options = {}) #:nodoc:
-          foreign_key = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(from_table, AbstractAdapter.proper_table_name(to_table), options)
-          "ADD #{foreign_key.to_sql}"
-        end
-
-        def _build_foreign_key(from_table, to_table, options = {}) #:nodoc:
-          ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(from_table, AbstractAdapter.proper_table_name(to_table), options)
-        end
-
-        def self.proper_table_name(name)
-          proper_name = ::ActiveRecord::Migration.new.proper_table_name(name)
-        end
-
-        # Remove a foreign key constraint
-        #
-        # Arguments are the same as for add_foreign_key, or by name:
-        #
-        #    remove_foreign_key table_name, to_table, options
-        #    remove_foreign_key table_name, name: constraint_name
-        #
-        # (NOTE: Sqlite3 does not support altering a table to remove
-        # foreign-key constraints.  If you're using Sqlite3, this method will
-        # raise an error.)
-        def remove_foreign_key(*args)
-          from_table, to_table, options = normalize_remove_foreign_key_args(*args)
-          options[:column] ||= foreign_key_column_for(to_table)
-          if sql = remove_foreign_key_sql(from_table, to_table, options)
-            execute "ALTER TABLE #{quote_table_name(from_table)} #{sql}"
-          end
-        end
-
-        def normalize_remove_foreign_key_args(*args)
-          options = args.extract_options!
-          if options.has_key? :column_names
-            ActiveSupport::Deprecation.warn ":column_names option is deprecated, use :column"
-            options[:column] = options.delete(:column_names)
-          end
-          if options.has_key? :references_column_names
-            ActiveSupport::Deprecation.warn ":references_column_names option is deprecated, use :primary_key"
-            options[:primary_key] = options.delete(:references_column_names)
-          end
-          if options.has_key? :references_table_name
-            ActiveSupport::Deprecation.warn ":references_table_name option is deprecated, use :to_table"
-            options[:to_table] = options.delete(:references_table_name)
-          end
-          case args.length
-          when 1
-            from_table = args[0]
-          when 2
-            from_table, to_table = args
-          when 3, 4
-            ActiveSupport::Deprecation.warn "3- and 4-argument forms of remove_foreign_key are deprecated.  use add_foreign_key(from_table, to_table, options)"
-            (from_table, column, to_table, primary_key) = args
-            options.merge!(column: column, primary_key: primary_key)
-          else
-            raise ArgumentError, "Wrong number of arguments(args.length) to remove_foreign_key"
-          end
-          to_table ||= options.delete(:to_table)
-          [from_table, to_table, options]
-        end
-
-        def get_foreign_key_name(from_table, to_table, options)
-          return options[:name] if options[:name]
-
-          fks = foreign_keys(from_table)
-          if fks.detect(&its.name == to_table)
-            ActiveSupport::Deprecation.warn "remove_foreign_key(table, name) is deprecated.  use remove_foreign_key(table, name: name)"
-            return to_table
-          end
-          test_fk = _build_foreign_key(from_table, to_table, options)
-          if fk = fks.detect { |fk| fk.match(test_fk) }
-            fk.name
-          else
-            raise "SchemaPlus::ForeignKeys: no foreign key constraint found on #{from_table.inspect} matching #{[to_table, options].inspect}" unless options[:if_exists]
-            nil
-          end
-        end
-
-        def remove_foreign_key_sql(from_table, to_table, options)
-          if foreign_key_name = get_foreign_key_name(from_table, to_table, options)
-            "DROP CONSTRAINT #{options[:if_exists] ? "IF EXISTS" : ""} #{foreign_key_name}"
-          end
-        end
-
-
-        # called from individual adpaters, after renaming table from old
-        # name to
-        def rename_foreign_keys(oldname, newname) #:nodoc:
-          foreign_keys(newname).each do |fk|
-            index = indexes(newname).find{|index| index.name == ForeignKeyDefinition.auto_index_name(oldname, fk.column)}
-            begin
-              remove_foreign_key(newname, name: fk.name)
-            rescue NotImplementedError
-              # sqlite3 can't remove foreign keys, so just skip it
-            end
-            # rename the index only when the fk constraint doesn't exist.
-            # mysql doesn't allow the rename (which is a delete & add)
-            # if the index is on a foreign key constraint
-            rename_index(newname, index.name, ForeignKeyDefinition.auto_index_name(newname, index.columns)) if index
-            begin
-              add_foreign_key(newname, fk.to_table, :column => fk.column, :primary_key => fk.primary_key, :name => fk.name.sub(/#{oldname}/, newname), :on_update => fk.on_update, :on_delete => fk.on_delete, :deferrable => fk.deferrable)
-            rescue NotImplementedError
-              # sqlite3 can't add foreign keys, so just skip it
-            end
-          end
-        end
-
-
-        #####################################################################
-        #
-        # The functions below here are abstract; each subclass should
-        # define them all. Defining them here only for reference.
-        #
-
-        # (abstract) Return the ForeignKeyDefinition objects for foreign key
-        # constraints defined on this table
-        def foreign_keys(table_name, name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; [] end
-
-        # (abstract) Return the ForeignKeyDefinition objects for foreign key
-        # constraints defined on other tables that reference this table
-        def reverse_foreign_keys(table_name, name = nil) raise "Internal Error: Connection adapter didn't override abstract function"; [] end
-      end
-    end
-  end
-end

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

@@ -1,138 +0,0 @@
-require 'active_record/connection_adapters/abstract/schema_definitions'
-
-module SchemaPlus::ForeignKeys
-  module ActiveRecord
-    module ConnectionAdapters
-      # Instances of this class are returned by the queries ActiveRecord::Base#foreign_keys and ActiveRecord::Base#reverse_foreign_keys (via AbstractAdapter#foreign_keys and AbstractAdapter#reverse_foreign_keys)
-      #
-      # The on_update and on_delete attributes can take on the following values:
-      #   :cascade
-      #   :restrict
-      #   :nullify
-      #   :set_default
-      #   :no_action
-      #
-      # The deferrable attribute can take on the following values:
-      #   true
-      #   :initially_deferred
-      module ForeignKeyDefinition
-
-        def column_names
-          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#column_names is deprecated, use Array.wrap(column)"
-          Array.wrap(column)
-        end
-
-        def references_column_names
-          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#references_column_names is deprecated, use Array.wrap(primary_key)"
-          Array.wrap(primary_key)
-        end
-
-        def references_table_name
-          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#references_table_name is deprecated, use #to_table"
-          to_table
-        end
-
-        def table_name
-          ActiveSupport::Deprecation.warn "ForeignKeyDefinition#table_name is deprecated, use #from_table"
-          from_table
-        end
-
-        ACTIONS = { :cascade => "CASCADE", :restrict => "RESTRICT", :nullify => "SET NULL", :set_default => "SET DEFAULT", :no_action => "NO ACTION" }.freeze
-        ACTION_LOOKUP = ACTIONS.invert.freeze
-
-        def initialize(from_table, to_table, options={})
-          [:on_update, :on_delete].each do |key|
-            if options[key] == :set_null
-              ActiveSupport::Deprecation.warn ":set_null value for #{key} is deprecated.  use :nullify instead"
-              options[key] = :nullify
-            end
-          end
-
-          super from_table, to_table, options
-
-          if column.is_a?(Array) and column.length == 1
-            options[:column] = column[0]
-          end
-          if primary_key.is_a?(Array) and primary_key.length == 1
-            options[:primary_key] = primary_key[0]
-          end
-
-          ACTIONS.has_key?(on_update) or raise(ArgumentError, "invalid :on_update action: #{on_update.inspect}") if on_update
-          ACTIONS.has_key?(on_delete) or raise(ArgumentError, "invalid :on_delete action: #{on_delete.inspect}") if on_delete
-          if ::ActiveRecord::Base.connection.adapter_name =~ /^mysql/i
-            raise(NotImplementedError, "MySQL does not support ON UPDATE SET DEFAULT") if on_update == :set_default
-            raise(NotImplementedError, "MySQL does not support ON DELETE SET DEFAULT") if on_delete == :set_default
-          end
-        end
-
-        # Truthy if the constraint is deferrable
-        def deferrable
-          options[:deferrable]
-        end
-
-        # Dumps a definition of foreign key.
-        def to_dump(column: nil, inline: nil)
-          dump = case
-                 when column then "foreign_key: {references:"
-                 when inline then "t.foreign_key"
-                 else "add_foreign_key #{from_table.inspect},"
-                 end
-          dump << " #{to_table.inspect}"
-
-          val_or_array = -> val { val.is_a?(Array) ? "[#{val.map(&:inspect).join(', ')}]" : val.inspect }
-
-          dump << ", column: #{val_or_array.call self.column}" unless column
-          dump << ", primary_key: #{val_or_array.call self.primary_key}" if custom_primary_key?
-          dump << ", name: #{name.inspect}" if name
-          dump << ", on_update: #{on_update.inspect}" if on_update
-          dump << ", on_delete: #{on_delete.inspect}" if on_delete
-          dump << ", deferrable: #{deferrable.inspect}" if deferrable
-          dump << "}" if column
-          dump
-        end
-
-        def to_sql
-          sql = name ? "CONSTRAINT #{name} " : ""
-          sql << "FOREIGN KEY (#{quoted_column_names.join(", ")}) REFERENCES #{quoted_to_table} (#{quoted_primary_keys.join(", ")})"
-          sql << " ON UPDATE #{ACTIONS[on_update]}" if on_update
-          sql << " ON DELETE #{ACTIONS[on_delete]}" if on_delete
-          sql << " DEFERRABLE" if deferrable
-          sql << " INITIALLY DEFERRED" if deferrable == :initially_deferred
-          sql
-        end
-
-        def quoted_column_names
-          Array(column).map { |name| ::ActiveRecord::Base.connection.quote_column_name(name) }
-        end
-
-        def quoted_primary_keys
-          Array(primary_key).map { |name| ::ActiveRecord::Base.connection.quote_column_name(name) }
-        end
-
-        def quoted_to_table
-          ::ActiveRecord::Base.connection.quote_table_name(to_table)
-        end
-
-        def self.default_name(from_table, column)
-          "fk_#{fixup_schema_name(from_table)}_#{Array.wrap(column).join('_and_')}"
-        end
-
-        def self.auto_index_name(from_table, column_name)
-          "fk__#{fixup_schema_name(from_table)}_#{Array.wrap(column_name).join('_and_')}"
-        end
-
-        def self.fixup_schema_name(table_name)
-          # replace . with _
-          table_name.to_s.gsub(/[.]/, '_')
-        end
-
-        def match(test)
-          return false unless from_table == test.from_table
-          [:to_table, :column].reject{ |attr| test.send(attr).blank? }.all? { |attr|
-            test.send(attr).to_s == self.send(attr).to_s
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,126 +0,0 @@
-module SchemaPlus::ForeignKeys
-  module ActiveRecord
-    module ConnectionAdapters
-      # SchemaPlus::ForeignKeys includes a MySQL implementation of the AbstractAdapter
-      # extensions.
-      module Mysql2Adapter
-
-        #:enddoc:
-
-        def remove_column(table_name, column_name, type=nil, options={})
-          foreign_keys(table_name).select { |foreign_key| Array.wrap(foreign_key.column).include?(column_name.to_s) }.each do |foreign_key|
-            remove_foreign_key(table_name, name: foreign_key.name)
-          end
-          super table_name, column_name, type, options
-        end
-
-        def rename_table(oldname, newname)
-          super
-          rename_foreign_keys(oldname, newname)
-        end
-
-        def remove_foreign_key(*args)
-          from_table, to_table, options = normalize_remove_foreign_key_args(*args)
-          if options[:if_exists]
-            foreign_key_name = get_foreign_key_name(from_table, to_table, options)
-            return if !foreign_key_name or not foreign_keys(from_table).detect{|fk| fk.name == foreign_key_name}
-          end
-          options.delete(:if_exists)
-          super from_table, to_table, options
-        end
-
-        def remove_foreign_key_sql(*args)
-          super.tap { |ret|
-            ret.sub!(/DROP CONSTRAINT/, 'DROP FOREIGN KEY') if ret
-          }
-        end
-
-        def foreign_keys(table_name, name = nil)
-          results = select_all("SHOW CREATE TABLE #{quote_table_name(table_name)}", name)
-
-          table_name = table_name.to_s
-          namespace_prefix = table_namespace_prefix(table_name)
-
-          foreign_keys = []
-
-          results.each do |result|
-            create_table_sql = result["Create Table"]
-            create_table_sql.lines.each do |line|
-              if line =~ /^  CONSTRAINT [`"](.+?)[`"] FOREIGN KEY \([`"](.+?)[`"]\) REFERENCES [`"](.+?)[`"] \((.+?)\)( ON DELETE (.+?))?( ON UPDATE (.+?))?,?$/
-                name = $1
-                columns = $2
-                to_table = $3
-                to_table = namespace_prefix + to_table if table_namespace_prefix(to_table).blank?
-                primary_keys = $4
-                on_update = $8
-                on_delete = $6
-                on_update = ForeignKeyDefinition::ACTION_LOOKUP[on_update] || :restrict
-                on_delete = ForeignKeyDefinition::ACTION_LOOKUP[on_delete] || :restrict
-
-                options = { :name => name,
-                            :on_delete => on_delete,
-                            :on_update => on_update,
-                            :column => columns.gsub('`', '').split(', '),
-                            :primary_key => primary_keys.gsub('`', '').split(', ')
-                }
-
-                foreign_keys << ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
-                  namespace_prefix + table_name,
-                  to_table,
-                  options)
-              end
-            end
-          end
-
-          foreign_keys
-        end
-
-        def reverse_foreign_keys(table_name, name = nil)
-          results = select_all(<<-SQL, name)
-        SELECT constraint_name, table_name, column_name, referenced_table_name, referenced_column_name
-          FROM information_schema.key_column_usage
-         WHERE table_schema = #{table_schema_sql(table_name)}
-           AND referenced_table_schema = table_schema
-         ORDER BY constraint_name, ordinal_position;
-          SQL
-
-          constraints = results.to_a.group_by do |r|
-            r.values_at('constraint_name', 'table_name', 'referenced_table_name')
-          end
-
-          from_table_constraints = constraints.select do |(_, _, to_table), _|
-            table_name_without_namespace(table_name).casecmp(to_table) == 0
-          end
-
-          from_table_constraints.map do |(constraint_name, from_table, to_table), columns|
-            from_table = table_namespace_prefix(from_table) + from_table
-            to_table = table_namespace_prefix(to_table) + to_table
-
-            options = {
-              :name => constraint_name,
-              :column => columns.map { |row| row['column_name'] },
-              :primary_key => columns.map { |row| row['referenced_column_name'] }
-            }
-
-            ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(from_table, to_table, options)
-          end
-        end
-
-        private
-
-        def table_namespace_prefix(table_name)
-          table_name.to_s =~ /(.*[.])/ ? $1 : ""
-        end
-
-        def table_schema_sql(table_name)
-          table_name.to_s =~ /(.*)[.]/ ? "'#{$1}'" : "SCHEMA()"
-        end
-
-        def table_name_without_namespace(table_name)
-          table_name.to_s.sub /.*[.]/, ''
-        end
-
-      end
-    end
-  end
-end