has_many_polymorphs 2.11 → 2.12

data/generators/commenting/commenting_generator.rb

@@ -1,94 +0,0 @@
-
-class CommentingGenerator < Rails::Generator::NamedBase
-  default_options :skip_migration => false
-  default_options :self_referential => false
-  attr_reader :parent_association_name
-  attr_reader :commentable_models
-
-  def initialize(runtime_args, runtime_options = {})
-    @parent_association_name = (runtime_args.include?("--self-referential") ? "commenter" : "comment")
-    @commentable_models = runtime_args.reject{|opt| opt =~ /^--/}.map do |commentable|
-      ":" + commentable.underscore.pluralize
-    end
-    @commentable_models += [":comments"] if runtime_args.include?("--self-referential") 
-    @commentable_models.uniq!
-        
-    verify @commentable_models
-    hacks     
-    runtime_args.unshift("placeholder")
-    super
-  end
-  
-  def verify models
-    puts "** Warning: only one commentable model specified; tests may not run properly." if models.size < 2
-    models.each do |model|
-      model = model[1..-1].classify
-      next if model == "Comment" # 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 'commenting_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 'comment.rb', File.join('app/models', class_path, "comment.rb")
-      m.template 'comment_test.rb', File.join('test/unit', class_path, "comment_test.rb")
-      m.template 'comments.yml', File.join('test/fixtures', class_path, "comments.yml")
-      
-      m.template 'commenting.rb', File.join('app/models', class_path, "commenting.rb")
-      m.template 'commenting_test.rb', File.join('test/unit', class_path, "commenting_test.rb")
-      m.template 'commentings.yml', File.join('test/fixtures', class_path, "commentings.yml")
-      
-      m.template 'commenting_extensions.rb', File.join('lib', 'commenting_extensions.rb')
-
-      unless options[:skip_migration]
-        m.migration_template 'migration.rb', 'db/migrate',
-          :migration_file_name => "create_comments_and_commentings"
-      end
-      
-    end
-  end
-
-  protected
-    def banner
-      "Usage: #{$0} generate commenting [CommentableModelA CommentableModelB ...]"
-    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 comments to comment themselves.") { |v| options[:self_referential] = v }
-    end
-    
-    # Useful for generating tests/fixtures
-    def model_one
-      commentable_models[0][1..-1].classify
-    end
-    
-    def model_two
-      commentable_models[1][1..-1].classify rescue model_one
-    end
-end

data/generators/commenting/templates/comment.rb

@@ -1,33 +0,0 @@
-
-# The Comment model. This model is automatically generated and added to your app if you run the commenting generator.
-
-class Comment < ActiveRecord::Base
-
-  # If database speed becomes an issue, you could remove these validations and rescue the ActiveRecord database constraint errors instead.
-  validates_presence_of :name, :email, :body
-  validates_format_of   :email, :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
-
-  after_validation :prepend_url
-  
-  # Set up the polymorphic relationship.
-  has_many_polymorphs :commentables, 
-    :from => [<%= commentable_models.join(", ") %>], 
-    :through => :commentings, 
-    :dependent => :destroy,
-<% if options[:self_referential] -%>    :as => :<%= parent_association_name -%>,
-<% end -%>
-    :parent_extend => proc {
-    }
-    
-  # Tag::Error class. Raised by ActiveRecord::Base::TaggingExtensions if something goes wrong.
-  class Error < StandardError
-  end
-
-  protected
-  def prepend_url
-    return if self[:url].blank?
-    if self[:url] !~ /^http(s):\/\//i
-      self.url = 'http://' + self[:url]
-    end
-  end
-end

data/generators/commenting/templates/comment_test.rb

@@ -1,12 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-class CommentTest < Test::Unit::TestCase
-  fixtures :comments, :commentings, <%= commentable_models[0..1].join(", ") -%>
-
-  def test_to_s
-    assert_equal "no1@nowhere.com", <%= model_two -%>.find(2).comments.first.email
-    assert_equal "http://letrails.cn", <%= model_two -%>.find(2).comments.last.url
-    assert_equal "http://fr.ivolo.us", <%= model_two -%>.find(2).comments.first.url
-  end
-  
-end

data/generators/commenting/templates/commenting.rb

@@ -1,13 +0,0 @@
-
-# The Commenting join model. This model is automatically generated and added to your app if you run the commenting generator.
-
-class Commenting < ActiveRecord::Base 
- 
-  belongs_to :<%= parent_association_name -%><%= ", :foreign_key => \"#{parent_association_name}_id\", :class_name => \"Comment\"" if options[:self_referential] %>
-  belongs_to :commentable, :polymorphic => true
-  
-  # This callback makes sure that an orphaned <tt>Comment</tt> is deleted if it no longer tags anything.
-  def before_destroy
-    <%= parent_association_name -%>.destroy_without_callbacks if <%= parent_association_name -%> and <%= parent_association_name -%>.commentings.count == 1
-  end    
-end

data/generators/commenting/templates/commenting_extensions.rb

