activerecord 3.1.12 → 3.2.22.1

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.
   #
@@ -422,11 +419,15 @@ module ActiveRecord
       cache_for_connection(connection).update(fixtures_map)
     end
 
-    def self.instantiate_fixtures(object, fixture_name, fixtures, load_instances = true)
+    #--
+    # TODO:NOTE: in the next version, the __with_new_arity suffix and
+    #   the method with the old arity will be removed.
+    #++
+    def self.instantiate_fixtures__with_new_arity(object, fixture_set, load_instances = true) # :nodoc:
       if load_instances
-        fixtures.each do |name, fixture|
+        fixture_set.each do |fixture_name, fixture|
           begin
-            object.instance_variable_set "@#{name}", fixture.find
+            object.instance_variable_set "@#{fixture_name}", fixture.find
           rescue FixtureClassNotFound
             nil
           end
@@ -434,9 +435,24 @@ module ActiveRecord
       end
     end
 
+    # The use with parameters  <tt>(object, fixture_set_name, fixture_set, load_instances = true)</tt>  is deprecated,  +fixture_set_name+  parameter is not used.
+    # Use as:
+    #
+    #   instantiate_fixtures(object, fixture_set, load_instances = true)
+    def self.instantiate_fixtures(object, fixture_set, load_instances = true, rails_3_2_compatibility_argument = true)
+      unless load_instances == true || load_instances == false
+        ActiveSupport::Deprecation.warn(
+          "ActiveRecord::Fixtures.instantiate_fixtures with parameters (object, fixture_set_name, fixture_set, load_instances = true) is deprecated and shall be removed from future releases.  Use it with parameters (object, fixture_set, load_instances = true) instead (skip fixture_set_name).",
+          caller)
+        fixture_set = load_instances
+        load_instances = rails_3_2_compatibility_argument
+      end
+      instantiate_fixtures__with_new_arity(object, fixture_set, load_instances)
+    end
+
     def self.instantiate_all_loaded_fixtures(object, load_instances = true)
-      all_loaded_fixtures.each do |table_name, fixtures|
-        ActiveRecord::Fixtures.instantiate_fixtures(object, table_name, fixtures, load_instances)
+      all_loaded_fixtures.each_value do |fixture_set|
+        ActiveRecord::Fixtures.instantiate_fixtures(object, fixture_set, load_instances)
       end
     end
 
@@ -467,7 +483,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)
@@ -573,7 +589,7 @@ module ActiveRecord
 
           # interpolate the fixture label
           row.each do |key, value|
-            row[key] = label if value == "$LABEL"
+            row[key] = label if value.is_a?(String) && value == "$LABEL"
           end
 
           # generate a primary key if necessary
@@ -645,81 +661,23 @@ 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
-      end
   end
 
   class Fixture #:nodoc:
@@ -794,7 +752,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 +838,7 @@ module ActiveRecord
       end
 
       @fixture_cache = {}
+      @fixture_connections = []
       @@already_loaded_fixtures ||= {}
 
       # Load fixtures once and begin transaction.
@@ -890,9 +849,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 +874,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)
@@ -938,8 +909,8 @@ module ActiveRecord
           ActiveRecord::Fixtures.instantiate_all_loaded_fixtures(self, load_instances?)
         else
           raise RuntimeError, 'Load fixtures before instantiating them.' if @loaded_fixtures.nil?
-          @loaded_fixtures.each do |fixture_name, fixtures|
-            ActiveRecord::Fixtures.instantiate_fixtures(self, fixture_name, fixtures, load_instances?)
+          @loaded_fixtures.each_value do |fixture_set|
+            ActiveRecord::Fixtures.instantiate_fixtures(self, fixture_set, load_instances?)
           end
         end
       end

data/lib/active_record/identity_map.rb

@@ -117,13 +117,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,174 @@
+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
+          instance = use_identity_map(sti_class, record_id, record)
+        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 use_identity_map(sti_class, record_id, record)
+        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
+
+        instance
+      end
+
+      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

data/lib/active_record/integration.rb

