activerecord 4.0.13 → 4.1.0.beta1

data/lib/active_record/model_schema.rb

@@ -32,6 +32,12 @@ module ActiveRecord
       class_attribute :table_name_suffix, instance_writer: false
       self.table_name_suffix = ""
 
+      ##
+      # :singleton-method:
+      # Accessor for the name of the schema migrations table. By default, the value is "schema_migrations"
+      class_attribute :schema_migrations_table_name, instance_accessor: false
+      self.schema_migrations_table_name = "schema_migrations"
+
       ##
       # :singleton-method:
       # Indicates whether table names should be the pluralized versions of the corresponding class names.
@@ -124,7 +130,7 @@ module ActiveRecord
         @quoted_table_name = nil
         @arel_table        = nil
         @sequence_name     = nil unless defined?(@explicit_sequence_name) && @explicit_sequence_name
-        @relation          = Relation.new(self, arel_table)
+        @relation          = Relation.create(self, arel_table)
       end
 
       # Returns a quoted version of the table name, used to construct SQL statements.
@@ -260,19 +266,6 @@ module ActiveRecord
         @content_columns ||= columns.reject { |c| c.primary || c.name =~ /(_id|_count)$/ || c.name == inheritance_column }
       end
 
-      # Returns a hash of all the methods added to query each of the columns in the table with the name of the method as the key
-      # and true as the value. This makes it possible to do O(1) lookups in respond_to? to check if a given method for attribute
-      # is available.
-      def column_methods_hash #:nodoc:
-        @dynamic_methods_hash ||= column_names.each_with_object(Hash.new(false)) do |attr, methods|
-          attr_name = attr.to_s
-          methods[attr.to_sym]       = attr_name
-          methods["#{attr}=".to_sym] = attr_name
-          methods["#{attr}?".to_sym] = attr_name
-          methods["#{attr}_before_type_cast".to_sym] = attr_name
-        end
-      end
-
       # Resets all the cached information about columns, which will cause them
       # to be reloaded on the next request.
       #

data/lib/active_record/nested_attributes.rb

@@ -230,6 +230,10 @@ module ActiveRecord
     #     validates_presence_of :member
     #   end
     #
+    # Note that if you do not specify the <tt>inverse_of</tt> option, then
+    # Active Record will try to automatically guess the inverse association
+    # based on heuristics.
+    #
     # For one-to-one nested associations, if you build the new (in-memory)
     # child object yourself before assignment, then this module will not
     # overwrite it, e.g.:
@@ -302,7 +306,7 @@ module ActiveRecord
 
         attr_names.each do |association_name|
           if reflection = reflect_on_association(association_name)
-            reflection.options[:autosave] = true
+            reflection.autosave = true
             add_autosave_association_callbacks(reflection)
 
             nested_attributes_options = self.nested_attributes_options.dup
@@ -331,7 +335,7 @@ module ActiveRecord
       # the helper methods defined below. Makes it seem like the nested
       # associations are just regular associations.
       def generate_association_writer(association_name, type)
