activerecord 3.2.22.5 → 5.2.8

data/lib/active_record/attribute_methods.rb

@@ -1,13 +1,15 @@
-require 'active_support/core_ext/enumerable'
-require 'active_support/deprecation'
+# frozen_string_literal: true
+
+require "mutex_m"
 
 module ActiveRecord
   # = Active Record Attribute Methods
-  module AttributeMethods #:nodoc:
+  module AttributeMethods
     extend ActiveSupport::Concern
     include ActiveModel::AttributeMethods
 
     included do
+      initialize_generated_modules
       include Read
       include Write
       include BeforeTypeCast
@@ -16,100 +18,118 @@ module ActiveRecord
       include TimeZoneConversion
       include Dirty
       include Serialization
-      include DeprecatedUnderscoreRead
 
-      # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
-      # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)).
-      # (Alias for the protected read_attribute method).
-      def [](attr_name)
-        read_attribute(attr_name)
-      end
+      delegate :column_for_attribute, to: :class
+    end
 
-      # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
-      # (Alias for the protected write_attribute method).
-      def []=(attr_name, value)
-        write_attribute(attr_name, value)
+    AttrNames = Module.new {
+      def self.set_name_cache(name, value)
+        const_name = "ATTR_#{name}"
+        unless const_defined? const_name
+          const_set const_name, value.dup.freeze
+        end
       end
+    }
+
+    BLACKLISTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass)
+
+    class GeneratedAttributeMethods < Module #:nodoc:
+      include Mutex_m
     end
 
     module ClassMethods
-      # Generates all the attribute related methods for columns in the database
-      # accessors, mutators and query methods.
-      def define_attribute_methods
-        unless defined?(@attribute_methods_mutex)
-          msg = "It looks like something (probably a gem/plugin) is overriding the " \
-                "ActiveRecord::Base.inherited method. It is important that this hook executes so " \
-                "that your models are set up correctly. A workaround has been added to stop this " \
-                "causing an error in 3.2, but future versions will simply not work if the hook is " \
-                "overridden. If you are using Kaminari, please upgrade as it is known to have had " \
-                "this problem.\n\n"
-          msg << "The following may help track down the problem:"
-
-          meth = method(:inherited)
-          if meth.respond_to?(:source_location)
-            msg << " #{meth.source_location.inspect}"
-          else
-            msg << " #{meth.inspect}"
-          end
-          msg << "\n\n"
+      def inherited(child_class) #:nodoc:
+        child_class.initialize_generated_modules
+        super
+      end
 
-          ActiveSupport::Deprecation.warn(msg)
+      def initialize_generated_modules # :nodoc:
+        @generated_attribute_methods = GeneratedAttributeMethods.new
+        @attribute_methods_generated = false
+        include @generated_attribute_methods
 
-          @attribute_methods_mutex = Mutex.new
-        end
+        super
+      end
 
-        # Use a mutex; we don't want two thread simaltaneously trying to define
+      # Generates all the attribute related methods for columns in the database
+      # accessors, mutators and query methods.
+      def define_attribute_methods # :nodoc:
+        return false if @attribute_methods_generated
+        # Use a mutex; we don't want two threads simultaneously trying to define
         # attribute methods.
-        @attribute_methods_mutex.synchronize do
-          return if attribute_methods_generated?
+        generated_attribute_methods.synchronize do
+          return false if @attribute_methods_generated
           superclass.define_attribute_methods unless self == base_class
-          super(column_names)
-          column_names.each { |name| define_external_attribute_method(name) }
+          super(attribute_names)
           @attribute_methods_generated = true
         end
       end
 
