commontator 0.5.14 → 1.0.0

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

@@ -8,15 +8,16 @@ module Commontator
     
     validates_presence_of :creator, :on => :create
     validates_presence_of :thread
+    validates_presence_of :body
 
     attr_accessible :body
     
-    cattr_accessor :is_votable
-    if respond_to?(:acts_as_votable)
-      acts_as_votable if respond_to?(:acts_as_votable)
-      self.is_votable = true
-    else
-      self.is_votable = false
+    cattr_accessor :acts_as_votable_initialized
+    
+    def is_votable?
+      return false unless self.class.respond_to?(:acts_as_votable)
+      self.class.acts_as_votable unless acts_as_votable_initialized
+      self.class.acts_as_votable_initialized = true
     end
     
     def is_modified?
@@ -31,16 +32,18 @@ module Commontator
       config = thread.config
       (is_modified? ? 'Last modified on ' : \
         "#{config.comment_create_verb_past.capitalize} on ") + \
-        comment.updated_at.strftime(config.timestamp_format)
+        updated_at.strftime(config.timestamp_format)
     end
     
     def delete(user = nil)
+      return false if is_deleted?
       self.deleted_at = Time.now
       self.deleter = user
       self.save!
     end
     
     def undelete
+      return false unless is_deleted?
       self.deleted_at = nil
       self.save!
     end
@@ -61,20 +64,21 @@ module Commontator
 
     def can_be_edited_by?(user)
       !thread.is_closed? && !is_deleted? &&\
-        ((user == creator && thread.config.can_edit_own_comments) ||\
+        ((user == creator && thread.config.can_edit_own_comments && thread.can_be_read_by?(user)) ||\
         (thread.can_be_edited_by?(user) && thread.config.admin_can_edit_comments)) &&\
         (thread.comments.last == self || thread.config.can_edit_old_comments)
     end
 
     def can_be_deleted_by?(user)
       (!thread.is_closed? &&\
-        ((user == creator && thread.config.can_delete_own_comments) &&\
+        ((user == creator && thread.config.can_delete_own_comments && \
+        thread.can_be_read_by?(user) && (!is_deleted? || deleter == user)) &&\
         (thread.comments.last == self || thread.config.can_delete_old_comments))) ||\
         thread.can_be_edited_by?(user)
     end
     
     def can_be_voted_on?
-      is_votable && !is_deleted? && thread.config.comments_can_be_voted_on
+      is_votable? && !is_deleted? && thread.config.comments_can_be_voted_on
     end
 
     def can_be_voted_on_by?(user)

data/app/models/commontator/subscription.rb

@@ -9,11 +9,11 @@ module Commontator
     attr_accessible :subscriber, :thread
     
     def mark_as_read
-      self.update_attribute(:is_unread, false)
+      self.update_attribute(:unread, 0)
     end
 
-    def mark_as_unread
-      self.update_attribute(:is_unread, true)
+    def add_unread
+      self.update_attribute(:unread, unread + 1)
     end
   end
 end

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

@@ -0,0 +1,19 @@
+module Commontator
+  class Subscription < ActiveRecord::Base
+    belongs_to :subscriber, :polymorphic => true
+    belongs_to :thread
+
+    validates_presence_of :subscriber, :thread
+    validates_uniqueness_of :thread_id, :scope => [:subscriber_id, :subscriber_type]
+    
+    attr_accessible :subscriber, :thread
+    
+    def mark_as_read
+      self.update_attribute(:is_unread, false)
+    end
+
+    def add_unread
+      self.update_attribute(:unread, unread + 1)
+    end
+  end
+end

data/app/models/commontator/thread.rb

@@ -15,7 +15,7 @@ module Commontator
     end
     
     def ordered_comments
-      (!commontable.blank? && config.comments_can_be_voted_on && config.comments_ordered_by_votes) ? \
+      (!commontable.blank? && config.can_vote_on_comments && config.comments_ordered_by_votes) ? \
         comments.order("cached_votes_down - cached_votes_up") : comments
     end
     
@@ -24,6 +24,7 @@ module Commontator
     end
     
     def subscription_for(subscriber)
+      return nil if subscriber.nil?
       Subscription.find_by_thread_id_and_subscriber_id_and_subscriber_type(self.id, subscriber.id, subscriber.class.name)
     end
     
@@ -39,14 +40,12 @@ module Commontator
       return false if is_subscribed?(subscriber)
       subscription = Subscription.create(
         :subscriber => subscriber, :thread => self)
-      subscribe_callback(subscriber)
     end
 
     def unsubscribe(subscriber)
       subscription = subscription_for(subscriber)
       return false if subscription.blank?
       subscription.destroy
-      unsubscribe_callback(subscriber)
     end
 
     def mark_as_read_for(subscriber)
@@ -54,19 +53,21 @@ module Commontator
       subscription_for(subscriber).mark_as_read
     end
     
-    def mark_as_unread_except_for(subscriber)
+    def add_unread_except_for(subscriber)
       Subscription.transaction do
-        subscriptions.each{|s| s.mark_as_unread unless s.subscriber == subscriber}
+        subscriptions.each{|s| s.add_unread unless s.subscriber == subscriber}
       end
     end
     
     def close(user = nil)
+      return false if is_closed?
       self.closed_at = Time.now
       self.closer = user
       self.save!
     end
     
     def reopen
+      return false unless is_closed?
       self.closed_at = nil
       self.save!
     end
@@ -91,49 +92,24 @@ module Commontator
         self.close(user)
       end
     end
-    
-    ####################
-    # Callback methods #
-    ####################
-    
-    def comment_created_callback(user, comment)
-      commontable.blank? || config.comment_created_callback.blank? || commontable.send(config.comment_created_callback, user, comment)
-    end
-    
-    def comment_edited_callback(user, comment)
-      commontable.blank? || config.comment_edited_callback.blank? || commontable.send(config.comment_edited_callback, user, comment)
-    end
-    
-    def comment_deleted_callback(user, comment)
-      commontable.blank? || config.comment_deleted_callback.blank? || commontable.send(config.comment_deleted_callback, user, comment)
-    end
-    
-    def thread_closed_callback(user)
-      commontable.blank? || config.thread_closed_callback.blank? || commontable.send(config.thread_closed_callback, user)
-    end
-    
-    def subscribe_callback(user)
-      commontable.blank? || config.subscribe_callback.blank? || commontable.send(config.subscribe_callback, user)
-    end
-          
-    def unsubscribe_callback(user)
-      commontable.blank? || config.unsubscribe_callback.blank? || commontable.send(config.unsubscribe_callback, user)
-    end
 
     ##########################
     # Access control methods #
     ##########################
-
-    def can_be_read_by?(user) # Reader and poster capabilities
-      (!commontable.blank? && (!is_closed? || config.closed_threads_are_readable) &&\
-        config.can_read_thread_method.blank? ? true : commontable.send(config.can_read_thread_method, user)) ||\
+    
+    # Reader and poster capabilities
+    def can_be_read_by?(user)
+      (!commontable.blank? && \
+        (!is_closed? || config.closed_threads_are_readable) && \
+        config.can_read_thread_proc.call(self, user)) || \
         can_be_edited_by?(user)
     end
 
-    def can_be_edited_by?(user) # Thread admin capabilities
-      !commontable.blank? && (config.can_edit_thread_method.blank? ?
-        (user.commontator_config.is_admin_method.blank? ? false : user.send(user.commontator_config.is_admin_method)) :
-        commontable.send(config.can_edit_thread_method, user))
+    # Thread moderator capabilities
+    def can_be_edited_by?(user)
+      !commontable.blank? && \
+        (config.can_edit_thread_proc.call(self, user) || \
+        (!user.nil? && user.commontator_config.user_admin_proc.call(user)))
     end
 
     def can_subscribe?(user)

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

@@ -0,0 +1,119 @@
+module Commontator
+  class Thread < ActiveRecord::Base
+    belongs_to :closer, :polymorphic => true
+    belongs_to :commontable, :polymorphic => true
+
+    has_many :comments, :dependent => :destroy
+    has_many :subscriptions, :dependent => :destroy
+
+    validates_presence_of :commontable, :on => :create
+    
+    attr_accessible :is_closed
+    
+    def config
+      commontable.try(:commontable_config)
+    end
+    
+    def ordered_comments
+      (!commontable.blank? && config.comments_can_be_voted_on && config.comments_ordered_by_votes) ? \
+        comments.order("cached_votes_down - cached_votes_up") : comments
+    end
+    
+    def subscribers
+      subscriptions.collect{|s| s.subscriber}
+    end
+    
+    def subscription_for(subscriber)
+      return nil if subscriber.nil?
+      Subscription.find_by_thread_id_and_subscriber_id_and_subscriber_type(self.id, subscriber.id, subscriber.class.name)
+    end
+    
+    def is_closed?
+      !closed_at.blank?
+    end
+    
+    def is_subscribed?(subscriber)
+      !subscription_for(subscriber).blank?
+    end
+
+    def subscribe(subscriber)
+      return false if is_subscribed?(subscriber)
+      subscription = Subscription.create(
+        :subscriber => subscriber, :thread => self)
+    end
+
+    def unsubscribe(subscriber)
+      subscription = subscription_for(subscriber)
+      return false if subscription.blank?
+      subscription.destroy
+    end
+
+    def mark_as_read_for(subscriber)
+      return if !subscription_for(subscriber)
+      subscription_for(subscriber).mark_as_read
+    end
+    
+    def add_unread_except_for(subscriber)
+      Subscription.transaction do
+        subscriptions.each{|s| s.add_unread unless s.subscriber == subscriber}
+      end
+    end
+    
+    def close(user = nil)
+      return false if is_closed?
+      self.closed_at = Time.now
+      self.closer = user
+      self.save!
+    end
+    
+    def reopen
+      return false unless is_closed?
+      self.closed_at = nil
+      self.save!
+    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?
+      new_thread = Thread.new
+      new_thread.commontable = commontable
+      self.with_lock do
+        new_thread.save!
+        commontable.thread = new_thread
+        commontable.save!
+        subscriptions.each do |s|
+          s.thread = new_thread
+          s.save!
+          s.mark_as_read
+        end
+        self.commontable = nil
+        self.close(user)
+      end
+    end
+
+    ##########################
+    # Access control methods #
+    ##########################
+    
+    # Reader and poster capabilities
+    def can_be_read_by?(user)
+      (!commontable.blank? && \
+        (!is_closed? || config.closed_threads_are_readable) && \
+        config.can_read_thread_proc.call(self, user)) || \
+        can_be_edited_by?(user)
+    end
+
+    # Thread moderator capabilities
+    def can_be_edited_by?(user)
+      !commontable.blank? && \
+        (config.can_edit_thread_proc.call(self, user) || \
+        (!user.nil? && user.commontator_config.user_admin_proc.call(user)))
+    end
+
+    def can_subscribe?(user)
+      !commontable.blank? && config.can_subscribe_to_thread && !is_closed? && can_be_read_by?(user)
+    end
+  end
+end

data/app/views/commontator/shared/_thread.html.erb

@@ -3,6 +3,8 @@
    # user
 %>
 
+<% subscription = thread.subscription_for(user) %>
+
 <% if thread.can_be_read_by?(user) %>
   <%= stylesheet_link_tag "commontator/application", :media => "all" %>
 
@@ -11,7 +13,8 @@
       <%= render :partial => 'commontator/threads/show', :locals => {:thread => thread,
                                                                      :user => user} %>
     <% else %>
-      <%= link_to "Show #{thread.config.comment_name.pluralize} (#{thread.comments.count})", commontator.thread_path(thread), :remote => true %>
+      <%= link_to "Show #{thread.config.comment_name.pluralize} (#{subscription ? subscription.unread + '/' + thread.comments.count : thread.comments.count})", \
+                  commontator.thread_path(thread), :remote => true %>
     <% end %>
   </div>
 <% end %>

data/app/views/commontator/shared/_thread.html.erb~

@@ -3,15 +3,18 @@
    # user
 %>
 
+<% subscription = thread.subscription_for(user) %>
+
 <% if thread.can_be_read_by?(user) %>
   <%= stylesheet_link_tag "commontator/application", :media => "all" %>
 
-  <div id="thread_<%= thread.id %>_div" class="thread">
+  <div id="thread_<%= thread.id %>_div" class="thread" style="display: none;">
     <% if @commontator_thread_show %>
       <%= render :partial => 'commontator/threads/show', :locals => {:thread => thread,
                                                                      :user => user} %>
     <% else %>
-      <%= link_to "Show #{thread.config.comment_name.pluralize} (#{thread.comments.count})", commontator.thread_path(thread), :remote => true %>
+      <%= link_to "Show #{thread.config.comment_name.pluralize} (#{subscription ? subscription.unread + '/' + thread.comments.count : thread.comments.count})", \
+                    commontator.thread_path(thread), :remote => true %>
     <% end %>
   </div>
 <% end %>

data/app/views/commontator/subscriptions_mailer/comment_created_email.html.erb

@@ -1,4 +1,4 @@
-<h4><%= @creator_name %>'s <%= @thread.config.comment_name %> on <%= @commontable_name %> #<%= @commontable_id %>:</h4>
+<h4><%= @creator_name %>'s <%= @thread.config.comment_name %> on <%= @commontable_name %> <%= @commontable_id %>:</h4>
 
 <%= render :partial => 'commontator/comments/body',
            :locals => { :comment => @comment } %>

data/app/views/commontator/subscriptions_mailer/comment_created_email.html.erb~

@@ -0,0 +1,6 @@
+<h4><%= @creator_name %>'s <%= @thread.config.comment_name %> on <%= @commontable_name %> #<%= @commontable_id %>:</h4>
+
+<%= render :partial => 'commontator/comments/body',
+           :locals => { :comment => @comment } %>
+
+<p><a href="<%= @commontable_url %>">Click here</a> to visit this thread.</p>

data/config/initializers/commontator.rb

@@ -4,7 +4,7 @@ Commontator.configure do |config|
 
   # Engine Configuration
 
-  # Method called on ApplicationController to return the current user
+  # Name of the ApplicationController helper method that returns the current user
   # Default: 'current_user'
   config.current_user_method = 'current_user'
 
@@ -25,6 +25,11 @@ Commontator.configure do |config|
   # Whether the user's name is clickable in the comment view
   # Default: false
   config.user_name_clickable = false
+  
+  # Whether automated emails are sent to the user whenever
+  # a comment is posted on a thread they subscribe to
+  # Default: true
+  config.subscription_emails = true
 
   # The method that returns the user's email address
   # Default: 'email'
@@ -34,10 +39,11 @@ Commontator.configure do |config|
   # Default: '' (use user_missing_name)
   config.user_name_method = ''
 
-  # Method that returns true if the user is an admin for all threads
+  # Proc called with user as argument that returns true if the user is an admin
   # Admins can always delete other users' comments and close threads
-  # Default: '' (no admins)
-  config.is_admin_method = ''
+  # Note: user can be nil
+  # Default: lambda { |user| false } (no admins)
+  config.user_admin_proc = lambda { |user| false }
 
 
   # Commontable (acts_as_commontable) Configuration
@@ -60,23 +66,6 @@ Commontator.configure do |config|
   # as an argument to acts_as_commontable in each one
   # Default: 'commontable'
   config.commontable_name = 'commontable'
-  
-  # Proc that returns the commontable url that contains the thread
-  # (defaults to the commontable show url)
-  # Main application's routes can be accessed using main_app object
-  # Default: lambda { |main_app, commontable| main_app.polymorphic_url(commontable) }
-  config.commontable_url_proc = lambda { |main_app, commontable| main_app.polymorphic_url(commontable) }
-
-  # Proc that returns the subscription email subject
-  # Default:
-  # lambda do |params|
-  #   "#{params[:creator_name]} #{params[:config].comment_create_verb_past} a " + \
-  #   "#{params[:config].comment_name} on #{params[:commontable_name]} ##{params[:commontable_id]}"
-  # end
-  config.subscription_email_subject_proc = lambda do |params|
-    "#{params[:creator_name]} #{params[:config].comment_create_verb_past} a " + \
-    "#{params[:config].comment_name} on #{params[:commontable_name]} ##{params[:commontable_id]}"
-  end
 
   # The format of the timestamps used by Commontator
   # Default: '%b %d %Y, %I:%M %p'
@@ -100,8 +89,8 @@ Commontator.configure do |config|
   config.can_edit_old_comments = false
 
   # Whether users can delete their own comments
-  # Default: false
-  config.can_delete_own_comments = false
+  # Default: true
+  config.can_delete_own_comments = true
 
   # Whether users can delete their own comments
   # after someone posted a newer comment
@@ -116,7 +105,7 @@ Commontator.configure do |config|
   # Note: requires acts_as_votable gem installed
   # and configured for your application
   # Default: false
-  config.comments_can_be_voted_on = false
+  config.can_vote_on_comments = false
 
   # Whether comments should be ordered by vote score
   # instead of by order posted
@@ -132,48 +121,37 @@ Commontator.configure do |config|
   # Default: true
   config.deleted_comments_are_visible = true
 
-  # Method called on commontable to return its id
+  # The method which returns the commontable's id that is sent to users in email messages
   # Default: 'id'
   config.commontable_id_method = 'id'
 
-  # Method called on commontable and passed user as argument
-  # If true, that user is a moderator for that particular commontable's thread
+  # Proc called with thread and user as arguments
+  # If it returns true, that user is a moderator for that particular thread
   # and is given admin-like capabilities for that thread only
-  # Default: '' (no thread-specific moderators)
-  config.can_edit_thread_method = ''
-
-  # Method called on commontable and passed user as argument
-  # If true, that user is allowed to read that commontable's thread
-  # Default: '' (no read restrictions)
-  config.can_read_thread_method = ''
-
-  # Method called on commontable when a comment is created
-  # Passed user, comment as arguments
-  # Default: '' (no callback)
-  config.comment_created_callback = ''
-
-  # Method called on commontable when a comment is edited
-  # Passed user, comment as arguments
-  # Default: '' (no callback)
-  config.comment_edited_callback = ''
-
-  # Method called on commontable when a comment is deleted
-  # Passed user, comment as arguments
-  # Default: '' (no callback)
-  config.comment_deleted_callback = ''
-
-  # Method called on commontable when a thread is closed
-  # Passed user as argument
-  # Default: '' (no callback)
-  config.thread_closed_callback = ''
-
-  # Method called on commontable when a thread is subscribed to
-  # Passed user as argument
-  # Default: '' (no callback)
-  config.subscribe_callback = ''
-
-  # Method called on commontable when a thread is unsubscribed to
-  # Passed user as argument
-  # Default: '' (no callback)
-  config.unsubscribe_callback = ''
+  # Note: user can be nil
+  # Default: lambda { |thread, user| false } (no thread-specific moderators)
+  config.can_edit_thread_proc = lambda { |thread, user| false }
+
+  # Proc called with thread and user as arguments
+  # If it returns true, that user is allowed to read that thread
+  # Note: user can be nil
+  # Default: lambda { |thread, user| true } (no read restrictions)
+  config.can_read_thread_proc = lambda { |thread, user| true }
+
+  # Proc that returns the commontable url that contains the thread
+  # (defaults to the commontable show url)
+  # Main application's routes can be accessed using main_app object
+  # Default: lambda { |main_app, commontable| main_app.polymorphic_url(commontable) }
+  config.commontable_url_proc = lambda { |main_app, commontable| main_app.polymorphic_url(commontable) }
+
+  # Proc that returns the subscription email subject string
+  # Default:
+  # lambda do |params|
+  #   "#{params[:creator_name]} #{params[:config].comment_create_verb_past} a " + \
+  #   "#{params[:config].comment_name} on #{params[:commontable_name]} ##{params[:commontable_id]}"
+  # end
+  config.subscription_email_subject_proc = lambda do |params|
+    "#{params[:creator_name]} #{params[:config].comment_create_verb_past} a " + \
+    "#{params[:config].comment_name} on #{params[:commontable_name]} ##{params[:commontable_id]}"
+  end
 end