activerecord 4.1.15 → 4.2.0.beta1

data/lib/active_record/attribute_methods.rb

@@ -18,6 +18,8 @@ module ActiveRecord
       include TimeZoneConversion
       include Dirty
       include Serialization
+
+      delegate :column_for_attribute, to: :class
     end
 
     AttrNames = Module.new {
@@ -29,7 +31,7 @@ module ActiveRecord
       end
     }
 
-    BLACKLISTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass)
+    BLACKLISTED_CLASS_METHODS = %w(private public protected)
 
     class AttributeMethodCache
       def initialize
@@ -48,7 +50,11 @@ module ActiveRecord
       end
 
       private
-      def method_body; raise NotImplementedError; end
+
+      # Override this method in the subclasses for method body.
+      def method_body(method_name, const_name)
+        raise NotImplementedError, "Subclasses must implement a method_body(method_name, const_name) method."
+      end
     end
 
     class GeneratedAttributeMethods < Module; end # :nodoc:
@@ -63,15 +69,13 @@ module ActiveRecord
         @generated_attribute_methods = GeneratedAttributeMethods.new { extend Mutex_m }
         @attribute_methods_generated = false
         include @generated_attribute_methods
-
-        super
       end
 
       # 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 thread simultaneously trying to define
+        # Use a mutex; we don't want two threads simultaneously trying to define
         # attribute methods.
         generated_attribute_methods.synchronize do
           return false if @attribute_methods_generated
@@ -84,7 +88,7 @@ module ActiveRecord
 
       def undefine_attribute_methods # :nodoc:
         generated_attribute_methods.synchronize do
-          super if defined?(@attribute_methods_generated) && @attribute_methods_generated
+          super if @attribute_methods_generated
           @attribute_methods_generated = false
         end
       end
@@ -105,7 +109,7 @@ module ActiveRecord
       #   # => false
       def instance_method_already_implemented?(method_name)
         if dangerous_attribute_method?(method_name)
-          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."
+          raise DangerousAttributeError, "#{method_name} is defined by Active Record"
         end
 
         if superclass == Base
@@ -155,16 +159,6 @@ module ActiveRecord
         end
       end
 
-      def find_generated_attribute_method(method_name) # :nodoc:
-        klass = self
-        until klass == Base
-          gen_methods = klass.generated_attribute_methods
-          return gen_methods.instance_method(method_name) if method_defined_within?(method_name, gen_methods, Object)
-          klass = klass.superclass
-        end
-        nil
-      end
-
       # Returns +true+ if +attribute+ is an attribute method and table exists,
       # +false+ otherwise.
       #
@@ -193,24 +187,29 @@ module ActiveRecord
             []
           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) # :nodoc:
-      self.class.define_attribute_methods
-      if respond_to_without_attributes?(method)
-        # make sure to invoke the correct attribute method, as we might have gotten here via a `super`
-        # call in a overwritten attribute method
-        if attribute_method = self.class.find_generated_attribute_method(method)
-          # this is probably horribly slow, but should only happen at most once for a given AR class
-          attribute_method.bind(self).call(*args, &block)
-        else
-          return super unless respond_to_missing?(method, true)
-          send(method, *args, &block)
+      # Returns the column object for the named attribute.
+      # Returns nil 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)
+      #   # => nil
+      def column_for_attribute(name)
+        column = columns_hash[name.to_s]
+        if column.nil?
+          ActiveSupport::Deprecation.warn(<<-MESSAGE.strip_heredoc)
+            `column_for_attribute` will return a null object for non-existent columns
+            in Rails 5.0. Use `has_attribute?` if you need to check for an
+            attribute's existence.
+          MESSAGE
         end
-      else
-        super
+        column
       end
     end
 
@@ -231,18 +230,14 @@ module ActiveRecord
     #   person.respond_to('age?')   # => true
     #   person.respond_to(:nothing) # => false
     def respond_to?(name, include_private = false)
+      return false unless super
       name = name.to_s
-      self.class.define_attribute_methods
-      result = super
-
-      # If the result is false the answer is false.
-      return false unless result
 
       # 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) && @attributes.any? && self.class.column_names.include?(name)
+      if defined?(@attributes) && self.class.column_names.include?(name)
         return has_attribute?(name)
       end
 
@@ -259,7 +254,7 @@ module ActiveRecord
     #   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.
@@ -283,20 +278,13 @@ module ActiveRecord
     #   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
-      attribute_names.each_with_object({}) { |name, attrs|
-        attrs[name] = read_attribute(name)
-      }
-    end
-
-    # Placeholder so it can be overriden when needed by serialization
-    def attributes_for_coder # :nodoc:
-      attributes
+      @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
+    # attribute +attr_name+. String attributes are truncated up to 50
     # characters, Date and Time attributes are returned in the
