activerecord 3.2.22.5 → 4.0.0.beta1

data/lib/active_record/counter_cache.rb

@@ -1,123 +1,121 @@
 module ActiveRecord
   # = Active Record Counter Cache
   module CounterCache
-    # Resets one or more counter caches to their correct value using an SQL
-    # count query. This is useful when adding new counter caches, or if the
-    # counter has been corrupted or modified directly by SQL.
-    #
-    # ==== Parameters
-    #
-    # * +id+ - The id of the object you wish to reset a counter on.
-    # * +counters+ - One or more counter names to reset
-    #
-    # ==== Examples
-    #
-    #   # For Post with id #1 records reset the comments_count
-    #   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)
+    extend ActiveSupport::Concern
 
-        if has_many_association.options[:as]
-          has_many_association.options[:as].to_s.classify
-        else
-          self.name
-        end
-
-        if has_many_association.is_a? ActiveRecord::Reflection::ThroughReflection
-          has_many_association = has_many_association.through_reflection
-        end
+    module ClassMethods
+      # Resets one or more counter caches to their correct value using an SQL
+      # count query. This is useful when adding new counter caches, or if the
+      # counter has been corrupted or modified directly by SQL.
+      #
+      # ==== Parameters
+      #
+      # * +id+ - The id of the object you wish to reset a counter on.
+      # * +counters+ - One or more counter names to reset
+      #
+      # ==== Examples
+      #
+      #   # For Post with id #1 records reset the comments_count
+      #   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)
 
-        foreign_key  = has_many_association.foreign_key.to_s
-        child_class  = has_many_association.klass
-        belongs_to   = child_class.reflect_on_all_associations(:belongs_to)
-        reflection   = belongs_to.find { |e| e.foreign_key.to_s == foreign_key && e.options[:counter_cache].present? }
-        counter_name = reflection.counter_cache_column
+          if has_many_association.is_a? ActiveRecord::Reflection::ThroughReflection
+            has_many_association = has_many_association.through_reflection
+          end
 
-        stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({
-          arel_table[counter_name] => object.send(association).count
-        })
-        connection.update stmt
-      end
-      return true
-    end
+          foreign_key  = has_many_association.foreign_key.to_s
+          child_class  = has_many_association.klass
+          belongs_to   = child_class.reflect_on_all_associations(:belongs_to)
+          reflection   = belongs_to.find { |e| e.foreign_key.to_s == foreign_key && e.options[:counter_cache].present? }
+          counter_name = reflection.counter_cache_column
 
-    # A generic "counter updater" implementation, intended primarily to be
-    # used by increment_counter and decrement_counter, but which may also
-    # be useful on its own. It simply does a direct SQL update for the record
-    # with the given ID, altering the given hash of counters by the amount
-    # given by the corresponding value:
-    #
-    # ==== Parameters
-    #
-    # * +id+ - The id of the object you wish to update a counter on or an Array of ids.
-    # * +counters+ - An Array of Hashes containing the names of the fields
-    #   to update as keys and the amount to update the field by as values.
-    #
-    # ==== Examples
-    #
-    #   # For the Post with id of 5, decrement the comment_count by 1, and
-    #   # increment the action_count by 1
-    #   Post.update_counters 5, :comment_count => -1, :action_count => 1
-    #   # Executes the following SQL:
-    #   # UPDATE posts
-    #   #    SET comment_count = COALESCE(comment_count, 0) - 1,
-    #   #        action_count = COALESCE(action_count, 0) + 1
-    #   #  WHERE id = 5
-    #
-    #   # For the Posts with id of 10 and 15, increment the comment_count by 1
-    #   Post.update_counters [10, 15], :comment_count => 1
-    #   # Executes the following SQL:
-    #   # UPDATE posts
-    #   #    SET comment_count = COALESCE(comment_count, 0) + 1
-    #   #  WHERE id IN (10, 15)
-    def update_counters(id, counters)
-      updates = counters.map do |counter_name, value|
-        operator = value < 0 ? '-' : '+'
-        quoted_column = connection.quote_column_name(counter_name)
-        "#{quoted_column} = COALESCE(#{quoted_column}, 0) #{operator} #{value.abs}"
+          stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({
+            arel_table[counter_name] => object.send(association).count
+          })
+          connection.update stmt
+        end
+        return true
       end
 
