schema_plus 1.8.9 → 2.0.0.pre1

data/lib/schema_plus/active_record/connection_adapters/schema_statements.rb

@@ -4,18 +4,9 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
     def self.included(base) #:nodoc:
       base.class_eval do
         alias_method_chain :create_table, :schema_plus
-        alias_method_chain :add_reference, :schema_plus unless ::ActiveRecord::VERSION::MAJOR.to_i < 4
-        alias_method_chain :add_index_options, :schema_plus if "#{::ActiveRecord::VERSION::MAJOR}.#{::ActiveRecord::VERSION::MINOR}".to_r >= "4.2".to_r
-        include AddIndex
       end
     end
 
-    def add_reference_with_schema_plus(table_name, ref_name, options = {}) #:nodoc:
-      options[:references] = nil if options[:polymorphic]
-      options[:_index] = options.delete(:index) unless options[:polymorphic] # usurp index creation from AR
-      add_reference_without_schema_plus(table_name, ref_name, options)
-    end
-
     ##
     # :method: create_table
     #
@@ -33,68 +24,11 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
       # override rails' :force to cascade
       drop_table(table, if_exists: true, cascade: true) if options.delete(:force)
 
-      if ::ActiveRecord::VERSION::MAJOR.to_i < 4
-        indexes = []
-      end
       create_table_without_schema_plus(table, options) do |table_definition|
         table_definition.schema_plus_config = SchemaPlus.config.merge(config_options)
-        if ::ActiveRecord::VERSION::MAJOR.to_i < 4
-          table_definition.name = table
-        end
         yield table_definition if block_given?
-        if ::ActiveRecord::VERSION::MAJOR.to_i < 4
-          indexes = table_definition.indexes
-        end
-      end
-      if ::ActiveRecord::VERSION::MAJOR.to_i < 4
-        indexes.each do |index|
-          add_index(table, index.columns, index.opts)
-        end
-      end
-    end
-
-    def add_index_options_with_schema_plus(table_name, column_name, options = {})
-      options = options.dup
-      with_columns = options.delete(:with) { |_| [] }
-      add_index_options_without_schema_plus(table_name, Array(column_name).concat(Array(with_columns).map(&:to_s)), options)
-    end
-
-    def self.add_index_exception_handler(connection, table, columns, options, e) #:nodoc:
-      raise unless e.message.match(/["']([^"']+)["'].*already exists/)
-      name = $1
-      existing = connection.indexes(table).find{|i| i.name == name}
-      attempted = ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table, columns, options.merge(:name => name))
-      raise if attempted != existing
-      ::ActiveRecord::Base.logger.warn "[schema_plus] Index name #{name.inspect}' on table #{table.inspect} already exists. Skipping."
-    end
-
-    module AddIndex
-      def self.included(base) #:nodoc:
-        base.class_eval do
-          alias_method_chain :add_index, :schema_plus
-        end
-      end
-
-      ##
-      # :method: add_index
-      #
-      # SchemaPlus modifies SchemaStatements::add_index so that it ignores
-      # errors raised about add an index that already exists -- i.e. that has
-      # the same index name, same columns, and same options -- and writes a
-      # warning to the log. Some combinations of rails & DB adapter versions
-      # would log such a warning, others would raise an error; with
-      # SchemaPlus all versions log the warning and do not raise the error.
-      #
-      # (This avoids collisions between SchemaPlus's auto index behavior and
-      # legacy explicit add_index statements, for platforms that would raise
-      # an error.)
-      #
-      def add_index_with_schema_plus(table, columns, options={})
-        options.delete(:if_exists) if options # some callers explcitly pass options=nil
-        add_index_without_schema_plus(table, columns, options)
-      rescue => e
-        SchemaStatements.add_index_exception_handler(self, table, columns, options, e)
       end
     end
   end
+
 end

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

@@ -1,24 +1,6 @@
 module SchemaPlus
   module ActiveRecord
     module ConnectionAdapters
