commontator 6.0.0.pre.1 → 6.0.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5eff6c0a48d5f543bfb93305eac807e923acf0542f10afb4720aae10220b6447
-  data.tar.gz: 4875720a501fbf2087ab5d350b9e570f94271623f9df6834d30002afbf545f72
+  metadata.gz: 3b104df98e58a375c90e006da5b5dfe15833cbc12bd8bc19a1c7deb5fe47fb50
+  data.tar.gz: f7b5f7d780315910e49e6989f58d98d2bf085dcd27007086ec1c4554b7f1d0a0
 SHA512:
-  metadata.gz: 96c05e5272b89801962355a629f22be1662c4fe9cce699d7c7be01ad4139275ab0c604c529252deba630117b9e0bd916b195bc669bb8797bce94ab896a4a34e8
-  data.tar.gz: 4e319ccd0514499cf691509ed1a15262e319c32d80f9f04ce4d1b4b873b07a94e83d5071310d07c741979ffb50c22106c1f7afabd0788f65085775538985ca1c
+  metadata.gz: 99f7eeda6f7d0208640dbe86a98b047ae1092460836bbf8d1d13e200993aad7dc505e12fb793bdfc4fca9aff1c01498ea479368772022c1b6e47a65b0636f8af
+  data.tar.gz: b0db208a7f29d5d3ab311c2ec9d044c86a205e08c79b335621e70a2b9af1027b3c146356b121d768c02c63f85708e57f453a51fe4b15d70523f1e1534b0afb7a

data/app/assets/stylesheets/commontator/application.scss

@@ -37,10 +37,13 @@
     background-color: #FFF;
   }
 
+  .children {
+    padding-left: 15px;
+  }
+
   /* Modified from: https://www.strangerstudios.com/sandbox/pagination/diggstyle.php */
   .page-entries-info, .will-paginate {
-  	margin-top: 10px;
-    margin-bottom: 10px;
+  	margin: 10px 0;
   }
 
   .pagination {
@@ -70,7 +73,11 @@
       color: #FFF;
     }
 
-    span {
+    .name {
+    	margin: 2px 9px 2px 0;
+    }
+
+    .disabled {
     	margin-right: 4px;
       border: 1px solid #EEE;
       padding: 2px 5px 2px 5px;

data/app/assets/stylesheets/commontator/comments.scss

@@ -100,4 +100,8 @@
       list-style-position: inside;
     }
   }
+
+  .pagination {
+    margin: 10px 7px;
+  }
 }

data/app/controllers/commontator/comments_controller.rb

@@ -1,6 +1,15 @@
 class Commontator::CommentsController < Commontator::ApplicationController
-  before_action :set_thread, :commontator_set_thread_variables, only: [ :new, :create ]
+  before_action :set_thread, only: [ :new, :create ]
   before_action :set_comment_and_thread, except: [ :new, :create ]
+  before_action :commontator_set_thread_variables, only: [ :show, :update, :delete, :undelete ]
+
+  # GET /comments/1
+  def show
+    respond_to do |format|
+      format.html { redirect_to commontable_url }
+      format.js
+    end
+  end
 
   # GET /threads/1/comments/new
   def new
@@ -13,7 +22,7 @@ class Commontator::CommentsController < Commontator::ApplicationController
         Commontator.commontator_name(parent.creator)
       }</span>\n#{
         parent.body
-      }\n</blockquote>\n" if @commontator_thread.config.comment_reply_style == :q
+      }\n</blockquote>\n" if [ :q, :b ].include? @commontator_thread.config.comment_reply_style
     end
     security_transgression_unless @comment.can_be_created_by?(@commontator_user)
 
@@ -39,6 +48,9 @@ class Commontator::CommentsController < Commontator::ApplicationController
           @commontator_thread.subscribe(@commontator_user) if sub == :a || sub == :b
           subscribe_mentioned if @commontator_thread.config.mentions_enabled
           Commontator::Subscription.comment_created(@comment)
+          @commontator_page = @commontator_thread.new_comment_page(
+            @comment.parent_id, @commontator_show_all
+          )
 
           format.js
         else
@@ -156,12 +168,12 @@ class Commontator::CommentsController < Commontator::ApplicationController
   def set_comment_and_thread
     @comment = Commontator::Comment.find(params[:id])
     @commontator_thread = @comment.thread
