activerecord 1.15.6 → 2.0.0

data/lib/active_record/observer.rb

@@ -84,10 +84,11 @@ module ActiveRecord
   #
   # Observers will by default be mapped to the class with which they share a name. So CommentObserver will
   # be tied to observing Comment, ProductManagerObserver to ProductManager, and so on. If you want to name your observer
-  # differently than the class you're interested in observing, you can use the Observer.observe class method:
+  # differently than the class you're interested in observing, you can use the Observer.observe class method which takes
+  # either the concrete class (Product) or a symbol for that class (:product):
   #
   #   class AuditObserver < ActiveRecord::Observer
-  #     observe Account
+  #     observe :account
   #
   #     def after_update(account)
   #       AuditTrail.new(account, "UPDATED")
@@ -97,7 +98,7 @@ module ActiveRecord
   # If the audit observer needs to watch more than one kind of object, this can be specified with multiple arguments:
   #
   #   class AuditObserver < ActiveRecord::Observer
-  #     observe Account, Balance
+  #     observe :account, :balance
   #
   #     def after_update(record)
   #       AuditTrail.new(record, "UPDATED")
@@ -127,20 +128,22 @@ module ActiveRecord
   class Observer
     include Singleton
 
-    # Observer subclasses should be reloaded by the dispatcher in Rails
-    # when Dependencies.mechanism = :load.
-    include Reloadable::Deprecated
-
     class << self
       # Attaches the observer to the supplied model classes.
       def observe(*models)
+        models.flatten!
+        models.collect! { |model| model.is_a?(Symbol) ? model.to_s.camelize.constantize : model }
         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
+        if observed_class_name = name.scan(/(.*)Observer/)[0]
+          observed_class_name[0].constantize
+        else
+          nil
+        end
       end
     end
 
@@ -163,11 +166,11 @@ module ActiveRecord
 
     protected
       def observed_classes
-        Set.new([self.class.observed_class].flatten)
+        Set.new([self.class.observed_class].compact.flatten)
       end
 
       def observed_subclasses
-        observed_classes.sum(&:subclasses)
+        observed_classes.collect(&:subclasses).flatten
       end
 
       def add_observer!(klass)

data/lib/active_record/query_cache.rb

@@ -1,64 +1,23 @@
 module ActiveRecord
-  class QueryCache #:nodoc:
-    def initialize(connection)
-      @connection = connection
-      @query_cache = {}
-    end
-
-    def clear_query_cache
-      @query_cache = {}
-    end
-
-    def select_all(sql, name = nil)
-      (@query_cache[sql] ||= @connection.select_all(sql, name)).dup
-    end
-
-    def select_one(sql, name = nil)
-      @query_cache[sql] ||= @connection.select_one(sql, name)
-    end
-
-    def columns(table_name, name = nil)
-      @query_cache["SHOW FIELDS FROM #{table_name}"] ||= @connection.columns(table_name, name)
-    end
-
-    def insert(sql, name = nil, pk = nil, id_value = nil)
-      clear_query_cache
-      @connection.insert(sql, name, pk, id_value)
-    end
-
-    def update(sql, name = nil)
-      clear_query_cache
-      @connection.update(sql, name)
-    end
-
-    def delete(sql, name = nil)
-      clear_query_cache
-      @connection.delete(sql, name)
-    end
-    
-    private
-      def method_missing(method, *arguments, &proc)
-        @connection.send(method, *arguments, &proc)
+  module QueryCache
+    # Enable the query cache within the block if Active Record is configured.
+    def cache(&block)
+      if ActiveRecord::Base.configurations.blank?
+        yield
+      else
+        connection.cache(&block)
       end
-  end
-  
-  class Base
-    # Set the connection for the class with caching on
-    class << self
-      alias_method :connection_without_query_cache=, :connection=
+    rescue
+      yield # if the database is not present, don't let the cache spoil the party
+    end
 
-      def connection=(spec)
-        if spec.is_a?(ConnectionSpecification) and spec.config[:query_cache]
-          spec = QueryCache.new(self.send(spec.adapter_method, spec.config))
-        end
-        self.connection_without_query_cache = spec
+    # Disable the query cache within the block if Active Record is configured.
+    def uncached(&block)
+      if ActiveRecord::Base.configurations.blank?
+        yield
+      else
+        connection.uncached(&block)
       end
     end
   end
-  
-  class AbstractAdapter #:nodoc:
-    # Stub method to be able to treat the connection the same whether the query cache has been turned on or not
-    def clear_query_cache
-    end
-  end
 end

data/lib/active_record/reflection.rb

