activerecord 3.2.22.5 → 4.0.0.beta1

data/lib/active_record/inheritance.rb

@@ -1,4 +1,4 @@
-require 'active_support/concern'
+require 'active_support/core_ext/hash/indifferent_access'
 
 module ActiveRecord
   module Inheritance
@@ -6,14 +6,29 @@ module ActiveRecord
 
     included do
       # Determine whether to store the full constant name including namespace when using STI
-      class_attribute :store_full_sti_class
+      class_attribute :store_full_sti_class, instance_writer: false
       self.store_full_sti_class = true
     end
 
     module ClassMethods
+      # Determines if one of the attributes passed in is the inheritance column,
+      # 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 (attrs = args.first).is_a?(Hash)
+          if subclass = subclass_from_attrs(attrs)
+            return subclass.new(*args, &block)
+          end
+        end
+        # Delegate to the original .new
+        super
+      end
+
       # True if this isn't a concrete subclass needing a STI type condition.
       def descends_from_active_record?
-        if superclass.abstract_class?
+        if self == Base
+          false
+        elsif superclass.abstract_class?
           superclass.descends_from_active_record?
         else
           superclass == Base || !columns_hash.include?(inheritance_column)
@@ -33,17 +48,41 @@ module ActiveRecord
         @symbolized_sti_name ||= sti_name.present? ? sti_name.to_sym : symbolized_base_class
       end
 
-      # Returns the base AR subclass that this class descends from. If A
-      # extends AR::Base, A.base_class will return A. If B descends from A
+      # Returns the class descending directly from ActiveRecord::Base, or
+      # an abstract class, if any, in the inheritance hierarchy.
+      #
+      # If A extends AR::Base, A.base_class will return A. If B descends from A
       # through some arbitrarily deep hierarchy, B.base_class will return A.
       #
       # If B < A and C < B and if A is an abstract_class then both B.base_class
       # and C.base_class would return B as the answer since A is an abstract_class.
       def base_class
-        class_of_active_record_descendant(self)
+        unless self < Base
+          raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
+        end
+
+        if superclass == Base || superclass.abstract_class?
+          self
+        else
+          superclass.base_class
+        end
       end
 
       # Set this to true if this is an abstract class (see <tt>abstract_class?</tt>).
+      # If you are using inheritance with ActiveRecord and don't want child classes
+      # to utilize the implied STI table name of the parent class, this will need to be true.
+      # For example, given the following:
+      #
+      #   class SuperClass < ActiveRecord::Base
+      #     self.abstract_class = true
+      #   end
+      #   class Child < SuperClass
+      #     self.table_name = 'the_table_i_really_want'
+      #   end
+      #
+      #
+      # <tt>self.abstract_class = true</tt> is required to make <tt>Child<.find,.create, or any Arel method></tt> use <tt>the_table_i_really_want</tt> instead of a table called <tt>super_classes</tt>
+      #
       attr_accessor :abstract_class
 
       # Returns whether this class is an abstract class or not.
@@ -55,36 +94,8 @@ module ActiveRecord
         store_full_sti_class ? name : name.demodulize
       end
 
-      # Finder methods must instantiate through this method to work with the
-      # single-table inheritance model that makes it possible to create
-      # objects of different types from the same table.
-      def instantiate(record)
-        sti_class = find_sti_class(record[inheritance_column])
-        record_id = sti_class.primary_key && record[sti_class.primary_key]
-
-        if ActiveRecord::IdentityMap.enabled? && record_id
-          instance = use_identity_map(sti_class, record_id, record)
-        else
-          instance = sti_class.allocate.init_with('attributes' => record)
-        end
-
-        instance
-      end
-
       protected
 
-      # Returns the class descending directly from ActiveRecord::Base or an
-      # abstract class, if any, in the inheritance hierarchy.
-      def class_of_active_record_descendant(klass)
-        if klass == Base || klass.superclass == Base || klass.superclass.abstract_class?
-          klass
-        elsif klass.superclass.nil?
-          raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
-        else
-          class_of_active_record_descendant(klass.superclass)
-        end
-      end
-
       # Returns the class type of the record using the current module as a prefix. So descendants of
       # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
       def compute_type(type_name)
