activerecord 4.2.11.1 → 6.0.3.5

data/lib/active_record/scoping/named.rb

@@ -1,6 +1,8 @@
-require 'active_support/core_ext/array'
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/kernel/singleton_class'
+# frozen_string_literal: true
+
+require "active_support/core_ext/array"
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/kernel/singleton_class"
 
 module ActiveRecord
   # = Active Record \Named \Scopes
@@ -9,7 +11,7 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       module ClassMethods
-        # Returns an <tt>ActiveRecord::Relation</tt> scope object.
+        # Returns an ActiveRecord::Relation scope object.
         #
         #   posts = Post.all
         #   posts.size # Fires "select count(*) from  posts" and returns the count
@@ -20,32 +22,57 @@ module ActiveRecord
         #   fruits = fruits.limit(10) if limited?
         #
         # You can define a scope that applies to all finders using
-        # <tt>ActiveRecord::Base.default_scope</tt>.
+        # {default_scope}[rdoc-ref:Scoping::Default::ClassMethods#default_scope].
         def all
-          if current_scope
-            current_scope.clone
+          scope = current_scope
+
+          if scope
+            if scope._deprecated_scope_source
+              ActiveSupport::Deprecation.warn(<<~MSG.squish)
+                Class level methods will no longer inherit scoping from `#{scope._deprecated_scope_source}`
+                in Rails 6.1. To continue using the scoped relation, pass it into the block directly.
+                To instead access the full set of models, as Rails 6.1 will, use `#{name}.default_scoped`.
+              MSG
+            end
+
+            if self == scope.klass
+              scope.clone
+            else
+              relation.merge!(scope)
+            end
           else
             default_scoped
           end
         end
 
-        def default_scoped # :nodoc:
-          relation.merge(build_default_scope)
+        def scope_for_association(scope = relation) # :nodoc:
+          if current_scope&.empty_scope?
+            scope
+          else
+            default_scoped(scope)
+          end
         end
 
-        # 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:
-          all.scope_for_create
+        # Returns a scope for the model with default scopes.
+        def default_scoped(scope = relation)
+          build_default_scope(scope) || scope
         end
 
-        # Are there default attributes associated with this scope?
-        def scope_attributes? # :nodoc:
-          current_scope || default_scopes.any?
+        def default_extensions # :nodoc:
+          if scope = scope_for_association || build_default_scope
+            scope.extensions
+          else
+            []
+          end
         end
 
-        # Adds a class method for retrieving and querying objects. A \scope
-        # represents a narrowing of a database query, such as
+        # Adds a class method for retrieving and querying objects.
+        # The method is intended to return an ActiveRecord::Relation
+        # object, which is composable with other scopes.
+        # If it returns +nil+ or +false+, an
+        # {all}[rdoc-ref:Scoping::Named::ClassMethods#all] scope is returned instead.
+        #
+        # A \scope represents a narrowing of a database query, such as
         # <tt>where(color: :red).select('shirts.*').includes(:washing_instructions)</tt>.
         #
         #   class Shirt < ActiveRecord::Base
@@ -53,12 +80,12 @@ module ActiveRecord
         #     scope :dry_clean_only, -> { joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true) }
         #   end
         #
-        # The above calls to +scope+ define class methods <tt>Shirt.red</tt> and
+        # The above calls to #scope define class methods <tt>Shirt.red</tt> and
         # <tt>Shirt.dry_clean_only</tt>. <tt>Shirt.red</tt>, in effect,
         # represents the query <tt>Shirt.where(color: 'red')</tt>.
         #
         # You should always pass a callable object to the scopes defined
-        # with +scope+. This ensures that the scope is re-evaluated each
+        # with #scope. This ensures that the scope is re-evaluated each
         # time it is called.
         #
         # Note that this is simply 'syntactic sugar' for defining an actual
@@ -71,14 +98,15 @@ module ActiveRecord
         #   end
         #
         # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by
-        # <tt>Shirt.red</tt> is not an Array; it resembles the association object
-        # constructed by a +has_many+ declaration. For instance, you can invoke
-        # <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>,
+        # <tt>Shirt.red</tt> is not an Array but an ActiveRecord::Relation,
+        # which is composable with other scopes; it resembles the association object
+        # constructed by a {has_many}[rdoc-ref:Associations::ClassMethods#has_many]
+        # declaration. For instance, you can invoke <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>,
         # <tt>Shirt.red.where(size: 'small')</tt>. Also, just as with the
         # association objects, named \scopes act like an Array, implementing
         # Enumerable; <tt>Shirt.red.each(&block)</tt>, <tt>Shirt.red.first</tt>,
         # and <tt>Shirt.red.inject(memo, &block)</tt> all behave as if
