activerecord 5.0.7 → 5.1.7

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -8,20 +8,20 @@ module ActiveRecord
       end
 
       def create
-        raise DatabaseAlreadyExists if File.exist?(configuration['database'])
+        raise DatabaseAlreadyExists if File.exist?(configuration["database"])
 
         establish_connection configuration
         connection
       end
 
       def drop
-        require 'pathname'
-        path = Pathname.new configuration['database']
+        require "pathname"
+        path = Pathname.new configuration["database"]
         file = path.absolute? ? path.to_s : File.join(root, path)
 
         FileUtils.rm(file)
       rescue Errno::ENOENT => error
-        raise NoDatabaseError.new(error.message, error)
+        raise NoDatabaseError.new(error.message)
       end
 
       def purge
@@ -35,25 +35,27 @@ module ActiveRecord
         connection.encoding
       end
 
-      def structure_dump(filename)
-        dbfile = configuration['database']
-        `sqlite3 #{dbfile} .schema > #{filename}`
+      def structure_dump(filename, extra_flags)
+        dbfile = configuration["database"]
+        flags = extra_flags.join(" ") if extra_flags
+        `sqlite3 #{flags} #{dbfile} .schema > #{filename}`
       end
 
-      def structure_load(filename)
-        dbfile = configuration['database']
-        `sqlite3 #{dbfile} < "#{filename}"`
+      def structure_load(filename, extra_flags)
+        dbfile = configuration["database"]
+        flags = extra_flags.join(" ") if extra_flags
+        `sqlite3 #{flags} #{dbfile} < "#{filename}"`
       end
 
       private
 
-      def configuration
-        @configuration
-      end
+        def configuration
+          @configuration
+        end
 
-      def root
-        @root
-      end
+        def root
+          @root
+        end
     end
   end
 end

data/lib/active_record/timestamp.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveRecord
   # = Active Record \Timestamp
   #
@@ -51,15 +52,48 @@ module ActiveRecord
       clear_timestamp_attributes
     end
 
+    class_methods do
+      def touch_attributes_with_time(*names, time: nil)
+        attribute_names = timestamp_attributes_for_update_in_model
+        attribute_names |= names.map(&:to_s)
+        time ||= current_time_from_proper_timezone
+        attribute_names.each_with_object({}) { |attr_name, result| result[attr_name] = time }
+      end
+
+      private
+        def timestamp_attributes_for_create_in_model
+          timestamp_attributes_for_create.select { |c| column_names.include?(c) }
+        end
+
+        def timestamp_attributes_for_update_in_model
+          timestamp_attributes_for_update.select { |c| column_names.include?(c) }
+        end
+
+        def all_timestamp_attributes_in_model
+          timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model
+        end
+
+        def timestamp_attributes_for_create
+          ["created_at", "created_on"]
+        end
+
+        def timestamp_attributes_for_update
+          ["updated_at", "updated_on"]
+        end
+
+        def current_time_from_proper_timezone
+          default_timezone == :utc ? Time.now.utc : Time.now
+        end
+    end
+
   private
 
     def _create_record
-      if self.record_timestamps
+      if record_timestamps
         current_time = current_time_from_proper_timezone
 
-        all_timestamp_attributes.each do |column|
-          column = column.to_s
-          if has_attribute?(column) && !attribute_present?(column)
+        all_timestamp_attributes_in_model.each do |column|
+          if !attribute_present?(column)
             write_attribute(column, current_time)
           end
         end
@@ -73,8 +107,7 @@ module ActiveRecord
         current_time = current_time_from_proper_timezone
 
         timestamp_attributes_for_update_in_model.each do |column|
-          column = column.to_s
-          next if attribute_changed?(column)
+          next if will_save_change_to_attribute?(column)
           write_attribute(column, current_time)
         end
       end
@@ -82,34 +115,26 @@ module ActiveRecord
     end
 
     def should_record_timestamps?
-      self.record_timestamps && (!partial_writes? || changed?)
+      record_timestamps && (!partial_writes? || has_changes_to_save?)
     end
 
     def timestamp_attributes_for_create_in_model
-      timestamp_attributes_for_create.select { |c| self.class.column_names.include?(c.to_s) }
+      self.class.send(:timestamp_attributes_for_create_in_model)
     end
 
     def timestamp_attributes_for_update_in_model
-      timestamp_attributes_for_update.select { |c| self.class.column_names.include?(c.to_s) }
+      self.class.send(:timestamp_attributes_for_update_in_model)
     end
 
     def all_timestamp_attributes_in_model
