activerecord 3.2.22.5 → 5.2.8

data/lib/active_record/counter_cache.rb

@@ -1,123 +1,218 @@
+# frozen_string_literal: true
+
 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)
-
-        if has_many_association.options[:as]
-          has_many_association.options[:as].to_s.classify
-        else
-          self.name
+    extend ActiveSupport::Concern
+
+    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 association counters to reset. Association name or counter name can be given.
+      # * <tt>:touch</tt> - Touch timestamp columns when updating.
+      #   Pass +true+ to touch +updated_at+ and/or +updated_on+. Pass a symbol to
+      #   touch that column or an array of symbols to touch just those ones.
+      #
+      # ==== Examples
+      #
+      #   # For the Post with id #1, reset the comments_count
+      #   Post.reset_counters(1, :comments)
+      #
+      #   # Like above, but also touch the +updated_at+ and/or +updated_on+
+      #   # attributes.
+      #   Post.reset_counters(1, :comments, touch: true)
+      def reset_counters(id, *counters, touch: nil)
+        object = find(id)
+
+        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, "'#{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
+          end
+
+          foreign_key  = has_many_association.foreign_key.to_s
+          child_class  = has_many_association.klass
+          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
+
+          updates = { counter_name => object.send(counter_association).count(:all) }
+
+          if touch
+            names = touch if touch != true
+            updates.merge!(touch_attributes_with_time(*names))
+          end
+
+          unscoped.where(primary_key => object.id).update_all(updates)
+        end
+
+        true
+      end
+
+      # 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+ - A Hash containing the names of the fields
+      #   to update as keys and the amount to update the field by as values.
+      # * <tt>:touch</tt> option - Touch timestamp columns when updating.
+      #   If attribute names are passed, they are updated along with updated_at/on
+      #   attributes.
+      #
+      # ==== 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)
+      #
+      #   # For the Posts with id of 10 and 15, increment the comment_count by 1
+      #   # and update the updated_at value for each counter.
+      #   Post.update_counters [10, 15], comment_count: 1, touch: true
+      #   # Executes the following SQL:
+      #   # UPDATE posts
+      #   #    SET comment_count = COALESCE(comment_count, 0) + 1,
+      #   #    `updated_at` = '2016-10-13T09:59:23-05:00'
+      #   #  WHERE id IN (10, 15)
+      def update_counters(id, counters)
+        touch = counters.delete(:touch)
+
+        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
 
-        if has_many_association.is_a? ActiveRecord::Reflection::ThroughReflection
-          has_many_association = has_many_association.through_reflection
+        if touch
+          names = touch if touch != true
+          touch_updates = touch_attributes_with_time(*names)
+          updates << sanitize_sql_for_assignment(touch_updates) unless touch_updates.empty?
         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
+        if id.is_a?(Relation) && self == id.klass
+          relation = id
+        else
+          relation = unscoped.where!(primary_key => id)
+        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
+        relation.update_all updates.join(", ")
+      end
+
+      # Increment a numeric field by one, via a direct SQL update.
+      #
+      # This method is used primarily for maintaining counter_cache columns that are
+      # 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.
+      # * <tt>:touch</tt> - Touch timestamp columns when updating.
+      #   Pass +true+ to touch +updated_at+ and/or +updated_on+. Pass a symbol to
+      #   touch that column or an array of symbols to touch just those ones.
+      #
+      # ==== Examples
+      #
+      #   # Increment the posts_count column for the record with an id of 5
+      #   DiscussionBoard.increment_counter(:posts_count, 5)
+      #
+      #   # Increment the posts_count column for the record with an id of 5
+      #   # and update the updated_at value.
+      #   DiscussionBoard.increment_counter(:posts_count, 5, touch: true)
+      def increment_counter(counter_name, id, touch: nil)
+        update_counters(id, counter_name => 1, touch: touch)
+      end
+
+      # 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.
+      # * <tt>:touch</tt> - Touch timestamp columns when updating.
+      #   Pass +true+ to touch +updated_at+ and/or +updated_on+. Pass a symbol to
+      #   touch that column or an array of symbols to touch just those ones.
+      #
+      # ==== Examples
+      #
+      #   # Decrement the posts_count column for the record with an id of 5
+      #   DiscussionBoard.decrement_counter(:posts_count, 5)
+      #
+      #   # Decrement the posts_count column for the record with an id of 5
+      #   # and update the updated_at value.
+      #   DiscussionBoard.decrement_counter(:posts_count, 5, touch: true)
+      def decrement_counter(counter_name, id, touch: nil)
+        update_counters(id, counter_name => -1, touch: touch)
       end
