activerecord 4.0.0.beta1 → 4.0.0.rc1

data/lib/active_record/inheritance.rb

@@ -15,6 +15,9 @@ module ActiveRecord
       # and if the inheritance column is attr accessible, it initializes an
       # instance of the given subclass instead of the base class
       def new(*args, &block)
+        if abstract_class? || self == Base
+          raise NotImplementedError, "#{self} is an abstract class and can not be instantiated."
+        end
         if (attrs = args.first).is_a?(Hash)
           if subclass = subclass_from_attrs(attrs)
             return subclass.new(*args, &block)
@@ -167,11 +170,16 @@ module ActiveRecord
       # this will ignore the inheritance column and return nil
       def subclass_from_attrs(attrs)
         subclass_name = attrs.with_indifferent_access[inheritance_column]
-        return nil if subclass_name.blank? || subclass_name == self.name
-        unless subclass = subclasses.detect { |sub| sub.name == subclass_name }
-          raise ActiveRecord::SubclassNotFound.new("Invalid single-table inheritance type: #{subclass_name} is not a subclass of #{name}")
+
+        if subclass_name.present? && subclass_name != self.name
+          subclass = subclass_name.safe_constantize
+
+          unless descendants.include?(subclass)
+            raise ActiveRecord::SubclassNotFound.new("Invalid single-table inheritance type: #{subclass_name} is not a subclass of #{name}")
+          end
+
+          subclass
         end
-        subclass
       end
     end
 

data/lib/active_record/integration.rb

@@ -21,7 +21,7 @@ module ActiveRecord
     # <tt>resources :users</tt> route. Normally, +user_path+ will
     # construct a path with the user object's 'id' in it:
     #
-    #   user = User.find_by_name('Phusion')
+    #   user = User.find_by(name: 'Phusion')
     #   user_path(user)  # => "/users/1"
     #
     # You can override +to_param+ in your model to make +user_path+ construct
@@ -33,7 +33,7 @@ module ActiveRecord
     #     end
     #   end
     #
-    #   user = User.find_by_name('Phusion')
+    #   user = User.find_by(name: 'Phusion')
     #   user_path(user)  # => "/users/Phusion"
     def to_param
       # We can't use alias_method here, because method 'id' optimizes itself on the fly.
@@ -49,7 +49,7 @@ module ActiveRecord
       case
       when new_record?
         "#{self.class.model_name.cache_key}/new"
-      when timestamp = self[:updated_at]
+      when timestamp = max_updated_column_timestamp
         timestamp = timestamp.utc.to_s(cache_timestamp_format)
         "#{self.class.model_name.cache_key}/#{id}-#{timestamp}"
       else

data/lib/active_record/locking/optimistic.rb

@@ -86,7 +86,7 @@ module ActiveRecord
               )
             ).arel.compile_update(arel_attributes_with_values_for_update(attribute_names))
 
-            affected_rows = connection.update stmt
+            affected_rows = self.class.connection.update stmt
 
             unless affected_rows == 1
               raise ActiveRecord::StaleObjectError.new(self, "update")
@@ -117,7 +117,7 @@ module ActiveRecord
           if locking_enabled?
             column_name = self.class.locking_column
             column      = self.class.columns_hash[column_name]
-            substitute  = connection.substitute_at(column, relation.bind_values.length)
+            substitute  = self.class.connection.substitute_at(column, relation.bind_values.length)
 
             relation = relation.where(self.class.arel_table[column_name].eq(substitute))
             relation.bind_values << [column, self[column_name].to_i]

data/lib/active_record/log_subscriber.rb

@@ -3,11 +3,11 @@ module ActiveRecord
     IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"]
 
     def self.runtime=(value)
-      Thread.current[:active_record_sql_runtime] = value
+      ActiveRecord::RuntimeRegistry.sql_runtime = value
     end
 
     def self.runtime
