activerecord 4.2.11.3 → 5.0.7.2

data/lib/active_record/scoping/named.rb

@@ -9,7 +9,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,7 +20,7 @@ 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
@@ -29,23 +29,35 @@ module ActiveRecord
           end
         end
 
-        def default_scoped # :nodoc:
-          relation.merge(build_default_scope)
+        def scope_for_association(scope = relation) # :nodoc:
+          current_scope = self.current_scope
+
+          if current_scope && 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
+        def default_scoped(scope = relation) # :nodoc:
+          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 = current_scope || 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 +65,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 +83,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 +102,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 +112,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
@@ -149,13 +163,32 @@ module ActiveRecord
               "a class method with the same name."
           end
 
+          valid_scope_name?(name)
           extension = Module.new(&block) if block
 
-          singleton_class.send(:define_method, name) do |*args|
-            scope = all.scoping { body.call(*args) }
-            scope = scope.extending(extension) if extension
+          if body.respond_to?(:to_proc)
+            singleton_class.send(:define_method, name) do |*args|
+              scope = all.scoping { instance_exec(*args, &body) }
+              scope = scope.extending(extension) if extension
+
+              scope || all
+            end
+          else
+            singleton_class.send(:define_method, name) do |*args|
+              scope = all.scoping { body.call(*args) }
+              scope = scope.extending(extension) if extension
+
+              scope || all
+            end
+          end
+        end
+
+      protected
 
-            scope || all
+        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

data/lib/active_record/secure_token.rb

@@ -0,0 +1,38 @@
+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 { self.send("#{attribute}=", self.class.generate_unique_secure_token) unless self.send("#{attribute}?")}
+      end
+
+      def generate_unique_secure_token
+        SecureRandom.base58(24)
+      end
+    end
+  end
+end

data/lib/active_record/serialization.rb

@@ -1,5 +1,5 @@
 module ActiveRecord #:nodoc:
-  # = Active Record Serialization
+  # = Active Record \Serialization
   module Serialization
     extend ActiveSupport::Concern
     include ActiveModel::Serializers::JSON
@@ -9,14 +9,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

@@ -7,12 +7,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)
   #
-  # 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.
@@ -47,8 +49,8 @@ module ActiveRecord
 
       def sql_for(binds, connection)
         val = @values.dup
-        binds = binds.dup
-        @indexes.each { |i| val[i] = connection.quote(*binds.shift.reverse) }
+        binds = connection.prepare_binds_for_database(binds)
+        @indexes.each { |i| val[i] = connection.quote(binds.shift) }
         val.join
       end
     end
@@ -67,21 +69,21 @@ module ActiveRecord
     end
 
     class BindMap # :nodoc:
-      def initialize(bind_values)
+      def initialize(bound_attributes)
         @indexes   = []
-        @bind_values = bind_values
+        @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
 
@@ -89,7 +91,7 @@ module ActiveRecord
 
     def self.create(connection, block = Proc.new)
       relation      = block.call Params.new
-      bind_map      = BindMap.new relation.bind_values
+      bind_map      = BindMap.new relation.bound_attributes
       query_builder = connection.cacheable_query relation.arel
       new query_builder, bind_map
     end
@@ -99,12 +101,12 @@ module ActiveRecord
       @bind_map      = bind_map
     end
 
-    def execute(params, klass, connection)
+    def execute(params, klass, 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)
     end
     alias :call :execute
   end

data/lib/active_record/store.rb

@@ -15,11 +15,16 @@ module ActiveRecord
   # 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+. Simply use +store_accessor+ instead to generate
+  # 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].
+  # 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.
   #
+  # NOTE: The default validations with the exception of +uniqueness+ will work.
+  # For example, if you want to check for +uniqueness+ with +hstore+ you will
+  # need to use a custom validation to handle it.
+  #
   # Examples:
   #
   #   class User < ActiveRecord::Base
@@ -39,7 +44,7 @@ module ActiveRecord
   #     store_accessor :settings, :privileges, :servants
   #   end
   #
-  # The stored attribute names can be retrieved using +stored_attributes+.
+  # The stored attribute names can be retrieved using {.stored_attributes}[rdoc-ref:rdoc-ref:ClassMethods#stored_attributes].
   #
   #   User.stored_attributes[:settings] # [:color, :homepage]
   #

data/lib/active_record/suppressor.rb

@@ -0,0 +1,58 @@
+module ActiveRecord
+  # ActiveRecord::Suppressor prevents the receiver from being saved during
+  # a given block.
+  #
+  # For example, here's a pattern of creating notifications when new comments
+  # are posted. (The notification may in turn trigger an email, a push
+  # notification, or just appear in the UI somewhere):
+  #
+  #   class Comment < ActiveRecord::Base
+  #     belongs_to :commentable, polymorphic: true
+  #     after_create -> { Notification.create! comment: self,
+  #       recipients: commentable.recipients }
+  #   end
+  #
+  # That's what you want the bulk of the time. New comment creates a new
+  # Notification. But there may well be off cases, like copying a commentable
+  # and its comments, where you don't want that. So you'd have a concern
+  # something like this:
+  #
+  #   module Copyable
+  #     def copy_to(destination)
+  #       Notification.suppress do
+  #         # Copy logic that creates new comments that we do not want
+  #         # triggering notifications.
+  #       end
+  #     end
+  #   end
+  module Suppressor
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def suppress(&block)
+        SuppressorRegistry.suppressed[name] = true
+        yield
+      ensure
+        SuppressorRegistry.suppressed[name] = false
+      end
+    end
+
+    def save(*) # :nodoc:
+      SuppressorRegistry.suppressed[self.class.name] ? true : super
+    end
+
+    def save!(*) # :nodoc:
+      SuppressorRegistry.suppressed[self.class.name] ? true : super
+    end
+  end
+
+  class SuppressorRegistry # :nodoc:
+    extend ActiveSupport::PerThreadRegistry
+
+    attr_reader :suppressed
+
+    def initialize
+      @suppressed = {}
+    end
+  end
+end

data/lib/active_record/table_metadata.rb

@@ -0,0 +1,69 @@
+module ActiveRecord
+  class TableMetadata # :nodoc:
+    delegate :foreign_type, :foreign_key, to: :association, prefix: true
+    delegate :association_primary_key, to: :association
+
+    def initialize(klass, arel_table, association = nil)
+      @klass = klass
+      @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)
+        end
+      end
+      new_hash
+    end
+
+    def arel_attribute(column_name)
+      if klass
+        klass.arel_attribute(column_name, arel_table)
+      else
+        arel_table[column_name]
+      end
+    end
+
+    def type(column_name)
+      if klass
+        klass.type_for_attribute(column_name.to_s)
+      else
+        Type::Value.new
+      end
+    end
+
+    def associated_with?(association_name)
+      klass && klass._reflect_on_association(association_name)
+    end
+
+    def associated_table(table_name)
+      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)
+      else
+        type_caster = TypeCaster::Connection.new(klass, table_name)
+        association_klass = nil
+        arel_table = Arel::Table.new(table_name, type_caster: type_caster)
+      end
+
+      TableMetadata.new(association_klass, arel_table, association)
+    end
+
+    def polymorphic_association?
+      association && association.polymorphic?
+    end
+
+    protected
+
+    attr_reader :klass, :arel_table, :association
+  end
+end