activerecord 1.13.2 → 1.14.0

data/lib/active_record/fixtures.rb

@@ -9,6 +9,9 @@ module YAML #:nodoc:
   end
 end
 
+class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
+end
+
 # Fixtures are a way of organizing data that you want to test against; in short, sample data. They come in 3 flavours:
 #
 #   1.  YAML fixtures
@@ -220,8 +223,10 @@ class Fixtures < YAML::Omap
     if load_instances
       ActiveRecord::Base.silence do
         fixtures.each do |name, fixture|
-          if model = fixture.find
-            object.instance_variable_set "@#{name}", model
+          begin
+            object.instance_variable_set "@#{name}", fixture.find
+          rescue FixtureClassNotFound
+            nil
           end
         end
       end
@@ -237,14 +242,13 @@ class Fixtures < YAML::Omap
   cattr_accessor :all_loaded_fixtures
   self.all_loaded_fixtures = {}
 
-  def self.create_fixtures(fixtures_directory, *table_names)
-    table_names = table_names.flatten.map { |n| n.to_s }
+  def self.create_fixtures(fixtures_directory, table_names, class_names = {})
+    table_names = [table_names].flatten.map { |n| n.to_s }
     connection = block_given? ? yield : ActiveRecord::Base.connection
-
     ActiveRecord::Base.silence do
       fixtures_map = {}
       fixtures = table_names.map do |table_name|
-        fixtures_map[table_name] = Fixtures.new(connection, File.split(table_name.to_s).last, File.join(fixtures_directory, table_name.to_s))
+        fixtures_map[table_name] = Fixtures.new(connection, File.split(table_name.to_s).last, class_names[table_name.to_sym], File.join(fixtures_directory, table_name.to_s))
       end               
       all_loaded_fixtures.merge! fixtures_map  
 
@@ -267,10 +271,10 @@ class Fixtures < YAML::Omap
 
   attr_reader :table_name
 
-  def initialize(connection, table_name, fixture_path, file_filter = DEFAULT_FILTER_RE)
+  def initialize(connection, table_name, class_name, fixture_path, file_filter = DEFAULT_FILTER_RE)
     @connection, @table_name, @fixture_path, @file_filter = connection, table_name, fixture_path, file_filter
-
-    @class_name = ActiveRecord::Base.pluralize_table_names ? @table_name.singularize.camelize : @table_name.camelize
+    @class_name = class_name || 
+                  (ActiveRecord::Base.pluralize_table_names ? @table_name.singularize.camelize : @table_name.camelize)
     @table_name = ActiveRecord::Base.table_name_prefix + @table_name + ActiveRecord::Base.table_name_suffix
     read_fixture_files
   end
@@ -286,11 +290,18 @@ class Fixtures < YAML::Omap
   end
 
   private
+
     def read_fixture_files
       if File.file?(yaml_file_path)
         # YAML fixtures
         begin
-          if yaml = YAML::load(erb_render(IO.read(yaml_file_path)))
+          yaml_string = ""
+          Dir["#{@fixture_path}/**/*.yml"].select {|f| test(?f,f) }.each do |subfixture_path|
+            yaml_string << IO.read(subfixture_path)
+          end
+          yaml_string << IO.read(yaml_file_path)
+
+          if yaml = YAML::load(erb_render(yaml_string))
             yaml = yaml.value if yaml.respond_to?(:type_id) and yaml.respond_to?(:value)
             yaml.each do |name, data|
               self[name] = Fixture.new(data, @class_name)
@@ -385,9 +396,11 @@ class Fixture #:nodoc:
   end
 
   def find
-    if Object.const_defined?(@class_name)
-      klass = Object.const_get(@class_name)
+    klass = @class_name.is_a?(Class) ? @class_name : Object.const_get(@class_name) rescue nil
+    if klass
       klass.find(self[klass.primary_key])
