opinio 0.5 → 0.6

data/README.rdoc

@@ -1,6 +1,8 @@
 = Opinio 
 {}[http://travis-ci.org/Draiken/opinio.png]
 
+*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.
@@ -16,12 +18,6 @@ and run:
 
   bundle
 
-== Documentation
-
-Rdocs here:
-  http://rubydoc.info/github/Draiken/opinio/master/frames
-
-
 == Usage
 
 Opinio provides generators to facilitate it's usage.
@@ -39,19 +35,17 @@ In order to add the comments functionality to a model, you use the *opinio_subje
     opinio_subjectum
   end
 
-On the +routes.rb+ you should simply add an +opinio+ for your resource that will have comments
+On the +routes.rb+ you should simply add an +opinio+ for your commentable resource
 
   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:
+To render the comments in your views, there is a helper to display the resource's comments easily:
 
   <%= comments_for @post %>
 
-And there you go, you can now comment in your post.
-
-Alternatively you can render just the comments or just the form like this:
+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 %>
@@ -62,7 +56,7 @@ or you can customize it for specific views on the helpers
 
   <%= render_comments @post, :page => params[:page], :limit => 5 %>
 
-This can also be used on the +comments_for+ helper.
+This options can also be used on the +comments_for+ helper.
 
 == Customization
 
@@ -75,11 +69,40 @@ Of course you will want to customize how the comments are displayed or any other
 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 *:commentable_type* or *:commentable_id*.
+without having to pass the *:commentable_type* or *:commentable_id* parameters.
 
 In order to do that, opinio provides a method to *ActionController::Base*:
 
@@ -102,10 +125,10 @@ 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
+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 would be like this:
+it could be written like this:
 
   comment_destroy_conditions do |comment|
     comment.owner == current_user
@@ -143,7 +166,6 @@ For issues please use the github {issues tracker}[https://github.com/Draiken/opi
 
 === TODO
 
-  * Better controller overriding (coding and documentation)
-  * Support for deeper levels of replies
   * Refactor the +comments_for+ helper
   * Extract documentation to wiki
+  * Add mongoid support

data/app/controllers/opinio/comments_controller.rb

@@ -21,7 +21,7 @@ class Opinio::CommentsController < ApplicationController
       format.js
       format.html do
         set_flash(flash_area, message)
-        redirect_to(resource.is_a?(Opinio.model_name.constantize) ? resource.commentable : resource)
+        redirect_to(opinio_after_create_path(resource))
       end
     end
   end
@@ -40,7 +40,7 @@ class Opinio::CommentsController < ApplicationController
 
     respond_to do |format|
       format.js
-      format.html { redirect_to( @comment.commentable ) }
+      format.html { redirect_to( opinio_after_destroy_path(@comment) ) }
     end
   end
   

data/lib/opinio.rb

@@ -7,6 +7,10 @@ module Opinio
     require 'opinio/controllers/replies'
   end
 
+  require 'opinio/railtie'
+  require 'opinio/rails'
+  require 'opinio/orm/active_record'
+
   mattr_accessor :model_name
   @@model_name = "Comment"
 
@@ -26,7 +30,7 @@ module Opinio
   @@interval_between_comments = false
 
   mattr_accessor :destroy_conditions
-  @@destroy_conditions = Proc.new { true }
+  @@destroy_conditions = Proc.new { false }
 
   mattr_accessor :current_user_method
   @@current_user_method = :current_user
@@ -53,14 +57,10 @@ module Opinio
   end
 
   def self.check_custom_identifiers(params)
-    self.custom_identifiers.each do |idf|
-      ret = idf.call(params)
-      return ret unless ret.nil?
+    self.custom_identifiers.each do |identifier|
+      identified = identifier.call(params)
+      return identified unless identified.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

@@ -25,6 +25,14 @@ module Opinio
         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

data/lib/opinio/opinio_model.rb

@@ -1,3 +1,5 @@
+require 'opinio/opinio_model/validations'
+
 module Opinio
   module OpinioModel
 
@@ -9,73 +11,45 @@ module Opinio
     
       # 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)
+        return if self.included_modules.include?(Opinio::OpinioModel::Validations)
         options = args.extract_options!
 
         if Opinio.use_title
           attr_accessible :title 
-          validates       :title,
-                          {:presence => true}.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
-
-        validates :owner, :presence => true, :associated => true
+        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::InstanceMethods
+        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
 
@@ -84,28 +58,9 @@ module Opinio
         base.validate :cannot_be_comment_of_a_comments_comment
         base.opinio_subjectum :order => 'created_at ASC'
       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.translate('opinio.messages.comment_interval', :time => self.comments_interval))
-            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
@@ -115,10 +70,6 @@ module Opinio
         end
       end
 
-      def strip_html_tags
-        self.body = strip_tags(self.body)
-      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

@@ -2,27 +2,23 @@ module Opinio
   module OpinioSubjectum
   
     def self.included(base)
-      base.extend         ClassMethods
+      base.extend(ClassMethods)
     end
   
     module ClassMethods
       def opinio_subjectum(*args)
         options = args.extract_options!
+        options.delete(:as)
 
-        has_many :comments,
-                 :class_name => Opinio.model_name,
-                 :as => :commentable,
-                 :order => options.reverse_merge(:order => "created_at #{Opinio.sort_order}")[:order],
-                 :dependent => :destroy
+        default_options = { :class_name => Opinio.model_name,
+                            :as => :commentable,
+                            :order => "created_at #{Opinio.sort_order}",
+                            :dependent => :destroy }
 
+        has_many :comments, default_options.merge(options)
 
-        send :include, Opinio::OpinioSubjectum::InstanceMethods
       end
     end
   
-    module InstanceMethods
-  
-    end
-  
   end
 end

data/lib/opinio/shared_examples.rb

@@ -45,6 +45,34 @@ shared_examples_for :opinio do
     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
 
 

data/lib/opinio/version.rb

@@ -1,5 +1,5 @@
 module Opinio
   class Version
-    VERSION = '0.5'
+    VERSION = '0.6'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opinio
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: '0.6'
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-26 00:00:00.000000000Z
+date: 2012-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &2164731680 !ruby/object:Gem::Requirement
+  requirement: &70264667294060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '3'
   type: :runtime
   prerelease: false
-  version_requirements: *2164731680
+  version_requirements: *70264667294060
 - !ruby/object:Gem::Dependency
   name: kaminari
-  requirement: &2164881320 !ruby/object:Gem::Requirement
+  requirement: &70264667286540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2164881320
+  version_requirements: *70264667286540
 - !ruby/object:Gem::Dependency
   name: jquery-rails
-  requirement: &2165159760 !ruby/object:Gem::Requirement
+  requirement: &70264667281340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2165159760
+  version_requirements: *70264667281340
 description: Opinio is an engine used to add comments functionallity to rails 3 applications.
 email:
 - luiz.felipe.gp@gmail.com
@@ -72,6 +72,7 @@ files:
 - 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
@@ -85,8 +86,7 @@ files:
 - config/locales/opinio.en.yml
 - MIT-LICENSE
 - Rakefile
-- Gemfile-rails-3.0.x
-- Gemfile-rails-3.1.x
+- Gemfile
 - README.rdoc
 homepage: 
 licenses: []

data/Gemfile-rails-3.1.x

@@ -1,29 +0,0 @@
-source "http://rubygems.org"
-
-gemspec
-
-gem "kaminari"
-gem "rails", ">= 3.1"
-gem "sqlite3"
-gem "jquery-rails"
-
-group :development do
-  gem "ruby-debug19" if RUBY_VERSION == '1.9.2'
-  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"
-end
-# To use debugger (ruby-debug for Ruby 1.8.7+, ruby-debug19 for Ruby 1.9.2+)
-# gem 'ruby-debug'
-# gem 'ruby-debug19'