-      def attribute_methods_generated?
-        @attribute_methods_generated ||= false
-      end
-
-      # We will define the methods as instance methods, but will call them as singleton
-      # methods. This allows us to use method_defined? to check if the method exists,
-      # which is fast and won't give any false positives from the ancestors (because
-      # there are no ancestors).
-      def generated_external_attribute_methods
-        @generated_external_attribute_methods ||= Module.new { extend self }
-      end
-
-      def undefine_attribute_methods
-        super
-        @attribute_methods_generated = false
+      def undefine_attribute_methods # :nodoc:
+        generated_attribute_methods.synchronize do
+          super if defined?(@attribute_methods_generated) && @attribute_methods_generated
+          @attribute_methods_generated = false
+        end
       end
 
+      # Raises an ActiveRecord::DangerousAttributeError exception when an
+      # \Active \Record method is defined in the model, otherwise +false+.
+      #
+      #   class Person < ActiveRecord::Base
+      #     def save
+      #       'already defined by Active Record'
+      #     end
+      #   end
+      #
+      #   Person.instance_method_already_implemented?(:save)
+      #   # => ActiveRecord::DangerousAttributeError: save is defined by Active Record. Check to make sure that you don't have an attribute or method with the same name.
+      #
+      #   Person.instance_method_already_implemented?(:name)
+      #   # => false
       def instance_method_already_implemented?(method_name)
         if dangerous_attribute_method?(method_name)
-          raise DangerousAttributeError, "#{method_name} is defined by ActiveRecord"
+          raise DangerousAttributeError, "#{method_name} is defined by Active Record. Check to make sure that you don't have an attribute or method with the same name."
         end
 
         if superclass == Base
           super
         else
-          # If B < A and A defines its own attribute method, then we don't want to overwrite that.
-          defined = method_defined_within?(method_name, superclass, superclass.generated_attribute_methods)
-          defined && !ActiveRecord::Base.method_defined?(method_name) || super
+          # If ThisClass < ... < SomeSuperClass < ... < Base and SomeSuperClass
+          # defines its own attribute method, then we don't want to overwrite that.
+          defined = method_defined_within?(method_name, superclass, Base) &&
+            ! superclass.instance_method(method_name).owner.is_a?(GeneratedAttributeMethods)
+          defined || super
         end
       end
 
-      # A method name is 'dangerous' if it is already defined by Active Record, but
+      # A method name is 'dangerous' if it is already (re)defined by Active Record, but
       # not by any ancestors. (So 'puts' is not dangerous but 'save' is.)
-      def dangerous_attribute_method?(name)
+      def dangerous_attribute_method?(name) # :nodoc:
         method_defined_within?(name, Base)
       end
 
-      def method_defined_within?(name, klass, sup = klass.superclass)
+      def method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
         if klass.method_defined?(name) || klass.private_method_defined?(name)
-          if sup.method_defined?(name) || sup.private_method_defined?(name)
-            klass.instance_method(name).owner != sup.instance_method(name).owner
+          if superklass.method_defined?(name) || superklass.private_method_defined?(name)
+            klass.instance_method(name).owner != superklass.instance_method(name).owner
+          else
+            true
+          end
+        else
+          false
+        end
+      end
+
+      # A class method is 'dangerous' if it is already (re)defined by Active Record, but
+      # not by any ancestors. (So 'puts' is not dangerous but 'new' is.)
+      def dangerous_class_method?(method_name)
+        BLACKLISTED_CLASS_METHODS.include?(method_name.to_s) || class_method_defined_within?(method_name, Base)
+      end
+
+      def class_method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
+        if klass.respond_to?(name, true)
+          if superklass.respond_to?(name, true)
+            klass.method(name).owner != superklass.method(name).owner
           else
             true
           end
@@ -118,92 +138,216 @@ module ActiveRecord
         end
       end
 
+      # Returns +true+ if +attribute+ is an attribute method and table exists,
+      # +false+ otherwise.
+      #
+      #   class Person < ActiveRecord::Base
+      #   end
+      #
+      #   Person.attribute_method?('name')   # => true
+      #   Person.attribute_method?(:age=)    # => true
+      #   Person.attribute_method?(:nothing) # => false
       def attribute_method?(attribute)
