activerecord 3.2.22.5 → 4.2.11.3

data/lib/active_record/locking/pessimistic.rb

@@ -3,12 +3,12 @@ module ActiveRecord
     # Locking::Pessimistic provides support for row-level locking using
     # SELECT ... FOR UPDATE and other lock types.
     #
-    # Pass <tt>:lock => true</tt> to <tt>ActiveRecord::Base.find</tt> to obtain an exclusive
+    # Chain <tt>ActiveRecord::Base#find</tt> to <tt>ActiveRecord::QueryMethods#lock</tt> to obtain an exclusive
     # lock on the selected rows:
     #   # select * from accounts where id=1 for update
-    #   Account.find(1, :lock => true)
+    #   Account.lock.find(1)
     #
-    # Pass <tt>:lock => 'some locking clause'</tt> to give a database-specific locking clause
+    # Call <tt>lock('some locking clause')</tt> to use a database-specific locking clause
     # of your own such as 'LOCK IN SHARE MODE' or 'FOR UPDATE NOWAIT'. Example:
     #
     #   Account.transaction do
@@ -26,7 +26,7 @@ module ActiveRecord
     #
     #   Account.transaction do
     #     # select * from accounts where ...
-    #     accounts = Account.where(...).all
+    #     accounts = Account.where(...)
     #     account1 = accounts.detect { |account| ... }
     #     account2 = accounts.detect { |account| ... }
     #     # select * from accounts where id=? for update
@@ -64,7 +64,7 @@ module ActiveRecord
       end
 
       # Wraps the passed block in a transaction, locking the object
-      # before yielding. You pass can the SQL locking clause
+      # before yielding. You can pass the SQL locking clause
       # as argument (see <tt>lock!</tt>).
       def with_lock(lock = true)
         transaction do

data/lib/active_record/log_subscriber.rb

@@ -1,11 +1,13 @@
 module ActiveRecord
   class LogSubscriber < ActiveSupport::LogSubscriber
+    IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"]
+
     def self.runtime=(value)
-      Thread.current["active_record_sql_runtime"] = value
+      ActiveRecord::RuntimeRegistry.sql_runtime = value
     end
 
     def self.runtime
-      Thread.current["active_record_sql_runtime"] ||= 0
+      ActiveRecord::RuntimeRegistry.sql_runtime ||= 0
     end
 
     def self.reset_runtime
@@ -15,7 +17,21 @@ module ActiveRecord
 
     def initialize
       super
-      @odd_or_even = false
+      @odd = false
+    end
+
+    def render_bind(column, value)
+      if column
+        if column.binary?
+          # This specifically deals with the PG adapter that casts bytea columns into a Hash.
+          value = value[:value] if value.is_a?(Hash)
+          value = value ? "<#{value.bytesize} bytes of binary data>" : "<NULL binary data>"
+        end
+
+        [column.name, value]
+      else
+        [nil, value]
+      end
     end
 
     def sql(event)
@@ -24,19 +40,15 @@ module ActiveRecord
 
       payload = event.payload
 
-      return if 'SCHEMA' == payload[:name]
+      return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
 
-      name  = '%s (%.1fms)' % [payload[:name], event.duration]
-      sql   = payload[:sql].squeeze(' ')
+      name  = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+      sql   = payload[:sql]
       binds = nil
 
       unless (payload[:binds] || []).empty?
         binds = "  " + payload[:binds].map { |col,v|
-          if col
-            [col.name, v]
-          else
-            [nil, v]
-          end
+          render_bind(col, v)
         }.inspect
       end
 
@@ -50,17 +62,8 @@ module ActiveRecord
       debug "  #{name}  #{sql}#{binds}"
     end
 
-    def identity(event)
-      return unless logger.debug?
-
-      name = color(event.payload[:name], odd? ? CYAN : MAGENTA, true)
-      line = odd? ? color(event.payload[:line], nil, true) : event.payload[:line]
-
-      debug "  #{name}  #{line}"
-    end
-
     def odd?
