commontator 4.5.4 → 4.6.0

data/app/controllers/commontator/subscriptions_controller.rb

@@ -30,3 +30,4 @@ module Commontator
     end
   end
 end
+

data/app/controllers/commontator/threads_controller.rb

@@ -3,14 +3,14 @@ module Commontator
     skip_before_filter :ensure_user, :only => :show
 
     before_filter :get_thread
-    before_filter :set_commontable_url, :only => :show
 
     # GET /threads/1
     def show
       commontator_thread_show(@thread.commontable)
+      @show_all = params[:show_all] && @thread.can_be_edited_by?(@user)
 
       respond_to do |format|
-        format.html { redirect_to commontable_url }
+        format.html { redirect_to main_app.polymorphic_path(@thread.commontable) }
         format.js
       end
     end
@@ -22,6 +22,8 @@ module Commontator
       @thread.errors.add(:base, t('commontator.thread.errors.already_closed')) \
         unless @thread.close(@user)
 
+      @show_all = true
+
       respond_to do |format|
         format.html { redirect_to @thread }
         format.js { render :show }
@@ -35,6 +37,8 @@ module Commontator
       @thread.errors.add(:base, t('commontator.thread.errors.not_closed')) \
         unless @thread.reopen
 
+      @show_all = true
+
       respond_to do |format|
         format.html { redirect_to @thread }
         format.js { render :show }
@@ -42,3 +46,4 @@ module Commontator
     end
   end
 end
+

data/app/helpers/commontator/application_helper.rb

@@ -5,3 +5,4 @@ module Commontator
     end
   end
 end
+

data/app/mailers/commontator/subscriptions_mailer.rb

@@ -19,28 +19,26 @@ module Commontator
       @thread = @comment.thread
       @creator = @comment.creator
 
-      @commontable = @thread.commontable
-      @config = @thread.config
+      @creator_name = Commontator.commontator_name(@creator)
 
-      @creator_name = @creator.commontator_name
+      @commontable_name = Commontator.commontable_name(@thread)
 
-      @commontable_name = @commontable.commontable_name
-
-      @commontable_url = ApplicationController.commontable_url
+      @commontable_url = Commontator.commontable_url(@thread)
 
       params = Hash.new
       params[:comment] = @comment
       params[:thread] = @thread
       params[:creator] = @creator
-      params[:commontable] = @commontable
-      params[:config] = @config
       params[:creator_name] = @creator_name
       params[:commontable_name] = @commontable_name
       params[:commontable_url] = @commontable_url
 
       @to = t('commontator.email.undisclosed_recipients')
-      @bcc = recipients.collect{|s| s.commontator_email(self)}
-      @from = @config.email_from_proc.call(self)
+      @bcc = recipients.collect{|s| Commontator.commontator_email(s, self)}
+      @from = @thread.config.email_from_proc.call(@thread)
     end
+
+    
   end
 end
+

data/app/mailers/commontator/subscriptions_mailer.rb~

@@ -0,0 +1,44 @@
+module Commontator
+  class SubscriptionsMailer < ActionMailer::Base
+    def comment_created(comment, recipients)
+      setup_variables(comment, recipients)
+
+      mail :to => @to,
+           :bcc => @bcc,
+           :from => @from,
+           :subject => t('commontator.email.comment_created.subject',
+                         :creator_name => @creator_name,
+                         :commontable_name => @commontable_name,
+                         :commontable_url => @commontable_url)
+    end
+
+    protected
+
+    def setup_variables(comment, recipients)
+      @comment = comment
+      @thread = @comment.thread
+      @creator = @comment.creator
+
+      @creator_name = Commontator.commontator_name(@creator)
+
+      @commontable_name = Commontator.commontable_name(@thread)
+
+      @commontable_url = Commontator.commontable_url(@thread)
+
+      params = Hash.new
+      params[:comment] = @comment
+      params[:thread] = @thread
+      params[:creator] = @creator
+      params[:creator_name] = @creator_name
+      params[:commontable_name] = @commontable_name
+      params[:commontable_url] = @commontable_url
+
+      @to = t('commontator.email.undisclosed_recipients')
+      @bcc = recipients.collect{|s| Commontator.commontator_email(s, self)}
+      @from = @config.email_from_proc.call(@thread)
+    end
+
+    
+  end
+end
+

