activerecord 1.14.4 → 1.15.0

data/lib/active_record/observer.rb

@@ -1,10 +1,10 @@
 require 'singleton'
+require 'set'
 
 module ActiveRecord
   module Observing # :nodoc:
-    def self.append_features(base)
-      super
-      base.extend(ClassMethods)
+    def self.included(base)
+      base.extend ClassMethods
     end
 
     module ClassMethods
@@ -13,18 +13,44 @@ module ActiveRecord
       #   # Calls PersonObserver.instance
       #   ActiveRecord::Base.observers = :person_observer
       #
-      #   # Calls Cacher.instance and GarbageCollector.instance 
+      #   # Calls Cacher.instance and GarbageCollector.instance
       #   ActiveRecord::Base.observers = :cacher, :garbage_collector
       #
       #   # Same as above, just using explicit class references
       #   ActiveRecord::Base.observers = Cacher, GarbageCollector
+      #
+      # Note: Setting this does not instantiate the observers yet.  #instantiate_observers is
+      # called during startup, and before each development request.  
       def observers=(*observers)
-        observers = [ observers ].flatten.each do |observer| 
-          observer.is_a?(Symbol) ? 
-            observer.to_s.camelize.constantize.instance :
+        @observers = observers.flatten
+      end
+
+      # Gets the current observers.
+      def observers
+        @observers ||= []
+      end
+
+      # Instantiate the global ActiveRecord observers
+      def instantiate_observers
+        return if @observers.blank?
+        @observers.each do |observer|
+          if observer.respond_to?(:to_sym) # Symbol or String
+            observer.to_s.camelize.constantize.instance
+          elsif observer.respond_to?(:instance)
             observer.instance
+          else
+            raise ArgumentError, "#{observer} must be a lowercase, underscored class name (or an instance of the class itself) responding to the instance method. Example: Person.observers = :big_brother # calls BigBrother.instance"
+          end
         end
       end
+
+      protected
+        # Notify observers when the observed class is subclassed.
+        def inherited(subclass)
+          super
+          changed
+          notify_observers :observed_class_inherited, subclass
+        end
     end
   end
 
@@ -85,12 +111,12 @@ module ActiveRecord
   # The observer can implement callback methods for each of the methods described in the Callbacks module.
   #
   # == 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.
   #
@@ -103,37 +129,50 @@ module ActiveRecord
 
     # 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 }
+    include Reloadable::Deprecated
+
+    class << self
+      # Attaches the observer to the supplied model classes.
+      def observe(*models)
+        define_method(:observed_classes) { Set.new(models) }
+      end
+
+      # The class observed by default is inferred from the observer's class name:
+      #   assert_equal [Person], PersonObserver.observed_class
+      def observed_class
+        name.scan(/(.*)Observer/)[0][0].constantize
+      end
     end
 
+    # Start observing the declared classes and their subclasses.
     def initialize
-      observed_classes = [ observed_class ].flatten
-      observed_subclasses_class = observed_classes.collect {|c| c.send(:subclasses) }.flatten!
-      (observed_classes + observed_subclasses_class).each do |klass| 
-        klass.add_observer(self)
-        klass.send(:define_method, :after_find) unless klass.respond_to?(:after_find)
-      end
+      Set.new(observed_classes + observed_subclasses).each { |klass| add_observer! klass }
     end
-  
-    def update(callback_method, object) #:nodoc:
-      send(callback_method, object) if respond_to?(callback_method)
+
+    # Send observed_method(object) if the method exists.
+    def update(observed_method, object) #:nodoc:
+      send(observed_method, object) if respond_to?(observed_method)
     end
-    
-    private
-      def observed_class
-        if self.class.respond_to? "observed_class"
-          self.class.observed_class
-        else
-          Object.const_get(infer_observed_class_name)
-        end
+
+    # Special method sent by the observed class when it is inherited.
+    # Passes the new subclass.
+    def observed_class_inherited(subclass) #:nodoc:
+      self.class.observe(observed_classes + [subclass])
+      add_observer!(subclass)
+    end
+
+    protected
+      def observed_classes
+        Set.new([self.class.observed_class].flatten)
+      end
+
+      def observed_subclasses
+        observed_classes.sum(&:subclasses)
       end
