activerecord 3.2.19 → 5.0.0

data/lib/active_record/gem_version.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  # Returns the version of the currently loaded Active Record as a <tt>Gem::Version</tt>
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 5
+    MINOR = 0
+    TINY  = 0
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/active_record/inheritance.rb

@@ -1,19 +1,77 @@
-require 'active_support/concern'
+require 'active_support/core_ext/hash/indifferent_access'
 
 module ActiveRecord
+  # == Single table inheritance
+  #
+  # Active Record allows inheritance by storing the name of the class in a column that by
+  # default is named "type" (can be changed by overwriting <tt>Base.inheritance_column</tt>).
+  # This means that an inheritance looking like this:
+  #
+  #   class Company < ActiveRecord::Base; end
+  #   class Firm < Company; end
+  #   class Client < Company; end
+  #   class PriorityClient < Client; end
+  #
+  # When you do <tt>Firm.create(name: "37signals")</tt>, this record will be saved in
+  # the companies table with type = "Firm". You can then fetch this row again using
+  # <tt>Company.where(name: '37signals').first</tt> and it will return a Firm object.
+  #
+  # Be aware that because the type column is an attribute on the record every new
+  # subclass will instantly be marked as dirty and the type column will be included
+  # in the list of changed attributes on the record. This is different from non
+  # STI classes:
+  #
+  #   Company.new.changed? # => false
+  #   Firm.new.changed?    # => true
+  #   Firm.new.changes     # => {"type"=>["","Firm"]}
+  #
+  # If you don't have a type column defined in your table, single-table inheritance won't
+  # be triggered. In that case, it'll work just like normal subclasses with no special magic
+  # for differentiating between them or reloading the right type with find.
+  #
+  # Note, all the attributes for all the cases are kept in the same table. Read more:
+  # http://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
+  #
   module Inheritance
     extend ActiveSupport::Concern
 
     included do
-      # Determine whether to store the full constant name including namespace when using STI
-      class_attribute :store_full_sti_class
+      # Determines whether to store the full constant name including namespace when using STI.
+      class_attribute :store_full_sti_class, instance_writer: false
       self.store_full_sti_class = true
     end
 
     module ClassMethods
-      # True if this isn't a concrete subclass needing a STI type condition.
+      # 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 abstract_class? || self == Base
+          raise NotImplementedError, "#{self} is an abstract class and cannot be instantiated."
+        end
+
+        attrs = args.first
+        if has_attribute?(inheritance_column)
+          subclass = subclass_from_attributes(attrs)
+
+          if subclass.nil? && base_class == self
+            subclass = subclass_from_attributes(column_defaults)
+          end
+        end
+
+        if subclass && subclass != self
+          subclass.new(*args, &block)
+        else
+          super
+        end
+      end
+
+      # Returns +true+ if this does not need STI type condition. Returns
+      # +false+ if STI type condition needs to be applied.
       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)
@@ -25,25 +83,41 @@ module ActiveRecord
         :true == (@finder_needs_type_condition ||= descends_from_active_record? ? :false : :true)
       end
 
-      def symbolized_base_class
-        @symbolized_base_class ||= base_class.to_s.to_sym
-      end
-
-      def symbolized_sti_name
-        @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 ActiveRecord::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 +129,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)
@@ -99,66 +145,85 @@ module ActiveRecord
           candidates << type_name
 
           candidates.each do |candidate|
-            begin
-              constant = ActiveSupport::Dependencies.constantize(candidate)
-              return constant if candidate == constant.to_s
-            rescue NameError => e
-              # We don't want to swallow NoMethodError < NameError errors
-              raise e unless e.instance_of?(NameError)
-            end
+            constant = ActiveSupport::Dependencies.safe_constantize(candidate)
+            return constant if candidate == constant.to_s
           end
 
-          raise NameError, "uninitialized constant #{candidates.first}"
+          raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
         end
       end
 
       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? && has_attribute?(inheritance_column)
       end
 
       def find_sti_class(type_name)
-        if type_name.blank? || !columns_hash.include?(inheritance_column)
-          self
-        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."
+        type_name = base_class.type_for_attribute(inheritance_column).cast(type_name)
+        subclass = 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
+        unless subclass == self || descendants.include?(subclass)
+          raise SubclassNotFound, "Invalid single-table inheritance type: #{subclass.name} is not a subclass of #{name}"
         end
+        subclass
       end
 
       def type_condition(table = arel_table)
-        sti_column = table[inheritance_column.to_sym]
-        sti_names  = ([self] + descendants).map { |model| model.sti_name }
+        sti_column = arel_attribute(inheritance_column, table)
+        sti_names  = ([self] + descendants).map(&:sti_name)
 
         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
+      def subclass_from_attributes(attrs)
+        attrs = attrs.to_h if attrs.respond_to?(:permitted?)
+        if attrs.is_a?(Hash)
+          subclass_name = attrs.with_indifferent_access[inheritance_column]
+
+          if subclass_name.present?
+            find_sti_class(subclass_name)
+          end
+        end
+      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

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/string/filters'
+
 module ActiveRecord
   module Integration
     extend ActiveSupport::Concern
@@ -5,13 +7,15 @@ 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 +:usec+, by default.
       class_attribute :cache_timestamp_format, :instance_writer => false
-      self.cache_timestamp_format = :number
+      self.cache_timestamp_format = :usec
     end
 
-    # Returns a String, which Action Pack uses for constructing an URL to this
+    # Returns a String, which Action Pack uses for constructing a URL to this
     # object. The default implementation returns this record's id as a String,
     # or nil if this record's unsaved.
     #