-        super || (table_exists? && column_names.include?(attribute.to_s.sub(/=$/, '')))
+        super || (table_exists? && column_names.include?(attribute.to_s.sub(/=$/, "")))
       end
 
-      # Returns an array of column names as strings if it's not
-      # an abstract class and table exists.
-      # Otherwise it returns an empty array.
+      # Returns an array of column names as strings if it's not an abstract class and
+      # table exists. Otherwise it returns an empty array.
+      #
+      #   class Person < ActiveRecord::Base
+      #   end
+      #
+      #   Person.attribute_names
+      #   # => ["id", "created_at", "updated_at", "name", "age"]
       def attribute_names
         @attribute_names ||= if !abstract_class? && table_exists?
-            column_names
-          else
-            []
-          end
+          attribute_types.keys
+        else
+          []
+        end
       end
-    end
 
-    # If we haven't generated any methods yet, generate them, then
-    # see if we've created the method we're looking for.
-    def method_missing(method, *args, &block)
-      unless self.class.attribute_methods_generated?
-        self.class.define_attribute_methods
+      # Regexp whitelist. Matches the following:
+      #   "#{table_name}.#{column_name}"
+      #   "#{column_name}"
+      COLUMN_NAME_WHITELIST = /\A(?:\w+\.)?\w+\z/i
+
+      # Regexp whitelist. Matches the following:
+      #   "#{table_name}.#{column_name}"
+      #   "#{table_name}.#{column_name} #{direction}"
+      #   "#{table_name}.#{column_name} #{direction} NULLS FIRST"
+      #   "#{table_name}.#{column_name} NULLS LAST"
+      #   "#{column_name}"
+      #   "#{column_name} #{direction}"
+      #   "#{column_name} #{direction} NULLS FIRST"
+      #   "#{column_name} NULLS LAST"
+      COLUMN_NAME_ORDER_WHITELIST = /
+        \A
+        (?:\w+\.)?
+        \w+
+        (?:\s+asc|\s+desc)?
+        (?:\s+nulls\s+(?:first|last))?
+        \z
+      /ix
+
+      def enforce_raw_sql_whitelist(args, whitelist: COLUMN_NAME_WHITELIST) # :nodoc:
+        unexpected = args.reject do |arg|
+          arg.kind_of?(Arel::Node) ||
+            arg.is_a?(Arel::Nodes::SqlLiteral) ||
+            arg.is_a?(Arel::Attributes::Attribute) ||
+            arg.to_s.split(/\s*,\s*/).all? { |part| whitelist.match?(part) }
+        end
 
-        if respond_to_without_attributes?(method)
-          send(method, *args, &block)
+        return if unexpected.none?
+
+        if allow_unsafe_raw_sql == :deprecated
+          ActiveSupport::Deprecation.warn(
+            "Dangerous query method (method whose arguments are used as raw " \
+            "SQL) called with non-attribute argument(s): " \
+            "#{unexpected.map(&:inspect).join(", ")}. Non-attribute " \
+            "arguments will be disallowed in Rails 6.0. This method should " \
+            "not be called with user-provided values, such as request " \
+            "parameters or model attributes. Known-safe values can be passed " \
+            "by wrapping them in Arel.sql()."
+          )
         else
-          super
+          raise(ActiveRecord::UnknownAttributeReference,
+            "Query method called with non-attribute argument(s): " +
+            unexpected.map(&:inspect).join(", ")
+          )
         end
-      else
-        super
       end
-    end
 
-    def attribute_missing(match, *args, &block)
-      if self.class.columns_hash[match.attr_name]
-        ActiveSupport::Deprecation.warn(
-          "The method `#{match.method_name}', matching the attribute `#{match.attr_name}' has " \
-          "dispatched through method_missing. This shouldn't happen, because `#{match.attr_name}' " \
-          "is a column of the table. If this error has happened through normal usage of Active " \
-          "Record (rather than through your own code or external libraries), please report it as " \
-          "a bug."
-        )
+      # Returns true if the given attribute exists, otherwise false.
+      #
+      #   class Person < ActiveRecord::Base
+      #   end
+      #
+      #   Person.has_attribute?('name')   # => true
+      #   Person.has_attribute?(:age)     # => true
+      #   Person.has_attribute?(:nothing) # => false
+      def has_attribute?(attr_name)
+        attribute_types.key?(attr_name.to_s)
       end
 
