activerecord 4.1.0.beta2 → 4.1.0.rc1

data/lib/active_record/dynamic_matchers.rb

@@ -6,8 +6,12 @@ module ActiveRecord
     # then we can remove the indirection.
 
     def respond_to?(name, include_private = false)
-      match = Method.match(self, name)
-      match && match.valid? || super
+      if self == Base
+        super
+      else
+        match = Method.match(self, name)
+        match && match.valid? || super
+      end
     end
 
     private

data/lib/active_record/enum.rb

@@ -1,5 +1,6 @@
 module ActiveRecord
-  # Declare an enum attribute where the values map to integers in the database, but can be queried by name. Example:
+  # Declare an enum attribute where the values map to integers in the database,
+  # but can be queried by name. Example:
   #
   #   class Conversation < ActiveRecord::Base
   #     enum status: [ :active, :archived ]
@@ -18,6 +19,15 @@ module ActiveRecord
   #   # conversation.update! status: 1
   #   conversation.status = "archived"
   #
+  #   # conversation.update! status: nil
+  #   conversation.status = nil
+  #   conversation.status.nil? # => true
+  #   conversation.status      # => nil
+  #
+  # Scopes based on the allowed values of the enum field will be provided
+  # as well. With the above example, it will create an +active+ and +archived+
+  # scope.
+  #
   # You can set the default value from the database declaration, like:
   #
   #   create_table :conversations do |t|
@@ -44,46 +54,76 @@ module ActiveRecord
   # remove unused values, the explicit +Hash+ syntax should be used.
   #
   # In rare circumstances you might need to access the mapping directly.
-  # The mappings are exposed through a constant with the attributes name:
+  # The mappings are exposed through a class method with the pluralized attribute
+  # name:
+  #
+  #   Conversation.statuses # => { "active" => 0, "archived" => 1 }
   #
-  #   Conversation::STATUS # => { "active" => 0, "archived" => 1 }
+  # Use that class method when you need to know the ordinal value of an enum:
   #
-  # Use that constant when you need to know the ordinal value of an enum:
+  #   Conversation.where("status <> ?", Conversation.statuses[:archived])
   #
-  #   Conversation.where("status <> ?", Conversation::STATUS[:archived])
+  # Where conditions on an enum attribute must use the ordinal value of an enum.
   module Enum
+    DEFINED_ENUMS = {} # :nodoc:
+
+    def enum_mapping_for(attr_name) # :nodoc:
+      DEFINED_ENUMS[attr_name.to_s]
+    end
+
     def enum(definitions)
       klass = self
       definitions.each do |name, values|
-        # DIRECTION = { }
-        enum_values = _enum_methods_module.const_set name.to_s.upcase, ActiveSupport::HashWithIndifferentAccess.new
+        # statuses = { }
+        enum_values = ActiveSupport::HashWithIndifferentAccess.new
         name        = name.to_sym
 
+        # def self.statuses statuses end
+        detect_enum_conflict!(name, name.to_s.pluralize, true)
+        klass.singleton_class.send(:define_method, name.to_s.pluralize) { enum_values }
+
         _enum_methods_module.module_eval do
-          # def direction=(value) self[:direction] = DIRECTION[value] end
+          # def status=(value) self[:status] = statuses[value] end
+          klass.send(:detect_enum_conflict!, name, "#{name}=")
           define_method("#{name}=") { |value|
-            unless enum_values.has_key?(value)
+            if enum_values.has_key?(value) || value.blank?
+              self[name] = enum_values[value]
+            elsif enum_values.has_value?(value)
+              # Assigning a value directly is not a end-user feature, hence it's not documented.
+              # This is used internally to make building objects from the generated scopes work
+              # as expected, i.e. +Conversation.archived.build.archived?+ should be true.
+              self[name] = value
+            else
               raise ArgumentError, "'#{value}' is not a valid #{name}"
             end
-            self[name] = enum_values[value]
           }
 
-          # def direction() DIRECTION.key self[:direction] end
+          # def status() statuses.key self[:status] end
+          klass.send(:detect_enum_conflict!, name, name)
           define_method(name) { enum_values.key self[name] }
 
+          # def status_before_type_cast() statuses.key self[:status] end
+          klass.send(:detect_enum_conflict!, name, "#{name}_before_type_cast")
+          define_method("#{name}_before_type_cast") { enum_values.key self[name] }
+
           pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
           pairs.each do |value, i|
             enum_values[value] = i
 