data/app/models/commontator/comment.rb

@@ -41,6 +41,11 @@ module Commontator
       votes.where(:voter_type => user.class.name, :voter_id => user.id).first
     end
 
+    def update_cached_votes(vote_scope = nil)
+      self.update_column(:cached_votes_up, count_votes_up(true))
+      self.update_column(:cached_votes_down, count_votes_down(true))
+    end
+
     def is_deleted?
       !deleted_at.blank?
     end
@@ -65,10 +70,8 @@ module Commontator
     end
     
     def updated_timestamp
-      return '' if editor.nil?
-      
       I18n.t 'commontator.comment.status.updated_at',
-             :editor_name => editor.commontator_name,
+             :editor_name => Commontator.commontator_name(editor || creator),
              :updated_at => I18n.l(updated_at, :format => :commontator)
     end
 
@@ -76,20 +79,14 @@ module Commontator
     # Access Control #
     ##################
 
-    def can_be_read_by?(user)
-      return true if thread.can_be_edited_by?(user)
-      (!is_deleted? || !thread.config.hide_deleted_comments) &&\
-      thread.can_be_read_by?(user)
-    end
-
     def can_be_created_by?(user)
       user == creator && user.is_commontator &&\
       !thread.is_closed? && thread.can_be_read_by?(user)
     end
 
     def can_be_edited_by?(user)
-      return true if thread.config.moderators_can_edit_comments &&\
-                     thread.can_be_edited_by?(user)
+      return true if thread.can_be_edited_by?(user) &&\
+                     thread.config.moderator_permissions.to_sym == :e
       comment_edit = thread.config.comment_editing.to_sym
       !thread.is_closed? && !is_deleted? && user == creator &&\
       comment_edit != :n && (is_latest? || comment_edit == :a) &&\
@@ -97,7 +94,10 @@ module Commontator
     end
 
     def can_be_deleted_by?(user)
-      return true if thread.can_be_edited_by?(user)
+      mod_perm = thread.config.moderator_permissions.to_sym
+      return true if thread.can_be_edited_by?(user) &&\
+                     (mod_perm == :e ||\
+                       mod_perm == :d)
       comment_del = thread.config.comment_deletion.to_sym
       !thread.is_closed? && (!is_deleted? || editor == user) &&\
       user == creator && comment_del != :n &&\
@@ -107,7 +107,7 @@ module Commontator
 
     def can_be_voted_on?
       !thread.is_closed? && !is_deleted? &&\
-      thread.config.comment_voting != :n && is_votable?
+      thread.config.comment_voting.to_sym != :n && is_votable?
     end
 
     def can_be_voted_on_by?(user)
@@ -116,3 +116,4 @@ module Commontator
     end
   end
 end
+

data/app/models/commontator/comment.rb~