-      super
+      # Returns the column object for the named attribute.
+      # Returns a +ActiveRecord::ConnectionAdapters::NullColumn+ if the
+      # named attribute does not exist.
+      #
+      #   class Person < ActiveRecord::Base
+      #   end
+      #
+      #   person = Person.new
+      #   person.column_for_attribute(:name) # the result depends on the ConnectionAdapter
+      #   # => #<ActiveRecord::ConnectionAdapters::Column:0x007ff4ab083980 @name="name", @sql_type="varchar(255)", @null=true, ...>
+      #
+      #   person.column_for_attribute(:nothing)
+      #   # => #<ActiveRecord::ConnectionAdapters::NullColumn:0xXXX @name=nil, @sql_type=nil, @cast_type=#<Type::Value>, ...>
+      def column_for_attribute(name)
+        name = name.to_s
+        columns_hash.fetch(name) do
+          ConnectionAdapters::NullColumn.new(name)
+        end
+      end
     end
 
+    # A Person object with a name attribute can ask <tt>person.respond_to?(:name)</tt>,
+    # <tt>person.respond_to?(:name=)</tt>, and <tt>person.respond_to?(:name?)</tt>
+    # which will all return +true+. It also defines the attribute methods if they have
+    # not been generated.
+    #
+    #   class Person < ActiveRecord::Base
+    #   end
+    #
+    #   person = Person.new
+    #   person.respond_to?(:name)    # => true
+    #   person.respond_to?(:name=)   # => true
+    #   person.respond_to?(:name?)   # => true
+    #   person.respond_to?('age')    # => true
+    #   person.respond_to?('age=')   # => true
+    #   person.respond_to?('age?')   # => true
+    #   person.respond_to?(:nothing) # => false
     def respond_to?(name, include_private = false)
-      self.class.define_attribute_methods unless self.class.attribute_methods_generated?
-      super
+      return false unless super
+
+      case name
+      when :to_partial_path
+        name = "to_partial_path".freeze
+      when :to_model
+        name = "to_model".freeze
+      else
+        name = name.to_s
+      end
+
+      # If the result is true then check for the select case.
+      # For queries selecting a subset of columns, return false for unselected columns.
+      # We check defined?(@attributes) not to issue warnings if called on objects that
+      # have been allocated but not yet initialized.
+      if defined?(@attributes) && self.class.column_names.include?(name)
+        return has_attribute?(name)
+      end
+
+      true
     end
 
-    # Returns true if the given attribute is in the attributes hash
+    # Returns +true+ if the given attribute is in the attributes hash, otherwise +false+.
+    #
+    #   class Person < ActiveRecord::Base
+    #   end
+    #
+    #   person = Person.new
+    #   person.has_attribute?(:name)    # => true
+    #   person.has_attribute?('age')    # => true
+    #   person.has_attribute?(:nothing) # => false
     def has_attribute?(attr_name)
-      @attributes.has_key?(attr_name.to_s)
+      @attributes.key?(attr_name.to_s)
     end
 
     # Returns an array of names for the attributes available on this object.
+    #
+    #   class Person < ActiveRecord::Base
+    #   end
+    #
+    #   person = Person.new
+    #   person.attribute_names
+    #   # => ["id", "created_at", "updated_at", "name", "age"]
     def attribute_names
       @attributes.keys
     end
 
     # Returns a hash of all the attributes with their names as keys and the values of the attributes as values.
+    #
+    #   class Person < ActiveRecord::Base
+    #   end
+    #
+    #   person = Person.create(name: 'Francesco', age: 22)
+    #   person.attributes
+    #   # => {"id"=>3, "created_at"=>Sun, 21 Oct 2012 04:53:04, "updated_at"=>Sun, 21 Oct 2012 04:53:04, "name"=>"Francesco", "age"=>22}
     def attributes
