commontator 5.1.0 → 6.0.0.pre.1

data/app/models/commontator/subscription.rb

@@ -1,22 +1,19 @@
-module Commontator
-  class Subscription < ActiveRecord::Base
-    belongs_to :subscriber, polymorphic: true
-    belongs_to :thread
+class Commontator::Subscription < ActiveRecord::Base
+  belongs_to :subscriber, polymorphic: true
+  belongs_to :thread, inverse_of: :subscriptions
 
-    validates_presence_of :subscriber, :thread
-    validates_uniqueness_of :thread_id, scope: [:subscriber_type, :subscriber_id]
+  validates :thread, presence: true, uniqueness: { scope: [ :subscriber_type, :subscriber_id ] }
 
-    def self.comment_created(comment)
-      recipients = comment.thread.subscribers.reject{|s| s == comment.creator}
-      return if recipients.empty?
+  def self.comment_created(comment)
+    recipients = comment.thread.subscribers.reject { |sub| sub == comment.creator }
+    return if recipients.empty?
 
-      mail = SubscriptionsMailer.comment_created(comment, recipients)
-      mail.respond_to?(:deliver_later) ? mail.deliver_later : mail.deliver
-    end
+    mail = Commontator::SubscriptionsMailer.comment_created(comment, recipients)
+    mail.respond_to?(:deliver_later) ? mail.deliver_later : mail.deliver
+  end
 
-    def unread_comments
-      created_at = Comment.arel_table[:created_at]
-      thread.filtered_comments.where(created_at.gt(updated_at))
-    end
+  def unread_comments
+    created_at = Commontator::Comment.arel_table[:created_at]
+    thread.filtered_comments.where(created_at.gteq(updated_at))
   end
 end

data/app/models/commontator/thread.rb

@@ -1,159 +1,165 @@
-module Commontator
-  class Thread < ActiveRecord::Base
-    belongs_to :closer, polymorphic: true, optional: true
-    belongs_to :commontable, polymorphic: true, optional: true
+class Commontator::Thread < ActiveRecord::Base
+  belongs_to :closer, polymorphic: true, optional: true
+  belongs_to :commontable, polymorphic: true, optional: true, inverse_of: :commontator_thread
 
-    has_many :comments, dependent: :destroy
-    has_many :subscriptions, dependent: :destroy
+  has_many :comments, dependent: :destroy, inverse_of: :thread
+  has_many :subscriptions, dependent: :destroy, inverse_of: :thread
 
-    validates_presence_of :commontable, unless: :is_closed?
-    validates_uniqueness_of :commontable_id,
-                            scope: :commontable_type,
-                            allow_nil: true
+  validates :commontable, presence: true, unless: :is_closed?
+  validates :commontable_id, uniqueness: { scope: :commontable_type, allow_nil: true }
 
-    def config
-      @config ||= commontable.try(:commontable_config) || Commontator
-    end
+  def config
+    @config ||= commontable.try(:commontable_config) || Commontator
+  end
 
-    def will_paginate?
-      return false if config.comments_per_page.nil? || !comments.respond_to?(:paginate)
-      require 'commontator/link_renderer'
-      true
-    end
+  def will_paginate?
+    !config.comments_per_page.nil? && Commontator::Comment.will_paginate?
+  end
 
-    def is_filtered?
-      will_paginate? || config.comment_filter
-    end
+  def is_filtered?
+    !config.comment_filter.nil?
+  end
 
-    def filtered_comments
-      cf = config.comment_filter
-      return comments if cf.nil?
-      comments.where(cf)
-    end
+  def filtered_comments
+    cf = config.comment_filter
+    return comments if cf.nil?
 
-    def ordered_comments(unfiltered = false)
-      vc = unfiltered ? comments : filtered_comments
-      case config.comment_order.to_sym
-      when :l then vc.order('created_at DESC')
-      when :e then vc.order('created_at ASC')
-      when :ve then vc.order('cached_votes_down - cached_votes_up', 'created_at ASC')
-      when :vl then vc.order('cached_votes_down - cached_votes_up', 'created_at DESC')
-      else vc
-      end
-    end
+    comments.where(cf)
+  end
 
-    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)
+  def ordered_comments(show_all = false)
+    vc = show_all ? comments : filtered_comments
+    cc = Commontator::Comment.arel_table
+    case config.comment_order.to_sym
+    when :l
+      vc.order(cc[:created_at].desc)
+    when :e
+      vc.order(cc[:created_at].asc)
+    when :ve
+      vc.order((cc[:cached_votes_down] - cc[:cached_votes_up]).asc, cc[:created_at].asc)
+    when :vl
+      vc.order((cc[:cached_votes_down] - cc[:cached_votes_up]).asc, cc[:created_at].desc)
+    else
+      vc
     end