-      @odd_or_even = !@odd_or_even
+      @odd = !@odd
     end
 
     def logger

data/lib/active_record/migration/command_recorder.rb

@@ -8,66 +8,128 @@ module ActiveRecord
     # * add_index
     # * add_timestamps
     # * create_table
+    # * create_join_table
     # * remove_timestamps
     # * rename_column
     # * rename_index
     # * rename_table
     class CommandRecorder
-      attr_accessor :commands, :delegate
+      include JoinTable
+
+      attr_accessor :commands, :delegate, :reverting
 
       def initialize(delegate = nil)
         @commands = []
         @delegate = delegate
+        @reverting = false
+      end
+
+      # While executing the given block, the recorded will be in reverting mode.
+      # All commands recorded will end up being recorded reverted
+      # and in reverse order.
+      # For example:
+      #
+      #   recorder.revert{ recorder.record(:rename_table, [:old, :new]) }
+      #   # same effect as recorder.record(:rename_table, [:new, :old])
+      def revert
+        @reverting = !@reverting
+        previous = @commands
+        @commands = []
+        yield
+      ensure
+        @commands = previous.concat(@commands.reverse)
+        @reverting = !@reverting
       end
 
       # record +command+. +command+ should be a method name and arguments.
       # For example:
       #
       #   recorder.record(:method_name, [:arg1, :arg2])
-      def record(*command)
-        @commands << command
+      def record(*command, &block)
+        if @reverting
+          @commands << inverse_of(*command, &block)
+        else
+          @commands << (command << block)
+        end
       end
 
-      # Returns a list that represents commands that are the inverse of the
-      # commands stored in +commands+. For example:
+      # Returns the inverse of the given command. For example:
       #
-      #   recorder.record(:rename_table, [:old, :new])
-      #   recorder.inverse # => [:rename_table, [:new, :old]]
+      #   recorder.inverse_of(:rename_table, [:old, :new])
+      #   # => [:rename_table, [:new, :old]]
       #
       # This method will raise an +IrreversibleMigration+ exception if it cannot
-      # invert the +commands+.
-      def inverse
-        @commands.reverse.map { |name, args|
-          method = :"invert_#{name}"
-          raise IrreversibleMigration unless respond_to?(method, true)
-          send(method, args)
-        }
+      # invert the +command+.
+      def inverse_of(command, args, &block)
+        method = :"invert_#{command}"
+        raise IrreversibleMigration unless respond_to?(method, true)
+        send(method, args, &block)
       end
 
       def respond_to?(*args) # :nodoc:
         super || delegate.respond_to?(*args)
       end
 
-      [:create_table, :change_table, :rename_table, :add_column, :remove_column, :rename_index, :rename_column, :add_index, :remove_index, :add_timestamps, :remove_timestamps, :change_column, :change_column_default].each do |method|
+      [:create_table, :create_join_table, :rename_table, :add_column, :remove_column,
+        :rename_index, :rename_column, :add_index, :remove_index, :add_timestamps, :remove_timestamps,
+        :change_column_default, :add_reference, :remove_reference, :transaction,
+        :drop_join_table, :drop_table, :execute_block, :enable_extension,
+        :change_column, :execute, :remove_columns, :change_column_null,
+        :add_foreign_key, :remove_foreign_key
+       # irreversible methods need to be here too
+      ].each do |method|
         class_eval <<-EOV, __FILE__, __LINE__ + 1
-          def #{method}(*args)          # def create_table(*args)
-            record(:"#{method}", args)  #   record(:create_table, args)
-          end                           # end
+          def #{method}(*args, &block)          # def create_table(*args, &block)
+            record(:"#{method}", args, &block)  #   record(:create_table, args, &block)
+          end                                   # end
         EOV
       end
+      alias :add_belongs_to :add_reference
+      alias :remove_belongs_to :remove_reference
+
+      def change_table(table_name, options = {}) # :nodoc:
+        yield delegate.update_table_definition(table_name, self)
+      end
 
       private
 
