activerecord 4.2.11.3 → 5.0.0.beta1

data/lib/active_record/attribute_decorators.rb

@@ -15,7 +15,7 @@ module ActiveRecord
       end
 
       def decorate_matching_attribute_types(matcher, decorator_name, &block)
-        clear_caches_calculated_from_columns
+        reload_schema_from_cache
         decorator_name = decorator_name.to_s
 
         # Create new hashes so we don't modify parent classes
@@ -24,10 +24,11 @@ module ActiveRecord
 
       private
 
-      def add_user_provided_columns(*)
-        super.map do |column|
-          decorated_type = attribute_type_decorations.apply(column.name, column.cast_type)
-          column.with_type(decorated_type)
+      def load_schema!
+        super
+        attribute_types.each do |name, type|
+          decorated_type = attribute_type_decorations.apply(name, type)
+          define_attribute(name, decorated_type)
         end
       end
     end

data/lib/active_record/attribute_methods.rb

@@ -1,7 +1,7 @@
 require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/string/filters'
 require 'mutex_m'
-require 'thread_safe'
+require 'concurrent/map'
 
 module ActiveRecord
   # = Active Record Attribute Methods
@@ -37,12 +37,12 @@ module ActiveRecord
     class AttributeMethodCache
       def initialize
         @module = Module.new
-        @method_cache = ThreadSafe::Cache.new
+        @method_cache = Concurrent::Map.new
       end
 
       def [](name)
         @method_cache.compute_if_absent(name) do
-          safe_name = name.unpack('h*').first
+          safe_name = name.unpack('h*'.freeze).first
           temp_method = "__temp__#{safe_name}"
           ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
           @module.module_eval method_body(temp_method, safe_name), __FILE__, __LINE__
@@ -83,7 +83,7 @@ module ActiveRecord
         generated_attribute_methods.synchronize do
           return false if @attribute_methods_generated
           superclass.define_attribute_methods unless self == base_class
-          super(column_names)
+          super(attribute_names)
           @attribute_methods_generated = true
         end
         true
@@ -96,7 +96,7 @@ module ActiveRecord
         end
       end
 
-      # Raises a <tt>ActiveRecord::DangerousAttributeError</tt> exception when an
+      # Raises an ActiveRecord::DangerousAttributeError exception when an
       # \Active \Record method is defined in the model, otherwise +false+.
       #
       #   class Person < ActiveRecord::Base
@@ -106,7 +106,7 @@ module ActiveRecord
       #   end
       #
       #   Person.instance_method_already_implemented?(:save)
-      #   # => ActiveRecord::DangerousAttributeError: save is defined by ActiveRecord
+      #   # => 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
@@ -150,7 +150,7 @@ module ActiveRecord
         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
+      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
@@ -185,14 +185,27 @@ module ActiveRecord
       #   # => ["id", "created_at", "updated_at", "name", "age"]
       def attribute_names
         @attribute_names ||= if !abstract_class? && table_exists?
-            column_names
+            attribute_types.keys
           else
             []
           end
       end
 
+      # 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
+
       # Returns the column object for the named attribute.
-      # Returns nil if the named attribute does not exist.
+      # Returns a +ActiveRecord::ConnectionAdapters::NullColumn+ if the
+      # named attribute does not exist.
       #
       #   class Person < ActiveRecord::Base
       #   end
@@ -202,23 +215,18 @@ module ActiveRecord
       #   # => #<ActiveRecord::ConnectionAdapters::Column:0x007ff4ab083980 @name="name", @sql_type="varchar(255)", @null=true, ...>
       #
       #   person.column_for_attribute(:nothing)
-      #   # => nil
+      #   # => #<ActiveRecord::ConnectionAdapters::NullColumn:0xXXX @name=nil, @sql_type=nil, @cast_type=#<Type::Value>, ...>
       def column_for_attribute(name)
-        column = columns_hash[name.to_s]
-        if column.nil?
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `#column_for_attribute` will return a null object for non-existent
-            columns in Rails 5. Use `#has_attribute?` if you need to check for
-            an attribute's existence.
-          MSG
+        name = name.to_s
+        columns_hash.fetch(name) do
+          ConnectionAdapters::NullColumn.new(name)
         end
-        column
       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 define the attribute methods if they have
+    # which will all return +true+. It also defines the attribute methods if they have
     # not been generated.
     #
     #   class Person < ActiveRecord::Base
@@ -234,7 +242,15 @@ module ActiveRecord
     #   person.respond_to(:nothing) # => false
     def respond_to?(name, include_private = false)
       return false unless super
