activerecord 4.1.8 → 4.2.11.3

data/lib/active_record/core.rb

@@ -1,6 +1,7 @@
+require 'thread'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/object/duplicable'
-require 'thread'
+require 'active_support/core_ext/string/filters'
 
 module ActiveRecord
   module Core
@@ -16,7 +17,6 @@ module ActiveRecord
       mattr_accessor :logger, instance_writer: false
 
       ##
-      # :singleton-method:
       # Contains the database configuration - as is typically stored in config/database.yml -
       # as a Hash.
       #
@@ -85,15 +85,17 @@ module ActiveRecord
       mattr_accessor :dump_schema_after_migration, instance_writer: false
       self.dump_schema_after_migration = true
 
-      # :nodoc:
       mattr_accessor :maintain_test_schema, instance_accessor: false
 
       def self.disable_implicit_join_references=(value)
-        ActiveSupport::Deprecation.warn("Implicit join references were removed with Rails 4.1." \
-                                        "Make sure to remove this configuration because it does nothing.")
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          Implicit join references were removed with Rails 4.1.
+          Make sure to remove this configuration because it does nothing.
+        MSG
       end
 
       class_attribute :default_connection_handler, instance_writer: false
+      class_attribute :find_by_statement_cache
 
       def self.connection_handler
         ActiveRecord::RuntimeRegistry.connection_handler || default_connection_handler
@@ -107,7 +109,94 @@ module ActiveRecord
     end
 
     module ClassMethods
-      def initialize_generated_modules
+      def allocate
+        define_attribute_methods
+        super
+      end
+
+      def initialize_find_by_cache # :nodoc:
+        self.find_by_statement_cache = {}.extend(Mutex_m)
+      end
+
+      def inherited(child_class) # :nodoc:
+        child_class.initialize_find_by_cache
+        super
+      end
+
+      def find(*ids) # :nodoc:
+        # We don't have cache keys for this stuff yet
+        return super unless ids.length == 1
+        # Allow symbols to super to maintain compatibility for deprecated finders until Rails 5
+        return super if ids.first.kind_of?(Symbol)
+        return super if block_given? ||
+                        primary_key.nil? ||
+                        default_scopes.any? ||
+                        current_scope ||
+                        columns_hash.include?(inheritance_column) ||
+                        ids.first.kind_of?(Array)
+
+        id  = ids.first
+        if ActiveRecord::Base === id
+          id = id.id
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            You are passing an instance of ActiveRecord::Base to `find`.
+            Please pass the id of the object by calling `.id`
+          MSG
+        end
+        key = primary_key
+
+        s = find_by_statement_cache[key] || find_by_statement_cache.synchronize {
+          find_by_statement_cache[key] ||= StatementCache.create(connection) { |params|
+            where(key => params.bind).limit(1)
+          }
+        }
+        record = s.execute([id], self, connection).first
+        unless record
+          raise RecordNotFound, "Couldn't find #{name} with '#{primary_key}'=#{id}"
+        end
+        record
+      rescue RangeError
+        raise RecordNotFound, "Couldn't find #{name} with an out of range value for '#{primary_key}'"
+      end
+
+      def find_by(*args) # :nodoc:
+        return super if current_scope || !(Hash === args.first) || reflect_on_all_aggregations.any?
+        return super if default_scopes.any?
+
+        hash = args.first
+
+        return super if hash.values.any? { |v|
+          v.nil? || Array === v || Hash === v
+        }
+
+        # We can't cache Post.find_by(author: david) ...yet
+        return super unless hash.keys.all? { |k| columns_hash.has_key?(k.to_s) }
+
+        key  = hash.keys
+
+        klass = self
+        s = find_by_statement_cache[key] || find_by_statement_cache.synchronize {
+          find_by_statement_cache[key] ||= StatementCache.create(connection) { |params|
+            wheres = key.each_with_object({}) { |param,o|
+              o[param] = params.bind
+            }
+            klass.where(wheres).limit(1)
+          }
+        }
+        begin
+          s.execute(hash.values, self, connection).first
+        rescue TypeError => e
+          raise ActiveRecord::StatementInvalid.new(e.message, e)
+        rescue RangeError
+          nil
+        end
+      end
+
+      def find_by!(*args) # :nodoc:
+        find_by(*args) or raise RecordNotFound.new("Couldn't find #{name}")
+      end
+
+      def initialize_generated_modules # :nodoc:
         generated_association_methods
       end
 
