commontator 5.1.0 → 6.0.0.pre.1

data/app/controllers/commontator/application_controller.rb

@@ -1,29 +1,29 @@
-module Commontator
-  class ApplicationController < ActionController::Base
-    before_action :set_user, :ensure_user
+class Commontator::ApplicationController < ActionController::Base
+  before_action :commontator_set_user, :ensure_user
 
-    rescue_from SecurityTransgression, with: -> { head(:forbidden) }
+  rescue_from Commontator::SecurityTransgression, with: -> { head(:forbidden) }
 
-    protected
+  helper Commontator::ApplicationHelper
 
-    def security_transgression_unless(check)
-      raise SecurityTransgression unless check
-    end
+  protected
 
-    def set_user
-      @user = Commontator.current_user_proc.call(self)
-    end
+  def security_transgression_unless(check)
+    raise Commontator::SecurityTransgression unless check
+  end
+
+  def ensure_user
+    security_transgression_unless(@commontator_user && @commontator_user.is_commontator)
+  end
 
-    def ensure_user
-      security_transgression_unless(@user && @user.is_commontator)
-    end
+  def set_thread
+    @commontator_thread = params[:thread_id].blank? ?
+      Commontator::Thread.find(params[:id]) :
+      Commontator::Thread.find(params[:thread_id])
+
+    security_transgression_unless @commontator_thread.can_be_read_by? @commontator_user
+  end
 
-    def set_thread
-      @thread = params[:thread_id].blank? ? \
-        Commontator::Thread.find(params[:id]) : \
-        Commontator::Thread.find(params[:thread_id])
-      security_transgression_unless @thread.can_be_read_by? @user
-      commontator_set_new_comment(@thread, @user)
-    end
+  def commontable_url
+    main_app.polymorphic_url(@commontator_thread.commontable)
   end
 end

data/app/controllers/commontator/comments_controller.rb

@@ -1,159 +1,168 @@
-module Commontator
-  class CommentsController < Commontator::ApplicationController
-    before_action :set_thread, only: [:new, :create]
-    before_action :set_comment_and_thread, except: [:new, :create]
-
-    # GET /threads/1/comments/new
-    def new
-      @comment = Comment.new
-      @comment.thread = @thread
-      @comment.creator = @user
-      security_transgression_unless @comment.can_be_created_by?(@user)
-
-      @per_page = params[:per_page] || @thread.config.comments_per_page
-
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js
-      end
+class Commontator::CommentsController < Commontator::ApplicationController
+  before_action :set_thread, :commontator_set_thread_variables, only: [ :new, :create ]
+  before_action :set_comment_and_thread, except: [ :new, :create ]
+
+  # GET /threads/1/comments/new
+  def new
+    @comment = Commontator::Comment.new(thread: @commontator_thread, creator: @commontator_user)
+    parent_id = params.dig(:comment, :parent_id)
+    unless parent_id.blank?
+      parent = Commontator::Comment.find parent_id
+      @comment.parent = parent
+      @comment.body = "<blockquote><span class=\"author\">#{
+        Commontator.commontator_name(parent.creator)
+      }</span>\n#{
+        parent.body
+      }\n</blockquote>\n" if @commontator_thread.config.comment_reply_style == :q
+    end
+    security_transgression_unless @comment.can_be_created_by?(@commontator_user)
 
+    respond_to do |format|
+      format.html { redirect_to commontable_url }
+      format.js
     end
+  end
+
+  # POST /threads/1/comments
+  def create
+    @comment = Commontator::Comment.new(
+      thread: @commontator_thread, creator: @commontator_user, body: params.dig(:comment, :body)
+    )
+    parent_id = params.dig(:comment, :parent_id)
+    @comment.parent = Commontator::Comment.find(parent_id) unless parent_id.blank?
+    security_transgression_unless @comment.can_be_created_by?(@commontator_user)
+
+    respond_to do |format|
+      if params[:cancel].blank?
+        if @comment.save
+          sub = @commontator_thread.config.thread_subscription.to_sym
+          @commontator_thread.subscribe(@commontator_user) if sub == :a || sub == :b
+          subscribe_mentioned if @commontator_thread.config.mentions_enabled
+          Commontator::Subscription.comment_created(@comment)
 