-        generated_feature_methods.module_eval <<-eoruby, __FILE__, __LINE__ + 1
+        generated_association_methods.module_eval <<-eoruby, __FILE__, __LINE__ + 1
           if method_defined?(:#{association_name}_attributes=)
             remove_method(:#{association_name}_attributes=)
           end
@@ -461,19 +465,17 @@ module ActiveRecord
             association.build(attributes.except(*UNASSIGNABLE_KEYS))
           end
         elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes['id'].to_s }
-          unless association.loaded? || call_reject_if(association_name, attributes)
+          unless call_reject_if(association_name, attributes)
             # Make sure we are operating on the actual object which is in the association's
             # proxy_target array (either by finding it, or adding it if not found)
-            target_record = association.target.detect { |record| record == existing_record }
-
+            # Take into account that the proxy_target may have changed due to callbacks
+            target_record = association.target.detect { |record| record.id.to_s == attributes['id'].to_s }
             if target_record
               existing_record = target_record
             else
-              association.add_to_target(existing_record)
+              association.add_to_target(existing_record, :skip_callbacks)
             end
-          end
 
-          if !call_reject_if(association_name, attributes)
             assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
           end
         else

data/lib/active_record/no_touching.rb

@@ -0,0 +1,52 @@
+module ActiveRecord
+  # = Active Record No Touching
+  module NoTouching
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Lets you selectively disable calls to `touch` for the
+      # duration of a block.
+      #
+      # ==== Examples
+      #   ActiveRecord::Base.no_touching do
+      #     Project.first.touch  # does nothing
+      #     Message.first.touch  # does nothing
+      #   end
+      #
+      #   Project.no_touching do
+      #     Project.first.touch  # does nothing
+      #     Message.first.touch  # works, but does not touch the associated project
+      #   end
+      #
+      def no_touching(&block)
+        NoTouching.apply_to(self, &block)
+      end
+    end
+
+    class << self
+      def apply_to(klass) #:nodoc:
+        klasses.push(klass)
+        yield
+      ensure
+        klasses.pop
+      end
+
+      def applied_to?(klass) #:nodoc:
+        klasses.any? { |k| k >= klass }
+      end
+
+      private
+        def klasses
+          Thread.current[:no_touching_classes] ||= []
+        end
+    end
+
+    def no_touching?
+      NoTouching.applied_to?(self.class)
+    end
+
+    def touch(*)
+      super unless no_touching?
+    end
+  end
+end

data/lib/active_record/null_relation.rb

@@ -39,11 +39,11 @@ module ActiveRecord
     end
 
     def to_sql
-      @to_sql ||= ""
+      ""
     end
 
     def count(*)
-      calculate :count, nil
+      0
     end
 
     def sum(*)
@@ -54,7 +54,7 @@ module ActiveRecord
       # TODO: Remove _options argument as soon we remove support to
       # activerecord-deprecated_finders.
       if operation == :count
-        group_values.any? ? Hash.new : 0
+        0
       else
         nil
       end

data/lib/active_record/persistence.rb

@@ -37,7 +37,7 @@ module ActiveRecord
       end
 
       # Given an attributes hash, +instantiate+ returns a new instance of
-      # the appropriate class. Accepts only keys as strings.
+      # the appropriate class.
       #
       # For example, +Post.all+ may return Comments, Messages, and Emails
       # by storing the record's subclass in a +type+ attribute. By calling
@@ -46,10 +46,10 @@ module ActiveRecord
       #
       # See +ActiveRecord::Inheritance#discriminate_class_for_record+ to see
       # how this "single-table" inheritance mapping is implemented.
-      def instantiate(attributes, column_types = {})
-        klass = discriminate_class_for_record(attributes)
+      def instantiate(record, column_types = {})
+        klass = discriminate_class_for_record(record)
         column_types = klass.decorate_columns(column_types.dup)
-        klass.allocate.init_with('attributes' => attributes, 'column_types' => column_types)
+        klass.allocate.init_with('attributes' => record, 'column_types' => column_types)
       end
 
       private
@@ -64,7 +64,7 @@ module ActiveRecord
     end
 
     # Returns true if this object hasn't been saved yet -- that is, a record
-    # for the object doesn't exist in the database yet; otherwise, returns false.
+    # for the object doesn't exist in the data store yet; otherwise, returns false.
     def new_record?
       sync_with_transaction_state
       @new_record
@@ -195,11 +195,7 @@ module ActiveRecord
     # share the same set of attributes.
     def becomes!(klass)
       became = becomes(klass)
-      sti_type = nil
-      if !klass.descends_from_active_record?
-        sti_type = klass.sti_name
-      end
-      became.public_send("#{klass.inheritance_column}=", sti_type)
+      became.public_send("#{klass.inheritance_column}=", klass.sti_name) unless self.class.descends_from_active_record?
       became
     end
 
@@ -346,7 +342,8 @@ module ActiveRecord
     #   # Account Load (1.2ms)  SELECT "accounts".* FROM "accounts" WHERE "accounts"."id" = $1 LIMIT 1  [["id", 1]]
     #   # => #<Account id: 1, email: 'account@example.com'>
     #
-    # Attributes are updated, and caches busted, in particular the associations cache.
+    # Attributes are reloaded from the database, and caches busted, in
+    # particular the associations cache.
     #
     # If the record no longer exists in the database <tt>ActiveRecord::RecordNotFound</tt>
     # is raised. Otherwise, in addition to the in-place modification the method
@@ -387,7 +384,7 @@ module ActiveRecord
 
       fresh_object =
         if options && options[:lock]
-          self.class.unscoped { self.class.lock(options[:lock]).find(id) }
+          self.class.unscoped { self.class.lock.find(id) }
         else
           self.class.unscoped { self.class.find(id) }
         end
@@ -397,7 +394,6 @@ module ActiveRecord
       @column_types           = self.class.column_types
       @column_types_override  = fresh_object.instance_variable_get('@column_types_override')
       @attributes_cache       = {}
-      @new_record             = false
       self
     end
 
@@ -446,11 +442,9 @@ module ActiveRecord
 
         changes[self.class.locking_column] = increment_lock if locking_enabled?
 
-        @changed_attributes.except!(*changes.keys)
+        changed_attributes.except!(*changes.keys)
         primary_key = self.class.primary_key
         self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
-      else
-        true
       end
     end
 
@@ -478,36 +472,24 @@ module ActiveRecord
 
     def create_or_update
       raise ReadOnlyRecord if readonly?
-      result = new_record? ? _create_record : _update_record
+      result = new_record? ? create_record : update_record
       result != false
     end
 
     # Updates the associated record with values matching those of the instance attributes.
     # Returns the number of affected rows.
-    def _update_record(attribute_names = @attributes.keys)
-      attributes_with_values = arel_attributes_with_values_for_update(attribute_names)
-      if attributes_with_values.empty?
+    def update_record(attribute_names = @attributes.keys)
+      attributes_values = arel_attributes_with_values_for_update(attribute_names)
+      if attributes_values.empty?
         0
       else
-        klass = self.class
-        column_hash = klass.connection.schema_cache.columns_hash klass.table_name
-        db_columns_with_values = attributes_with_values.map { |attr,value|
-          real_column = column_hash[attr.name]
-          [real_column, value]
-        }
-        bind_attrs = attributes_with_values.dup
-        bind_attrs.keys.each_with_index do |column, i|
-          real_column = db_columns_with_values[i].first
-          bind_attrs[column] = klass.connection.substitute_at(real_column, i)
-        end
-        stmt = klass.unscoped.where(klass.arel_table[klass.primary_key].eq(id_was || id)).arel.compile_update(bind_attrs)
-        klass.connection.update stmt, 'SQL', db_columns_with_values
+        self.class.unscoped.update_record attributes_values, id, id_was
       end
     end
 
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
-    def _create_record(attribute_names = @attributes.keys)
+    def create_record(attribute_names = @attributes.keys)
       attributes_values = arel_attributes_with_values_for_create(attribute_names)
 
       new_id = self.class.unscoped.insert attributes_values

data/lib/active_record/querying.rb

@@ -1,20 +1,21 @@
 module ActiveRecord
   module Querying
-    delegate :find, :take, :take!, :first, :first!, :last, :last!, :exists?, :any?, :many?, :to => :all
-    delegate :first_or_create, :first_or_create!, :first_or_initialize, :to => :all
-    delegate :find_or_create_by, :find_or_create_by!, :find_or_initialize_by, :to => :all
-    delegate :find_by, :find_by!, :to => :all
-    delegate :destroy, :destroy_all, :delete, :delete_all, :update, :update_all, :to => :all
-    delegate :find_each, :find_in_batches, :to => :all
+    delegate :find, :take, :take!, :first, :first!, :last, :last!, :exists?, :any?, :many?, to: :all
+    delegate :first_or_create, :first_or_create!, :first_or_initialize, to: :all
+    delegate :find_or_create_by, :find_or_create_by!, :find_or_initialize_by, to: :all
+    delegate :find_by, :find_by!, to: :all
+    delegate :destroy, :destroy_all, :delete, :delete_all, :update, :update_all, to: :all
+    delegate :find_each, :find_in_batches, to: :all
     delegate :select, :group, :order, :except, :reorder, :limit, :offset, :joins,
-             :where, :preload, :eager_load, :includes, :from, :lock, :readonly,
-             :having, :create_with, :uniq, :distinct, :references, :none, :unscope, :to => :all
-    delegate :count, :average, :minimum, :maximum, :sum, :calculate, :pluck, :ids, :to => :all
+             :where, :rewhere, :preload, :eager_load, :includes, :from, :lock, :readonly,
+             :having, :create_with, :uniq, :distinct, :references, :none, :unscope, to: :all
+    delegate :count, :average, :minimum, :maximum, :sum, :calculate, to: :all
+    delegate :pluck, :ids, to: :all
 
     # Executes a custom SQL query against your database and returns all the results. The results will
     # be returned as an array with columns requested encapsulated as attributes of the model you call
     # this method from. If you call <tt>Product.find_by_sql</tt> then the results will be returned in
-    # a Product object with the attributes you specified in the SQL query.
+    # a +Product+ object with the attributes you specified in the SQL query.
     #
     # If you call a complicated SQL query which spans multiple tables the columns specified by the
     # SELECT will be attributes of the model, whether or not they are columns of the corresponding
@@ -29,9 +30,10 @@ module ActiveRecord
     #   Post.find_by_sql "SELECT p.title, c.author FROM posts p, comments c WHERE p.id = c.post_id"
     #   # => [#<Post:0x36bff9c @attributes={"title"=>"Ruby Meetup", "first_name"=>"Quentin"}>, ...]
     #
-    #   # You can use the same string replacement techniques as you can with ActiveRecord#find
+    # You can use the same string replacement techniques as you can with <tt>ActiveRecord::QueryMethods#where</tt>:
+    #
     #   Post.find_by_sql ["SELECT title FROM posts WHERE author = ? AND created > ?", author_id, start_date]
-    #   # => [#<Post:0x36bff9c @attributes={"title"=>"The Cheap Man Buys Twice"}>, ...]
+    #   Post.find_by_sql ["SELECT body FROM comments WHERE author = :user_id OR approved_by = :user_id", { :user_id => user_id }]
     def find_by_sql(sql, binds = [])
       result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds)
       column_types = {}