-        # <tt>Shirt.red</tt> really was an Array.
+        # <tt>Shirt.red</tt> really was an array.
         #
         # These named \scopes are composable. For instance,
         # <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are
@@ -89,7 +117,8 @@ module ActiveRecord
         #
         # All scopes are available as class methods on the ActiveRecord::Base
         # descendant upon which the \scopes were defined. But they are also
-        # available to +has_many+ associations. If,
+        # available to {has_many}[rdoc-ref:Associations::ClassMethods#has_many]
+        # associations. If,
         #
         #   class Person < ActiveRecord::Base
         #     has_many :shirts
@@ -98,8 +127,8 @@ module ActiveRecord
         # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of
         # Elton's red, dry clean only shirts.
         #
-        # \Named scopes can also have extensions, just as with +has_many+
-        # declarations:
+        # \Named scopes can also have extensions, just as with
+        # {has_many}[rdoc-ref:Associations::ClassMethods#has_many] declarations:
         #
         #   class Shirt < ActiveRecord::Base
         #     scope :red, -> { where(color: 'red') } do
@@ -140,7 +169,7 @@ module ActiveRecord
         #   Article.featured.titles
         def scope(name, body, &block)
           unless body.respond_to?(:call)
-            raise ArgumentError, 'The scope body needs to be callable.'
+            raise ArgumentError, "The scope body needs to be callable."
           end
 
           if dangerous_class_method?(name)
@@ -149,15 +178,39 @@ module ActiveRecord
               "a class method with the same name."
           end
 
-          extension = Module.new(&block) if block
+          if method_defined_within?(name, Relation)
+            raise ArgumentError, "You tried to define a scope named \"#{name}\" " \
+              "on the model \"#{self.name}\", but ActiveRecord::Relation already defined " \
+              "an instance method with the same name."
+          end
 
-          singleton_class.send(:define_method, name) do |*args|
-            scope = all.scoping { body.call(*args) }
-            scope = scope.extending(extension) if extension
+          valid_scope_name?(name)
+          extension = Module.new(&block) if block
 
-            scope || all
+          if body.respond_to?(:to_proc)
+            singleton_class.define_method(name) do |*args|
+              scope = all._exec_scope(name, *args, &body)
+              scope = scope.extending(extension) if extension
+              scope
+            end
+          else
+            singleton_class.define_method(name) do |*args|
+              scope = body.call(*args) || all
+              scope = scope.extending(extension) if extension
+              scope
+            end
           end
+
+          generate_relation_method(name)
         end
+
+        private
+          def valid_scope_name?(name)
+            if respond_to?(name, true) && logger
+              logger.warn "Creating scope :#{name}. " \
+                "Overwriting existing method #{self.name}.#{name}."
+            end
+          end
       end
     end
   end

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,25 +11,35 @@ module ActiveRecord
       include Named
     end
 
-    module ClassMethods
-      def current_scope #:nodoc:
-        ScopeRegistry.value_for(:current_scope, base_class.to_s)
+    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
+        all.scope_for_create
+      end
+
+      # Are there attributes associated with this scope?
+      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) #:nodoc:
-        ScopeRegistry.set_value_for(:current_scope, base_class.to_s, scope)
+      def current_scope=(scope)
+        ScopeRegistry.set_value_for(:current_scope, self, scope)
       end
     end
 
-    def populate_with_current_scope_attributes
+    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
+    def initialize_internals_callback # :nodoc:
       super
       populate_with_current_scope_attributes
     end
@@ -42,18 +54,18 @@ module ActiveRecord
     # following code:
     #
     #   registry = ActiveRecord::Scoping::ScopeRegistry
-    #   registry.set_value_for(:current_scope, "Board", some_new_scope)
+    #   registry.set_value_for(:current_scope, Board, some_new_scope)
     #
     # Now when you run:
     #
-    #   registry.value_for(:current_scope, "Board")
+    #   registry.value_for(:current_scope, Board)
     #
-    # You will obtain whatever was defined in +some_new_scope+. The +value_for+
-    # and +set_value_for+ methods are delegated to the current +ScopeRegistry+
+    # You will obtain whatever was defined in +some_new_scope+. The #value_for
+    # and #set_value_for methods are delegated to the current ScopeRegistry
     # object, so the above example code can also be called as:
     #
     #   ActiveRecord::Scoping::ScopeRegistry.set_value_for(:current_scope,
-    #       "Board", some_new_scope)
+    #       Board, some_new_scope)
     class ScopeRegistry # :nodoc:
       extend ActiveSupport::PerThreadRegistry
 