@@ -181,12 +270,8 @@ module ActiveRecord
     #   # Instantiates a single new object
     #   User.new(first_name: 'Jamie')
     def initialize(attributes = nil, options = {})
-      defaults = self.class.column_defaults.dup
-      defaults.each { |k, v| defaults[k] = v.dup if v.duplicable? }
-
-      @attributes   = self.class.initialize_attributes(defaults)
-      @column_types_override = nil
-      @column_types = self.class.column_types
+      @attributes = self.class._default_attributes.dup
+      self.class.define_attribute_methods
 
       init_internals
       initialize_internals_callback
@@ -196,32 +281,35 @@ module ActiveRecord
       init_attributes(attributes, options) if attributes
 
       yield self if block_given?
-      run_callbacks :initialize unless _initialize_callbacks.empty?
+      _run_initialize_callbacks
     end
 
-    # Initialize an empty model object from +coder+. +coder+ must contain
-    # the attributes necessary for initializing an empty model object. For
-    # example:
+    # Initialize an empty model object from +coder+. +coder+ should be
+    # the result of previously encoding an Active Record model, using
+    # `encode_with`
     #
     #   class Post < ActiveRecord::Base
     #   end
     #
+    #   old_post = Post.new(title: "hello world")
+    #   coder = {}
+    #   old_post.encode_with(coder)
+    #
     #   post = Post.allocate
-    #   post.init_with('attributes' => { 'title' => 'hello world' })
+    #   post.init_with(coder)
     #   post.title # => 'hello world'
     def init_with(coder)
-      @attributes   = self.class.initialize_attributes(coder['attributes'])
-      @column_types_override = coder['column_types']
-      @column_types = self.class.column_types
+      coder = LegacyYamlAdapter.convert(self.class, coder)
+      @attributes = coder['attributes']
 
       init_internals
 
-      @new_record = false
+      @new_record = coder['new_record']
 
       self.class.define_attribute_methods
 
-      run_callbacks :find
-      run_callbacks :initialize
+      _run_find_callbacks
+      _run_initialize_callbacks
 
       self
     end
@@ -254,17 +342,13 @@ module ActiveRecord
 
     ##
     def initialize_dup(other) # :nodoc:
-      cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
-      self.class.initialize_attributes(cloned_attributes, :serialized => false)
-
-      @attributes = cloned_attributes
-      @attributes[self.class.primary_key] = nil
+      @attributes = @attributes.dup
+      @attributes.reset(self.class.primary_key)
 
-      run_callbacks(:initialize) unless _initialize_callbacks.empty?
+      _run_initialize_callbacks
 
       @aggregation_cache = {}
       @association_cache = {}
-      @attributes_cache  = {}
 
       @new_record  = true
       @destroyed   = false
@@ -285,7 +369,11 @@ module ActiveRecord
     #   Post.new.encode_with(coder)
     #   coder # => {"attributes" => {"id" => nil, ... }}
     def encode_with(coder)
-      coder['attributes'] = attributes_for_coder
+      # FIXME: Remove this when we better serialize attributes
+      coder['raw_attributes'] = attributes_before_type_cast
+      coder['attributes'] = @attributes
+      coder['new_record'] = new_record?
+      coder['active_record_yaml_version'] = 0
     end
 
     # Returns true if +comparison_object+ is the same exact object, or +comparison_object+
@@ -308,7 +396,11 @@ module ActiveRecord
     # Delegates to id in order to allow two records of the same type and id to work with something like:
     #   [ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
     def hash