-      
-      def infer_observed_class_name
-        self.class.name.scan(/(.*)Observer/)[0][0]
+
+      def add_observer!(klass)
+        klass.add_observer(self)
+        klass.class_eval 'def after_find() end' unless klass.respond_to?(:after_find)
       end
   end
 end

data/lib/active_record/reflection.rb

@@ -21,33 +21,46 @@ module ActiveRecord
         reflection
       end
       
+      # Returns a hash containing all AssociationReflection objects for the current class
+      # Example:
+      #
+      #   Invoice.reflections
+      #   Account.reflections
+      #
       def reflections
-        read_inheritable_attribute(:reflections) or write_inheritable_attribute(:reflections, {})
+        read_inheritable_attribute(:reflections) || write_inheritable_attribute(:reflections, {})
       end
-      
+       
       # Returns an array of AggregateReflection objects for all the aggregations in the class.
       def reflect_on_all_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)
         reflections[aggregation].is_a?(AggregateReflection) ? reflections[aggregation] : nil
       end
 
       # 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
+      # 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)
         reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
       end
@@ -147,6 +160,7 @@ module ActiveRecord
       # 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
@@ -166,7 +180,7 @@ module ActiveRecord
       def check_validity!
         if options[:through]
           if through_reflection.nil?
-            raise HasManyThroughAssociationNotFoundError.new(self)
+            raise HasManyThroughAssociationNotFoundError.new(active_record.name, self)
           end
           
           if source_reflection.nil?
@@ -174,7 +188,7 @@ module ActiveRecord
           end
           
           if source_reflection.options[:polymorphic]
-            raise HasManyThroughAssociationPolymorphicError.new(class_name, self, source_reflection)
+            raise HasManyThroughAssociationPolymorphicError.new(active_record.name, self, source_reflection)
           end
           
           unless [:belongs_to, :has_many].include?(source_reflection.macro) && source_reflection.options[:through].nil?

data/lib/active_record/schema_dumper.rb

@@ -1,3 +1,6 @@
+require 'stringio'
+require 'bigdecimal'
+
 module ActiveRecord
   # This class is used to dump the database schema for some connection to some
   # output format (i.e., ActiveRecord::Schema).
@@ -82,13 +85,27 @@ HEADER
           tbl.print ", :force => true"
           tbl.puts " do |t|"
 
-          columns.each do |column|
+          column_specs = columns.map do |column|
             raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
             next if column.name == pk
