activerecord 5.0.0.beta1.1 → 5.0.0.beta2

data/lib/active_record/migration/compatibility.rb

@@ -5,6 +5,12 @@ module ActiveRecord
 
       module FourTwoShared
         module TableDefinition
+          def references(*, **options)
+            options[:index] ||= false
+            super
+          end
+          alias :belongs_to :references
+
           def timestamps(*, **options)
             options[:null] = true if options[:null].nil?
             super
@@ -24,6 +30,25 @@ module ActiveRecord
           end
         end
 
+        def change_table(table_name, options = {})
+          if block_given?
+            super(table_name, options) do |t|
+              class << t
+                prepend TableDefinition
+              end
+              yield t
+            end
+          else
+            super
+          end
+        end
+
+        def add_reference(*, **options)
+          options[:index] ||= false
+          super
+        end
+        alias :add_belongs_to :add_reference
+
         def add_timestamps(*, **options)
           options[:null] = true if options[:null].nil?
           super
@@ -41,8 +66,9 @@ module ActiveRecord
         end
 
         def remove_index(table_name, options = {})
-          index_name = index_name_for_remove(table_name, options)
-          execute "DROP INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
+          options = { column: options } unless options.is_a?(Hash)
+          options[:name] = index_name_for_remove(table_name, options)
+          super(table_name, options)
         end
 
         private

data/lib/active_record/model_schema.rb

@@ -42,6 +42,19 @@ module ActiveRecord
       class_attribute :schema_migrations_table_name, instance_accessor: false
       self.schema_migrations_table_name = "schema_migrations"
 
+      ##
+      # :singleton-method:
+      # Accessor for the name of the internal metadata table. By default, the value is "ar_internal_metadata"
+      class_attribute :internal_metadata_table_name, instance_accessor: false
+      self.internal_metadata_table_name = "ar_internal_metadata"
+
+      ##
+      # :singleton-method:
+      # Accessor for an array of names of environments where destructive actions should be prohibited. By default,
+      # the value is ["production"]
+      class_attribute :protected_environments, instance_accessor: false
+      self.protected_environments = ["production"]
+
       ##
       # :singleton-method:
       # Indicates whether table names should be the pluralized versions of the corresponding class names.
@@ -242,7 +255,18 @@ module ActiveRecord
         @attribute_types ||= Hash.new(Type::Value.new)
       end
 
-      def type_for_attribute(attr_name) # :nodoc:
+      # Returns the type of the attribute with the given name, after applying
+      # all modifiers. This method is the only valid source of information for
+      # anything related to the types of a model's attributes. This method will
+      # access the database and load the model's schema if it is required.
+      #
+      # The return value of this method will implement the interface described
+      # by ActiveModel::Type::Value (though the object itself may not subclass
+      # it).
+      #
+      # +attr_name+ The name of the attribute to retrieve the type for. Must be
+      # a string
+      def type_for_attribute(attr_name)
         attribute_types[attr_name]
       end
 

data/lib/active_record/persistence.rb

@@ -102,11 +102,11 @@ module ActiveRecord
 
     # Saves the model.
     #
-    # If the model is new a record gets created in the database, otherwise
+    # If the model is new, a record gets created in the database, otherwise
     # the existing record gets updated.
     #
-    # By default, save always run validations. If any of them fail the action
-    # is cancelled and #save returns +false+. However, if you supply
+    # By default, save always runs validations. If any of them fail the action
+    # is cancelled and #save returns +false+, and the record won't be saved. However, if you supply
     # validate: false, validations are bypassed altogether. See
     # ActiveRecord::Validations for more information.
     #
@@ -132,9 +132,10 @@ module ActiveRecord
     # If the model is new, a record gets created in the database, otherwise
     # the existing record gets updated.
     #
-    # With #save! validations always run. If any of them fail
-    # ActiveRecord::RecordInvalid gets raised. See ActiveRecord::Validations
-    # for more information.
+    # By default, #save! always runs validations. If any of them fail
+    # ActiveRecord::RecordInvalid gets raised, and the record won't be saved. However, if you supply
+    # validate: false, validations are bypassed altogether. See
+    # ActiveRecord::Validations for more information.
     #
     # By default, #save! also sets the +updated_at+/+updated_on+ attributes to
     # the current time. However, if you supply <tt>touch: false</tt>, these