-      timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model
+      self.class.send(:all_timestamp_attributes_in_model)
     end
 
-    def timestamp_attributes_for_update
-      [:updated_at, :updated_on]
-    end
-
-    def timestamp_attributes_for_create
-      [:created_at, :created_on]
-    end
-
-    def all_timestamp_attributes
-      timestamp_attributes_for_create + timestamp_attributes_for_update
+    def current_time_from_proper_timezone
+      self.class.send(:current_time_from_proper_timezone)
     end
 
-    def max_updated_column_timestamp(timestamp_names = timestamp_attributes_for_update)
+    def max_updated_column_timestamp(timestamp_names = self.class.send(:timestamp_attributes_for_update))
       timestamp_names
         .map { |attr| self[attr] }
         .compact
@@ -117,10 +142,6 @@ module ActiveRecord
         .max
     end
 
-    def current_time_from_proper_timezone
-      self.class.default_timezone == :utc ? Time.now.utc : Time.now
-    end
-
     # Clear attributes and changed_attributes
     def clear_timestamp_attributes
       all_timestamp_attributes_in_model.each do |attribute_name|

data/lib/active_record/touch_later.rb

@@ -25,7 +25,7 @@ module ActiveRecord
       # touch the parents as we are not calling the after_save callbacks
       self.class.reflect_on_all_associations(:belongs_to).each do |r|
         if touch = r.options[:touch]
-          ActiveRecord::Associations::Builder::BelongsTo.touch_record(self, r.foreign_key, r.name, touch, :touch_later)
+          ActiveRecord::Associations::Builder::BelongsTo.touch_record(self, changes_to_save, r.foreign_key, r.name, touch, :touch_later)
         end
       end
     end
@@ -58,6 +58,5 @@ module ActiveRecord
       def belongs_to_touch_method
         :touch_later
       end
-
   end
 end

data/lib/active_record/transactions.rb

@@ -11,7 +11,6 @@ module ActiveRecord
                        :before_commit_without_transaction_enrollment,
                        :commit_without_transaction_enrollment,
                        :rollback_without_transaction_enrollment,
-                       terminator: deprecated_false_terminator,
                        scope: [:kind, :name]
     end
 
@@ -189,8 +188,8 @@ module ActiveRecord
     #
     # === Caveats
     #
-    # If you're on MySQL, then do not use DDL operations in nested transactions
-    # blocks that are emulated with savepoints. That is, do not execute statements
+    # If you're on MySQL, then do not use Data Definition Language(DDL) operations in nested
+    # transactions blocks that are emulated with savepoints. That is, do not execute statements
     # like 'CREATE TABLE' inside such blocks. This is because MySQL automatically
     # releases all savepoints upon executing a DDL operation. When +transaction+
     # is finished and tries to release the savepoint it created earlier, a
@@ -274,35 +273,25 @@ module ActiveRecord
         set_callback(:rollback_without_transaction_enrollment, :after, *args, &block)
       end
 
-      def raise_in_transactional_callbacks
-        ActiveSupport::Deprecation.warn('ActiveRecord::Base.raise_in_transactional_callbacks is deprecated and will be removed without replacement.')
-        true
-      end
-
-      def raise_in_transactional_callbacks=(value)
-        ActiveSupport::Deprecation.warn('ActiveRecord::Base.raise_in_transactional_callbacks= is deprecated, has no effect and will be removed without replacement.')
-        value
-      end
-
       private
 
-      def set_options_for_callbacks!(args, enforced_options = {})
-        options = args.extract_options!.merge!(enforced_options)
-        args << options
+        def set_options_for_callbacks!(args, enforced_options = {})
+          options = args.extract_options!.merge!(enforced_options)
+          args << options
 
-        if 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})"
+          if options[:on]
+            fire_on = Array(options[:on])
+            assert_valid_transaction_action(fire_on)
+            options[:if] = Array(options[:if])
+            options[:if].unshift("transaction_include_any_action?(#{fire_on})")
+          end
         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}"
+        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
         end
-      end
     end
 
     # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