-      id.hash
+      if id
+        id.hash
+      else
+        super
+      end
     end
 
     # Clone and freeze the attributes hash such that associations are still
@@ -364,21 +456,45 @@ module ActiveRecord
       "#<#{self.class} #{inspection}>"
     end
 
+    # Takes a PP and prettily prints this record to it, allowing you to get a nice result from `pp record`
+    # when pp is required.
+    def pretty_print(pp)
+      return super if custom_inspect_method_defined?
+      pp.object_address_group(self) do
+        if defined?(@attributes) && @attributes
+          column_names = self.class.column_names.select { |name| has_attribute?(name) || new_record? }
+          pp.seplist(column_names, proc { pp.text ',' }) do |column_name|
+            column_value = read_attribute(column_name)
+            pp.breakable ' '
+            pp.group(1) do
+              pp.text column_name
+              pp.text ':'
+              pp.breakable
+              pp.pp column_value
+            end
+          end
+        else
+          pp.breakable ' '
+          pp.text 'not initialized'
+        end
+      end
+    end
+
     # Returns a hash of the given methods with their names as keys and returned values as values.
     def slice(*methods)
       Hash[methods.map! { |method| [method, public_send(method)] }].with_indifferent_access
     end
 
+    private
+
     def set_transaction_state(state) # :nodoc:
       @transaction_state = state
     end
 
     def has_transactional_callbacks? # :nodoc:
-      !_rollback_callbacks.empty? || !_commit_callbacks.empty? || !_create_callbacks.empty?
+      !_rollback_callbacks.empty? || !_commit_callbacks.empty?
     end
 
-    private
-
     # Updates the attributes on this particular ActiveRecord object so that
     # if it is associated with a transaction, then the state of the AR object
     # will be updated to reflect the current state of the transaction
@@ -401,6 +517,8 @@ module ActiveRecord
     end
 
     def update_attributes_from_transaction_state(transaction_state, depth)
+      @reflects_state = [false] if depth == 0
+
       if transaction_state && transaction_state.finalized? && !has_transactional_callbacks?
         unless @reflects_state[depth]
           restore_transaction_record_state if transaction_state.rolledback?
@@ -427,12 +545,8 @@ module ActiveRecord
     end
 
     def init_internals
-      pk = self.class.primary_key
-      @attributes[pk] = nil unless @attributes.key?(pk)
-
       @aggregation_cache        = {}
       @association_cache        = {}
-      @attributes_cache         = {}
       @readonly                 = false
       @destroyed                = false
       @marked_for_destruction   = false
@@ -441,7 +555,6 @@ module ActiveRecord
       @txn                      = nil
       @_start_transaction_state = {}
       @transaction_state        = nil
-      @reflects_state           = [false]
     end
 
     def initialize_internals_callback
@@ -452,5 +565,15 @@ module ActiveRecord
     def init_attributes(attributes, options)
       assign_attributes(attributes)
     end
+
+    def thaw
+      if frozen?
+        @attributes = @attributes.dup
+      end
+    end
+
+    def custom_inspect_method_defined?
+      self.class.instance_method(:inspect).owner != ActiveRecord::Base.instance_method(:inspect).owner
+    end
   end
 end

data/lib/active_record/counter_cache.rb

@@ -11,7 +11,7 @@ module ActiveRecord
       # ==== Parameters
       #
       # * +id+ - The id of the object you wish to reset a counter on.
-      # * +counters+ - One or more association counters to reset
+      # * +counters+ - One or more association counters to reset. Association name or counter name can be given.
       #
       # ==== Examples
       #
@@ -19,9 +19,14 @@ module ActiveRecord
       #   Post.reset_counters(1, :comments)
       def reset_counters(id, *counters)
         object = find(id)