-    # <tt>:db</tt> format, Array attributes are truncated upto 10 values.
+    # <tt>:db</tt> format, Array attributes are truncated up to 10 values.
     # Other attributes return the value of <tt>#inspect</tt> without
     # modification.
     #
@@ -333,39 +321,24 @@ module ActiveRecord
     #   class Task < ActiveRecord::Base
     #   end
     #
-    #   person = Task.new(title: '', is_done: false)
-    #   person.attribute_present?(:title)   # => false
-    #   person.attribute_present?(:is_done) # => true
-    #   person.name = 'Francesco'
-    #   person.is_done = true
-    #   person.attribute_present?(:title)   # => true
-    #   person.attribute_present?(:is_done) # => true
+    #   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.nil? && !(value.respond_to?(:empty?) && value.empty?)
     end
 
-    # Returns the column object for the named attribute. Returns +nil+ if the
-    # named attribute not exists.
-    #
-    #   class Person < ActiveRecord::Base
-    #   end
-    #
-    #   person = Person.new
-    #   person.column_for_attribute(:name) # the result depends on the ConnectionAdapter
-    #   # => #<ActiveRecord::ConnectionAdapters::SQLite3Column:0x007ff4ab083980 @name="name", @sql_type="varchar(255)", @null=true, ...>
-    #
-    #   person.column_for_attribute(:nothing)
-    #   # => nil
-    def column_for_attribute(name)
-      # FIXME: should this return a null object for columns that don't exist?
-      self.class.columns_hash[name.to_s]
-    end
-
     # 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.
+    #
     # Alias for the <tt>read_attribute</tt> method.
     #
     #   class Person < ActiveRecord::Base
@@ -399,13 +372,6 @@ module ActiveRecord
 
     protected
 
-    def clone_attributes(reader_method = :read_attribute, attributes = {}) # :nodoc:
-      attribute_names.each do |name|
-        attributes[name] = clone_attribute_value(reader_method, name)
-      end
-      attributes
-    end
-
     def clone_attribute_value(reader_method, attribute_name) # :nodoc:
       value = send(reader_method, attribute_name)
       value.duplicable? ? value.clone : value
@@ -423,7 +389,7 @@ module ActiveRecord
 
     def attribute_method?(attr_name) # :nodoc:
       # We check defined? because Syck calls respond_to? before actually calling initialize.
-      defined?(@attributes) && @attributes.include?(attr_name)
+      defined?(@attributes) && @attributes.key?(attr_name)
     end
 
     private
@@ -442,16 +408,16 @@ module ActiveRecord
 
     # Filters the primary keys and readonly attributes from the attribute names.
     def attributes_for_update(attribute_names)
-      attribute_names.select do |name|
-        column_for_attribute(name) && !readonly_attribute?(name)
+      attribute_names.reject do |name|
+        readonly_attribute?(name)
       end
     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.select do |name|
-        column_for_attribute(name) && !(pk_attribute?(name) && id.nil?)
+      attribute_names.reject do |name|
+        pk_attribute?(name) && id.nil?
       end
     end
 
@@ -460,13 +426,10 @@ module ActiveRecord
     end
 
     def pk_attribute?(name)
-      column_for_attribute(name).primary
+      name == self.class.primary_key
     end
 
     def typecasted_attribute_value(name)
-      # FIXME: we need @attributes to be used consistently.
-      # If the values stored in @attributes were already typecasted, this code
-      # could be simplified
       read_attribute(name)
     end
   end

data/lib/active_record/attribute_set/builder.rb

@@ -0,0 +1,32 @@
+module ActiveRecord
+  class AttributeSet # :nodoc:
+    class Builder # :nodoc:
+      attr_reader :types
+
+      def initialize(types)
+        @types = types
+      end
+
+      def build_from_database(values = {}, additional_types = {})
+        attributes = build_attributes_from_values(values, additional_types)
+        add_uninitialized_attributes(attributes)
+        AttributeSet.new(attributes)
+      end
+
+      private
+
+      def build_attributes_from_values(values, additional_types)
+        values.each_with_object({}) do |(name, value), hash|
+          type = additional_types.fetch(name, types[name])
+          hash[name] = Attribute.from_database(name, value, type)
+        end
+      end
+
+      def add_uninitialized_attributes(attributes)
+        types.except(*attributes.keys).each do |name, type|
+          attributes[name] = Attribute.uninitialized(name, type)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/attribute_set.rb