@@ -114,39 +125,33 @@ module ActiveRecord
 
       private
 
-      def use_identity_map(sti_class, record_id, record)
-        if (column = sti_class.columns_hash[sti_class.primary_key]) && column.number?
-          record_id = record_id.to_i
-        end
-
-        if instance = IdentityMap.get(sti_class, record_id)
-          instance.reinit_with('attributes' => record)
+      # Called by +instantiate+ to decide which class to use for a new
+      # record instance. For single-table inheritance, we check the record
+      # for a +type+ column and return the corresponding class.
+      def discriminate_class_for_record(record)
+        if using_single_table_inheritance?(record)
+          find_sti_class(record[inheritance_column])
         else
-          instance = sti_class.allocate.init_with('attributes' => record)
-          IdentityMap.add(instance)
+          super
         end
+      end
 
-        instance
+      def using_single_table_inheritance?(record)
+        record[inheritance_column].present? && columns_hash.include?(inheritance_column)
       end
 
       def find_sti_class(type_name)
-        if type_name.blank? || !columns_hash.include?(inheritance_column)
-          self
+        if store_full_sti_class
+          ActiveSupport::Dependencies.constantize(type_name)
         else
-          begin
-            if store_full_sti_class
-              ActiveSupport::Dependencies.constantize(type_name)
-            else
-              compute_type(type_name)
-            end
-          rescue NameError
-            raise SubclassNotFound,
-              "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " +
-              "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " +
-              "Please rename this column if you didn't intend it to be used for storing the inheritance class " +
-              "or overwrite #{name}.inheritance_column to use another column for that information."
-          end
+          compute_type(type_name)
         end
+      rescue NameError
+        raise SubclassNotFound,
+          "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " +
+          "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " +
+          "Please rename this column if you didn't intend it to be used for storing the inheritance class " +
+          "or overwrite #{name}.inheritance_column to use another column for that information."
       end
 
       def type_condition(table = arel_table)
@@ -155,6 +160,19 @@ module ActiveRecord
 
         sti_column.in(sti_names)
       end
+
+      # Detect the subclass from the inheritance column of attrs. If the inheritance column value
+      # 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)
+        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}")
+        end
+        subclass
+      end
     end
 
     private

data/lib/active_record/integration.rb

@@ -5,10 +5,12 @@ module ActiveRecord
     included do
       ##
       # :singleton-method:
-      # Indicates the format used to generate the timestamp format in the cache key.
-      # This is +:number+, by default.
+      # Indicates the format used to generate the timestamp in the cache key.
+      # Accepts any of the symbols in <tt>Time::DATE_FORMATS</tt>.
+      #
+      # This is +:nsec+, by default.
       class_attribute :cache_timestamp_format, :instance_writer => false
-      self.cache_timestamp_format = :number
+      self.cache_timestamp_format = :nsec
     end
 
     # Returns a String, which Action Pack uses for constructing an URL to this
@@ -40,8 +42,6 @@ module ActiveRecord
 
     # Returns a cache key that can be used to identify this record.
     #
-    # ==== Examples
-    #
     #   Product.new.cache_key     # => "products/new"
     #   Product.find(5).cache_key # => "products/5" (updated_at not available)
     #   Person.find(5).cache_key  # => "people/5-20071224150000" (updated_at available)

data/lib/active_record/locale/en.yml

@@ -4,12 +4,19 @@ en:
     #created_at: "Created at"
     #updated_at: "Updated at"
 
+  # Default error messages
+  errors:
+    messages:
+      taken: "has already been taken"
+
   # Active Record models configuration
   activerecord:
     errors:
       messages:
-        taken: "has already been taken"
         record_invalid: "Validation failed: %{errors}"