-        counters.each do |association|
-          has_many_association = _reflect_on_association(association.to_sym)
-          raise ArgumentError, "'#{self.name}' has no association called '#{association}'" unless has_many_association
+        counters.each do |counter_association|
+          has_many_association = _reflect_on_association(counter_association)
+          unless has_many_association
+            has_many = reflect_on_all_associations(:has_many)
+            has_many_association = has_many.find { |association| association.counter_cache_column && association.counter_cache_column.to_sym == counter_association.to_sym }
+            counter_association = has_many_association.plural_name if has_many_association
+          end
+          raise ArgumentError, "'#{self.name}' has no association called '#{counter_association}'" unless has_many_association
 
           if has_many_association.is_a? ActiveRecord::Reflection::ThroughReflection
             has_many_association = has_many_association.through_reflection
@@ -29,11 +34,11 @@ module ActiveRecord
 
           foreign_key  = has_many_association.foreign_key.to_s
           child_class  = has_many_association.klass
-          reflection   = child_class._reflections.values.find { |e| :belongs_to == e.macro && e.foreign_key.to_s == foreign_key && e.options[:counter_cache].present? }
+          reflection   = child_class._reflections.values.find { |e| e.belongs_to? && e.foreign_key.to_s == foreign_key && e.options[:counter_cache].present? }
           counter_name = reflection.counter_cache_column
 
           stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({
-            arel_table[counter_name] => object.send(association).count(:all)
+            arel_table[counter_name] => object.send(counter_association).count(:all)
           }, primary_key)
           connection.update stmt
         end
@@ -117,5 +122,54 @@ module ActiveRecord
         update_counters(id, counter_name => -1)
       end
     end
+
+    protected
+
+      def actually_destroyed?
+        @_actually_destroyed
+      end
+
+      def clear_destroy_state
+        @_actually_destroyed = nil
+      end
+
+    private
+
+      def _create_record(*)
+        id = super
+
+        each_counter_cached_associations do |association|
+          if send(association.reflection.name)
+            association.increment_counters
+            @_after_create_counter_called = true
+          end
+        end
+
+        id
+      end
+
+      def destroy_row
+        affected_rows = super
+
+        if affected_rows > 0
+          each_counter_cached_associations do |association|
+            foreign_key = association.reflection.foreign_key.to_sym
+            unless destroyed_by_association && destroyed_by_association.foreign_key.to_sym == foreign_key
+              if send(association.reflection.name)
+                association.decrement_counters
+              end
+            end
+          end
+        end
+
+        affected_rows
+      end
+
+      def each_counter_cached_associations
+        _reflections.each do |name, reflection|
+          yield association(name.to_sym) if reflection.belongs_to? && reflection.counter_cache_column
+        end
+      end
+
   end
 end

data/lib/active_record/enum.rb

@@ -18,17 +18,18 @@ module ActiveRecord
   #   conversation.archived? # => true
   #   conversation.status    # => "archived"
   #
-  #   # conversation.update! status: 1
+  #   # conversation.status = 1
   #   conversation.status = "archived"
   #
-  #   # conversation.update! status: nil
   #   conversation.status = nil
   #   conversation.status.nil? # => true
   #   conversation.status      # => nil
   #
   # Scopes based on the allowed values of the enum field will be provided
-  # as well. With the above example, it will create an +active+ and +archived+
-  # scope.
+  # as well. With the above example:
+  #
+  #   Conversation.active
+  #   Conversation.archived
   #
   # You can set the default value from the database declaration, like:
   #
@@ -68,7 +69,7 @@ module ActiveRecord
   # Where conditions on an enum attribute must use the ordinal value of an enum.
   module Enum
     def self.extended(base) # :nodoc:
-      base.class_attribute(:defined_enums)
+      base.class_attribute(:defined_enums, instance_writer: false)
       base.defined_enums = {}
     end
 
@@ -138,19 +139,16 @@ module ActiveRecord
         @_enum_methods_module ||= begin
           mod = Module.new do
             private