@@ -19,7 +23,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
@@ -31,7 +35,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.
@@ -40,20 +44,69 @@ 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)
-    def cache_key
+    #
+    # You can also pass a list of named timestamps, and the newest in the list will be
+    # used to generate the key:
+    #
+    #   Person.find(5).cache_key(:updated_at, :last_reviewed_at)
+    def cache_key(*timestamp_names)
       case
       when new_record?
-        "#{self.class.model_name.cache_key}/new"
-      when timestamp = self[:updated_at]
+        "#{model_name.cache_key}/new"
+      when timestamp_names.any?
+        timestamp = max_updated_column_timestamp(timestamp_names)
         timestamp = timestamp.utc.to_s(cache_timestamp_format)
-        "#{self.class.model_name.cache_key}/#{id}-#{timestamp}"
+        "#{model_name.cache_key}/#{id}-#{timestamp}"
+      when timestamp = max_updated_column_timestamp
+        timestamp = timestamp.utc.to_s(cache_timestamp_format)
+        "#{model_name.cache_key}/#{id}-#{timestamp}"
       else
-        "#{self.class.model_name.cache_key}/#{id}"
+        "#{model_name.cache_key}/#{id}"
+      end
+    end
+
+    module ClassMethods
+      # Defines your model's +to_param+ method to generate "pretty" URLs
+      # using +method_name+, which can be any attribute or method that
+      # responds to +to_s+.
+      #
+      #   class User < ActiveRecord::Base
+      #     to_param :name
+      #   end
+      #
+      #   user = User.find_by(name: 'Fancy Pants')
+      #   user.id         # => 123
+      #   user_path(user) # => "/users/123-fancy-pants"
+      #
+      # Values longer than 20 characters will be truncated. The value
+      # is truncated word by word.
+      #
+      #   user = User.find_by(name: 'David Heinemeier Hansson')
+      #   user.id         # => 125
+      #   user_path(user) # => "/users/125-david"
+      #
+      # Because the generated param begins with the record's +id+, it is
+      # suitable for passing to +find+. In a controller, for example:
+      #
+      #   params[:id]               # => "123-fancy-pants"
+      #   User.find(params[:id]).id # => 123
+      def to_param(method_name = nil)
+        if method_name.nil?
+          super()
+        else
+          define_method :to_param do
+            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
+          end
+        end
       end
     end
   end

data/lib/active_record/internal_metadata.rb

@@ -0,0 +1,56 @@
+require 'active_record/scoping/default'
+require 'active_record/scoping/named'
+
+module ActiveRecord
+  # This class is used to create a table that keeps track of values and keys such
+  # as which environment migrations were run in.
+  class InternalMetadata < ActiveRecord::Base # :nodoc:
+    class << self
+      def primary_key
+        "key"
+      end
+
+      def table_name
+        "#{table_name_prefix}#{ActiveRecord::Base.internal_metadata_table_name}#{table_name_suffix}"
+      end
+
+      def original_table_name
+        "#{table_name_prefix}active_record_internal_metadatas#{table_name_suffix}"
+      end
+
+      def []=(key, value)
+        find_or_initialize_by(key: key).update_attributes!(value: value)
+      end
+
+      def [](key)
+        where(key: key).pluck(:value).first
+      end
+
+      def table_exists?
+        ActiveSupport::Deprecation.silence { connection.table_exists?(table_name) }
+      end
+
+      def original_table_exists?
+        # This method will be removed in Rails 5.1
+        # Since it is only necessary when `active_record_internal_metadatas` could exist
+        ActiveSupport::Deprecation.silence { connection.table_exists?(original_table_name) }
+      end
+
+      # Creates an internal metadata table with columns +key+ and +value+
+      def create_table
+        if original_table_exists?
+          connection.rename_table(original_table_name, table_name)
+        end
+        unless table_exists?
+          key_options = connection.internal_string_options_for_primary_key
+
+          connection.create_table(table_name, id: false) do |t|
+            t.string :key, key_options
+            t.string :value
+            t.timestamps
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/legacy_yaml_adapter.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+  module LegacyYamlAdapter
+    def self.convert(klass, coder)
+      return coder unless coder.is_a?(Psych::Coder)
+
+      case coder["active_record_yaml_version"]
+      when 1 then coder
+      else
+        if coder["attributes"].is_a?(AttributeSet)
+          Rails420.convert(klass, coder)
+        else
+          Rails41.convert(klass, coder)
+        end
+      end
+    end
+
+    module Rails420
+      def self.convert(klass, coder)
+        attribute_set = coder["attributes"]
+
+        klass.attribute_names.each do |attr_name|
+          attribute = attribute_set[attr_name]
+          if attribute.type.is_a?(Delegator)
+            type_from_klass = klass.type_for_attribute(attr_name)
+            attribute_set[attr_name] = attribute.with_type(type_from_klass)
+          end
+        end
+
+        coder
+      end
+    end
+
+    module Rails41
+      def self.convert(klass, coder)
+        attributes = klass.attributes_builder
+          .build_from_database(coder["attributes"])
+        new_record = coder["attributes"][klass.primary_key].blank?
+
+        {
+          "attributes" => attributes,
+          "new_record" => new_record,
+        }
+      end
+    end
+  end
+end

data/lib/active_record/locale/en.yml

@@ -4,12 +4,20 @@ en:
     #created_at: "Created at"
     #updated_at: "Updated at"
 
+  # Default error messages
+  errors:
+    messages:
+      required: "must exist"
+      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:
+          has_one: "Cannot delete record because a dependent %{record} exists"
+          has_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.