has_many_polymorphs 2.9 → 2.10

data/CHANGELOG

@@ -1,4 +1,6 @@
 
+v2.10. Add :parent_conditions option; bugfix for nullified conditions; bugfix for self-referential tagging generator; allow setting of has_many_polymorphs_options hash in Configuration's after_initialize if you need to adjust the autoload behavior; clear error message on missing or improperly namespaced models; fix .build on double-sided relationships; add :namespace key for easier set up of Camping apps or other unusual class structures.
+
 v2.9. Gem version renumbering; my apologies if this messes anyone up.
 
 v2.8. RDoc documentation; repository relocation; Rakefile cleanup; remove deprecated plugin-specific class caching.

data/Manifest

@@ -0,0 +1,57 @@
+TODO
+test/unit/polymorph_test.rb
+test/test_helper.rb
+test/schema.rb
+test/modules/other_extension_module.rb
+test/modules/extension_module.rb
+test/models/wild_boar.rb
+test/models/tabby.rb
+test/models/petfood.rb
+test/models/person.rb
+test/models/parentship.rb
+test/models/kitten.rb
+test/models/frog.rb
+test/models/eaters_foodstuff.rb
+test/models/dog.rb
+test/models/cat.rb
+test/models/canine.rb
+test/models/beautiful_fight_relationship.rb
+test/models/aquatic/whale.rb
+test/models/aquatic/pupils_whale.rb
+test/models/aquatic/fish.rb
+test/fixtures/wild_boars.yml
+test/fixtures/petfoods.yml
+test/fixtures/people.yml
+test/fixtures/keep_your_enemies_close.yml
+test/fixtures/frogs.yml
+test/fixtures/eaters_foodstuffs.yml
+test/fixtures/cats.yml
+test/fixtures/bow_wows.yml
+test/fixtures/aquatic/whales.yml
+test/fixtures/aquatic/little_whale_pupils.yml
+test/fixtures/aquatic/fish.yml
+README
+Manifest
+LICENSE
+lib/has_many_polymorphs.rb
+lib/has_many_polymorphs/support_methods.rb
+lib/has_many_polymorphs/reflection.rb
+lib/has_many_polymorphs/rake_task_redefine_task.rb
+lib/has_many_polymorphs/dependencies.rb
+lib/has_many_polymorphs/debugging_tools.rb
+lib/has_many_polymorphs/configuration.rb
+lib/has_many_polymorphs/class_methods.rb
+lib/has_many_polymorphs/base.rb
+lib/has_many_polymorphs/autoload.rb
+lib/has_many_polymorphs/association.rb
+init.rb
+generators/tagging/templates/tags.yml
+generators/tagging/templates/taggings.yml
+generators/tagging/templates/tagging_test.rb
+generators/tagging/templates/tagging_extensions.rb
+generators/tagging/templates/tagging.rb
+generators/tagging/templates/tag_test.rb
+generators/tagging/templates/tag.rb
+generators/tagging/templates/migration.rb
+generators/tagging/tagging_generator.rb
+CHANGELOG

data/README

@@ -7,6 +7,8 @@ An ActiveRecord plugin for self-referential and double-sided polymorphic associa
 
 Copyright 2007 Cloudburst, LLC. Licensed under the AFL 3. See the included LICENSE file. 
 
+The public certificate for this gem is at http://rubyforge.org/frs/download.php/25331/evan_weaver-original-public_cert.pem.
+
 == Description
 
 This plugin lets you define self-referential and double-sided polymorphic associations in your models. It is an extension of <tt>has_many :through</tt>.