data/lib/active_record/railtie.rb

@@ -112,56 +112,6 @@ module ActiveRecord
 
     initializer "active_record.set_configs" do |app|
       ActiveSupport.on_load(:active_record) do
-        begin
-          old_behavior, ActiveSupport::Deprecation.behavior = ActiveSupport::Deprecation.behavior, :stderr
-          whitelist_attributes = app.config.active_record.delete(:whitelist_attributes)
-
-          if respond_to?(:mass_assignment_sanitizer=)
-            mass_assignment_sanitizer = nil
-          else
-            mass_assignment_sanitizer = app.config.active_record.delete(:mass_assignment_sanitizer)
-          end
-
-          unless whitelist_attributes.nil? && mass_assignment_sanitizer.nil?
-            ActiveSupport::Deprecation.warn <<-EOF.strip_heredoc, []
-              Model based mass assignment security has been extracted
-              out of Rails into a gem. Please use the new recommended protection model for
-              params or add `protected_attributes` to your Gemfile to use the old one.
-
-              To disable this message remove the `whitelist_attributes` option from your
-              `config/application.rb` file and any `mass_assignment_sanitizer` options
-              from your `config/environments/*.rb` files.
-
-              See http://guides.rubyonrails.org/security.html#mass-assignment for more information.
-            EOF
-          end
-
-          unless app.config.active_record.delete(:auto_explain_threshold_in_seconds).nil?
-            ActiveSupport::Deprecation.warn <<-EOF.strip_heredoc, []
-              The Active Record auto explain feature has been removed.
-
-              To disable this message remove the `active_record.auto_explain_threshold_in_seconds`
-              option from the `config/environments/*.rb` config file.
-
-              See http://guides.rubyonrails.org/4_0_release_notes.html for more information.
-            EOF
-          end
-
-          unless app.config.active_record.delete(:observers).nil?
-            ActiveSupport::Deprecation.warn <<-EOF.strip_heredoc, []
-              Active Record Observers has been extracted out of Rails into a gem.
-              Please use callbacks or add `rails-observers` to your Gemfile to use observers.
-
-              To disable this message remove the `observers` option from your
-              `config/application.rb` or from your initializers.
-
-              See http://guides.rubyonrails.org/4_0_release_notes.html for more information.
-            EOF
-          end
-        ensure
-          ActiveSupport::Deprecation.behavior = old_behavior
-        end
-
         app.config.active_record.each do |k,v|
           send "#{k}=", v
         end