@@ -63,25 +75,31 @@ module ActiveRecord
         @registry = Hash.new { |hash, key| hash[key] = {} }
       end
 
-      # Obtains the value for a given +scope_name+ and +variable_name+.
-      def value_for(scope_type, variable_name)
+      # Obtains the value for a given +scope_type+ and +model+.
+      def value_for(scope_type, model, skip_inherited_scope = false)
         raise_invalid_scope_type!(scope_type)
-        @registry[scope_type][variable_name]
+        return @registry[scope_type][model.name] if skip_inherited_scope
+        klass = model
+        base = model.base_class
+        while klass <= base
+          value = @registry[scope_type][klass.name]
+          return value if value
+          klass = klass.superclass
+        end
       end
 
-      # Sets the +value+ for a given +scope_type+ and +variable_name+.
-      def set_value_for(scope_type, variable_name, value)
+      # Sets the +value+ for a given +scope_type+ and +model+.
+      def set_value_for(scope_type, model, value)
         raise_invalid_scope_type!(scope_type)
-        @registry[scope_type][variable_name] = value
+        @registry[scope_type][model.name] = value
       end
 
       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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module SecureToken
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Example using #has_secure_token
+      #
+      #   # Schema: User(token:string, auth_token:string)
+      #   class User < ActiveRecord::Base
+      #     has_secure_token
+      #     has_secure_token :auth_token
+      #   end
+      #
+      #   user = User.new
+      #   user.save
+      #   user.token # => "pX27zsMN2ViQKta1bGfLmVJE"
+      #   user.auth_token # => "77TMHrHJFvFDwodq8w7Ev2m7"
+      #   user.regenerate_token # => true
+      #   user.regenerate_auth_token # => true
+      #
+      # <tt>SecureRandom::base58</tt> is used to generate the 24-character unique token, so collisions are highly unlikely.
+      #
+      # Note that it's still possible to generate a race condition in the database in the same way that
+      # {validates_uniqueness_of}[rdoc-ref:Validations::ClassMethods#validates_uniqueness_of] can.
+      # 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"
+        define_method("regenerate_#{attribute}") { update! attribute => self.class.generate_unique_secure_token }
+        before_create { send("#{attribute}=", self.class.generate_unique_secure_token) unless send("#{attribute}?") }
+      end
+
+      def generate_unique_secure_token
+        SecureRandom.base58(24)
+      end
+    end
+  end
+end

data/lib/active_record/serialization.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module ActiveRecord #:nodoc:
-  # = Active Record Serialization
+  # = Active Record \Serialization
   module Serialization
     extend ActiveSupport::Concern
     include ActiveModel::Serializers::JSON
@@ -9,14 +11,12 @@ module ActiveRecord #:nodoc:
     end
 
     def serializable_hash(options = nil)
-      options = options.try(:clone) || {}
+      options = options.try(:dup) || {}
 
-      options[:except] = Array(options[:except]).map { |n| n.to_s }
+      options[:except] = Array(options[:except]).map(&:to_s)
       options[:except] |= Array(self.class.inheritance_column)
 
       super(options)
     end
   end
 end
-
-require 'active_record/serializers/xml_serializer'

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:
   #
@@ -7,12 +8,14 @@ module ActiveRecord
   #     Book.where(name: "my book").where("author_id > 3")
   #   end
   #
-  # The cached statement is executed by using the +execute+ method:
+  # The cached statement is executed by using the
+  # {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+ call the cached relation gets duped.
-  # Database is queried when +to_a+ is called on the relation.
+  # The relation returned by the block is cached, and for each
+  # {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
   # block parameter.
@@ -23,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:
 
@@ -38,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 = binds.dup
-        @indexes.each { |i| val[i] = connection.quote(*binds.shift.reverse) }
+        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:
@@ -67,45 +95,54 @@ module ActiveRecord
     end
 
     class BindMap # :nodoc:
-      def initialize(bind_values)
-        @indexes   = []
-        @bind_values = bind_values
+      def initialize(bound_attributes)
+        @indexes = []
+        @bound_attributes = bound_attributes
 
-        bind_values.each_with_index do |(_, value), i|
-          if Substitute === value
+        bound_attributes.each_with_index do |attr, i|
+          if Substitute === attr.value
             @indexes << i
           end
         end
       end
 
       def bind(values)
-        bvs = @bind_values.map { |pair| pair.dup }
-        @indexes.each_with_index { |offset,i| bvs[offset][1] = values[i] }
-        bvs
+        bas = @bound_attributes.dup
+        @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.bind_values
-      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)
+    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
+      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