r2979@asus: jeremy | 2005-07-10 01:51:00 -0700

 Split association reflection test into has_many and has_one tests.  TODO: extend to belongs_to and habtm as well.  Kill trailing whitespace.
 r2980@asus:  jeremy | 2005-07-10 01:53:41 -0700
 Test that eager load of firm.account (a has_one) returns the correct account.  This doesn't cover the regression in Ticket #1688, however.  Need a case where class name is not provided and the singular name is over-singularized by active_record.class_name.  Kill trailing whitespace.
 r2981@asus:  jeremy | 2005-07-10 01:56:44 -0700
 Fix class name resolution in AssociationReflection#name_to_class_name.  Use the equivalent of the idiomatic ||= (read or write if nil) for the class_inheritable_attribute reflection arrays.  Kill trailing whitespace.
 r2982@asus:  jeremy | 2005-07-10 01:59:08 -0700
 Remove superfluous assignment in compute_type.  In an inject, the return value is used for the next injection, so assigning to the injected value is unnecessary.


git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@1790 5ecf4fe2-1ee6-0310-87b1-e25e094e27de

2 files changed, 33 insertions, 31 deletions

diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb
index 3b5f9b94db..6ff0e4a9e0 100755
--- a/activerecord/lib/active_record/base.rb
+++ b/activerecord/lib/active_record/base.rb
@@ -836,7 +836,7 @@ module ActiveRecord #:nodoc:
         # MyApp::Business::Account would be appear as MyApp::Business::AccountSubclass.
         def compute_type(type_name)
           type_name_with_module(type_name).split("::").inject(Object) do |final_type, part|
-            final_type = final_type.const_get(part)
+            final_type.const_get(part)
           end
         end
 
diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
index 6b718704d2..9aec0ca34b 100644
--- a/activerecord/lib/active_record/reflection.rb
+++ b/activerecord/lib/active_record/reflection.rb
@@ -10,13 +10,13 @@ module ActiveRecord
 
           def composed_of_with_reflection(part_id, options = {})
             composed_of_without_reflection(part_id, options)
-            write_inheritable_array "aggregations", [ AggregateReflection.new(:composed_of, part_id, options, self) ]
+            reflect_on_all_aggregations << AggregateReflection.new(:composed_of, part_id, options, self)
           end
 
-          alias_method :composed_of, :composed_of_with_reflection          
+          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
@@ -24,16 +24,16 @@ module ActiveRecord
 
             def #{association_type}_with_reflection(association_id, options = {})
               #{association_type}_without_reflection(association_id, options)
-              write_inheritable_array "associations", [ AssociationReflection.new(:#{association_type}, association_id, options, self) ]
+              reflect_on_all_associations << AssociationReflection.new(:#{association_type}, association_id, options, self)
             end
 
-            alias_method :#{association_type}, :#{association_type}_with_reflection          
+            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. 
+    # Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations.
     # This information can for example be used in a form builder that took an Active Record object and created input
     # fields for all of the attributes depending on their type and displayed the associations to other objects.
     #
@@ -41,9 +41,9 @@ module ActiveRecord
     module ClassMethods
       # Returns an array of AggregateReflection objects for all the aggregations in the class.
       def reflect_on_all_aggregations
-        read_inheritable_attribute "aggregations"
+        read_inheritable_attribute(:aggregations) or write_inheritable_attribute(:aggregations, [])
       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)
@@ -52,47 +52,47 @@ module ActiveRecord
 
       # Returns an array of AssociationReflection objects for all the aggregations in the class.
       def reflect_on_all_associations
-        read_inheritable_attribute "associations"
+        read_inheritable_attribute(:associations) or write_inheritable_attribute(:associations, [])
       end
-      
+
       # Returns the AssociationReflection object for the named +aggregation+ (use the symbol). Example:
       #   Account.reflect_on_association(:owner) # returns the owner AssociationReflection
       def reflect_on_association(association)
-        reflect_on_all_associations.find { |reflection| reflection.name == association } unless reflect_on_all_associations.nil?
+        reflect_on_all_associations.find { |reflection| reflection.name == association }
       end
     end
-    
 
-    # Abstract base class for AggregateReflection and AssociationReflection that describes the interface available for both of 
+
+    # Abstract base class for AggregateReflection and AssociationReflection that describes the interface available for both of
     # 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
-      
+
       # Returns the name of the macro, so it would return :balance for "composed_of :balance, :class_name => 'Money'" or
       # :clients for "has_many :clients".
       def name
         @name
       end
-      
-      # Returns the name of the macro, so it would return :composed_of for 
+
+      # Returns the name 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
       end
-      
-      # Returns the hash of options used for the macro, so it would return { :class_name => "Money" } for 
+
+      # Returns the hash of options used for the macro, so it would return { :class_name => "Money" } for
       # "composed_of :balance, :class_name => 'Money'" or {} for "has_many :clients".
       def options
         @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
-      
+
       def ==(other_aggregation)
         name == other_aggregation.name && other_aggregation.options && active_record == other_aggregation.active_record
       end
@@ -102,9 +102,9 @@ 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)) 
+        Object.const_get(options[:class_name] || name_to_class_name(name.id2name))
       end
-      
+
       private
         def name_to_class_name(name)
           name.capitalize.gsub(/_(.)/) { |s| $1.capitalize }
@@ -116,21 +116,23 @@ module ActiveRecord
       def klass
         @klass ||= active_record.send(:compute_type, (name_to_class_name(name.id2name)))
       end
-      
+
       def table_name
         @table_name ||= klass.table_name
       end
 
       private
         def name_to_class_name(name)
-          if name !~ /::/
-            class_name = active_record.send(
-              :type_name_with_module, 
-              (options[:class_name] || active_record.class_name(active_record.table_name_prefix + name + active_record.table_name_suffix))
-            )
+          if name =~ /::/
+            name
+          else
+            unless class_name = options[:class_name]
+              class_name = name.to_s.camelize
+              class_name = class_name.singularize if [:has_many, :has_and_belongs_to_many].include?(macro)
+            end
+            active_record.send(:type_name_with_module, class_name)
           end
-          return class_name || name
         end
     end
   end
-end
\ No newline at end of file
+end