@@ -246,7 +247,7 @@ module ActiveRecord
     # This method raises an ActiveRecord::ActiveRecordError  if the
     # attribute is marked as readonly.
     #
-    # See also #update_column.
+    # Also see #update_column.
     def update_attribute(name, value)
       name = name.to_s
       verify_readonly_attribute(name)
@@ -269,7 +270,7 @@ module ActiveRecord
     alias update_attributes update
 
     # Updates its receiver just like #update but calls #save! instead
-    # of +save+, so an exception is raised if the record is invalid.
+    # of +save+, so an exception is raised if the record is invalid and saving will fail.
     def update!(attributes)
       # The following transaction covers any possible database side-effects of the
       # attributes assignment. For example, setting the IDs of a child collection.
@@ -348,7 +349,7 @@ module ActiveRecord
     end
 
     # Wrapper around #decrement that saves the record. This method differs from
-    # its non-bang version in that it passes through the attribute setter.
+    # its non-bang version in the sense that it passes through the attribute setter.
     # Saving is not subjected to validation checks. Returns +true+ if the
     # record could be saved.
     def decrement!(attribute, by = 1)
@@ -373,7 +374,7 @@ module ActiveRecord
     end
 
     # Wrapper around #toggle that saves the record. This method differs from
-    # its non-bang version in that it passes through the attribute setter.
+    # its non-bang version in the sense that it passes through the attribute setter.
     # Saving is not subjected to validation checks. Returns +true+ if the
     # record could be saved.
     def toggle!(attribute)

data/lib/active_record/railtie.rb

@@ -40,7 +40,7 @@ module ActiveRecord
         task :load_config do
           ActiveRecord::Tasks::DatabaseTasks.database_configuration = Rails.application.config.database_configuration
 
-          if defined?(ENGINE_PATH) && engine = Rails::Engine.find(ENGINE_PATH)
+          if defined?(ENGINE_ROOT) && engine = Rails::Engine.find(ENGINE_ROOT)
             if engine.paths['db/migrate'].existent
               ActiveRecord::Tasks::DatabaseTasks.migrations_paths += engine.paths['db/migrate'].to_a
             end
@@ -57,8 +57,10 @@ module ActiveRecord
     console do |app|
       require "active_record/railties/console_sandbox" if app.sandbox?
       require "active_record/base"
-      console = ActiveSupport::Logger.new(STDERR)
-      Rails.logger.extend ActiveSupport::Logger.broadcast console
+      unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDERR, STDOUT)
+        console = ActiveSupport::Logger.new(STDERR)
+        Rails.logger.extend ActiveSupport::Logger.broadcast console
+      end
     end
 
     runner do
@@ -69,6 +71,7 @@ module ActiveRecord
       ActiveSupport.on_load(:active_record) do
         self.time_zone_aware_attributes = true
         self.default_timezone = :utc
+        self.time_zone_aware_types = ActiveRecord::Base.time_zone_aware_types
       end
     end
 

data/lib/active_record/railties/databases.rake

@@ -1,6 +1,16 @@
 require 'active_record'
 
 db_namespace = namespace :db do
+  desc "Set the environment value for the database"
+  task "environment:set" => [:environment, :load_config] do
+    ActiveRecord::InternalMetadata.create_table
+    ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
+  end
+
+  task :check_protected_environments => [:environment, :load_config] do
+    ActiveRecord::Tasks::DatabaseTasks.check_protected_environments!
+  end
+
   task :load_config do
     ActiveRecord::Base.configurations       = ActiveRecord::Tasks::DatabaseTasks.database_configuration || {}
     ActiveRecord::Migrator.migrations_paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
@@ -18,24 +28,28 @@ db_namespace = namespace :db do
   end
 
   namespace :drop do
-    task :all => :load_config do
+    task :all => [:load_config, :check_protected_environments] do
       ActiveRecord::Tasks::DatabaseTasks.drop_all
     end
   end
 
   desc 'Drops the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:drop:all to drop all databases in the config). Without RAILS_ENV, it defaults to dropping the development and test databases.'
-  task :drop => [:load_config] do
+  task :drop => [:load_config, :check_protected_environments] do
+    db_namespace["drop:_unsafe"].invoke
+  end
+
+  task "drop:_unsafe" => [:load_config] do
     ActiveRecord::Tasks::DatabaseTasks.drop_current
   end
 
   namespace :purge do
