opinio 0.3.0

data/Gemfile

@@ -0,0 +1,24 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "kaminari"
+gem "rails", "~> 3.0.4"
+gem "sqlite3"
+gem "jquery-rails"
+
+group :development do
+  gem "ruby-debug19"
+end
+
+group :test do
+  gem "cucumber"
+  gem "cucumber-rails"
+  gem "capybara"
+  gem "launchy"
+  gem "database_cleaner"
+  gem "rspec-rails"
+end
+# To use debugger (ruby-debug for Ruby 1.8.7+, ruby-debug19 for Ruby 1.9.2+)
+# gem 'ruby-debug'
+# gem 'ruby-debug19'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,127 @@
+= Opinio
+
+== Description
+
+Opinio is an engine used to add comments behaviour to your application.
+The engine is designed to work only with *Rails 3*
+
+== Intallation
+
+Simply add the following line to your *Gemfile*:
+
+  gem "opinio"
+
+and run:
+
+  bundle
+
+== Documentation
+
+Rdocs here:
+  http://rubydoc.info/github/Draiken/opinio/master/frames
+
+
+== Usage
+
+Opinio provides generators to facilitate it's usage.
+The most common way to quickly get Opinio working is:
+
+  rails g opinio:install comment
+
+This will generate the *Comment* model, migration and also generate the opinio initializer for customization of the engine.
+A `opinio_model` will be added on the `routes.rb`. This method adds the default urls for the model that will acts as the comment
+
+In order to add the comments functionallity to a model, you use the *opinio_subjectum* method
+
+  class Post < ActiveRecord::Base
+    opinio_subjectum
+  end
+
+On the `routes.rb` you should simply add an `opinio` for your resource that will have comments
+
+  resources :posts do
+    opinio
+  end
+
+If you want to display the comments for the item outside of the resource, you can simply add this to your views:
+
+  <%= comments_for @post %>
+
+And there you go, you can now comment in your post.
+Aditional options can be found on the {RDocs}[http://rubydoc.info/github/Draiken/opinio/master/frames]
+
+== Customization
+
+=== Views
+
+Of course you will want to customize how the comments are displayed or any other customization to the view. To generate the view files on your application, run:
+
+  rails g opinio:views
+
+And you can customize all the views used by the engine.
+
+=== Behaviour
+
+==== Pretty Urls
+
+Often times you will want the engine to show the index of comments for a specific item
+without having to pass *:commentable_type* or *:commentable_id*.
+
+In order to do that, opinio provides a method to *ActionController::Base*:
+
+  opinio_identifier do |params|
+    next Review.find(params[:review_id]) if params[:review_id]
+    next Product.find(params[:product_id]) if params[:product_id]
+  end
+
+Note: you use next instead of return because it is a proc that will be executed later on, and you cannot return on procs
+
+Basically on this method you receive the *params* variable and you tell the engine, who owns
+the comments from that page.
+This allows you to use routes like:
+
+  /products/1/comments
+  /products/1/reviews/1/comments
+
+Without passing those 2 parameters.
+I suggest you put this method on the *ApplicationController*
+
+==== Customize destroy conditions
+
+By default, anyone can destroy any comment in the engine. We don't want that.
+To setup a custom destroy condition we can use the methods provided by opinio
+in our controllers. For instance, if our opinio model is called 'comment' 
+it would be like this:
+
+  comment_destroy_conditions do |comment|
+    comment.owner == current_user
+  end
+
+This would make users only be able to remove their own comments.
+Another example would be using the *CanCan*:
+
+  comment_destroy_conditions do |comment|
+    authorize :destroy, comment
+  end
+
+You get the picture, you're inside your controller's methods on that block
+so you can call anything your normal controllers call on actions.
+
+== Contribution
+
+If you want to help in any way with *Opinio* please message me or fork the project, make the changes and send me a pull request.
+For issues please use the github {issues tracker}[https://github.com/Draiken/opinio/issues]
+
+Remember this engine is still in development :)
+
+=== TODO
+
+  * Haml views
+  * Better controller overriding (coding and documentation)
+  * Support for deeper levels of replies
+  * Refactor the `comments_for` helper
+  * Extract documentation to wiki
+  * Add tons of rspecs for
+    * controllers
+    * routes
+    * model extensions

data/Rakefile

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+require 'rubygems'
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rake'
+require 'rake/rdoctask'
+
+require 'cucumber'
+require 'cucumber/rake/task'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Opinio'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/app/controllers/opinio/comments_controller.rb

@@ -0,0 +1,33 @@
+class Opinio::CommentsController < ApplicationController
+  include Opinio::Controllers::InternalHelpers
+  include Opinio::Controllers::Replies if Opinio.accept_replies
+
+  def index
+    @comments = resource.comments.page(params[:page])
+  end
+
+  def create
+    @comment = resource.comments.build(params[:comment])
+    @comment.owner = current_user
+    if @comment.save
+      flash[:notice] = I18n.translate('opinio.comment.sent', :default => "Comment sent successfully.")
+    else
+      flash[:error]  = I18n.translate('opinio.comment.error', :default => "Error sending the comment.")
+    end
+  end
+
+  def destroy
+    @comment = Opinio.model_name.constantize.find(params[:id])
+
+    if can_destroy_opinio?(@comment)
+      @comment.destroy
+      flash[:notice] = I18n.translate('opinio.comment.destroyed', :default => "Comment removed successfully")
+    else
+      #flash[:error]  = I18n.translate('opinio.comment.not_permitted', :default => "Not permitted")
+      logger.warning "user #{current_user.email} tried to remove a comment from another user #{@comment.owner.email}"
+      render :text => "unauthorized", :status => 401
+    end
+  end
+
+  
+end

data/app/views/opinio/comments/_comment.html.erb

@@ -0,0 +1,15 @@
+<% reply = defined?(reply) ? reply : false %>
+<li id="comment_<%= comment.id %>">
+  <span>User: <%= comment.owner.id %></span>
+  <p>
+    <%= comment.body %>
+  </p>
+  <%= link_to 'Destroy', comment_path(comment), :method => :delete, :remote => true %>
+  <%# this enables only 1 level of replies %>
+  <% if Opinio.accept_replies && !reply %>
+    <span><%= link_to t("opinio.reply", :default => "Reply"), reply_comment_path(comment), :remote => true %></span>
+    <ul id="comment_<%= comment.id %>_replies" class="replies">
+      <%= render :partial => "opinio/comments/comment", :collection => comment.comments, :locals => {:reply => true} %>
+    </ul>
+  <% end %>
+</li>

data/app/views/opinio/comments/_comments.html.erb

@@ -0,0 +1,15 @@
+<div>
+  <%= paginate comments %>
+</div>
+
+<ul id="comments">
+  <% unless comments.empty? %>
+    <%= render :partial => 'opinio/comments/comment', :collection => comments %>
+  <% else %>
+    <li id="no_comments"><%= t 'opinio.no_comments_found', :default => "No comments found" %></li>
+  <% end %>
+</ul>
+
+<div>
+  <%= paginate comments %>
+</div>

data/app/views/opinio/comments/_new.html.erb

@@ -0,0 +1,18 @@
+<div id="new_comment">
+  <% if current_user %>
+    <h2>Send Comments</h3>
+    <%= form_for Comment.new, :remote => true do |f| %>
+      <p>
+        <%= f.label :body, "Comment" %>
+        <%= f.text_area :body %>
+      </p>
+      <%= hidden_field_tag :commentable_id, commentable.id %>
+      <%= hidden_field_tag :commentable_type, commentable.class.base_class.name.to_s %>
+      <%= f.submit "Send Comment" %>
+    <% end %>
+  <% else %>
+    <p>
+      Must be logged in to comment.
+    </p>
+  <% end %>
+</div>

data/app/views/opinio/comments/create.js.erb

@@ -0,0 +1,11 @@
+jQuery('#no_comments').fadeOut()
+<% if @reply %>
+  if(jQuery('#comment_<%= @comment.commentable_id %> ul').length == 0)
+    jQuery('#comment_<%= @comment.commentable_id %>').append('<ul id="comment_<%= @comment.commentable_id %>_replies" class="replies"></ul>')
+  jQuery('#comment_<%= @comment.commentable_id %>_replies').append("<%= escape_javascript( render @comment, :locals => {:reply => @reply} ) %>")
+  jQuery('#commentable_id').val('<%= @comment.commentable.commentable_id %>')
+  jQuery('#commentable_type').val('<%= @comment.commentable.commentable_type %>')
+<% else %>
+  jQuery('#comments').prepend("<%= escape_javascript( render @comment, :locals => {:reply => @reply} ) %>")
+<% end %>
+

data/app/views/opinio/comments/destroy.js.erb

@@ -0,0 +1,3 @@
+jQuery('#comment_<%= @comment.id %>').remove();
+jQuery('#comments').prepend("<%= escape_javascript(flash[:notice]) %>");
+jQuery('#comments').prepend("<%= escape_javascript(flash[:error]) %>");

data/app/views/opinio/comments/index.html.erb

@@ -0,0 +1,7 @@
+<h1>Comments</h1>
+
+<%= paginate @comments %>
+
+<%= render :partial => "opinio/comments/comments", :locals => { :comments => @comments } %>
+
+<%= paginate @comments %>

data/app/views/opinio/comments/reply.js.erb

@@ -0,0 +1,3 @@
+jQuery("#commentable_id").val('<%= @commentable_id %>')
+jQuery("#commentable_type").val('<%= @commentable_type %>')
+jQuery("#new_comment textarea").focus()

data/lib/generators/opinio/install/install_generator.rb

@@ -0,0 +1,34 @@
+module Opinio
+  module Generators
+    class InstallGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::Migration
+
+      source_root File.expand_path('../templates', __FILE__)
+
+
+      def generate_model
+        template "models/model.rb", "app/models/#{file_name}.rb"
+      end
+
+      def generate_migration
+        migration_template "migrations/create_model.rb", "db/migrate/create_#{table_name}", {:assigns => {:name => name, :table_name => table_name}}
+      end
+
+      def generate_initializer
+        template "initializers/opinio.erb", "config/initializers/opinio.rb"
+      end
+
+      def generate_route
+        route "opinio_model"
+      end
+
+      def self.next_migration_number(dirname)
+        if ActiveRecord::Base.timestamped_migrations
+          Time.now.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+    end
+  end
+end 

data/lib/generators/opinio/install/templates/initializers/opinio.erb

@@ -0,0 +1,8 @@
+# Opinio Configuration
+
+Opinio.setup do |config|
+
+  # Use this to change the class that calls +opinio+ method 
+  config.model_name = "<%= class_name %>"
+
+end

data/lib/generators/opinio/install/templates/migrations/create_model.rb

@@ -0,0 +1,13 @@
+class Create<%= table_name.camelize %> < ActiveRecord::Migration
+  def self.up
+    create_table :<%= table_name %> do |t|
+      t.opinio
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :<%= table_name %>
+  end
+end

data/lib/generators/opinio/install/templates/models/model.rb

@@ -0,0 +1,3 @@
+class <%= class_name %> < ActiveRecord::Base
+  opinio
+end

data/lib/generators/opinio/views/views_generator.rb

@@ -0,0 +1,13 @@
+module Opinio
+  module Generators
+    class ViewsGenerator < Rails::Generators::Base
+
+      source_root File.expand_path('../../../../../app/views', __FILE__)
+
+      def copy_views
+        directory "opinio", "app/views/opinio"
+      end
+
+    end
+  end
+end 

data/lib/opinio.rb

@@ -0,0 +1,55 @@
+module Opinio
+  #autoload :Railtie, 'opinio/railtie'
+  autoload :Schema, 'opinio/schema'
+
+  module Controllers
+    autoload :Helpers, 'opinio/controllers/helpers'
+    autoload :InternalHelpers, 'opinio/controllers/internal_helpers'
+    autoload :Replies, 'opinio/controllers/replies'
+  end
+
+  mattr_accessor :model_name
+  @@model_name = "Comment"
+
+  mattr_accessor :owner_class_name
+  @@owner_class_name = "User"
+
+  mattr_accessor :use_title
+  @@use_title = false
+
+  mattr_accessor :accept_replies
+  @@accept_replies = false
+
+  mattr_accessor :custom_identifiers
+  @@custom_identifiers = Array.new
+
+  mattr_accessor :interval_between_comments
+  @@interval_between_comments = false
+
+  mattr_accessor :destroy_conditions
+  @@destroy_conditions = Proc.new { true }
+
+  def self.setup
+    yield self
+  end
+
+  def self.opinio_identifier(block)
+    @@custom_identifiers << block
+  end
+
+  def self.set_destroy_conditions(&block)
+    @@destroy_conditions = block
+  end
+
+  def self.check_custom_identifiers(params)
+    self.custom_identifiers.each do |idf|
+      ret = idf.call(params)
+      return ret unless ret.nil?
+    end
+    nil
+  end
+
+  require File.join(File.dirname(__FILE__), 'opinio', 'railtie')
+  require File.join(File.dirname(__FILE__), 'opinio', 'rails')
+  require File.join(File.dirname(__FILE__), 'opinio', 'orm', 'active_record')
+end

data/lib/opinio/controllers/extensions.rb

@@ -0,0 +1,27 @@
+module Opinio
+  module Controllers
+    module Extensions
+      extend ActiveSupport::Concern
+
+      included do
+        (class << self; self; end).instance_eval do
+          define_method "#{Opinio.model_name.underscore}_destroy_conditions" do |&block|
+            Opinio.set_destroy_conditions( &block )
+          end
+        end
+      end
+
+      module ClassMethods
+        def opinio_identifier(&block)
+          Opinio.opinio_identifier(block)
+        end
+      end
+
+      module InstanceMethods
+        def can_destroy_opinio?(opinio)
+          self.instance_exec(opinio, &Opinio.destroy_conditions)
+        end
+      end
+    end
+  end
+end

data/lib/opinio/controllers/helpers.rb

@@ -0,0 +1,22 @@
+module Opinio
+  module Controllers
+    module Helpers
+
+      def comments_for(object, options = {})        
+        render_comments(object, options) +
+        ( render_comments_form(object, options) unless options[:no_new] ).to_s
+      end
+
+      def render_comments(object, options = {})
+        limit = options.delete(:limit) || Opinio.model_name.constantize.default_per_page
+        render( :partial => "opinio/comments/comments", :locals => {:comments => object.comments.page(1).limit(limit), :commentable => object, :options => options} )
+      end
+
+      def render_comments_form(object, options = {})
+        render( :partial => "opinio/comments/new", :locals => {:commentable => object, :options => options} )
+      end
+    end
+    
+  end
+  
+end

data/lib/opinio/controllers/internal_helpers.rb

@@ -0,0 +1,33 @@
+module Opinio
+  module Controllers
+    module InternalHelpers
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :resource, :resource_name
+      end
+
+      def resource
+        @resource ||= custom_resource_identifier(params) || resource_by_params 
+      end
+
+      def resource_by_params
+        if params[:commentable_type]
+          params[:commentable_type].constantize.find(params[:commentable_id])
+        elsif params[:comment]
+          params[:comment][:commentable_type].constantize.find(params[:comment][:commentable_id])
+        else
+          raise "Unable to determine comments holder"
+        end
+      end
+
+      def custom_resource_identifier(params)
+        Opinio.check_custom_identifiers(params)
+      end
+
+      def resource_name
+        Opinio.model_name
+      end
+    end
+  end
+end

data/lib/opinio/controllers/replies.rb

@@ -0,0 +1,23 @@
+module Opinio
+  module Controllers
+    module Replies
+      extend ActiveSupport::Concern
+
+      included do
+        before_filter :check_reply, :only => [:create]
+      end
+
+      def reply
+        @commentable_type = Opinio.model_name
+        @commentable_id   = params[:id]
+        @commentable      = Opinio.model_name.constantize.find(params[:id])
+      end
+
+      private
+
+      def check_reply
+        @reply = params[:commentable_type] == Opinio.model_name
+      end
+    end
+  end
+end

data/lib/opinio/opinio_model.rb

@@ -0,0 +1,112 @@
+module Opinio
+  module OpinioModel
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+    
+      # Adds the Opinio functionallity to the model
+      # You can pass a hash of options to customize the Opinio model
+      #
+      # === Options
+      #
+      # [:belongs_to]
+      #   You can specify the class that owns the comments on
+      #   +config/initializers/opinio.rb+
+      #   but you can also pass it explicitly here:
+      #   eg. <tt>:belongs_to => "Admin"</tt>
+      # [:counter_cache]
+      #   Customize the counter cache here, defaults to false
+      # [:body_length]
+      #   You can pass a <tt>Range</tt> to determine the size of the body that will be
+      #   validated
+      # [:title_length]
+      #   If you are using titles in your opinio model (set on the
+      #   initializer) you can pass a <tt>Range</tt> so it is validated.
+      def opinio(*args)
+        return if self.included_modules.include?(Opinio::OpinioModel::InstanceMethods)
+        options = args.extract_options!
+
+        if Opinio.use_title
+          attr_accessible :title 
+          validates       :title,
+                          {}.merge( :length => options[:title_length] )
+        end
+        attr_accessible :body
+
+        commentable_options = { :polymorphic => true }
+        if options[:counter_cache]
+          commentable_options.merge!(:counter_cache => options[:counter_cache])
+        end
+
+        belongs_to :commentable, commentable_options
+        belongs_to :owner, :class_name => options.reverse_merge(:belongs_to => Opinio.owner_class_name)[:belongs_to]
+
+        #TODO: refactor this
+        if Opinio.interval_between_comments
+          validate :last_comment_time, :if => :new_record?
+          cattr_accessor :comments_interval
+          self.comments_interval = options.reverse_merge(:time => Opinio.interval_between_comments)[:time]
+        end
+
+        extra_options = {}
+        if options[:body_length]
+          extra_options = { :length => options[:body_length] }
+        end
+
+        validates :body,
+                  { :presence => true }.reverse_merge(extra_options)
+
+        validates_presence_of :commentable
+
+        scope :owned_by, lambda {|owner| where('owner_id = ?', owner.id) }
+
+        send :include, Opinio::OpinioModel::InstanceMethods
+
+        if Opinio.accept_replies
+          validate :cannot_be_comment_of_a_comments_comment
+          opinio_subjectum :order => 'created_at ASC'
+        end
+
+      end
+    end
+
+    module InstanceMethods
+
+      private
+
+      # Checks the time of the last comment
+      # made by the same owner
+      def last_comment_time
+        last_comment = Comment.owned_by(self.owner).order('created_at DESC').last
+        if last_comment
+          if (Time.now - last_comment.created_at).round >= self.comments_interval
+            true
+          else
+            errors.add(
+              :created_at,
+              I18n.t('opinio.comment_interval',
+                     :time => self.comments_interval,
+                     :default => "You must wait %{time} seconds to comment again.")
+            )
+            false
+          end
+        else
+          true
+        end
+      end
+
+      # Validates that you cannot comment on a comment's comment
+      def cannot_be_comment_of_a_comments_comment
+        if new_record? && self.commentable_type == Opinio.model_name
+          if commentable.commentable_type == Opinio.model_name
+            errors.add :base, I18n.translate('opinio.cannot_be_comment_of_comment', :default => 'Cannot reply another comment\'s reply')
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/opinio/opinio_subjectum.rb

@@ -0,0 +1,28 @@
+module Opinio
+  module OpinioSubjectum
+  
+    def self.included(base)
+      base.extend         ClassMethods
+    end
+  
+    module ClassMethods
+      def opinio_subjectum(*args)
+        options = args.extract_options!
+
+        has_many :comments,
+                 :class_name => Opinio.model_name,
+                 :as => :commentable,
+                 :order => options.reverse_merge(:order => "created_at DESC")[:order],
+                 :dependent => :destroy
+
+
+        send :include, Opinio::OpinioSubjectum::InstanceMethods
+      end
+    end
+  
+    module InstanceMethods
+  
+    end
+  
+  end
+end

data/lib/opinio/orm/active_record.rb

@@ -0,0 +1,19 @@
+require 'active_record/connection_adapters/abstract/schema_definitions'
+
+module Opinio
+  module Orm
+    module ActiveRecord
+      module Schema
+        include Opinio::Schema
+        # Tell how to apply schema methods.
+        def apply_opinio_schema(name, type, options={})
+          column name, type.to_s.downcase.to_sym, options
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::Table.send :include, Opinio::Orm::ActiveRecord::Schema
+ActiveRecord::ConnectionAdapters::TableDefinition.send :include, Opinio::Orm::ActiveRecord::Schema
+

data/lib/opinio/rails.rb

@@ -0,0 +1,8 @@
+require File.join(File.dirname(__FILE__), 'rails', 'routes')
+
+module Opinio
+  class Engine < ::Rails::Engine
+
+  end
+end
+

data/lib/opinio/rails/routes.rb

@@ -0,0 +1,20 @@
+module ActionDispatch::Routing
+  class Mapper
+    def opinio(*args)
+      options       = args.extract_options!.symbolize_keys
+      route_name    = options[:path_name] || Opinio.model_name.pluralize.downcase
+      options[:controller] ||= 'opinio/comments'
+
+      get "#{ route_name }(/:page)" => "#{options[:controller].to_s}#index", :as => :comments 
+    end
+
+    def opinio_model(*args)
+      options = args.extract_options!
+      options[:controller] ||= 'opinio/comments'
+      resources :comments, :controller => options[:controller] do
+        get 'reply', :on => :member if Opinio.accept_replies
+      end
+    end
+
+  end
+end

data/lib/opinio/railtie.rb

@@ -0,0 +1,22 @@
+require 'rails'
+
+module Opinio
+  class Railtie < ::Rails::Railtie #:nodoc:
+    initializer 'opinio' do |app|
+      ActiveSupport.on_load(:active_record) do
+        require File.join(File.dirname(__FILE__), 'opinio_model')
+        require File.join(File.dirname(__FILE__), 'opinio_subjectum')
+        ::ActiveRecord::Base.send :include, Opinio::OpinioModel
+        ::ActiveRecord::Base.send :include, Opinio::OpinioSubjectum
+      end
+      ActiveSupport.on_load(:action_view) do
+        require File.join(File.dirname(__FILE__), 'controllers', 'helpers')
+        ::ActionView::Base.send :include,   Opinio::Controllers::Helpers
+      end
+      ActiveSupport.on_load(:action_controller) do
+        require File.join(File.dirname(__FILE__), 'controllers', 'extensions')
+        ::ActionController::Base.send :include,   Opinio::Controllers::Extensions
+      end
+    end
+  end
+end

data/lib/opinio/schema.rb

@@ -0,0 +1,21 @@
+module Opinio
+  module Schema
+
+    def opinio(options = {})
+      null    = options[:null] || false
+      default = options.key?(:default) ? options[:default] : ("" if null == false)
+
+      apply_opinio_schema :owner_id, :integer, :null => false
+      apply_opinio_schema :commentable_id, :integer, :null => false
+      apply_opinio_schema :commentable_type, :string, :null => false
+      apply_opinio_schema :title, :string, :default => default, :null => null if options[:title]
+      apply_opinio_schema :body, :text, :null => false
+    end
+
+    # Overwrite with specific modification to create your own schema.
+    def apply_opinio_schema(name, type, options={})
+      raise NotImplementedError
+    end
+    
+  end
+end

data/lib/opinio/version.rb

@@ -0,0 +1,5 @@
+module Opinio
+  class Version
+    VERSION = '0.3.0'
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: opinio
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
+platform: ruby
+authors:
+- Luiz Felipe Garcia Pereira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-06-09 00:00:00.000000000 -03:00
+default_executable: 
+dependencies: []
+description: Opinio is an engine used to add comments functionallity to rails 3 applications.
+email:
+- luiz.felipe.gp@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/controllers/opinio/comments_controller.rb
+- app/views/opinio/comments/_comment.html.erb
+- app/views/opinio/comments/_comments.html.erb
+- app/views/opinio/comments/_new.html.erb
+- app/views/opinio/comments/create.js.erb
+- app/views/opinio/comments/destroy.js.erb
+- app/views/opinio/comments/index.html.erb
+- app/views/opinio/comments/reply.js.erb
+- lib/generators/opinio/install/install_generator.rb
+- lib/generators/opinio/install/templates/initializers/opinio.erb
+- lib/generators/opinio/install/templates/migrations/create_model.rb
+- lib/generators/opinio/install/templates/models/model.rb
+- lib/generators/opinio/views/views_generator.rb
+- lib/opinio/controllers/extensions.rb
+- lib/opinio/controllers/helpers.rb
+- lib/opinio/controllers/internal_helpers.rb
+- lib/opinio/controllers/replies.rb
+- lib/opinio/opinio_model.rb
+- lib/opinio/opinio_subjectum.rb
+- lib/opinio/orm/active_record.rb
+- lib/opinio/rails/routes.rb
+- lib/opinio/rails.rb
+- lib/opinio/railtie.rb
+- lib/opinio/schema.rb
+- lib/opinio/version.rb
+- lib/opinio.rb
+- MIT-LICENSE
+- Rakefile
+- Gemfile
+- README.rdoc
+has_rdoc: true
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A rails 3 engine for comments.
+test_files: []