@@ -407,103 +396,102 @@ module ActiveRecord
       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[: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
+    private
 
-    # 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
-      force_clear_transaction_record_state if @_start_transaction_state[:level] < 1
-    end
+      # 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
+        @_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
 
-    # Force to clear the transaction record state.
-    def force_clear_transaction_record_state #:nodoc:
-      @_start_transaction_state.clear
-    end
+      # Clear the new record state and id of a record.
+      def clear_transaction_record_state
+        @_start_transaction_state[:level] = (@_start_transaction_state[:level] || 0) - 1
+        force_clear_transaction_record_state if @_start_transaction_state[:level] < 1
+      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:
-      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]
-          pk = self.class.primary_key
-          if pk && read_attribute(pk) != restore_state[:id]
-            write_attribute(pk, restore_state[:id])
+      # Force to clear the transaction record state.
+      def force_clear_transaction_record_state
+        @_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)
+        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]
+            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
-          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]
-    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)
+        @_start_transaction_state[state]
+      end
 
-    # Determine if a transaction included an action for :create, :update, or :destroy. Used in filtering callbacks.
-    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?)
+      # Determine if a transaction included an action for :create, :update, or :destroy. Used in filtering callbacks.
+      def transaction_include_any_action?(actions)
+        actions.any? do |action|
+          case action
+          when :create
+            transaction_record_state(:new_record)
+          when :destroy
+            defined?(@_trigger_destroy_callback) && @_trigger_destroy_callback
+          when :update
+            !(transaction_record_state(:new_record) || destroyed?) &&
+              (defined?(@_trigger_update_callback) && @_trigger_update_callback)
+          end
         end
       end
-    end
-
-    private
 
-    def set_transaction_state(state) # :nodoc:
-      @transaction_state = state
-    end
+      def set_transaction_state(state)
+        @transaction_state = state
+      end
 
-    def has_transactional_callbacks? # :nodoc:
-      !_rollback_callbacks.empty? || !_commit_callbacks.empty? || !_before_commit_callbacks.empty?
-    end
+      def has_transactional_callbacks?
+        !_rollback_callbacks.empty? || !_commit_callbacks.empty? || !_before_commit_callbacks.empty?
+      end
 
-    # Updates the attributes on this particular Active Record object so that
-    # if it's associated with a transaction, then the state of the Active Record
-    # object will be updated to reflect the current state of the transaction
-    #
-    # The +@transaction_state+ variable stores the states of the associated
-    # transaction. This relies on the fact that a transaction can only be in
-    # one rollback or commit (otherwise a list of states would be required)
-    # Each Active Record object inside of a transaction carries that transaction's
-    # TransactionState.
-    #
-    # This method checks to see if the ActiveRecord object's state reflects
-    # the TransactionState, and rolls back or commits the Active Record object
-    # as appropriate.
-    #
-    # Since Active Record objects can be inside multiple transactions, this
-    # method recursively goes through the parent of the TransactionState and
-    # checks if the Active Record object reflects the state of the object.
-    def sync_with_transaction_state
-      update_attributes_from_transaction_state(@transaction_state)
-    end
+      # Updates the attributes on this particular Active Record object so that
+      # if it's associated with a transaction, then the state of the Active Record
+      # object will be updated to reflect the current state of the transaction.
+      #
+      # The +@transaction_state+ variable stores the states of the associated
+      # transaction. This relies on the fact that a transaction can only be in
+      # one rollback or commit (otherwise a list of states would be required).
+      # Each Active Record object inside of a transaction carries that transaction's
+      # TransactionState.
+      #
+      # This method checks to see if the ActiveRecord object's state reflects
+      # the TransactionState, and rolls back or commits the Active Record object
+      # as appropriate.
+      #
+      # Since Active Record objects can be inside multiple transactions, this
+      # method recursively goes through the parent of the TransactionState and
+      # checks if the Active Record object reflects the state of the object.
+      def sync_with_transaction_state
+        update_attributes_from_transaction_state(@transaction_state)
+      end
 
-    def update_attributes_from_transaction_state(transaction_state)
-      if transaction_state && transaction_state.finalized?
-        restore_transaction_record_state if transaction_state.rolledback?
-        clear_transaction_record_state
+      def update_attributes_from_transaction_state(transaction_state)
+        if transaction_state && transaction_state.finalized?
+          restore_transaction_record_state if transaction_state.rolledback?
+          clear_transaction_record_state
+        end
       end
-    end
   end
 end

data/lib/active_record/type/adapter_specific_registry.rb

@@ -1,4 +1,4 @@
-require 'active_model/type/registry'
+require "active_model/type/registry"
 
 module ActiveRecord
   # :stopdoc:
@@ -10,15 +10,15 @@ module ActiveRecord
 
       private
 
-      def registration_klass
-        Registration
-      end
+        def registration_klass
+          Registration
+        end
 
-      def find_registration(symbol, *args)
-        registrations
-          .select { |registration| registration.matches?(symbol, *args) }
-          .max
-      end
+        def find_registration(symbol, *args)
+          registrations
+            .select { |registration| registration.matches?(symbol, *args) }
+            .max
+        end
     end
 
     class Registration
