activerecord 3.0.0 → 4.0.0

data/lib/active_record/counter_cache.rb

@@ -1,115 +1,122 @@
 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
 
-        expected_name = if has_many_association.options[:as]
-          has_many_association.options[:as].to_s.classify
-        else
-          self.name
-        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 association counters 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)
+          raise ArgumentError, "'#{self.name}' has no association called '#{association}'" unless has_many_association
 
-        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
+          if has_many_association.is_a? ActiveRecord::Reflection::ThroughReflection
+            has_many_association = has_many_association.through_reflection
+          end
 
-        self.unscoped.where(arel_table[self.primary_key].eq(object.id)).arel.update({
-          arel_table[counter_name] => object.send(association).count
-        })
-      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 = comment_count - 1,
-    #   #        action_count = action_count + 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 = comment_count + 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
 
-      update_all(updates.join(', '), primary_key => id )
-    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}"
+        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
+        where(primary_key => id).update_all updates.join(', ')
+      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)
+      # 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 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

@@ -0,0 +1,131 @@
+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)
+      match = Method.match(self, name)
+      match && match.valid? || super
+    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
+          /^#{prefix}_([_a-zA-Z]\w*)#{suffix}$/
+        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
+
+      # 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
+
+    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,24 +53,29 @@ module ActiveRecord
   class RecordNotSaved < 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).
+  # Raised by ActiveRecord::Base.destroy! when a call to destroy would return false.
+  class RecordNotDestroyed < ActiveRecordError
+  end
+
+  # Superclass for all database execution errors.
+  #
+  # Wraps the underlying database error as +original_exception+.
   class StatementInvalid < ActiveRecordError
+    attr_reader :original_exception
+
+    def initialize(message, original_exception = nil)
+      super(message)
+      @original_exception = original_exception
+    end
   end
 
   # Raised when SQL statement is invalid and the application gets a blank result.
   class ThrowResult < ActiveRecordError
   end
 
-  # Parent class for all specific exceptions which wrap database driver exceptions
-  # provides access to the original exception also.
+  # Defunct wrapper class kept for compatibility.
+  # +StatementInvalid+ wraps the original exception now.
   class WrappedDatabaseException < StatementInvalid
-    attr_reader :original_exception
-
-    def initialize(message, original_exception)
-      super(message)
-      @original_exception = original_exception
-    end
   end
 
   # Raised when a record cannot be inserted because it would violate a uniqueness constraint.
@@ -87,7 +92,7 @@ module ActiveRecord
   #
   # For example, in
   #
-  #   Location.find :all, :conditions => ["lat = ? AND lng = ?", 53.7362]
+  #   Location.where("lat = ? AND lng = ?", 53.7362)
   #
   # two placeholders are given but only one variable to fill them.
   class PreparedStatementInvalid < ActiveRecordError
@@ -99,6 +104,14 @@ module ActiveRecord
   #
   # Read more about optimistic locking in ActiveRecord::Locking module RDoc.
   class StaleObjectError < ActiveRecordError
+    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
+
   end
 
   # Raised when association is being configured improperly or
@@ -154,9 +167,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
 
@@ -169,4 +182,32 @@ module ActiveRecord
       @errors = errors
     end
   end
+
+  # Raised when a primary key is needed, but there is not one specified in the schema or model.
+  class UnknownPrimaryKey < ActiveRecordError
+    attr_reader :model
+
+    def initialize(model)
+      super("Unknown primary key for table #{model.table_name} in model #{model}.")
+      @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

data/lib/active_record/explain.rb