-      IdentityMap.remove_by_id(symbolized_base_class, id) if IdentityMap.enabled?
+      # A generic "counter updater" implementation, intended primarily to be
+      # used by increment_counter and decrement_counter, but which may also
+      # be useful on its own. It simply does a direct SQL update for the record
+      # with the given ID, altering the given hash of counters by the amount
+      # given by the corresponding value:
+      #
+      # ==== Parameters
+      #
+      # * +id+ - The id of the object you wish to update a counter on or an Array of ids.
+      # * +counters+ - An Array of Hashes containing the names of the fields
+      #   to update as keys and the amount to update the field by as values.
+      #
+      # ==== Examples
+      #
+      #   # For the Post with id of 5, decrement the comment_count by 1, and
+      #   # increment the action_count by 1
+      #   Post.update_counters 5, comment_count: -1, action_count: 1
+      #   # Executes the following SQL:
+      #   # UPDATE posts
+      #   #    SET comment_count = COALESCE(comment_count, 0) - 1,
+      #   #        action_count = COALESCE(action_count, 0) + 1
+      #   #  WHERE id = 5
+      #
+      #   # For the Posts with id of 10 and 15, increment the comment_count by 1
+      #   Post.update_counters [10, 15], comment_count: 1
+      #   # Executes the following SQL:
+      #   # UPDATE posts
+      #   #    SET comment_count = COALESCE(comment_count, 0) + 1
+      #   #  WHERE id IN (10, 15)
+      def update_counters(id, counters)
+        updates = counters.map do |counter_name, value|
+          operator = value < 0 ? '-' : '+'
+          quoted_column = connection.quote_column_name(counter_name)
+          "#{quoted_column} = COALESCE(#{quoted_column}, 0) #{operator} #{value.abs}"
+        end
 
-      update_all(updates.join(', '), primary_key => id )
-    end
+        where(primary_key => id).update_all updates.join(', ')
+      end
 
-    # Increment a number field by one, usually representing a count.
-    #
-    # This is used for caching aggregate values, so that they don't need to be computed every time.
-    # For example, a DiscussionBoard may cache post_count and comment_count otherwise every time the board is
-    # shown it would have to run an SQL query to find how many posts and comments there are.
-    #
-    # ==== Parameters
-    #
-    # * +counter_name+ - The name of the field that should be incremented.
-    # * +id+ - The id of the object that should be incremented.
-    #
-    # ==== Examples
-    #
-    #   # Increment the post_count column for the record with an id of 5
-    #   DiscussionBoard.increment_counter(:post_count, 5)
-    def increment_counter(counter_name, id)
-      update_counters(id, counter_name => 1)
-    end
+      # Increment a numeric field by one, via a direct SQL update.
+      #
+      # This method is used primarily for maintaining counter_cache columns used to
+      # store aggregate values. For example, a DiscussionBoard may cache posts_count
+      # and comments_count to avoid running an SQL query to calculate the number of
+      # posts and comments there are each time it is displayed.
+      #
+      # ==== Parameters
+      #
+      # * +counter_name+ - The name of the field that should be incremented.
+      # * +id+ - The id of the object that should be incremented or an Array of ids.
+      #
+      # ==== Examples
+      #
+      #   # Increment the post_count column for the record with an id of 5
+      #   DiscussionBoard.increment_counter(:post_count, 5)
+      def increment_counter(counter_name, id)
+        update_counters(id, counter_name => 1)
+      end
 
-    # Decrement a number field by one, usually representing a count.
-    #
-    # This works the same as increment_counter but reduces the column value by 1 instead of increasing it.
-    #
-    # ==== Parameters
-    #
-    # * +counter_name+ - The name of the field that should be decremented.
-    # * +id+ - The id of the object that should be decremented.
-    #
-    # ==== Examples
-    #
-    #   # Decrement the post_count column for the record with an id of 5
-    #   DiscussionBoard.decrement_counter(:post_count, 5)
-    def decrement_counter(counter_name, id)
-      update_counters(id, counter_name => -1)
+      # Decrement a numeric field by one, via a direct SQL update.
+      #
+      # This works the same as increment_counter but reduces the column value by
+      # 1 instead of increasing it.
+      #
+      # ==== Parameters
+      #
+      # * +counter_name+ - The name of the field that should be decremented.
+      # * +id+ - The id of the object that should be decremented or an Array of ids.
+      #
+      # ==== Examples
+      #
+      #   # Decrement the post_count column for the record with an id of 5
+      #   DiscussionBoard.decrement_counter(:post_count, 5)
+      def decrement_counter(counter_name, id)
+        update_counters(id, counter_name => -1)
+      end
     end
   end
 end