-              def save_changed_attribute(attr_name, value)
+              def save_changed_attribute(attr_name, old)
                 if (mapping = self.class.defined_enums[attr_name.to_s])
+                  value = _read_attribute(attr_name)
                   if attribute_changed?(attr_name)
-                    old = changed_attributes[attr_name]
-
                     if mapping[old] == value
-                      changed_attributes.delete(attr_name)
+                      clear_attribute_changes([attr_name])
                     end
                   else
-                    old = clone_attribute_value(:read_attribute, attr_name)
-
                     if old != value
-                      changed_attributes[attr_name] = mapping.key old
+                      set_attribute_was(attr_name, mapping.key(old))
                     end
                   end
                 else

data/lib/active_record/errors.rb

@@ -30,17 +30,18 @@ module ActiveRecord
   class SerializationTypeMismatch < ActiveRecordError
   end
 
-  # Raised when adapter not specified on connection (or configuration file <tt>config/database.yml</tt>
-  # misses adapter field).
+  # Raised when adapter not specified on connection (or configuration file
+  # +config/database.yml+ misses adapter field).
   class AdapterNotSpecified < ActiveRecordError
   end
 
-  # Raised when Active Record cannot find database adapter specified in <tt>config/database.yml</tt> or programmatically.
+  # Raised when Active Record cannot find database adapter specified in
+  # +config/database.yml+ or programmatically.
   class AdapterNotFound < ActiveRecordError
   end
 
-  # Raised when connection to the database could not been established (for example when <tt>connection=</tt>
-  # is given a nil object).
+  # Raised when connection to the database could not been established (for
+  # example when +connection=+ is given a nil object).
   class ConnectionNotEstablished < ActiveRecordError
   end
 
@@ -51,10 +52,29 @@ module ActiveRecord
   # Raised by ActiveRecord::Base.save! and ActiveRecord::Base.create! methods when record cannot be
   # saved because record is invalid.
   class RecordNotSaved < ActiveRecordError
+    attr_reader :record
+
+    def initialize(message, record = nil)
+      @record = record
+      super(message)
+    end
   end
 
   # Raised by ActiveRecord::Base.destroy! when a call to destroy would return false.
+  #
+  #   begin
+  #     complex_operation_that_internally_calls_destroy!
+  #   rescue ActiveRecord::RecordNotDestroyed => invalid
+  #     puts invalid.record.errors
+  #   end
+  #
   class RecordNotDestroyed < ActiveRecordError
+    attr_reader :record
+
+    def initialize(message, record = nil)
+      @record = record
+      super(message)
+    end
   end
 
   # Superclass for all database execution errors.
@@ -82,35 +102,26 @@ module ActiveRecord
   class InvalidForeignKey < WrappedDatabaseException
   end
 
-  # Raised when number of bind variables in statement given to <tt>:condition</tt> key (for example,
-  # when using +find+ method)
-  # does not match number of expected variables.
+  # Raised when number of bind variables in statement given to +:condition+ key
+  # (for example, when using +find+ method) does not match number of expected
+  # values supplied.
   #
-  # For example, in
+  # For example, when there are two placeholders with only one value supplied:
   #
   #   Location.where("lat = ? AND lng = ?", 53.7362)
-  #
-  # two placeholders are given but only one variable to fill them.
   class PreparedStatementInvalid < ActiveRecordError
   end
 
-  # Raised when a given database does not exist
-  class NoDatabaseError < ActiveRecordError
-    def initialize(message)
-      super extend_message(message)
-    end
-
-    # can be over written to add additional error information.
-    def extend_message(message)
-      message
-    end
+  # Raised when a given database does not exist.
+  class NoDatabaseError < StatementInvalid
   end
 
   # Raised on attempt to save stale record. Record is stale when it's being saved in another query after
   # instantiation, for example, when two users edit the same wiki page and one starts editing and saves
   # the page before the other.
   #