-      Thread.current[:active_record_sql_runtime] ||= 0
+      ActiveRecord::RuntimeRegistry.sql_runtime ||= 0
     end
 
     def self.reset_runtime

data/lib/active_record/migration.rb

@@ -102,7 +102,7 @@ module ActiveRecord
   #   table definition.
   # * <tt>drop_table(name)</tt>: Drops the table called +name+.
   # * <tt>change_table(name, options)</tt>: Allows to make column alterations to
-  #   the table called +name+. It makes the table object availabe to a block that
+  #   the table called +name+. It makes the table object available to a block that
   #   can then add/remove columns, indexes or foreign keys to it.
   # * <tt>rename_table(old_name, new_name)</tt>: Renames the table called +old_name+
   #   to +new_name+.
@@ -330,6 +330,24 @@ module ActiveRecord
   #
   # For a list of commands that are reversible, please see
   # <tt>ActiveRecord::Migration::CommandRecorder</tt>.
+  #
+  # == Transactional Migrations
+  #
+  # If the database adapter supports DDL transactions, all migrations will
+  # automatically be wrapped in a transaction. There are queries that you
+  # can't execute inside a transaction though, and for these situations
+  # you can turn the automatic transactions off.
+  #
+  #   class ChangeEnum < ActiveRecord::Migration
+  #     disable_ddl_transaction!
+  #
+  #     def up
+  #       execute "ALTER TYPE model_size ADD VALUE 'new_value'"
+  #     end
+  #   end
+  #
+  # Remember that you can still open your own transactions, even if you
+  # are in a Migration with <tt>self.disable_ddl_transaction!</tt>.
   class Migration
     autoload :CommandRecorder, 'active_record/migration/command_recorder'
 
@@ -351,6 +369,7 @@ module ActiveRecord
 
     class << self
       attr_accessor :delegate # :nodoc:
+      attr_accessor :disable_ddl_transaction # :nodoc:
     end
 
     def self.check_pending!
@@ -365,8 +384,16 @@ module ActiveRecord
       new.migrate direction
     end
 
-    cattr_accessor :verbose
+    # Disable DDL transactions for this migration.
+    def self.disable_ddl_transaction!
+      @disable_ddl_transaction = true
+    end
+
+    def disable_ddl_transaction # :nodoc:
+      self.class.disable_ddl_transaction
+    end
 
+    cattr_accessor :verbose
     attr_accessor :name, :version
 
     def initialize(name = self.class.name, version = nil)
@@ -375,8 +402,8 @@ module ActiveRecord
       @connection = nil
     end
 
+    self.verbose = true
     # instantiate the delegate object after initialize is defined
-    self.verbose  = true
     self.delegate = new
 
     # Reverses the migration commands for the given block and
@@ -439,7 +466,7 @@ module ActiveRecord
       @connection.respond_to?(:reverting) && @connection.reverting
     end
 
-    class ReversibleBlockHelper < Struct.new(:reverting)
+    class ReversibleBlockHelper < Struct.new(:reverting) # :nodoc:
       def up
         yield unless reverting
       end
@@ -607,8 +634,17 @@ module ActiveRecord
         source_migrations = ActiveRecord::Migrator.migrations(path)
 
         source_migrations.each do |migration|
-          source = File.read(migration.filename)
-          source = "# This migration comes from #{scope} (originally #{migration.version})\n#{source}"
+          source = File.binread(migration.filename)
+          inserted_comment = "# This migration comes from #{scope} (originally #{migration.version})\n"
+          if /\A#.*\b(?:en)?coding:\s*\S+/ =~ source
+            # If we have a magic comment in the original migration,
+            # insert our comment after the first newline(end of the magic comment line)
+            # so the magic keep working.
+            # Note that magic comments must be at the first line(except sh-bang).
+            source[/\n/] = "\n#{inserted_comment}"
+          else
+            source = "#{inserted_comment}#{source}"
+          end
 
           if duplicate = destination_migrations.detect { |m| m.name == migration.name }
             if options[:on_skip] && duplicate.scope != scope.to_s
