activerecord 3.1.11 → 3.2.0

data/lib/active_record/dynamic_matchers.rb

@@ -0,0 +1,79 @@
+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
+
+      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 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 = arguments.extract_options!
+          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
+      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
+        end
+      }.flatten
+    end
+
+    def all_attributes_exists?(attribute_names)
+      (expand_attribute_names_for_aggregates(attribute_names) -
+       column_methods_hash.keys).empty?
+    end
+
+    def aggregate_mapping(reflection)
+      mapping = reflection.options[:mapping] || [reflection.name, reflection.name]
+      mapping.first.is_a?(Array) ? mapping : [mapping]
+    end
+
+
+  end
+end

data/lib/active_record/errors.rb

@@ -87,7 +87,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 +99,16 @@ 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)
+      @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

data/lib/active_record/explain.rb

@@ -0,0 +1,83 @@
+require 'active_support/core_ext/class/attribute'
+
+module ActiveRecord
+  module Explain
+    def self.extended(base)
+      base.class_eval do
+        # If a query takes longer than these many seconds we log its query plan
+        # automatically. nil disables this feature.
+        class_attribute :auto_explain_threshold_in_seconds, :instance_writer => false
+        self.auto_explain_threshold_in_seconds = nil
+      end
+    end
+
+    # If auto explain is enabled, this method triggers EXPLAIN logging for the
+    # queries triggered by the block if it takes more than the threshold as a
+    # whole. That is, the threshold is not checked against each individual
+    # query, but against the duration of the entire block. This approach is
+    # convenient for relations.
+    #
+    # The available_queries_for_explain thread variable collects the queries
+    # to be explained. If the value is nil, it means queries are not being
+    # currently collected. A false value indicates collecting is turned
+    # off. Otherwise it is an array of queries.
+    def logging_query_plan # :nodoc:
+      threshold = auto_explain_threshold_in_seconds
+      current   = Thread.current
+      if threshold && current[:available_queries_for_explain].nil?
+        begin
+          queries = current[:available_queries_for_explain] = []
+          start = Time.now
+          result = yield
+          logger.warn(exec_explain(queries)) if Time.now - start > threshold
+          result
+        ensure
+          current[:available_queries_for_explain] = nil
+        end
+      else
+        yield
+      end
+    end
+
+    # Relation#explain needs to be able to collect the queries regardless of
+    # whether auto explain is enabled. This method serves that purpose.
+    def collecting_queries_for_explain # :nodoc:
+      current = Thread.current
+      original, current[:available_queries_for_explain] = current[:available_queries_for_explain], []
+      return yield, current[:available_queries_for_explain]
+    ensure
+      # Note that the return value above does not depend on this assigment.
+      current[:available_queries_for_explain] = original
+    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:
+      queries && 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")
+    end
+
+    # Silences automatic EXPLAIN logging for the duration of the block.
+    #
+    # This has high priority, no EXPLAINs will be run even if downwards
+    # the threshold is set to 0.
+    #
+    # As the name of the method suggests this only applies to automatic
+    # EXPLAINs, manual calls to +ActiveRecord::Relation#explain+ run.
+    def silence_auto_explain
+      current = Thread.current
+      original, current[:available_queries_for_explain] = current[:available_queries_for_explain], false
+      yield
+    ensure
+      current[:available_queries_for_explain] = original
+    end
+  end
+end

data/lib/active_record/explain_subscriber.rb

@@ -0,0 +1,21 @@
+require 'active_support/notifications'
+
+module ActiveRecord
+  class ExplainSubscriber # :nodoc:
+    def call(*args)
+      if queries = Thread.current[:available_queries_for_explain]
+        payload = args.last
+        queries << payload.values_at(:sql, :binds) unless ignore_payload?(payload)
+      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.
+    IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN)
+    def ignore_payload?(payload)
+      payload[:exception] || IGNORED_PAYLOADS.include?(payload[:name])
+    end
+
+    ActiveSupport::Notifications.subscribe("sql.active_record", new)
+  end
+end

data/lib/active_record/fixtures/file.rb

@@ -0,0 +1,65 @@
+begin
+  require 'psych'
+rescue LoadError
+end
+
+require 'erb'
+require 'yaml'
+
+module ActiveRecord
+  class Fixtures
+    class File
+      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
+
+      RESCUE_ERRORS = [ ArgumentError ] # :nodoc:
+
+      private
+      if defined?(Psych) && defined?(Psych::SyntaxError)
+        RESCUE_ERRORS << Psych::SyntaxError
+      end
+
+      def rows
+        return @rows if @rows
+
+        begin
+          data = YAML.load(render(IO.read(@file)))
+        rescue *RESCUE_ERRORS => 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