+  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 paginated_comments(page = 1, per_page = config.comments_per_page, show_all = false)
+    oc = ordered_comments(show_all)
+    return oc unless will_paginate?
 
-    def is_closed?
-      !closed_at.blank?
-    end
+    oc.paginate(page: page, per_page: per_page)
+  end
 
-    def close(user = nil)
-      return false if is_closed?
-      self.closed_at = Time.now
-      self.closer = user
-      save
-    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
+      cc = Commontator::Comment.arel_table
+      # Last comment with rating == 0
+      filtered_comments.where((cc[:cached_votes_up] - cc[:cached_votes_down]).gteq(0)).count
+    when :vl
+      cc = Commontator::Comment.arel_table
+      # First comment with rating == 0
+      filtered_comments.where((cc[:cached_votes_up] - cc[: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 reopen
-      return false unless is_closed? && !commontable.nil?
-      self.closed_at = nil
-      save
-    end
+  def is_closed?
+    !closed_at.nil?
+  end
 
-    def subscribers
-      subscriptions.collect{|s| s.subscriber}
-    end
+  def close(user = nil)
+    return false if is_closed?
 
-    def subscription_for(subscriber)
-      return nil if !subscriber || !subscriber.is_commontator
-      subscriber.subscriptions.where(thread_id: self.id).first
-    end
+    self.closed_at = Time.now
+    self.closer = user
+    save
+  end
 
-    def subscribe(subscriber)
-      return false unless subscriber.is_commontator && !subscription_for(subscriber)
-      subscription = Subscription.new
-      subscription.subscriber = subscriber
-      subscription.thread = self
-      subscription.save
-    end
+  def reopen
+    return false unless is_closed? && !commontable.nil?
 
-    def unsubscribe(subscriber)
-      subscription = subscription_for(subscriber)
-      return false unless subscription
-      subscription.destroy
-    end
+    self.closed_at = nil
+    save
+  end
 
-    def mark_as_read_for(subscriber)
-      subscription = subscription_for(subscriber)
-      return false unless subscription
-      subscription.touch
-    end
+  def subscribers
+    subscriptions.map(&:subscriber)
+  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
-      return if commontable.blank? || !is_closed?
-      new_thread = Thread.new
-      new_thread.commontable = commontable
-
-      with_lock do
-        self.commontable = nil
-        save!
-        new_thread.save!
-        subscriptions.each do |s|
-          s.thread = new_thread
-          s.save!
-        end
-      end
-    end
+  def subscription_for(subscriber)
+    return nil if !subscriber || !subscriber.is_commontator
 
-    ##################
-    # Access Control #
-    ##################
+    subscriber.commontator_subscriptions.find_by(thread_id: self.id)
+  end
 
-    # Reader capabilities (user can be nil or false)
-    def can_be_read_by?(user)
-      return true if can_be_edited_by?(user)
-      !commontable.nil? &&\
-      config.thread_read_proc.call(self, user)
-    end
+  def subscribe(subscriber)
+    return false unless subscriber.is_commontator && !subscription_for(subscriber)
 
-    # Thread moderator capabilities
-    def can_be_edited_by?(user)
-      !commontable.nil? && !user.nil? && user.is_commontator &&\
-      config.thread_moderator_proc.call(self, user)
-    end
+    subscription = Commontator::Subscription.new
+    subscription.subscriber = subscriber
+    subscription.thread = self
+    subscription.save
+  end
+
+  def unsubscribe(subscriber)
+    subscription = subscription_for(subscriber)
+    return false unless subscription
+
+    subscription.destroy
+  end
+
+  def mark_as_read_for(subscriber)
+    subscription = subscription_for(subscriber)
+    return false unless subscription
 
-    def can_subscribe?(user)
-      thread_sub = config.thread_subscription.to_sym
-      !is_closed? && !user.nil? && user.is_commontator &&\
-      (thread_sub == :m || thread_sub == :b) &&\
-      can_be_read_by?(user)
+    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
+    return if commontable.nil? || !is_closed?
+
+    new_thread = Commontator::Thread.new
+    new_thread.commontable = commontable
+
+    with_lock do
+      self.commontable = nil
+      save!
+      new_thread.save!
+      Commontator::Subscription.where(thread: self).update_all(thread_id: new_thread.id)
     end
   end
+
+  ##################
+  # Access Control #
+  ##################
+
+  # Reader capabilities (user can be nil or false)
+  def can_be_read_by?(user)
+    return true if can_be_edited_by?(user)
+
+    !commontable.nil? && config.thread_read_proc.call(self, user)
+  end
+
+  # Thread moderator capabilities
+  def can_be_edited_by?(user)
+    !commontable.nil? && !user.nil? && user.is_commontator &&
+    config.thread_moderator_proc.call(self, user)
+  end
+
+  def can_subscribe?(user)
+    thread_sub = config.thread_subscription.to_sym
+    !is_closed? && !user.nil? && user.is_commontator &&
+    (thread_sub == :m || thread_sub == :b) && can_be_read_by?(user)
+  end
 end

data/app/views/commontator/comments/_actions.html.erb

@@ -1,6 +1,7 @@
-<% # Clients of this partial must supply the following variables:
-   # comment
-   # user
+<%#
+  Views that use this partial must supply the following variables:
+  comment
+  user
 %>
 
 <% can_edit = comment.can_be_edited_by?(user)
@@ -9,21 +10,19 @@
 <% if can_edit %>
   <%= link_to t('commontator.comment.actions.edit'),
               commontator.edit_comment_path(comment),
-              id: "comment_#{comment.id.to_s}_edit_link",
-              class: "comment_edit_link",
+              id: "commontator-comment-#{comment.id}-edit",
+              class: 'edit',
               remote: true %>
 <% end %>
 
-&nbsp;
-
 <% if can_delete %>
   <% is_deleted = comment.is_deleted? %>
   <% del_string = is_deleted ? 'undelete' : 'delete' %>
   <%= link_to t("commontator.comment.actions.#{del_string}"),
               commontator.polymorphic_path([del_string, comment]),
-              confirm: (!is_deleted ? t('commontator.comment.actions.confirm_delete') : nil),
+              data: is_deleted ? {} : { confirm: t('commontator.comment.actions.confirm_delete') },
               method: :put,
-              id: "comment_#{comment.id.to_s}_#{del_string}_link",
-              class: "comment_#{del_string}_link",
+              id: "commontator-comment-#{comment.id}-#{del_string}",
+              class: del_string,
               remote: true %>
 <% end %>

data/app/views/commontator/comments/_body.html.erb

@@ -1,8 +1,13 @@
-<% # Clients of this partial must provide the following variable:
-   # comment
+<%#
+  Views that use this partial must provide the following variable:
+  comment
 %>
 
-<%= simple_format comment.is_deleted? ? \
-      t('commontator.comment.status.deleted_by',
-        deleter_name: Commontator.commontator_name(comment.editor)) : \
-      comment.body %>
+<%=
+  commontator_simple_format(
+    comment.is_deleted? ? t(
+      'commontator.comment.status.deleted_by',
+      deleter_name: Commontator.commontator_name(comment.editor)
+    ) : comment.body
+  )
+%>

data/app/views/commontator/comments/_form.html.erb

@@ -1,16 +1,17 @@
-<% # Clients of this partial must provide the following variables:
-   # comment
-   #
-   # Optionally, they can also supply the following variables:
-   per_page ||= nil
-   thread ||= nil
-   no_remote ||= false
+<%
+  # Views that use this partial must provide the following variables:
+  # comment
+  #
+  # Optionally, they can also supply the following variables:
+  per_page ||= nil
+  thread ||= nil
+  no_remote ||= false
 %>
 
 <% config = comment.thread.config %>
 
 <% if comment.errors.any? %>
-  <div class="comment_error_explanation">
+  <div class="error-explanation">
     <h3><%= t "commontator.comment.errors.#{comment.id.blank? ? 'create' : 'update'}" %></h3>
 
     <ul>
@@ -21,19 +22,29 @@
   </div>
 <% end %>
 
-<%= form_for([commontator, thread, comment],
-             remote: !no_remote) do |f| %>
-
+<%= form_for([commontator, thread, comment], remote: !no_remote) do |form| %>
   <%= hidden_field_tag :per_page, per_page %>
-  
-  <div class="comment_form_field">
-    <%= f.text_area :body, rows: '7' %>
-    <%= javascript_tag('Commontator.initMentions()') if Commontator.mentions_enabled %>
+
+  <%= form.hidden_field :parent_id %>
+
+  <% unless comment.parent.nil? %>
+    <div class="replying">
+      <%= t('commontator.comment.replying',
+            creator_name: Commontator.commontator_name(comment.parent.creator)) %>
+    </div>
+  <% end %>
+
+  <div class="field">
+    <%=
+      form.text_area :body, rows: '7', id: comment.id.blank? ?
+        "commontator-thread-#{@commontator_thread.id}-new-comment-body" :
+        "commontator-comment-#{comment.id}-edit-body"
+    %>
+    <%= javascript_tag('Commontator.initMentions();') if config.mentions_enabled %>
   </div>
-  
-  <div class="comment_form_actions">
-    <%= f.submit t("commontator.comment.actions.#{comment.id.blank? ? 'create' : 'update'}") %>
-    <%= f.submit t('commontator.comment.actions.cancel'), name: 'cancel' %>
+
+  <div class="submit">
+    <%= form.submit t("commontator.comment.actions.#{comment.id.blank? ? 'create' : 'update'}") %>
+    <%= form.submit t('commontator.comment.actions.cancel'), name: 'cancel' %>
   </div>
-  
 <% end %>