@@ -622,7 +658,7 @@ module ActiveRecord
           old_path, migration.filename = migration.filename, new_path
           last = migration
 
-          File.open(migration.filename, "w") { |f| f.write source }
+          File.binwrite(migration.filename, source)
           copied << migration
           options[:on_copy].call(scope, migration, old_path) if options[:on_copy]
           destination_migrations << migration
@@ -663,7 +699,7 @@ module ActiveRecord
       File.basename(filename)
     end
 
-    delegate :migrate, :announce, :write, :to => :migration
+    delegate :migrate, :announce, :write, :disable_ddl_transaction, to: :migration
 
     private
 
@@ -822,7 +858,7 @@ module ActiveRecord
     end
 
     def current_version
-      migrated.sort.last || 0
+      migrated.max || 0
     end
 
     def current_migration
@@ -831,11 +867,15 @@ module ActiveRecord
     alias :current :current_migration
 
     def run
-      target = migrations.detect { |m| m.version == @target_version }
-      raise UnknownMigrationVersionError.new(@target_version) if target.nil?
-      unless (up? && migrated.include?(target.version.to_i)) || (down? && !migrated.include?(target.version.to_i))
-        target.migrate(@direction)
-        record_version_state_after_migrating(target.version)
+      migration = migrations.detect { |m| m.version == @target_version }
+      raise UnknownMigrationVersionError.new(@target_version) if migration.nil?
+      unless (up? && migrated.include?(migration.version.to_i)) || (down? && !migrated.include?(migration.version.to_i))
+        begin
+          execute_migration_in_transaction(migration, @direction)
+        rescue => e
+          canceled_msg = use_transaction?(migration) ? ", this migration was canceled" : ""
+          raise StandardError, "An error has occurred#{canceled_msg}:\n\n#{e}", e.backtrace
+        end
       end
     end
 
@@ -856,12 +896,9 @@ module ActiveRecord
         Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger
 
         begin
-          ddl_transaction do
-            migration.migrate(@direction)
-            record_version_state_after_migrating(migration.version)
-          end
+          execute_migration_in_transaction(migration, @direction)
         rescue => e
-          canceled_msg = Base.connection.supports_ddl_transactions? ? "this and " : ""
+          canceled_msg = use_transaction?(migration) ? "this and " : ""
           raise StandardError, "An error has occurred, #{canceled_msg}all later migrations canceled:\n\n#{e}", e.backtrace
         end
       end
@@ -896,6 +933,13 @@ module ActiveRecord
       migrated.include?(migration.version.to_i)
     end
 
+    def execute_migration_in_transaction(migration, direction)
+      ddl_transaction(migration) do
+        migration.migrate(direction)
+        record_version_state_after_migrating(migration.version)
+      end
+    end
+
     def target
       migrations.detect { |m| m.version == @target_version }
     end
@@ -935,12 +979,16 @@ module ActiveRecord
     end
 
     # Wrap the migration in a transaction only if supported by the adapter.
-    def ddl_transaction
-      if Base.connection.supports_ddl_transactions?
+    def ddl_transaction(migration)
+      if use_transaction?(migration)
         Base.transaction { yield }
       else
         yield
       end
     end
+
+    def use_transaction?(migration)
+      !migration.disable_ddl_transaction && Base.connection.supports_ddl_transactions?
+    end
   end
 end

data/lib/active_record/model_schema.rb

@@ -205,7 +205,7 @@ module ActiveRecord
 
       # Returns an array of column objects for the table associated with this class.
       def columns
-        @columns ||= connection.schema_cache.columns[table_name].map do |col|
+        @columns ||= connection.schema_cache.columns(table_name).map do |col|
           col = col.dup
           col.primary = (col.name == primary_key)
           col

data/lib/active_record/nested_attributes.rb

@@ -90,8 +90,9 @@ module ActiveRecord
     #     accepts_nested_attributes_for :posts
     #   end
     #