-      module SQLiteColumn
-        def initialize(name, default, sql_type = nil, null = true)
-          if default =~ /DATETIME/
-            @default_expr = "(#{default})"
-          end
-          super(name, default, sql_type, null)
-        end
-
-        # AR 4.2 uses default_function rather than default_expr
-        def self.included(base)
-          base.alias_method_chain :default_function, :sqlite3 if base.instance_methods.include? :default_function
-        end
-
-        def default_function_with_sqlite3
-          @default_function ||= "(#{default})" if default =~ /DATETIME/
-          default_function_without_sqlite3
-        end
-      end
 
       # SchemaPlus includes an Sqlite3 implementation of the AbstractAdapter
       # extensions.
@@ -28,18 +10,7 @@ module SchemaPlus
 
         def self.included(base)
           base.class_eval do
-            alias_method_chain :indexes, :schema_plus
             alias_method_chain :rename_table, :schema_plus
-            alias_method_chain :tables, :schema_plus
-            alias_method_chain :copy_table, :schema_plus
-          end
-
-          if ::ActiveRecord::VERSION::MAJOR.to_i < 4
-            ::ActiveRecord::ConnectionAdapters::SQLiteColumn.send(:include, SQLiteColumn) unless ::ActiveRecord::ConnectionAdapters::SQLiteColumn.include?(SQLiteColumn)
-          elsif defined? ::ActiveRecord::ConnectionAdapters::SQLite3Column
-            ::ActiveRecord::ConnectionAdapters::SQLite3Column.send(:include, SQLiteColumn) unless ::ActiveRecord::ConnectionAdapters::SQLite3Column.include?(SQLiteColumn)
-          else # in ActiveRecord::VERSION 4.2 there's no SQLite3Column
-            ::ActiveRecord::ConnectionAdapters::Column.send(:include, SQLiteColumn) unless ::ActiveRecord::ConnectionAdapters::Column.include?(SQLiteColumn)
           end
         end
 
@@ -48,57 +19,17 @@ module SchemaPlus
           execute('PRAGMA FOREIGN_KEYS = ON')
         end
 