+        restrict_dependent_destroy:
+          one: "Cannot delete record because a dependent %{record} exists"
+          many: "Cannot delete record because dependent %{record} exist"
         # Append your own errors here or at the model/attributes scope.
 
       # You can define own errors for models or model attributes.

data/lib/active_record/locking/optimistic.rb

@@ -40,16 +40,18 @@ module ActiveRecord
     # This locking mechanism will function inside a single Ruby process. To make it work across all
     # web requests, the recommended approach is to add +lock_version+ as a hidden field to your form.
     #
-    # You must ensure that your database schema defaults the +lock_version+ column to 0.
-    #
     # This behavior can be turned off by setting <tt>ActiveRecord::Base.lock_optimistically = false</tt>.
-    # To override the name of the +lock_version+ column, invoke the <tt>set_locking_column</tt> method.
-    # This method uses the same syntax as <tt>set_table_name</tt>
+    # To override the name of the +lock_version+ column, set the <tt>locking_column</tt> class attribute:
+    #
+    #   class Person < ActiveRecord::Base
+    #     self.locking_column = :lock_person
+    #   end
+    #
     module Optimistic
       extend ActiveSupport::Concern
 
       included do
-        cattr_accessor :lock_optimistically, :instance_writer => false
+        class_attribute :lock_optimistically, instance_writer: false
         self.lock_optimistically = true
       end
 
@@ -64,7 +66,7 @@ module ActiveRecord
           send(lock_col + '=', previous_lock_value + 1)
         end
 
-        def update(attribute_names = @attributes.keys) #:nodoc:
+        def update_record(attribute_names = @attributes.keys) #:nodoc:
           return super unless locking_enabled?
           return 0 if attribute_names.empty?
 
@@ -80,9 +82,9 @@ module ActiveRecord
 
             stmt = relation.where(
               relation.table[self.class.primary_key].eq(id).and(
-                relation.table[lock_col].eq(quote_value(previous_lock_value, self.class.columns_hash[lock_col]))
+                relation.table[lock_col].eq(self.class.quote_value(previous_lock_value))
               )
-            ).arel.compile_update(arel_attributes_values(false, false, attribute_names))
+            ).arel.compile_update(arel_attributes_with_values_for_update(attribute_names))
 
             affected_rows = connection.update stmt
 
@@ -99,26 +101,29 @@ module ActiveRecord
           end
         end
 
-        def destroy #:nodoc:
-          return super unless locking_enabled?
+        def destroy_row
+          affected_rows = super
+
+          if locking_enabled? && affected_rows != 1
+            raise ActiveRecord::StaleObjectError.new(self, "destroy")
+          end
 
-          destroy_associations
+          affected_rows
+        end
 
-          if persisted?
-            table = self.class.arel_table
-            lock_col = self.class.locking_column
-            predicate = table[self.class.primary_key].eq(id).
-              and(table[lock_col].eq(send(lock_col).to_i))
+        def relation_for_destroy
+          relation = super
 
-            affected_rows = self.class.unscoped.where(predicate).delete_all
+          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)
 
-            unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError.new(self, "destroy")
-            end
+            relation = relation.where(self.class.arel_table[column_name].eq(substitute))
+            relation.bind_values << [column, self[column_name].to_i]
           end
 
-          @destroyed = true
-          freeze
+          relation
         end
 
       module ClassMethods
@@ -131,14 +136,9 @@ module ActiveRecord
           lock_optimistically && columns_hash[locking_column]
         end
 
-        def locking_column=(value)
-          @original_locking_column = @locking_column if defined?(@locking_column)
-          @locking_column          = value.to_s
-        end
-
         # Set the column to use for optimistic locking. Defaults to +lock_version+.
-        def set_locking_column(value = nil, &block)
-          deprecated_property_setter :locking_column, value, block
+        def locking_column=(value)
+          @locking_column = value.to_s
         end
 
         # The version column used for optimistic locking. Defaults to +lock_version+.