data/lib/active_record/dynamic_matchers.rb

@@ -1,84 +1,131 @@
 module ActiveRecord
-  module DynamicMatchers
-    def respond_to?(method_id, include_private = false)
-      if match = DynamicFinderMatch.match(method_id)
-        return true if all_attributes_exists?(match.attribute_names)
-      elsif match = DynamicScopeMatch.match(method_id)
-        return true if all_attributes_exists?(match.attribute_names)
-      end
+  module DynamicMatchers #:nodoc:
+    # This code in this file seems to have a lot of indirection, but the indirection
+    # is there to provide extension points for the activerecord-deprecated_finders
+    # gem. When we stop supporting activerecord-deprecated_finders (from Rails 5),
+    # then we can remove the indirection.
 
-      super
+    def respond_to?(name, include_private = false)
+      match = Method.match(self, name)
+      match && match.valid? || super
     end
 
     private
 
-    # Enables dynamic finders like <tt>User.find_by_user_name(user_name)</tt> and
-    # <tt>User.scoped_by_user_name(user_name). Refer to Dynamic attribute-based finders
-    # section at the top of this file for more detailed information.
-    #
-    # It's even possible to use all the additional parameters to +find+. For example, the
-    # full interface for +find_all_by_amount+ is actually <tt>find_all_by_amount(amount, options)</tt>.
-    #
-    # Each dynamic finder using <tt>scoped_by_*</tt> is also defined in the class after it
-    # is first invoked, so that future attempts to use it do not run through method_missing.
-    def method_missing(method_id, *arguments, &block)
-      if match = (DynamicFinderMatch.match(method_id) || DynamicScopeMatch.match(method_id))
-        attribute_names = match.attribute_names
-        super unless all_attributes_exists?(attribute_names)
-        if !(match.is_a?(DynamicFinderMatch) && match.instantiator? && arguments.first.is_a?(Hash)) && arguments.size < attribute_names.size
-          method_trace = "#{__FILE__}:#{__LINE__}:in `#{method_id}'"
-          backtrace = [method_trace] + caller
-          raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{attribute_names.size})", backtrace
-        end
-        if match.respond_to?(:scope?) && match.scope?
-          self.class_eval <<-METHOD, __FILE__, __LINE__ + 1
-            def self.#{method_id}(*args)                                    # def self.scoped_by_user_name_and_password(*args)
-              attributes = Hash[[:#{attribute_names.join(',:')}].zip(args)] #   attributes = Hash[[:user_name, :password].zip(args)]
-                                                                            #
-              scoped(:conditions => attributes)                             #   scoped(:conditions => attributes)
-            end                                                             # end
-          METHOD
-          send(method_id, *arguments)
-        elsif match.finder?
-          options = if arguments.length > attribute_names.size
-                      arguments.extract_options!
-                    else
-                      {}
-                    end
-
-          relation = options.any? ? scoped(options) : scoped
-          relation.send :find_by_attributes, match, attribute_names, *arguments, &block
-        elsif match.instantiator?
-          scoped.send :find_or_instantiator_by_attributes, match, attribute_names, *arguments, &block
-        end
+    def method_missing(name, *arguments, &block)
+      match = Method.match(self, name)
+
+      if match && match.valid?
+        match.define
+        send(name, *arguments, &block)
       else
         super
       end
     end
 
-    # Similar in purpose to +expand_hash_conditions_for_aggregates+.
-    def expand_attribute_names_for_aggregates(attribute_names)
-      attribute_names.map { |attribute_name|
-        unless (aggregation = reflect_on_aggregation(attribute_name.to_sym)).nil?
-          aggregate_mapping(aggregation).map do |field_attr, _|
-            field_attr.to_sym
-          end
-        else
-          attribute_name.to_sym
+    class Method
+      @matchers = []
+
+      class << self
+        attr_reader :matchers
+
+        def match(model, name)
+          klass = matchers.find { |k| name =~ k.pattern }
+          klass.new(model, name) if klass
+        end
+
+        def pattern
+          /^#{prefix}_([_a-zA-Z]\w*)#{suffix}$/
+        end
+
+        def prefix
+          raise NotImplementedError
         end
-      }.flatten
+
+        def suffix
+          ''
+        end
+      end
+
+      attr_reader :model, :name, :attribute_names
+
+      def initialize(model, name)
+        @model           = model
+        @name            = name.to_s
+        @attribute_names = @name.match(self.class.pattern)[1].split('_and_')
+        @attribute_names.map! { |n| @model.attribute_aliases[n] || n }
+      end
+
+      def valid?
+        attribute_names.all? { |name| model.columns_hash[name] || model.reflect_on_aggregation(name.to_sym) }
+      end
+
+      def define
+        model.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def self.#{name}(#{signature})
+            #{body}
+          end
+        CODE
+      end
+
+      def body
+        raise NotImplementedError
+      end
     end
 
-    def all_attributes_exists?(attribute_names)
-      (expand_attribute_names_for_aggregates(attribute_names) -
-       column_methods_hash.keys).empty?
+    module Finder
+      # Extended in activerecord-deprecated_finders
+      def body
+        result
+      end
+
+      # Extended in activerecord-deprecated_finders
+      def result
+        "#{finder}(#{attributes_hash})"
+      end
+
+      # Extended in activerecord-deprecated_finders
+      def signature
+        attribute_names.join(', ')
+      end
+
+      def attributes_hash
+        "{" + attribute_names.map { |name| ":#{name} => #{name}" }.join(',') + "}"
+      end
+
+      def finder
+        raise NotImplementedError
+      end
     end
 
-    def aggregate_mapping(reflection)
-      mapping = reflection.options[:mapping] || [reflection.name, reflection.name]
-      mapping.first.is_a?(Array) ? mapping : [mapping]
+    class FindBy < Method
+      Method.matchers << self
+      include Finder
+
+      def self.prefix
+        "find_by"
+      end
+
+      def finder
+        "find_by"
+      end
     end
 
+    class FindByBang < Method
+      Method.matchers << self
+      include Finder
+
+      def self.prefix
+        "find_by"
+      end
+
+      def self.suffix
+        "!"
+      end
 
+      def finder
+        "find_by!"
+      end
+    end
   end
 end

data/lib/active_record/errors.rb

@@ -22,7 +22,7 @@ module ActiveRecord
   #   end
   #
   #   # Comments are not patches, this assignment raises AssociationTypeMismatch.
-  #   @ticket.patches << Comment.new(:content => "Please attach tests to your patch.")
+  #   @ticket.patches << Comment.new(content: "Please attach tests to your patch.")
   class AssociationTypeMismatch < ActiveRecordError
   end
 
@@ -53,6 +53,10 @@ module ActiveRecord
   class RecordNotSaved < ActiveRecordError
   end
 
+  # Raised by ActiveRecord::Base.destroy! when a call to destroy would return false.
+  class RecordNotDestroyed < ActiveRecordError
+  end
+
   # Raised when SQL statement cannot be executed by the database (for example, it's often the case for
   # MySQL when Ruby driver used is too old).
   class StatementInvalid < ActiveRecordError
@@ -102,13 +106,11 @@ module ActiveRecord
     attr_reader :record, :attempted_action
 
     def initialize(record, attempted_action)
+      super("Attempted to #{attempted_action} a stale object: #{record.class.name}")
       @record = record
       @attempted_action = attempted_action
     end
 
-    def message
-      "Attempted to #{attempted_action} a stale object: #{record.class.name}"
-    end
   end
 
   # Raised when association is being configured improperly or
@@ -164,9 +166,9 @@ module ActiveRecord
   class AttributeAssignmentError < ActiveRecordError
     attr_reader :exception, :attribute
     def initialize(message, exception, attribute)
+      super(message)
       @exception = exception
       @attribute = attribute
-      @message = message
     end
   end
 
@@ -185,11 +187,26 @@ module ActiveRecord
     attr_reader :model
 
     def initialize(model)
+      super("Unknown primary key for table #{model.table_name} in model #{model}.")
       @model = model
     end
 
-    def message
-      "Unknown primary key for table #{model.table_name} in model #{model}."
-    end
+  end
+
+  # Raised when a relation cannot be mutated because it's already loaded.
+  #
+  #   class Task < ActiveRecord::Base
+  #   end
+  #
+  #   relation = Task.all
+  #   relation.loaded? # => true
+  #
+  #   # Methods which try to mutate a loaded relation fail.
+  #   relation.where!(title: 'TODO')  # => ActiveRecord::ImmutableRelation
+  #   relation.limit!(5)              # => ActiveRecord::ImmutableRelation
+  class ImmutableRelation < ActiveRecordError
+  end
+
+  class TransactionIsolationError < ActiveRecordError
   end
 end