-        def supports_partial_indexes? #:nodoc:
-          # unfortunately with the current setup there's no easy way to
-          # test multiple SQLite3 versions.  Currently travis-ci uses
-          # SQLite3 version 3.7 but local development on OS X uses 3.8.
-          SQLite3.libversion >= 3008000
-        end
-
-        def indexes_with_schema_plus(table_name, name = nil)
-          indexes = indexes_without_schema_plus(table_name, name)
-          exec_query("SELECT name, sql FROM sqlite_master WHERE type = 'index'").map do |row|
-            sql = row['sql']
-            index = nil
-            getindex = -> { index ||= indexes.detect { |i| i.name == row['name'] } }
-            if (desc_columns = sql.scan(/['"`]?(\w+)['"`]? DESC\b/).flatten).any?
-              getindex.call()
-              index.orders = Hash[index.columns.map {|column| [column, desc_columns.include?(column) ? :desc : :asc]}]
-            end
-            if (conditions = sql.match(/\bWHERE\s+(.*)/i))
-              getindex.call()
-              index.conditions = conditions[1]
-            end
-          end
-          indexes
-        end
-
-        def copy_table_with_schema_plus(*args, &block)
-          fk_override = { :auto_create => false, :auto_index => false }
-          save = Hash[fk_override.keys.collect{|key| [key, SchemaPlus.config.foreign_keys.send(key)]}]
-          begin
-            SchemaPlus.config.foreign_keys.update_attributes(fk_override)
-            copy_table_without_schema_plus(*args, &block)
-          ensure
-            SchemaPlus.config.foreign_keys.update_attributes(save)
-          end
-        end
-
         def rename_table_with_schema_plus(oldname, newname) #:nodoc:
           rename_table_without_schema_plus(oldname, newname)
-          rename_indexes_and_foreign_keys(oldname, newname)
-        end
-
-        def add_foreign_key(table_name, column_names, references_table_name, references_column_names, options = {})
-          raise NotImplementedError, "Sqlite3 does not support altering a table to add foreign key constraints (table #{table_name.inspect} column #{column_names.inspect})"
+          rename_foreign_keys(oldname, newname)
         end
 
-        def remove_foreign_key(table_name, foreign_key_name)
-          raise NotImplementedError, "Sqlite3 does not support altering a table to remove foreign key constraints (table #{table_name.inspect} constraint #{foreign_key_name.inspect})"
+        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 drop_table(name, options={})
-          super(name, options.except(:cascade))
+        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)
@@ -106,21 +37,7 @@ module SchemaPlus
         end
 
         def reverse_foreign_keys(table_name, name = nil)
-          get_foreign_keys(nil, name).select{|definition| definition.references_table_name == table_name}
-        end
-
-        def tables_with_schema_plus(*args)
-          # AR 4.2 explicitly looks for views or tables, but only for sqlite3.  so take away the tables.
-          tables_without_schema_plus(*args) - views
-        end
-
-        def views(name = nil)
-          execute("SELECT name FROM sqlite_master WHERE type='view'", name).collect{|row| row["name"]}
-        end
-
-        def view_definition(view_name, name = nil)
-          sql = execute("SELECT sql FROM sqlite_master WHERE type='view' AND name=#{quote(view_name)}", name).collect{|row| row["sql"]}.first
-          sql.sub(/^CREATE VIEW \S* AS\s+/im, '') unless sql.nil?
+          get_foreign_keys(nil, name).select{|definition| definition.to_table == table_name}
         end
 
         protected
@@ -143,43 +60,32 @@ module SchemaPlus
 
           foreign_keys = []
           results.each do |row|
-            table_name = row["name"]
-            row["sql"].scan(re).each do |d0, name, column_names, references_table_name, references_column_names, d1, on_update, d2, on_delete, deferrable, initially_deferred|
-              column_names = column_names.gsub('`', '').split(', ')
+            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(', ')
 
-              references_column_names = references_column_names.gsub('`"', '').split(', ')
-              on_update = on_update ? on_update.downcase.gsub(' ', '_').to_sym : :no_action
-              on_delete = on_delete ? on_delete.downcase.gsub(' ', '_').to_sym : :no_action
+              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_names => column_names,
-                          :references_column_names => references_column_names,
+                          :column => columns,
+                          :primary_key => primary_keys,
                           :deferrable => deferrable }
 
-              foreign_keys << ForeignKeyDefinition.new(table_name,
-                                                       references_table_name,
-                                                       options)
+              foreign_keys << ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
+                from_table,
+                to_table,
+                options)
             end
           end
 
           foreign_keys
         end
 
-        module AddColumnOptions
-          def default_expr_valid?(expr)
-            true # arbitrary sql is okay
-          end
-
-          def sql_for_function(function)
-            case function
-              when :now
-                "(DATETIME('now'))"
-            end
-          end
-        end
       end
 
     end

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

@@ -64,133 +64,31 @@ module SchemaPlus::ActiveRecord::ConnectionAdapters
   #      end
   #
   module TableDefinition
-    include SchemaPlus::ActiveRecord::ColumnOptionsHandler
 
     attr_accessor :schema_plus_config #:nodoc:
-    attr_reader :foreign_keys #:nodoc:
 
-    def self.included(base) #:nodoc:
-      base.class_eval do
-        alias_method_chain :initialize, :schema_plus
-        alias_method_chain :column, :schema_plus
-        alias_method_chain :references, :schema_plus
-        alias_method_chain :belongs_to, :schema_plus
-        alias_method_chain :primary_key, :schema_plus
-
-        if ::ActiveRecord::VERSION::MAJOR.to_i < 4
-          attr_accessor :name
-          attr_accessor :indexes
-          alias_method_chain :to_sql, :schema_plus
-        end
-      end
-    end
-
-    def initialize_with_schema_plus(*args) #:nodoc:
-      initialize_without_schema_plus(*args)
-      @foreign_keys = []
-      if ::ActiveRecord::VERSION::MAJOR.to_i < 4
-        @indexes = []
-      end
+    def foreign_keys
+      @foreign_keys ||= []
     end
 