@@ -44,7 +44,7 @@ module ActiveRecord
         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
+      # Returns an array of AssociationReflection objects for all the associations 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:
       #
@@ -56,7 +56,7 @@ module ActiveRecord
         macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
       end
 
-      # Returns the AssociationReflection object for the named +aggregation+ (use the symbol). Example:
+      # Returns the AssociationReflection object for the named +association+ (use the symbol). Example:
       #
       #   Account.reflect_on_association(:owner) # returns the owner AssociationReflection
       #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
@@ -71,6 +71,7 @@ module ActiveRecord
     # those classes. Objects of AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
     class MacroReflection
       attr_reader :active_record
+
       def initialize(macro, name, options, active_record)
         @macro, @name, @options, @active_record = macro, name, options, active_record
       end
@@ -81,7 +82,7 @@ module ActiveRecord
         @name
       end
 
-      # Returns the name of the macro, so it would return :composed_of for
+      # Returns the type of the macro, so it would return :composed_of for
       # "composed_of :balance, :class_name => 'Money'" or :has_many for "has_many :clients".
       def macro
         @macro
@@ -93,30 +94,29 @@ module ActiveRecord
         @options
       end
 
-      # 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
-        
+      # Returns the class for the macro, so "composed_of :balance, :class_name => 'Money'" returns the Money class and
+      # "has_many :clients" returns the Client class.
+      def klass
+        @klass ||= class_name.constantize
+      end
+
       def class_name
-        @class_name ||= name_to_class_name(name.id2name)
+        @class_name ||= options[:class_name] || derive_class_name
       end
 
       def ==(other_aggregation)
         name == other_aggregation.name && other_aggregation.options && active_record == other_aggregation.active_record
       end
+
+      private
+        def derive_class_name
+          name.to_s.camelize
+        end
     end
 
 
     # Holds all the meta-data about an aggregation as it was specified in the Active Record class.
     class AggregateReflection < MacroReflection #:nodoc:
-      def klass
-        @klass ||= Object.const_get(options[:class_name] || class_name)
-      end
-
-      private
-        def name_to_class_name(name)
-          name.capitalize.gsub(/_(.)/) { |s| $1.capitalize }
-        end
     end
 
     # Holds all the meta-data about an association as it was specified in the Active Record class.
@@ -130,17 +130,9 @@ module ActiveRecord
       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
+        @primary_key_name ||= options[:foreign_key] || derive_primary_key_name
       end
-      
+
       def association_foreign_key
         @association_foreign_key ||= @options[:association_foreign_key] || class_name.foreign_key
       end
@@ -202,19 +194,24 @@ module ActiveRecord
       end
 
       private
-        def name_to_class_name(name)
-          if name =~ /::/
-            name
+        def derive_class_name
+          # get the class_name of the belongs_to association of the through reflection
+          if through_reflection
+            options[:source_type] || 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
+          end
+        end
+
+        def derive_primary_key_name
+          if macro == :belongs_to
+            "#{name}_id"
+          elsif options[:as]
+            "#{options[:as]}_id"
           else
-            if options[:class_name]
-              options[:class_name]
-            elsif through_reflection # get the class_name of the belongs_to association of the through reflection
-              options[:source_type] || 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
-            end
+            active_record.name.foreign_key
           end
         end
     end

data/lib/active_record/schema.rb

@@ -8,16 +8,16 @@ module ActiveRecord
   #
   #   ActiveRecord::Schema.define do
   #     create_table :authors do |t|
-  #       t.column :name, :string, :null => false
+  #       t.string :name, :null => false
   #     end
   #
   #     add_index :authors, :name, :unique
   #
   #     create_table :posts do |t|
-  #       t.column :author_id, :integer, :null => false
-  #       t.column :subject, :string
-  #       t.column :body, :text
-  #       t.column :private, :boolean, :default => false
+  #       t.integer :author_id, :null => false
+  #       t.string :subject
+  #       t.text :body
+  #       t.boolean :private, :default => false
   #     end
   #
   #     add_index :posts, :author_id

data/lib/active_record/schema_dumper.rb

@@ -37,9 +37,16 @@ module ActiveRecord
         define_params = @info ? ":version => #{@info['version']}" : ""
 
         stream.puts <<HEADER
-# This file is autogenerated. Instead of editing this file, please use the
-# migrations feature of ActiveRecord to incrementally modify your database, and
+# This file is auto-generated from the current state of the database. Instead of editing this file, 
+# please use the migrations feature of ActiveRecord to incrementally modify your database, and
 # then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your database schema. If you need