data/lib/active_record/fixtures.rb

@@ -6,14 +6,13 @@ rescue LoadError
 end
 
 require 'yaml'
-require 'csv'
 require 'zlib'
 require 'active_support/dependencies'
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/logger'
 require 'active_support/ordered_hash'
-require 'active_support/core_ext/module/deprecation'
+require 'active_record/fixtures/file'
 
 if defined? ActiveRecord
   class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
@@ -23,8 +22,6 @@ else
   end
 end
 
-class FixturesFileNotFound < StandardError; end
-
 module ActiveRecord
   # \Fixtures are a way of organizing data that you want to test against; in short, sample data.
   #
@@ -467,7 +464,7 @@ module ActiveRecord
               connection,
               table_name,
               class_names[table_name.to_sym] || table_name.classify,
-              File.join(fixtures_directory, path))
+              ::File.join(fixtures_directory, path))
           end
 
           all_loaded_fixtures.update(fixtures_map)
@@ -645,80 +642,25 @@ module ActiveRecord
       end
 
       def read_fixture_files
-        if File.file?(yaml_file_path)
-          read_yaml_fixture_files
-        elsif File.file?(csv_file_path)
-          read_csv_fixture_files
-        else
-          raise FixturesFileNotFound, "Could not find #{yaml_file_path} or #{csv_file_path}"
-        end
-      end
-
-      def read_yaml_fixture_files
-        yaml_string = (Dir["#{@fixture_path}/**/*.yml"].select { |f|
-          File.file?(f)
-        } + [yaml_file_path]).map { |file_path| IO.read(file_path) }.join
-
-        if yaml = parse_yaml_string(yaml_string)
-          # If the file is an ordered map, extract its children.
-          yaml_value =
-            if yaml.respond_to?(:type_id) && yaml.respond_to?(:value)
-              yaml.value
-            else
-              [yaml]
-            end
-
-          yaml_value.each do |fixture|
-            raise Fixture::FormatError, "Bad data for #{@class_name} fixture named #{fixture}" unless fixture.respond_to?(:each)
-            fixture.each do |name, data|
-              unless data
-                raise Fixture::FormatError, "Bad data for #{@class_name} fixture named #{name} (nil)"
-              end
-
-              fixtures[name] = ActiveRecord::Fixture.new(data, model_class)
+        yaml_files = Dir["#{@fixture_path}/**/*.yml"].select { |f|
+          ::File.file?(f)
+        } + [yaml_file_path]
+
+        yaml_files.each do |file|
+          Fixtures::File.open(file) do |fh|
+            fh.each do |name, row|
+              fixtures[name] = ActiveRecord::Fixture.new(row, model_class)
             end
           end
         end
       end
 
-      def read_csv_fixture_files
-        reader = CSV.parse(erb_render(IO.read(csv_file_path)))
-        header = reader.shift
-        i = 0
-        reader.each do |row|
-          data = {}
-          row.each_with_index { |cell, j| data[header[j].to_s.strip] = cell.to_s.strip }
-          fixtures["#{@class_name.to_s.underscore}_#{i+=1}"] = ActiveRecord::Fixture.new(data, model_class)
-        end
-      end
-      deprecate :read_csv_fixture_files
-
       def yaml_file_path
         "#{@fixture_path}.yml"
       end
 
-      def csv_file_path
-        @fixture_path + ".csv"
-      end
-
       def yaml_fixtures_key(path)
-        File.basename(@fixture_path).split(".").first
-      end
-
-      RESCUE_ERRORS = [ ArgumentError ]
-
-      if defined?(Psych) && defined?(Psych::SyntaxError)
-        RESCUE_ERRORS << Psych::SyntaxError
-      end
-
-      def parse_yaml_string(fixture_content)
-        YAML::load(erb_render(fixture_content))
-      rescue *RESCUE_ERRORS => error
-        raise Fixture::FormatError, "a YAML error occurred parsing #{yaml_file_path}. 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
-
-      def erb_render(fixture_content)
-        ERB.new(fixture_content).result
+        ::File.basename(@fixture_path).split(".").first
       end
   end
 
@@ -794,7 +736,7 @@ module ActiveRecord
 
       def fixtures(*fixture_names)
         if fixture_names.first == :all