-    if ::ActiveRecord::VERSION::MAJOR.to_i < 4
-      def primary_key_with_schema_plus(name, options = {}) #:nodoc:
-        column(name, :primary_key, options)
-      end
-    else
-      def primary_key_with_schema_plus(name, type = :primary_key, options = {}) #:nodoc:
-        column(name, type, options.merge(:primary_key => true))
-      end
-    end
-
-
-    # need detect :polymorphic at this level, because rails strips it out
-    # before calling #column (twice, once for _id and once for _type)
-    def references_with_schema_plus(*args) #:nodoc:
+    def foreign_key(*args) # (column_names, to_table, primary_key=nil, options=nil)
       options = args.extract_options!
-      options[:references] = nil if options[:polymorphic]
-      schema_plus_normalize_column_options(options)
-      options[:_index] = options.delete(:index) unless options[:polymorphic] # usurp index creation from AR
-      args << options
-      references_without_schema_plus(*args)
-    end
-
-    # need detect :polymorphic at this level, because rails strips it out
-    # before calling #column (twice, once for _id and once for _type)
-    def belongs_to_with_schema_plus(*args) #:nodoc:
-      options = args.extract_options!
-      options[:references] = nil if options[:polymorphic]
-      schema_plus_normalize_column_options(options)
-      options[:_index] = options.delete(:index) unless options[:polymorphic] # usurp index creation from AR
-      args << options
-      belongs_to_without_schema_plus(*args)
-    end
-
-    def column_with_schema_plus(name, type, options = {}) #:nodoc:
-      schema_plus_normalize_column_options(options)
-      # prevent AR from seeing :index => false as a request for an index
-      if noindex = options[:index] == false
-        options.delete(:index)
+      case args.length
+      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
-      column_without_schema_plus(name, type, options)
-      options[:index] = false if noindex
-      schema_plus_handle_column_options(self.name, name, options, :config => schema_plus_config)
-      self
-    end
-
-    def to_sql_with_schema_plus #:nodoc:
-      sql = to_sql_without_schema_plus
-      sql << ', ' << @foreign_keys.map(&:to_sql) * ', ' unless @foreign_keys.empty?
-      sql
-    end
 
-    # Define an index for the current
-    if ::ActiveRecord::VERSION::MAJOR.to_i < 4
-      def index(column_name, options={})
-        @indexes << ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(self.name, column_name, options)
-      end
-    end
-
-    def foreign_key(column_names, references_table_name, references_column_names, options = {})
-      options.merge!(:column_names => column_names, :references_column_names => references_column_names)
+      options.merge!(:column => column_names)
       options.reverse_merge!(:name => ForeignKeyDefinition.default_name(self.name, column_names))
-      @foreign_keys << ForeignKeyDefinition.new(self.name, AbstractAdapter.proper_table_name(references_table_name), options)
+      foreign_keys << ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(self.name, AbstractAdapter.proper_table_name(to_table), options)
       self
     end
 
-    protected
-    # The only purpose of that method is to provide a consistent intefrace
-    # for ColumnOptionsHandler. First argument (table name) is ignored.
-    def add_index(_, *args) #:nodoc:
-      index(*args)
-    end
-
-    # The only purpose of that method is to provide a consistent intefrace
-    # for ColumnOptionsHandler. First argument (table name) is ignored.
-    def add_foreign_key(_, *args) #:nodoc:
-      foreign_key(*args)
-    end
-
-    # This is a deliberately empty stub.  The reason for it is that
-    # ColumnOptionsHandler is used for changes as well as for table
-    # definitions, and in the case of changes, previously existing foreign
-    # keys sometimes need to be removed.  but in the case here, that of
-    # table definitions, the only reason a foreign key would exist is
-    # because we're redefining a table that already exists (via :force =>
-    # true).  in which case the foreign key will get dropped when the
-    # drop_table gets emitted, so no need to do it immediately.  (and for
-    # sqlite3, attempting to do it immediately would raise an error).
-    def remove_foreign_key(_, *args) #:nodoc:
-    end
-
-    # This is a deliberately empty stub.  The reason for it is that
-    # ColumnOptionsHandler will remove a previous index when changing a
-    # column.  But we don't do column changes within table definitions.
-    # Presumably will be called with :if_exists true.  If not, will raise
-    # an error.
-    def remove_index(_, options)
-      raise "InternalError: remove_index called in a table definition" unless options[:if_exists]
-    end
-
   end
 end

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