-      attrs = {}
-      attribute_names.each { |name| attrs[name] = read_attribute(name) }
-      attrs
+      @attributes.to_hash
     end
 
     # Returns an <tt>#inspect</tt>-like string for the value of the
-    # attribute +attr_name+. String attributes are truncated upto 50
-    # characters, and Date and Time attributes are returned in the
+    # attribute +attr_name+. String attributes are truncated up to 50
+    # characters, Date and Time attributes are returned in the
     # <tt>:db</tt> format. Other attributes return the value of
     # <tt>#inspect</tt> without modification.
     #
-    #   person = Person.create!(:name => "David Heinemeier Hansson " * 3)
+    #   person = Person.create!(name: 'David Heinemeier Hansson ' * 3)
     #
     #   person.attribute_for_inspect(:name)
-    #   # => '"David Heinemeier Hansson David Heinemeier Hansson D..."'
+    #   # => "\"David Heinemeier Hansson David Heinemeier Hansson ...\""
     #
     #   person.attribute_for_inspect(:created_at)
-    #   # => '"2009-01-12 04:48:57"'
+    #   # => "\"2012-10-22 00:15:07\""
+    #
+    #   person.attribute_for_inspect(:tag_ids)
+    #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
     def attribute_for_inspect(attr_name)
       value = read_attribute(attr_name)
 
       if value.is_a?(String) && value.length > 50
-        "#{value[0..50]}...".inspect
+        "#{value[0, 50]}...".inspect
       elsif value.is_a?(Date) || value.is_a?(Time)
         %("#{value.to_s(:db)}")
       else
@@ -211,65 +355,138 @@ module ActiveRecord
       end
     end
 
-    # Returns true if the specified +attribute+ has been set by the user or by a database load and is neither
-    # nil nor empty? (the latter only applies to objects that respond to empty?, most notably Strings).
+    # Returns +true+ if the specified +attribute+ has been set by the user or by a
+    # database load and is neither +nil+ nor <tt>empty?</tt> (the latter only applies
+    # to objects that respond to <tt>empty?</tt>, most notably Strings). Otherwise, +false+.
+    # Note that it always returns +true+ with boolean attributes.
+    #
+    #   class Task < ActiveRecord::Base
+    #   end
+    #
+    #   task = Task.new(title: '', is_done: false)
+    #   task.attribute_present?(:title)   # => false
+    #   task.attribute_present?(:is_done) # => true
+    #   task.title = 'Buy milk'
+    #   task.is_done = true
+    #   task.attribute_present?(:title)   # => true
+    #   task.attribute_present?(:is_done) # => true
     def attribute_present?(attribute)
-      value = read_attribute(attribute)
+      value = _read_attribute(attribute)
       !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
     end
 