-    task :all => :load_config do
+    task :all => [:load_config, :check_protected_environments] do
       ActiveRecord::Tasks::DatabaseTasks.purge_all
     end
   end
 
   # desc "Empty the database from DATABASE_URL or config/database.yml for the current RAILS_ENV (use db:purge:all to purge all databases in the config). Without RAILS_ENV it defaults to purging the development and test databases."
-  task :purge => [:load_config] do
+  task :purge => [:load_config, :check_protected_environments] do
     ActiveRecord::Tasks::DatabaseTasks.purge_current
   end
 
@@ -288,7 +302,7 @@ db_namespace = namespace :db do
     end
 
     desc "Recreates the databases from the structure.sql file"
-    task :load => [:load_config] do
+    task :load => [:environment, :load_config] do
       ActiveRecord::Tasks::DatabaseTasks.load_schema_current(:sql, ENV['SCHEMA'])
     end
 
@@ -351,7 +365,7 @@ db_namespace = namespace :db do
     task :clone_structure => %w(db:test:deprecated db:structure:dump db:test:load_structure)
 
     # desc "Empty the test database"
-    task :purge => %w(environment load_config) do
+    task :purge => %w(environment load_config check_protected_environments) do
       ActiveRecord::Tasks::DatabaseTasks.purge ActiveRecord::Base.configurations['test']
     end
 

data/lib/active_record/reflection.rb

@@ -483,28 +483,7 @@ module ActiveRecord
       # Returns +true+ if +self+ is a +has_one+ reflection.
       def has_one?; false; end
 
-      def association_class
-        case macro
-        when :belongs_to
-          if polymorphic?
-            Associations::BelongsToPolymorphicAssociation
-          else
-            Associations::BelongsToAssociation
-          end
-        when :has_many
-          if options[:through]
-            Associations::HasManyThroughAssociation
-          else
-            Associations::HasManyAssociation
-          end
-        when :has_one
-          if options[:through]
-            Associations::HasOneThroughAssociation
-          else
-            Associations::HasOneAssociation
-          end
-        end
-      end
+      def association_class; raise NotImplementedError; end
 
       def polymorphic?
         options[:polymorphic]
@@ -522,14 +501,7 @@ module ActiveRecord
       private
 
         def calculate_constructable(macro, options)
-          case macro
-          when :belongs_to
-            !polymorphic?
-          when :has_one
-            !options[:through]
-          else
-            true
-          end
+          true
         end
 
         # Attempts to find the inverse association name automatically.
@@ -545,7 +517,7 @@ module ActiveRecord
           end
         end
 
-        # returns either nil or the inverse association name that it finds.
+        # returns either false or the inverse association name that it finds.
         def automatic_inverse_of
           if can_find_inverse_of_automatically?(self)
             inverse_name = ActiveSupport::Inflector.underscore(options[:as] || active_record.name.demodulize).to_sym
@@ -629,6 +601,14 @@ module ActiveRecord
       def macro; :has_many; end
 
       def collection?; true; end
+
+      def association_class
+        if options[:through]
+          Associations::HasManyThroughAssociation
+        else
+          Associations::HasManyAssociation
+        end
+      end
     end
 
     class HasOneReflection < AssociationReflection # :nodoc:
@@ -639,6 +619,20 @@ module ActiveRecord
       def macro; :has_one; end
 
       def has_one?; true; end
+
+      def association_class
+        if options[:through]
+          Associations::HasOneThroughAssociation
+        else
+          Associations::HasOneAssociation
+        end
+      end
+
+      private
+
+        def calculate_constructable(macro, options)
+          !options[:through]
+        end
     end
 
     class BelongsToReflection < AssociationReflection # :nodoc:
@@ -650,6 +644,14 @@ module ActiveRecord
 
       def belongs_to?; true; end
 
+      def association_class
+        if polymorphic?
+          Associations::BelongsToPolymorphicAssociation
+        else
+          Associations::BelongsToAssociation
+        end
+      end
+
       def join_keys(association_klass)
         key = polymorphic? ? association_primary_key(association_klass) : association_primary_key
         JoinKeys.new(key, foreign_key)