@@ -2,26 +2,16 @@ module SchemaPlus
   module ActiveRecord
     module Migration
       module CommandRecorder
-        include SchemaPlus::ActiveRecord::ColumnOptionsHandler
 
         attr_accessor :schema_plus_config #:nodoc:
 
         def self.included(base) #:nodoc:
           base.class_eval do
-            alias_method_chain :add_column, :schema_plus
-            alias_method_chain :add_reference, :schema_plus unless ::ActiveRecord::VERSION::MAJOR.to_i < 4
+            alias_method_chain :add_reference, :schema_plus
             alias_method_chain :invert_add_index, :schema_plus
-            alias_method_chain :invert_add_foreign_key, :schema_plus if "#{::ActiveRecord::VERSION::MAJOR}.#{::ActiveRecord::VERSION::MINOR}".to_r >= "4.2".to_r
           end
         end
 
-        def add_column_with_schema_plus(table_name, name, type, options = {}) #:nodoc:
-          schema_plus_normalize_column_options(options)
-          add_column_without_schema_plus(table_name, name, type, options)
-          revertable_schema_plus_handle_column_options(table_name, name, options, :config => schema_plus_config)
-          self
-        end
-
         # 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)
@@ -29,63 +19,22 @@ module SchemaPlus
         # should track it down separately and submit a patch/fix to rails
         #
         def add_reference_with_schema_plus(table_name, ref_name, options = {}) #:nodoc:
-          options[:references] = nil if options[:polymorphic]
-          # which is the worse hack...?
-          if RUBY_VERSION >= "2.0.0" and self.delegate.respond_to? :add_reference_sql
-            # .. rebinding a method from a different module?  (can't do this in ruby 1.9.3)
-            ::ActiveRecord::ConnectionAdapters::SchemaStatements.instance_method(:add_reference).bind(self).call(table_name, ref_name, options)
-          else
-            # .. or copying and pasting the code?
-            polymorphic = options.delete(:polymorphic)
-            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
-          end
+          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
 
-        if ::ActiveRecord::VERSION::MAJOR >= 4
-          def revertable_schema_plus_handle_column_options(table_name, name, options, config)
-            length = commands.length
-            schema_plus_handle_column_options(table_name, name, options, config)
-            if reverting
-              rev = []
-              while commands.length > length
-                cmd = commands.pop
-                rev.unshift cmd unless cmd[0].to_s =~ /^add_/
-              end
-              commands.concat rev
-            end
-          end
-        else
-          alias :revertable_schema_plus_handle_column_options :schema_plus_handle_column_options
-        end
-
-        def add_foreign_key(*args)
-          record(:add_foreign_key, args)
-        end
-
-        def invert_add_foreign_key(args)
-          table_name, column_names, references_table_name, references_column_names, options = args
-          [:remove_foreign_key, [table_name, column_names, references_table_name, references_column_names, (options||{}).merge(if_exists: true)]]
-        end
-        alias :invert_add_foreign_key_with_schema_plus :invert_add_foreign_key
-
         def invert_add_index_with_schema_plus(args)
           table, columns, options = *args
           [:remove_index, [table, (options||{}).merge(column: columns, if_exists: true)]]
         end
 
-        def remove_foreign_key(*args)
-          record(:remove_foreign_key, args)
-        end
-
-        def invert_remove_foreign_key(args)
-          [:add_foreign_key, args]
-        end
-
       end
     end
   end