data/lib/active_record/railties/databases.rake

@@ -12,7 +12,7 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Create the database from DATABASE_URL or config/database.yml for the current Rails.env (use db:create:all to create all dbs in the config)'
+  desc 'Create the database from DATABASE_URL or config/database.yml for the current Rails.env (use db:create:all to create all databases in the config)'
   task :create => [:load_config] do
     if ENV['DATABASE_URL']
       ActiveRecord::Tasks::DatabaseTasks.create_database_url
@@ -95,15 +95,14 @@ db_namespace = namespace :db do
         next  # means "return" for rake task
       end
       db_list = ActiveRecord::Base.connection.select_values("SELECT version FROM #{ActiveRecord::Migrator.schema_migrations_table_name}")
-      db_list.map! { |version| ActiveRecord::SchemaMigration.normalize_migration_number(version) }
+      db_list.map! { |version| "%.3d" % version }
       file_list = []
       ActiveRecord::Migrator.migrations_paths.each do |path|
         Dir.foreach(path) do |file|
           # match "20091231235959_some_name.rb" and "001_some_name.rb" pattern
           if match_data = /^(\d{3,})_(.+)\.rb$/.match(file)
-            version = ActiveRecord::SchemaMigration.normalize_migration_number(match_data[1])
-            status = db_list.delete(version) ? 'up' : 'down'
-            file_list << [status, version, match_data[2].humanize]
+            status = db_list.delete(match_data[1]) ? 'up' : 'down'
+            file_list << [status, match_data[1], match_data[2].humanize]
           end
         end
       end