-    # POST /threads/1/comments
-    def create
-      @comment = Comment.new
-      @comment.thread = @thread
-      @comment.creator = @user
-      @comment.body = params[:comment].nil? ? nil : params[:comment][:body]
-      security_transgression_unless @comment.can_be_created_by?(@user)
-      subscribe_mentioned if Commontator.mentions_enabled
-
-      respond_to do |format|
-        if  !params[:cancel].nil?
-          format.html { redirect_to @thread }
-          format.js { render :cancel }
-        elsif @comment.save
-          sub = @thread.config.thread_subscription.to_sym
-          @thread.subscribe(@user) if sub == :a || sub == :b
-          Subscription.comment_created(@comment)
-
-          @per_page = params[:per_page] || @thread.config.comments_per_page
-
-          format.html { redirect_to @thread }
           format.js
         else
-          format.html { redirect_to @thread }
           format.js { render :new }
         end
+      else
+        format.js { render :cancel }
       end
+
+      format.html { redirect_to commontable_url }
     end
+  end
 
-    # GET /comments/1/edit
-    def edit
-      security_transgression_unless @comment.can_be_edited_by?(@user)
+  # GET /comments/1/edit
+  def edit
+    @comment.editor = @commontator_user
+    security_transgression_unless @comment.can_be_edited_by?(@commontator_user)
 
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js
-      end
+    respond_to do |format|
+      format.html { redirect_to commontable_url }
+      format.js
     end
+  end
+
+  # PUT /comments/1
+  def update
+    @comment.editor = @commontator_user
+    @comment.body = params.dig(:comment, :body)
+    security_transgression_unless @comment.can_be_edited_by?(@commontator_user)
+
+    respond_to do |format|
+      if params[:cancel].blank?
+        if @comment.save
+          subscribe_mentioned if @commontator_thread.config.mentions_enabled
 
-    # PUT /comments/1
-    def update
-      security_transgression_unless @comment.can_be_edited_by?(@user)
-      @comment.body = params[:comment].nil? ? nil : params[:comment][:body]
-      @comment.editor = @user
-      subscribe_mentioned if Commontator.mentions_enabled
-
-      respond_to do |format|
-        if !params[:cancel].nil?
-          format.html { redirect_to @thread }
-          format.js { render :cancel }
-        elsif @comment.save
-          format.html { redirect_to @thread }
           format.js
         else
-          format.html { redirect_to @thread }
           format.js { render :edit }
         end
+      else
+        @comment.restore_attributes
+
+        format.js { render :cancel }
       end
+
+      format.html { redirect_to commontable_url }
     end
+  end
 
-    # PUT /comments/1/delete
-    def delete
-      security_transgression_unless @comment.can_be_deleted_by?(@user)
+  # PUT /comments/1/delete
+  def delete
+    security_transgression_unless @comment.can_be_deleted_by?(@commontator_user)
 
-      @comment.errors.add(:base, t('commontator.comment.errors.already_deleted')) \
-        unless @comment.delete_by(@user)
+    @comment.errors.add(:base, t('commontator.comment.errors.already_deleted')) \
+      unless @comment.delete_by(@commontator_user)
 
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :delete }
-      end
+    respond_to do |format|
+      format.html { redirect_to commontable_url }
+      format.js { render :delete }
     end
+  end
 
-    # PUT /comments/1/undelete
-    def undelete
-      security_transgression_unless @comment.can_be_deleted_by?(@user)
+  # PUT /comments/1/undelete
+  def undelete
+    security_transgression_unless @comment.can_be_deleted_by?(@commontator_user)
 
-      @comment.errors.add(:base, t('commontator.comment.errors.not_deleted')) \
-        unless @comment.undelete_by(@user)
+    @comment.errors.add(:base, t('commontator.comment.errors.not_deleted')) \
+      unless @comment.undelete_by(@commontator_user)
 
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :delete }
-      end
+    respond_to do |format|
+      format.html { redirect_to commontable_url }
+      format.js { render :delete }
     end
