activerecord 3.1.10 → 4.2.11

data/lib/active_record/transactions.rb

@@ -1,15 +1,27 @@
-require 'thread'
-
 module ActiveRecord
   # See ActiveRecord::Transactions::ClassMethods for documentation.
   module Transactions
     extend ActiveSupport::Concern
-
-    class TransactionError < ActiveRecordError # :nodoc:
-    end
+    #:nodoc:
+    ACTIONS = [:create, :destroy, :update]
+    #:nodoc:
+    CALLBACK_WARN_MESSAGE = "Currently, Active Record suppresses errors raised " \
+      "within `after_rollback`/`after_commit` callbacks and only print them to " \
+      "the logs. In the next version, these errors will no longer be suppressed. " \
+      "Instead, the errors will propagate normally just like in other Active " \
+      "Record callbacks.\n" \
+      "\n" \
+      "You can opt into the new behavior and remove this warning by setting:\n" \
+      "\n" \
+      "  config.active_record.raise_in_transactional_callbacks = true\n\n"
 
     included do
-      define_callbacks :commit, :rollback, :terminator => "result == false", :scope => [:kind, :name]
+      define_callbacks :commit, :rollback,
+                       terminator: ->(_, result) { result == false },
+                       scope: [:kind, :name]
+
+      mattr_accessor :raise_in_transactional_callbacks, instance_writer: false
+      self.raise_in_transactional_callbacks = false
     end
 
     # = Active Record Transactions
@@ -108,10 +120,10 @@ module ActiveRecord
     #
     #   # Suppose that we have a Number model with a unique column called 'i'.
     #   Number.transaction do
-    #     Number.create(:i => 0)
+    #     Number.create(i: 0)
     #     begin
     #       # This will raise a unique constraint error...
-    #       Number.create(:i => 0)
+    #       Number.create(i: 0)
     #     rescue ActiveRecord::StatementInvalid
     #       # ...which we ignore.
     #     end
@@ -119,7 +131,7 @@ module ActiveRecord
     #     # On PostgreSQL, the transaction is now unusable. The following
     #     # statement will cause a PostgreSQL error, even though the unique
     #     # constraint is no longer violated:
-    #     Number.create(:i => 1)
+    #     Number.create(i: 1)
     #     # => "PGError: ERROR:  current transaction is aborted, commands
     #     #     ignored until end of transaction block"
     #   end
@@ -134,9 +146,9 @@ module ActiveRecord
     # transaction. For example, the following behavior may be surprising:
     #
     #   User.transaction do
-    #     User.create(:username => 'Kotori')
+    #     User.create(username: 'Kotori')
     #     User.transaction do
-    #       User.create(:username => 'Nemu')
+    #       User.create(username: 'Nemu')
     #       raise ActiveRecord::Rollback
     #     end
     #   end
@@ -147,25 +159,25 @@ module ActiveRecord
     # real transaction is committed.
     #
     # In order to get a ROLLBACK for the nested transaction you may ask for a real
-    # sub-transaction by passing <tt>:requires_new => true</tt>. If anything goes wrong,
+    # sub-transaction by passing <tt>requires_new: true</tt>. If anything goes wrong,
     # the database rolls back to the beginning of the sub-transaction without rolling
     # back the parent transaction. If we add it to the previous example:
     #
     #   User.transaction do
-    #     User.create(:username => 'Kotori')
-    #     User.transaction(:requires_new => true) do
-    #       User.create(:username => 'Nemu')
+    #     User.create(username: 'Kotori')
+    #     User.transaction(requires_new: true) do
+    #       User.create(username: 'Nemu')
     #       raise ActiveRecord::Rollback
     #     end
     #   end
     #
-    # only "Kotori" is created. (This works on MySQL and PostgreSQL, but not on SQLite3.)
+    # only "Kotori" is created. This works on MySQL and PostgreSQL. SQLite3 version >= '3.6.8' also supports it.
     #
     # Most databases don't support true nested transactions. At the time of
     # writing, the only database that we're aware of that supports true nested
     # transactions, is MS-SQL. Because of this, Active Record emulates nested
     # transactions by using savepoints on MySQL and PostgreSQL. See