@@ -173,7 +172,7 @@ db_namespace = namespace :db do
     end
   end
 
-  desc 'Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the db first)'
+  desc 'Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the database first)'
   task :setup => ['db:schema:load_if_ruby', 'db:structure:load_if_sql', :seed]
 
   desc 'Load the seed data from db/seeds.rb'
@@ -237,7 +236,7 @@ db_namespace = namespace :db do
   end
 
   namespace :schema do
-    desc 'Create a db/schema.rb file that can be portably used against any DB supported by AR'
+    desc 'Create a db/schema.rb file that is portable against any DB supported by AR'
     task :dump => [:environment, :load_config] do
       require 'active_record/schema_dumper'
       filename = ENV['SCHEMA'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, 'schema.rb')
@@ -250,11 +249,8 @@ db_namespace = namespace :db do
     desc 'Load a schema.rb file into the database'
     task :load => [:environment, :load_config] do
       file = ENV['SCHEMA'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, 'schema.rb')
-      if File.exist?(file)
-        load(file)
-      else
-        abort %{#{file} doesn't exist yet. Run `rake db:migrate` to create it, then try again. 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.}
-      end
+      ActiveRecord::Tasks::DatabaseTasks.check_schema_file(file)
+      load(file)
     end
 
     task :load_if_ruby => ['db:create', :environment] do
@@ -288,10 +284,10 @@ db_namespace = namespace :db do
       current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
       ActiveRecord::Tasks::DatabaseTasks.structure_dump(current_config, filename)
 
-      if ActiveRecord::Base.connection.supports_migrations? &&
-          ActiveRecord::SchemaMigration.table_exists?
+      if ActiveRecord::Base.connection.supports_migrations?
         File.open(filename, "a") do |f|
           f.puts ActiveRecord::Base.connection.dump_schema_information
+          f.print "\n"
         end
       end
       db_namespace['structure:dump'].reenable
@@ -300,6 +296,7 @@ db_namespace = namespace :db do
     # desc "Recreate the databases from the structure.sql file"
     task :load => [:environment, :load_config] do
       filename = ENV['DB_STRUCTURE'] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, "structure.sql")
+      ActiveRecord::Tasks::DatabaseTasks.check_schema_file(filename)
       current_config = ActiveRecord::Tasks::DatabaseTasks.current_config
       ActiveRecord::Tasks::DatabaseTasks.structure_load(current_config, filename)
     end
@@ -381,7 +378,7 @@ namespace :railties do
     task :migrations => :'db:load_config' do
       to_load = ENV['FROM'].blank? ? :all : ENV['FROM'].split(",").map {|n| n.strip }
       railties = {}
-      Rails.application.migration_railties.each do |railtie|
+      Rails.application.railties.each do |railtie|
         next unless to_load == :all || to_load.include?(railtie.railtie_name)
 
         if railtie.respond_to?(:paths) && (path = railtie.paths['db/migrate'].first)