+  end
 
-    # PUT /comments/1/upvote
-    def upvote
-      security_transgression_unless @comment.can_be_voted_on_by?(@user)
+  # PUT /comments/1/upvote
+  def upvote
+    security_transgression_unless @comment.can_be_voted_on_by?(@commontator_user)
 
-      @comment.upvote_from @user
+    @comment.upvote_from @commontator_user
 
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :vote }
-      end
+    respond_to do |format|
+      format.html { redirect_to commontable_url }
+      format.js { render :vote }
     end
+  end
 
-    # PUT /comments/1/downvote
-    def downvote
-      security_transgression_unless @comment.can_be_voted_on_by?(@user) &&\
-        @comment.thread.config.comment_voting.to_sym == :ld
+  # PUT /comments/1/downvote
+  def downvote
+    security_transgression_unless @comment.can_be_voted_on_by?(@commontator_user) &&\
+      @comment.thread.config.comment_voting.to_sym == :ld
 
-      @comment.downvote_from @user
+    @comment.downvote_from @commontator_user
 
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :vote }
-      end
+    respond_to do |format|
+      format.html { redirect_to commontable_url }
+      format.js { render :vote }
     end
+  end
 
-    # PUT /comments/1/unvote
-    def unvote
-      security_transgression_unless @comment.can_be_voted_on_by?(@user)
+  # PUT /comments/1/unvote
+  def unvote
+    security_transgression_unless @comment.can_be_voted_on_by?(@commontator_user)
 
-      @comment.unvote voter: @user
+    @comment.unvote voter: @commontator_user
 
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :vote }
-      end
+    respond_to do |format|
+      format.html { redirect_to commontable_url }
+      format.js { render :vote }
     end
+  end
 
-    protected
+  protected
 
-    def set_comment_and_thread
-      @comment = Comment.find(params[:id])
-      @thread = @comment.thread
-      commontator_set_new_comment(@thread, @user)
-    end
+  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(@user, @thread, '').where(id: params[:mentioned_ids]).each do |user|
-        @thread.subscribe(user)
-      end
+  def subscribe_mentioned
+    Commontator.commontator_mentions(@commontator_user, @commontator_thread, '')
+               .where(id: params[:mentioned_ids]).each do |user|
+      @commontator_thread.subscribe(user)
     end
   end
 end

data/app/controllers/commontator/security_transgression.rb

@@ -0,0 +1,2 @@
+class Commontator::SecurityTransgression < StandardError
+end

data/app/controllers/commontator/subscriptions_controller.rb

@@ -1,32 +1,30 @@
-module Commontator
-  class SubscriptionsController < Commontator::ApplicationController
-    before_action :set_thread
+class Commontator::SubscriptionsController < Commontator::ApplicationController
+  before_action :set_thread
 
-    # PUT /threads/1/subscribe
-    def subscribe
-      security_transgression_unless @thread.can_subscribe?(@user)
+  # PUT /threads/1/subscribe
+  def subscribe
+    security_transgression_unless @commontator_thread.can_subscribe?(@commontator_user)
 
-      @thread.errors.add(:base, t('commontator.subscription.errors.already_subscribed')) \
-        unless @thread.subscribe(@user)
-
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :subscribe }
-      end
+    @commontator_thread.errors.add(:base, t('commontator.subscription.errors.already_subscribed')) \
+      unless @commontator_thread.subscribe(@commontator_user)
 
+    respond_to do |format|
+      format.html { redirect_to commontable_url }
+      format.js   { render :subscribe }
     end
 
-    # PUT /threads/1/unsubscribe
-    def unsubscribe
-      security_transgression_unless @thread.can_subscribe?(@user)
+  end
+
+  # PUT /threads/1/unsubscribe
+  def unsubscribe
+    security_transgression_unless @commontator_thread.can_subscribe?(@commontator_user)
 