-    # You can now set or update attributes on an associated post model through
-    # the attribute hash.
+    # You can now set or update attributes on the associated posts through
+    # an attribute hash for a member: include the key +:posts_attributes+
+    # with an array of hashes of post attributes as a value.
     #
     # For each hash that does _not_ have an <tt>id</tt> key a new record will
     # be instantiated, unless the hash also contains a <tt>_destroy</tt> key
@@ -114,10 +115,10 @@ module ActiveRecord
     # hashes if they fail to pass your criteria. For example, the previous
     # example could be rewritten as:
     #
-    #    class Member < ActiveRecord::Base
-    #      has_many :posts
-    #      accepts_nested_attributes_for :posts, reject_if: proc { |attributes| attributes['title'].blank? }
-    #    end
+    #   class Member < ActiveRecord::Base
+    #     has_many :posts
+    #     accepts_nested_attributes_for :posts, reject_if: proc { |attributes| attributes['title'].blank? }
+    #   end
     #
     #   params = { member: {
     #     name: 'joe', posts_attributes: [
@@ -134,19 +135,19 @@ module ActiveRecord
     #
     # Alternatively, :reject_if also accepts a symbol for using methods:
     #
-    #    class Member < ActiveRecord::Base
-    #      has_many :posts
-    #      accepts_nested_attributes_for :posts, reject_if: :new_record?
-    #    end
+    #   class Member < ActiveRecord::Base
+    #     has_many :posts
+    #     accepts_nested_attributes_for :posts, reject_if: :new_record?
+    #   end
     #
-    #    class Member < ActiveRecord::Base
-    #      has_many :posts
-    #      accepts_nested_attributes_for :posts, reject_if: :reject_posts
+    #   class Member < ActiveRecord::Base
+    #     has_many :posts
+    #     accepts_nested_attributes_for :posts, reject_if: :reject_posts
     #
-    #      def reject_posts(attributed)
-    #        attributed['title'].blank?
-    #      end
-    #    end
+    #     def reject_posts(attributed)
+    #       attributed['title'].blank?
+    #     end
+    #   end
     #
     # If the hash contains an <tt>id</tt> key that matches an already
     # associated record, the matching record will be modified:
@@ -183,6 +184,29 @@ module ActiveRecord
     #   member.save
     #   member.reload.posts.length # => 1
     #
+    # Nested attributes for an associated collection can also be passed in
+    # the form of a hash of hashes instead of an array of hashes:
+    #
+    #   Member.create(name:             'joe',
+    #                 posts_attributes: { first:  { title: 'Foo' },
+    #                                     second: { title: 'Bar' } })
+    #
+    # has the same effect as
+    #
+    #   Member.create(name:             'joe',
+    #                 posts_attributes: [ { title: 'Foo' },
+    #                                     { title: 'Bar' } ])
+    #
+    # The keys of the hash which is the value for +:posts_attributes+ are
+    # ignored in this case.
+    # However, it is not allowed to use +'id'+ or +:id+ for one of
+    # such keys, otherwise the hash will be wrapped in an array and
+    # interpreted as an attribute hash for a single post.
+    #
+    # Passing attributes for an associated collection in the form of a hash
+    # of hashes can be used with hashes generated from HTTP/HTML parameters,
+    # where there maybe no natural way to submit an array of hashes.
+    #
     # === Saving
     #
     # All changes to models, including the destruction of those marked for
@@ -269,23 +293,36 @@ module ActiveRecord
             self.nested_attributes_options = nested_attributes_options
 
             type = (reflection.collection? ? :collection : :one_to_one)