-    # http://dev.mysql.com/doc/refman/5.0/en/savepoint.html
+    # http://dev.mysql.com/doc/refman/5.6/en/savepoint.html
     # for more information about savepoints.
     #
     # === Callbacks
@@ -194,7 +206,7 @@ module ActiveRecord
     # automatically released. The following example demonstrates the problem:
     #
     #   Model.connection.transaction do                           # BEGIN
-    #     Model.connection.transaction(:requires_new => true) do  # CREATE SAVEPOINT active_record_1
+    #     Model.connection.transaction(requires_new: true) do  # CREATE SAVEPOINT active_record_1
     #       Model.connection.create_table(...)                    # active_record_1 now automatically released
     #     end                                                     # RELEASE savepoint active_record_1
     #                                                             # ^^^^ BOOM! database error!
@@ -208,22 +220,55 @@ module ActiveRecord
         connection.transaction(options, &block)
       end
 
+      # This callback is called after a record has been created, updated, or destroyed.
+      #
+      # You can specify that the callback should only be fired by a certain action with
+      # the +:on+ option:
+      #
+      #   after_commit :do_foo, on: :create
+      #   after_commit :do_bar, on: :update
+      #   after_commit :do_baz, on: :destroy
+      #
+      #   after_commit :do_foo_bar, on: [:create, :update]
+      #   after_commit :do_bar_baz, on: [:update, :destroy]
+      #
+      # Note that transactional fixtures do not play well with this feature. Please
+      # use the +test_after_commit+ gem to have these hooks fired in tests.
       def after_commit(*args, &block)
-        options = args.last
-        if options.is_a?(Hash) && options[:on]
-          options[:if] = Array.wrap(options[:if])
-          options[:if] << "transaction_include_action?(:#{options[:on]})"
-        end
+        set_options_for_callbacks!(args)
         set_callback(:commit, :after, *args, &block)
+        unless ActiveRecord::Base.raise_in_transactional_callbacks
+          ActiveSupport::Deprecation.warn(CALLBACK_WARN_MESSAGE)
+        end
       end
 
+      # This callback is called after a create, update, or destroy are rolled back.
+      #
+      # Please check the documentation of +after_commit+ for options.
       def after_rollback(*args, &block)
+        set_options_for_callbacks!(args)
+        set_callback(:rollback, :after, *args, &block)
+        unless ActiveRecord::Base.raise_in_transactional_callbacks
+          ActiveSupport::Deprecation.warn(CALLBACK_WARN_MESSAGE)
+        end
+      end
+
+      private
+
+      def set_options_for_callbacks!(args)
         options = args.last
         if options.is_a?(Hash) && options[:on]
-          options[:if] = Array.wrap(options[:if])
-          options[:if] << "transaction_include_action?(:#{options[:on]})"
+          fire_on = Array(options[:on])
+          assert_valid_transaction_action(fire_on)
+          options[:if] = Array(options[:if])
+          options[:if] << "transaction_include_any_action?(#{fire_on})"
+        end
+      end
+
+      def assert_valid_transaction_action(actions)
+        if (actions - ACTIONS).any?
+          raise ArgumentError, ":on conditions for after_commit and after_rollback callbacks have to be one of #{ACTIONS}"
         end
-        set_callback(:rollback, :after, *args, &block)
       end
     end
 
@@ -246,40 +291,50 @@ module ActiveRecord
       with_transaction_returning_status { super }
     end
 
+    def touch(*) #:nodoc:
+      with_transaction_returning_status { super }
+    end
+
     # Reset id and @new_record if the transaction rolls back.
     def rollback_active_record_state!
       remember_transaction_record_state
       yield
     rescue Exception
-      IdentityMap.remove(self) if IdentityMap.enabled?
       restore_transaction_record_state
       raise
     ensure
       clear_transaction_record_state
     end
 
-    # Call the after_commit callbacks
-    def committed! #:nodoc:
-      run_callbacks :commit
+    # Call the +after_commit+ callbacks.
+    #
+    # Ensure that it is not called if the object was never persisted (failed create),
+    # but call it after the commit of a destroyed object.
+    def committed!(should_run_callbacks = true) #:nodoc:
+      _run_commit_callbacks if should_run_callbacks && destroyed? || persisted?
     ensure