+    else
+      raise FixtureClassNotFound, "The class #{@class_name.inspect} was not found."
     end
   end
 
@@ -416,6 +429,7 @@ module Test #:nodoc:
     class TestCase #:nodoc:
       cattr_accessor :fixture_path
       class_inheritable_accessor :fixture_table_names
+      class_inheritable_accessor :fixture_class_names
       class_inheritable_accessor :use_transactional_fixtures
       class_inheritable_accessor :use_instantiated_fixtures   # true, false, or :no_instances
       class_inheritable_accessor :pre_loaded_fixtures
@@ -424,9 +438,16 @@ module Test #:nodoc:
       self.use_transactional_fixtures = false
       self.use_instantiated_fixtures = true
       self.pre_loaded_fixtures = false
-
+      
+      self.fixture_class_names = {}
+      
       @@already_loaded_fixtures = {}
-
+      self.fixture_class_names = {}
+      
+      def self.set_fixture_class(class_names = {})
+        self.fixture_class_names = self.fixture_class_names.merge(class_names)
+      end
+      
       def self.fixtures(*table_names)
         table_names = table_names.flatten.map { |n| n.to_s }
         self.fixture_table_names |= table_names
@@ -453,7 +474,11 @@ module Test #:nodoc:
             force_reload = optionals.shift
             @fixture_cache[table_name] ||= Hash.new
             @fixture_cache[table_name][fixture] = nil if force_reload
-            @fixture_cache[table_name][fixture] ||= @loaded_fixtures[table_name][fixture.to_s].find
+            if @loaded_fixtures[table_name][fixture.to_s]
+              @fixture_cache[table_name][fixture] ||= @loaded_fixtures[table_name][fixture.to_s].find
+            else
+              raise StandardError, "No fixture with name '#{fixture}' found for table '#{table_name}'"
+            end
           end
         end
       end
@@ -508,7 +533,7 @@ module Test #:nodoc:
           ActiveRecord::Base.connection.rollback_db_transaction
           ActiveRecord::Base.unlock_mutex
         end
-        ActiveRecord::Base.clear_connection_cache!
+        ActiveRecord::Base.verify_active_connections!
       end
 
       alias_method :teardown, :teardown_with_fixtures
@@ -537,7 +562,7 @@ module Test #:nodoc:
       private
         def load_fixtures
           @loaded_fixtures = {}
-          fixtures = Fixtures.create_fixtures(fixture_path, fixture_table_names)
+          fixtures = Fixtures.create_fixtures(fixture_path, fixture_table_names, fixture_class_names)
           unless fixtures.nil?
             if fixtures.instance_of?(Fixtures)
               @loaded_fixtures[fixtures.table_name] = fixtures

data/lib/active_record/locking.rb

@@ -18,6 +18,8 @@ module ActiveRecord
   # 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>.
+  # To override the name of the lock_version column, invoke the <tt>set_locking_column</tt> method.
+  # This method uses the same syntax as <tt>set_table_name</tt>
   module Locking
     def self.append_features(base) #:nodoc:
       super
@@ -28,22 +30,24 @@ module ActiveRecord
     end
 
     def update_with_lock #:nodoc:
-      if locking_enabled?
-        previous_value    = self.lock_version
-        self.lock_version = previous_value + 1
-        
-        affected_rows = connection.update(<<-end_sql, "#{self.class.name} Update with optimistic locking")
-          UPDATE #{self.class.table_name}
-          SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))}
-          WHERE #{self.class.primary_key} = #{quote(id)} AND lock_version = #{quote(previous_value)}
-        end_sql
+      return update_without_lock unless locking_enabled?
 