-    commontator_set_new_comment
   end
 
   def subscribe_mentioned
     Commontator.commontator_mentions(@commontator_user, @commontator_thread, '')
-               .where(id: params[:mentioned_ids]).each do |user|
+               .where(id: params[:mentioned_ids])
+               .each do |user|
       @commontator_thread.subscribe(user)
     end
   end

data/app/controllers/commontator/threads_controller.rb

@@ -2,6 +2,7 @@ class Commontator::ThreadsController < Commontator::ApplicationController
   skip_before_action :ensure_user, only: :show
   before_action :set_thread
   before_action :commontator_set_thread_variables, except: :mentions
+  before_action :commontator_set_new_comment, only: [ :show, :reopen ]
 
   # GET /threads/1
   def show

data/app/helpers/commontator/link_renderer.rb

@@ -1,8 +1,11 @@
-require 'will_paginate'
-
 class Commontator::LinkRenderer < WillPaginate::ActionView::LinkRenderer
   protected
 
+  def html_container(html)
+    html = "<span class=\"name\">#{@options[:name]}</span>#{html}" if @options[:name]
+    tag(:div, html, container_attributes)
+  end
+
   def url(page)
     @base_url_params ||= begin
       url_params = merge_get_params(default_url_params)
@@ -12,8 +15,7 @@ class Commontator::LinkRenderer < WillPaginate::ActionView::LinkRenderer
     url_params = @base_url_params.dup
     add_current_page_param(url_params, page)
 
-    routes_proxy = @options[:routes_proxy] || @template
-    routes_proxy.url_for(url_params)
+    @template.commontator.url_for(url_params)
   end
 
   private

data/app/models/commontator/collection.rb

@@ -0,0 +1,26 @@
+class Commontator::Collection < WillPaginate::Collection
+  attr_reader :root_per_page
+
+  # This method determines if we are in a shorter version of the first page, which we call page 0
+  def page_zero?
+    total_entries > @per_page && @per_page < @root_per_page
+  end
+
+  def initialize(array, count, root_per_page, per_page, page = 1)
+    self.total_entries = count
+    @root_per_page = root_per_page
+    @per_page = per_page
+    @current_page = page_zero? ? 0 : WillPaginate::PageNumber(page)
+    @first_call = true
+
+    replace(array)
+  end
+
+  # We return 2 total_pages under certain conditions to trick will_paginate
+  # into rendering the pagination controls when it otherwise wouldn't
+  def total_pages
+    min_total_pages = page_zero? && @first_call ? 2 : 1
+    @first_call = false
+    [ (total_entries.to_f/@root_per_page).ceil, min_total_pages ].max
+  end
+end

data/app/models/commontator/comment.rb

@@ -4,30 +4,14 @@ class Commontator::Comment < ActiveRecord::Base
   belongs_to :thread, inverse_of: :comments
   belongs_to :parent, optional: true, class_name: name, inverse_of: :children
 
-  has_many :children, class_name: name, inverse_of: :parent
-
-  serialize :ancestor_ids, Commontator::JsonArrayCoder
-  serialize :descendant_ids, Commontator::JsonArrayCoder
+  has_many :children, class_name: name, foreign_key: :parent_id, inverse_of: :parent
 
   validates :editor, presence: true, on: :update
   validates :body, presence: true, uniqueness: {
-    scope: [ :creator_type, :creator_id, :thread_id, :deleted_at ],
-    message: I18n.t('commontator.comment.errors.double_posted')
+    scope: [ :creator_type, :creator_id, :thread_id, :deleted_at ], message: :double_posted
   }
   validate :parent_is_not_self, :parent_belongs_to_the_same_thread, if: :parent
 
-  before_save :set_ancestor_ids_and_ancestor_descendant_ids
-  before_destroy :remove_ancestor_descendant_ids
-
-  cattr_accessor :will_paginate
-  self.will_paginate = begin
-    require 'will_paginate'
-
-    true
-  rescue LoadError
-    false
-  end
-
   cattr_accessor :is_votable
   self.is_votable = begin
     require 'acts_as_votable'
@@ -38,10 +22,6 @@ class Commontator::Comment < ActiveRecord::Base
     false
   end
 