@@ -658,6 +660,12 @@ module ActiveRecord
       def join_id_for(owner) # :nodoc:
         owner[foreign_key]
       end
+
+      private
+
+        def calculate_constructable(macro, options)
+          !polymorphic?
+        end
     end
 
     class HasAndBelongsToManyReflection < AssociationReflection # :nodoc:

data/lib/active_record/relation.rb

@@ -99,7 +99,7 @@ module ActiveRecord
       end
 
       substitutes = values.map do |(arel_attr, _)|
-        [arel_attr, connection.substitute_at(klass.columns_hash[arel_attr.name])]
+        [arel_attr, Arel::Nodes::BindParam.new]
       end
 
       [substitutes, binds]
@@ -132,7 +132,7 @@ module ActiveRecord
     # ==== Examples
     #
     #   users = User.where(name: 'Oscar')
-    #   users.create # => #<User id: 3, name: "oscar", ...>
+    #   users.create # => #<User id: 3, name: "Oscar", ...>
     #
     #   users.create(name: 'fxn')
     #   users.create # => #<User id: 4, name: "fxn", ...>
@@ -371,11 +371,11 @@ module ActiveRecord
 
       stmt.set Arel.sql(@klass.send(:sanitize_sql_for_assignment, updates))
       stmt.table(table)
-      stmt.key = table[primary_key]
 
       if joins_values.any?
-        @klass.connection.join_to_update(stmt, arel)
+        @klass.connection.join_to_update(stmt, arel, table[primary_key])
       else
+        stmt.key = table[primary_key]
         stmt.take(arel.limit)
         stmt.order(*arel.orders)
         stmt.wheres = arel.constraints

data/lib/active_record/relation/batches.rb

@@ -29,15 +29,15 @@ module ActiveRecord
     #
     # ==== Options
     # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
-    # * <tt>:begin_at</tt> - Specifies the primary key value to start from, inclusive of the value.
-    # * <tt>:end_at</tt> - Specifies the primary key value to end at, inclusive of the value.
+    # * <tt>:start</tt> - Specifies the primary key value to start from, inclusive of the value.
+    # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
     # This is especially useful if you want multiple workers dealing with
     # the same processing queue. You can make worker 1 handle all the records
     # between id 0 and 10,000 and worker 2 handle from 10,000 and beyond
-    # (by setting the +:begin_at+ and +:end_at+ option on each worker).
+    # (by setting the +:start+ and +:finish+ option on each worker).
     #
     #   # Let's process for a batch of 2000 records, skipping the first 2000 rows
-    #   Person.find_each(begin_at: 2000, batch_size: 2000) do |person|
+    #   Person.find_each(start: 2000, batch_size: 2000) do |person|
     #     person.party_all_night!
     #   end
     #
@@ -48,22 +48,15 @@ module ActiveRecord
     #
     # NOTE: You can't set the limit either, that's used to control
     # the batch sizes.
-    def find_each(begin_at: nil, end_at: nil, batch_size: 1000, start: nil)
-      if start
-        begin_at = start
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing `start` value to find_each is deprecated, and will be removed in Rails 5.1.
-            Please pass `begin_at` instead.
-        MSG
-      end
+    def find_each(start: nil, finish: nil, batch_size: 1000)
       if block_given?
-        find_in_batches(begin_at: begin_at, end_at: end_at, batch_size: batch_size) do |records|
+        find_in_batches(start: start, finish: finish, batch_size: batch_size) do |records|
           records.each { |record| yield record }
         end
       else
-        enum_for(:find_each, begin_at: begin_at, end_at: end_at, batch_size: batch_size) do
+        enum_for(:find_each, start: start, finish: finish, batch_size: batch_size) do
           relation = self
-          apply_limits(relation, begin_at, end_at).size
+          apply_limits(relation, start, finish).size
         end
       end
     end
@@ -88,15 +81,15 @@ module ActiveRecord
     #
     # ==== Options
     # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
-    # * <tt>:begin_at</tt> - Specifies the primary key value to start from, inclusive of the value.
-    # * <tt>:end_at</tt> - Specifies the primary key value to end at, inclusive of the value.
+    # * <tt>:start</tt> - Specifies the primary key value to start from, inclusive of the value.
+    # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
     # This is especially useful if you want multiple workers dealing with
     # the same processing queue. You can make worker 1 handle all the records
     # between id 0 and 10,000 and worker 2 handle from 10,000 and beyond