-        unless affected_rows == 1
-          raise ActiveRecord::StaleObjectError, "Attempted to update a stale object"
-        end
-      else
-        update_without_lock
+      lock_col = self.class.locking_column
+      previous_value = send(lock_col)
+      send(lock_col + '=', previous_value + 1)
+
+      affected_rows = connection.update(<<-end_sql, "#{self.class.name} Update with optimistic locking")
+        UPDATE #{self.class.table_name}
+        SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))}
+        WHERE #{self.class.primary_key} = #{quote(id)} 
+        AND #{lock_col} = #{quote(previous_value)}
+      end_sql
+
+      unless affected_rows == 1
+        raise ActiveRecord::StaleObjectError, "Attempted to update a stale object"
       end
+
+      return true
     end
   end
 
@@ -52,7 +56,24 @@ module ActiveRecord
     cattr_accessor :lock_optimistically
 
     def locking_enabled? #:nodoc:
-      lock_optimistically && respond_to?(:lock_version)
+      lock_optimistically && respond_to?(self.class.locking_column)
+    end
+    
+    class << self
+      def set_locking_column(value = nil, &block)
+        define_attr_method :locking_column, value, &block
+      end
+  
+      def locking_column #:nodoc:
+        reset_locking_column
+      end
+  
+      def reset_locking_column #:nodoc:
+        default = 'lock_version'
+        set_locking_column(default)
+        default
+      end
     end
+    
   end
 end

data/lib/active_record/migration.rb

@@ -93,7 +93,7 @@ module ActiveRecord
   # pending migrations, creating the <tt>schema_info</tt> table if missing.
   #
   # To roll the database back to a previous migration version, use
-  # <tt>rake migrate version=X</tt> where <tt>X</tt> is the version to which
+  # <tt>rake migrate VERSION=X</tt> where <tt>X</tt> is the version to which
   # you wish to downgrade. If any of the migrations throw an
   # <tt>IrreversibleMigration</tt> exception, that step will fail and you'll
   # have some manual work to do.
@@ -101,7 +101,7 @@ module ActiveRecord
   # == Database support
   #
   # Migrations are currently supported in MySQL, PostgreSQL, SQLite,
-  # SQL Server, and Oracle (all supported databases except DB2).
+  # SQL Server, Sybase, and Oracle (all supported databases except DB2).
   #
   # == More examples
   #
@@ -159,16 +159,118 @@ module ActiveRecord
   #       end
   #     end
   #   end
+  #
+  # == Controlling verbosity
+  #
+  # By default, migrations will describe the actions they are taking, writing
+  # them to the console as they happen, along with benchmarks describing how
+  # long each step took.
+  #
+  # You can quiet them down by setting ActiveRecord::Migration.verbose = false.
+  #
+  # You can also insert your own messages and benchmarks by using the #say_with_time
+  # method:
+  #
+  #   def self.up
+  #     ...
+  #     say_with_time "Updating salaries..." do
+  #       Person.find(:all).each do |p|
+  #         p.salary = SalaryCalculator.compute(p)
+  #       end
+  #     end
+  #     ...
+  #   end
+  #
+  # The phrase "Updating salaries..." would then be printed, along with the
+  # benchmark for the block when the block completes.
   class Migration
+    @@verbose = true
+    cattr_accessor :verbose
+
     class << self
-      def up() end
-      def down() end
+      def up_using_benchmarks #:nodoc:
+        migrate(:up)
+      end
+
+      def down_using_benchmarks #:nodoc:
+        migrate(:down)
+      end
+
+      # Execute this migration in the named direction
+      def migrate(direction)
+        return unless respond_to?(direction)
+
+        case direction
+          when :up   then announce "migrating"
+          when :down then announce "reverting"
+        end
+        
+        result = nil
+        time = Benchmark.measure { result = send("real_#{direction}") }
+
+        case direction
+          when :up   then announce "migrated (%.4fs)" % time.real; write
+          when :down then announce "reverted (%.4fs)" % time.real; write
+        end
+        
+        result
+      end
+
+      # Because the method added may do an alias_method, it can be invoked
+      # recursively. We use @ignore_new_methods as a guard to indicate whether
+      # it is safe for the call to proceed.
+      def singleton_method_added(sym) #:nodoc:
+        return if @ignore_new_methods
+        
+        begin
+          @ignore_new_methods = true
+
+          case sym
+            when :up, :down
+              klass = (class << self; self; end)
+              klass.send(:alias_method, "real_#{sym}", sym)
+              klass.send(:alias_method, sym, "#{sym}_using_benchmarks")
+          end
+        ensure
+          @ignore_new_methods = false
+        end
+      end
+
+      def write(text="")
+        puts(text) if verbose
+      end
 
