activerecord 3.1.10 → 4.2.11

data/lib/active_record/counter_cache.rb

@@ -1,118 +1,175 @@
 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)
-
-        expected_name = 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.
+      #
+      # ==== 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 |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
+          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
+
+          stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({
+            arel_table[counter_name] => object.send(counter_association).count(:all)
+          }, primary_key)
+          connection.update stmt
+        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+ - A Hash 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
 
-        child_class  = has_many_association.klass
-        belongs_to   = child_class.reflect_on_all_associations(:belongs_to)
-        reflection   = belongs_to.find { |e| e.class_name == expected_name }
-        counter_name = reflection.counter_cache_column
+        unscoped.where(primary_key => id).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.
+      #
+      # ==== 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
 
-        stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({
-          arel_table[counter_name] => object.send(association).count
-        })
-        connection.update stmt
+      # 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
-      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}"
+    protected
+
+      def actually_destroyed?
+        @_actually_destroyed
       end
 
-      IdentityMap.remove_by_id(symbolized_base_class, id) if IdentityMap.enabled?
+      def clear_destroy_state
+        @_actually_destroyed = nil
+      end
 
-      update_all(updates.join(', '), primary_key => id )
-    end
+    private
 
-    # 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
+      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
 
-    # 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
   end
 end

data/lib/active_record/dynamic_matchers.rb

@@ -0,0 +1,140 @@
+module ActiveRecord
+  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.
+
+    def respond_to?(name, include_private = false)
+      if self == Base
+        super
+      else
+        match = Method.match(self, name)
+        match && match.valid? || super
+      end
+    end
+
+    private
+
+    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
+
+    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
+          @pattern ||= /\A#{prefix}_([_a-zA-Z]\w*)#{suffix}\Z/
+        end
+
+        def prefix
+          raise NotImplementedError
+        end
+
+        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
+
+    module Finder
+      # Extended in activerecord-deprecated_finders
+      def body
+        result
+      end
+
+      # Extended in activerecord-deprecated_finders
+      def result
+        "#{finder}(#{attributes_hash})"
+      end
+
+      # The parameters in the signature may have reserved Ruby words, in order
+      # to prevent errors, we start each param name with `_`.
+      #
+      # Extended in activerecord-deprecated_finders
+      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
+      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/enum.rb