-      clear_transaction_record_state
+      force_clear_transaction_record_state
     end
 
-    # Call the after rollback callbacks. The restore_state argument indicates if the record
+    # Call the +after_rollback+ callbacks. The +force_restore_state+ argument indicates if the record
     # state should be rolled back to the beginning or just to the last savepoint.
-    def rolledback!(force_restore_state = false) #:nodoc:
-      run_callbacks :rollback
+    def rolledback!(force_restore_state = false, should_run_callbacks = true) #:nodoc:
+      _run_rollback_callbacks if should_run_callbacks
     ensure
-      IdentityMap.remove(self) if IdentityMap.enabled?
       restore_transaction_record_state(force_restore_state)
+      clear_transaction_record_state
     end
 
-    # Add the record to the current transaction so that the :after_rollback and :after_commit callbacks
+    # Add the record to the current transaction so that the +after_rollback+ and +after_commit+ callbacks
     # can be called.
     def add_to_transaction
-      if self.class.connection.add_transaction_record(self)
-        remember_transaction_record_state
+      if has_transactional_callbacks?
+        self.class.connection.add_transaction_record(self)
+      else
+        sync_with_transaction_state
+        set_transaction_state(self.class.connection.transaction_state)
       end
+      remember_transaction_record_state
     end
 
     # Executes +method+ within a transaction and captures its return value as a
@@ -292,68 +347,80 @@ module ActiveRecord
       status = nil
       self.class.transaction do
         add_to_transaction
-        status = yield
+        begin
+          status = yield
+        rescue ActiveRecord::Rollback
+          clear_transaction_record_state
+          status = nil
+        end
+
         raise ActiveRecord::Rollback unless status
       end
       status
+    ensure
+      if @transaction_state && @transaction_state.committed?
+        clear_transaction_record_state
+      end
     end
 
     protected
 
     # Save the new record state and id of a record so it can be restored later if a transaction fails.
-    def remember_transaction_record_state #:nodoc
-      @_start_transaction_state ||= {}
-      @_start_transaction_state[:id] = id if has_attribute?(self.class.primary_key)
-      unless @_start_transaction_state.include?(:new_record)
-        @_start_transaction_state[:new_record] = @new_record
-      end
-      unless @_start_transaction_state.include?(:destroyed)
-        @_start_transaction_state[:destroyed] = @destroyed
-      end
+    def remember_transaction_record_state #:nodoc:
+      @_start_transaction_state[:id] = id
+      @_start_transaction_state.reverse_merge!(
+        new_record: @new_record,
+        destroyed: @destroyed,
+        frozen?: frozen?,
+      )
       @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) + 1
     end
 
     # Clear the new record state and id of a record.
-    def clear_transaction_record_state #:nodoc
-      if defined?(@_start_transaction_state)
-        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
-        remove_instance_variable(:@_start_transaction_state) if @_start_transaction_state[:level] < 1
-      end
+    def clear_transaction_record_state #:nodoc:
+      @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+      force_clear_transaction_record_state if @_start_transaction_state[:level] < 1
+    end
+
+    # Force to clear the transaction record state.
+    def force_clear_transaction_record_state #:nodoc:
+      @_start_transaction_state.clear
     end
 
     # Restore the new record state and id of a record that was previously saved by a call to save_record_state.
-    def restore_transaction_record_state(force = false) #:nodoc
-      if defined?(@_start_transaction_state)
-        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
-        if @_start_transaction_state[:level] < 1
-          restore_state = remove_instance_variable(:@_start_transaction_state)
-          @attributes = @attributes.dup if @attributes.frozen?
+    def restore_transaction_record_state(force = false) #:nodoc:
+      unless @_start_transaction_state.empty?
+        transaction_level = (@_start_transaction_state[:level] || 0) - 1
+        if transaction_level < 1 || force
+          restore_state = @_start_transaction_state
+          thaw
           @new_record = restore_state[:new_record]
           @destroyed  = restore_state[:destroyed]
-          if restore_state.has_key?(:id)
-            self.id = restore_state[:id]
-          else
-            @attributes.delete(self.class.primary_key)
-            @attributes_cache.delete(self.class.primary_key)
+          pk = self.class.primary_key
+          if pk && read_attribute(pk) != restore_state[:id]
+            write_attribute(pk, restore_state[:id])
           end
