schema_plus 2.0.0.pre15 → 2.0.0.pre16

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

@@ -1,89 +0,0 @@
-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

@@ -1,98 +0,0 @@
-module SchemaPlus::ForeignKeys
-  module ActiveRecord
-    module ConnectionAdapters
-
-      # SchemaPlus::ForeignKeys includes an Sqlite3 implementation of the AbstractAdapter
-      # extensions.
-      module Sqlite3Adapter
-
-        # :enddoc:
-
-        def initialize(*args)
-          super
-          execute('PRAGMA FOREIGN_KEYS = ON')
-        end
-
-        def rename_table(oldname, newname) #:nodoc:
-          super
-          rename_foreign_keys(oldname, newname)
-        end
-
-        def copy_table(*args, &block)
-          fk_override = { :auto_create => false, :auto_index => false }
-          save = Hash[fk_override.keys.collect{|key| [key, SchemaPlus::ForeignKeys.config.send(key)]}]
-          begin
-            SchemaPlus::ForeignKeys.config.update_attributes(fk_override)
-            super
-          ensure
-            SchemaPlus::ForeignKeys.config.update_attributes(save)
-          end
-        end
-
-        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

@@ -1,108 +0,0 @@
-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_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

@@ -1,35 +0,0 @@
-module SchemaPlus::ForeignKeys
-  module ActiveRecord
-    module Migration
-      module CommandRecorder
-
-        attr_accessor :schema_plus_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
-
-        # overrides to add if_exists option
-        def invert_add_index(args)
-          table, columns, options = *args
-          [:remove_index, [table, (options||{}).merge(column: columns, if_exists: true)]]
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-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|
-            @inline_fks[table] = env.connection.foreign_keys(table)
-            env.dump.depends(table, @inline_fks[table].collect(&:to_table))
-          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
-
-      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.statements += env.dump.data.inline_fks[env.table.name].map { |foreign_key|
-            foreign_key.to_dump(inline: true) unless dumped[foreign_key]
-          }.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

@@ -1,184 +0,0 @@
-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_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)
-          fk_options = env.options[:foreign_key]
-
-          case fk_options
-          when false then ;
-          when true then fk_options = {}
-          end
-
-          if fk_options != false # may be nil
-            [:references, :on_update, :on_delete, :deferrable].each do |key|
-              (fk_options||={}).reverse_merge!(key => env.options[key]) if env.options.has_key? key
-            end
-          end
-
-          if fk_options and fk_options.has_key?(:references)
-            case fk_options[:references]
-            when nil, false
-              fk_options = false
-            when Array then
-              table, primary_key = fk_options[:references]
-              fk_options[:references] = table
-              fk_options[:primary_key] ||= primary_key
-            end
-          end
-
-
-          fk_options = false if fk_options and fk_options.has_key?(:references) and not fk_options[:references]
-
-          env.options[:foreign_key] = fk_options
-        end
-
-        #
-        # Add the foreign keys
-        #
-        def around(env)
-          options = env.options
-          original_options = options.dup
-
-          is_reference = (env.type == :reference)
-          is_polymorphic = is_reference && options[:polymorphic]
-
-          # usurp index creation from AR.  That's necessary to make
-          # auto_index work properly
-          index = options.delete(:index) unless is_polymorphic
-          if is_reference
-            options[:foreign_key] = false
-            options[:_is_reference] = true
-          end
-
-          yield env
-
-          return if is_polymorphic
-
-          env.options = original_options
-
-          add_foreign_keys_and_auto_index(env)
-
-        end
-
-        private
-
-        def add_foreign_keys_and_auto_index(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_config) || SchemaPlus::ForeignKeys.config)
-          fk_args = get_fk_args(env, config)
-
-          # remove existing fk and auto-generated index in case of change of fk on existing column
-          if env.operation == :change and fk_args # includes :none for explicitly off
-            remove_foreign_key_if_exists(env)
-            remove_auto_index_if_exists(env)
-          end
-
-          fk_args = nil if fk_args == :none
-
-          create_index(env, fk_args, config)
-          create_fk(env, fk_args) if fk_args
-
-          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 auto_index_name(env)
-          ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.auto_index_name(env.table_name, env.column_name)
-        end
-
-        def create_index(env, fk_args, config)
-          # create index if requested explicity or implicitly due to auto_index
-          index = env.options[:index]
-          index = { :name => auto_index_name(env) } if index.nil? and fk_args && config.auto_index?
-          return unless index
-          case env.caller
-          when ::ActiveRecord::ConnectionAdapters::TableDefinition
-            env.caller.index(env.column_name, index)
-          else
-            env.caller.add_index(env.table_name, env.column_name, index)
-          end
-        end
-
-        def create_fk(env, fk_args)
-          references = fk_args.delete(:references)
-          case env.caller
-          when ::ActiveRecord::ConnectionAdapters::TableDefinition
-            env.caller.foreign_key(env.column_name, references, fk_args)
-          else
-            env.caller.add_foreign_key(env.table_name, references, fk_args.merge(:column => env.column_name))
-          end
-        end
-
-
-        def get_fk_args(env, config)
-          args = nil
-          column_name = env.column_name.to_s
-          options = env.options
-
-          return :none if options[:foreign_key] == false
-
-          args = options[:foreign_key]
-          auto = config.auto_create?
-          auto = false if options[:_is_reference] and env.type != :reference # this is a nested call to column() from with reference(); suppress auto-fk
-          args ||= {} if auto and column_name =~ /_id$/
-
-          return nil if args.nil?
-
-          args[:references] ||= env.table_name if column_name == 'parent_id'
-
-          args[:references] ||= begin
-                                  table_name = column_name.sub(/_id$/, '')
-                                  table_name = table_name.pluralize if ::ActiveRecord::Base.pluralize_table_names
-                                  table_name
-                                end
-
-          args[:on_update] ||= config.on_update
-          args[:on_delete] ||= config.on_delete
-
-          args
-        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 remove_auto_index_if_exists(env)
-          env.caller.remove_index(env.table_name, :name => auto_index_name(env), :column => env.column_name, :if_exists => true)
-        end
-
-      end
-
-    end
-  end
-end
-