@@ -0,0 +1,77 @@
+require 'active_record/attribute_set/builder'
+
+module ActiveRecord
+  class AttributeSet # :nodoc:
+    delegate :keys, to: :initialized_attributes
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def [](name)
+      attributes[name] || Attribute.null(name)
+    end
+
+    def values_before_type_cast
+      attributes.transform_values(&:value_before_type_cast)
+    end
+
+    def to_hash
+      initialized_attributes.transform_values(&:value)
+    end
+    alias_method :to_h, :to_hash
+
+    def key?(name)
+      attributes.key?(name) && self[name].initialized?
+    end
+
+    def fetch_value(name, &block)
+      self[name].value(&block)
+    end
+
+    def write_from_database(name, value)
+      attributes[name] = self[name].with_value_from_database(value)
+    end
+
+    def write_from_user(name, value)
+      attributes[name] = self[name].with_value_from_user(value)
+    end
+
+    def freeze
+      @attributes.freeze
+      super
+    end
+
+    def initialize_dup(_)
+      @attributes = attributes.transform_values(&:dup)
+      super
+    end
+
+    def initialize_clone(_)
+      @attributes = attributes.clone
+      super
+    end
+
+    def reset(key)
+      if key?(key)
+        write_from_database(key, nil)
+      end
+    end
+
+    def ensure_initialized(key)
+      unless self[key].initialized?
+        write_from_database(key, nil)
+      end
+    end
+
+    protected
+
+    attr_reader :attributes
+
+    private
+
+    def initialized_attributes
+      attributes.select { |_, attr| attr.initialized? }
+    end
+  end
+end

data/lib/active_record/attributes.rb

@@ -0,0 +1,122 @@
+module ActiveRecord
+  module Attributes # :nodoc:
+    extend ActiveSupport::Concern
+
+    Type = ActiveRecord::Type
+
+    included do
+      class_attribute :user_provided_columns, instance_accessor: false # :internal:
+      self.user_provided_columns = {}
+    end
+
+    module ClassMethods # :nodoc:
+      # Defines or overrides a attribute on this model. This allows customization of
+      # Active Record's type casting behavior, as well as adding support for user defined
+      # types.
+      #
+      # +name+ The name of the methods to define attribute methods for, and the column which
+      # this will persist to.
+      #
+      # +cast_type+ A type object that contains information about how to type cast the value.
+      # See the examples section for more information.
+      #
+      # ==== Options
+      # The options hash accepts the following options:
+      #
+      # +default+ is the default value that the column should use on a new record.
+      #
+      # ==== Examples
+      #
+      # The type detected by Active Record can be overridden.
+      #
+      #   # db/schema.rb
+      #   create_table :store_listings, force: true do |t|
+      #     t.decimal :price_in_cents
+      #   end
+      #
+      #   # app/models/store_listing.rb
+      #   class StoreListing < ActiveRecord::Base
+      #   end
+      #
+      #   store_listing = StoreListing.new(price_in_cents: '10.1')
+      #
+      #   # before
+      #   store_listing.price_in_cents # => BigDecimal.new(10.1)
+      #
+      #   class StoreListing < ActiveRecord::Base
+      #     attribute :price_in_cents, Type::Integer.new
+      #   end
+      #
+      #   # after
+      #   store_listing.price_in_cents # => 10
+      #
+      # Users may also define their own custom types, as long as they respond to the methods
+      # defined on the value type. The `type_cast` method on your type object will be called
+      # with values both from the database, and from your controllers. See
+      # `ActiveRecord::Attributes::Type::Value` for the expected API. It is recommended that your
+      # type objects inherit from an existing type, or the base value type.
+      #
+      #   class MoneyType < ActiveRecord::Type::Integer
+      #     def type_cast(value)
+      #       if value.include?('$')
+      #         price_in_dollars = value.gsub(/\$/, '').to_f
+      #         price_in_dollars * 100
+      #       else
+      #         value.to_i
+      #       end
+      #     end
+      #   end
+      #
+      #   class StoreListing < ActiveRecord::Base
+      #     attribute :price_in_cents, MoneyType.new
+      #   end
+      #
+      #   store_listing = StoreListing.new(price_in_cents: '$10.00')
+      #   store_listing.price_in_cents # => 1000
+      def attribute(name, cast_type, options = {})
+        name = name.to_s
+        clear_caches_calculated_from_columns
+        # Assign a new hash to ensure that subclasses do not share a hash
+        self.user_provided_columns = user_provided_columns.merge(name => connection.new_column(name, options[:default], cast_type))
+      end
+
+      # Returns an array of column objects for the table associated with this class.
+      def columns
+        @columns ||= add_user_provided_columns(connection.schema_cache.columns(table_name))
+      end
+
+      # Returns a hash of column objects for the table associated with this class.
+      def columns_hash
+        @columns_hash ||= Hash[columns.map { |c| [c.name, c] }]
+      end
+
+      def reset_column_information # :nodoc:
+        super
+        clear_caches_calculated_from_columns
+      end
+
+      private
+
+      def add_user_provided_columns(schema_columns)
+        existing_columns = schema_columns.map do |column|
+          user_provided_columns[column.name] || column
+        end
+
+        existing_column_names = existing_columns.map(&:name)
+        new_columns = user_provided_columns.except(*existing_column_names).values
+
+        existing_columns + new_columns
+      end
+
+      def clear_caches_calculated_from_columns
+        @attributes_builder = nil
+        @column_names = nil
+        @column_types = nil
+        @columns = nil
+        @columns_hash = nil
+        @content_columns = nil
+        @default_attributes = nil
+      end
+    end
+  end
+end