-      private
-        def method_missing(method, *arguments, &block)
-          arguments[0] = Migrator.proper_table_name(arguments.first) unless arguments.empty?
+      def announce(message)
+        text = "#{name}: #{message}"
+        write "== %s %s" % [ text, "=" * (75 - text.length) ]
+      end
+
+      def say(message, subitem=false)
+        write "#{subitem ? "   ->" : "--"} #{message}"
+      end
+
+      def say_with_time(message)
+        say(message)
+        result = nil
+        time = Benchmark.measure { result = yield }
+        say "%.4fs" % time.real, :subitem
+        result
+      end
+
+      def suppress_messages
+        save = verbose
+        self.verbose = false
+        yield
+      ensure
+        self.verbose = save
+      end
+
+      def method_missing(method, *arguments, &block)
+        say_with_time "#{method}(#{arguments.map { |a| a.inspect }.join(", ")})" do
+          arguments[0] = Migrator.proper_table_name(arguments.first) unless arguments.empty? || method == :execute
           ActiveRecord::Base.connection.send(method, *arguments, &block)
         end
+      end
     end
   end
 
@@ -176,6 +278,7 @@ module ActiveRecord
     class << self
       def migrate(migrations_path, target_version = nil)
         Base.connection.initialize_schema_information
+
         case
           when target_version.nil?, current_version < target_version
             up(migrations_path, target_version)
@@ -225,7 +328,7 @@ module ActiveRecord
         next if irrelevant_migration?(version)
 
         Base.logger.info "Migrating to #{migration_class} (#{version})"
-        migration_class.send(@direction)
+        migration_class.migrate(@direction)
         set_schema_version(version)
       end
     end

data/lib/active_record/observer.rb

@@ -42,6 +42,18 @@ module ActiveRecord
   #
   # This Observer sends an email when a Comment#save is finished.
   #
+  #   class ContactObserver < ActiveRecord::Observer
+  #     def after_create(contact)
+  #       contact.logger.info('New contact added!')
+  #     end
+  #
+  #     def after_destroy(contact)
+  #       contact.logger.warn("Contact with an id of #{contact.id} was destroyed!")
+  #     end
+  #   end
+  #
+  # This Observer uses logger to log when specific callbacks are triggered.
+  #
   # == Observing a class that can't be inferred
   #
   # Observers will by default be mapped to the class with which they share a name. So CommentObserver will
@@ -72,15 +84,27 @@ module ActiveRecord
   #
   # The observer can implement callback methods for each of the methods described in the Callbacks module.
   #
-  # == Triggering Observers
+  # == Storing Observers in Rails
+  # 
+  # If you're using Active Record within Rails, observer classes are usually stored in app/models with the
+  # naming convention of app/models/audit_observer.rb.
+  #
+  # == Configuration
   # 
   # In order to activate an observer, list it in the <tt>config.active_record.observers</tt> configuration setting in your
   # <tt>config/environment.rb</tt> file.
   #
   #   config.active_record.observers = :comment_observer, :signup_observer
+  #
+  # Observers will not be invoked unless you define these in your application configuration.
+  #
   class Observer
     include Singleton
 
+    # Observer subclasses should be reloaded by the dispatcher in Rails
+    # when Dependencies.mechanism = :load.
+    include Reloadable::Subclasses
+    
     # Attaches the observer to the supplied model classes.
     def self.observe(*models)
       define_method(:observed_class) { models }

