activerecord 5.0.6 → 6.0.1

data/lib/active_record/scoping.rb

@@ -1,4 +1,6 @@
-require 'active_support/per_thread_registry'
+# frozen_string_literal: true
+
+require "active_support/per_thread_registry"
 
 module ActiveRecord
   module Scoping
@@ -9,33 +11,32 @@ module ActiveRecord
       include Named
     end
 
-    module ClassMethods
-      def current_scope(skip_inherited_scope = false) # :nodoc:
-        ScopeRegistry.value_for(:current_scope, self, skip_inherited_scope)
-      end
-
-      def current_scope=(scope) #:nodoc:
-        ScopeRegistry.set_value_for(:current_scope, self, scope)
-      end
-
+    module ClassMethods # :nodoc:
       # Collects attributes from scopes that should be applied when creating
       # an AR instance for the particular class this is called on.
-      def scope_attributes # :nodoc:
+      def scope_attributes
         all.scope_for_create
       end
 
       # Are there attributes associated with this scope?
-      def scope_attributes? # :nodoc:
+      def scope_attributes?
         current_scope
       end
+
+      def current_scope(skip_inherited_scope = false)
+        ScopeRegistry.value_for(:current_scope, self, skip_inherited_scope)
+      end
+
+      def current_scope=(scope)
+        ScopeRegistry.set_value_for(:current_scope, self, scope)
+      end
     end
 
     def populate_with_current_scope_attributes # :nodoc:
       return unless self.class.scope_attributes?
 
-      self.class.scope_attributes.each do |att,value|
-        send("#{att}=", value) if respond_to?("#{att}=")
-      end
+      attributes = self.class.scope_attributes
+      _assign_attributes(attributes) if attributes.any?
     end
 
     def initialize_internals_callback # :nodoc:
@@ -95,11 +96,11 @@ module ActiveRecord
 
       private
 
-      def raise_invalid_scope_type!(scope_type)
-        if !VALID_SCOPE_TYPES.include?(scope_type)
-          raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+        def raise_invalid_scope_type!(scope_type)
+          if !VALID_SCOPE_TYPES.include?(scope_type)
+            raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+          end
         end
-      end
     end
   end
 end

data/lib/active_record/secure_token.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module SecureToken
     extend ActiveSupport::Concern
@@ -25,9 +27,9 @@ module ActiveRecord
       # You're encouraged to add a unique index in the database to deal with this even more unlikely scenario.
       def has_secure_token(attribute = :token)
         # Load securerandom only when has_secure_token is used.
-        require 'active_support/core_ext/securerandom'
+        require "active_support/core_ext/securerandom"
         define_method("regenerate_#{attribute}") { update! attribute => self.class.generate_unique_secure_token }
-        before_create { self.send("#{attribute}=", self.class.generate_unique_secure_token) unless self.send("#{attribute}?")}
+        before_create { send("#{attribute}=", self.class.generate_unique_secure_token) unless send("#{attribute}?") }
       end
 
       def generate_unique_secure_token

data/lib/active_record/serialization.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord #:nodoc:
   # = Active Record \Serialization
   module Serialization

data/lib/active_record/statement_cache.rb

@@ -1,5 +1,6 @@
-module ActiveRecord
+# frozen_string_literal: true
 
+module ActiveRecord
   # Statement cache is used to cache a single statement in order to avoid creating the AST again.
   # Initializing the cache is done by passing the statement in the create block:
   #
@@ -8,12 +9,12 @@ module ActiveRecord
   #   end
   #
   # The cached statement is executed by using the
-  # [connection.execute]{rdoc-ref:ConnectionAdapters::DatabaseStatements#execute} method:
+  # {connection.execute}[rdoc-ref:ConnectionAdapters::DatabaseStatements#execute] method:
   #
-  #   cache.execute([], Book, Book.connection)
+  #   cache.execute([], Book.connection)
   #
   # The relation returned by the block is cached, and for each
-  # [execute]{rdoc-ref:ConnectionAdapters::DatabaseStatements#execute}
+  # {execute}[rdoc-ref:ConnectionAdapters::DatabaseStatements#execute]
   # call the cached relation gets duped. Database is queried when +to_a+ is called on the relation.
   #
   # If you want to cache the statement without the values you can use the +bind+ method of the
@@ -25,7 +26,7 @@ module ActiveRecord
   #
   # And pass the bind values as the first argument of +execute+ call.
   #