@@ -0,0 +1,119 @@
+module Commontator
+  class Comment < ActiveRecord::Base
+    belongs_to :creator, :polymorphic => true
+    belongs_to :editor, :polymorphic => true
+    belongs_to :thread
+
+    has_one :commontable, :through => :thread
+
+    validates_presence_of :creator, :on => :create
+    validates_presence_of :editor, :on => :update
+    validates_presence_of :thread
+    validates_presence_of :body
+
+    validates_uniqueness_of :body,
+      :scope => [:creator_type, :creator_id, :thread_id],
+      :message => I18n.t('commontator.comment.errors.double_posted')
+
+    protected
+
+    cattr_accessor :acts_as_votable_initialized
+
+    public
+
+    def is_modified?
+      !editor.nil?
+    end
+
+    def is_latest?
+      thread.comments.last == self
+    end
+
+    def is_votable?
+      return true if acts_as_votable_initialized
+      return false unless self.class.respond_to?(:acts_as_votable)
+      self.class.acts_as_votable
+      self.class.acts_as_votable_initialized = true
+    end
+
+    def get_vote_by(user)
+      return nil unless is_votable? && user && user.is_commontator
+      votes.where(:voter_type => user.class.name, :voter_id => user.id).first
+    end
+
+    def update_cached_votes(vote_scope = nil)
+      self.update_column(:cached_votes_up, count_votes_up(true)
+      self.update_column(:cached_votes_down, count_votes_down(true)
+    end
+
+    def is_deleted?
+      !deleted_at.blank?
+    end
+
+    def delete_by(user)
+      return false if is_deleted?
+      self.deleted_at = Time.now
+      self.editor = user
+      self.save
+    end
+
+    def undelete_by(user)
+      return false unless is_deleted?
+      self.deleted_at = nil
+      self.editor = user
+      self.save
+    end
+
+    def created_timestamp
+      I18n.t 'commontator.comment.status.created_at',
+             :created_at => I18n.l(created_at, :format => :commontator)
+    end
+    
+    def updated_timestamp
+      I18n.t 'commontator.comment.status.updated_at',
+             :editor_name => Commontator.commontator_name(editor || creator),
+             :updated_at => I18n.l(updated_at, :format => :commontator)
+    end
+
+    ##################
+    # Access Control #
+    ##################
+
+    def can_be_created_by?(user)
+      user == creator && user.is_commontator &&\
+      !thread.is_closed? && thread.can_be_read_by?(user)
+    end
+
+    def can_be_edited_by?(user)
+      return true if thread.can_be_edited_by?(user) &&\
+                     thread.config.moderator_permissions.to_sym == :e
+      comment_edit = thread.config.comment_editing.to_sym
+      !thread.is_closed? && !is_deleted? && user == creator &&\
+      comment_edit != :n && (is_latest? || comment_edit == :a) &&\
+      thread.can_be_read_by?(user)
+    end
+
+    def can_be_deleted_by?(user)
+      mod_perm = thread.config.moderator_permissions.to_sym
+      return true if thread.can_be_edited_by?(user) &&\
+                     (mod_perm == :e ||\
+                       mod_perm == :d)
+      comment_del = thread.config.comment_deletion.to_sym
+      !thread.is_closed? && (!is_deleted? || editor == user) &&\
+      user == creator && comment_del != :n &&\
+      (is_latest? || comment_del == :a) &&\
+      thread.can_be_read_by?(user)
+    end
+
+    def can_be_voted_on?
+      !thread.is_closed? && !is_deleted? &&\
+      thread.config.comment_voting.to_sym != :n && is_votable?
+    end
+
+    def can_be_voted_on_by?(user)
+      !user.nil? && user.is_commontator && user != creator &&\
+      thread.can_be_read_by?(user) && can_be_voted_on?
+    end
+  end
+end
+

data/app/models/commontator/subscription.rb

@@ -6,12 +6,16 @@ module Commontator
     validates_presence_of :subscriber, :thread
     validates_uniqueness_of :thread_id, :scope => [:subscriber_type, :subscriber_id]
 
-    def mark_as_read
-      update_attribute(:unread, 0)
+    def self.comment_created(comment)
+      recipients = comment.thread.subscribers.reject{|s| s == comment.creator}
+      SubscriptionsMailer.comment_created(comment, recipients).deliver \
+        unless recipients.empty?
     end
 
-    def add_unread
-      update_attribute(:unread, unread + 1)
+    def unread_comments
+      created_at = Comment.arel_table[:created_at]
+      thread.filtered_comments.where(created_at.gt(updated_at))
     end
   end
 end
+

data/app/models/commontator/thread.rb

@@ -12,34 +12,78 @@ module Commontator
                             :allow_nil => true
 
     def config
-      commontable.try(:commontable_config) || Commontator
+      @config ||= commontable.try(:commontable_config) || Commontator
     end
 
     def will_paginate?
       return false if config.comments_per_page.nil? || !comments.respond_to?(:paginate)
-      require 'commontator/remote_link_renderer'
+      require 'commontator/link_renderer'
       true
     end
 
-    def ordered_comments
+    def is_filtered?
+      will_paginate? || config.comment_filter
+    end
+
+    def filtered_comments
+      cf = config.comment_filter
+      return comments if cf.nil?
+      comments.where(cf)
+    end
+
+    def ordered_comments(unfiltered = false)
+      vc = unfiltered ? comments : filtered_comments
       case config.comment_order.to_sym
-      when :l then comments.order('id DESC')
-      when :ve then comments.order('cached_votes_down - cached_votes_up')
-      when :vl then comments.order('cached_votes_down - cached_votes_up', 'id DESC')
-      else comments
+      when :l then vc.order('id DESC')
+      when :ve then vc.order('cached_votes_down - cached_votes_up')
+      when :vl then vc.order('cached_votes_down - cached_votes_up', 'id DESC')
+      else vc
       end
     end
 
-    def paginated_comments(page, per_page)
+    def paginated_comments(page = 1, per_page = config.comments_per_page)
       oc = ordered_comments
       return oc unless will_paginate?
       oc.paginate(:page => page, :per_page => per_page)
     end
 
+    def new_comment_page(per_page = config.comments_per_page)
+      return 1 if per_page.nil? || per_page.to_i <= 0
+      comment_index = \
+        case config.comment_order.to_sym
+        when :l
+          1 # First comment
+        when :ve
+          comment_arel = Comment.arel_table
+          # Last comment with rating = 0
+          filtered_comments.where((comment_arel[:cached_votes_up] - comment_arel[:cached_votes_down]).gteq 0).count
+        when :vl
+          comment_arel = Comment.arel_table
+          # First comment with rating = 0
+          filtered_comments.where((comment_arel[:cached_votes_up] - comment_arel[:cached_votes_down]).gt 0).count + 1
+        else
+          filtered_comments.count # Last comment
+        end
+      (comment_index.to_f/per_page.to_i).ceil
+    end
+
     def is_closed?
       !closed_at.blank?
     end
 
+    def close(user = nil)
+      return false if is_closed?
+      self.closed_at = Time.now
+      self.closer = user
+      save
+    end
+
+    def reopen
+      return false unless is_closed? && !commontable.nil?
+      self.closed_at = nil
+      save
+    end
+
     def subscribers
       subscriptions.collect{|s| s.subscriber}
     end
@@ -49,12 +93,8 @@ module Commontator
       subscriber.subscriptions.where(:thread_id => self.id).first
     end
 
-    def is_subscribed?(subscriber)
-      !subscription_for(subscriber).blank?
-    end
-
     def subscribe(subscriber)
-      return false if is_subscribed?(subscriber) || !subscriber.is_commontator
+      return false unless subscriber.is_commontator && !subscription_for(subscriber)
       subscription = Subscription.new
       subscription.subscriber = subscriber
       subscription.thread = self
@@ -63,50 +103,30 @@ module Commontator
 
     def unsubscribe(subscriber)
       subscription = subscription_for(subscriber)
-      return false if subscription.blank?
+      return false unless subscription
       subscription.destroy
     end
 
-    def add_unread_except_for(subscriber)
-      Subscription.transaction do
-        subscriptions.each{|s| s.add_unread unless s.subscriber == subscriber}
-      end
-    end
-
     def mark_as_read_for(subscriber)
-      return if !subscription_for(subscriber)
-      subscription_for(subscriber).mark_as_read
-    end
-
-    def close(user = nil)
-      return false if is_closed?
-      self.closed_at = Time.now
-      self.closer = user
-      save
-    end
-
-    def reopen
-      return false unless is_closed? && !commontable.nil?
-      self.closed_at = nil
-      save
+      subscription = subscription_for(subscriber)
+      return false unless subscription
+      subscription.touch
     end
 
     # Creates a new empty thread and assigns it to the commontable
     # The old thread is kept in the database for archival purposes
-    def clear(user = nil)
-      return if commontable.blank?
+    def clear
+      return if commontable.blank? || !is_closed?
       new_thread = Thread.new
       new_thread.commontable = commontable
+
       with_lock do
         self.commontable = nil
-        self.closed_at = Time.now
-        self.closer = user
         save!
         new_thread.save!
         subscriptions.each do |s|
           s.thread = new_thread
           s.save!
-          s.mark_as_read
         end
       end
     end
@@ -115,10 +135,10 @@ module Commontator
     # Access Control #
     ##################
 
-    # Reader capabilities (remember: user can be nil or false)
+    # Reader capabilities (user can be nil or false)
     def can_be_read_by?(user)
       return true if can_be_edited_by?(user)
-      !commontable.nil? && (!is_closed? || !config.hide_closed_threads) &&\
+      !commontable.nil? &&\
       config.thread_read_proc.call(self, user)
     end
 
@@ -131,8 +151,9 @@ module Commontator
     def can_subscribe?(user)
       thread_sub = config.thread_subscription.to_sym
       !is_closed? && !user.nil? && user.is_commontator &&\
-      thread_sub != :n && thread_sub != :a &&\
+      (thread_sub == :m || thread_sub == :b) &&\
       can_be_read_by?(user)
     end
   end
 end
+