data/lib/active_record/autosave_association.rb

@@ -177,15 +177,15 @@ module ActiveRecord
         # before actually defining them.
         def add_autosave_association_callbacks(reflection)
           save_method = :"autosave_associated_records_for_#{reflection.name}"
+          validation_method = :"validate_associated_records_for_#{reflection.name}"
+          collection = reflection.collection?
 
-          if reflection.collection?
+          if collection
             before_save :before_save_collection_association
 
             define_non_cyclic_method(save_method) { save_collection_association(reflection) }
-            # Doesn't use after_save as that would save associations added in after_create/after_update twice
-            after_create save_method
-            after_update save_method
-          elsif reflection.macro == :has_one
+            after_save save_method
+          elsif reflection.has_one?
             define_method(save_method) { save_has_one_association(reflection) } unless method_defined?(save_method)
             # Configures two callbacks instead of a single after_save so that
             # the model may rely on their execution order relative to its
@@ -202,22 +202,9 @@ module ActiveRecord
             before_save save_method
           end
 
-          define_autosave_validation_callbacks(reflection)
-        end
-
-        def define_autosave_validation_callbacks(reflection)
-          validation_method = :"validate_associated_records_for_#{reflection.name}"
           if reflection.validate? && !method_defined?(validation_method)
-            if reflection.collection?
-              method = :validate_collection_association
-            else
-              method = :validate_single_association
-            end
-
-            define_non_cyclic_method(validation_method) do
-              send(method, reflection)
-              true
-            end
+            method = (collection ? :validate_collection_association : :validate_single_association)
+            define_non_cyclic_method(validation_method) { send(method, reflection) }
             validate validation_method
           end
         end
@@ -316,7 +303,8 @@ module ActiveRecord
       def association_valid?(reflection, record)
         return true if record.destroyed? || record.marked_for_destruction?
 
-        unless valid = record.valid?
+        validation_context = self.validation_context unless [:create, :update].include?(self.validation_context)
+        unless valid = record.valid?(validation_context)
           if reflection.options[:autosave]
             record.errors.each do |attribute, message|
               attribute = "#{reflection.name}.#{attribute}"
@@ -350,6 +338,7 @@ module ActiveRecord
           autosave = reflection.options[:autosave]
 
           if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
+
             if autosave
               records_to_destroy = records.select(&:marked_for_destruction?)
               records_to_destroy.each { |record| association.destroy(record) }
@@ -373,6 +362,7 @@ module ActiveRecord
 
               raise ActiveRecord::Rollback unless saved
             end
+            @new_record_before_save = false
           end
 
           # reconstruct the scope now that we know the owner's id

data/lib/active_record/base.rb

@@ -9,16 +9,19 @@ require 'active_support/core_ext/class/delegating_attributes'
 require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/hash/deep_merge'
 require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/hash/transform_values'
 require 'active_support/core_ext/string/behavior'
 require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/module/introspection'
 require 'active_support/core_ext/object/duplicable'
 require 'active_support/core_ext/class/subclasses'
 require 'arel'
+require 'active_record/attribute_decorators'
 require 'active_record/errors'
 require 'active_record/log_subscriber'
 require 'active_record/explain_subscriber'
 require 'active_record/relation/delegation'
+require 'active_record/attributes'
 
 module ActiveRecord #:nodoc:
   # = Active Record
@@ -138,6 +141,7 @@ module ActiveRecord #:nodoc:
   #
   # In addition to the basic accessors, query methods are also automatically available on the Active Record object.
   # Query methods allow you to test whether an attribute value is present.
+  # For numeric values, present is defined as non-zero.
   #
   # For example, an Active Record User with the <tt>name</tt> attribute has a <tt>name?</tt> method that you can call
   # to determine whether the user has a name:
@@ -217,25 +221,9 @@ module ActiveRecord #:nodoc:
   #
   # == 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.
-  #
-  # 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
+  # Active Record allows inheritance by storing the name of the class in a
+  # column that is named "type" by default. See ActiveRecord::Inheritance for
+  # more details.
   #
   # == Connection to multiple databases in different models
   #
@@ -306,6 +294,8 @@ module ActiveRecord #:nodoc:
     include Integration
     include Validations
     include CounterCache
+    include Attributes
+    include AttributeDecorators
     include Locking::Optimistic
     include Locking::Pessimistic
     include AttributeMethods