@@ -26,7 +28,7 @@ The plugin also includes a generator for a tagging system, a common use case (se
 
 == Requirements
 
-* Rails 1.2.3 or grguest
+* Rails 1.2.3 or greater
 
 = Usage
 
@@ -153,7 +155,20 @@ If you are having trouble, think very carefully about how your model classes, ke
 
 Note that because of the way Rails reloads model classes, the plugin can sometimes bog down your development server. Set <tt>config.cache_classes = true</tt> in <tt>config/environments/development.rb</tt> to avoid this. 
 
-== Further resources
+== Reporting problems
 
-* http://blog.evanweaver.com/pages/code#polymorphs
 * http://rubyforge.org/forum/forum.php?forum_id=16450
+
+Patches and contributions are very welcome. Please note that contributors are required to assign copyright for their additions to Cloudburst, LLC.
+
+== Further resources
+
+* http://blog.evanweaver.com/articles/2007/08/15/polymorphs-tutorial
+* http://blog.evanweaver.com/articles/2007/02/22/polymorphs-25-total-insanity-branch
+* http://blog.evanweaver.com/articles/2007/02/09/how-to-find-the-most-popular-tags
+* http://blog.evanweaver.com/articles/2007/01/13/growing-up-your-acts_as_taggable
+* http://blog.evanweaver.com/articles/2006/12/02/polymorphs-19
+* http://blog.evanweaver.com/articles/2006/11/05/directed-double-polymorphic-associations
+* http://blog.evanweaver.com/articles/2006/11/04/namespaced-model-support-in-has_many_polymorphs
+* http://blog.evanweaver.com/articles/2006/09/26/sti-support-in-has_many_polymorphs
+* http://blog.evanweaver.com/articles/2006/09/11/make-polymorphic-children-belong-to-only-one-parent

data/TODO

@@ -1,3 +1,4 @@
 
+* Migration examples in docs
 * Controller for tagging generator
 * Tag cloud method

data/generators/tagging/tagging_generator.rb

@@ -23,7 +23,9 @@ class TaggingGenerator < Rails::Generator::NamedBase
   def verify models
     puts "** Warning: only one taggable model specified; tests may not run properly." if models.size < 2
     models.each do |model|
-      self.class.const_get(model[1..-1].classify) rescue puts "** Error: model #{model[1..-1].classify} could not be loaded." or exit
+      model = model[1..-1].classify
+      next if model == "Tag" # don't load ourselves when --self-referential is used
+      self.class.const_get(model) rescue puts "** Error: model #{model[1..-1].classify} could not be loaded." or exit
     end
   end
   
@@ -81,4 +83,13 @@ class TaggingGenerator < Rails::Generator::NamedBase
       opt.on("--self-referential",
              "Allow tags to tag themselves.") { |v| options[:self_referential] = v }
     end
+    
+    # Useful for generating tests/fixtures
+    def model_one
+      taggable_models[0][1..-1].classify
+    end
+    
+    def model_two
+      taggable_models[1][1..-1].classify rescue model_one
+    end
 end

data/generators/tagging/templates/tag_test.rb

@@ -1,10 +1,10 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class TagTest < Test::Unit::TestCase
-  fixtures :tags, :taggings, :recipes, :posts
+  fixtures :tags, :taggings, <%= taggable_models[0..1].join(", ") -%>
 
   def test_to_s
-    assert_equal "delicious sexy", Recipe.find(2).tags.to_s
+    assert_equal "delicious sexy", <%= model_two -%>.find(2).tags.to_s
   end
   
 end

data/generators/tagging/templates/tagging_test.rb

@@ -1,12 +1,14 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class TaggingTest < Test::Unit::TestCase
-  fixtures :taggings, :tags, :posts, :recipes
+  fixtures :taggings, :tags, <%= taggable_models[0..1].join(", ") -%>
 
   def setup
-    @obj1 = Recipe.find(1)
-    @obj2 = Recipe.find(2)
-    @obj3 = Post.find(1)
+    @obj1 = <%= model_two %>.find(1)
+    @obj2 = <%= model_two %>.find(2)
+<% if taggable_models.size > 1 -%>
+    @obj3 = <%= model_one -%>.find(1)
+<% end -%>
     @tag1 = Tag.find(1)  
     @tag2 = Tag.find(2)  
     @tagging1 = Tagging.find(1)
@@ -49,7 +51,9 @@ class TaggingTest < Test::Unit::TestCase
       @tagging1.send(:taggable?, true) 
     end
     assert !@tagging1.send(:taggable?)
+<% if taggable_models.size > 1 -%>
     assert @obj3.send(:taggable?)
+<% end -%>
 <% if options[:self_referential] -%>  
     assert @tag1.send(:taggable?)
 <% end -%>    

data/generators/tagging/templates/taggings.yml

@@ -1,13 +1,15 @@
 --- 
+<% if taggable_models.size > 1 -%>
 taggings_003: 
   <%= parent_association_name -%>_id: "2"
   id: "3"
-  taggable_type: <%= model_one = taggable_models[0][1..-1].classify %>
-  taggable_id: "1"
+  taggable_type: <%= model_one %>
+  taggable_id: "1"                
+<% end -%>
 taggings_004: 
   <%= parent_association_name -%>_id: "2"
   id: "4"
-  taggable_type: <%= model_two = (taggable_models[1][1..-1].classify rescue model_one) %>
+  taggable_type: <%= model_two %>
   taggable_id: "2"
 taggings_001: 
   <%= parent_association_name -%>_id: "1"

data/has_many_polymorphs.gemspec

@@ -1,11 +1,11 @@
 
-# Gem::Specification for Has_many_polymorphs-2.9
+# Gem::Specification for Has_many_polymorphs-2.10
 # Originally generated by Echoe
 
 Gem::Specification.new do |s|
   s.name = %q{has_many_polymorphs}
-  s.version = "2.9"
-  s.date = %q{2007-08-13}
+  s.version = "2.10"
+  s.date = %q{2007-09-16}
   s.summary = %q{An ActiveRecord plugin for self-referential and double-sided polymorphic associations.}
   s.email = %q{}
   s.homepage = %q{http://blog.evanweaver.com/pages/code#polymorphs}
@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   s.description = %q{An ActiveRecord plugin for self-referential and double-sided polymorphic associations.}
   s.has_rdoc = true
   s.authors = [""]
-  s.files = ["test/unit/polymorph_test.rb", "test/test_helper.rb", "test/schema.rb", "test/modules/other_extension_module.rb", "test/modules/extension_module.rb", "test/models/wild_boar.rb", "test/models/tabby.rb", "test/models/petfood.rb", "test/models/kitten.rb", "test/models/frog.rb", "test/models/eaters_foodstuff.rb", "test/models/dog.rb", "test/models/cat.rb", "test/models/canine.rb", "test/models/beautiful_fight_relationship.rb", "test/models/aquatic/whale.rb", "test/models/aquatic/pupils_whale.rb", "test/models/aquatic/fish.rb", "test/fixtures/wild_boars.yml", "test/fixtures/petfoods.yml", "test/fixtures/keep_your_enemies_close.yml", "test/fixtures/frogs.yml", "test/fixtures/eaters_foodstuffs.yml", "test/fixtures/cats.yml", "test/fixtures/bow_wows.yml", "test/fixtures/aquatic/whales.yml", "test/fixtures/aquatic/little_whale_pupils.yml", "test/fixtures/aquatic/fish.yml", "lib/has_many_polymorphs.rb", "lib/has_many_polymorphs/support_methods.rb", "lib/has_many_polymorphs/reflection.rb", "lib/has_many_polymorphs/rake_task_redefine_task.rb", "lib/has_many_polymorphs/dependencies.rb", "lib/has_many_polymorphs/debugging_tools.rb", "lib/has_many_polymorphs/class_methods.rb", "lib/has_many_polymorphs/base.rb", "lib/has_many_polymorphs/autoload.rb", "lib/has_many_polymorphs/association.rb", "init.rb", "generators/tagging/templates/tags.yml", "generators/tagging/templates/taggings.yml", "generators/tagging/templates/tagging_test.rb", "generators/tagging/templates/tagging_extensions.rb", "generators/tagging/templates/tagging.rb", "generators/tagging/templates/tag_test.rb", "generators/tagging/templates/tag.rb", "generators/tagging/templates/migration.rb", "generators/tagging/tagging_generator.rb", "TODO", "README", "LICENSE", "CHANGELOG", "has_many_polymorphs.gemspec"]
+  s.files = ["TODO", "test/unit/polymorph_test.rb", "test/test_helper.rb", "test/schema.rb", "test/modules/other_extension_module.rb", "test/modules/extension_module.rb", "test/models/wild_boar.rb", "test/models/tabby.rb", "test/models/petfood.rb", "test/models/person.rb", "test/models/parentship.rb", "test/models/kitten.rb", "test/models/frog.rb", "test/models/eaters_foodstuff.rb", "test/models/dog.rb", "test/models/cat.rb", "test/models/canine.rb", "test/models/beautiful_fight_relationship.rb", "test/models/aquatic/whale.rb", "test/models/aquatic/pupils_whale.rb", "test/models/aquatic/fish.rb", "test/fixtures/wild_boars.yml", "test/fixtures/petfoods.yml", "test/fixtures/people.yml", "test/fixtures/keep_your_enemies_close.yml", "test/fixtures/frogs.yml", "test/fixtures/eaters_foodstuffs.yml", "test/fixtures/cats.yml", "test/fixtures/bow_wows.yml", "test/fixtures/aquatic/whales.yml", "test/fixtures/aquatic/little_whale_pupils.yml", "test/fixtures/aquatic/fish.yml", "README", "Manifest", "LICENSE", "lib/has_many_polymorphs.rb", "lib/has_many_polymorphs/support_methods.rb", "lib/has_many_polymorphs/reflection.rb", "lib/has_many_polymorphs/rake_task_redefine_task.rb", "lib/has_many_polymorphs/dependencies.rb", "lib/has_many_polymorphs/debugging_tools.rb", "lib/has_many_polymorphs/configuration.rb", "lib/has_many_polymorphs/class_methods.rb", "lib/has_many_polymorphs/base.rb", "lib/has_many_polymorphs/autoload.rb", "lib/has_many_polymorphs/association.rb", "init.rb", "generators/tagging/templates/tags.yml", "generators/tagging/templates/taggings.yml", "generators/tagging/templates/tagging_test.rb", "generators/tagging/templates/tagging_extensions.rb", "generators/tagging/templates/tagging.rb", "generators/tagging/templates/tag_test.rb", "generators/tagging/templates/tag.rb", "generators/tagging/templates/migration.rb", "generators/tagging/tagging_generator.rb", "CHANGELOG", "has_many_polymorphs.gemspec"]
   s.test_files = ["test/test_helper.rb"]
   s.add_dependency(%q<activerecord>, ["> 0.0.0"])
 end
@@ -31,9 +31,10 @@ end
 #   p.project = "fauna"
 #   p.summary = "An ActiveRecord plugin for self-referential and double-sided polymorphic associations."
 #   p.url = "http://blog.evanweaver.com/pages/code#polymorphs"  
-#   p.docs_host = "blog.evanweaver.com:~/www/snax/public/files/doc/"  
+#   p.docs_host = "blog.evanweaver.com:~/www/bax/public/files/doc/"  
 #   p.dependencies = ["activerecord"]
-#   p.rdoc_pattern = /polymorphs\/association|polymorphs\/class_methods|polymorphs\/reflection|README|CHANGELOG|TODO|LICENSE|templates\/migration\.rb|templates\/tag\.rb|templates\/tagging\.rb|templates\/tagging_extensions\.rb/    
+#   p.rdoc_pattern = /polymorphs\/association|polymorphs\/class_methods|polymorphs\/reflection|polymorphs\/autoload|polymorphs\/configuration|README|CHANGELOG|TODO|LICENSE|templates\/migration\.rb|templates\/tag\.rb|templates\/tagging\.rb|templates\/tagging_extensions\.rb/    
+#   p.require_signed = true
 # end
 # 
 # desc 'Run the test suite.'

data/lib/has_many_polymorphs/association.rb

@@ -153,7 +153,7 @@ module ActiveRecord #:nodoc:
         raise PolymorphicMethodNotSupportedError, "You can't associate new records."
       end      
 
-    end
-    
+    end   
+        
   end
 end

data/lib/has_many_polymorphs/autoload.rb

@@ -1,33 +1,62 @@
 
 require 'initializer'
 
-class Rails::Initializer
+class Rails::Initializer #:nodoc:
 
-=begin rdoc
+=begin rdoc    
 Searches for models that use <tt>has_many_polymorphs</tt> or <tt>acts_as_double_polymorphic_join</tt> and makes sure that they get loaded during app initialization. This ensures that helper methods are injected into the target classes. 
 
-Overrides Rails::Initializer#after_initialize.
+Note that you can override DEFAULT_OPTIONS via Rails::Configuration#has_many_polymorphs_options. For example, if you need an application extension to be required before has_many_polymorphs loads your models, add an <tt>after_initialize</tt> block in <tt>config/environment.rb</tt> that appends to the <tt>'requirements'</tt> key:
+  Rails::Initializer.run do |config|     
+    # your other configuration here
+    
+    config.after_initialize do
+      config.has_many_polymorphs_options['requirements'] << '/lib/my_extension'
+    end    
+  end
+  
 =end
 
-  def after_initialize_with_autoload
-    after_initialize_without_autoload
-  
-    _logger_debug "has_many_polymorphs: autoload hook invoked"
-    Dir["#{RAILS_ROOT}/app/models/**/*.rb"].each do |filename|
-      next if filename =~ /svn|CVS|bzr/
-      open filename do |file|
-        if file.grep(/has_many_polymorphs|acts_as_double_polymorphic_join/).any?
-          begin
-            model = File.basename(filename)[0..-4].classify
-            _logger_warn "has_many_polymorphs: preloading parent model #{model}"
-            model.constantize
-          rescue Object => e
-            _logger_warn "has_many_polymorphs: WARNING; possibly critical error preloading #{model}: #{e.inspect}"
+  module HasManyPolymorphsAutoload
+        
+    DEFAULT_OPTIONS = {
+      :file_pattern => "#{RAILS_ROOT}/app/models/**/*.rb",
+      :file_exclusions => ['svn', 'CVS', 'bzr'],
+      :methods => ['has_many_polymorphs', 'acts_as_double_polymorphic_join'],
+      :requirements => []}
+    
+    mattr_accessor :options
+    @@options = HashWithIndifferentAccess.new(DEFAULT_OPTIONS)      
+
+    # Override for Rails::Initializer#after_initialize.
+    def after_initialize_with_autoload
+      after_initialize_without_autoload
+
+      _logger_debug "has_many_polymorphs: autoload hook invoked"
+      
+      HasManyPolymorphsAutoload.options[:requirements].each do |requirement|
+        require requirement
+      end
+    
+      Dir[HasManyPolymorphsAutoload.options[:file_pattern]].each do |filename|
+        next if filename =~ /#{HasManyPolymorphsAutoload.options[:file_exclusions].join("|")}/
+        open filename do |file|
+          if file.grep(/#{HasManyPolymorphsAutoload.options[:methods].join("|")}/).any?
+            begin
+              model = File.basename(filename)[0..-4].camelize
+              _logger_warn "has_many_polymorphs: preloading parent model #{model}"
+              model.constantize
+            rescue Object => e
+              _logger_warn "has_many_polymorphs: WARNING; possibly critical error preloading #{model}: #{e.inspect}"
+            end
           end
         end
       end
-    end
-  end  
+    end  
+    
+  end
   
+  include HasManyPolymorphsAutoload
+    
   alias_method_chain :after_initialize, :autoload
 end

data/lib/has_many_polymorphs/base.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     class << self
     
       # Interprets a polymorphic row from a unified SELECT, returning the appropriate ActiveRecord instance. Overrides ActiveRecord::Base.instantiate_without_callbacks.
-      def instantiate_without_callbacks_with_polymorphic_checks(record)
+      def instantiate_with_polymorphic_checks(record)
         if record['polymorphic_parent_class']
           reflection = record['polymorphic_parent_class'].constantize.reflect_on_association(record['polymorphic_association_id'].to_sym)
 #          _logger_debug "Instantiating a polymorphic row for #{record['polymorphic_parent_class']}.reflect_on_association(:#{record['polymorphic_association_id']})"
@@ -37,13 +37,23 @@ module ActiveRecord
           # allocate and assign values
           returning(klass.allocate) do |obj|
             obj.instance_variable_set("@attributes", record)
+            obj.instance_variable_set("@attributes_cache", Hash.new)
+            
+            if obj.respond_to_without_attributes?(:after_find)
+              obj.send(:callback, :after_find)
+            end
+            
+            if obj.respond_to_without_attributes?(:after_initialize)
+              obj.send(:callback, :after_initialize)
+            end
+            
           end
         else                       
-          instantiate_without_callbacks_without_polymorphic_checks(record)
+          instantiate_without_polymorphic_checks(record)
         end
       end
       
-      alias_method_chain :instantiate_without_callbacks, :polymorphic_checks 
+      alias_method_chain :instantiate, :polymorphic_checks 
     end
     
   end

data/lib/has_many_polymorphs/class_methods.rb

@@ -12,14 +12,17 @@ STI association targets must enumerated and named. For example, if Dog and Cat b
 
 Namespaced models follow the Rails <tt>underscore</tt> convention. ZooAnimal::Lion becomes <tt>:'zoo_animal/lion'</tt>.
 
-You do not need to set up any other associations other than for either the regular method or the double. The join associations and all individual and reverse associations are generated for you. However, a join class and table is required. There are tentative reports that it works without it if you make the parent class join to the targets <tt>:through</tt> itself, but this is untested.
+You do not need to set up any other associations other than for either the regular method or the double. The join associations and all individual and reverse associations are generated for you. However, a join model and table are required. 
+
+There is a tentative report that you can make the parent model be its own join model, but this is untested.
 
 =end
 
    module PolymorphicClassMethods
    
-     RESERVED_KEYS = [:conditions, :order, :limit, :offset, :extend, :skip_duplicates, 
-                                   :join_extend, :dependent, :rename_individual_collections] #:nodoc:
+     RESERVED_DOUBLES_KEYS = [:conditions, :order, :limit, :offset, :extend, :skip_duplicates, 
+                                   :join_extend, :dependent, :rename_individual_collections,
+                                   :namespace] #:nodoc:
  
 =begin rdoc
 
@@ -52,41 +55,22 @@ These options are passed through to targets on both sides of the association. If
 <tt>:order</tt>:: A string for the SQL <tt>ORDER BY</tt> clause.
 <tt>:limit</tt>:: An integer. Affects the polymorphic and individual associations.
 <tt>:offset</tt>:: An integer. Only affects the polymorphic association.
-  
+<tt>:namespace</tt>:: A symbol. Prepended to all the models in the <tt>:from</tt> and <tt>:through</tt> keys. This is especially useful for Camping, which namespaces models by default.
+
 =end
 
-      def acts_as_double_polymorphic_join options={}, &extension     
+      def acts_as_double_polymorphic_join options={}, &extension      
         
-        collections = options._select {|k,v| v.is_a? Array and k.to_s !~ /(#{RESERVED_KEYS.map(&:to_s).join('|')})$/}      
-        raise PolymorphicError, "Couldn't understand options in acts_as_double_polymorphic_join. Valid parameters are your two class collections, and then #{RESERVED_KEYS.inspect[1..-2]}, with optionally your collection names prepended and joined with an underscore." unless collections.size == 2
+        collections, options = extract_double_collections(options)
         
-        options = options._select {|k,v| !collections[k]}
-        options[:extend] = (options[:extend] ? Array(options[:extend]) + [extension] : extension) if extension # inline the block
-          
-        collection_option_keys = Hash[*collections.keys.map do |key|
-          [key, RESERVED_KEYS.map{|option| "#{key}_#{option}".to_sym}] 
-        end._flatten_once]    
-      
-        collections.keys.each do |collection|      
-          options.each do |key, value|
-            next if collection_option_keys.values.flatten.include? key
-            # shift the general options to the individual sides
-            collection_value = options[collection_key = "#{collection}_#{key}".to_sym]
-            case key
-              when :conditions
-                collection_value, value = sanitize_sql(collection_value), sanitize_sql(value)
-                options[collection_key] = (collection_value ? "(#{collection_value}) AND (#{value})" : value)
-              when :order
-                options[collection_key] = (collection_value ? "#{collection_value}, #{value}" : value)
-              when :extend, :join_extend
-                options[collection_key] = Array(collection_value) + Array(value)
-              when :limit, :offset, :dependent, :rename_individual_collections
-                options[collection_key] ||= value
-              else
-                raise PolymorphicError, "Unknown option key #{key.inspect}."
-            end     
-          end
-        end
+        # handle the block
+        options[:extend] = (if options[:extend]
+          Array(options[:extend]) + [extension]
+        else 
+          extension
+        end) if extension 
+        
+        collection_option_keys = make_general_option_keys_specific!(options, collections)
   
         join_name = self.name.tableize.to_sym
         collections.each do |association_id, children|
@@ -97,7 +81,7 @@ These options are passed through to targets on both sides of the association. If
           rescue NoMethodError
             raise PolymorphicError, "Couldn't find 'belongs_to' association for :#{parent_hash_key._singularize} in #{self.name}." unless parent_foreign_key
           end
-  
+
           parents = collections[parent_hash_key]
           conflicts = (children & parents) # set intersection          
           parents.each do |plural_parent_name| 
@@ -105,19 +89,31 @@ These options are passed through to targets on both sides of the association. If
             parent_class = plural_parent_name._as_class
             singular_reverse_association_id = parent_hash_key._singularize 
               
-            parent_class.send(:has_many_polymorphs, 
-              association_id, {:is_double => true,
-                                  :from => children, 
-                                  :as => singular_reverse_association_id,
-                                  :through => join_name.to_sym, 
-                                  :foreign_key => parent_foreign_key, 
-                                  :foreign_type_key => parent_foreign_key.to_s.sub(/_id$/, '_type'),
-                                  :singular_reverse_association_id => singular_reverse_association_id,
-                                  :conflicts => conflicts}.merge(Hash[*options._select do |key, value|
-                                    collection_option_keys[association_id].include? key and !value.nil?
-                                  end.map do |key, value|
-                                    [key.to_s[association_id.to_s.length+1..-1].to_sym, value]
-                                  end._flatten_once])) # rename side-specific options to general names
+            internal_options = {
+              :is_double => true,
+              :from => children, 
+              :as => singular_reverse_association_id,
+              :through => join_name.to_sym, 
+              :foreign_key => parent_foreign_key, 
+              :foreign_type_key => parent_foreign_key.to_s.sub(/_id$/, '_type'),
+              :singular_reverse_association_id => singular_reverse_association_id,
+              :conflicts => conflicts
+            }
+            
+            general_options = Hash[*options._select do |key, value|
+              collection_option_keys[association_id].include? key and !value.nil?
+            end.map do |key, value|
+              [key.to_s[association_id.to_s.length+1..-1].to_sym, value]
+            end._flatten_once] # rename side-specific options to general names
+            
+            general_options.each do |key, value|
+              # avoid clobbering keys that appear in both option sets
+              if internal_options[key]
+                general_options[key] = Array(value) + Array(internal_options[key])
+              end
+            end
+
+            parent_class.send(:has_many_polymorphs, association_id, internal_options.merge(general_options))
   
             if conflicts.include? plural_parent_name 
               # unify the alternate sides of the conflicting children
@@ -128,7 +124,7 @@ These options are passed through to targets on both sides of the association. If
                       self.send("#{association_id._singularize}_#{method_name}")).freeze
                   end
                 end     
-              end
+              end            
               
               # unify the join model... join model is always renamed for doubles, unlike child associations
               unless parent_class.instance_methods.include?(join_name)
@@ -146,6 +142,54 @@ These options are passed through to targets on both sides of the association. If
           end
         end
       end
+      
+      private
+      
+      def extract_double_collections(options)
+        collections = options._select do |key, value| 
+          value.is_a? Array and key.to_s !~ /(#{RESERVED_DOUBLES_KEYS.map(&:to_s).join('|')})$/
+        end
+        
+        raise PolymorphicError, "Couldn't understand options in acts_as_double_polymorphic_join. Valid parameters are your two class collections, and then #{RESERVED_DOUBLES_KEYS.inspect[1..-2]}, with optionally your collection names prepended and joined with an underscore." unless collections.size == 2
+        
+        options = options._select do |key, value| 
+          !collections[key]
+        end
+        
+        [collections, options]
+      end
+      
+      def make_general_option_keys_specific!(options, collections)
+        collection_option_keys = Hash[*collections.keys.map do |key|
+          [key, RESERVED_DOUBLES_KEYS.map{|option| "#{key}_#{option}".to_sym}] 
+        end._flatten_once]    
+      
+        collections.keys.each do |collection|      
+          options.each do |key, value|
+            next if collection_option_keys.values.flatten.include? key
+            # shift the general options to the individual sides
+            collection_key = "#{collection}_#{key}".to_sym
+            collection_value = options[collection_key]
+            case key
+              when :conditions
+                collection_value, value = sanitize_sql(collection_value), sanitize_sql(value)
+                options[collection_key] = (collection_value ? "(#{collection_value}) AND (#{value})" : value)
+              when :order
+                options[collection_key] = (collection_value ? "#{collection_value}, #{value}" : value)
+              when :extend, :join_extend
+                options[collection_key] = Array(collection_value) + Array(value)
+              else
+                options[collection_key] ||= value
+            end     
+          end
+        end
+        
+        collection_option_keys
+      end
+      
+      
+      
+      public
 
 =begin rdoc
 
@@ -157,32 +201,41 @@ This method createds a single-sided polymorphic relationship.
 
 The only required parameter, aside from the association name, is <tt>:from</tt>. 
 
-The method generates a number of associations aside from the polymorphic one. In this example Petfood also gets <tt>dogs</tt>, <tt>cats</tt>, and <tt>birds</tt>, and Dog, Cat, and Bird get <tt>petfoods</tt>. (The reverse association to the parent is always plural.)
+The method generates a number of associations aside from the polymorphic one. In this example Petfood also gets <tt>dogs</tt>, <tt>cats</tt>, and <tt>birds</tt>, and Dog, Cat, and Bird get <tt>petfoods</tt>. (The reverse association to the parents is always plural.)
 
 == Available options
 
-<tt>:from</tt>:: An array of symbols representing the target classes. Required.
+<tt>:from</tt>:: An array of symbols representing the target models. Required.
 <tt>:as</tt>:: A symbol for the parent's interface in the join--what the parent 'acts as'.
 <tt>:through</tt>:: A symbol representing the class of the join model. Follows Rails defaults if not supplied (the parent and the association names, alphabetized, concatenated with an underscore, and singularized).
 <tt>:foreign_key</tt>:: The column name for the parent's id in the join. 
-<tt>:foreign_type_key</tt>:: The column name for the parent's class in the join, if the parent itself is polymorphic. Rarely needed.
+<tt>:foreign_type_key</tt>:: The column name for the parent's class name in the join, if the parent itself is polymorphic. Rarely needed.
 <tt>:polymorphic_key</tt>:: The column name for the child's id in the join.
-<tt>:polymorphic_type_key</tt>:: The column name for the child's class in the join.
+<tt>:polymorphic_type_key</tt>:: The column name for the child's class name in the join.
 <tt>:dependent</tt>:: Accepts <tt>:destroy</tt>, <tt>:nullify</tt>, <tt>:delete_all</tt>. Controls how the join record gets treated on any associate delete (whether from the polymorph or from an individual collection); defaults to <tt>:destroy</tt>.
 <tt>:skip_duplicates</tt>:: If <tt>true</tt>, will check to avoid pushing already associated records (but also triggering a database load). Defaults to <tt>true</tt>.
 <tt>:rename_individual_collections</tt>:: If <tt>true</tt>, all individual collections are prepended with the polymorph name, and the children's parent collection is appended with "_of_#{association_name}"</tt>. For example, <tt>zoos</tt> becomes <tt>zoos_of_animals</tt>. This is to help avoid method name collisions in crowded classes.
 <tt>:extend</tt>:: One or an array of mixed modules and procs, which are applied to the polymorphic association (usually to define custom methods).
 <tt>:join_extend</tt>:: One or an array of mixed modules and procs, which are applied to the join association.
-<tt>:parent_extend</tt>:: One or an array of mixed modules and procs, which are applied to the target classes' association to the parent.
+<tt>:parent_extend</tt>:: One or an array of mixed modules and procs, which are applied to the target models' association to the parents.
 <tt>:conditions</tt>:: An array or string of conditions for the SQL <tt>WHERE</tt> clause. 
+<tt>:parent_conditions</tt>:: An array or string of conditions which are applied to the target models' association to the parents.
 <tt>:order</tt>:: A string for the SQL <tt>ORDER BY</tt> clause.
+<tt>:parent_order</tt>:: A string for the SQL <tt>ORDER BY</tt> which is applied to the target models' association to the parents.
 <tt>:group</tt>:: An array or string of conditions for the SQL <tt>GROUP BY</tt> clause. Affects the polymorphic and individual associations.
 <tt>:limit</tt>:: An integer. Affects the polymorphic and individual associations.
 <tt>:offset</tt>:: An integer. Only affects the polymorphic association.
+<tt>:namespace</tt>:: A symbol. Prepended to all the models in the <tt>:from</tt> and <tt>:through</tt> keys. This is especially useful for Camping, which namespaces models by default.
 <tt>:uniq</tt>:: If <tt>true</tt>, the records returned are passed through a pure-Ruby <tt>uniq</tt> before they are returned. Rarely needed.
 
 If you pass a block, it gets converted to a Proc and added to <tt>:extend</tt>. 
 
+== On condition nullification
+
+When you request an individual association, non-applicable but fully-qualified fields in the polymorphic association's <tt>:conditions</tt>, <tt>:order</tt>, and <tt>:group</tt> options get changed to <tt>NULL</tt>. For example, if you set <tt>:conditions => "dogs.name != 'Spot'"</tt>, when you request <tt>.cats</tt>, the conditions string is changed to <tt>NULL != 'Spot'</tt>. 
+
+Be aware, however, that <tt>NULL != 'Spot'</tt> returns <tt>false</tt> due to SQL's 3-value logic. Instead, you need to use the <tt>:conditions</tt> string <tt>"dogs.name IS NULL OR dogs.name != 'Spot'"</tt> to get the behavior you probably expect for negative matches.
+
 =end
 
       def has_many_polymorphs (association_id, options = {}, &extension)
@@ -219,6 +272,8 @@ If you pass a block, it gets converted to a Proc and added to <tt>:extend</tt>.
           :select, # applies to the polymorphic relationship
           :conditions, # applies to the polymorphic relationship, the children, and the join
   #        :include,
+          :parent_conditions,
+          :parent_order,
           :order, # applies to the polymorphic relationship, the children, and the join
           :group, # only applies to the polymorphic relationship and the children
           :limit, # only applies to the polymorphic relationship and the children
@@ -228,6 +283,7 @@ If you pass a block, it gets converted to a Proc and added to <tt>:extend</tt>.
           :parent_limit,
           :parent_offset,
   #        :source,
+          :namespace,
           :uniq, # XXX untested, only applies to the polymorphic relationship
   #        :finder_sql,
   #        :counter_sql,
@@ -242,13 +298,13 @@ If you pass a block, it gets converted to a Proc and added to <tt>:extend</tt>.
         raise PolymorphicError, ":from option must be an array" unless options[:from].is_a? Array            
         options[:from].each{|plural| verify_pluralization_of(plural)}
   
-        options[:as] ||= self.name.demodulize.downcase.to_sym
+        options[:as] ||= self.name.demodulize.underscore.to_sym
         options[:conflicts] = Array(options[:conflicts])      
         options[:foreign_key] ||= "#{options[:as]}_id"
         
         options[:association_foreign_key] = 
           options[:polymorphic_key] ||= "#{association_id._singularize}_id"
-        options[:polymorphic_type_key] ||= "#{association_id._singularize}_type"      
+        options[:polymorphic_type_key] ||= "#{association_id._singularize}_type"
         
         if options.has_key? :ignore_duplicates
           _logger_warn "DEPRECATION WARNING: please use :skip_duplicates instead of :ignore_duplicates"
@@ -258,9 +314,20 @@ If you pass a block, it gets converted to a Proc and added to <tt>:extend</tt>.
         options[:dependent] = :destroy unless options.has_key? :dependent
         options[:conditions] = sanitize_sql(options[:conditions])
         
-  #      options[:finder_sql] ||= "(options[:polymorphic_key]
-  
-        options[:through] ||= build_join_table_symbol((options[:as]._pluralize or self.table_name), association_id)
+        # options[:finder_sql] ||= "(options[:polymorphic_key]
+        
+        options[:through] ||= build_join_table_symbol(association_id, (options[:as]._pluralize or self.table_name))
+        
+        # set up namespaces if we have a namespace key
+        # XXX needs test coverage
+        if options[:namespace]
+          namespace = options[:namespace].to_s.chomp("/") + "/"
+          options[:from].map! do |child|
+            "#{namespace}#{child}".to_sym
+          end
+          options[:through] = "#{namespace}#{options[:through]}".to_sym
+        end
+        
         options[:join_class_name] ||= options[:through]._classify      
         options[:table_aliases] ||= build_table_aliases([options[:through]] + options[:from])
         options[:select] ||= build_select(association_id, options[:table_aliases]) 
@@ -274,7 +341,7 @@ If you pass a block, it gets converted to a Proc and added to <tt>:extend</tt>.
         
         # create the reflection object      
         returning(create_reflection(:has_many_polymorphs, association_id, options, self)) do |reflection|
-          if defined? Dependencies and RAILS_ENV == "development"                    
+          if defined? Dependencies and defined? RAILS_ENV and RAILS_ENV == "development"                    
             inject_dependencies(association_id, reflection) if Dependencies.mechanism == :load
           end
           
@@ -294,7 +361,11 @@ If you pass a block, it gets converted to a Proc and added to <tt>:extend</tt>.
         # for the targets
         returning({}) do |aliases|
           from.map(&:to_s).sort.map(&:to_sym).each_with_index do |plural, t_index|
-            table = plural._as_class.table_name
+            begin
+              table = plural._as_class.table_name
+            rescue NameError => e
+              raise PolymorphicError, "Could not find a valid class for #{plural.inspect}. If it's namespaced, be sure to specify it as :\"module/#{plural}\" instead."
+            end
             plural._as_class.columns.map(&:name).each_with_index do |field, f_index|
               aliases["#{table}.#{field}"] = "t#{t_index}_r#{f_index}"
             end
@@ -324,29 +395,32 @@ If you pass a block, it gets converted to a Proc and added to <tt>:extend</tt>.
    
       def create_join_association(association_id, reflection)
   
-        options = {:foreign_key => reflection.options[:foreign_key], 
+        options = {
+          :foreign_key => reflection.options[:foreign_key], 
           :dependent => reflection.options[:dependent], 
           :class_name => reflection.klass.name, 
-          :extend => reflection.options[:join_extend],
-  #        :limit => reflection.options[:limit],
-  #        :offset => reflection.options[:offset],
-          :order => devolve(association_id, reflection, reflection.options[:order], reflection.klass),
-          :conditions => devolve(association_id, reflection, reflection.options[:conditions], reflection.klass)
-          }        
+          :extend => reflection.options[:join_extend]
+          # :limit => reflection.options[:limit],
+          # :offset => reflection.options[:offset],
+          # :order => devolve(association_id, reflection, reflection.options[:order], reflection.klass, true),
+          # :conditions => devolve(association_id, reflection, reflection.options[:conditions], reflection.klass, true)
+          }
           
         if reflection.options[:foreign_type_key]         
           type_check = "#{reflection.options[:foreign_type_key]} = #{quote_value(self.base_class.name)}"
           conjunction = options[:conditions] ? " AND " : nil
           options[:conditions] = "#{options[:conditions]}#{conjunction}#{type_check}"
+          options[:as] = reflection.options[:as]
         end
-  
-        has_many(reflection.options[:through], options)      
+        
+        has_many(reflection.options[:through], options)
+        
         inject_before_save_into_join_table(association_id, reflection)          
       end
       
       def inject_before_save_into_join_table(association_id, reflection)
         sti_hook = "sti_class_rewrite"
-        rewrite_procedure = %[self.send(:#{association_id._singularize}_type=, self.#{association_id._singularize}_type.constantize.base_class.name)]
+        rewrite_procedure = %[self.send(:#{reflection.options[:polymorphic_type_key]}=, self.#{reflection.options[:polymorphic_type_key]}.constantize.base_class.name)]
         
         # XXX should be abstracted?
         reflection.klass.class_eval %[          
@@ -387,27 +461,34 @@ If you pass a block, it gets converted to a Proc and added to <tt>:extend</tt>.
               through = "#{reflection.options[:through]}#{'_as_child' if parent == self}".to_sym
               has_many(through,
                 :as => association_id._singularize, 
+#                :source => association_id._singularize, 
+#                :source_type => reflection.options[:polymorphic_type_key], 
                 :class_name => reflection.klass.name,
                 :dependent => reflection.options[:dependent], 
                 :extend => reflection.options[:join_extend],
   #              :limit => reflection.options[:limit],
   #              :offset => reflection.options[:offset],
-                :order => devolve(association_id, reflection, reflection.options[:order], reflection.klass),
-                :conditions => devolve(association_id, reflection, reflection.options[:conditions], reflection.klass)
+                :order => devolve(association_id, reflection, reflection.options[:parent_order], reflection.klass),
+                :conditions => devolve(association_id, reflection, reflection.options[:parent_conditions], reflection.klass)
                 )
   
-              # the association to the collection parents
+              # the association to the target's parents
               association = "#{reflection.options[:as]._pluralize}#{"_of_#{association_id}" if reflection.options[:rename_individual_collections]}".to_sym                        
               has_many(association, 
                 :through => through, 
                 :class_name => parent.name,
                 :source => reflection.options[:as], 
-                :foreign_key => reflection.options[:foreign_key] ,
+                :foreign_key => reflection.options[:foreign_key],
                 :extend => reflection.options[:parent_extend],
+                :conditions => reflection.options[:parent_conditions],
                 :order => reflection.options[:parent_order],
                 :offset => reflection.options[:parent_offset],
                 :limit => reflection.options[:parent_limit],
                 :group => reflection.options[:parent_group])
+                
+#                debugger if association == :parents
+#                
+#                nil
                       
             end                    
           end
@@ -452,8 +533,8 @@ If you pass a block, it gets converted to a Proc and added to <tt>:extend</tt>.
         end
       end
   
-      # some support methods    
-      
+      # some support methods
+            
       def child_pluralization_map(association_id, reflection)
         Hash[*reflection.options[:from].map do |plural|
           [plural,  plural._singularize]
@@ -470,8 +551,8 @@ If you pass a block, it gets converted to a Proc and added to <tt>:extend</tt>.
         s.to_s.gsub('/', '_').to_sym
       end
               
-      def build_join_table_symbol(a, b)
-        [a.to_s, b.to_s].sort.join("_").to_sym
+      def build_join_table_symbol(association_id, name)
+        [name.to_s, association_id.to_s].sort.join("_").to_sym
       end
       
       def all_classes_for(association_id, reflection)
@@ -480,18 +561,25 @@ If you pass a block, it gets converted to a Proc and added to <tt>:extend</tt>.
         klasses.uniq
       end
       
-      def devolve(association_id, reflection, string, klass)
+      def devolve(association_id, reflection, string, klass, remove_inappropriate_clauses = false) 
+        # XXX remove_inappropriate_clauses is not implemented; we'll wait until someone actually needs it
         return unless string
-        (all_classes_for(association_id, reflection) - # the join class must always be preserved
-          [klass, klass.base_class, reflection.klass, reflection.klass.base_class]).map do |klass|
+        string = string.dup
+        # _logger_debug "has_many_polymorphs: devolving #{string} for #{klass}"
+        inappropriate_classes = (all_classes_for(association_id, reflection) - # the join class must always be preserved
+          [klass, klass.base_class, reflection.klass, reflection.klass.base_class])
+        inappropriate_classes.map do |klass|
           klass.columns.map do |column| 
             [klass.table_name, column.name]
           end.map do |table, column|
             ["#{table}.#{column}", "`#{table}`.#{column}", "#{table}.`#{column}`", "`#{table}`.`#{column}`"]
           end
         end.flatten.sort_by(&:size).reverse.each do |quoted_reference|        
+          # _logger_debug "devolved #{quoted_reference} to NULL"
+          # XXX clause removal would go here 
           string.gsub!(quoted_reference, "NULL")
         end
+        # _logger_debug "has_many_polymorphs: altered to #{string}"
         string
       end
       

data/lib/has_many_polymorphs/configuration.rb

@@ -0,0 +1,17 @@
+
+=begin rdoc
+Access the <tt>has_many_polymorphs_options</tt> hash in your Rails::Initializer.run#after_initialize block if you need to modify the behavior of Rails::Initializer::HasManyPolymorphsAutoload.
+=end
+
+class Rails::Configuration
+
+  def has_many_polymorphs_options
+    Rails::Initializer::HasManyPolymorphsAutoload.options
+  end
+  
+  def has_many_polymorphs_options=(hash)
+    Rails::Initializer::HasManyPolymorphsAutoload.options = hash
+  end
+  
+end
+

data/lib/has_many_polymorphs.rb

@@ -1,6 +1,8 @@
 
 require 'active_record'
 
+RAILS_DEFAULT_LOGGER = nil unless defined? RAILS_DEFAULT_LOGGER
+
 require 'has_many_polymorphs/reflection'
 require 'has_many_polymorphs/association'
 require 'has_many_polymorphs/class_methods'
@@ -19,6 +21,7 @@ end
 
 if defined? Rails and RAILS_ENV and RAILS_ROOT
   _logger_warn "has_many_polymorphs: Rails environment detected"
+  require 'has_many_polymorphs/configuration'
   require 'has_many_polymorphs/dependencies'
   require 'has_many_polymorphs/autoload'
 end

data/test/fixtures/people.yml

@@ -0,0 +1,7 @@
+bob:
+  id: 1
+  name: Bob 
+  age: 45
+  created_at: "2007-04-01 12:00:00"
+  updated_at: "2007-04-04 10:00:00"
+  

data/test/models/parentship.rb

@@ -0,0 +1,4 @@
+class Parentship < ActiveRecord::Base     
+  belongs_to :parent, :class_name => "Person", :foreign_key => "parent_id"
+  belongs_to :kid, :polymorphic => true, :foreign_type => "child_type"
+end

data/test/models/person.rb

@@ -0,0 +1,9 @@
+require 'parentship'
+class Person < ActiveRecord::Base                   
+  has_many_polymorphs :kids,
+                      :through => :parentships, 
+                      :from => [:people], 
+                      :as => :parent,
+                      :polymorphic_type_key => "child_type",
+                      :conditions => "people.age < 10"   
+end                                               

data/test/models/petfood.rb

@@ -23,7 +23,8 @@ class Petfood < ActiveRecord::Base
     :ignore_duplicates => false,
     :conditions => "NULL IS NULL",
     :order => "eaters_foodstuffs.updated_at ASC",
-    :parent_order => "the_petfood_primary_key DESC",
+    :parent_order => "petfoods.the_petfood_primary_key DESC",
+    :parent_conditions => "petfoods.name IS NULL OR petfoods.name != 'Snausages'",
     :extend => [ExtensionModule, OtherExtensionModule, proc {}],
     :join_extend => proc { 
       def a_method

data/test/schema.rb

@@ -67,6 +67,21 @@ ActiveRecord::Schema.define(:version => 0) do
     t.column :protector_type, :string
     t.column :created_at, :datetime, :null => false
     t.column :updated_at, :datetime, :null => false
+  end  
+  
+  create_table :parentships, :force => true do |t|
+    t.column :parent_id, :integer
+    t.column :child_type, :string
+    t.column :kid_id, :integer 
+    t.column :created_at, :datetime, :null => false
+    t.column :updated_at, :datetime, :null => false
+  end                    
+  
+  create_table :people, :force => true do |t|
+    t.column :name, :string
+    t.column :age, :integer
+    t.column :created_at, :datetime, :null => false
+    t.column :updated_at, :datetime, :null => false
   end
 
 end

data/test/unit/polymorph_test.rb

@@ -4,7 +4,7 @@ class PolymorphTest < Test::Unit::TestCase
   
   fixtures :cats, :bow_wows, :frogs, :wild_boars, :eaters_foodstuffs, :petfoods,
               :"aquatic/fish", :"aquatic/whales", :"aquatic/little_whale_pupils",
-              :keep_your_enemies_close
+              :keep_your_enemies_close, :people
   require 'beautiful_fight_relationship'  
         
   def setup
@@ -24,6 +24,9 @@ class PolymorphTest < Test::Unit::TestCase
    @join_count = EatersFoodstuff.count    
    @l = @kibbles.eaters.size
    @m = @bits.eaters.size
+
+   @double_join_count = BeautifulFightRelationship.count
+   @n = @alice.enemies.size
   end
   
   def d
@@ -40,14 +43,24 @@ class PolymorphTest < Test::Unit::TestCase
     Tabby.reflect_on_all_associations.map &:check_validity! 
     Kitten.reflect_on_all_associations.map &:check_validity! 
     Dog.reflect_on_all_associations.map &:check_validity! 
+    Canine.reflect_on_all_associations.map &:check_validity! 
     Aquatic::Fish.reflect_on_all_associations.map &:check_validity! 
     EatersFoodstuff.reflect_on_all_associations.map &:check_validity! 
     WildBoar.reflect_on_all_associations.map &:check_validity! 
     Frog.reflect_on_all_associations.map &:check_validity! 
-    Aquatic::Whale.reflect_on_all_associations.map &:check_validity! 
     Cat.reflect_on_all_associations.map &:check_validity! 
-    Aquatic::PupilsWhale.reflect_on_all_associations.map &:check_validity! 
+    Right.reflect_on_all_associations.map &:check_validity! 
+    Left.reflect_on_all_associations.map &:check_validity! 
+    DoubleJoin.reflect_on_all_associations.map &:check_validity! 
     BeautifulFightRelationship.reflect_on_all_associations.map &:check_validity! 
+    Person.reflect_on_all_associations.map &:check_validity! 
+    Parentship.reflect_on_all_associations.map &:check_validity! 
+    Aquatic::Whale.reflect_on_all_associations.map &:check_validity! 
+    Aquatic::PupilsWhale.reflect_on_all_associations.map &:check_validity! 
+    Tagging.reflect_on_all_associations.map &:check_validity! 
+    Recipe.reflect_on_all_associations.map &:check_validity! 
+    Category.reflect_on_all_associations.map &:check_validity! 
+    Tag.reflect_on_all_associations.map &:check_validity! 
   end
   
   def test_assignment     
@@ -90,12 +103,11 @@ class PolymorphTest < Test::Unit::TestCase
  
   def test_add_join_record
     assert_equal Kitten, @chloe.class
-    assert @join_record = EatersFoodstuff.new(:foodstuff_id => @bits.id, :eater_id => @chloe.id, :eater_type => @chloe.class.name ) 
-    assert @join_record.save!
-    assert @join_record.id
+    assert join = EatersFoodstuff.new(:foodstuff_id => @bits.id, :eater_id => @chloe.id, :eater_type => @chloe.class.name ) 
+    assert join.save!
+    assert join.id
     assert_equal @join_count + 1, EatersFoodstuff.count
 
-    # not reloaded
     #assert_equal @m, @bits.eaters.size # Doesn't behave this way on latest edge anymore
     assert_equal @m + 1, @bits.eaters.count # SQL
 
@@ -104,6 +116,18 @@ class PolymorphTest < Test::Unit::TestCase
     assert @bits.eaters.include?(@chloe)
   end
 
+  def test_build_join_record_on_association
+    assert_equal Kitten, @chloe.class
+    assert join = @chloe.eaters_foodstuffs.build(:foodstuff => @bits)
+    # assert_equal join.eater_type, @chloe.class.name # will be STI parent type
+    assert join.save!
+    assert join.id
+    assert_equal @join_count + 1, EatersFoodstuff.count
+
+    assert @bits.eaters.reload
+    assert @bits.eaters.include?(@chloe)
+  end
+
 #  not supporting this, since has_many :through doesn't support it either  
 #  def test_add_unsaved   
 #    # add an unsaved item
@@ -258,8 +282,9 @@ class PolymorphTest < Test::Unit::TestCase
   end
 
   def test_attributes_come_through_when_child_has_underscore_in_table_name
-    @join_record = EatersFoodstuff.new(:foodstuff_id => @bits.id, :eater_id =>  @puma.id, :eater_type => @puma.class.name) 
-    @join_record.save!
+    join = EatersFoodstuff.new(:foodstuff_id => @bits.id, :eater_id =>  @puma.id, :eater_type => @puma.class.name) 
+    join.save!
+    
     @bits.eaters.reload
 
     assert_equal "Puma", @puma.name
@@ -349,6 +374,20 @@ class PolymorphTest < Test::Unit::TestCase
     assert_equal 3, @alice.beautiful_fight_relationships.size
   end
   
+  def test_double_collection_build_join_record_on_association
+    
+    join = @alice.beautiful_fight_relationships_as_protector.build(:enemy => @spot)
+    
+    assert_equal @alice.class.base_class.name, join.protector_type
+    assert_nothing_raised { join.save! }
+
+    assert join.id
+    assert_equal @double_join_count + 1, BeautifulFightRelationship.count
+
+    assert @alice.enemies.reload
+    assert @alice.enemies.include?(@spot)
+  end
+  
   def test_double_dependency_injection
 #    breakpoint
   end
@@ -521,9 +560,16 @@ class PolymorphTest < Test::Unit::TestCase
       end" }
     assert_raises(@association_error) {
       eval "class SomeModel < ActiveRecord::Base
-       acts_as_double_polymorphic_join :polymorph => [:dogs, :cats], :unimorphs => [:dogs, :cats]
+        acts_as_double_polymorphic_join :polymorph => [:dogs, :cats], :unimorphs => [:dogs, :cats]
       end" }    
   end
+  
+  def test_error_message_on_namespaced_targets
+    assert_raises(@association_error) {
+      eval "class SomeModel < ActiveRecord::Base
+        has_many_polymorphs :polymorphs, :from => [:fish]
+      end" }
+  end
 
   def test_single_custom_finders
     [@kibbles, @alice, @puma, @spot, @bits].each {|record| @kibbles.eaters << record; sleep 1} # XXX yeah i know
@@ -588,12 +634,38 @@ class PolymorphTest < Test::Unit::TestCase
     assert_equal EatersFoodstuff.name, Petfood.reflect_on_association(:eaters).class_name
   end
   
-  def test_parent_order_orders_parents
+  def test_parent_order
     @alice.foodstuffs_of_eaters << Petfood.find(:all, :order => "the_petfood_primary_key ASC")
     @alice.reload #not necessary
     assert_equal [2,1], @alice.foodstuffs_of_eaters.map(&:id)  
   end
 
+  def test_parent_conditions
+    @kibbles.eaters << @alice
+    assert_equal [@alice], @kibbles.eaters
+
+    @snausages = Petfood.create(:name => 'Snausages')
+    @snausages.eaters << @alice    
+    assert_equal [@alice], @snausages.eaters
+    
+    assert_equal [@kibbles], @alice.foodstuffs_of_eaters
+  end        
+  
+  def test_self_referential_hmp_with_conditions
+    p = Person.find(:first)
+    kid = Person.create(:name => "Tim", :age => 3)
+    p.kids << kid
+
+    kid.reload; p.reload
+
+  # assert_equal [p], kid.parents 
+  # assert Rails.has_one? Bug
+  # non-standard foreign_type key is not set properly when you are the polymorphic interface of a has_many going to a :through
+
+    assert_equal [kid], p.kids
+    assert_equal [kid], p.people
+  end
+
 #  def test_polymorphic_include
 #    @kibbles.eaters << [@kibbles, @alice, @puma, @spot, @bits]
 #    assert @kibbles.eaters.include?(@kibbles.eaters_foodstuffs.find(:all, :include => :eater).first.eater)

data.tar.gz.sig

@@ -0,0 +1,3 @@
+ک�E;ˇ^;��G��N�nh�Qy�<)��Dhk
+�P�"�%��qI5��i�[�8�c�VNӬ�kz�F��($<hC�-v�;�����s4ɲ�m �\J:�ս���ʖ���'��jb
+�J����ޠ+��u$=��-KQ�5��/?_������0_x~�3mDo�D���?���h����m���oϤ����x�1��U�����i�9�\&9��Wd
�r���Sؖ��> �Au�/j{���P�R��qf��

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: has_many_polymorphs
 version: !ruby/object:Gem::Version 
-  version: "2.9"
-date: 2007-08-13 00:00:00 -04:00
+  version: "2.10"
+date: 2007-09-16 00:00:00 -04:00
 summary: An ActiveRecord plugin for self-referential and double-sided polymorphic associations.
 require_paths: 
 - lib
@@ -25,10 +25,33 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDLjCCAhagAwIBAgIBADANBgkqhkiG9w0BAQUFADA9MQ0wCwYDVQQDDARldmFu
+  MRgwFgYKCZImiZPyLGQBGRYIY2xvdWRidXIxEjAQBgoJkiaJk/IsZAEZFgJzdDAe
+  Fw0wNzA5MTYxMDMzMDBaFw0wODA5MTUxMDMzMDBaMD0xDTALBgNVBAMMBGV2YW4x
+  GDAWBgoJkiaJk/IsZAEZFghjbG91ZGJ1cjESMBAGCgmSJomT8ixkARkWAnN0MIIB
+  IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA5C0Io89nyApnr+PvbNFge9Vs
+  yRWAlGBUEMahpXp28VrrfXZT0rAW7JBo4PlCE3jl4nE4dzE6gAdItSycjTosrw7A
+  Ir5+xoyl4Vb35adv56TIQQXvNz+BzlqnkAY5JN0CSBRTQb6mxS3hFyD/h4qgDosj
+  R2RFVzHqSxCS8xq4Ny8uzOwOi+Xyu4w67fI5JvnPvMxqrlR1eaIQHmxnf76RzC46
+  QO5QhufjAYGGXd960XzbQsQyTDUYJzrvT7AdOfiyZzKQykKt8dEpDn+QPjFTnGnT
+  QmgJBX5WJN0lHF2l1sbv3gh4Kn1tZu+kTUqeXY6ShAoDTyvZRiFqQdwh8w2lTQID
+  AQABozkwNzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQU+WqJz3xQ
+  XSea1hRvvHWcIMgeeC4wDQYJKoZIhvcNAQEFBQADggEBAGLZ75jfOEW8Nsl26CTt
+  JFrWxQTcQT/UljeefVE3xYr7lc9oQjbqO3FOyued3qW7TaNEtZfSHoYeUSMYbpw1
+  XAwocIPuSRFDGM4B+hgQGVDx8PMGiJKom4qLXjO40UZsR7QyN/u869Vj45LURm6h
+  MBcPeqCASI+WNprj9+uZa2kmHiitrFqqfMBNlm5IFbn9XeYSta9AHVvs5QQqV2m5
+  hIPfLqCyxsn/YgOGvo6iwyQTWyTswamaAC3HRWZxIS1sfn/Ssqa7E7oQMkv5FAXr
+  x5rKePfXINf8XTJczkl9OBEYdE9aNdJsJpXD0asLgGVwBICS5Bjohp6mizJcDC1+
+  yZ0=
+  -----END CERTIFICATE-----
+
 post_install_message: 
 authors: 
 - ""
 files: 
+- TODO
 - test/unit/polymorph_test.rb
 - test/test_helper.rb
 - test/schema.rb
@@ -37,6 +60,8 @@ files:
 - test/models/wild_boar.rb
 - test/models/tabby.rb
 - test/models/petfood.rb
+- test/models/person.rb
+- test/models/parentship.rb
 - test/models/kitten.rb
 - test/models/frog.rb
 - test/models/eaters_foodstuff.rb
@@ -49,6 +74,7 @@ files:
 - test/models/aquatic/fish.rb
 - test/fixtures/wild_boars.yml
 - test/fixtures/petfoods.yml
+- test/fixtures/people.yml
 - test/fixtures/keep_your_enemies_close.yml
 - test/fixtures/frogs.yml
 - test/fixtures/eaters_foodstuffs.yml
@@ -57,12 +83,16 @@ files:
 - test/fixtures/aquatic/whales.yml
 - test/fixtures/aquatic/little_whale_pupils.yml
 - test/fixtures/aquatic/fish.yml
+- README
+- Manifest
+- LICENSE
 - lib/has_many_polymorphs.rb
 - lib/has_many_polymorphs/support_methods.rb
 - lib/has_many_polymorphs/reflection.rb
 - lib/has_many_polymorphs/rake_task_redefine_task.rb
 - lib/has_many_polymorphs/dependencies.rb
 - lib/has_many_polymorphs/debugging_tools.rb
+- lib/has_many_polymorphs/configuration.rb
 - lib/has_many_polymorphs/class_methods.rb
 - lib/has_many_polymorphs/base.rb
 - lib/has_many_polymorphs/autoload.rb
@@ -77,9 +107,6 @@ files:
 - generators/tagging/templates/tag.rb
 - generators/tagging/templates/migration.rb
 - generators/tagging/tagging_generator.rb
-- TODO
-- README
-- LICENSE
 - CHANGELOG
 - has_many_polymorphs.gemspec
 test_files: