has_many_polymorphs 2.2

data/TODO

@@ -0,0 +1,2 @@
+
+* Tag cloud method

data/examples/hmph.rb

@@ -0,0 +1,69 @@
+require 'camping'
+require 'has_many_polymorphs'
+
+Camping.goes :Hmph
+
+module Hmph::Models
+  class GuestsKennel < Base
+    belongs_to :kennel
+    belongs_to :guest, :polymorphic => true
+  end
+
+  class Dog < Base
+  end
+
+  class Cat < Base
+  end
+
+  class Bird < Base
+  end
+  
+  class Kennel < Base
+    has_many_polymorphs :guests, 
+      :from => [:dogs, :cats, :birds],
+      :through => :guests_kennels,
+      :namespace => :"hmph/models/"      
+  end  
+
+  class InitialSchema < V 1.0
+    def self.up
+      create_table :hmph_kennels do |t|
+        t.column :created_at, :datetime
+        t.column :modified_at, :datetime
+        t.column :name, :string, :default => 'Anonymous Kennel'
+      end
+
+      create_table :hmph_guests_kennels do |t|
+        t.column :guest_id, :integer
+        t.column :guest_type, :string
+        t.column :kennel_id, :integer
+      end
+
+      create_table :hmph_dogs do |t|
+        t.column :name, :string, :default => 'Fido'
+      end
+
+      create_table :hmph_cats do |t|
+        t.column :name, :string, :default => 'Morris'
+      end
+
+      create_table :hmph_birds do |t|
+        t.column :name, :string, :default => 'Polly'
+      end
+    end
+
+    def self.down
+      drop_table :hmph_kennels
+      drop_table :hmph_guests_kennels
+      drop_table :hmph_dogs
+      drop_table :hmph_cats
+      drop_table :hmph_birds
+    end
+  end
+end
+
+module Hmph::Controllers
+end
+
+module Hmph::Views
+end

data/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/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/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/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/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/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/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/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/generators/tagging/templates/tags.yml

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