@@ -50,44 +50,46 @@ module ActiveRecord
         priority <=> other.priority
       end
 
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
-      attr_reader :name, :block, :adapter, :override
-
-      def priority
-        result = 0
-        if adapter
-          result |= 1
-        end
-        if override
-          result |= 2
+        attr_reader :name, :block, :adapter, :override
+
+        def priority
+          result = 0
+          if adapter
+            result |= 1
+          end
+          if override
+            result |= 2
+          end
+          result
         end
-        result
-      end
 
-      def priority_except_adapter
-        priority & 0b111111100
-      end
+        def priority_except_adapter
+          priority & 0b111111100
+        end
 
       private
 
-      def matches_adapter?(adapter: nil, **)
-        (self.adapter.nil? || adapter == self.adapter)
-      end
+        def matches_adapter?(adapter: nil, **)
+          (self.adapter.nil? || adapter == self.adapter)
+        end
 
-      def conflicts_with?(other)
-        same_priority_except_adapter?(other) &&
-          has_adapter_conflict?(other)
-      end
+        def conflicts_with?(other)
+          same_priority_except_adapter?(other) &&
+            has_adapter_conflict?(other)
+        end
 
-      def same_priority_except_adapter?(other)
-        priority_except_adapter == other.priority_except_adapter
-      end
+        def same_priority_except_adapter?(other)
+          priority_except_adapter == other.priority_except_adapter
+        end
 
-      def has_adapter_conflict?(other)
-        (override.nil? && other.adapter) ||
-          (adapter && other.override.nil?)
-      end
+        def has_adapter_conflict?(other)
+          (override.nil? && other.adapter) ||
+            (adapter && other.override.nil?)
+        end
     end
 
     class DecorationRegistration < Registration
@@ -110,17 +112,19 @@ module ActiveRecord
         super | 4
       end
 
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
-      attr_reader :options, :klass
+        attr_reader :options, :klass
 
       private
 
-      def matches_options?(**kwargs)
-        options.all? do |key, value|
-          kwargs[key] == value
+        def matches_options?(**kwargs)
+          options.all? do |key, value|
+            kwargs[key] == value
+          end
         end
-      end
     end
   end
 

data/lib/active_record/type/decimal_without_scale.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  module Type
+    class DecimalWithoutScale < ActiveModel::Type::BigInteger # :nodoc:
+      def type
+        :decimal
+      end
+
+      def type_cast_for_schema(value)
+        value.to_s.inspect
+      end
+    end
+  end
+end

data/lib/active_record/type/hash_lookup_type_map.rb

@@ -15,9 +15,9 @@ module ActiveRecord
 
       private
 
-      def perform_fetch(type, *args, &block)
-        @mapping.fetch(type, block).call(type, *args)
-      end
+        def perform_fetch(type, *args, &block)
+          @mapping.fetch(type, block).call(type, *args)
+        end
     end
   end
 end

data/lib/active_record/type/internal/abstract_json.rb

@@ -24,6 +24,10 @@ module ActiveRecord
           end
         end
 
+        def changed_in_place?(raw_old_value, new_value)
+          deserialize(raw_old_value) != new_value
+        end
+
         def accessor
           ActiveRecord::Store::StringKeyedHashAccessor
         end

data/lib/active_record/type/serialized.rb

@@ -1,6 +1,8 @@
 module ActiveRecord
   module Type
     class Serialized < DelegateClass(ActiveModel::Type::Value) # :nodoc:
+      undef to_yaml if method_defined?(:to_yaml)
+
       include ActiveModel::Type::Helpers::Mutable
 
       attr_reader :subtype, :coder
@@ -43,21 +45,25 @@ module ActiveRecord
 
       def assert_valid_value(value)
         if coder.respond_to?(:assert_valid_value)
-          coder.assert_valid_value(value)
+          coder.assert_valid_value(value, action: "serialize")
         end
       end
 
+      def force_equality?(value)
+        coder.respond_to?(:object_class) && value.is_a?(coder.object_class)
+      end
+
       private
 
-      def default_value?(value)
-        value == coder.load(nil)
-      end
+        def default_value?(value)
+          value == coder.load(nil)
+        end
 
-      def encoded(value)
-        unless default_value?(value)
-          coder.dump(value)
+        def encoded(value)
+          unless default_value?(value)
+            coder.dump(value)
+          end
         end
-      end
     end
   end
 end