@@ -1,30 +0,0 @@
-class ActiveRecord::Base
-  module CommentingExtensions
-
-    def comment_count
-      commentable?
-      self.comments.size
-    end
-
-    def comment_with(attributes)
-      commentable?(true)
-      begin
-        comment = Comment.create(attributes)
-        raise Comment::Error, "Comment could not be saved with" if comment.new_record?
-        comment.commentables << self
-      rescue
-      end
-    end
-
-    private
-    def commentable?(should_raise = false) #:nodoc:
-      unless flag = respond_to?(:<%= parent_association_name -%>s)
-        raise "#{self.class} is not a commentable model" if should_raise
-      end
-      flag
-    end
-  end
-
-  include CommentingExtensions
-end
-

data/generators/commenting/templates/commenting_test.rb

@@ -1,30 +0,0 @@
-require File.dirname(__FILE__) + '/../test_helper'
-
-class CommentingTest < Test::Unit::TestCase
-  fixtures :commentings, :comments, <%= commentable_models[0..1].join(", ") -%>
-
-  def setup
-    @obj1 = <%= model_two %>.find(1)
-    @obj2 = <%= model_two %>.find(2)
-<% if commentable_models.size > 1 -%>
-    @obj3 = <%= model_one -%>.find(1)
-<% end -%>
-    @comment1 = Comment.find(1)  
-    @comment2 = Comment.find(2)  
-    @commenting1 = Commenting.find(1)
-  end
-
-  def test_commentable
-    assert_raises(RuntimeError) do 
-      @commenting1.send(:commentable?, true) 
-    end
-    assert !@commenting1.send(:commentable?)
-<% if commentable_models.size > 1 -%>
-    assert @obj3.send(:commentable?)
-<% end -%>
-<% if options[:self_referential] -%>  
-    assert @comment1.send(:commentable?)
-<% end -%>    
-  end
-    
-end

data/generators/commenting/templates/commentings.yml

@@ -1,23 +0,0 @@
---- 
-<% if commentable_models.size > 1 -%>
-commentings_003: 
-  <%= parent_association_name -%>_id: "2"
-  id: "3"
-  commentable_type: <%= model_one %>
-  commentable_id: "1"                
-<% end -%>
-commentings_004: 
-  <%= parent_association_name -%>_id: "2"
-  id: "4"
-  commentable_type: <%= model_two %>
-  commentable_id: "2"
-commentings_001: 
-  <%= parent_association_name -%>_id: "1"
-  id: "1"
-  commentable_type: <%= model_two %>
-  commentable_id: "1"
-commentings_002: 
-  <%= parent_association_name -%>_id: "1"
-  id: "2"
-  commentable_type: <%= model_two %>
-  commentable_id: "2"

data/generators/commenting/templates/comments.yml

@@ -1,13 +0,0 @@
---- 
-comments_001: 
-  id: "1"
-  name: frivolous
-  email: no1@nowhere.com
-  url: http://fr.ivolo.us
-  body: this plugin rocks!
-tags_002: 
-  id: "2"
-  name: yuanyiz
-  email: no1@nowhere.com
-  url: http://letrails.cn
-  body: this plugin has saved my life

data/generators/commenting/templates/migration.rb

@@ -1,28 +0,0 @@
-
-# A migration to add tables for Comment and Commenting. This file is automatically generated and added to your app if you run the commenting generator.
-
-class CreateCommentsAndCommentings < ActiveRecord::Migration
-
-  # Add the new tables.
-  def self.up
-    create_table :comments do |t|
-      t.column :name, :string, :null => false
-      t.column :url, :string
-      t.column :email, :string
-      t.column :body, :text
-    end
-
-    create_table :commentings do |t|
-      t.column :<%= parent_association_name -%>_id, :integer, :null => false
-      t.column :commentable_id, :integer, :null => false
-      t.column :commentable_type, :string, :null => false
-    end
-  end
-
-  # Remove the tables.
-  def self.down
-    drop_table :comments
-    drop_table :commentings
-  end
-
-end

data/lib/has_many_polymorphs/dependencies.rb

@@ -1,41 +0,0 @@
-
-=begin rdoc
-Adds a minimal dependency injection framework so that owners of polymorphic relationships reload after their children, reinjecting the child helper methods.
-
-Overrides Dependencies#<tt>new_constants_in</tt>.
-=end
-
-module Dependencies
-    
-  mattr_accessor :injection_graph
-  self.injection_graph = Hash.new([])
-
-  # Add a dependency for this target.
-  def inject_dependency(target, *requirements)
-    target, requirements = target.to_s, requirements.map(&:to_s)    
-    injection_graph[target] = ((injection_graph[target] + requirements).uniq - [target])
-    requirements.each {|requirement| mark_for_unload requirement }
-    _logger_debug "injection graph: #{injection_graph.inspect}" if Dependencies.log_activity
-  end
-
-  # Make sure any dependent constants of the constants added by <tt>yield</tt> are reloaded.
-  def new_constants_in_with_injection(*descs, &block) # chain
-
-    if Dependencies.log_activity
-      _logger_debug "autoloaded constants: #{autoloaded_constants.inspect}"
-      _logger_debug "explicitly unloadable constants: #{explicitly_unloadable_constants.inspect}" 
-    end
-    
-    returning(new_constants_in_without_injection(*descs, &block)) do |found|
-      _logger_debug "new constants: #{found.inspect}" if Dependencies.log_activity and found.any?
-      found.each do |constant|
-        injection_graph[constant].each do |requirement| 
-          requirement.constantize
-           _logger_debug "constantized #{requirement}" if Dependencies.log_activity
-        end
-      end    
-    end
-  end
-  alias_method_chain :new_constants_in, :injection
-   
-end