+# to create the application database on another system, you should be using db:schema:load, not running
+# all the migrations from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended to check this file into your version control system.
 
 ActiveRecord::Schema.define(#{define_params}) do
 
@@ -54,8 +61,8 @@ HEADER
         @connection.tables.sort.each do |tbl|
           next if ["schema_info", ignore_tables].flatten.any? do |ignored|
             case ignored
-            when String: tbl == ignored
-            when Regexp: tbl =~ ignored
+            when String; tbl == ignored
+            when Regexp; tbl =~ ignored
             else
               raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
             end
@@ -89,22 +96,37 @@ HEADER
             raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
             next if column.name == pk
             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[:name]      = column.name.inspect
+            spec[:type]      = column.type.to_s
+            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[: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 }
+
+          # find all migration keys used in this table
+          keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map(&:keys).flatten
+
+          # figure out the lengths for each column based on above keys
           lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
-          format_string = lengths.map{ |len| "%-#{len}s" }.join("")
+
+          # the string we're going to sprintf our values against, with standardized column widths
+          format_string = lengths.map{ |len| "%-#{len}s" }
+
+          # find the max length for the 'type' column, which is special
+          type_length = column_specs.map{ |column| column[:type].length }.max
+
+          # add column type definition to our format string
+          format_string.unshift "    t.%-#{type_length}s "
+
+          format_string *= ''
+
           column_specs.each do |colspec|
             values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
-            tbl.print "    t.column "
+            values.unshift colspec[:type]
             tbl.print((format_string % values).gsub(/,\s*$/, ''))
             tbl.puts
           end

data/lib/active_record/serialization.rb

@@ -0,0 +1,98 @@
+module ActiveRecord #:nodoc:
+  module Serialization
+    class Serializer #:nodoc:
+      attr_reader :options
+
+      def initialize(record, options = {})
+        @record, @options = record, options.dup
+      end
+
+      # To replicate the behavior in ActiveRecord#attributes,
+      # :except takes precedence over :only.  If :only is not set
+      # for a N level model but is set for the N+1 level models,
+      # then because :except is set to a default value, the second
+      # level model can have both :except and :only set.  So if
+      # :only is set, always delete :except.
+      def serializable_attribute_names
+        attribute_names = @record.attribute_names
+
+        if options[:only]
+          options.delete(:except)
+          attribute_names = attribute_names & Array(options[:only]).collect { |n| n.to_s }
+        else
+          options[:except] = Array(options[:except]) | Array(@record.class.inheritance_column)
+          attribute_names = attribute_names - options[:except].collect { |n| n.to_s }
+        end
+
+        attribute_names
+      end
+
+      def serializable_method_names
+        Array(options[:methods]).inject([]) do |method_attributes, name|
+          method_attributes << name if @record.respond_to?(name.to_s)
+          method_attributes
+        end
+      end
+
+      def serializable_names
+        serializable_attribute_names + serializable_method_names
+      end
+
+      # Add associations specified via the :includes option.
+      # Expects a block that takes as arguments:
+      #   +association+ - name of the association
+      #   +records+     - the association record(s) to be serialized
+      #   +opts+        - options for the association records
+      def add_includes(&block)
+        if include_associations = options.delete(:include)
+          base_only_or_except = { :except => options[:except],
+                                  :only => options[:only] }
+
+          include_has_options = include_associations.is_a?(Hash)
+          associations = include_has_options ? include_associations.keys : Array(include_associations)
+
+          for association in associations
+            records = case @record.class.reflect_on_association(association).macro
+            when :has_many, :has_and_belongs_to_many
+              @record.send(association).to_a
+            when :has_one, :belongs_to
+              @record.send(association)
+            end
+
+            unless records.nil?
+              association_options = include_has_options ? include_associations[association] : base_only_or_except
+              opts = options.merge(association_options)
+              yield(association, records, opts)
+            end
+          end
+
+          options[:include] = include_associations
+        end
+      end
+
+      def serializable_record
+        returning(serializable_record = {}) do
+          serializable_names.each { |name| serializable_record[name] = @record.send(name) }
+          add_includes do |association, records, opts|
+            if records.is_a?(Enumerable)
+              serializable_record[association] = records.collect { |r| self.class.new(r, opts).serializable_record }
+            else
+              serializable_record[association] = self.class.new(records, opts).serializable_record
+            end
+          end
+        end
+      end
+
+      def serialize
+        # overwrite to implement
+      end
+
+      def to_s(&block)
+        serialize(&block)
+      end
+    end
+  end
+end
+
+require 'active_record/serializers/xml_serializer'
+require 'active_record/serializers/json_serializer'