@@ -147,10 +147,6 @@ module ActiveRecord
           @locking_column
         end
 
-        def original_locking_column #:nodoc:
-          deprecated_original_property_getter :locking_column
-        end
-
         # Quote the column name used for optimistic locking.
         def quoted_locking_column
           connection.quote_column_name(locking_column)
@@ -168,16 +164,16 @@ module ActiveRecord
           super
         end
 
-        # If the locking column has no default value set,
-        # start the lock version at zero. Note we can't use
-        # <tt>locking_enabled?</tt> at this point as
-        # <tt>@attributes</tt> may not have been initialized yet.
-        def initialize_attributes(attributes, options = {}) #:nodoc:
-          if attributes.key?(locking_column) && lock_optimistically
-            attributes[locking_column] ||= 0
-          end
+        def column_defaults
+          @column_defaults ||= begin
+            defaults = super
+
+            if defaults.key?(locking_column) && lock_optimistically
+              defaults[locking_column] ||= 0
+            end
 
-          attributes
+            defaults
+          end
         end
       end
     end

data/lib/active_record/locking/pessimistic.rb

@@ -3,12 +3,12 @@ module ActiveRecord
     # Locking::Pessimistic provides support for row-level locking using
     # SELECT ... FOR UPDATE and other lock types.
     #
-    # Pass <tt>:lock => true</tt> to <tt>ActiveRecord::Base.find</tt> to obtain an exclusive
+    # Pass <tt>lock: true</tt> to <tt>ActiveRecord::Base.find</tt> to obtain an exclusive
     # lock on the selected rows:
     #   # select * from accounts where id=1 for update
-    #   Account.find(1, :lock => true)
+    #   Account.find(1, lock: true)
     #
-    # Pass <tt>:lock => 'some locking clause'</tt> to give a database-specific locking clause
+    # Pass <tt>lock: 'some locking clause'</tt> to give a database-specific locking clause
     # of your own such as 'LOCK IN SHARE MODE' or 'FOR UPDATE NOWAIT'. Example:
     #
     #   Account.transaction do
@@ -26,7 +26,7 @@ module ActiveRecord
     #
     #   Account.transaction do
     #     # select * from accounts where ...
-    #     accounts = Account.where(...).all
+    #     accounts = Account.where(...)
     #     account1 = accounts.detect { |account| ... }
     #     account2 = accounts.detect { |account| ... }
     #     # select * from accounts where id=? for update

data/lib/active_record/log_subscriber.rb

@@ -1,11 +1,13 @@
 module ActiveRecord
   class LogSubscriber < ActiveSupport::LogSubscriber
+    IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"]
+
     def self.runtime=(value)
-      Thread.current["active_record_sql_runtime"] = value
+      Thread.current[:active_record_sql_runtime] = value
     end
 
     def self.runtime
-      Thread.current["active_record_sql_runtime"] ||= 0
+      Thread.current[:active_record_sql_runtime] ||= 0
     end
 
     def self.reset_runtime
@@ -18,25 +20,33 @@ module ActiveRecord
       @odd_or_even = false
     end
 
+    def render_bind(column, value)
+      if column
+        if column.binary?
+          value = "<#{value.bytesize} bytes of binary data>"
+        end
+
+        [column.name, value]
+      else
+        [nil, value]
+      end
+    end
+
     def sql(event)
       self.class.runtime += event.duration
       return unless logger.debug?
 
       payload = event.payload
 
-      return if 'SCHEMA' == payload[:name]
+      return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
 
-      name  = '%s (%.1fms)' % [payload[:name], event.duration]
+      name  = "#{payload[:name]} (#{event.duration.round(1)}ms)"
       sql   = payload[:sql].squeeze(' ')
       binds = nil
 
       unless (payload[:binds] || []).empty?
         binds = "  " + payload[:binds].map { |col,v|
-          if col
-            [col.name, v]
-          else
-            [nil, v]
-          end
+          render_bind(col, v)
         }.inspect
       end