activerecord 4.2.11.1 → 5.0.0

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
@@ -30,22 +30,22 @@ module ActiveRecord
         end
 
         def default_scoped # :nodoc:
-          relation.merge(build_default_scope)
-        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
-        end
+          scope = build_default_scope
 
-        # Are there default attributes associated with this scope?
-        def scope_attributes? # :nodoc:
-          current_scope || default_scopes.any?
+          if scope
+            relation.spawn.merge!(scope)
+          else
+            relation
+          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 +53,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 +71,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 +90,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 +100,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 +151,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.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
@@ -11,12 +11,10 @@ module ActiveRecord #:nodoc:
     def serializable_hash(options = nil)
       options = options.try(:clone) || {}
 
-      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
@@ -104,7 +106,7 @@ module ActiveRecord
 
       sql = query_builder.sql_for bind_values, connection
 
-      klass.find_by_sql sql, bind_values
+      klass.find_by_sql(sql, bind_values, preparable: true)
     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,68 @@
+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)
+      return self if table_name == arel_table.name
+
+      association = klass._reflect_on_association(table_name)
+      if 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

data/lib/active_record/tasks/database_tasks.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     class DatabaseAlreadyExists < StandardError; end # :nodoc:
     class DatabaseNotSupported < StandardError; end # :nodoc:
 
-    # <tt>ActiveRecord::Tasks::DatabaseTasks</tt> is a utility class, which encapsulates
+    # ActiveRecord::Tasks::DatabaseTasks is a utility class, which encapsulates
     # logic behind common tasks used to manage database and migrations.
     #
     # The tasks defined here are used with Rake tasks provided by Active Record.
@@ -18,15 +18,15 @@ module ActiveRecord
     #
     # The possible config values are:
     #
-    #   * +env+: current environment (like Rails.env).
-    #   * +database_configuration+: configuration of your databases (as in +config/database.yml+).
-    #   * +db_dir+: your +db+ directory.
-    #   * +fixtures_path+: a path to fixtures directory.
-    #   * +migrations_paths+: a list of paths to directories with migrations.
-    #   * +seed_loader+: an object which will load seeds, it needs to respond to the +load_seed+ method.
-    #   * +root+: a path to the root of the application.
+    # * +env+: current environment (like Rails.env).
+    # * +database_configuration+: configuration of your databases (as in +config/database.yml+).
+    # * +db_dir+: your +db+ directory.
+    # * +fixtures_path+: a path to fixtures directory.
+    # * +migrations_paths+: a list of paths to directories with migrations.
+    # * +seed_loader+: an object which will load seeds, it needs to respond to the +load_seed+ method.
+    # * +root+: a path to the root of the application.
     #
-    # Example usage of +DatabaseTasks+ outside Rails could look as such:
+    # Example usage of DatabaseTasks outside Rails could look as such:
     #
     #   include ActiveRecord::Tasks
     #   DatabaseTasks.database_configuration = YAML.load_file('my_database_config.yml')
@@ -42,6 +42,22 @@ module ActiveRecord
 
       LOCAL_HOSTS    = ['127.0.0.1', 'localhost']
 
+      def check_protected_environments!
+        unless ENV['DISABLE_DATABASE_ENVIRONMENT_CHECK']
+          current = ActiveRecord::Migrator.current_environment
+          stored  = ActiveRecord::Migrator.last_stored_environment
+
+          if ActiveRecord::Migrator.protected_environment?
+            raise ActiveRecord::ProtectedEnvironmentError.new(stored)
+          end
+
+          if stored && stored != current
+            raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
+          end
+        end
+      rescue ActiveRecord::NoDatabaseError
+      end
+
       def register_task(pattern, task)
         @tasks ||= {}
         @tasks[pattern] = task
@@ -91,15 +107,21 @@ module ActiveRecord
       def create(*arguments)
         configuration = arguments.first
         class_for_adapter(configuration['adapter']).new(*arguments).create
+        $stdout.puts "Created database '#{configuration['database']}'"
       rescue DatabaseAlreadyExists
-        $stderr.puts "#{configuration['database']} already exists"
+        $stderr.puts "Database '#{configuration['database']}' already exists"
       rescue Exception => error