-            # scope :incoming, -> { where direction: 0 }
-            klass.scope value, -> { klass.where name => i }
-
-            # def incoming?() direction == 0 end
+            # def active?() status == 0 end
+            klass.send(:detect_enum_conflict!, name, "#{value}?")
             define_method("#{value}?") { self[name] == i }
 
-            # def incoming! update! direction: :incoming end
+            # def active!() update! status: :active end
+            klass.send(:detect_enum_conflict!, name, "#{value}!")
             define_method("#{value}!") { update! name => value }
+
+            # scope :active, -> { where status: 0 }
+            klass.send(:detect_enum_conflict!, name, value, true)
+            klass.scope value, -> { klass.where name => i }
           end
+
+          DEFINED_ENUMS[name.to_s] = enum_values
         end
       end
     end
@@ -91,10 +131,64 @@ module ActiveRecord
     private
       def _enum_methods_module
         @_enum_methods_module ||= begin
-          mod = Module.new
+          mod = Module.new do
+            private
+              def save_changed_attribute(attr_name, value)
+                if (mapping = self.class.enum_mapping_for(attr_name))
+                  if attribute_changed?(attr_name)
+                    old = changed_attributes[attr_name]
+
+                    if mapping[old] == value
+                      changed_attributes.delete(attr_name)
+                    end
+                  else
+                    old = clone_attribute_value(:read_attribute, attr_name)
+
+                    if old != value
+                      changed_attributes[attr_name] = mapping.key old
+                    end
+                  end
+                else
+                  super
+                end
+              end
+          end
           include mod
           mod
         end
       end
+
+      ENUM_CONFLICT_MESSAGE = \
+        "You tried to define an enum named \"%{enum}\" on the model \"%{klass}\", but " \
+        "this will generate a %{type} method \"%{method}\", which is already defined " \
+        "by %{source}."
+
+      def detect_enum_conflict!(enum_name, method_name, klass_method = false)
+        if klass_method && dangerous_class_method?(method_name)
+          raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
+            enum: enum_name,
+            klass: self.name,
+            type: 'class',
+            method: method_name,
+            source: 'Active Record'
+          }
+        elsif !klass_method && dangerous_attribute_method?(method_name)
+          raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
+            enum: enum_name,
+            klass: self.name,
+            type: 'instance',
+            method: method_name,
+            source: 'Active Record'
+          }
+        elsif !klass_method && method_defined_within?(method_name, _enum_methods_module, Module)
+          raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
+            enum: enum_name,
+            klass: self.name,
+            type: 'instance',
+            method: method_name,
+            source: 'another enum'
+          }
+        end
+      end
   end
 end

data/lib/active_record/errors.rb

@@ -94,6 +94,18 @@ module ActiveRecord
   class PreparedStatementInvalid < ActiveRecordError
   end
 
+  # Raised when a given database does not exist
+  class NoDatabaseError < ActiveRecordError
+    def initialize(message)
+      super extend_message(message)
+    end
+
+    # can be over written to add additional error information.
+    def extend_message(message)
+      message
+    end
+  end
+
   # Raised on attempt to save stale record. Record is stale when it's being saved in another query after
   # instantiation, for example, when two users edit the same wiki page and one starts editing and saves
   # the page before the other.

data/lib/active_record/fixtures.rb

@@ -462,7 +462,7 @@ module ActiveRecord
         @class_names.delete_if { |k,klass|
           unless klass.is_a? Class
             klass = klass.safe_constantize
-            ActiveSupport::Deprecation.warn("The ability to pass in strings as a class name will be removed in Rails 4.2, consider using the class itself instead.")
+            ActiveSupport::Deprecation.warn("The ability to pass in strings as a class name to `set_fixture_class` will be removed in Rails 4.2. Use the class itself instead.")
           end
           !insert_class(@class_names, k, klass)
         }
@@ -521,8 +521,16 @@ module ActiveRecord
           connection.transaction(:requires_new => true) do
             fixture_sets.each do |fs|
               conn = fs.model_class.respond_to?(:connection) ? fs.model_class.connection : connection