@@ -0,0 +1,60 @@
+module ActiveRecord
+  module Integration
+    extend ActiveSupport::Concern
+
+    included do
+      ##
+      # :singleton-method:
+      # Indicates the format used to generate the timestamp format in the cache key.
+      # This is +:number+, by default.
+      class_attribute :cache_timestamp_format, :instance_writer => false
+      self.cache_timestamp_format = :number
+    end
+
+    # Returns a String, which Action Pack uses for constructing an URL to this
+    # object. The default implementation returns this record's id as a String,
+    # or nil if this record's unsaved.
+    #
+    # For example, suppose that you have a User model, and that you have a
+    # <tt>resources :users</tt> route. Normally, +user_path+ will
+    # construct a path with the user object's 'id' in it:
+    #
+    #   user = User.find_by_name('Phusion')
+    #   user_path(user)  # => "/users/1"
+    #
+    # You can override +to_param+ in your model to make +user_path+ construct
+    # a path using the user's name instead of the user's id:
+    #
+    #   class User < ActiveRecord::Base
+    #     def to_param  # overridden
+    #       name
+    #     end
+    #   end
+    #
+    #   user = User.find_by_name('Phusion')
+    #   user_path(user)  # => "/users/Phusion"
+    def to_param
+      # We can't use alias_method here, because method 'id' optimizes itself on the fly.
+      id && id.to_s # Be sure to stringify the id for routes
+    end
+
+    # Returns a cache key that can be used to identify this record.
+    #
+    # ==== Examples
+    #
+    #   Product.new.cache_key     # => "products/new"
+    #   Product.find(5).cache_key # => "products/5" (updated_at not available)
+    #   Person.find(5).cache_key  # => "people/5-20071224150000" (updated_at available)
+    def cache_key
+      case
+      when new_record?
+        "#{self.class.model_name.cache_key}/new"
+      when timestamp = self[:updated_at]
+        timestamp = timestamp.utc.to_s(cache_timestamp_format)
+        "#{self.class.model_name.cache_key}/#{id}-#{timestamp}"
+      else
+        "#{self.class.model_name.cache_key}/#{id}"
+      end
+    end
+  end
+end

data/lib/active_record/locking/optimistic.rb

@@ -37,6 +37,9 @@ module ActiveRecord
     # You're then responsible for dealing with the conflict by rescuing the exception and either rolling back, merging,
     # or otherwise apply the business logic needed to resolve the conflict.
     #
+    # This locking mechanism will function inside a single Ruby process. To make it work across all
+    # web requests, the recommended approach is to add +lock_version+ as a hidden field to your form.
+    #
     # You must ensure that your database schema defaults the +lock_version+ column to 0.
     #
     # This behavior can be turned off by setting <tt>ActiveRecord::Base.lock_optimistically = false</tt>.
@@ -48,10 +51,6 @@ module ActiveRecord
       included do
         cattr_accessor :lock_optimistically, :instance_writer => false
         self.lock_optimistically = true
-
-        class << self
-          alias_method :locking_column=, :set_locking_column
-        end
       end
 
       def locking_enabled? #:nodoc:
@@ -65,21 +64,6 @@ module ActiveRecord
           send(lock_col + '=', previous_lock_value + 1)
         end
 
-        def attributes_from_column_definition
-          result = super
-
-          # If the locking column has no default value set,
-          # start the lock version at zero. Note we can't use
-          # <tt>locking_enabled?</tt> at this point as
-          # <tt>@attributes</tt> may not have been initialized yet.
-
-          if result.key?(self.class.locking_column) && lock_optimistically
-            result[self.class.locking_column] ||= 0
-          end
-
-          result
-        end
-
         def update(attribute_names = @attributes.keys) #:nodoc:
           return super unless locking_enabled?
           return 0 if attribute_names.empty?
@@ -96,14 +80,14 @@ module ActiveRecord
 
             stmt = relation.where(
               relation.table[self.class.primary_key].eq(id).and(
-                relation.table[lock_col].eq(quote_value(previous_lock_value))
+                relation.table[lock_col].eq(quote_value(previous_lock_value, self.class.columns_hash[lock_col]))
               )
             ).arel.compile_update(arel_attributes_values(false, false, attribute_names))
 
             affected_rows = connection.update stmt
 
             unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError, "Attempted to update a stale object: #{self.class.name}"