data/test/integration/app/app/controllers/addresses_controller.rb

@@ -1,85 +0,0 @@
-class AddressesController < ApplicationController
-  # GET /addresses
-  # GET /addresses.xml
-  def index
-    @addresses = Address.find(:all)
-
-    respond_to do |format|
-      format.html # index.html.erb
-      format.xml  { render :xml => @addresses }
-    end
-  end
-
-  # GET /addresses/1
-  # GET /addresses/1.xml
-  def show
-    @address = Address.find(params[:id])
-
-    respond_to do |format|
-      format.html # show.html.erb
-      format.xml  { render :xml => @address }
-    end
-  end
-
-  # GET /addresses/new
-  # GET /addresses/new.xml
-  def new
-    @address = Address.new
-
-    respond_to do |format|
-      format.html # new.html.erb
-      format.xml  { render :xml => @address }
-    end
-  end
-
-  # GET /addresses/1/edit
-  def edit
-    @address = Address.find(params[:id])
-  end
-
-  # POST /addresses
-  # POST /addresses.xml
-  def create
-    @address = Address.new(params[:address])
-
-    respond_to do |format|
-      if @address.save
-        flash[:notice] = 'Address was successfully created.'
-        format.html { redirect_to(@address) }
-        format.xml  { render :xml => @address, :status => :created, :location => @address }
-      else
-        format.html { render :action => "new" }
-        format.xml  { render :xml => @address.errors, :status => :unprocessable_entity }
-      end
-    end
-  end
-
-  # PUT /addresses/1
-  # PUT /addresses/1.xml
-  def update
-    @address = Address.find(params[:id])
-
-    respond_to do |format|
-      if @address.update_attributes(params[:address])
-        flash[:notice] = 'Address was successfully updated.'
-        format.html { redirect_to(@address) }
-        format.xml  { head :ok }
-      else
-        format.html { render :action => "edit" }
-        format.xml  { render :xml => @address.errors, :status => :unprocessable_entity }
-      end
-    end
-  end
-
-  # DELETE /addresses/1
-  # DELETE /addresses/1.xml
-  def destroy
-    @address = Address.find(params[:id])
-    @address.destroy
-
-    respond_to do |format|
-      format.html { redirect_to(addresses_url) }
-      format.xml  { head :ok }
-    end
-  end
-end

data/test/integration/app/app/controllers/sellers_controller.rb

@@ -1,85 +0,0 @@
-class SellersController < ApplicationController
-  # GET /sellers
-  # GET /sellers.xml
-  def index
-    @sellers = Seller.find(:all)
-
-    respond_to do |format|
-      format.html # index.html.erb
-      format.xml  { render :xml => @sellers }
-    end
-  end
-
-  # GET /sellers/1
-  # GET /sellers/1.xml
-  def show
-    @seller = Seller.find(params[:id])
-
-    respond_to do |format|
-      format.html # show.html.erb
-      format.xml  { render :xml => @seller }
-    end
-  end
-
-  # GET /sellers/new
-  # GET /sellers/new.xml
-  def new
-    @seller = Seller.new
-
-    respond_to do |format|
-      format.html # new.html.erb
-      format.xml  { render :xml => @seller }
-    end
-  end
-
-  # GET /sellers/1/edit
-  def edit
-    @seller = Seller.find(params[:id])
-  end
-
-  # POST /sellers
-  # POST /sellers.xml
-  def create
-    @seller = Seller.new(params[:seller])
-
-    respond_to do |format|
-      if @seller.save
-        flash[:notice] = 'Seller was successfully created.'
-        format.html { redirect_to(@seller) }
-        format.xml  { render :xml => @seller, :status => :created, :location => @seller }
-      else
-        format.html { render :action => "new" }
-        format.xml  { render :xml => @seller.errors, :status => :unprocessable_entity }
-      end
-    end
-  end
-
-  # PUT /sellers/1
-  # PUT /sellers/1.xml
-  def update
-    @seller = Seller.find(params[:id])
-
-    respond_to do |format|
-      if @seller.update_attributes(params[:seller])
-        flash[:notice] = 'Seller was successfully updated.'
-        format.html { redirect_to(@seller) }
-        format.xml  { head :ok }
-      else
-        format.html { render :action => "edit" }
-        format.xml  { render :xml => @seller.errors, :status => :unprocessable_entity }
-      end
-    end
-  end
-
-  # DELETE /sellers/1
-  # DELETE /sellers/1.xml
-  def destroy
-    @seller = Seller.find(params[:id])
-    @seller.destroy
-
-    respond_to do |format|
-      format.html { redirect_to(sellers_url) }
-      format.xml  { head :ok }
-    end
-  end
-end