+          freeze if restore_state[:frozen?]
         end
       end
     end
 
     # Determine if a record was created or destroyed in a transaction. State should be one of :new_record or :destroyed.
-    def transaction_record_state(state) #:nodoc
-      @_start_transaction_state[state] if defined?(@_start_transaction_state)
+    def transaction_record_state(state) #:nodoc:
+      @_start_transaction_state[state]
     end
 
     # Determine if a transaction included an action for :create, :update, or :destroy. Used in filtering callbacks.
-    def transaction_include_action?(action) #:nodoc
-      case action
-      when :create
-        transaction_record_state(:new_record)
-      when :destroy
-        destroyed?
-      when :update
-        !(transaction_record_state(:new_record) || destroyed?)
+    def transaction_include_any_action?(actions) #:nodoc:
+      actions.any? do |action|
+        case action
+        when :create
+          transaction_record_state(:new_record)
+        when :destroy
+          destroyed?
+        when :update
+          !(transaction_record_state(:new_record) || destroyed?)
+        end
       end
     end
   end

data/lib/active_record/translation.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  module Translation
+    include ActiveModel::Translation
+
+    # Set the lookup ancestors for ActiveModel.
+    def lookup_ancestors #:nodoc:
+      klass = self
+      classes = [klass]
+      return classes if klass == ActiveRecord::Base
+
+      while klass != klass.base_class
+        classes << klass = klass.superclass
+      end
+      classes
+    end
+
+    # Set the i18n scope to overwrite ActiveModel.
+    def i18n_scope #:nodoc:
+      :activerecord
+    end
+  end
+end

data/lib/active_record/type/big_integer.rb

@@ -0,0 +1,13 @@
+require 'active_record/type/integer'
+
+module ActiveRecord
+  module Type
+    class BigInteger < Integer # :nodoc:
+      private
+
+      def max_value
+        ::Float::INFINITY
+      end
+    end
+  end
+end

data/lib/active_record/type/binary.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  module Type
+    class Binary < Value # :nodoc:
+      def type
+        :binary
+      end
+
+      def binary?
+        true
+      end
+
+      def type_cast(value)
+        if value.is_a?(Data)
+          value.to_s
+        else
+          super
+        end
+      end
+
+      def type_cast_for_database(value)
+        return if value.nil?
+        Data.new(super)
+      end
+
+      def changed_in_place?(raw_old_value, value)
+        old_value = type_cast_from_database(raw_old_value)
+        old_value != value
+      end
+
+      class Data # :nodoc:
+        def initialize(value)
+          @value = value.to_s
+        end
+
+        def to_s
+          @value
+        end
+        alias_method :to_str, :to_s
+
+        def hex
+          @value.unpack('H*')[0]
+        end
+
+        def ==(other)
+          other == to_s || super
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/boolean.rb

@@ -0,0 +1,31 @@
+module ActiveRecord
+  module Type
+    class Boolean < Value # :nodoc:
+      def type
+        :boolean
+      end
+
+      private
+
+      def cast_value(value)
+        if value == ''
+          nil
+        elsif ConnectionAdapters::Column::TRUE_VALUES.include?(value)
+          true
+        else
+          if !ConnectionAdapters::Column::FALSE_VALUES.include?(value)
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              You attempted to assign a value which is not explicitly `true` or `false`
+              (#{value.inspect})
+              to a boolean column. Currently this value casts to `false`. This will
+              change to match Ruby's semantics, and will cast to `true` in Rails 5.
+              If you would like to maintain the current behavior, you should
+              explicitly handle the values you would like cast to `false`.
+            MSG
+          end
+          false
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/date.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  module Type
+    class Date < Value # :nodoc:
+      def type
+        :date
+      end
+
+      def klass
+        ::Date
+      end
+
+      def type_cast_for_database(value)
+        type_cast(value)
+      end
+
+      def type_cast_for_schema(value)
+        "'#{value.to_s(:db)}'"
+      end
+
+      private
+
+      def cast_value(value)
+        if value.is_a?(::String)
+          return if value.empty?
+          fast_string_to_date(value) || fallback_string_to_date(value)
+        elsif value.respond_to?(:to_date)
+          value.to_date
+        else
+          value
+        end
+      end
+
+      def fast_string_to_date(string)
+        if string =~ ConnectionAdapters::Column::Format::ISO_DATE
+          new_date $1.to_i, $2.to_i, $3.to_i
+        end
+      end
+
+      def fallback_string_to_date(string)
+        new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+      end
+
+      def new_date(year, mon, mday)
+        if year && year != 0
+          ::Date.new(year, mon, mday) rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/date_time.rb

@@ -0,0 +1,54 @@
+module ActiveRecord
+  module Type
+    class DateTime < Value # :nodoc:
+      include TimeValue
+
+      def type
+        :datetime
+      end
+
+      def type_cast_for_database(value)
+        return super unless value.acts_like?(:time)
+
+        zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+
+        if value.respond_to?(zone_conversion_method)
+          value = value.send(zone_conversion_method)
+        end
+
+        return value unless has_precision?
+
+        result = value.to_s(:db)
+        if value.respond_to?(:usec) && (1..6).cover?(precision)
+          "#{result}.#{sprintf("%0#{precision}d", value.usec / 10 ** (6 - precision))}"
+        else
+          result
+        end
+      end
+
+      private
+
+      alias has_precision? precision
+
+      def cast_value(string)
+        return string unless string.is_a?(::String)
+        return if string.empty?
+
+        fast_string_to_time(string) || fallback_string_to_time(string)
+      end
+
+      # '0.123456' -> 123456
+      # '1.123456' -> 123456
+      def microseconds(time)
+        time[:sec_fraction] ? (time[:sec_fraction] * 1_000_000).to_i : 0
+      end
+
+      def fallback_string_to_time(string)
+        time_hash = ::Date._parse(string)
+        time_hash[:sec_fraction] = microseconds(time_hash)
+
+        new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
+      end
+    end
+  end
+end

data/lib/active_record/type/decimal.rb

@@ -0,0 +1,64 @@
+module ActiveRecord
+  module Type
+    class Decimal < Value # :nodoc:
+      include Numeric
+
+      def type
+        :decimal
+      end
+
+      def type_cast_for_schema(value)
+        value.to_s
+      end
+
+      private
+
+      def cast_value(value)
+        casted_value = case value
+        when ::Float
+          convert_float_to_big_decimal(value)
+        when ::Numeric
+          BigDecimal(value, precision.to_i)
+        when ::String
+          begin
+            value.to_d
+          rescue ArgumentError
+            BigDecimal(0)
+          end
+        else
+          if value.respond_to?(:to_d)
+            value.to_d
+          else
+            cast_value(value.to_s)
+          end
+        end
+
+        apply_scale(casted_value)
+      end
+
+      def convert_float_to_big_decimal(value)
+        if precision
+          BigDecimal(apply_scale(value), float_precision)
+        else
+          value.to_d
+        end
+      end
+
+      def float_precision
+        if precision.to_i > ::Float::DIG + 1
+          ::Float::DIG + 1
+        else
+          precision.to_i
+        end
+      end
+
+      def apply_scale(value)
+        if scale
+          value.round(scale)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/decimal_without_scale.rb

@@ -0,0 +1,11 @@
+require 'active_record/type/big_integer'
+
+module ActiveRecord
+  module Type
+    class DecimalWithoutScale < BigInteger # :nodoc:
+      def type
+        :decimal
+      end
+    end
+  end
+end

data/lib/active_record/type/decorator.rb

@@ -0,0 +1,14 @@
+module ActiveRecord
+  module Type
+    module Decorator # :nodoc:
+      def init_with(coder)
+        @subtype = coder['subtype']
+        __setobj__(@subtype)
+      end
+
+      def encode_with(coder)
+        coder['subtype'] = __getobj__
+      end
+    end
+  end
+end

data/lib/active_record/type/float.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module Type
+    class Float < Value # :nodoc:
+      include Numeric
+
+      def type
+        :float
+      end
+
+      alias type_cast_for_database type_cast
+
+      private
+
+      def cast_value(value)
+        value.to_f
+      end
+    end
+  end
+end