+              raise ActiveRecord::StaleObjectError.new(self, "update")
             end
 
             affected_rows
@@ -118,6 +102,8 @@ module ActiveRecord
         def destroy #:nodoc:
           return super unless locking_enabled?
 
+          destroy_associations
+
           if persisted?
             table = self.class.arel_table
             lock_col = self.class.locking_column
@@ -127,7 +113,7 @@ module ActiveRecord
             affected_rows = self.class.unscoped.where(predicate).delete_all
 
             unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError, "Attempted to delete a stale object: #{self.class.name}"
+              raise ActiveRecord::StaleObjectError.new(self, "destroy")
             end
           end
 
@@ -145,15 +131,24 @@ module ActiveRecord
           lock_optimistically && columns_hash[locking_column]
         end
 
+        def locking_column=(value)
+          @original_locking_column = @locking_column if defined?(@locking_column)
+          @locking_column          = value.to_s
+        end
+
         # Set the column to use for optimistic locking. Defaults to +lock_version+.
         def set_locking_column(value = nil, &block)
-          define_attr_method :locking_column, value, &block
-          value
+          deprecated_property_setter :locking_column, value, block
         end
 
         # The version column used for optimistic locking. Defaults to +lock_version+.
         def locking_column
-          reset_locking_column
+          reset_locking_column unless defined?(@locking_column)
+          @locking_column
+        end
+
+        def original_locking_column #:nodoc:
+          deprecated_original_property_getter :locking_column
         end
 
         # Quote the column name used for optimistic locking.
@@ -163,7 +158,7 @@ module ActiveRecord
 
         # Reset the column used for optimistic locking back to the +lock_version+ default.
         def reset_locking_column
-          set_locking_column DEFAULT_LOCKING_COLUMN
+          self.locking_column = DEFAULT_LOCKING_COLUMN
         end
 
         # Make sure the lock version column gets updated when counters are
@@ -172,6 +167,18 @@ module ActiveRecord
           counters = counters.merge(locking_column => 1) if locking_enabled?
           super
         end
+
+        # If the locking column has no default value set,
+        # start the lock version at zero. Note we can't use
+        # <tt>locking_enabled?</tt> at this point as
+        # <tt>@attributes</tt> may not have been initialized yet.
+        def initialize_attributes(attributes, options = {}) #:nodoc:
+          if attributes.key?(locking_column) && lock_optimistically
+            attributes[locking_column] ||= 0
+          end
+
+          attributes
+        end
       end
     end
   end

data/lib/active_record/locking/pessimistic.rb

@@ -14,7 +14,7 @@ module ActiveRecord
     #   Account.transaction do
     #     # select * from accounts where name = 'shugo' limit 1 for update
     #     shugo = Account.where("name = 'shugo'").lock(true).first
-    #     yuko = Account.where("name = 'shugo'").lock(true).first
+    #     yuko = Account.where("name = 'yuko'").lock(true).first
     #     shugo.balance -= 100
     #     shugo.save!
     #     yuko.balance += 100
@@ -38,6 +38,18 @@ module ActiveRecord
     #     account2.save!
     #   end
     #
+    # You can start a transaction and acquire the lock in one go by calling
+    # <tt>with_lock</tt> with a block. The block is called from within
+    # a transaction, the object is already locked. Example:
+    #
+    #   account = Account.first
+    #   account.with_lock do
+    #     # This block is called within a transaction,
+    #     # account is already locked.
+    #     account.balance -= 100
+    #     account.save!
+    #   end
+    #
     # Database-specific information on row locking:
     #   MySQL: http://dev.mysql.com/doc/refman/5.1/en/innodb-locking-reads.html
     #   PostgreSQL: http://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
@@ -50,6 +62,16 @@ module ActiveRecord
         reload(:lock => lock) if persisted?
         self
       end
+
+      # Wraps the passed block in a transaction, locking the object
+      # before yielding. You pass can the SQL locking clause
+      # as argument (see <tt>lock!</tt>).
+      def with_lock(lock = true)
+        transaction do
+          lock!(lock)
+          yield
+        end
+      end
     end
   end
 end