@@ -0,0 +1,197 @@
+require 'active_support/core_ext/object/deep_dup'
+
+module ActiveRecord
+  # Declare an enum attribute where the values map to integers in the database,
+  # but can be queried by name. Example:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum status: [ :active, :archived ]
+  #   end
+  #
+  #   # conversation.update! status: 0
+  #   conversation.active!
+  #   conversation.active? # => true
+  #   conversation.status  # => "active"
+  #
+  #   # conversation.update! status: 1
+  #   conversation.archived!
+  #   conversation.archived? # => true
+  #   conversation.status    # => "archived"
+  #
+  #   # conversation.status = 1
+  #   conversation.status = "archived"
+  #
+  #   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:
+  #
+  #   Conversation.active
+  #   Conversation.archived
+  #
+  # You can set the default value from the database declaration, like:
+  #
+  #   create_table :conversations do |t|
+  #     t.column :status, :integer, default: 0
+  #   end
+  #
+  # Good practice is to let the first declared status be the default.
+  #
+  # Finally, it's also possible to explicitly map the relation between attribute and
+  # database integer with a +Hash+:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum status: { active: 0, archived: 1 }
+  #   end
+  #
+  # Note that when an +Array+ is used, the implicit mapping from the values to database
+  # integers is derived from the order the values appear in the array. In the example,
+  # <tt>:active</tt> is mapped to +0+ as it's the first element, and <tt>:archived</tt>
+  # is mapped to +1+. In general, the +i+-th element is mapped to <tt>i-1</tt> in the
+  # database.
+  #
+  # Therefore, once a value is added to the enum array, its position in the array must
+  # be maintained, and new values should only be added to the end of the array. To
+  # remove unused values, the explicit +Hash+ syntax should be used.
+  #
+  # In rare circumstances you might need to access the mapping directly.
+  # The mappings are exposed through a class method with the pluralized attribute
+  # name:
+  #
+  #   Conversation.statuses # => { "active" => 0, "archived" => 1 }
+  #
+  # Use that class method when you need to know the ordinal value of an enum:
+  #
+  #   Conversation.where("status <> ?", Conversation.statuses[:archived])
+  #
+  # 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, instance_writer: false)
+      base.defined_enums = {}
+    end
+
+    def inherited(base) # :nodoc:
+      base.defined_enums = defined_enums.deep_dup
+      super
+    end
+
+    def enum(definitions)
+      klass = self
+      definitions.each do |name, values|
+        # statuses = { }
+        enum_values = ActiveSupport::HashWithIndifferentAccess.new
+        name        = name.to_sym
+
+        # def self.statuses statuses end
+        detect_enum_conflict!(name, name.to_s.pluralize, true)
+        klass.singleton_class.send(:define_method, name.to_s.pluralize) { enum_values }
+
+        _enum_methods_module.module_eval do
+          # def status=(value) self[:status] = statuses[value] end
+          klass.send(:detect_enum_conflict!, name, "#{name}=")
+          define_method("#{name}=") { |value|
+            if enum_values.has_key?(value) || value.blank?
+              self[name] = enum_values[value]
+            elsif enum_values.has_value?(value)
+              # Assigning a value directly is not a end-user feature, hence it's not documented.
+              # This is used internally to make building objects from the generated scopes work
+              # as expected, i.e. +Conversation.archived.build.archived?+ should be true.
+              self[name] = value
+            else
+              raise ArgumentError, "'#{value}' is not a valid #{name}"
+            end
+          }
+
+          # def status() statuses.key self[:status] end
+          klass.send(:detect_enum_conflict!, name, name)
+          define_method(name) { enum_values.key self[name] }
+
+          # def status_before_type_cast() statuses.key self[:status] end
+          klass.send(:detect_enum_conflict!, name, "#{name}_before_type_cast")
+          define_method("#{name}_before_type_cast") { enum_values.key self[name] }
+
+          pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
+          pairs.each do |value, i|
+            enum_values[value] = i
+
+            # def active?() status == 0 end
+            klass.send(:detect_enum_conflict!, name, "#{value}?")
+            define_method("#{value}?") { self[name] == i }
+
+            # def active!() update! status: :active end
+            klass.send(:detect_enum_conflict!, name, "#{value}!")
+            define_method("#{value}!") { update! name => value }
+
+            # scope :active, -> { where status: 0 }
+            klass.send(:detect_enum_conflict!, name, value, true)
+            klass.scope value, -> { klass.where name => i }
+          end
+        end
+        defined_enums[name.to_s] = enum_values
+      end
+    end
+
+    private
+      def _enum_methods_module
+        @_enum_methods_module ||= begin
+          mod = Module.new do
+            private
+              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)
+                    if mapping[old] == value
+                      clear_attribute_changes([attr_name])
+                    end
+                  else
+                    if old != value
+                      set_attribute_was(attr_name, mapping.key(old))
+                    end
+                  end
+                else
+                  super
+                end
+              end
+          end
+          include mod
+          mod
+        end
+      end
+
+      ENUM_CONFLICT_MESSAGE = \
+        "You tried to define an enum named \"%{enum}\" on the model \"%{klass}\", but " \
+        "this will generate a %{type} method \"%{method}\", which is already defined " \
+        "by %{source}."
+
+      def detect_enum_conflict!(enum_name, method_name, klass_method = false)
+        if klass_method && dangerous_class_method?(method_name)
+          raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
+            enum: enum_name,
+            klass: self.name,
+            type: 'class',
+            method: method_name,
+            source: 'Active Record'
+          }
+        elsif !klass_method && dangerous_attribute_method?(method_name)
+          raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
+            enum: enum_name,
+            klass: self.name,
+            type: 'instance',
+            method: method_name,
+            source: 'Active Record'
+          }
+        elsif !klass_method && method_defined_within?(method_name, _enum_methods_module, Module)
+          raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
+            enum: enum_name,
+            klass: self.name,
+            type: 'instance',
+            method: method_name,
+            source: 'another enum'
+          }
+        end
+      end
+  end
+end