-  #   cache.execute(["my book"], Book, Book.connection)
+  #   cache.execute(["my book"], Book.connection)
   class StatementCache # :nodoc:
     class Substitute; end # :nodoc:
 
@@ -40,28 +41,53 @@ module ActiveRecord
     end
 
     class PartialQuery < Query # :nodoc:
-      def initialize values
+      def initialize(values)
         @values = values
-        @indexes = values.each_with_index.find_all { |thing,i|
-          Arel::Nodes::BindParam === thing
+        @indexes = values.each_with_index.find_all { |thing, i|
+          Substitute === thing
         }.map(&:last)
       end
 
       def sql_for(binds, connection)
         val = @values.dup
-        binds = connection.prepare_binds_for_database(binds)
-        @indexes.each { |i| val[i] = connection.quote(binds.shift) }
+        casted_binds = binds.map(&:value_for_database)
+        @indexes.each { |i| val[i] = connection.quote(casted_binds.shift) }
         val.join
       end
     end
 
-    def self.query(visitor, ast)
-      Query.new visitor.accept(ast, Arel::Collectors::SQLString.new).value
+    class PartialQueryCollector
+      def initialize
+        @parts = []
+        @binds = []
+      end
+
+      def <<(str)
+        @parts << str
+        self
+      end
+
+      def add_bind(obj)
+        @binds << obj
+        @parts << Substitute.new
+        self
+      end
+
+      def value
+        [@parts, @binds]
+      end
+    end
+
+    def self.query(sql)
+      Query.new(sql)
     end
 
-    def self.partial_query(visitor, ast, collector)
-      collected = visitor.accept(ast, collector).value
-      PartialQuery.new collected
+    def self.partial_query(values)
+      PartialQuery.new(values)
+    end
+
+    def self.partial_query_collector
+      PartialQueryCollector.new
     end
 
     class Params # :nodoc:
@@ -70,7 +96,7 @@ module ActiveRecord
 
     class BindMap # :nodoc:
       def initialize(bound_attributes)
-        @indexes   = []
+        @indexes = []
         @bound_attributes = bound_attributes
 
         bound_attributes.each_with_index do |attr, i|
@@ -82,32 +108,41 @@ module ActiveRecord
 
       def bind(values)
         bas = @bound_attributes.dup
-        @indexes.each_with_index { |offset,i| bas[offset] = bas[offset].with_cast_value(values[i]) }
+        @indexes.each_with_index { |offset, i| bas[offset] = bas[offset].with_cast_value(values[i]) }
         bas
       end
     end
 
-    attr_reader :bind_map, :query_builder
-
-    def self.create(connection, block = Proc.new)
-      relation      = block.call Params.new
-      bind_map      = BindMap.new relation.bound_attributes
-      query_builder = connection.cacheable_query relation.arel
-      new query_builder, bind_map
+    def self.create(connection, callable = nil, &block)
+      relation = (callable || block).call Params.new
+      query_builder, binds = connection.cacheable_query(self, relation.arel)
+      bind_map = BindMap.new(binds)
+      new(query_builder, bind_map, relation.klass)
     end
 
-    def initialize(query_builder, bind_map)
+    def initialize(query_builder, bind_map, klass)
       @query_builder = query_builder
-      @bind_map      = bind_map
+      @bind_map = bind_map
+      @klass = klass
     end
 
-    def execute(params, klass, connection, &block)
+    def execute(params, connection, &block)
       bind_values = bind_map.bind params
 
       sql = query_builder.sql_for bind_values, connection
 
       klass.find_by_sql(sql, bind_values, preparable: true, &block)
+    rescue ::RangeError
+      nil
     end
-    alias :call :execute
+
+    def self.unsupported_value?(value)
+      case value
+      when NilClass, Array, Range, Hash, Relation, Base then true
+      end
+    end
+
+    private
+      attr_reader :query_builder, :bind_map, :klass
   end
 end

data/lib/active_record/store.rb

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/hash/indifferent_access'
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveRecord
   # Store gives you a thin wrapper around serialize for the purpose of storing hashes in a single column.
@@ -9,14 +11,20 @@ module ActiveRecord
   # of the model. This is very helpful for easily exposing store keys to a form or elsewhere that's
   # already built around just accessing attributes on the model.
   #
+  # Every accessor comes with dirty tracking methods (+key_changed?+, +key_was+ and +key_change+) and
+  # methods to access the changes made during the last save (+saved_change_to_key?+, +saved_change_to_key+ and
+  # +key_before_last_save+).
+  #
+  # NOTE: There is no +key_will_change!+ method for accessors, use +store_will_change!+ instead.
+  #
   # Make sure that you declare the database column used for the serialized store as a text, so there's
   # plenty of room.
   #
   # You can set custom coder to encode/decode your serialized attributes to/from different formats.
   # JSON, YAML, Marshal are supported out of the box. Generally it can be any wrapper that provides +load+ and +dump+.
   #
-  # NOTE: If you are using PostgreSQL specific columns like +hstore+ or +json+ there is no need for
-  # the serialization provided by {.store}[rdoc-ref:rdoc-ref:ClassMethods#store].
+  # NOTE: If you are using structured database data types (eg. PostgreSQL +hstore+/+json+, or MySQL 5.7+
+  # +json+) there is no need for the serialization provided by {.store}[rdoc-ref:rdoc-ref:ClassMethods#store].
   # Simply use {.store_accessor}[rdoc-ref:ClassMethods#store_accessor] instead to generate
   # the accessor methods. Be aware that these columns use a string keyed hash and do not allow access
   # using a symbol.
@@ -29,24 +37,40 @@ module ActiveRecord
   #
   #   class User < ActiveRecord::Base
   #     store :settings, accessors: [ :color, :homepage ], coder: JSON
+  #     store :parent, accessors: [ :name ], coder: JSON, prefix: true
+  #     store :spouse, accessors: [ :name ], coder: JSON, prefix: :partner
+  #     store :settings, accessors: [ :two_factor_auth ], suffix: true
+  #     store :settings, accessors: [ :login_retry ], suffix: :config
   #   end
   #
-  #   u = User.new(color: 'black', homepage: '37signals.com')
+  #   u = User.new(color: 'black', homepage: '37signals.com', parent_name: 'Mary', partner_name: 'Lily')
   #   u.color                          # Accessor stored attribute
+  #   u.parent_name                    # Accessor stored attribute with prefix
+  #   u.partner_name                   # Accessor stored attribute with custom prefix
+  #   u.two_factor_auth_settings       # Accessor stored attribute with suffix
+  #   u.login_retry_config             # Accessor stored attribute with custom suffix
   #   u.settings[:country] = 'Denmark' # Any attribute, even if not specified with an accessor
   #
   #   # There is no difference between strings and symbols for accessing custom attributes
   #   u.settings[:country]  # => 'Denmark'
   #   u.settings['country'] # => 'Denmark'
   #
+  #   # Dirty tracking
+  #   u.color = 'green'
+  #   u.color_changed? # => true
+  #   u.color_was # => 'black'
+  #   u.color_change # => ['black', 'red']
+  #
   #   # Add additional accessors to an existing store through store_accessor
   #   class SuperUser < User
   #     store_accessor :settings, :privileges, :servants
+  #     store_accessor :parent, :birthday, prefix: true
+  #     store_accessor :settings, :secret_question, suffix: :config
   #   end
   #
   # The stored attribute names can be retrieved using {.stored_attributes}[rdoc-ref:rdoc-ref:ClassMethods#stored_attributes].
   #
-  #   User.stored_attributes[:settings] # [:color, :homepage]
+  #   User.stored_attributes[:settings] # [:color, :homepage, :two_factor_auth, :login_retry]
   #
   # == Overwriting default accessors
   #
@@ -78,22 +102,79 @@ module ActiveRecord
 
     module ClassMethods
       def store(store_attribute, options = {})
-        serialize store_attribute, IndifferentCoder.new(options[:coder])
-        store_accessor(store_attribute, options[:accessors]) if options.has_key? :accessors
+        serialize store_attribute, IndifferentCoder.new(store_attribute, options[:coder])
+        store_accessor(store_attribute, options[:accessors], options.slice(:prefix, :suffix)) if options.has_key? :accessors
       end
 
-      def store_accessor(store_attribute, *keys)
+      def store_accessor(store_attribute, *keys, prefix: nil, suffix: nil)
         keys = keys.flatten
 
+        accessor_prefix =
+          case prefix
+          when String, Symbol
+            "#{prefix}_"
+          when TrueClass
+            "#{store_attribute}_"
+          else
+            ""
+          end
+        accessor_suffix =
+          case suffix
+          when String, Symbol
+            "_#{suffix}"
+          when TrueClass
+            "_#{store_attribute}"
+          else
+            ""
+          end
+
         _store_accessors_module.module_eval do
           keys.each do |key|
-            define_method("#{key}=") do |value|
+            accessor_key = "#{accessor_prefix}#{key}#{accessor_suffix}"
+
+            define_method("#{accessor_key}=") do |value|
               write_store_attribute(store_attribute, key, value)
             end
 
-            define_method(key) do
+            define_method(accessor_key) do
               read_store_attribute(store_attribute, key)
             end
+
+            define_method("#{accessor_key}_changed?") do
+              return false unless attribute_changed?(store_attribute)
+              prev_store, new_store = changes[store_attribute]
+              prev_store&.dig(key) != new_store&.dig(key)
+            end
+
+            define_method("#{accessor_key}_change") do
+              return unless attribute_changed?(store_attribute)
+              prev_store, new_store = changes[store_attribute]
+              [prev_store&.dig(key), new_store&.dig(key)]
+            end
+
+            define_method("#{accessor_key}_was") do
+              return unless attribute_changed?(store_attribute)
+              prev_store, _new_store = changes[store_attribute]
+              prev_store&.dig(key)
+            end
+
+            define_method("saved_change_to_#{accessor_key}?") do
+              return false unless saved_change_to_attribute?(store_attribute)
+              prev_store, new_store = saved_change_to_attribute(store_attribute)
+              prev_store&.dig(key) != new_store&.dig(key)
+            end
+
+            define_method("saved_change_to_#{accessor_key}") do
+              return unless saved_change_to_attribute?(store_attribute)
+              prev_store, new_store = saved_change_to_attribute(store_attribute)
+              [prev_store&.dig(key), new_store&.dig(key)]
+            end
+
+            define_method("#{accessor_key}_before_last_save") do
+              return unless saved_change_to_attribute?(store_attribute)
+              prev_store, _new_store = saved_change_to_attribute(store_attribute)
+              prev_store&.dig(key)
+            end
           end
         end
 
@@ -114,27 +195,26 @@ module ActiveRecord
 
       def stored_attributes
         parent = superclass.respond_to?(:stored_attributes) ? superclass.stored_attributes : {}
-        if self.local_stored_attributes
-          parent.merge!(self.local_stored_attributes) { |k, a, b| a | b }
+        if local_stored_attributes
+          parent.merge!(local_stored_attributes) { |k, a, b| a | b }
         end
         parent
       end
     end
 
-    protected
-      def read_store_attribute(store_attribute, key)
+    private
+      def read_store_attribute(store_attribute, key) # :doc:
         accessor = store_accessor_for(store_attribute)
         accessor.read(self, store_attribute, key)
       end
 
-      def write_store_attribute(store_attribute, key, value)
+      def write_store_attribute(store_attribute, key, value) # :doc:
         accessor = store_accessor_for(store_attribute)
         accessor.write(self, store_attribute, key, value)
       end
 
-    private
       def store_accessor_for(store_attribute)
-        type_for_attribute(store_attribute.to_s).accessor
+        type_for_attribute(store_attribute).accessor
       end
 
       class HashAccessor # :nodoc:
@@ -177,34 +257,34 @@ module ActiveRecord
         end
       end
 
-    class IndifferentCoder # :nodoc:
-      def initialize(coder_or_class_name)
-        @coder =
-          if coder_or_class_name.respond_to?(:load) && coder_or_class_name.respond_to?(:dump)
-            coder_or_class_name
-          else
-            ActiveRecord::Coders::YAMLColumn.new(coder_or_class_name || Object)
-          end
-      end
+      class IndifferentCoder # :nodoc:
+        def initialize(attr_name, coder_or_class_name)
+          @coder =
+            if coder_or_class_name.respond_to?(:load) && coder_or_class_name.respond_to?(:dump)
+              coder_or_class_name
+            else
+              ActiveRecord::Coders::YAMLColumn.new(attr_name, coder_or_class_name || Object)
+            end
+        end
 
-      def dump(obj)
-        @coder.dump self.class.as_indifferent_hash(obj)
-      end
+        def dump(obj)
+          @coder.dump self.class.as_indifferent_hash(obj)
+        end
 
-      def load(yaml)
-        self.class.as_indifferent_hash(@coder.load(yaml || ''))
-      end
+        def load(yaml)
+          self.class.as_indifferent_hash(@coder.load(yaml || ""))
+        end
 
-      def self.as_indifferent_hash(obj)
-        case obj
-        when ActiveSupport::HashWithIndifferentAccess
-          obj
-        when Hash
-          obj.with_indifferent_access
-        else
-          ActiveSupport::HashWithIndifferentAccess.new
+        def self.as_indifferent_hash(obj)
+          case obj
+          when ActiveSupport::HashWithIndifferentAccess
+            obj
+          when Hash
+            obj.with_indifferent_access
+          else
+            ActiveSupport::HashWithIndifferentAccess.new
+          end
         end
       end
-    end
   end
 end

data/lib/active_record/suppressor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # ActiveRecord::Suppressor prevents the receiver from being saved during
   # a given block.
@@ -30,10 +32,11 @@ module ActiveRecord
 
     module ClassMethods
       def suppress(&block)
+        previous_state = SuppressorRegistry.suppressed[name]
         SuppressorRegistry.suppressed[name] = true
         yield
       ensure
-        SuppressorRegistry.suppressed[name] = false
+        SuppressorRegistry.suppressed[name] = previous_state
       end
     end
 

data/lib/active_record/table_metadata.rb

@@ -1,21 +1,21 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class TableMetadata # :nodoc:
-    delegate :foreign_type, :foreign_key, to: :association, prefix: true
-    delegate :association_primary_key, to: :association
+    delegate :foreign_type, :foreign_key, :join_primary_key, :join_foreign_key, to: :association, prefix: true
 
-    def initialize(klass, arel_table, association = nil)
+    def initialize(klass, arel_table, association = nil, types = klass)
       @klass = klass
+      @types = types
       @arel_table = arel_table
       @association = association
     end
 
     def resolve_column_aliases(hash)
-      # This method is a hot spot, so for now, use Hash[] to dup the hash.
-      #   https://bugs.ruby-lang.org/issues/7166
-      new_hash = Hash[hash]
-      hash.each do |key, _|
-        if (key.is_a?(Symbol)) && klass.attribute_alias?(key)
-          new_hash[klass.attribute_alias(key)] = new_hash.delete(key)
+      new_hash = hash.dup
+      hash.each_key do |key|
+        if key.is_a?(Symbol) && new_key = klass.attribute_aliases[key.to_s]
+          new_hash[new_key] = new_hash.delete(key)
         end
       end
       new_hash
@@ -30,11 +30,11 @@ module ActiveRecord
     end
 
     def type(column_name)
-      if klass
-        klass.type_for_attribute(column_name.to_s)
-      else
-        Type::Value.new
-      end
+      types.type_for_attribute(column_name)
+    end
+
+    def has_column?(column_name)
+      klass && klass.columns_hash.key?(column_name.to_s)
     end
 
     def associated_with?(association_name)
@@ -42,28 +42,34 @@ module ActiveRecord
     end
 
     def associated_table(table_name)
-      association = klass._reflect_on_association(table_name) || klass._reflect_on_association(table_name.singularize)
+      association = klass._reflect_on_association(table_name) || klass._reflect_on_association(table_name.to_s.singularize)
 
       if !association && table_name == arel_table.name
         return self
       elsif association && !association.polymorphic?
         association_klass = association.klass
         arel_table = association_klass.arel_table.alias(table_name)
+        TableMetadata.new(association_klass, arel_table, association)
       else
         type_caster = TypeCaster::Connection.new(klass, table_name)
-        association_klass = nil
         arel_table = Arel::Table.new(table_name, type_caster: type_caster)
+        TableMetadata.new(nil, arel_table, association, type_caster)
       end
-
-      TableMetadata.new(association_klass, arel_table, association)
     end
 
     def polymorphic_association?
       association && association.polymorphic?
     end
 
-    protected
+    def aggregated_with?(aggregation_name)
+      klass && reflect_on_aggregation(aggregation_name)
+    end
+
+    def reflect_on_aggregation(aggregation_name)
+      klass.reflect_on_aggregation(aggregation_name)
+    end
 
-    attr_reader :klass, :arel_table, :association
+    private
+      attr_reader :klass, :types, :arel_table, :association
   end
 end