-        $stderr.puts error, *(error.backtrace)
+        $stderr.puts error
         $stderr.puts "Couldn't create database for #{configuration.inspect}"
+        raise
       end
 
       def create_all
+        old_pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(ActiveRecord::Base.connection_specification_name)
         each_local_configuration { |configuration| create configuration }
+        if old_pool
+          ActiveRecord::Base.connection_handler.establish_connection(old_pool.spec)
+        end
       end
 
       def create_current(environment = env)
@@ -112,11 +134,13 @@ module ActiveRecord
       def drop(*arguments)
         configuration = arguments.first
         class_for_adapter(configuration['adapter']).new(*arguments).drop
+        $stdout.puts "Dropped database '#{configuration['database']}'"
       rescue ActiveRecord::NoDatabaseError
         $stderr.puts "Database '#{configuration['database']}' does not exist"
       rescue Exception => error
-        $stderr.puts error, *(error.backtrace)
-        $stderr.puts "Couldn't drop #{configuration['database']}"
+        $stderr.puts error
+        $stderr.puts "Couldn't drop database '#{configuration['database']}'"
+        raise
       end
 
       def drop_all
@@ -130,8 +154,6 @@ module ActiveRecord
       end
 
       def migrate
-        raise "Empty VERSION provided" if ENV["VERSION"] && ENV["VERSION"].empty?
-
         verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
         version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
         scope   = ENV['SCOPE']
@@ -191,27 +213,7 @@ module ActiveRecord
         class_for_adapter(configuration['adapter']).new(*arguments).structure_load(filename)
       end
 
-      def load_schema(format = ActiveRecord::Base.schema_format, file = nil)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          This method will act on a specific connection in the future.
-          To act on the current connection, use `load_schema_current` instead.
-        MSG
-
-        load_schema_current(format, file)
-      end
-
-      def schema_file(format = ActiveRecord::Base.schema_format)
-        case format
-        when :ruby
-          File.join(db_dir, "schema.rb")
-        when :sql
-          File.join(db_dir, "structure.sql")
-        end
-      end
-
-      # This method is the successor of +load_schema+. We should rename it
-      # after +load_schema+ went through a deprecation cycle. (Rails > 4.2)
-      def load_schema_for(configuration, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
+      def load_schema(configuration, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
         file ||= schema_file(format)
 
         case format
@@ -225,24 +227,37 @@ module ActiveRecord
         else
           raise ArgumentError, "unknown format #{format.inspect}"
         end
+        ActiveRecord::InternalMetadata.create_table
+        ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
       end
 
-      def load_schema_current_if_exists(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
-        if File.exist?(file || schema_file(format))
-          load_schema_current(format, file, environment)
+      def load_schema_for(*args)
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          This method was renamed to `#load_schema` and will be removed in the future.
+          Use `#load_schema` instead.
+        MSG
+        load_schema(*args)
+      end
+
+      def schema_file(format = ActiveRecord::Base.schema_format)
+        case format
+        when :ruby
+          File.join(db_dir, "schema.rb")
+        when :sql
+          File.join(db_dir, "structure.sql")
         end
       end
 
       def load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
         each_current_configuration(environment) { |configuration|
-          load_schema_for configuration, format, file
+          load_schema configuration, format, file
         }
         ActiveRecord::Base.establish_connection(environment.to_sym)
       end
 
       def check_schema_file(filename)
         unless File.exist?(filename)
-          message = %{#{filename} doesn't exist yet. Run `rake db:migrate` to create it, then try again.}
+          message = %{#{filename} doesn't exist yet. Run `rails db:migrate` to create it, then try again.}
           message << %{ If you do not intend to use a database, you should instead alter #{Rails.root}/config/application.rb to limit the frameworks that will be loaded.} if defined?(::Rails)
           Kernel.abort message
         end
@@ -270,8 +285,7 @@ module ActiveRecord
 
       def each_current_configuration(environment)
         environments = [environment]
-        # add test environment only if no RAILS_ENV was specified.
-        environments << 'test' if environment == 'development' && ENV['RAILS_ENV'].nil?
+        environments << 'test' if environment == 'development'
 
         configurations = ActiveRecord::Base.configurations.values_at(*environments)
         configurations.compact.each do |configuration|