opinio-bootstrap 0.6.0.2

data/Gemfile

@@ -0,0 +1,31 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem "kaminari"
+gem "rails", "~> 3.0.0"
+gem "sqlite3"
+gem "jquery-rails"
+
+group :development do
+  platforms :mri_19 do
+    gem "debugger"
+  end
+  gem 'guard-rspec'
+  if RUBY_PLATFORM =~ /darwin/i
+    gem 'rb-fsevent'
+    gem 'growl'
+  end
+end
+
+group :test do
+  gem "cucumber"
+  gem "cucumber-rails"
+  gem "capybara"
+  gem "launchy"
+  gem "database_cleaner"
+  gem "rspec-rails", :git => "https://github.com/rspec/rspec-rails.git", :tag => "v2.12.2"
+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.md

@@ -0,0 +1,197 @@
+# Opinio-Bootstrap #
+
+## Description ##
+
+This is a fork of Luiz Pereira's great [Opinio](https://github.com/Draiken/opinio) gem for Rails 3+.
+
+It intends to simply utilize [Twitter Bootstrap](http://twitter.github.com/bootstrap/) styling in views out-of-the-box.
+
+In particular, it utilizes the media-object component.  
+
+Currently it requires an image_url(:thumb) method (the default for [Carrierwave](https://github.com/jnicklas/carrierwave)) for your User object; If you are set up with Bootstrap and are storing an image on the User, styling will automatically include the User's avatar along with a link to the user, along with the comment and associated links.  
+
+So you need a valid call to
+
+    @user.image_url(:thumb).to_s
+    
+for the avatar image (media object).
+
+To do: make dynamic the method by which User's image is called; provide a default stock placeholder image for those not utilizing an image mounting system for their User object (e.g. Carrierwave/Paperclip).
+
+Make sure Bootstrap is in your Rails *Gemfile*:
+
+    gem "bootstrap-sass", ">= 2.2.2.0"
+    
+The remainder of this page is [Opinio](https://github.com/Draiken/opinio)'s original README.
+
+## Original ##
+
+**IMPORTANT** Version 0.6 might break some behaviour from 0.5 and lower versions, please refer to the [changelog](https://github.com/Draiken/opinio/blob/master/CHANGELOG.rdoc)
+
+## 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
+
+## 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 act as the comment
+in your app.
+
+In order to add the comments functionality 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 commentable resource
+
+    resources :posts do
+      opinio
+    end
+
+To render the comments in your views, there is a helper to display the resource's comments easily:
+
+    <%= comments_for @post %>
+
+This will render the comments and a form for new comment submissions. Alternatively you can render just the comments or just the form like this:
+
+    <%= render_comments @post %>
+    <%= render_comments_form @post %>
+
+If you need to render the comments with a specific page or limit
+you can use Kaminari's configurations like `paginates_per 10` on your comment model
+or you can customize it for specific views on the helpers
+
+    <%= render_comments @post, :page => params[:page], :limit => 5 %>
+
+This options can also be used on the `comments_for` helper.
+
+## 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 ###
+
+#### Opinio Model ####
+
+You can customize the opinio model to suit your needs. The basic customization is the owner class name. It defaults to `User` but you can change that in the initializer or in the model by passing the `:owner_class_name => "MyOwnerClass"` option to the `opinio_model` method call.
+
+Another customization you can do is set the `counter_cache` to true in the commentable model. You can use the `:counter_cache` option for that.
+
+The other two customizations are only made through the initializer, and they are the `accept_replies` which defaults to true and `strip_html_tags_on_save` which also defaults to `true`.
+
+Validations on the opinio model are very basic, just ensuring it has a body, a commentable and an owner, if you want any other kind of validation, like the minimum size of a comment, you can use the regular AR validations as you wish.
+
+Remember that if you use titles, you need to add that to your comments table, since the generator doesn't add it by default.
+
+#### Opinio Subjectum ####
+
+To change how the models that actually have the comments, you can customize them with any option you would use to a regular `has_many` relationship in ActiveRecord.
+
+The default options are these:
+
+      has_many :comments,
+               :class_name => Opinio.model_name,
+               :as => :commentable,
+               :order => "created_at #{Opinio.sort_order}"),
+               :dependent => :destroy
+
+The `sort_order` and `model_name` are both setup in the initializer. Here you can do things like, let's say you have moderation in your comments, you can only show the approved comments:
+
+    opinio_subjectum :conditions => ["approved = ?", true]
+
+Remember you can override any of these options (except `as`) by passing them to the `opinio_subjectum` method.
+
+#### Pretty Urls ####
+
+Often times you will want the engine to show the index of comments for a specific item
+without having to pass the `:commentable_type` or `:commentable_id` parameters.
+
+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, noone can destroy a comment in the engine. You have to tell the engine who can do it.
+To setup a custom destroy condition use the methods provided by opinio
+in our controllers. For instance, if our opinio model is called 'comment' 
+it could be written 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.
+
+### Testing ###
+
+Opinio provides a few shared examples for testing of your model with rspec
+On your opinio model test case you can require opinio's shared examples and use them
+
+    require 'opinio/shared_examples'
+
+    describe Comment do
+      it_should_behave_like :opinio
+    end
+
+    describe Post do
+      it_should_behave_like :opinio_subjectum
+    end
+
+## 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)
+
+### TODO ###
+
+  * Refactor the `comments_for` helper
+  * Extract documentation to wiki
+  * Add mongoid support

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 'rdoc/task'
+
+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,47 @@
+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 = send(Opinio.current_user_method)
+    if @comment.save
+      flash_area = :notice
+      message = t('opinio.messages.comment_sent')
+    else
+      flash_area = :error
+      message = t('opinio.messages.comment_sending_error')
+    end
+
+    respond_to do |format|
+      format.js
+      format.html do
+        set_flash(flash_area, message)
+        redirect_to(opinio_after_create_path(resource))
+      end
+    end
+  end
+
+  def destroy
+    @comment = Opinio.model_name.constantize.find(params[:id])
+
+    if can_destroy_opinio?(@comment)
+      @comment.destroy
+      set_flash(:notice, t('opinio.messages.comment_destroyed'))
+    else
+      #flash[:error]  = I18n.translate('opinio.comment.not_permitted', :default => "Not permitted")
+      logger.warn "user #{send(Opinio.current_user_method)} tried to remove a comment from another user #{@comment.owner.id}"
+      render :text => "unauthorized", :status => 401 and return
+    end
+
+    respond_to do |format|
+      format.js
+      format.html { redirect_to( opinio_after_destroy_path(@comment) ) }
+    end
+  end
+  
+end

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

@@ -0,0 +1,20 @@
+<% reply = defined?(reply) ? reply : false %>
+<div id="comment_<%= comment.id %>" class="media">
+<a class="pull-left" href="<%= user_path(comment.owner) %>">
+  <img class="media-object" src="<%= comment.owner.image_url(:thumb).to_s %>" />
+  <span><%= comment.owner.name.titlecase %></span>
+  </a>
+  <div class="media-body">
+    <%= simple_format(comment.body) %>
+  <% if comment.owner == send(Opinio.current_user_method) %>
+  <%= link_to t('opinio.actions.delete'), comment_path(comment), :method => :delete, :remote => true %>
+  <% end %>
+  <%# this enables only 1 level of replies %>
+  <% if Opinio.accept_replies && !reply && !(comment.owner == current_user) %>
+    <span><%= link_to t('opinio.actions.reply'), reply_comment_path(comment), :remote => true %></span>
+  <% end %>
+  <div id="comment_<%= comment.id %>_replies" class="replies media">
+    <%= render :partial => "opinio/comments/comment", :collection => comment.comments, :locals => {:reply => true} %>
+  </div>
+  </div>
+</div>

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

@@ -0,0 +1,12 @@
+<div>
+  <%= paginate comments %>
+</div>
+  <% unless comments.empty? %>
+    <%= render :partial => 'opinio/comments/comment', :collection => comments %>
+  <% else %>
+    <h3><%= t('opinio.messages.no_comments_found') %></h3>
+  <% end %>
+
+<div>
+  <%= paginate comments %>
+</div>

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

@@ -0,0 +1,19 @@
+<div id="new_comment">
+  <% if send(Opinio.current_user_method) %>
+    <h3 class="addcomment"><%= t('opinio.messages.add_comment') %></h3>
+    <%= form_for Comment.new, :remote => false do |f| %>
+      <p>
+        <%= f.text_area :body, :placeholder => "Enter comment...", rows:"10" %>
+      </p>
+      <%= hidden_field_tag :commentable_id, commentable.id %>
+      <%= hidden_field_tag :commentable_type, commentable.class.base_class.name.to_s %>
+        <%= hidden_field_tag :original_controller, params[:controller] %>
+        <%= hidden_field_tag :original_id, params[:id] %>
+      <%= f.submit t('opinio.actions.add') %>
+    <% end %>
+  <% else %>
+    <p>
+      <%= t('opinio.messages.must_be_logged_in_to_comment') %>
+    </p>
+  <% end %>
+</div>

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

@@ -0,0 +1,16 @@
+$('#no_comments').hide();
+<% if @comment.valid? %>
+  <% if @reply %>
+    if($('#comment_<%= @comment.commentable_id %> ul').length == 0)
+      $('#comment_<%= @comment.commentable_id %>').append('<ul id="comment_<%= @comment.commentable_id %>_replies" class="replies"></ul>');
+    $('#comment_<%= @comment.commentable_id %>_replies').append("<%= escape_javascript( render @comment, :locals => {:reply => @reply} ) %>");
+    $('#commentable_id').val('<%= @comment.commentable.commentable_id %>');
+    $('#commentable_type').val('<%= @comment.commentable.commentable_type %>');
+  <% else %>
+    $('#comments').<%= Opinio.sort_order == 'ASC' ? 'append' : 'prepend'%>("<%= escape_javascript( render @comment, :locals => {:reply => @reply} ) %>");
+  <% end %>
+  $('textarea#comment_body').val('');
+<% else %>
+  $('#comments').prepend("<%= escape_javascript(flash[:notice]) %>");
+  $('#comments').prepend("<%= escape_javascript(flash[:error]) %>");
+<% 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><%= t('opinio.messages.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,6 @@
+<% @comment = Comment.find(@commentable_id) %>
+$("#commentable_id").val('<%= @commentable_id %>');
+$("#commentable_type").val('<%= @commentable_type %>');
+$("#new_comment textarea").val('');
+$("#new_comment h3.addcomment").text('Replying to <%= @comment.owner.name.titlecase %>');
+$("#new_comment textarea").focus();

data/config/locales/opinio.en.yml

@@ -0,0 +1,16 @@
+en:
+  opinio:
+    actions:
+      delete: 'Delete'
+      reply: 'Reply'
+      add: 'Add comment'
+    messages:
+      no_comments_found: 'No comments found'
+      must_be_logged_in_to_comment: 'Must be logged in to comment.'
+      add_comment: 'Add comment'
+      comments: 'Comments'
+      comment_sent: 'Comment sent successfully.'
+      comment_sending_error: 'Error while sending the comment.'
+      comment_destroyed: 'Comment removed successfully.'
+      comment_interval: 'You must wait %{time} seconds to comment again.'
+      cannot_be_comment_of_comment: "Cannot reply another comment's reply"

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

@@ -0,0 +1,38 @@
+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 add_dependency_gem
+        gem "kaminari"
+      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,28 @@
+# Opinio Configuration
+
+Opinio.setup do |config|
+
+  # Use this to change the class that calls +opinio+ method 
+  config.model_name = "<%= class_name %>"
+
+  # This is the owner class of the comment (opinio model)
+  # config.owner_class_name = "User"
+
+  # Change this if you do not want to allow replies on your comments
+  # config.accept_replies = true
+  
+  # Here you can change the method called to check who is the current user
+  # config.current_user_method = :current_user
+
+  # Strip html tags on save comment
+  config.strip_html_tags_on_save = true
+
+  # Comments sort order by created_at (DESC or ASC)
+  # Note: you can override that easily within each opinio subjectum
+  config.sort_order = 'DESC'
+
+  # Wether or not the default opinio controller should set the flash
+  # when creating/removing comments
+  config.set_flash = true
+
+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,27 @@
+module Opinio
+  module Generators
+    class ViewsGenerator < Rails::Generators::Base
+
+      source_root File.expand_path('../../../../../app/views/opinio/comments', __FILE__)
+
+      class_option :haml, :desc => 'Generate HAML views instead of ERB.', :type => :boolean
+
+      def copy_views
+        html_names = ["_comment", "_comments", "_new", "index"]
+        js_names = ["create", "destroy", "reply"]
+        html_names.each do |name|
+          copy_file "#{name}.html.#{view_language}", "app/views/opinio/comments/#{name}.html.#{view_language}"
+        end
+        js_names.each do |name|
+          copy_file "#{name}.js.erb", "app/views/opinio/comments/#{name}.js.erb"
+        end
+      end
+
+      def view_language
+        options.haml? ? 'haml' : 'erb'
+      end
+
+
+    end
+  end
+end 

data/lib/opinio.rb

@@ -0,0 +1,66 @@
+module Opinio
+  require 'opinio/schema'
+
+  module Controllers
+    require 'opinio/controllers/helpers'
+    require 'opinio/controllers/internal_helpers'
+    require 'opinio/controllers/replies'
+  end
+
+  require 'opinio/railtie'
+  require 'opinio/rails'
+  require 'opinio/orm/active_record'
+
+  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 { false }
+
+  mattr_accessor :current_user_method
+  @@current_user_method = :current_user
+
+  mattr_accessor :strip_html_tags_on_save
+  @@strip_html_tags_on_save = true
+
+  mattr_accessor :sort_order
+  @@sort_order = 'DESC'
+
+  mattr_accessor :set_flash
+  @@set_flash = 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 |identifier|
+      identified = identifier.call(params)
+      return identified unless identified.nil?
+    end
+    nil
+  end
+end

data/lib/opinio/controllers/extensions.rb

@@ -0,0 +1,39 @@
+module Opinio
+  module Controllers
+    module Extensions
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.send :include, InstanceMethods
+
+        base.class_eval 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
+      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
+
+        def opinio_after_create_path(resource)
+          resource.is_a?(Opinio.model_name.constantize) ? resource.commentable : resource
+        end
+
+        def opinio_after_destroy_path(comment)
+          comment.commentable
+        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
+        page  = options.delete(:page)  || 1
+        render( :partial => "opinio/comments/comments", :locals => {:comments => object.comments.page(page).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,37 @@
+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
+
+      def set_flash(name, message)
+        flash[name] = message if Opinio.set_flash
+      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,77 @@
+require 'opinio/opinio_model/validations'
+
+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
+      def opinio(*args)
+        return if self.included_modules.include?(Opinio::OpinioModel::Validations)
+        options = args.extract_options!
+
+        if Opinio.use_title
+          attr_accessible :title 
+        end
+        attr_accessible :body
+
+        belongs_to :commentable, :polymorphic => true, :counter_cache => options.fetch(:counter_cache, false) 
+        belongs_to :owner, :class_name => options.fetch(:owner_class_name, Opinio.owner_class_name)
+
+        scope :owned_by, lambda {|owner| where('owner_id = ?', owner.id) }
+
+        send :include, Opinio::OpinioModel::Validations
+
+        if Opinio.accept_replies
+          send :include, RepliesSupport
+        end
+
+        if Opinio.strip_html_tags_on_save
+          send :include, Sanitizing
+        end
+
+      end
+    end
+
+    module Sanitizing
+      def self.included(base)
+        base.class_eval do
+          send :include, ActionView::Helpers::SanitizeHelper
+          before_save :strip_html_tags
+        end
+      end
+
+      private
+
+      def strip_html_tags
+        self.body = strip_tags(self.body)
+      end
+    end
+
+    module RepliesSupport
+      def self.included(base)
+        base.class_eval do
+          validate :cannot_be_comment_of_a_comments_comment
+          opinio_subjectum :order => 'created_at ASC'
+        end
+      end
+
+      private
+
+      # 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.t('opinio.messages.cannot_be_comment_of_comment')
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/opinio/opinio_model/validations.rb

@@ -0,0 +1,50 @@
+module Opinio
+  module OpinioModel
+    module Validations
+
+      extend ActiveSupport::Concern
+
+      included do
+
+        #TODO: refactor this
+        if Opinio.interval_between_comments
+          include Opinio::OpinioModel::Validations::IntervalMethods
+          validate :validate_last_comment_time, :if => :new_record?
+          cattr_accessor :comments_interval
+          self.comments_interval = options.reverse_merge(:time => Opinio.interval_between_comments)[:time]
+        end
+
+        validates :body, :presence => true
+        validates :commentable, :presence => true
+        validates :owner, :presence => true, :associated => true
+
+      end
+
+
+      module IntervalMethods
+
+        private
+
+        # Checks the time of the last comment
+        # made by the same owner
+        def validate_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.translate('opinio.messages.comment_interval',
+                                        :time => self.comments_interval))
+              false
+            end
+          else
+            true
+          end
+        end
+
+      end # IntervalMethods
+
+    end # Validations
+  end # OpinioModel
+end # Opinio

data/lib/opinio/opinio_subjectum.rb

@@ -0,0 +1,24 @@
+module Opinio
+  module OpinioSubjectum
+  
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  
+    module ClassMethods
+      def opinio_subjectum(*args)
+        options = args.extract_options!
+        options.delete(:as)
+
+        default_options = { :class_name => Opinio.model_name,
+                            :as => :commentable,
+                            :order => "created_at #{Opinio.sort_order}",
+                            :dependent => :destroy }
+
+        has_many :comments, default_options.merge(options)
+
+      end
+    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, options 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/shared_examples.rb

@@ -0,0 +1,89 @@
+shared_examples_for :opinio do
+
+  let(:comment) { Comment.new }
+  let(:owner) { User.create }
+
+  before(:all) do
+    @post = Post.new(:title => "My first post", :body => "Damn I really suck at writing")
+    @post.save
+  end
+
+  it "should have the correct attributes" do
+    should respond_to(:owner)
+    should respond_to(:body)
+    should respond_to(:commentable)
+  end
+
+
+  it "should not allow comments of comments" do
+    Comment.class_eval do
+      include Opinio::OpinioModel::RepliesSupport
+    end
+
+    c = Comment.new(:body => "The Comment !")
+    c.commentable = @post
+    c.owner = owner
+    c.save.should == true
+
+    c2 = Comment.new(:body => "The Comment !")
+    c2.owner = owner
+    c2.commentable = c
+    c2.save.should == true
+
+    c3 = c2.dup
+    c3.commentable = c2
+    c3.save.should == false
+
+    c3.errors[:base].count.should == 1
+  end
+
+  it "should validate presence of body and commentable" do
+    comment.should be_invalid
+    comment.errors[:body].should be_present
+    comment.errors[:commentable].should be_present
+  end
+
+  it "and it should insist on having an owner" do
+    c = Comment.new(:body => "The Comment !")
+    c.commentable = @post
+    c.save.should == false
+  end
+
+  context "when strip_html_tags_on_save is true" do
+    it "should strip html tags" do
+      comment = create_valid_comment('<h1>Chuck will save us!</h1>')
+      comment.body.should == 'Chuck will save us!'
+    end
+  end
+
+  context "when strip_html_tags_on_save is false" do
+    
+    # we have to create a different class
+    # because opinio adds the strip tags callbacks
+    # only once when opinio is called on the class
+    class NoSanitizerComment < ActiveRecord::Base
+      self.table_name = :comments
+    end
+
+    before do
+      Opinio.stub(:strip_html_tags_on_save).and_return(false)
+      NoSanitizerComment.class_eval do
+        opinio
+      end
+    end
+    it "should not strip html tags" do
+      comment = create_valid_comment('<h1>Chuck will save us!</h1>', NoSanitizerComment)
+      comment.body.should == '<h1>Chuck will save us!</h1>'
+    end
+  end
+
+end
+
+
+shared_examples_for :opinio_subjectum do
+
+  it "and should add opinio_subjectum functionallity" do
+    should respond_to(:comments)
+  end
+
+end

data/lib/opinio/version.rb

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

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: opinio-bootstrap
+version: !ruby/object:Gem::Version
+  version: 0.6.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Luiz Felipe Garcia Pereira
+- Richard Carey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: kaminari
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jquery-rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bootstrap-sass
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.2.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.2.2.0
+description: Opinio is an engine used to add comments functionallity to rails 3 applications;
+  this version is adapted to Twitter Bootstrap.
+email:
+- luiz.felipe.gp@gmail.com
+- rc@rcdmcg.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/validations.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/shared_examples.rb
+- lib/opinio/version.rb
+- lib/opinio.rb
+- config/locales/opinio.en.yml
+- MIT-LICENSE
+- Rakefile
+- Gemfile
+- README.md
+homepage: https://github.com/rceee/opinio-bootstrap
+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.8.24
+signing_key: 
+specification_version: 3
+summary: A rails 3 engine for comments, with Twitter Bootstrap styling.
+test_files: []