-    # Returns the column object for the named attribute.
-    def column_for_attribute(name)
-      self.class.columns_hash[name.to_s]
+    # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
+    # "2004-12-12" in a date column is cast to a date object, like Date.new(2004, 12, 12)). It raises
+    # <tt>ActiveModel::MissingAttributeError</tt> if the identified attribute is missing.
+    #
+    # Note: +:id+ is always present.
+    #
+    #   class Person < ActiveRecord::Base
+    #     belongs_to :organization
+    #   end
+    #
+    #   person = Person.new(name: 'Francesco', age: '22')
+    #   person[:name] # => "Francesco"
+    #   person[:age]  # => 22
+    #
+    #   person = Person.select('id').first
+    #   person[:name]            # => ActiveModel::MissingAttributeError: missing attribute: name
+    #   person[:organization_id] # => ActiveModel::MissingAttributeError: missing attribute: organization_id
+    def [](attr_name)
+      read_attribute(attr_name) { |n| missing_attribute(n, caller) }
+    end
+
+    # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
+    # (Alias for the protected #write_attribute method).
+    #
+    #   class Person < ActiveRecord::Base
+    #   end
+    #
+    #   person = Person.new
+    #   person[:age] = '22'
+    #   person[:age] # => 22
+    #   person[:age].class # => Integer
+    def []=(attr_name, value)
+      write_attribute(attr_name, value)
+    end
+
+    # Returns the name of all database fields which have been read from this
+    # model. This can be useful in development mode to determine which fields
+    # need to be selected. For performance critical pages, selecting only the
+    # required fields can be an easy performance win (assuming you aren't using
+    # all of the fields on the model).
+    #
+    # For example:
+    #
+    #   class PostsController < ActionController::Base
+    #     after_action :print_accessed_fields, only: :index
+    #
+    #     def index
+    #       @posts = Post.all
+    #     end
+    #
+    #     private
+    #
+    #     def print_accessed_fields
+    #       p @posts.first.accessed_fields
+    #     end
+    #   end
+    #
+    # Which allows you to quickly change your code to:
+    #
+    #   class PostsController < ActionController::Base
+    #     def index
+    #       @posts = Post.select(:id, :title, :author_id, :updated_at)
+    #     end
+    #   end
+    def accessed_fields
+      @attributes.accessed
     end
 
     protected
 
-    def clone_attributes(reader_method = :read_attribute, attributes = {})
-      attribute_names.each do |name|
-        attributes[name] = clone_attribute_value(reader_method, name)
+      def attribute_method?(attr_name) # :nodoc:
+        # We check defined? because Syck calls respond_to? before actually calling initialize.
+        defined?(@attributes) && @attributes.key?(attr_name)
       end
-      attributes
-    end
 
-    def clone_attribute_value(reader_method, attribute_name)
-      value = send(reader_method, attribute_name)
-      value.duplicable? ? value.clone : value
-    rescue TypeError, NoMethodError
-      value
-    end
+    private
 
-    # Returns a copy of the attributes hash where all the values have been safely quoted for use in
-    # an Arel insert/update method.
-    def arel_attributes_values(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
-      attrs      = {}
-      klass      = self.class
-      arel_table = klass.arel_table
+      def attributes_with_values_for_create(attribute_names)
+        attributes_with_values(attributes_for_create(attribute_names))
+      end
 
-      attribute_names.each do |name|
-        if (column = column_for_attribute(name)) && (include_primary_key || !column.primary)
+      def attributes_with_values_for_update(attribute_names)
+        attributes_with_values(attributes_for_update(attribute_names))
+      end
 
-          if include_readonly_attributes || !self.class.readonly_attributes.include?(name)
+      def attributes_with_values(attribute_names)
+        attribute_names.each_with_object({}) do |name, attrs|
+          attrs[name] = _read_attribute(name)
+        end
+      end
 
-            value = if klass.serialized_attributes.include?(name)
-                      @attributes[name].serialized_value
-                    else
-                      # FIXME: we need @attributes to be used consistently.
-                      # If the values stored in @attributes were already type
-                      # casted, this code could be simplified
-                      read_attribute(name)
-                    end
+      # Filters the primary keys and readonly attributes from the attribute names.
+      def attributes_for_update(attribute_names)
+        attribute_names.reject do |name|
+          readonly_attribute?(name)
+        end
+      end
 
-            attrs[arel_table[name]] = value
-          end
+      # Filters out the primary keys, from the attribute names, when the primary
+      # key is to be generated (e.g. the id attribute has no value).
+      def attributes_for_create(attribute_names)
+        attribute_names.reject do |name|
+          pk_attribute?(name) && id.nil?
         end
       end
 
-      attrs
-    end
+      def readonly_attribute?(name)
+        self.class.readonly_attributes.include?(name)
+      end
 
-    def attribute_method?(attr_name)
-      attr_name == 'id' || (defined?(@attributes) && @attributes.include?(attr_name))
-    end
+      def pk_attribute?(name)
+        name == self.class.primary_key
+      end
   end
 end