-              fs.fixture_sql(conn).each do |stmt|
-                conn.execute stmt
+              table_rows = fs.table_rows
+
+              table_rows.keys.each do |table|
+                conn.delete "DELETE FROM #{conn.quote_table_name(table)}", 'Fixture Delete'
+              end
+
+              table_rows.each do |fixture_set_name, rows|
+                rows.each do |row|
+                  conn.insert_fixture(row, fixture_set_name)
+                end
               end
             end
 
@@ -560,7 +568,7 @@ module ActiveRecord
       @model_class = nil
 
       if class_name.is_a?(String)
-        ActiveSupport::Deprecation.warn("The ability to pass in strings as a class name will be removed in Rails 4.2, consider using the class itself instead.")
+        ActiveSupport::Deprecation.warn("The ability to pass in strings as a class name to `FixtureSet.new` will be removed in Rails 4.2. Use the class itself instead.")
       end
 
       if class_name.is_a?(Class) # TODO: Should be an AR::Base type class, or any?
@@ -594,17 +602,7 @@ module ActiveRecord
       fixtures.size
     end
 
-    def fixture_sql(conn)
-      table_rows = self.table_rows
-
-      table_rows.keys.map { |table|
-        "DELETE FROM #{conn.quote_table_name(table)}"
-      }.concat table_rows.flat_map { |fixture_set_name, rows|
-        rows.map { |row| conn.fixture_sql(row, fixture_set_name) }
-      }
-    end
-
-    # Return a hash of rows to be inserted. The key is the table, the value is
+    # Returns a hash of rows to be inserted. The key is the table, the value is
     # a list of rows to insert to that table.
     def table_rows
       now = config.default_timezone == :utc ? Time.now.utc : Time.now

data/lib/active_record/inheritance.rb

@@ -16,15 +16,19 @@ module ActiveRecord
       # 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."
+          raise NotImplementedError, "#{self} is an abstract class and cannot be instantiated."
         end
-        if (attrs = args.first).is_a?(Hash)
-          if subclass = subclass_from_attrs(attrs)
-            return subclass.new(*args, &block)
-          end
+
+        attrs = args.first
+        if subclass_from_attributes?(attrs)
+          subclass = subclass_from_attributes(attrs)
+        end
+
+        if subclass
+          subclass.new(*args, &block)
+        else
+          super
         end
-        # Delegate to the original .new
-        super
       end
 
       # Returns +true+ if this does not need STI type condition. Returns
@@ -45,10 +49,12 @@ module ActiveRecord
       end
 
       def symbolized_base_class
+        ActiveSupport::Deprecation.warn("ActiveRecord::Base.symbolized_base_class is deprecated and will be removed without replacement.")
         @symbolized_base_class ||= base_class.to_s.to_sym
       end
 
       def symbolized_sti_name
+        ActiveSupport::Deprecation.warn("ActiveRecord::Base.symbolized_sti_name is deprecated and will be removed without replacement.")
         @symbolized_sti_name ||= sti_name.present? ? sti_name.to_sym : symbolized_base_class
       end
 
@@ -124,7 +130,7 @@ module ActiveRecord
             end
           end
 
-          raise NameError, "uninitialized constant #{candidates.first}"
+          raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
         end
       end
 
@@ -170,7 +176,11 @@ module ActiveRecord
       # is not self or a valid subclass, raises ActiveRecord::SubclassNotFound
       # If this is a StrongParameters hash, and access to inheritance_column is not permitted,
       # this will ignore the inheritance column and return nil
-      def subclass_from_attrs(attrs)
+      def subclass_from_attributes?(attrs)
+        columns_hash.include?(inheritance_column) && attrs.is_a?(Hash)
+      end
+
+      def subclass_from_attributes(attrs)
         subclass_name = attrs.with_indifferent_access[inheritance_column]
 
         if subclass_name.present? && subclass_name != self.name
@@ -185,8 +195,18 @@ module ActiveRecord
       end
     end
 
+    def initialize_dup(other)
+      super
+      ensure_proper_type
+    end
+
     private
 
+    def initialize_internals_callback
+      super
+      ensure_proper_type
+    end
+
     # Sets the attribute used for single table inheritance to this class name if this is not the
     # ActiveRecord::Base descendant.
     # Considering the hierarchy Reply < Message < ActiveRecord::Base, this makes it possible to

data/lib/active_record/integration.rb

@@ -98,8 +98,10 @@ module ActiveRecord
           super()
         else
           define_method :to_param do