-    # (by setting the +:begin_at+ and +:end_at+ option on each worker).
+    # (by setting the +:start+ and +:finish+ option on each worker).
     #
     #   # Let's process the next 2000 records
-    #   Person.find_in_batches(begin_at: 2000, batch_size: 2000) do |group|
+    #   Person.find_in_batches(start: 2000, batch_size: 2000) do |group|
     #     group.each { |person| person.party_all_night! }
     #   end
     #
@@ -107,24 +100,16 @@ module ActiveRecord
     #
     # NOTE: You can't set the limit either, that's used to control
     # the batch sizes.
-    def find_in_batches(begin_at: nil, end_at: nil, batch_size: 1000, start: nil)
-      if start
-        begin_at = start
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing `start` value to find_in_batches is deprecated, and will be removed in Rails 5.1.
-            Please pass `begin_at` instead.
-        MSG
-      end
-
+    def find_in_batches(start: nil, finish: nil, batch_size: 1000)
       relation = self
       unless block_given?
-        return to_enum(:find_in_batches, begin_at: begin_at, end_at: end_at, batch_size: batch_size) do
-          total = apply_limits(relation, begin_at, end_at).size
+        return to_enum(:find_in_batches, start: start, finish: finish, batch_size: batch_size) do
+          total = apply_limits(relation, start, finish).size
           (total - 1).div(batch_size) + 1
         end
       end
 
-      in_batches(of: batch_size, begin_at: begin_at, end_at: end_at, load: true) do |batch|
+      in_batches(of: batch_size, start: start, finish: finish, load: true) do |batch|
         yield batch.to_a
       end
     end
@@ -153,18 +138,18 @@ module ActiveRecord
     # ==== Options
     # * <tt>:of</tt> - Specifies the size of the batch. Default to 1000.
     # * <tt>:load</tt> - Specifies if the relation should be loaded. Default to false.
-    # * <tt>:begin_at</tt> - Specifies the primary key value to start from, inclusive of the value.
-    # * <tt>:end_at</tt> - Specifies the primary key value to end at, inclusive of the value.
+    # * <tt>:start</tt> - Specifies the primary key value to start from, inclusive of the value.
+    # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
     #
     # This is especially useful if you want to work with the
     # ActiveRecord::Relation object instead of the array of records, or if
     # you want multiple workers dealing with the same processing queue. You can
     # make worker 1 handle all the records between id 0 and 10,000 and worker 2
-    # handle from 10,000 and beyond (by setting the +:begin_at+ and +:end_at+
+    # handle from 10,000 and beyond (by setting the +:start+ and +:finish+
     # option on each worker).
     #
     #   # Let's process the next 2000 records
-    #   Person.in_batches(of: 2000, begin_at: 2000).update_all(awesome: true)
+    #   Person.in_batches(of: 2000, start: 2000).update_all(awesome: true)
     #
     # An example of calling where query method on the relation:
     #
@@ -186,10 +171,10 @@ module ActiveRecord
     #
     # NOTE: You can't set the limit either, that's used to control the batch
     # sizes.
-    def in_batches(of: 1000, begin_at: nil, end_at: nil, load: false)
+    def in_batches(of: 1000, start: nil, finish: nil, load: false)
       relation = self
       unless block_given?
-        return BatchEnumerator.new(of: of, begin_at: begin_at, end_at: end_at, relation: self)
+        return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
       end
 
       if logger && (arel.orders.present? || arel.taken.present?)
@@ -197,7 +182,7 @@ module ActiveRecord
       end
 
       relation = relation.reorder(batch_order).limit(of)
-      relation = apply_limits(relation, begin_at, end_at)
+      relation = apply_limits(relation, start, finish)
       batch_relation = relation
 
       loop do
@@ -225,9 +210,9 @@ module ActiveRecord
 
     private
 
-    def apply_limits(relation, begin_at, end_at)
-      relation = relation.where(table[primary_key].gteq(begin_at)) if begin_at
-      relation = relation.where(table[primary_key].lteq(end_at)) if end_at
+    def apply_limits(relation, start, finish)
+      relation = relation.where(table[primary_key].gteq(start)) if start
+      relation = relation.where(table[primary_key].lteq(finish)) if finish
       relation
     end