-      def invert_create_table(args)
-        [:drop_table, [args.first]]
+      module StraightReversions
+        private
+        { transaction:       :transaction,
+          execute_block:     :execute_block,
+          create_table:      :drop_table,
+          create_join_table: :drop_join_table,
+          add_column:        :remove_column,
+          add_timestamps:    :remove_timestamps,
+          add_reference:     :remove_reference,
+          enable_extension:  :disable_extension
+        }.each do |cmd, inv|
+          [[inv, cmd], [cmd, inv]].uniq.each do |method, inverse|
+            class_eval <<-EOV, __FILE__, __LINE__ + 1
+              def invert_#{method}(args, &block)    # def invert_create_table(args, &block)
+                [:#{inverse}, args, block]          #   [:drop_table, args, block]
+              end                                   # end
+            EOV
+          end
+        end
+      end
+
+      include StraightReversions
+
+      def invert_drop_table(args, &block)
+        if args.size == 1 && block == nil
+          raise ActiveRecord::IrreversibleMigration, "To avoid mistakes, drop_table is only reversible if given options or a block (can be empty)."
+        end
+        super
       end
 
       def invert_rename_table(args)
         [:rename_table, args.reverse]
       end
 
-      def invert_add_column(args)
-        [:remove_column, args.first(2)]
+      def invert_remove_column(args)
+        raise ActiveRecord::IrreversibleMigration, "remove_column is only reversible if given a type." if args.size <= 2
+        super
       end
 
       def invert_rename_index(args)
@@ -80,26 +142,56 @@ module ActiveRecord
 
       def invert_add_index(args)
         table, columns, options = *args
-        index_name = options.try(:[], :name)
-        options_hash =  index_name ? {:name => index_name} : {:column => columns}
+        options ||= {}
+
+        index_name = options[:name]
+        options_hash = index_name ? { name: index_name } : { column: columns }
+
         [:remove_index, [table, options_hash]]
       end
 
-      def invert_remove_timestamps(args)
-        [:add_timestamps, args]
+      def invert_remove_index(args)
+        table, options = *args
+
+        unless options && options.is_a?(Hash) && options[:column]
+          raise ActiveRecord::IrreversibleMigration, "remove_index is only reversible if given a :column option."
+        end
+
+        options = options.dup
+        [:add_index, [table, options.delete(:column), options]]
+      end
+
+      alias :invert_add_belongs_to :invert_add_reference
+      alias :invert_remove_belongs_to :invert_remove_reference
+
+      def invert_change_column_null(args)
+        args[2] = !args[2]
+        [:change_column_null, args]
       end
 
-      def invert_add_timestamps(args)
-        [:remove_timestamps, args]
+      def invert_add_foreign_key(args)
+        from_table, to_table, add_options = args
+        add_options ||= {}
+
+        if add_options[:name]
+          options = { name: add_options[:name] }
+        elsif add_options[:column]
+          options = { column: add_options[:column] }
+        else
+          options = to_table
+        end
+
+        [:remove_foreign_key, [from_table, options]]
       end
 
       # Forwards any missing method call to the \target.
       def method_missing(method, *args, &block)
-        @delegate.send(method, *args, &block)
-      rescue NoMethodError => e
-        raise e, e.message.sub(/ for #<.*$/, " via proxy for #{@delegate}")
+        if @delegate.respond_to?(method)
+          @delegate.send(method, *args, &block)
+        else
+          super
+        end
       end
-
     end
   end
 end

data/lib/active_record/migration/join_table.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  class Migration
+    module JoinTable #:nodoc:
+      private
+
+      def find_join_table_name(table_1, table_2, options = {})
+        options.delete(:table_name) || join_table_name(table_1, table_2)
+      end
+
+      def join_table_name(table_1, table_2)
+        ModelSchema.derive_join_table_name(table_1, table_2).to_sym
+      end
+    end
+  end
+end