-          fixture_names = Dir["#{fixture_path}/**/*.{yml,csv}"]
+          fixture_names = Dir["#{fixture_path}/**/*.{yml}"]
           fixture_names.map! { |f| f[(fixture_path.size + 1)..-5] }
         else
           fixture_names = fixture_names.flatten.map { |n| n.to_s }
@@ -880,6 +822,7 @@ module ActiveRecord
       end
 
       @fixture_cache = {}
+      @fixture_connections = []
       @@already_loaded_fixtures ||= {}
 
       # Load fixtures once and begin transaction.
@@ -890,9 +833,12 @@ module ActiveRecord
           @loaded_fixtures = load_fixtures
           @@already_loaded_fixtures[self.class] = @loaded_fixtures
         end
-        ActiveRecord::Base.connection.increment_open_transactions
-        ActiveRecord::Base.connection.transaction_joinable = false
-        ActiveRecord::Base.connection.begin_db_transaction
+        @fixture_connections = enlist_fixture_connections
+        @fixture_connections.each do |connection|
+          connection.increment_open_transactions
+          connection.transaction_joinable = false
+          connection.begin_db_transaction
+        end
       # Load fixtures for every test.
       else
         ActiveRecord::Fixtures.reset_cache
@@ -912,13 +858,22 @@ module ActiveRecord
       end
 
       # Rollback changes if a transaction is active.
-      if run_in_transaction? && ActiveRecord::Base.connection.open_transactions != 0
-        ActiveRecord::Base.connection.rollback_db_transaction
-        ActiveRecord::Base.connection.decrement_open_transactions
+      if run_in_transaction?
+        @fixture_connections.each do |connection|
+          if connection.open_transactions != 0
+            connection.rollback_db_transaction
+            connection.decrement_open_transactions
+          end
+        end
+        @fixture_connections.clear
       end
       ActiveRecord::Base.clear_active_connections!
     end
 
+    def enlist_fixture_connections
+      ActiveRecord::Base.connection_handler.connection_pools.values.map(&:connection)
+    end
+
     private
       def load_fixtures
         fixtures = ActiveRecord::Fixtures.create_fixtures(fixture_path, fixture_table_names, fixture_class_names)

data/lib/active_record/identity_map.rb

@@ -90,7 +90,7 @@ module ActiveRecord
       end
 
       def add(record)
-        repository[record.class.symbolized_sti_name][record.id] = record if contain_all_columns?(record)
+        repository[record.class.symbolized_sti_name][record.id] = record
       end
 
       def remove(record)
@@ -104,12 +104,6 @@ module ActiveRecord
       def clear
         repository.clear
       end
-
-      private
-
-        def contain_all_columns?(record)
-          (record.class.column_names - record.attribute_names).empty?
-        end
     end
 
     # Reinitialize an Identity Map model object from +coder+.
@@ -117,13 +111,12 @@ module ActiveRecord
     # model object.
     def reinit_with(coder)
       @attributes_cache = {}
-      dirty = @changed_attributes.keys
-      @attributes.update(coder['attributes'].except(*dirty))
+      dirty      = @changed_attributes.keys
+      attributes = self.class.initialize_attributes(coder['attributes'].except(*dirty))
+      @attributes.update(attributes)
       @changed_attributes.update(coder['attributes'].slice(*dirty))
       @changed_attributes.delete_if{|k,v| v.eql? @attributes[k]}
 
-      set_serialized_attributes
-
       run_callbacks :find
 
       self

data/lib/active_record/inheritance.rb