@@ -0,0 +1,38 @@
+require 'active_support/lazy_load_hooks'
+require 'active_record/explain_registry'
+
+module ActiveRecord
+  module Explain
+    # Executes the block with the collect flag enabled. Queries are collected
+    # asynchronously by the subscriber and returned.
+    def collecting_queries_for_explain # :nodoc:
+      ExplainRegistry.collect = true
+      yield
+      ExplainRegistry.queries
+    ensure
+      ExplainRegistry.reset
+    end
+
+    # Makes the adapter execute EXPLAIN for the tuples of queries and bindings.
+    # Returns a formatted string ready to be logged.
+    def exec_explain(queries) # :nodoc:
+      str = queries.map do |sql, bind|
+        [].tap do |msg|
+          msg << "EXPLAIN for: #{sql}"
+          unless bind.empty?
+            bind_msg = bind.map {|col, val| [col.name, val]}.inspect
+            msg.last << " #{bind_msg}"
+          end
+          msg << connection.explain(sql, bind)
+        end.join("\n")
+      end.join("\n")
+
+      # Overriding inspect to be more human readable, specially in the console.
+      def str.inspect
+        self
+      end
+
+      str
+    end
+  end
+end

data/lib/active_record/explain_registry.rb

@@ -0,0 +1,30 @@
+require 'active_support/per_thread_registry'
+
+module ActiveRecord
+  # This is a thread locals registry for EXPLAIN. For example
+  #
+  #   ActiveRecord::ExplainRegistry.queries
+  #
+  # returns the collected queries local to the current thread.
+  #
+  # See the documentation of <tt>ActiveSupport::PerThreadRegistry</tt>
+  # for further details.
+  class ExplainRegistry # :nodoc:
+    extend ActiveSupport::PerThreadRegistry
+
+    attr_accessor :queries, :collect
+
+    def initialize
+      reset
+    end
+
+    def collect?
+      @collect
+    end
+
+    def reset
+      @collect = false
+      @queries = []
+    end
+  end
+end

data/lib/active_record/explain_subscriber.rb

@@ -0,0 +1,29 @@
+require 'active_support/notifications'
+require 'active_record/explain_registry'
+
+module ActiveRecord
+  class ExplainSubscriber # :nodoc:
+    def start(name, id, payload)
+      # unused
+    end
+
+    def finish(name, id, payload)
+      if ExplainRegistry.collect? && !ignore_payload?(payload)
+        ExplainRegistry.queries << payload.values_at(:sql, :binds)
+      end
+    end
+
+    # SCHEMA queries cannot be EXPLAINed, also we do not want to run EXPLAIN on
+    # our own EXPLAINs now matter how loopingly beautiful that would be.
+    #
+    # 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
+    def ignore_payload?(payload)
+      payload[:exception] || IGNORED_PAYLOADS.include?(payload[:name]) || payload[:sql] !~ EXPLAINED_SQLS
+    end
+
+    ActiveSupport::Notifications.subscribe("sql.active_record", new)
+  end
+end

data/lib/active_record/fixture_set/file.rb

@@ -0,0 +1,55 @@
+require 'erb'
+require 'yaml'
+
+module ActiveRecord
+  class FixtureSet
+    class File # :nodoc:
+      include Enumerable
+
+      ##
+      # Open a fixture file named +file+.  When called with a block, the block
+      # is called with the filehandle and the filehandle is automatically closed
+      # when the block finishes.
+      def self.open(file)
+        x = new file
+        block_given? ? yield(x) : x
+      end
+
+      def initialize(file)
+        @file = file
+        @rows = nil
+      end
+
+      def each(&block)
+        rows.each(&block)
+      end
+
+
+      private
+        def rows
+          return @rows if @rows
+
+          begin
+            data = YAML.load(render(IO.read(@file)))
+          rescue ArgumentError, Psych::SyntaxError => error
+            raise Fixture::FormatError, "a YAML error occurred parsing #{@file}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{error.class}: #{error}", error.backtrace
+          end
+          @rows = data ? validate(data).to_a : []
+        end
+
+        def render(content)
+          ERB.new(content).result
+        end
+
+        # Validate our unmarshalled data.
+        def validate(data)
+          unless Hash === data || YAML::Omap === data
+            raise Fixture::FormatError, 'fixture is not a hash'
+          end
+
+          raise Fixture::FormatError unless data.all? { |name, row| Hash === row }
+          data
+        end
+    end
+  end
+end