-  # Read more about optimistic locking in ActiveRecord::Locking module RDoc.
+  # Read more about optimistic locking in ActiveRecord::Locking module
+  # documentation.
   class StaleObjectError < ActiveRecordError
     attr_reader :record, :attempted_action
 
@@ -122,8 +133,9 @@ module ActiveRecord
 
   end
 
-  # Raised when association is being configured improperly or
-  # user tries to use offset and limit together with has_many or has_and_belongs_to_many associations.
+  # Raised when association is being configured improperly or user tries to use
+  # offset and limit together with +has_many+ or +has_and_belongs_to_many+
+  # associations.
   class ConfigurationError < ActiveRecordError
   end
 
@@ -161,7 +173,8 @@ module ActiveRecord
   class Rollback < ActiveRecordError
   end
 
-  # Raised when attribute has a name reserved by Active Record (when attribute has name of one of Active Record instance methods).
+  # Raised when attribute has a name reserved by Active Record (when attribute
+  # has name of one of Active Record instance methods).
   class DangerousAttributeError < ActiveRecordError
   end
 
@@ -173,16 +186,17 @@ module ActiveRecord
     def initialize(record, attribute)
       @record = record
       @attribute = attribute.to_s
-      super("unknown attribute: #{attribute}")
+      super("unknown attribute '#{attribute}' for #{@record.class}.")
     end
 
   end
 
   # Raised when an error occurred while doing a mass assignment to an attribute through the
-  # <tt>attributes=</tt> method. The exception has an +attribute+ property that is the name of the
+  # +attributes=+ method. The exception has an +attribute+ property that is the name of the
   # offending attribute.
   class AttributeAssignmentError < ActiveRecordError
     attr_reader :exception, :attribute
+
     def initialize(message, exception, attribute)
       super(message)
       @exception = exception
@@ -195,6 +209,7 @@ module ActiveRecord
   # objects, each corresponding to the error while assigning to an attribute.
   class MultiparameterAssignmentErrors < ActiveRecordError
     attr_reader :errors
+
     def initialize(errors)
       @errors = errors
     end
@@ -204,11 +219,12 @@ module ActiveRecord
   class UnknownPrimaryKey < ActiveRecordError
     attr_reader :model
 
-    def initialize(model)
-      super("Unknown primary key for table #{model.table_name} in model #{model}.")
+    def initialize(model, description = nil)
+      message = "Unknown primary key for table #{model.table_name} in model #{model}."
+      message += "\n#{description}" if description
+      super(message)
       @model = model
     end
-
   end
 
   # Raised when a relation cannot be mutated because it's already loaded.
@@ -225,6 +241,13 @@ module ActiveRecord
   class ImmutableRelation < ActiveRecordError
   end
 
+  # TransactionIsolationError will be raised under the following conditions:
+  #
+  # * The adapter does not support setting the isolation level
+  # * You are joining an existing open transaction
+  # * You are creating a nested (savepoint) transaction
+  #
+  # The mysql, mysql2 and postgresql adapters support setting the transaction isolation level.
   class TransactionIsolationError < ActiveRecordError
   end
 end

data/lib/active_record/explain.rb

@@ -27,7 +27,7 @@ module ActiveRecord
         end.join("\n")
       end.join("\n")
 
-      # Overriding inspect to be more human readable, specially in the console.
+      # Overriding inspect to be more human readable, especially in the console.
       def str.inspect
         self
       end

data/lib/active_record/explain_subscriber.rb

@@ -19,7 +19,7 @@ module ActiveRecord
     # On the other hand, we want to monitor the performance of our real database
     # queries, not the performance of the access to the query cache.
     IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN CACHE)
-    EXPLAINED_SQLS = /\A\s*(select|update|delete|insert)\b/i
+    EXPLAINED_SQLS = /\A\s*(with|select|update|delete|insert)\b/i
     def ignore_payload?(payload)
       payload[:exception] || IGNORED_PAYLOADS.include?(payload[:name]) || payload[:sql] !~ EXPLAINED_SQLS
     end