-  def self.will_paginate?
-    will_paginate
-  end
-
   def self.is_votable?
     is_votable
   end
@@ -51,13 +31,14 @@ class Commontator::Comment < ActiveRecord::Base
   end
 
   def is_latest?
-    thread.comments.last == self
+    thread.latest_comment(false) == self
   end
 
   def get_vote_by(user)
     return nil unless self.class.is_votable? && !user.nil? && user.is_commontator
 
-    votes_for.find_by(voter_type: user.class.name, voter_id: user.id)
+    # Preloaded with a condition in thread#nested_comments_for
+    votes_for.to_a.find { |vote| vote.voter_id == user.id && vote.voter_type == user.class.name }
   end
 
   def update_cached_votes(vote_scope = nil)
@@ -85,6 +66,12 @@ class Commontator::Comment < ActiveRecord::Base
     self.save
   end
 
+  def body
+    is_deleted? ? I18n.t(
+      'commontator.comment.status.deleted_by', deleter_name: Commontator.commontator_name(editor)
+    ) : super
+  end
+
   def created_timestamp
     I18n.t 'commontator.comment.status.created_at',
            created_at: I18n.l(created_at, format: :commontator)
@@ -124,8 +111,7 @@ class Commontator::Comment < ActiveRecord::Base
   end
 
   def can_be_voted_on?
-    !thread.is_closed? && !is_deleted? &&
-    thread.config.comment_voting.to_sym != :n && self.class.is_votable?
+    !thread.is_closed? && !is_deleted? && thread.is_votable? && self.class.is_votable?
   end
 
   def can_be_voted_on_by?(user)
@@ -135,6 +121,7 @@ class Commontator::Comment < ActiveRecord::Base
 
   protected
 
+  # These 2 validation messages are not currently translated because end users should never see them
   def parent_is_not_self
     return if parent != self
     errors.add :parent, 'must be a different comment'
@@ -146,88 +133,4 @@ class Commontator::Comment < ActiveRecord::Base
     errors.add :parent, 'must belong to the same thread'
     throw :abort
   end