-      return true
     end
 
-    # 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}"
+    private
+
+      def _create_record(*)
+        id = super
+
+        each_counter_cached_associations do |association|
+          if send(association.reflection.name)
+            association.increment_counters
+          end
+        end
+
+        id
       end
 
-      IdentityMap.remove_by_id(symbolized_base_class, id) if IdentityMap.enabled?
+      def destroy_row
+        affected_rows = super
 
-      update_all(updates.join(', '), primary_key => id )
-    end
+        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
 
-    # 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
+        affected_rows
+      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)
-    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/define_callbacks.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  # This module exists because ActiveRecord::AttributeMethods::Dirty needs to
+  # define callbacks, but continue to have its version of +save+ be the super
+  # method of ActiveRecord::Callbacks. This will be removed when the removal
+  # of deprecated code removes this need.
+  module DefineCallbacks
+    extend ActiveSupport::Concern
+
+    module ClassMethods # :nodoc:
+      include ActiveModel::Callbacks
+    end
+
+    included do
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :initialize, :find, :touch, only: :after
+      define_model_callbacks :save, :create, :update, :destroy
+    end
+  end
+end

data/lib/active_record/dynamic_matchers.rb

@@ -1,84 +1,122 @@
+# frozen_string_literal: true
+
 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)
+  module DynamicMatchers #:nodoc:
+    private
+      def respond_to_missing?(name, _)
+        if self == Base
+          super
+        else
+          match = Method.match(self, name)
+          match && match.valid? || super
+        end
       end
 
-      super
-    end
+      def method_missing(name, *arguments, &block)
+        match = Method.match(self, name)
 
-    private
+        if match && match.valid?
+          match.define
+          send(name, *arguments, &block)
+        else
+          super
+        end
+      end
+
+      class Method
+        @matchers = []
+
+        class << self
+          attr_reader :matchers
+
+          def match(model, name)
+            klass = matchers.find { |k| k.pattern.match?(name) }
+            klass.new(model, name) if klass
+          end
+
+          def pattern
+            @pattern ||= /\A#{prefix}_([_a-zA-Z]\w*)#{suffix}\Z/
+          end
 
-    # 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
+          def prefix
+            raise NotImplementedError
+          end
+
+          def suffix
+            ""
+          end
         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
+
+        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
-      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
+
+        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
+
+        private
+
+          def body
+            "#{finder}(#{attributes_hash})"
           end
-        else
-          attribute_name.to_sym
+
+          # The parameters in the signature may have reserved Ruby words, in order
+          # to prevent errors, we start each param name with `_`.
+          def signature
+            attribute_names.map { |name| "_#{name}" }.join(", ")
+          end
+
+          # Given that the parameters starts with `_`, the finder needs to use the
+          # same parameter name.
+          def attributes_hash
+            "{" + attribute_names.map { |name| ":#{name} => _#{name}" }.join(",") + "}"
+          end
+
+          def finder
+            raise NotImplementedError
+          end
+      end
+
+      class FindBy < Method
+        Method.matchers << self
+
+        def self.prefix
+          "find_by"
+        end
+
+        def finder
+          "find_by"
         end
-      }.flatten
-    end
+      end
 
-    def all_attributes_exists?(attribute_names)
-      (expand_attribute_names_for_aggregates(attribute_names) -
-       column_methods_hash.keys).empty?
-    end
+      class FindByBang < Method
+        Method.matchers << self
 
-    def aggregate_mapping(reflection)
-      mapping = reflection.options[:mapping] || [reflection.name, reflection.name]
-      mapping.first.is_a?(Array) ? mapping : [mapping]
-    end
+        def self.prefix
+          "find_by"
+        end
 
+        def self.suffix
+          "!"
+        end
 
+        def finder
+          "find_by!"
+        end
+      end
   end
 end