data/has_many_polymorphs.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{has_many_polymorphs}
+  s.version = "2.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = [""]
+  s.cert_chain = ["/Users/eweaver/p/configuration/gem_certificates/evan_weaver-original-public_cert.pem"]
+  s.date = %q{2009-11-18}
+  s.description = %q{An ActiveRecord plugin for self-referential and double-sided polymorphic associations.}
+  s.email = %q{}
+  s.extra_rdoc_files = ["CHANGELOG", "generators/tagging/templates/migration.rb", "generators/tagging/templates/tag.rb", "generators/tagging/templates/tagging.rb", "generators/tagging/templates/tagging_extensions.rb", "lib/has_many_polymorphs/association.rb", "lib/has_many_polymorphs/autoload.rb", "lib/has_many_polymorphs/class_methods.rb", "lib/has_many_polymorphs/configuration.rb", "lib/has_many_polymorphs/reflection.rb", "LICENSE", "README", "test/integration/app/doc/README_FOR_APP", "test/integration/app/README", "TODO"]
+  s.files = ["CHANGELOG", "examples/hmph.rb", "generators/tagging/tagging_generator.rb", "generators/tagging/templates/migration.rb", "generators/tagging/templates/tag.rb", "generators/tagging/templates/tag_test.rb", "generators/tagging/templates/tagging.rb", "generators/tagging/templates/tagging_extensions.rb", "generators/tagging/templates/tagging_test.rb", "generators/tagging/templates/taggings.yml", "generators/tagging/templates/tags.yml", "init.rb", "lib/has_many_polymorphs/association.rb", "lib/has_many_polymorphs/autoload.rb", "lib/has_many_polymorphs/base.rb", "lib/has_many_polymorphs/class_methods.rb", "lib/has_many_polymorphs/configuration.rb", "lib/has_many_polymorphs/debugging_tools.rb", "lib/has_many_polymorphs/rake_task_redefine_task.rb", "lib/has_many_polymorphs/reflection.rb", "lib/has_many_polymorphs/support_methods.rb", "lib/has_many_polymorphs.rb", "LICENSE", "Manifest", "Rakefile", "README", "test/fixtures/bow_wows.yml", "test/fixtures/cats.yml", "test/fixtures/eaters_foodstuffs.yml", "test/fixtures/fish.yml", "test/fixtures/frogs.yml", "test/fixtures/keep_your_enemies_close.yml", "test/fixtures/little_whale_pupils.yml", "test/fixtures/people.yml", "test/fixtures/petfoods.yml", "test/fixtures/whales.yml", "test/fixtures/wild_boars.yml", "test/generator/tagging_generator_test.rb", "test/integration/app/app/controllers/application.rb", "test/integration/app/app/controllers/bones_controller.rb", "test/integration/app/app/helpers/addresses_helper.rb", "test/integration/app/app/helpers/application_helper.rb", "test/integration/app/app/helpers/bones_helper.rb", "test/integration/app/app/helpers/sellers_helper.rb", "test/integration/app/app/helpers/states_helper.rb", "test/integration/app/app/helpers/users_helper.rb", "test/integration/app/app/models/bone.rb", "test/integration/app/app/models/double_sti_parent.rb", "test/integration/app/app/models/double_sti_parent_relationship.rb", "test/integration/app/app/models/organic_substance.rb", "test/integration/app/app/models/single_sti_parent.rb", "test/integration/app/app/models/single_sti_parent_relationship.rb", "test/integration/app/app/models/stick.rb", "test/integration/app/app/models/stone.rb", "test/integration/app/app/views/addresses/edit.html.erb", "test/integration/app/app/views/addresses/index.html.erb", "test/integration/app/app/views/addresses/new.html.erb", "test/integration/app/app/views/addresses/show.html.erb", "test/integration/app/app/views/bones/index.rhtml", "test/integration/app/app/views/layouts/addresses.html.erb", "test/integration/app/app/views/layouts/sellers.html.erb", "test/integration/app/app/views/layouts/states.html.erb", "test/integration/app/app/views/layouts/users.html.erb", "test/integration/app/app/views/sellers/edit.html.erb", "test/integration/app/app/views/sellers/index.html.erb", "test/integration/app/app/views/sellers/new.html.erb", "test/integration/app/app/views/sellers/show.html.erb", "test/integration/app/app/views/states/edit.html.erb", "test/integration/app/app/views/states/index.html.erb", "test/integration/app/app/views/states/new.html.erb", "test/integration/app/app/views/states/show.html.erb", "test/integration/app/app/views/users/edit.html.erb", "test/integration/app/app/views/users/index.html.erb", "test/integration/app/app/views/users/new.html.erb", "test/integration/app/app/views/users/show.html.erb", "test/integration/app/config/boot.rb", "test/integration/app/config/database.yml", "test/integration/app/config/environment.rb", "test/integration/app/config/environment.rb.canonical", "test/integration/app/config/environments/development.rb", "test/integration/app/config/environments/production.rb", "test/integration/app/config/environments/test.rb", "test/integration/app/config/locomotive.yml", "test/integration/app/config/routes.rb", "test/integration/app/config/ultrasphinx/default.base", "test/integration/app/config/ultrasphinx/development.conf.canonical", "test/integration/app/db/migrate/001_create_sticks.rb", "test/integration/app/db/migrate/002_create_stones.rb", "test/integration/app/db/migrate/003_create_organic_substances.rb", "test/integration/app/db/migrate/004_create_bones.rb", "test/integration/app/db/migrate/005_create_single_sti_parents.rb", "test/integration/app/db/migrate/006_create_double_sti_parents.rb", "test/integration/app/db/migrate/007_create_single_sti_parent_relationships.rb", "test/integration/app/db/migrate/008_create_double_sti_parent_relationships.rb", "test/integration/app/db/migrate/009_create_library_model.rb", "test/integration/app/doc/README_FOR_APP", "test/integration/app/generators/commenting_generator_test.rb", "test/integration/app/lib/library_model.rb", "test/integration/app/public/404.html", "test/integration/app/public/500.html", "test/integration/app/public/dispatch.cgi", "test/integration/app/public/dispatch.fcgi", "test/integration/app/public/dispatch.rb", "test/integration/app/public/favicon.ico", "test/integration/app/public/images/rails.png", "test/integration/app/public/index.html", "test/integration/app/public/javascripts/application.js", "test/integration/app/public/javascripts/controls.js", "test/integration/app/public/javascripts/dragdrop.js", "test/integration/app/public/javascripts/effects.js", "test/integration/app/public/javascripts/prototype.js", "test/integration/app/public/robots.txt", "test/integration/app/public/stylesheets/scaffold.css", "test/integration/app/Rakefile", "test/integration/app/README", "test/integration/app/script/about", "test/integration/app/script/breakpointer", "test/integration/app/script/console", "test/integration/app/script/destroy", "test/integration/app/script/generate", "test/integration/app/script/performance/benchmarker", "test/integration/app/script/performance/profiler", "test/integration/app/script/plugin", "test/integration/app/script/process/inspector", "test/integration/app/script/process/reaper", "test/integration/app/script/process/spawner", "test/integration/app/script/runner", "test/integration/app/script/server", "test/integration/app/test/fixtures/double_sti_parent_relationships.yml", "test/integration/app/test/fixtures/double_sti_parents.yml", "test/integration/app/test/fixtures/organic_substances.yml", "test/integration/app/test/fixtures/single_sti_parent_relationships.yml", "test/integration/app/test/fixtures/single_sti_parents.yml", "test/integration/app/test/fixtures/sticks.yml", "test/integration/app/test/fixtures/stones.yml", "test/integration/app/test/functional/addresses_controller_test.rb", "test/integration/app/test/functional/bones_controller_test.rb", "test/integration/app/test/functional/sellers_controller_test.rb", "test/integration/app/test/functional/states_controller_test.rb", "test/integration/app/test/functional/users_controller_test.rb", "test/integration/app/test/test_helper.rb", "test/integration/app/test/unit/bone_test.rb", "test/integration/app/test/unit/double_sti_parent_relationship_test.rb", "test/integration/app/test/unit/double_sti_parent_test.rb", "test/integration/app/test/unit/organic_substance_test.rb", "test/integration/app/test/unit/single_sti_parent_relationship_test.rb", "test/integration/app/test/unit/single_sti_parent_test.rb", "test/integration/app/test/unit/stick_test.rb", "test/integration/app/test/unit/stone_test.rb", "test/integration/server_test.rb", "test/models/aquatic/fish.rb", "test/models/aquatic/pupils_whale.rb", "test/models/aquatic/whale.rb", "test/models/beautiful_fight_relationship.rb", "test/models/canine.rb", "test/models/cat.rb", "test/models/dog.rb", "test/models/eaters_foodstuff.rb", "test/models/frog.rb", "test/models/kitten.rb", "test/models/parentship.rb", "test/models/person.rb", "test/models/petfood.rb", "test/models/tabby.rb", "test/models/wild_boar.rb", "test/modules/extension_module.rb", "test/modules/other_extension_module.rb", "test/patches/symlinked_plugins_1.2.6.diff", "test/schema.rb", "test/setup.rb", "test/test_helper.rb", "test/unit/has_many_polymorphs_test.rb", "TODO", "has_many_polymorphs.gemspec"]
+  s.homepage = %q{http://blog.evanweaver.com/files/doc/fauna/has_many_polymorphs/}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Has_many_polymorphs", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{fauna}
+  s.rubygems_version = %q{1.3.5}
+  s.signing_key = %q{/Users/eweaver/p/configuration/gem_certificates/evan_weaver-original-private_key.pem}
+  s.summary = %q{An ActiveRecord plugin for self-referential and double-sided polymorphic associations.}
+  s.test_files = ["test/generator/tagging_generator_test.rb", "test/integration/server_test.rb", "test/unit/has_many_polymorphs_test.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 0"])
+  end
+end

data/init.rb

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