-            tbl.print "    t.column #{column.name.inspect}, #{column.type.inspect}"
-            tbl.print ", :limit => #{column.limit.inspect}" if column.limit != @types[column.type][:limit] 
-            tbl.print ", :default => #{column.default.inspect}" if !column.default.nil?
-            tbl.print ", :null => false" if !column.null
+            spec = {}
+            spec[:name]    = column.name.inspect
+            spec[:type]    = column.type.inspect
+            spec[:limit]   = column.limit.inspect if column.limit != @types[column.type][:limit] && column.type != :decimal
+            spec[:precision] = column.precision.inspect if !column.precision.nil?
+            spec[:scale] = column.scale.inspect if !column.scale.nil?
+            spec[:null]    = 'false' if !column.null
+            spec[:default] = default_string(column.default) if !column.default.nil?
+            (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
+            spec
+          end.compact
+          keys = [:name, :type, :limit, :precision, :scale, :default, :null] & column_specs.map{ |spec| spec.keys }.inject([]){ |a,b| a | b }
+          lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
+          format_string = lengths.map{ |len| "%-#{len}s" }.join("")
+          column_specs.each do |colspec|
+            values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
+            tbl.print "    t.column "
+            tbl.print((format_string % values).gsub(/,\s*$/, ''))
             tbl.puts
           end
 
@@ -108,6 +125,17 @@ HEADER
         stream
       end
 
+      def default_string(value)
+        case value
+        when BigDecimal
+          value.to_s
+        when Date, DateTime, Time
+          "'" + value.to_s(:db) + "'"
+        else
+          value.inspect
+        end
+      end
+      
       def indexes(table, stream)
         indexes = @connection.indexes(table)
         indexes.each do |index|

data/lib/active_record/timestamp.rb

@@ -1,26 +1,35 @@
 module ActiveRecord
-  # Active Records will automatically record creation and/or update timestamps of database objects
-  # if fields of the names created_at/created_on or updated_at/updated_on are present. This module is
-  # automatically included, so you don't need to do that manually.
+  # Active Record automatically timestamps create and update if the table has fields
+  # created_at/created_on or updated_at/updated_on.
   #
-  # This behavior can be turned off by setting <tt>ActiveRecord::Base.record_timestamps = false</tt>.
-  # This behavior by default uses local time, but can use UTC by setting <tt>ActiveRecord::Base.default_timezone = :utc</tt>
+  # Timestamping can be turned off by setting
+  #   <tt>ActiveRecord::Base.record_timestamps = false</tt>
+  #
+  # Keep in mind that, via inheritance, you can turn off timestamps on a per
+  # model basis by setting <tt>record_timestamps</tt> to false in the desired
+  # models.
+  #
+  #   class Feed < ActiveRecord::Base
+  #     self.record_timestamps = false
+  #     # ...
+  #   end
+  #
+  # Timestamps are in the local timezone by default but can use UTC by setting
+  #   <tt>ActiveRecord::Base.default_timezone = :utc</tt>
   module Timestamp
-    def self.append_features(base) # :nodoc:
+    def self.included(base) #:nodoc:
       super
 
-      base.class_eval do
-        alias_method :create_without_timestamps, :create
-        alias_method :create, :create_with_timestamps
+      base.alias_method_chain :create, :timestamps
+      base.alias_method_chain :update, :timestamps
 
-        alias_method :update_without_timestamps, :update
-        alias_method :update, :update_with_timestamps
-      end
+      base.cattr_accessor :record_timestamps
+      base.record_timestamps = true
     end
 
     def create_with_timestamps #:nodoc:
       if record_timestamps
-      t = ( self.class.default_timezone == :utc ? Time.now.utc : Time.now )
+        t = self.class.default_timezone == :utc ? Time.now.utc : Time.now
         write_attribute('created_at', t) if respond_to?(:created_at) && created_at.nil?
         write_attribute('created_on', t) if respond_to?(:created_on) && created_on.nil?
 
@@ -32,31 +41,11 @@ module ActiveRecord
 
     def update_with_timestamps #:nodoc:
       if record_timestamps
-      t = ( self.class.default_timezone == :utc ? Time.now.utc : Time.now )
+        t = self.class.default_timezone == :utc ? Time.now.utc : Time.now
         write_attribute('updated_at', t) if respond_to?(:updated_at)
         write_attribute('updated_on', t) if respond_to?(:updated_on)
       end
       update_without_timestamps
     end
   end
-
-  class Base
-    # Records the creation date and possibly time in created_on (date only) or created_at (date and time) and the update date and possibly
-    # time in updated_on and updated_at. This only happens if the object responds to either of these messages, which they will do automatically
-    # if the table has columns of either of these names. This feature is turned on by default.
-    @@record_timestamps = true
-    cattr_accessor :record_timestamps
-
-    # deprecated: use ActiveRecord::Base.default_timezone instead.
-    @@timestamps_gmt = false
-    def self.timestamps_gmt=( gmt ) #:nodoc:
-      warn "timestamps_gmt= is deprecated. use default_timezone= instead"
-      self.default_timezone = ( gmt ? :utc : :local )
-    end
-
-    def self.timestamps_gmt #:nodoc:
-      warn "timestamps_gmt is deprecated. use default_timezone instead"
-      self.default_timezone == :utc
-    end
-  end
 end

data/lib/active_record/transactions.rb

@@ -4,21 +4,16 @@ require 'thread'
 
 module ActiveRecord
   module Transactions # :nodoc:
-    TRANSACTION_MUTEX = Mutex.new
-
     class TransactionError < ActiveRecordError # :nodoc:
     end
 
-    def self.append_features(base)
-      super
+    def self.included(base)
       base.extend(ClassMethods)
 
       base.class_eval do
-        alias_method :destroy_without_transactions, :destroy
-        alias_method :destroy, :destroy_with_transactions
-
-        alias_method :save_without_transactions, :save
-        alias_method :save, :save_with_transactions
+        [:destroy, :save, :save!].each do |method|
+          alias_method_chain method, :transactions
+        end
       end
     end
 
@@ -60,7 +55,7 @@ module ActiveRecord
     # will happen under the protected cover of a transaction. So you can use validations to check for values that the transaction
     # depend on or you can raise exceptions in the callbacks to rollback.
     #
-    # == Object-level transactions
+    # == Object-level transactions (deprecated)
     #
     # You can enable object-level transactions for Active Record objects, though. You do this by naming each of the Active Records
     # that you want to enable object-level transactions for, like this:
@@ -70,8 +65,14 @@ module ActiveRecord
     #     mary.deposit(100)
     #   end
     #
-    # If the transaction fails, David and Mary will be returned to their pre-transactional state. No money will have changed hands in
-    # neither object nor database.
+    # If the transaction fails, David and Mary will be returned to their
+    # pre-transactional state. No money will have changed hands in neither
+    # object nor database.
+    #
+    # However, useful state such as validation errors are also rolled back,
+    # limiting the usefulness of this feature. As such it is deprecated in
+    # Rails 1.2 and will be removed in the next release. Install the
+    # object_transactions plugin if you wish to continue using it.
     #
     # == Exception handling
     #
@@ -82,11 +83,14 @@ module ActiveRecord
     module ClassMethods
       def transaction(*objects, &block)
         previous_handler = trap('TERM') { raise TransactionError, "Transaction aborted" }
-        lock_mutex
-        
+        increment_open_transactions
+
         begin
-          objects.each { |o| o.extend(Transaction::Simple) }
-          objects.each { |o| o.start_transaction }
+          unless objects.empty?
+            ActiveSupport::Deprecation.warn "Object transactions are deprecated and will be removed from Rails 2.0.  See http://www.rubyonrails.org/deprecation for details.", caller
+            objects.each { |o| o.extend(Transaction::Simple) }
+            objects.each { |o| o.start_transaction }
+          end
 
           result = connection.transaction(Thread.current['start_db_transaction'], &block)
 
@@ -96,22 +100,21 @@ module ActiveRecord
           objects.each { |o| o.abort_transaction }
           raise
         ensure
-          unlock_mutex
+          decrement_open_transactions
           trap('TERM', previous_handler)
         end
       end
-      
-      def lock_mutex#:nodoc:
-        Thread.current['open_transactions'] ||= 0
-        TRANSACTION_MUTEX.lock if Thread.current['open_transactions'] == 0
-        Thread.current['start_db_transaction'] = (Thread.current['open_transactions'] == 0)
-        Thread.current['open_transactions'] += 1
-      end
-      
-      def unlock_mutex#:nodoc:
-        Thread.current['open_transactions'] -= 1
-        TRANSACTION_MUTEX.unlock if Thread.current['open_transactions'] == 0
-      end
+
+      private
+        def increment_open_transactions #:nodoc:
+          open = Thread.current['open_transactions'] ||= 0
+          Thread.current['start_db_transaction'] = open.zero?
+          Thread.current['open_transactions'] = open + 1
+        end
+
+        def decrement_open_transactions #:nodoc:
+          Thread.current['open_transactions'] -= 1
+        end
     end
 
     def transaction(*objects, &block)
@@ -121,9 +124,13 @@ module ActiveRecord
     def destroy_with_transactions #:nodoc:
       transaction { destroy_without_transactions }
     end
-    
+
     def save_with_transactions(perform_validation = true) #:nodoc:
       transaction { save_without_transactions(perform_validation) }
     end
+
+    def save_with_transactions! #:nodoc:
+      transaction { save_without_transactions! }
+    end
   end
 end