@@ -0,0 +1,167 @@
+require 'active_support/concern'
+
+module ActiveRecord
+  module Inheritance
+    extend ActiveSupport::Concern
+
+    included do
+      # Determine whether to store the full constant name including namespace when using STI
+      class_attribute :store_full_sti_class
+      self.store_full_sti_class = true
+    end
+
+    module ClassMethods
+      # True if this isn't a concrete subclass needing a STI type condition.
+      def descends_from_active_record?
+        if superclass.abstract_class?
+          superclass.descends_from_active_record?
+        else
+          superclass == Base || !columns_hash.include?(inheritance_column)
+        end
+      end
+
+      def finder_needs_type_condition? #:nodoc:
+        # This is like this because benchmarking justifies the strange :false stuff
+        :true == (@finder_needs_type_condition ||= descends_from_active_record? ? :false : :true)
+      end
+
+      def symbolized_base_class
+        @symbolized_base_class ||= base_class.to_s.to_sym
+      end
+
+      def symbolized_sti_name
+        @symbolized_sti_name ||= sti_name.present? ? sti_name.to_sym : symbolized_base_class
+      end
+
+      # Returns the base AR subclass that this class descends from. If A
+      # extends AR::Base, A.base_class will return A. If B descends from A
+      # through some arbitrarily deep hierarchy, B.base_class will return A.
+      #
+      # If B < A and C < B and if A is an abstract_class then both B.base_class
+      # and C.base_class would return B as the answer since A is an abstract_class.
+      def base_class
+        class_of_active_record_descendant(self)
+      end
+
+      # Set this to true if this is an abstract class (see <tt>abstract_class?</tt>).
+      attr_accessor :abstract_class
+
+      # Returns whether this class is an abstract class or not.
+      def abstract_class?
+        defined?(@abstract_class) && @abstract_class == true
+      end
+
+      def sti_name
+        store_full_sti_class ? name : name.demodulize
+      end
+
+      # Finder methods must instantiate through this method to work with the
+      # single-table inheritance model that makes it possible to create
+      # objects of different types from the same table.
+      def instantiate(record)
+        sti_class = find_sti_class(record[inheritance_column])
+        record_id = sti_class.primary_key && record[sti_class.primary_key]
+
+        if ActiveRecord::IdentityMap.enabled? && record_id
+          if (column = sti_class.columns_hash[sti_class.primary_key]) && column.number?
+            record_id = record_id.to_i
+          end
+          if instance = IdentityMap.get(sti_class, record_id)
+            instance.reinit_with('attributes' => record)
+          else
+            instance = sti_class.allocate.init_with('attributes' => record)
+            IdentityMap.add(instance)
+          end
+        else
+          instance = sti_class.allocate.init_with('attributes' => record)
+        end
+
+        instance
+      end
+
+      protected
+
+      # Returns the class descending directly from ActiveRecord::Base or an
+      # abstract class, if any, in the inheritance hierarchy.
+      def class_of_active_record_descendant(klass)
+        if klass == Base || klass.superclass == Base || klass.superclass.abstract_class?
+          klass
+        elsif klass.superclass.nil?
+          raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
+        else
+          class_of_active_record_descendant(klass.superclass)
+        end
+      end
+
+      # Returns the class type of the record using the current module as a prefix. So descendants of
+      # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
+      def compute_type(type_name)
+        if type_name.match(/^::/)
+          # If the type is prefixed with a scope operator then we assume that
+          # the type_name is an absolute reference.
+          ActiveSupport::Dependencies.constantize(type_name)
+        else
+          # Build a list of candidates to search for
+          candidates = []
+          name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
+          candidates << type_name
+
+          candidates.each do |candidate|
+            begin
+              constant = ActiveSupport::Dependencies.constantize(candidate)
+              return constant if candidate == constant.to_s
+            rescue NameError => e
+              # We don't want to swallow NoMethodError < NameError errors
+              raise e unless e.instance_of?(NameError)
+            end
+          end
+
+          raise NameError, "uninitialized constant #{candidates.first}"
+        end
+      end
+
+      private
+
+      def find_sti_class(type_name)
+        if type_name.blank? || !columns_hash.include?(inheritance_column)
+          self
+        else
+          begin
+            if store_full_sti_class
+              ActiveSupport::Dependencies.constantize(type_name)
+            else
+              compute_type(type_name)
+            end
+          rescue NameError
+            raise SubclassNotFound,
+              "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " +
+              "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " +
+              "Please rename this column if you didn't intend it to be used for storing the inheritance class " +
+              "or overwrite #{name}.inheritance_column to use another column for that information."
+          end
+        end
+      end
+
+      def type_condition(table = arel_table)
+        sti_column = table[inheritance_column.to_sym]
+        sti_names  = ([self] + descendants).map { |model| model.sti_name }
+
+        sti_column.in(sti_names)
+      end
+    end
+
+    private
+
+    # Sets the attribute used for single table inheritance to this class name if this is not the
+    # ActiveRecord::Base descendant.
+    # Considering the hierarchy Reply < Message < ActiveRecord::Base, this makes it possible to
+    # do Reply.new without having to set <tt>Reply[Reply.inheritance_column] = "Reply"</tt> yourself.
+    # No such attribute would be set for objects of the Message class in that example.
+    def ensure_proper_type
+      klass = self.class
+      if klass.finder_needs_type_condition?
+        write_attribute(klass.inheritance_column, klass.sti_name)
+      end
+    end
+  end
+end