data/lib/active_record/reflection.rb

@@ -1,36 +1,7 @@
 module ActiveRecord
   module Reflection # :nodoc:
-    def self.append_features(base)
-      super
+    def self.included(base)
       base.extend(ClassMethods)
-
-      base.class_eval do
-        class << self
-          alias_method :composed_of_without_reflection, :composed_of
-
-          def composed_of_with_reflection(part_id, options = {})
-            composed_of_without_reflection(part_id, options)
-            reflect_on_all_aggregations << AggregateReflection.new(:composed_of, part_id, options, self)
-          end
-
-          alias_method :composed_of, :composed_of_with_reflection
-        end
-      end
-
-      for association_type in %w( belongs_to has_one has_many has_and_belongs_to_many )
-        base.module_eval <<-"end_eval"
-          class << self
-            alias_method :#{association_type}_without_reflection, :#{association_type}
-      
-            def #{association_type}_with_reflection(association_id, options = {}, &block)
-              #{association_type}_without_reflection(association_id, options, &block)      
-              reflect_on_all_associations << AssociationReflection.new(:#{association_type}, association_id, options, self)
-            end
-      
-            alias_method :#{association_type}, :#{association_type}_with_reflection
-          end
-        end_eval
-      end
     end
 
     # Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations.
@@ -39,26 +10,46 @@ module ActiveRecord
     #
     # You can find the interface for the AggregateReflection and AssociationReflection classes in the abstract MacroReflection class.
     module ClassMethods
+      def create_reflection(macro, name, options, active_record)
+        case macro
+          when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
+            reflection = AssociationReflection.new(macro, name, options, active_record)
+          when :composed_of
+            reflection = AggregateReflection.new(macro, name, options, active_record)
+        end
+        write_inheritable_hash :reflections, name => reflection
+        reflection
+      end
+      
+      def reflections
+        read_inheritable_attribute(:reflections) or write_inheritable_attribute(:reflections, {})
+      end
+      
       # Returns an array of AggregateReflection objects for all the aggregations in the class.
       def reflect_on_all_aggregations
-        read_inheritable_attribute(:aggregations) or write_inheritable_attribute(:aggregations, [])
+        reflections.values.select { |reflection| reflection.is_a?(AggregateReflection) }
       end
 
       # Returns the AggregateReflection object for the named +aggregation+ (use the symbol). Example:
       #   Account.reflect_on_aggregation(:balance) # returns the balance AggregateReflection
       def reflect_on_aggregation(aggregation)
-        reflect_on_all_aggregations.find { |reflection| reflection.name == aggregation } unless reflect_on_all_aggregations.nil?
+        reflections[aggregation].is_a?(AggregateReflection) ? reflections[aggregation] : nil
       end
 
-      # Returns an array of AssociationReflection objects for all the aggregations in the class.
-      def reflect_on_all_associations
-        read_inheritable_attribute(:associations) or write_inheritable_attribute(:associations, [])
+      # Returns an array of AssociationReflection objects for all the aggregations in the class. If you only want to reflect on a
+      # certain association type, pass in the symbol (:has_many, :has_one, :belongs_to) for that as the first parameter. Example:
+      # Account.reflect_on_all_associations             # returns an array of all associations
+      # Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
+      def reflect_on_all_associations(macro = nil)
+        association_reflections = reflections.values.select { |reflection| reflection.is_a?(AssociationReflection) }
+        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
       end
 
       # Returns the AssociationReflection object for the named +aggregation+ (use the symbol). Example:
       #   Account.reflect_on_association(:owner) # returns the owner AssociationReflection
+      #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
       def reflect_on_association(association)
-        reflect_on_all_associations.find { |reflection| reflection.name == association }
+        reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
       end
     end
 
@@ -92,6 +83,10 @@ module ActiveRecord
       # Returns the class for the macro, so "composed_of :balance, :class_name => 'Money'" would return the Money class and
       # "has_many :clients" would return the Client class.
       def klass() end
+        
+      def class_name
+        @class_name ||= name_to_class_name(name.id2name)
+      end
 
       def ==(other_aggregation)
         name == other_aggregation.name && other_aggregation.options && active_record == other_aggregation.active_record
@@ -102,7 +97,7 @@ module ActiveRecord
     # Holds all the meta-data about an aggregation as it was specified in the Active Record class.
     class AggregateReflection < MacroReflection #:nodoc:
       def klass
-        Object.const_get(options[:class_name] || name_to_class_name(name.id2name))
+        @klass ||= Object.const_get(class_name)
       end
 
       private
@@ -114,23 +109,90 @@ module ActiveRecord
     # Holds all the meta-data about an association as it was specified in the Active Record class.
     class AssociationReflection < MacroReflection #:nodoc:
       def klass
-        @klass ||= active_record.send(:compute_type, (name_to_class_name(name.id2name)))
+        @klass ||= active_record.send(:compute_type, class_name)
       end
 
       def table_name
         @table_name ||= klass.table_name
       end
 
+      def primary_key_name
+        return @primary_key_name if @primary_key_name
+        case
+          when macro == :belongs_to
+            @primary_key_name = options[:foreign_key] || class_name.foreign_key
+          when options[:as]
+            @primary_key_name = options[:foreign_key] || "#{options[:as]}_id"
+          else
+            @primary_key_name = options[:foreign_key] || active_record.name.foreign_key
+        end
+      end
+      
+      def association_foreign_key
+        @association_foreign_key ||= @options[:association_foreign_key] || class_name.foreign_key
+      end
+
+      def counter_cache_column
+        if options[:counter_cache] == true
+          "#{active_record.name.underscore.pluralize}_count"
+        elsif options[:counter_cache]
+          options[:counter_cache]
+        end
+      end
+
+      def through_reflection
+        @through_reflection ||= options[:through] ? active_record.reflect_on_association(options[:through]) : false
+      end
+
+      # Gets an array of possible :through source reflection names
+      #
+      #   [singularized, pluralized]
+      def source_reflection_names
+        @source_reflection_names ||= (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }
+      end
+
+      # Gets the source of the through reflection.  It checks both a singularized and pluralized form for :belongs_to or :has_many.
+      # (The :tags association on Tagging below)
+      # 
+      #   class Post
+      #     has_many :tags, :through => :taggings
+      #   end
+      #
+      def source_reflection
+        return nil unless through_reflection
+        @source_reflection ||= source_reflection_names.collect { |name| through_reflection.klass.reflect_on_association(name) }.compact.first
+      end
+
+      def check_validity!
+        if options[:through]
+          if through_reflection.nil?
+            raise HasManyThroughAssociationNotFoundError.new(self)
+          end
+          
+          if source_reflection.nil?
+            raise HasManyThroughSourceAssociationNotFoundError.new(self)
+          end
+          
+          if source_reflection.options[:polymorphic]
+            raise HasManyThroughAssociationPolymorphicError.new(class_name, @reflection, source_reflection)
+          end
+        end
+      end
+
       private
         def name_to_class_name(name)
           if name =~ /::/
             name
           else
-            unless class_name = options[:class_name]
+            if options[:class_name]
+              options[:class_name]
+            elsif through_reflection # get the class_name of the belongs_to association of the through reflection
+              source_reflection.class_name
+            else
               class_name = name.to_s.camelize
-              class_name = class_name.singularize if [:has_many, :has_and_belongs_to_many].include?(macro)
+              class_name = class_name.singularize if [ :has_many, :has_and_belongs_to_many ].include?(macro)
+              class_name
             end
-            active_record.send(:type_name_with_module, class_name)
           end
         end
     end