-
-            # def pirate_attributes=(attributes)
-            #   assign_nested_attributes_for_one_to_one_association(:pirate, attributes, mass_assignment_options)
-            # end
-            generated_feature_methods.module_eval <<-eoruby, __FILE__, __LINE__ + 1
-              if method_defined?(:#{association_name}_attributes=)
-                remove_method(:#{association_name}_attributes=)
-              end
-              def #{association_name}_attributes=(attributes)
-                assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
-              end
-            eoruby
+            generate_association_writer(association_name, type)
           else
             raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
           end
         end
       end
+
+      private
+
+      # Generates a writer method for this association. Serves as a point for
+      # accessing the objects in the association. For example, this method
+      # could generate the following:
+      #
+      #   def pirate_attributes=(attributes)
+      #     assign_nested_attributes_for_one_to_one_association(:pirate, attributes)
+      #   end
+      #
+      # This redirects the attempts to write objects in an association through
+      # 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
+          if method_defined?(:#{association_name}_attributes=)
+            remove_method(:#{association_name}_attributes=)
+          end
+          def #{association_name}_attributes=(attributes)
+            assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
+          end
+        eoruby
+      end
     end
 
     # Returns ActiveRecord::AutosaveAssociation::marked_for_destruction? It's
@@ -325,7 +362,7 @@ module ActiveRecord
         assign_to_or_mark_for_destruction(record, attributes, options[:allow_destroy]) unless call_reject_if(association_name, attributes)
 
       elsif attributes['id'].present?
-        raise_nested_attributes_record_not_found(association_name, attributes['id'])
+        raise_nested_attributes_record_not_found!(association_name, attributes['id'])
 
       elsif !reject_new_record?(association_name, attributes)
         method = "build_#{association_name}"
@@ -371,20 +408,7 @@ module ActiveRecord
         raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
       end
 
-      if limit = options[:limit]
-        limit = case limit
-        when Symbol
-          send(limit)
-        when Proc
-          limit.call
-        else
-          limit
-        end
-
-        if limit && attributes_collection.size > limit
-          raise TooManyRecords, "Maximum #{limit} records are allowed. Got #{attributes_collection.size} records instead."
-        end
-      end
+      check_record_limit!(options[:limit], attributes_collection)
 
       if attributes_collection.is_a? Hash
         keys = attributes_collection.keys
@@ -428,7 +452,30 @@ module ActiveRecord
             assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
           end
         else
-          raise_nested_attributes_record_not_found(association_name, attributes['id'])
+          raise_nested_attributes_record_not_found!(association_name, attributes['id'])
+        end
+      end
+    end
+
+    # Takes in a limit and checks if the attributes_collection has too many
+    # records. The method will take limits in the form of symbols, procs, and
+    # number-like objects (anything that can be compared with an integer).
+    #
+    # Will raise an TooManyRecords error if the attributes_collection is
+    # larger than the limit.
+    def check_record_limit!(limit, attributes_collection)
+      if limit
+        limit = case limit
+        when Symbol
+          send(limit)
+        when Proc
+          limit.call
+        else
+          limit
+        end
+
+        if limit && attributes_collection.size > limit
+          raise TooManyRecords, "Maximum #{limit} records are allowed. Got #{attributes_collection.size} records instead."
         end
       end
     end
@@ -452,6 +499,11 @@ module ActiveRecord
       has_destroy_flag?(attributes) || call_reject_if(association_name, attributes)
     end
 
+    # Determines if a record with the particular +attributes+ should be
+    # rejected by calling the reject_if Symbol or Proc (if defined).
+    # The reject_if option is defined by +accepts_nested_attributes_for+.
+    #
+    # Returns false if there is a +destroy_flag+ on the attributes.
     def call_reject_if(association_name, attributes)
       return false if has_destroy_flag?(attributes)
       case callback = self.nested_attributes_options[association_name][:reject_if]
@@ -462,7 +514,7 @@ module ActiveRecord
       end
     end
 
-    def raise_nested_attributes_record_not_found(association_name, record_id)
+    def raise_nested_attributes_record_not_found!(association_name, record_id)
       raise RecordNotFound, "Couldn't find #{self.class.reflect_on_association(association_name).klass.name} with ID=#{record_id} for #{self.class.name} with ID=#{id}"
     end
   end