-
-  def remove_ancestor_descendant_ids
-    return if ancestor_ids.empty?
-
-    # Remove id and descendant_ids from ancestors
-    self.class.where(id: ancestor_ids).order(:id).update_all("descendant_ids = #{
-      ([ id ] + descendant_ids).reduce(self.class.arel_table[:descendant_ids]) do |memo, descendant_id|
-        Arel::Nodes::NamedFunction.new('REPLACE', [
-          Arel::Nodes::NamedFunction.new('REPLACE', [
-            Arel::Nodes::NamedFunction.new('REPLACE', [
-              Arel::Nodes::NamedFunction.new('REPLACE', [
-                memo, Arel::Nodes.build_quoted("[#{descendant_id}]"), Arel::Nodes.build_quoted('[]')
-              ]), Arel::Nodes.build_quoted("[#{descendant_id},"), Arel::Nodes.build_quoted('[')
-            ]), Arel::Nodes.build_quoted(",#{descendant_id},"), Arel::Nodes.build_quoted(',')
-          ]), Arel::Nodes.build_quoted(",#{descendant_id}]"), Arel::Nodes.build_quoted(']')
-        ])
-      end.to_sql
-    }")
-
-    association(:parent).reset
-  end
-
-  def set_ancestor_ids_and_ancestor_descendant_ids
-    return if ancestor_ids.first == parent_id
-
-    pa = parent
-
-    remove_ancestor_descendant_ids
-
-    # Remove ancestor_ids from descendants
-    unless ancestor_ids.empty? || descendant_ids.empty?
-      self.class.where(id: descendant_ids).order(:id).update_all("ancestor_ids = #{
-        ancestor_ids.reduce(self.class.arel_table[:ancestor_ids]) do |memo, ancestor_id|
-          Arel::Nodes::NamedFunction.new('REPLACE', [
-            Arel::Nodes::NamedFunction.new('REPLACE', [
-              Arel::Nodes::NamedFunction.new('REPLACE', [
-                Arel::Nodes::NamedFunction.new('REPLACE', [
-                  memo, Arel::Nodes.build_quoted("[#{ancestor_id}]"), Arel::Nodes.build_quoted('[]')
-                ]), Arel::Nodes.build_quoted("[#{ancestor_id},"), Arel::Nodes.build_quoted('[')
-              ]), Arel::Nodes.build_quoted(",#{ancestor_id},"), Arel::Nodes.build_quoted(',')
-            ]), Arel::Nodes.build_quoted(",#{ancestor_id}]"), Arel::Nodes.build_quoted(']')
-          ])
-        end.to_sql
-      }")
-
-      children.reset
-    end
-
-    if pa.nil?
-      self.ancestor_ids = []
-    else
-      self.ancestor_ids = [ pa.id ] + pa.ancestor_ids
-
-      # Add id and descendant_ids to ancestors
-      descendant_ids_str = ([ id ] + descendant_ids).to_json[1..-2]
-      self.class.where(id: ancestor_ids).order(:id).update_all("descendant_ids = #{
-        Arel::Nodes::NamedFunction.new('REPLACE', [
-          Arel::Nodes::NamedFunction.new('REPLACE', [
-            Arel::Nodes::NamedFunction.new('COALESCE', [
-              self.class.arel_table[:descendant_ids], Arel::Nodes.build_quoted('[]')
-            ]), Arel::Nodes.build_quoted(']'), Arel::Nodes.build_quoted(",#{descendant_ids_str}]")
-          ]), Arel::Nodes.build_quoted('[,'), Arel::Nodes.build_quoted('[')
-        ]).to_sql
-      }")
-
-      association(:parent).reset
-
-      # Add ancestor_ids to descendants
-      unless descendant_ids.empty?
-        ancestor_ids_str = ancestor_ids.to_json[1..-2]
-        self.class.where(id: descendant_ids).order(:id).update_all("ancestor_ids = #{
-          Arel::Nodes::NamedFunction.new('REPLACE', [
-            Arel::Nodes::NamedFunction.new('REPLACE', [
-              Arel::Nodes::NamedFunction.new('COALESCE', [
-                self.class.arel_table[:ancestor_ids], Arel::Nodes.build_quoted('[]')
-              ]), Arel::Nodes.build_quoted(']'), Arel::Nodes.build_quoted(",#{ancestor_ids_str}]")
-            ]), Arel::Nodes.build_quoted('[,'), Arel::Nodes.build_quoted('[')
-          ]).to_sql
-        }")
-
-        children.reset
-      end
-    end
-  end
 end

data/app/models/commontator/subscription.rb

@@ -12,8 +12,8 @@ class Commontator::Subscription < ActiveRecord::Base
     mail.respond_to?(:deliver_later) ? mail.deliver_later : mail.deliver
   end
 
-  def unread_comments
+  def unread_comments(show_all)
     created_at = Commontator::Comment.arel_table[:created_at]
-    thread.filtered_comments.where(created_at.gteq(updated_at))
+    thread.filtered_comments(show_all).where(created_at.gteq(updated_at))
   end
 end

data/app/models/commontator/thread.rb

@@ -12,23 +12,25 @@ class Commontator::Thread < ActiveRecord::Base
     @config ||= commontable.try(:commontable_config) || Commontator
   end
 
-  def will_paginate?
-    !config.comments_per_page.nil? && Commontator::Comment.will_paginate?
+  def is_votable?
+    config.comment_voting.to_sym != :n
   end
 
   def is_filtered?
     !config.comment_filter.nil?
   end
 
-  def filtered_comments
+  def filtered_comments(show_all)
+    return comments if show_all
+
     cf = config.comment_filter
     return comments if cf.nil?
 
     comments.where(cf)
   end
 
-  def ordered_comments(show_all = false)
-    vc = show_all ? comments : filtered_comments
+  def ordered_comments(show_all)
+    vc = filtered_comments(show_all)
     cc = Commontator::Comment.arel_table
     case config.comment_order.to_sym
     when :l
@@ -44,32 +46,116 @@ class Commontator::Thread < ActiveRecord::Base
     end
   end
 
-  def paginated_comments(page = 1, per_page = config.comments_per_page, show_all = false)
+  def latest_comment(show_all)
+    @latest_comment ||= ordered_comments(show_all).last
+  end
+
+  def comments_with_parent_id(parent_id, show_all)
     oc = ordered_comments(show_all)
