radiant-tags-extension 1.5.1

data/vendor/plugins/has_many_polymorphs/generators/tagging/tagging_generator.rb

@@ -0,0 +1,97 @@
+require 'ruby-debug' and Debugger.start if ENV['USER'] == 'eweaver'
+
+class TaggingGenerator < Rails::Generator::NamedBase
+  default_options :skip_migration => false
+  default_options :self_referential => false
+  attr_reader :parent_association_name
+  attr_reader :taggable_models
+
+  def initialize(runtime_args, runtime_options = {})
+    parse!(runtime_args, runtime_options)
+    
+    @parent_association_name = (runtime_args.include?("--self-referential") ? "tagger" : "tag")
+    @taggable_models = runtime_args.reject{|opt| opt =~ /^--/}.map do |taggable|
+      ":" + taggable.underscore.pluralize
+    end
+    @taggable_models += [":tags"] if runtime_args.include?("--self-referential") 
+    @taggable_models.uniq!
+        
+    verify @taggable_models
+    hacks     
+    runtime_args.unshift("placeholder")
+    super
+  end
+  
+  def verify models
+    puts "** Warning: only one taggable model specified; tests may not run properly." if models.size < 2
+    models.each do |model|
+      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
+  
+  def hacks    
+    # add the extension require in environment.rb
+    phrase = "require 'tagging_extensions'"
+    filename = "#{RAILS_ROOT}/config/environment.rb"
+    unless (open(filename) do |file|
+      file.grep(/#{Regexp.escape phrase}/).any?
+    end)
+      open(filename, 'a+') do |file|
+        file.puts "\n" + phrase + "\n"
+      end
+    end
+  end
+  
+  def manifest
+    record do |m|
+      m.class_collisions class_path, class_name, "#{class_name}Test"
+
+      m.directory File.join('app/models', class_path)
+      m.directory File.join('test/unit', class_path)
+      m.directory File.join('test/fixtures', class_path)
+      m.directory File.join('test/fixtures', class_path)
+      m.directory File.join('lib')
+
+      m.template 'tag.rb', File.join('app/models', class_path, "tag.rb")
+      m.template 'tag_test.rb', File.join('test/unit', class_path, "tag_test.rb")
+      m.template 'tags.yml', File.join('test/fixtures', class_path, "tags.yml")
+      
+      m.template 'tagging.rb', File.join('app/models', class_path, "tagging.rb")
+      m.template 'tagging_test.rb', File.join('test/unit', class_path, "tagging_test.rb")
+      m.template 'taggings.yml', File.join('test/fixtures', class_path, "taggings.yml")
+      
+      m.template 'tagging_extensions.rb', File.join('lib', 'tagging_extensions.rb')
+
+      unless options[:skip_migration]
+        m.migration_template 'migration.rb', 'db/migrate',
+          :migration_file_name => "create_tags_and_taggings"
+      end
+      
+    end
+  end
+
+  protected
+    def banner
+      "Usage: #{$0} generate tagging [TaggableModelA TaggableModelB ...]"
+    end
+
+    def add_options!(opt)
+      opt.separator ''
+      opt.separator 'Options:'
+      opt.on("--skip-migration", 
+             "Don't generate a migration file for this model") { |v| options[:skip_migration] = v }
+      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/vendor/plugins/has_many_polymorphs/generators/tagging/templates/migration.rb

@@ -0,0 +1,28 @@
+
+# A migration to add tables for Tag and Tagging. This file is automatically generated and added to your app if you run the tagging generator included with has_many_polymorphs.
+
+class CreateTagsAndTaggings < ActiveRecord::Migration
+
+  # Add the new tables.
+  def self.up
+    create_table :tags do |t|
+      t.column :name, :string, :null => false
+    end
+    add_index :tags, :name, :unique => true
+
+    create_table :taggings do |t|
+      t.column :<%= parent_association_name -%>_id, :integer, :null => false
+      t.column :taggable_id, :integer, :null => false
+      t.column :taggable_type, :string, :null => false
+      # t.column :position, :integer # Uncomment this if you need to use <tt>acts_as_list</tt>.
+    end
+    add_index :taggings, [:<%= parent_association_name -%>_id, :taggable_id, :taggable_type], :unique => true    
+  end
+
+  # Remove the tables.
+  def self.down
+    drop_table :tags
+    drop_table :taggings
+  end
+
+end

data/vendor/plugins/has_many_polymorphs/generators/tagging/templates/tag.rb

@@ -0,0 +1,39 @@
+
+# The Tag model. This model is automatically generated and added to your app if you run the tagging generator included with has_many_polymorphs.
+
+class Tag < ActiveRecord::Base
+
+  DELIMITER = " " # Controls how to split and join tagnames from strings. You may need to change the <tt>validates_format_of parameters</tt> if you change this.
+
+  # If database speed becomes an issue, you could remove these validations and rescue the ActiveRecord database constraint errors instead.
+  validates_presence_of :name
+  validates_uniqueness_of :name, :case_sensitive => false
+  
+  # Change this validation if you need more complex tag names.
+  validates_format_of :name, :with => /^[a-zA-Z0-9\_\-]+$/, :message => "can not contain special characters"
+  
+  # Set up the polymorphic relationship.
+  has_many_polymorphs :taggables, 
+    :from => [<%= taggable_models.join(", ") %>], 
+    :through => :taggings, 
+    :dependent => :destroy,
+<% if options[:self_referential] -%>    :as => :<%= parent_association_name -%>,
+<% end -%>
+    :skip_duplicates => false, 
+    :parent_extend => proc {
+      # Defined on the taggable models, not on Tag itself. Return the tagnames associated with this record as a string.
+      def to_s
+        self.map(&:name).sort.join(Tag::DELIMITER)
+      end
+    }
+    
+  # Callback to strip extra spaces from the tagname before saving it. If you allow tags to be renamed later, you might want to use the <tt>before_save</tt> callback instead.
+  def before_create 
+    self.name = name.downcase.strip.squeeze(" ")
+  end
+  
+  # Tag::Error class. Raised by ActiveRecord::Base::TaggingExtensions if something goes wrong.
+  class Error < StandardError
+  end
+    
+end

data/vendor/plugins/has_many_polymorphs/generators/tagging/templates/tag_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TagTest < ActiveSupport::TestCase
+  fixtures <%= taggable_models[0..1].join(", ") -%>
+  
+  def setup
+    @obj = <%= model_two %>.find(:first)
+    @obj.tag_with "pale imperial"
+  end
+
+  def test_to_s
+    assert_equal "imperial pale", <%= model_two -%>.find(:first).tags.to_s
+  end
+  
+end

data/vendor/plugins/has_many_polymorphs/generators/tagging/templates/tagging.rb

@@ -0,0 +1,16 @@
+
+# The Tagging join model. This model is automatically generated and added to your app if you run the tagging generator included with has_many_polymorphs.
+
+class Tagging < ActiveRecord::Base 
+ 
+  belongs_to :<%= parent_association_name -%><%= ", :foreign_key => \"#{parent_association_name}_id\", :class_name => \"Tag\"" if options[:self_referential] %>
+  belongs_to :taggable, :polymorphic => true
+  
+  # If you also need to use <tt>acts_as_list</tt>, you will have to manage the tagging positions manually by creating decorated join records when you associate Tags with taggables.
+  # acts_as_list :scope => :taggable
+    
+  # This callback makes sure that an orphaned <tt>Tag</tt> is deleted if it no longer tags anything.
+  def after_destroy
+    <%= parent_association_name -%>.destroy_without_callbacks if <%= parent_association_name -%> and <%= parent_association_name -%>.taggings.count == 0
+  end    
+end

data/vendor/plugins/has_many_polymorphs/generators/tagging/templates/tagging_extensions.rb

@@ -0,0 +1,203 @@
+class ActiveRecord::Base #:nodoc:
+
+  # These extensions make models taggable. This file is automatically generated and required by your app if you run the tagging generator included with has_many_polymorphs.
+  module TaggingExtensions
+    
+    # Add tags to <tt>self</tt>. Accepts a string of tagnames, an array of tagnames, an array of ids, or an array of Tags.
+    #
+    # We need to avoid name conflicts with the built-in ActiveRecord association methods, thus the underscores.
+    def _add_tags incoming
+      taggable?(true)
+      tag_cast_to_string(incoming).each do |tag_name|
+        begin
+          tag = Tag.find_or_create_by_name(tag_name)
+          raise Tag::Error, "tag could not be saved: #{tag_name}" if tag.new_record?
+          tags << tag
+        rescue ActiveRecord::StatementInvalid => e
+          raise unless e.to_s =~ /duplicate/i
+        end
+      end
+    end
+  
+    # Removes tags from <tt>self</tt>. Accepts a string of tagnames, an array of tagnames, an array of ids, or an array of Tags.  
+    def _remove_tags outgoing
+      taggable?(true)
+      outgoing = tag_cast_to_string(outgoing)
+  <% if options[:self_referential] %>  
+      # because of http://dev.rubyonrails.org/ticket/6466
+      taggings.destroy(*(taggings.find(:all, :include => :<%= parent_association_name -%>).select do |tagging| 
+        outgoing.include? tagging.<%= parent_association_name -%>.name
+      end))
+  <% else -%>   
+      <%= parent_association_name -%>s.delete(*(<%= parent_association_name -%>s.select do |tag|
+        outgoing.include? tag.name    
+      end))
+  <% end -%>
+    end
+
+   # Returns the tags on <tt>self</tt> as a string.
+    def tag_list
+      # Redefined later to avoid an RDoc parse error.
+    end
+  
+    # Replace the existing tags on <tt>self</tt>. Accepts a string of tagnames, an array of tagnames, an array of ids, or an array of Tags.
+    def tag_with list    
+      #:stopdoc:
+      taggable?(true)
+      list = tag_cast_to_string(list)
+             
+      # Transactions may not be ideal for you here; be aware.
+      Tag.transaction do 
+        current = <%= parent_association_name -%>s.map(&:name)
+        _add_tags(list - current)
+        _remove_tags(current - list)
+      end
+      
+      self
+      #:startdoc:
+    end
+
+   # Returns the tags on <tt>self</tt> as a string.
+    def tag_list #:nodoc:
+      #:stopdoc:
+      taggable?(true)
+      <%= parent_association_name -%>s.reload
+      <%= parent_association_name -%>s.to_s
+      #:startdoc:
+    end
+
+    def tag_list=(value)
+        tag_with(value)
+    end    
+
+    private 
+    
+    def tag_cast_to_string obj #:nodoc:
+      case obj
+        when Array
+          obj.map! do |item|
+            case item
+              when /^\d+$/, Fixnum then Tag.find(item).name # This will be slow if you use ids a lot.
+              when Tag then item.name
+              when String then item
+              else
+                raise "Invalid type"
+            end
+          end              
+        when String
+          obj = obj.split(Tag::DELIMITER).map do |tag_name| 
+            tag_name.strip.squeeze(" ")
+          end
+        else
+          raise "Invalid object of class #{obj.class} as tagging method parameter"
+      end.flatten.compact.map(&:downcase).uniq
+    end 
+  
+    # Check if a model is in the :taggables target list. The alternative to this check is to explicitly include a TaggingMethods module (which you would create) in each target model.  
+    def taggable?(should_raise = false) #:nodoc:
+      unless flag = respond_to?(:<%= parent_association_name -%>s)
+        raise "#{self.class} is not a taggable model" if should_raise
+      end
+      flag
+    end
+
+  end
+  
+  module TaggingFinders
+    # Find all the objects tagged with the supplied list of tags
+    # 
+    # Usage : Model.tagged_with("ruby")
+    #         Model.tagged_with("hello", "world")
+    #         Model.tagged_with("hello", "world", :limit => 10)
+    #
+    # XXX This query strategy is not performant, and needs to be rewritten as an inverted join or a series of unions
+    # 
+    def tagged_with(*tag_list)
+      options = tag_list.last.is_a?(Hash) ? tag_list.pop : {}
+      tag_list = parse_tags(tag_list)
+      
+      scope = scope(:find)
+      options[:select] ||= "#{table_name}.*"
+      options[:from] ||= "#{table_name}, tags, taggings"
+      
+      sql  = "SELECT #{(scope && scope[:select]) || options[:select]} "
+      sql << "FROM #{(scope && scope[:from]) || options[:from]} "
+
+      add_joins!(sql, options[:joins], scope)
+      
+      sql << "WHERE #{table_name}.#{primary_key} = taggings.taggable_id "
+      sql << "AND taggings.taggable_type = '#{ActiveRecord::Base.send(:class_name_of_active_record_descendant, self).to_s}' "
+      sql << "AND taggings.tag_id = tags.id "
+      
+      tag_list_condition = tag_list.map {|name| "'#{name}'"}.join(", ")
+      
+      sql << "AND (tags.name IN (#{sanitize_sql(tag_list_condition)})) "
+      sql << "AND #{sanitize_sql(options[:conditions])} " if options[:conditions]
+      
+      columns = column_names.map do |column| 
+        "#{table_name}.#{column}"
+      end.join(", ")
+      
+      sql << "GROUP BY #{columns} "
+      sql << "HAVING COUNT(taggings.tag_id) = #{tag_list.size}"
+      
+      add_order!(sql, options[:order], scope)
+      add_limit!(sql, options, scope)
+      add_lock!(sql, options, scope)
+      
+      find_by_sql(sql)
+    end
+   
+   def self.tagged_with_any(*tag_list)
+     options = tag_list.last.is_a?(Hash) ? tag_list.pop : {}
+     tag_list = parse_tags(tag_list)
+   
+     scope = scope(:find)
+     options[:select] ||= "#{table_name}.*"
+     options[:from] ||= "#{table_name}, tags, taggings"
+   
+     sql  = "SELECT #{(scope && scope[:select]) || options[:select]} "
+     sql << "FROM #{(scope && scope[:from]) || options[:from]} "
+
+     add_joins!(sql, options, scope)
+   
+     sql << "WHERE #{table_name}.#{primary_key} = taggings.taggable_id "
+     sql << "AND taggings.taggable_type = '#{ActiveRecord::Base.send(:class_name_of_active_record_descendant, self).to_s}' "
+     sql << "AND taggings.tag_id = tags.id "
+     
+     sql << "AND ("
+     or_options = []
+     tag_list.each do |name|
+       or_options << "tags.name = '#{name}'"
+     end
+     or_options_joined = or_options.join(" OR ")
+     sql << "#{or_options_joined}) "
+     
+     
+     sql << "AND #{sanitize_sql(options[:conditions])} " if options[:conditions]
+      
+     columns = column_names.map do |column| 
+       "#{table_name}.#{column}"
+     end.join(", ")
+      
+     sql << "GROUP BY #{columns} "
+   
+     add_order!(sql, options[:order], scope)
+     add_limit!(sql, options, scope)
+     add_lock!(sql, options, scope)
+   
+     find_by_sql(sql)
+   end
+    
+    def parse_tags(tags)
+      return [] if tags.blank?
+      tags = Array(tags).first
+      tags = tags.respond_to?(:flatten) ? tags.flatten : tags.split(Tag::DELIMITER)
+      tags.map { |tag| tag.strip.squeeze(" ") }.flatten.compact.map(&:downcase).uniq
+    end
+    
+  end
+
+  include TaggingExtensions
+  extend  TaggingFinders
+end

data/vendor/plugins/has_many_polymorphs/generators/tagging/templates/tagging_test.rb

@@ -0,0 +1,85 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TaggingTest < ActiveSupport::TestCase
+  fixtures :tags, :taggings, <%= taggable_models[0..1].join(", ") -%>
+
+  def setup
+    @objs = <%= model_two %>.find(:all, :limit => 2)
+    
+    @obj1 = @objs[0]
+    @obj1.tag_with("pale")
+    @obj1.reload
+    
+    @obj2 = @objs[1]
+    @obj2.tag_with("pale imperial")
+    @obj2.reload
+    
+<% if taggable_models.size > 1 -%>
+    @obj3 = <%= model_one -%>.find(:first)
+<% end -%>
+    @tag1 = Tag.find(1)  
+    @tag2 = Tag.find(2)  
+    @tagging1 = Tagging.find(1)
+  end
+
+  def test_tag_with
+    @obj2.tag_with "hoppy pilsner"
+    assert_equal "hoppy pilsner", @obj2.tag_list
+  end
+  
+  def test_find_tagged_with
+    @obj1.tag_with "seasonal lager ipa"
+    @obj2.tag_with ["lager", "stout", "fruity", "seasonal"]
+    
+    result1 = [@obj1]
+    assert_equal <%= model_two %>.tagged_with("ipa"), result1
+    assert_equal <%= model_two %>.tagged_with("ipa lager"), result1
+    assert_equal <%= model_two %>.tagged_with("ipa", "lager"), result1
+    
+    result2 = [@obj1.id, @obj2.id].sort
+    assert_equal <%= model_two %>.tagged_with("seasonal").map(&:id).sort, result2
+    assert_equal <%= model_two %>.tagged_with("seasonal lager").map(&:id).sort, result2
+    assert_equal <%= model_two %>.tagged_with("seasonal", "lager").map(&:id).sort, result2
+  end
+  
+<% if options[:self_referential] -%>  
+  def test_self_referential_tag_with
+    @tag1.tag_with [1, 2]
+    assert @tag1.tags.any? {|obj| obj == @tag1}
+    assert !@tag2.tags.any? {|obj| obj == @tag1}
+  end
+
+<% end -%>
+  def test__add_tags
+    @obj1._add_tags "porter longneck"
+    assert Tag.find_by_name("porter").taggables.any? {|obj| obj == @obj1}
+    assert Tag.find_by_name("longneck").taggables.any? {|obj| obj == @obj1}
+    assert_equal "longneck pale porter", @obj1.tag_list    
+    
+    @obj1._add_tags [2]
+    assert_equal "imperial longneck pale porter", @obj1.tag_list        
+  end
+  
+  def test__remove_tags
+    @obj2._remove_tags ["2", @tag1]
+    assert @obj2.tags.empty?
+  end
+  
+  def test_tag_list
+    assert_equal "imperial pale", @obj2.tag_list
+  end
+    
+  def test_taggable
+    assert_raises(RuntimeError) do 
+      @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 -%>    
+  end
+    
+end

data/vendor/plugins/has_many_polymorphs/generators/tagging/templates/taggings.yml

@@ -0,0 +1,23 @@
+--- 
+<% if taggable_models.size > 1 -%>
+taggings_003: 
+  <%= parent_association_name -%>_id: "2"
+  id: "3"
+  taggable_type: <%= model_one %>
+  taggable_id: "1"                
+<% end -%>
+taggings_004: 
+  <%= parent_association_name -%>_id: "2"
+  id: "4"
+  taggable_type: <%= model_two %>
+  taggable_id: "2"
+taggings_001: 
+  <%= parent_association_name -%>_id: "1"
+  id: "1"
+  taggable_type: <%= model_two %>
+  taggable_id: "1"
+taggings_002: 
+  <%= parent_association_name -%>_id: "1"
+  id: "2"
+  taggable_type: <%= model_two %>
+  taggable_id: "2"

data/vendor/plugins/has_many_polymorphs/generators/tagging/templates/tags.yml

@@ -0,0 +1,7 @@
+--- 
+tags_001: 
+  name: pale
+  id: "1"
+tags_002: 
+  name: imperial
+  id: "2"

data/vendor/plugins/has_many_polymorphs/init.rb

@@ -0,0 +1,2 @@
+
+require 'has_many_polymorphs'

data/vendor/plugins/has_many_polymorphs/lib/has_many_polymorphs/association.rb

@@ -0,0 +1,160 @@
+module ActiveRecord #:nodoc:
+  module Associations #:nodoc:
+    
+    class PolymorphicError < ActiveRecordError #:nodoc:
+    end 
+    
+    class PolymorphicMethodNotSupportedError < ActiveRecordError #:nodoc:
+    end
+    
+    # The association class for a <tt>has_many_polymorphs</tt> association.
+    class PolymorphicAssociation < HasManyThroughAssociation
+
+      # Push a record onto the association. Triggers a database load for a uniqueness check only if <tt>:skip_duplicates</tt> is <tt>true</tt>. Return value is undefined.
+      def <<(*records)
+        return if records.empty?
+
+        if @reflection.options[:skip_duplicates]
+          _logger_debug "Loading instances for polymorphic duplicate push check; use :skip_duplicates => false and perhaps a database constraint to avoid this possible performance issue"
+          load_target
+        end
+        
+        @reflection.klass.transaction do
+          flatten_deeper(records).each do |record|
+            if @owner.new_record? or not record.respond_to?(:new_record?) or record.new_record?
+              raise PolymorphicError, "You can't associate unsaved records."            
+            end
+            next if @reflection.options[:skip_duplicates] and @target.include? record
+            @owner.send(@reflection.through_reflection.name).proxy_target << @reflection.klass.create!(construct_join_attributes(record))
+            @target << record if loaded?
+          end
+        end
+        
+        self
+      end
+      
+      alias :push :<<
+      alias :concat :<<      
+     
+      # Runs a <tt>find</tt> against the association contents, returning the matched records. All regular <tt>find</tt> options except <tt>:include</tt> are supported.
+      def find(*args)
+        opts = args._extract_options!
+        opts.delete :include
+        super(*(args + [opts]))
+      end      
+      
+      def construct_scope
+        _logger_warn "Warning; not all usage scenarios for polymorphic scopes are supported yet."
+        super
+      end
+     
+     # Deletes a record from the association. Return value is undefined.
+      def delete(*records)
+        records = flatten_deeper(records)
+        records.reject! {|record| @target.delete(record) if record.new_record?}
+        return if records.empty?
+        
+        @reflection.klass.transaction do
+          records.each do |record|
+            joins = @reflection.through_reflection.name
+            @owner.send(joins).delete(@owner.send(joins).select do |join|
+              join.send(@reflection.options[:polymorphic_key]) == record.id and 
+              join.send(@reflection.options[:polymorphic_type_key]) == "#{record.class.base_class}"
+            end)
+            @target.delete(record)
+          end
+        end
+      end
+      
+      # Clears all records from the association. Returns an empty array.
+      def clear(klass = nil)
+        load_target
+        return if @target.empty?
+        
+        if klass
+          delete(@target.select {|r| r.is_a? klass })
+        else
+          @owner.send(@reflection.through_reflection.name).clear
+          @target.clear
+        end
+        []
+      end
+            
+      protected
+
+#      undef :sum
+#      undef :create!
+
+      def construct_quoted_owner_attributes(*args) #:nodoc:
+        # no access to returning() here? why not?
+        type_key = @reflection.options[:foreign_type_key]
+        h = {@reflection.primary_key_name => @owner.id}
+        h[type_key] = @owner.class.base_class.name if type_key
+        h
+      end
+
+      def construct_from #:nodoc:
+        # build the FROM part of the query, in this case, the polymorphic join table
+        @reflection.klass.quoted_table_name
+      end
+
+      def construct_owner #:nodoc:
+        # the table name for the owner object's class
+        @owner.class.quoted_table_name
+      end
+      
+      def construct_owner_key #:nodoc:
+        # the primary key field for the owner object
+        @owner.class.primary_key
+      end
+
+      def construct_select(custom_select = nil) #:nodoc:
+        # build the select query
+        selected = custom_select || @reflection.options[:select]
+      end
+
+      def construct_joins(custom_joins = nil) #:nodoc:
+        # build the string of default joins
+        "JOIN #{construct_owner} AS polymorphic_parent ON #{construct_from}.#{@reflection.options[:foreign_key]} = polymorphic_parent.#{construct_owner_key} " + 
+        @reflection.options[:from].map do |plural|
+          klass = plural._as_class
+          "LEFT JOIN #{klass.quoted_table_name} ON #{construct_from}.#{@reflection.options[:polymorphic_key]} = #{klass.quoted_table_name}.#{klass.primary_key} AND #{construct_from}.#{@reflection.options[:polymorphic_type_key]} = #{@reflection.klass.quote_value(klass.base_class.name)}"
+        end.uniq.join(" ") + " #{custom_joins}"
+      end
+
+      def construct_conditions #:nodoc:
+        # build the fully realized condition string
+        conditions = construct_quoted_owner_attributes.map do |field, value|
+          "#{construct_from}.#{field} = #{@reflection.klass.quote_value(value)}" if value
+        end
+        conditions << custom_conditions if custom_conditions
+        "(" + conditions.compact.join(') AND (') + ")"
+      end
+
+      def custom_conditions #:nodoc:
+        # custom conditions... not as messy as has_many :through because our joins are a little smarter
+        if @reflection.options[:conditions]
+          "(" + interpolate_sql(@reflection.klass.send(:sanitize_sql, @reflection.options[:conditions])) + ")"
+        end
+      end
+
+      alias :construct_owner_attributes :construct_quoted_owner_attributes
+      alias :conditions :custom_conditions # XXX possibly not necessary
+      alias :sql_conditions :custom_conditions # XXX ditto      
+
+      # construct attributes for join for a particular record
+      def construct_join_attributes(record) #:nodoc:
+        {@reflection.options[:polymorphic_key] => record.id, 
+          @reflection.options[:polymorphic_type_key] => "#{record.class.base_class}",          
+          @reflection.options[:foreign_key] => @owner.id}.merge(@reflection.options[:foreign_type_key] ? 
+        {@reflection.options[:foreign_type_key] => "#{@owner.class.base_class}"} : {}) # for double-sided relationships
+      end
+                    
+      def build(attrs = nil) #:nodoc:
+        raise PolymorphicMethodNotSupportedError, "You can't associate new records."
+      end      
+
+    end   
+        
+  end
+end