activerecord 4.1.16 → 4.2.0.beta1

data/lib/active_record/timestamp.rb

@@ -1,4 +1,3 @@
-
 module ActiveRecord
   # = Active Record Timestamp
   #
@@ -48,8 +47,9 @@ module ActiveRecord
         current_time = current_time_from_proper_timezone
 
         all_timestamp_attributes.each do |column|
-          if respond_to?(column) && respond_to?("#{column}=") && self.send(column).nil?
-            write_attribute(column.to_s, current_time)
+          column = column.to_s
+          if has_attribute?(column) && !attribute_present?(column)
+            write_attribute(column, current_time)
           end
         end
       end
@@ -99,9 +99,11 @@ module ActiveRecord
     end
 
     def max_updated_column_timestamp(timestamp_names = timestamp_attributes_for_update)
-      if (timestamps = timestamp_names.map { |attr| self[attr] }.compact).present?
-        timestamps.map { |ts| ts.to_time }.max
-      end
+      timestamp_names
+        .map { |attr| self[attr] }
+        .compact
+        .map(&:to_time)
+        .max
     end
 
     def current_time_from_proper_timezone
@@ -112,7 +114,7 @@ module ActiveRecord
     def clear_timestamp_attributes
       all_timestamp_attributes_in_model.each do |attribute_name|
         self[attribute_name] = nil
-        changed_attributes.delete(attribute_name)
+        clear_attribute_changes([attribute_name])
       end
     end
   end

data/lib/active_record/transactions.rb

@@ -1,15 +1,25 @@
-require 'thread'
-
 module ActiveRecord
   # See ActiveRecord::Transactions::ClassMethods for documentation.
   module Transactions
     extend ActiveSupport::Concern
     ACTIONS = [:create, :destroy, :update]
+    CALLBACK_WARN_MESSAGE = <<-EOF
+Currently, Active Record will rescue any errors raised within
+after_rollback/after_commit callbacks and print them to the logs. In the next
+version, these errors will no longer be rescued. Instead, they will simply
+bubble just like other Active Record callbacks.
+
+You can opt into the new behavior and remove this warning by setting
+config.active_record.raise_in_transactional_callbacks to true.
+EOF
 
     included do
       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
@@ -225,6 +235,9 @@ module ActiveRecord
       def after_commit(*args, &block)
         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.
@@ -233,6 +246,9 @@ module ActiveRecord
       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
@@ -249,7 +265,7 @@ module ActiveRecord
 
       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}"
+          raise ArgumentError, ":on conditions for after_commit and after_rollback callbacks have to be one of #{ACTIONS.join(",")}"
         end
       end
     end
@@ -292,16 +308,16 @@ module ActiveRecord
     #
     # 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! #:nodoc:
-      run_callbacks :commit if destroyed? || persisted?
+    def committed!(should_run_callbacks = true) #:nodoc:
+      run_callbacks :commit if should_run_callbacks && destroyed? || persisted?
     ensure
-      @_start_transaction_state.clear
+      force_clear_transaction_record_state
     end
 
     # 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_callbacks :rollback if should_run_callbacks
     ensure
       restore_transaction_record_state(force_restore_state)
       clear_transaction_record_state
@@ -328,7 +344,7 @@ module ActiveRecord
         begin
           status = yield
         rescue ActiveRecord::Rollback
-          @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+          clear_transaction_record_state
           status = nil
         end
 
@@ -341,7 +357,7 @@ module ActiveRecord
 
     # 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[:id] = id if has_attribute?(self.class.primary_key)
+      @_start_transaction_state[:id] = id
       unless @_start_transaction_state.include?(:new_record)
         @_start_transaction_state[:new_record] = @new_record
       end
@@ -349,13 +365,18 @@ module ActiveRecord
         @_start_transaction_state[:destroyed] = @destroyed
       end
       @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) + 1
-      @_start_transaction_state[:frozen?] = @attributes.frozen?
+      @_start_transaction_state[:frozen?] = frozen?
     end
 
     # Clear the new record state and id of a record.
     def clear_transaction_record_state #:nodoc:
       @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
-      @_start_transaction_state.clear if @_start_transaction_state[:level] < 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.
@@ -364,17 +385,10 @@ module ActiveRecord
         transaction_level = (@_start_transaction_state[:level] || 0) - 1
         if transaction_level < 1 || force
           restore_state = @_start_transaction_state