-            if (default = super()) && (result = send(method_name).to_s).present?
-              "#{default}-#{result.squish.truncate(20, separator: /\s/, omission: nil).parameterize}"
+            if (default = super()) &&
+                 (result = send(method_name).to_s).present? &&
+                   (param = result.squish.truncate(20, separator: /\s/, omission: nil).parameterize).present?
+              "#{default}-#{param}"
             else
               default
             end

data/lib/active_record/migration.rb

@@ -385,8 +385,21 @@ module ActiveRecord
       attr_accessor :delegate # :nodoc:
       attr_accessor :disable_ddl_transaction # :nodoc:
 
-      def check_pending!
-        raise ActiveRecord::PendingMigrationError if ActiveRecord::Migrator.needs_migration?
+      def check_pending!(connection = Base.connection)
+        raise ActiveRecord::PendingMigrationError if ActiveRecord::Migrator.needs_migration?(connection)
+      end
+
+      def load_schema_if_pending!
+        if ActiveRecord::Migrator.needs_migration?
+          ActiveRecord::Tasks::DatabaseTasks.load_schema
+          check_pending!
+        end
+      end
+
+      def maintain_test_schema! # :nodoc:
+        if ActiveRecord::Base.maintain_test_schema
+          suppress_messages { load_schema_if_pending! }
+        end
       end
 
       def method_missing(name, *args, &block) # :nodoc:
@@ -746,7 +759,7 @@ module ActiveRecord
 
       def load_migration
         require(File.expand_path(filename))
-        name.constantize.new
+        name.constantize.new(name, version)
       end
 
   end
@@ -817,17 +830,17 @@ module ActiveRecord
         SchemaMigration.all.map { |x| x.version.to_i }.sort
       end
 
-      def current_version
+      def current_version(connection = Base.connection)
         sm_table = schema_migrations_table_name
-        if Base.connection.table_exists?(sm_table)
+        if connection.table_exists?(sm_table)
           get_all_versions.max || 0
         else
           0
         end
       end
 
-      def needs_migration?
-        current_version < last_version
+      def needs_migration?(connection = Base.connection)
+        current_version(connection) < last_version
       end
 
       def last_version

data/lib/active_record/migration/command_recorder.rb

@@ -74,7 +74,7 @@ module ActiveRecord
         :rename_index, :rename_column, :add_index, :remove_index, :add_timestamps, :remove_timestamps,
         :change_column_default, :add_reference, :remove_reference, :transaction,
         :drop_join_table, :drop_table, :execute_block, :enable_extension,
-        :change_column, :execute, :remove_columns, # irreversible methods need to be here too
+        :change_column, :execute, :remove_columns, :change_column_null # irreversible methods need to be here too
       ].each do |method|
         class_eval <<-EOV, __FILE__, __LINE__ + 1
           def #{method}(*args, &block)          # def create_table(*args, &block)
@@ -86,7 +86,7 @@ module ActiveRecord
       alias :remove_belongs_to :remove_reference
 
       def change_table(table_name, options = {})
-        yield ConnectionAdapters::Table.new(table_name, self)
+        yield delegate.update_table_definition(table_name, self)
       end
 
       private
@@ -140,7 +140,12 @@ module ActiveRecord
 
       def invert_add_index(args)
         table, columns, options = *args
-        [:remove_index, [table, (options || {}).merge(column: columns)]]
+        options ||= {}
+
+        index_name = options[:name]
+        options_hash = index_name ? { name: index_name } : { column: columns }
+
+        [:remove_index, [table, options_hash]]
       end
 
       def invert_remove_index(args)
@@ -157,11 +162,18 @@ module ActiveRecord
       alias :invert_add_belongs_to :invert_add_reference
       alias :invert_remove_belongs_to :invert_remove_reference
 
+      def invert_change_column_null(args)
+        args[2] = !args[2]
+        [:change_column_null, args]
+      end
+
       # Forwards any missing method call to the \target.
       def method_missing(method, *args, &block)
-        @delegate.send(method, *args, &block)
-      rescue NoMethodError => e
-        raise e, e.message.sub(/ for #<.*$/, " via proxy for #{@delegate}")
+        if @delegate.respond_to?(method)
+          @delegate.send(method, *args, &block)
+        else
+          super
+        end
       end
     end
   end