-    return oc unless will_paginate?
+    [ :i, :b ].include?(config.comment_reply_style) ? oc.where(parent_id: parent_id) : oc
+  end
+
+  def paginated_comments(page = 1, parent_id, show_all)
+    cp = comments_with_parent_id(parent_id, show_all)
+
+    cp.paginate(page: page, per_page: config.comments_per_page[0])
+  end
+
+  def nest_comments(
+    comments, root_per_page, per_page_by_parent_id, count_by_parent_id, children_by_parent_id
+  )
+    comments.map do |comment|
+      # Delete is used to ensure loops don't cause stack overflow
+      children = children_by_parent_id.delete(comment.id) || []
+      count = count_by_parent_id.delete(comment.id) || 0
+      per_page = per_page_by_parent_id.delete(comment.id) || 0
+      nested_children = nest_comments(
+        children, root_per_page, per_page_by_parent_id, count_by_parent_id, children_by_parent_id
+      )
 
-    oc.paginate(page: page, per_page: per_page)
+      [ comment, Commontator::Collection.new(nested_children, count, root_per_page, per_page) ]
+    end
+  end
+
+  def nested_comments_for(user, comments, show_all)
+    includes = [ :thread, :creator, :editor ]
+    total_entries = comments.total_entries
+    root_per_page = config.comments_per_page[0]
+    current_page = comments.current_page.to_i
+    comments = comments.includes(includes).to_a
+    count_by_parent_id = {}
+    per_page_by_parent_id = {}
+    children_by_parent_id = Hash.new { |hash, key| hash[key] = [] }
+
+    if [ :i, :b ].include? config.comment_reply_style
+      all_parent_ids = comments.map(&:id)
+      (config.comments_per_page[1..-1] + [ 0 ]).each_with_index do |per_page, index|
+        ordered_comments(show_all).where(parent_id: all_parent_ids)
+                                  .group(:parent_id)
+                                  .count
+                                  .each do |parent_id, count|
+          count_by_parent_id[parent_id] = count
+          per_page_by_parent_id[parent_id] = per_page
+        end
+
+        next if per_page == 0
+
+        children = all_parent_ids.empty? ? [] : Commontator::Comment.find_by_sql(
+          all_parent_ids.map do |parent_id|
+            Commontator::Comment.select(Arel.star).from(
+              Arel::Nodes::Grouping.new(
+                Arel::Nodes::SqlLiteral.new(
+                  ordered_comments(show_all).where(parent_id: parent_id).limit(per_page).to_sql
+                )
+              )
+            ).to_sql
+          end.reduce { |memo, sql| memo.nil? ? sql : "#{memo} UNION ALL #{sql}" }
+        )
+        children.each { |comment| children_by_parent_id[comment.parent_id] << comment }
+        all_parent_ids = children.map(&:id)
+      end
+    end
+
+    Commontator::Collection.new(
+      nest_comments(
+        comments, root_per_page, per_page_by_parent_id, count_by_parent_id, children_by_parent_id
+      ),
+      total_entries,
+      root_per_page,
+      root_per_page,
+      current_page
+    ).tap do |nested_comments|
+      next unless is_votable?
+
+      ActiveRecord::Associations::Preloader.new.preload(
+        nested_comments.flatten, :votes_for, ActsAsVotable::Vote.where(voter: user)
+      )
+    end
   end
 
-  def new_comment_page(per_page = config.comments_per_page)
-    return 1 if per_page.nil? || per_page.to_i <= 0
+  def new_comment_page(parent_id, show_all)
+    per_page = config.comments_per_page[0].to_i
+    return 1 if per_page <= 0
 
+    comment_order = config.comment_order.to_sym
+    return 1 if comment_order == :l
+
+    cp = comments_with_parent_id(parent_id, show_all)
+    cc = Commontator::Comment.arel_table
     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
+      cp.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
+      cp.where((cc[:cached_votes_up] - cc[:cached_votes_down]).gt(0)).count + 1
     else
-      filtered_comments.count # Last comment
+      cp.count # Last comment
     end
 
-    (comment_index.to_f/per_page.to_i).ceil
+    (comment_index.to_f/per_page).ceil
   end
 
   def is_closed?