-          was_frozen = restore_state[:frozen?]
-          @attributes = @attributes.dup if @attributes.frozen?
+          thaw unless restore_state[:frozen?]
           @new_record = restore_state[:new_record]
           @destroyed  = restore_state[:destroyed]
-          if restore_state.has_key?(:id)
-            write_attribute(self.class.primary_key, restore_state[:id])
-          else
-            @attributes.delete(self.class.primary_key)
-            @attributes_cache.delete(self.class.primary_key)
-          end
-          @attributes.freeze if was_frozen
+          write_attribute(self.class.primary_key, restore_state[:id])
         end
       end
     end

data/lib/active_record/type.rb

@@ -0,0 +1,20 @@
+require 'active_record/type/mutable'
+require 'active_record/type/numeric'
+require 'active_record/type/time_value'
+require 'active_record/type/value'
+
+require 'active_record/type/binary'
+require 'active_record/type/boolean'
+require 'active_record/type/date'
+require 'active_record/type/date_time'
+require 'active_record/type/decimal'
+require 'active_record/type/decimal_without_scale'
+require 'active_record/type/float'
+require 'active_record/type/integer'
+require 'active_record/type/serialized'
+require 'active_record/type/string'
+require 'active_record/type/text'
+require 'active_record/type/time'
+
+require 'active_record/type/type_map'
+require 'active_record/type/hash_lookup_type_map'

data/lib/active_record/type/binary.rb

@@ -0,0 +1,40 @@
+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
+
+      class Data # :nodoc:
+        def initialize(value)
+          @value = value.to_s
+        end
+
+        def to_s
+          @value
+        end
+
+        def hex
+          @value.unpack('H*')[0]
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/boolean.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module Type
+    class Boolean < Value # :nodoc:
+      def type
+        :boolean
+      end
+
+      private
+
+      def cast_value(value)
+        if value == ''
+          nil
+        else
+          ConnectionAdapters::Column::TRUE_VALUES.include?(value)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/date.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+  module Type
+    class Date < Value # :nodoc:
+      def type
+        :date
+      end
+
+      def klass
+        ::Date
+      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,43 @@
+module ActiveRecord
+  module Type
+    class DateTime < Value # :nodoc:
+      include TimeValue
+
+      def type
+        :datetime
+      end
+
+      def type_cast_for_database(value)
+        zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+
+        if value.acts_like?(:time)
+          value.send(zone_conversion_method)
+        else
+          super
+        end
+      end
+
+      private
+
+      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,40 @@
+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)
+        case value
+        when ::Float
+          BigDecimal(value, float_precision)
+        when ::Numeric, ::String
+          BigDecimal(value, precision.to_i)
+        else
+          if value.respond_to?(:to_d)
+            value.to_d
+          else
+            cast_value(value.to_s)
+          end
+        end
+      end
+
+      def float_precision
+        if precision.to_i > ::Float::DIG + 1
+          ::Float::DIG + 1
+        else
+          precision.to_i
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/decimal_without_scale.rb

@@ -0,0 +1,11 @@
+require 'active_record/type/integer'
+
+module ActiveRecord
+  module Type
+    class DecimalWithoutScale < Integer # :nodoc:
+      def type
+        :decimal
+      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

data/lib/active_record/type/hash_lookup_type_map.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module Type
+    class HashLookupTypeMap < TypeMap # :nodoc:
+      delegate :key?, to: :@mapping
+
+      def lookup(type, *args)
+        @mapping.fetch(type, proc { default_value }).call(type, *args)
+      end
+
+      def fetch(type, *args, &block)
+        @mapping.fetch(type, block).call(type, *args)
+      end
+
+      def alias_type(type, alias_type)
+        register_type(type) { |_, *args| lookup(alias_type, *args) }
+      end
+    end
+  end
+end

data/lib/active_record/type/integer.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module Type
+    class Integer < Value # :nodoc:
+      include Numeric
+
+      def type
+        :integer
+      end
+
+      alias type_cast_for_database type_cast
+
+      private
+
+      def cast_value(value)
+        case value
+        when true then 1
+        when false then 0
+        else value.to_i rescue nil
+        end
+      end
+    end
+  end
+end