-      @thread.errors.add(:base, t('commontator.subscription.errors.not_subscribed')) \
-        unless @thread.unsubscribe(@user)
+    @commontator_thread.errors.add(:base, t('commontator.subscription.errors.not_subscribed')) \
+      unless @commontator_thread.unsubscribe(@commontator_user)
 
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :subscribe }
-      end
+    respond_to do |format|
+      format.html { redirect_to commontable_url }
+      format.js   { render :subscribe }
     end
   end
 end

data/app/controllers/commontator/threads_controller.rb

@@ -1,68 +1,68 @@
-module Commontator
-  class ThreadsController < Commontator::ApplicationController
-    skip_before_action :ensure_user, only: :show
-    before_action :set_thread
+class Commontator::ThreadsController < Commontator::ApplicationController
+  skip_before_action :ensure_user, only: :show
+  before_action :set_thread
+  before_action :commontator_set_thread_variables, except: :mentions
 
-    # 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 main_app.polymorphic_path(@thread.commontable) }
-        format.js
-      end
+  # GET /threads/1
+  def show
+    respond_to do |format|
+      format.html { redirect_to commontable_url }
+      format.js   { commontator_thread_show(@commontator_thread.commontable) }
     end
+  end
 
-    # PUT /threads/1/close
-    def close
-      security_transgression_unless @thread.can_be_edited_by?(@user)
-
-      @thread.errors.add(:base, t('commontator.thread.errors.already_closed')) \
-        unless @thread.close(@user)
+  # PUT /threads/1/close
+  def close
+    security_transgression_unless @commontator_thread.can_be_edited_by?(@commontator_user)
 
-      @show_all = true
+    @commontator_thread.errors.add(:base, t('commontator.thread.errors.already_closed')) \
+      unless @commontator_thread.close(@commontator_user)
 
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :show }
+    respond_to do |format|
+      format.html { redirect_to commontable_url }
+      format.js   do
+        commontator_thread_show(@commontator_thread.commontable)
+        render :show
       end
     end
+  end
 
-    # PUT /threads/1/reopen
-    def reopen
-      security_transgression_unless @thread.can_be_edited_by?(@user)
-
-      @thread.errors.add(:base, t('commontator.thread.errors.not_closed')) \
-        unless @thread.reopen
+  # PUT /threads/1/reopen
+  def reopen
+    security_transgression_unless @commontator_thread.can_be_edited_by?(@commontator_user)
 
-      @show_all = true
+    @commontator_thread.errors.add(:base, t('commontator.thread.errors.not_closed')) \
+      unless @commontator_thread.reopen
 
-      respond_to do |format|
-        format.html { redirect_to @thread }
-        format.js { render :show }
+    respond_to do |format|
+      format.html { redirect_to commontable_url }
+      format.js   do
+        commontator_thread_show(@commontator_thread.commontable)
+        render :show
       end
     end
+  end
 
-    # GET /threads/1/mentions.json
-    def mentions
-      security_transgression_unless @thread.can_be_read_by?(@user) && Commontator.mentions_enabled
-      query = params[:q].to_s
+  # GET /threads/1/mentions.json
+  def mentions
+    security_transgression_unless @commontator_thread.can_be_read_by?(@commontator_user) &&
+                                  @commontator_thread.config.mentions_enabled
 
-      if query.size < 3
-        render json: { errors: ['Query string is too short (minimum 3 characters)'] },
-               status: :unprocessable_entity
-      else
-        render json: serialized_mentions(query)
-      end
-    end
+    respond_to do |format|
+      format.json do
+        query = params[:q].to_s
 
-    protected
-
-    def serialized_mentions(query)
-      { mentions: Commontator.commontator_mentions(@user, @thread, query).map do |user|
-        { id: user.id, name: Commontator.commontator_name(user), type: 'user' }
-      end }
+        if query.size < 3
+          render json: { errors: ['Query string is too short (minimum 3 characters)'] },
+                 status: :unprocessable_entity
+        else
+          render json: {
+            mentions: Commontator.commontator_mentions(
+              @commontator_user, @commontator_thread, query
+            ).map { |user| { id: user.id, name: Commontator.commontator_name(user), type: 'user' } }
+          }
+        end
+      end
     end
   end
 end