-      name = name.to_s
+
+      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.
@@ -287,8 +303,9 @@ module ActiveRecord
     # Returns an <tt>#inspect</tt>-like string for the value of 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.
+    # <tt>:db</tt> format, Array attributes are truncated up to 10 values.
+    # Other attributes return the value of <tt>#inspect</tt> without
+    # modification.
     #
     #   person = Person.create!(name: 'David Heinemeier Hansson ' * 3)
     #
@@ -299,7 +316,7 @@ module ActiveRecord
     #   # => "\"2012-10-22 00:15:07\""
     #
     #   person.attribute_for_inspect(:tag_ids)
-    #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
+    #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...]"
     def attribute_for_inspect(attr_name)
       value = read_attribute(attr_name)
 
@@ -307,6 +324,9 @@ module ActiveRecord
         "#{value[0, 50]}...".inspect
       elsif value.is_a?(Date) || value.is_a?(Time)
         %("#{value.to_s(:db)}")
+      elsif value.is_a?(Array) && value.size > 10
+        inspected = value.first(10).inspect
+        %(#{inspected[0...-1]}, ...])
       else
         value.inspect
       end
@@ -338,7 +358,7 @@ module ActiveRecord
     #
     # Note: +:id+ is always present.
     #
-    # Alias for the <tt>read_attribute</tt> method.
+    # Alias for the #read_attribute method.
     #
     #   class Person < ActiveRecord::Base
     #     belongs_to :organization
@@ -356,7 +376,7 @@ module ActiveRecord
     end
 
     # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
-    # (Alias for the protected <tt>write_attribute</tt> method).
+    # (Alias for the protected #write_attribute method).
     #
     #   class Person < ActiveRecord::Base
     #   end
@@ -364,11 +384,44 @@ module ActiveRecord
     #   person = Person.new
     #   person[:age] = '22'
     #   person[:age] # => 22
-    #   person[:age].class # => Integer
+    #   person[:age] # => Fixnum
     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_attribute_value(reader_method, attribute_name) # :nodoc:

data/lib/active_record/attribute_methods/before_type_cast.rb

@@ -2,7 +2,7 @@ module ActiveRecord
   module AttributeMethods
     # = Active Record Attribute Methods Before Type Cast
     #
-    # <tt>ActiveRecord::AttributeMethods::BeforeTypeCast</tt> provides a way to
+    # ActiveRecord::AttributeMethods::BeforeTypeCast provides a way to
     # read the value of the attributes before typecasting and deserialization.
     #
     #   class Task < ActiveRecord::Base

data/lib/active_record/attribute_methods/dirty.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/module/attribute_accessors'
+require 'active_record/attribute_mutation_tracker'
 
 module ActiveRecord
   module AttributeMethods
@@ -34,24 +35,43 @@ module ActiveRecord
       # <tt>reload</tt> the record and clears changed attributes.
       def reload(*)
         super.tap do
-          clear_changes_information
+          @mutation_tracker = nil
+          @previous_mutation_tracker = nil
+          @changed_attributes = HashWithIndifferentAccess.new
         end
       end
 
       def initialize_dup(other) # :nodoc:
         super
-        @original_raw_attributes = nil
-        calculate_changes_from_defaults
+        @attributes = self.class._default_attributes.map do |attr|
+          attr.with_value_from_user(@attributes.fetch_value(attr.name))
+        end
+        @mutation_tracker = nil
       end
 
       def changes_applied
-        super
-        store_original_raw_attributes
+        @previous_mutation_tracker = mutation_tracker
+        @changed_attributes = HashWithIndifferentAccess.new
+        store_original_attributes
       end
 
       def clear_changes_information
+        @previous_mutation_tracker = nil
+        @changed_attributes = HashWithIndifferentAccess.new
+        store_original_attributes
+      end
+
+      def raw_write_attribute(attr_name, *)
+        result = super
+        clear_attribute_change(attr_name)
+        result
+      end
+
+      def clear_attribute_changes(attr_names)
         super
-        original_raw_attributes.clear
+        attr_names.each do |attr_name|
+          clear_attribute_change(attr_name)
+        end
       end
 
       def changed_attributes
@@ -60,7 +80,7 @@ module ActiveRecord
         if defined?(@cached_changed_attributes)
           @cached_changed_attributes
         else
-          super.reverse_merge(attributes_changed_in_place).freeze
+          super.reverse_merge(mutation_tracker.changed_values).freeze
         end
       end
 
@@ -70,59 +90,29 @@ module ActiveRecord
         end
       end
 
+      def previous_changes
+        previous_mutation_tracker.changes
+      end
+
       def attribute_changed_in_place?(attr_name)
-        old_value = original_raw_attribute(attr_name)
-        @attributes[attr_name].changed_in_place_from?(old_value)
+        mutation_tracker.changed_in_place?(attr_name)
       end
 
       private
 
-      def changes_include?(attr_name)
-        super || attribute_changed_in_place?(attr_name)
-      end
-
-      def calculate_changes_from_defaults
-        @changed_attributes = nil
-        self.class.column_defaults.each do |attr, orig_value|
-          set_attribute_was(attr, orig_value) if _field_changed?(attr, orig_value)
+      def mutation_tracker
+        unless defined?(@mutation_tracker)
+          @mutation_tracker = nil
         end
+        @mutation_tracker ||= AttributeMutationTracker.new(@attributes)
       end
 
-      # Wrap write_attribute to remember original attribute value.
-      def write_attribute(attr, value)
-        attr = attr.to_s
-
-        old_value = old_attribute_value(attr)
-
-        result = super
-        store_original_raw_attribute(attr)
-        save_changed_attribute(attr, old_value)
-        result
-      end
-
-      def raw_write_attribute(attr, value)
-        attr = attr.to_s
-
-        result = super
-        original_raw_attributes[attr] = value
-        result
+      def changes_include?(attr_name)
+        super || mutation_tracker.changed?(attr_name)
       end
 
-      def save_changed_attribute(attr, old_value)
-        clear_changed_attributes_cache
-        if attribute_changed_by_setter?(attr)
-          clear_attribute_changes(attr) unless _field_changed?(attr, old_value)
-        else
-          set_attribute_was(attr, old_value) if _field_changed?(attr, old_value)
-        end
-      end
-
-      def old_attribute_value(attr)
-        if attribute_changed?(attr)
-          changed_attributes[attr]
-        else
-          clone_attribute_value(:_read_attribute, attr)
-        end
+      def clear_attribute_change(attr_name)
+        mutation_tracker.forget_change(attr_name)
       end
 
       def _update_record(*)
@@ -133,47 +123,17 @@ module ActiveRecord
         partial_writes? ? super(keys_for_partial_write) : super
       end
 
-      # Serialized attributes should always be written in case they've been
-      # changed in place.
       def keys_for_partial_write
-        changed & persistable_attribute_names
-      end
-
-      def _field_changed?(attr, old_value)
-        @attributes[attr].changed_from?(old_value)
-      end
-
-      def attributes_changed_in_place
-        changed_in_place.each_with_object({}) do |attr_name, h|
-          orig = @attributes[attr_name].original_value
-          h[attr_name] = orig
-        end
-      end
-
-      def changed_in_place
-        self.class.attribute_names.select do |attr_name|
-          attribute_changed_in_place?(attr_name)
-        end
+        changed & self.class.column_names
       end
 
-      def original_raw_attribute(attr_name)
-        original_raw_attributes.fetch(attr_name) do
-          read_attribute_before_type_cast(attr_name)
-        end
+      def store_original_attributes
+        @attributes = @attributes.map(&:forgetting_assignment)
+        @mutation_tracker = nil
       end
 
-      def original_raw_attributes
-        @original_raw_attributes ||= {}
-      end
-
-      def store_original_raw_attribute(attr_name)
-        original_raw_attributes[attr_name] = @attributes[attr_name].value_for_database rescue nil
-      end
-
-      def store_original_raw_attributes
-        attribute_names.each do |attr|
-          store_original_raw_attribute(attr)
-        end
+      def previous_mutation_tracker
+        @previous_mutation_tracker ||= NullMutationTracker.instance
       end
 
       def cache_changed_attributes

data/lib/active_record/attribute_methods/primary_key.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     module PrimaryKey
       extend ActiveSupport::Concern
 
-      # Returns this record's primary key value wrapped in an Array if one is
+      # Returns this record's primary key value wrapped in an array if one is
       # available.
       def to_key
         sync_with_transaction_state
@@ -108,7 +108,7 @@ module ActiveRecord
         #     self.primary_key = 'sysid'
         #   end
         #
-        # You can also define the +primary_key+ method yourself:
+        # You can also define the #primary_key method yourself:
         #
         #   class Project < ActiveRecord::Base
         #     def self.primary_key