reviewkit 0.1.0

data/app/controllers/reviewkit/application_controller.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  class ApplicationController < ActionController::Base
+    helper ::ApplicationHelper if defined?(::ApplicationHelper)
+    helper_method :reviewkit_current_actor,
+                  :reviewkit_engine_layout?,
+                  :reviewkit_frame_request?,
+                  :reviewkit_requested_frame_id
+
+    around_action :set_reviewkit_current_attributes
+    layout :reviewkit_layout
+
+    private
+
+    def reviewkit_current_actor
+      @reviewkit_current_actor ||= Reviewkit.config.current_actor.call(self)
+    end
+
+    def reviewkit_frame_request?
+      reviewkit_requested_frame_id.present?
+    end
+
+    def reviewkit_requested_frame_id
+      request.headers["Turbo-Frame"].presence || params[:reviewkit_frame_id].presence
+    end
+
+    def reviewkit_layout
+      return false if reviewkit_frame_request?
+
+      @reviewkit_layout ||= begin
+        configured_layout = Reviewkit.config.layout
+        return configured_layout if configured_layout.present? && configured_layout != Reviewkit::Configuration::DEFAULT_LAYOUT
+
+        if host_layout_override?("reviewkit/application")
+          "reviewkit/application"
+        elsif host_layout_override?("application")
+          "application"
+        else
+          Reviewkit::Configuration::DEFAULT_LAYOUT
+        end
+      end
+    end
+
+    def reviewkit_engine_layout?
+      reviewkit_layout == Reviewkit::Configuration::DEFAULT_LAYOUT
+    end
+
+    def authorize_reviewkit!(action, record = nil, **context)
+      allowed = Reviewkit.config.authorize_action.call(self, action, record, **context)
+      raise Reviewkit::AuthorizationError, "Forbidden action: #{action}" unless allowed
+    end
+
+    def host_layout_override?(layout_name)
+      basename = layout_name.split("/").last
+      relative_directory = layout_name.include?("/") ? File.join("app/views/layouts", File.dirname(layout_name)) : "app/views/layouts"
+
+      Dir.glob(Rails.root.join(relative_directory, "#{basename}.*")).any?
+    end
+
+    def set_reviewkit_current_attributes
+      Reviewkit::Current.set(
+        actor: reviewkit_current_actor,
+        controller: self,
+        source: self.class.name
+      ) do
+        yield
+      end
+    end
+
+    def handle_authorization_error
+      respond_to do |format|
+        format.html { redirect_back fallback_location: main_app.respond_to?(:root_path) ? main_app.root_path : "/", alert: "You are not authorized to access that review." }
+        format.turbo_stream { head :forbidden }
+        format.any { head :forbidden }
+      end
+    end
+  rescue_from Reviewkit::AuthorizationError, with: :handle_authorization_error
+  end
+end

data/app/controllers/reviewkit/comments_controller.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  class CommentsController < ApplicationController
+    before_action :set_thread
+    before_action :set_comment, only: %i[show edit update destroy]
+
+    def create
+      authorize_reviewkit!(:comment, @thread.review)
+
+      @comment = @thread.comments.build(comment_attributes.merge(author: reviewkit_current_actor, metadata: {}))
+
+      @comment.save
+
+      render_thread_bucket(status: @comment.persisted? ? :ok : :unprocessable_content)
+    end
+
+    def show
+      authorize_reviewkit!(:show, @thread.review)
+      render_comment_frame
+    end
+
+    def edit
+      authorize_comment_management!(:edit_comment)
+      render_edit_frame
+    end
+
+    def update
+      authorize_comment_management!(:update_comment)
+
+      if @comment.update(comment_attributes)
+        render_comment_frame
+      else
+        render_edit_frame(status: :unprocessable_content)
+      end
+    end
+
+    def destroy
+      authorize_comment_management!(:destroy_comment)
+
+      if @thread.comments.size == 1
+        @thread.destroy!
+      else
+        @comment.destroy!
+      end
+
+      render_thread_bucket(status: :ok)
+    end
+
+    protected
+
+    def review_thread_scope
+      ReviewThread.includes(:review, :document, :comments)
+    end
+
+    def comment_scope(thread)
+      thread.comments
+    end
+
+    def permitted_comment_attributes
+      %i[body]
+    end
+
+    def comment_request_attributes
+      %i[frame_id view]
+    end
+
+    def comment_frame_redirect_path(comment)
+      review_path(comment.review_thread.review, anchor: helpers.reviewkit_document_anchor(comment.review_thread.document))
+    end
+
+    private
+
+    def set_thread
+      @thread = review_thread_scope.find(params[:review_thread_id])
+    end
+
+    def set_comment
+      @comment = comment_scope(@thread).find(params[:id])
+    end
+
+    def comment_params
+      params.fetch(:comment, ActionController::Parameters.new).permit(*(permitted_comment_attributes + comment_request_attributes))
+    end
+
+    def comment_attributes
+      comment_params.to_h.symbolize_keys.slice(*permitted_comment_attributes)
+    end
+
+    def authorize_comment_management!(action)
+      authorize_reviewkit!(action, @comment)
+      raise Reviewkit::AuthorizationError, "Forbidden action: #{action}" unless comment_manageable?(@comment)
+    end
+
+    def comment_manageable?(comment)
+      comment.author == reviewkit_current_actor
+    end
+
+    def render_comment_frame(status: :ok)
+      if reviewkit_frame_request?
+        render partial: "reviewkit/comments/comment", locals: { comment: @comment }, status: status
+      else
+        redirect_to comment_frame_redirect_path(@comment)
+      end
+    end
+
+    def render_edit_frame(status: :ok)
+      if reviewkit_frame_request?
+        render partial: "reviewkit/comments/edit_form", locals: { comment: @comment }, status: status
+      else
+        redirect_to comment_frame_redirect_path(@comment)
+      end
+    end
+
+    def render_thread_bucket(status:)
+      @review = @thread.review
+      @document = @thread.document
+      @row = @document.diff_rows.find { |row| row.fetch("line_code") == @thread.line_code }
+      @threads = @review.review_threads.includes(:comments)
+                        .where(document: @document, line_code: @thread.line_code)
+                        .order(:created_at)
+
+      respond_to do |format|
+        format.turbo_stream do
+          render turbo_stream: ::Turbo::Streams::TagBuilder.new(view_context).replace(
+            helpers.reviewkit_thread_bucket_row_id(@document, @thread.line_code),
+            partial: "reviewkit/review_threads/bucket_row",
+            locals: {
+              colspan: comment_params[:view] == "unified" ? 4 : 6,
+              composer_open: false,
+              composer_side: nil,
+              document: @document,
+              frame_id: comment_params[:frame_id].presence || helpers.dom_id(@review, :review),
+              line_code: @thread.line_code,
+              review: @review,
+              row: @row,
+              thread_errors: @comment&.errors&.full_messages || [],
+              threads: @threads,
+              view_mode: comment_params[:view] == "unified" ? "unified" : "split"
+            }
+          ), status: status
+        end
+        format.html { redirect_to review_path(@review, anchor: helpers.reviewkit_document_anchor(@document)) }
+      end
+    end
+  end
+end

data/app/controllers/reviewkit/review_threads_controller.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  class ReviewThreadsController < ApplicationController
+    before_action :set_review, only: :create
+    before_action :set_thread, only: %i[show edit update destroy resolve reopen mark_outdated]
+
+    def create
+      authorize_reviewkit!(:comment, @review)
+
+      document = review_documents_scope.find(review_thread_params.fetch(:document_id))
+
+      ReviewThread.transaction do
+        @thread = @review.review_threads.build(
+          build_review_thread_attributes(document)
+        )
+        @thread.save!
+
+        @thread.comments.create!(
+          author: reviewkit_current_actor,
+          body: starter_comment_body,
+          metadata: {}
+        )
+      end
+
+      render_thread_row(document, @thread.line_code)
+    rescue ActiveRecord::RecordInvalid => error
+      render_thread_row(
+        document,
+        review_thread_params.fetch(:line_code),
+        status: :unprocessable_content,
+        thread_errors: error.record.errors.full_messages,
+        composer_open: true,
+        composer_side: review_thread_params[:side]
+      )
+    end
+
+    def show
+      authorize_reviewkit!(:show, @thread.review)
+      render_thread_frame
+    end
+
+    def edit
+      authorize_thread_management!(:edit_thread)
+      render_edit_frame
+    end
+
+    def update
+      authorize_thread_management!(:update_thread)
+
+      if starter_comment.update(thread_params)
+        @thread.reload
+        render_thread_frame
+      else
+        render_edit_frame(status: :unprocessable_content)
+      end
+    end
+
+    def destroy
+      authorize_thread_management!(:destroy_thread)
+      document = @thread.document
+      line_code = @thread.line_code
+      @thread.destroy!
+
+      render_thread_row(document, line_code)
+    end
+
+    def resolve
+      authorize_reviewkit!(:resolve, @thread)
+      @thread.resolve!
+      render_thread_row(@thread.document, @thread.line_code)
+    end
+
+    def reopen
+      authorize_reviewkit!(:reopen, @thread)
+      @thread.reopen!
+      render_thread_row(@thread.document, @thread.line_code)
+    end
+
+    def mark_outdated
+      authorize_reviewkit!(:update_thread_status, @thread)
+      @thread.mark_outdated!
+      render_thread_row(@thread.document, @thread.line_code)
+    end
+
+    protected
+
+    def review_scope
+      Review.all
+    end
+
+    def review_thread_scope
+      ReviewThread.includes(:review, :document, :comments)
+    end
+
+    def permitted_review_thread_attributes
+      []
+    end
+
+    def review_thread_request_attributes
+      %i[
+        body
+        document_id
+        frame_id
+        line_code
+        new_line
+        new_text
+        old_line
+        old_text
+        side
+        view
+      ]
+    end
+
+    def permitted_review_thread_update_attributes
+      %i[body]
+    end
+
+    def review_documents_scope
+      @review.documents
+    end
+
+    def build_review_thread_attributes(document)
+      {
+        document:,
+        line_code: review_thread_params.fetch(:line_code),
+        metadata: line_metadata,
+        new_line: integer_or_nil(review_thread_params[:new_line]),
+        old_line: integer_or_nil(review_thread_params[:old_line]),
+        side: review_thread_params.fetch(:side)
+      }.merge(review_thread_model_attributes)
+    end
+
+    def thread_redirect_path(thread)
+      review_path(thread.review, anchor: helpers.reviewkit_document_anchor(thread.document))
+    end
+
+    def thread_row_redirect_path(review, document, line_code:, composer_open:, composer_side:)
+      review_path(
+        review,
+        document_id: document.id,
+        open_thread: composer_open ? line_code : nil,
+        thread_side: composer_side,
+        view: view_mode
+      )
+    end
+
+    private
+
+    def set_review
+      @review = review_scope.find(params[:review_id])
+    end
+
+    def set_thread
+      @thread = review_thread_scope.find(params[:id])
+    end
+
+    def starter_comment
+      @starter_comment ||= @thread.comments.order(:created_at, :id).first!
+    end
+
+    def review_thread_params
+      params.require(:review_thread).permit(*(review_thread_request_attributes + permitted_review_thread_attributes))
+    end
+
+    def thread_params
+      params.require(:review_thread).permit(*permitted_review_thread_update_attributes)
+    end
+
+    def review_thread_model_attributes
+      review_thread_params.to_h.symbolize_keys.slice(*permitted_review_thread_attributes)
+    end
+
+    def starter_comment_body
+      review_thread_params.fetch(:body)
+    end
+
+    def integer_or_nil(value)
+      value.present? ? value.to_i : nil
+    end
+
+    def line_metadata
+      {
+        "old_text" => review_thread_params[:old_text].to_s,
+        "new_text" => review_thread_params[:new_text].to_s
+      }
+    end
+
+    def authorize_thread_management!(action)
+      authorize_reviewkit!(action, @thread)
+      raise Reviewkit::AuthorizationError, "Forbidden action: #{action}" unless helpers.reviewkit_thread_manageable?(@thread)
+    end
+
+    def render_thread_frame(status: :ok)
+      if reviewkit_frame_request?
+        render partial: "reviewkit/review_threads/thread",
+               locals: {
+                 frame_id: requested_frame_id(@thread.review),
+                 review: @thread.review,
+                 thread: @thread,
+                 view_mode: view_mode
+               },
+               status: status
+      else
+        redirect_to thread_redirect_path(@thread)
+      end
+    end
+
+    def render_edit_frame(status: :ok)
+      if reviewkit_frame_request?
+        render partial: "reviewkit/review_threads/edit_form",
+               locals: {
+                 comment: starter_comment,
+                 frame_id: requested_frame_id(@thread.review),
+                 review: @thread.review,
+                 thread: @thread,
+                 view_mode: view_mode
+               },
+               status: status
+      else
+        redirect_to thread_redirect_path(@thread)
+      end
+    end
+
+    def render_thread_row(document, line_code, status: :ok, thread_errors: [], composer_open: false, composer_side: nil)
+      review = document.review
+      row = document.diff_rows.find { |diff_row| diff_row.fetch("line_code") == line_code }
+      threads = review.review_threads.includes(:comments)
+                      .where(document: document, line_code: line_code)
+                      .order(:created_at)
+
+      respond_to do |format|
+        format.turbo_stream do
+          render turbo_stream: ::Turbo::Streams::TagBuilder.new(view_context).replace(
+            helpers.reviewkit_thread_bucket_row_id(document, line_code),
+            partial: "reviewkit/review_threads/bucket_row",
+            locals: {
+              colspan: view_mode == "unified" ? 4 : 6,
+              composer_open: composer_open || thread_errors.present?,
+              composer_side: composer_side,
+              document: document,
+              frame_id: requested_frame_id(review),
+              line_code: line_code,
+              review: review,
+              row: row,
+              thread_errors: thread_errors,
+              threads: threads,
+              view_mode: view_mode
+            }
+          ), status: status
+        end
+        format.html do
+          redirect_to thread_row_redirect_path(
+            review,
+            document,
+            line_code:,
+            composer_open: composer_open || thread_errors.present?,
+            composer_side:
+          )
+        end
+      end
+    end
+
+    def requested_frame_id(review)
+      params[:frame_id].presence || request_review_thread_param(:frame_id).presence || helpers.dom_id(review, :review)
+    end
+
+    def view_mode
+      requested_view = params[:view].presence || request_review_thread_param(:view).presence
+      requested_view == "unified" ? "unified" : "split"
+    end
+
+    def request_review_thread_param(key)
+      review_thread_params[key] if params[:review_thread].present?
+    end
+  end
+end

data/app/controllers/reviewkit/reviews_controller.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  class ReviewsController < ApplicationController
+    before_action :set_review, only: %i[show edit update approve reject destroy]
+    before_action :set_review_display_state, only: %i[show edit update approve reject]
+    before_action :set_thread_index, only: %i[show edit update approve reject]
+
+    def index
+      @reviews = reviews_scope.includes(*review_index_includes)
+      authorize_reviewkit!(:index, Review)
+    end
+
+    def show
+      authorize_reviewkit!(:show, @review)
+    end
+
+    def edit
+      authorize_reviewkit!(:edit_review, @review)
+      @editing_review = true
+      render :show
+    end
+
+    def update
+      authorize_reviewkit!(:update_review, @review)
+
+      if @review.update(review_params)
+        redirect_to review_redirect_path(@review), status: :see_other, notice: "Review updated."
+      else
+        @editing_review = true
+        render :show, status: :unprocessable_content
+      end
+    end
+
+    def approve
+      authorize_reviewkit!(:approve, @review)
+      transition_review!(:approve!, :notice, "Review approved.")
+    end
+
+    def reject
+      authorize_reviewkit!(:reject, @review)
+      transition_review!(:reject!, :alert, "Review rejected.")
+    end
+
+    def destroy
+      authorize_reviewkit!(:destroy, @review)
+      @review.destroy!
+
+      redirect_to reviews_index_path, status: :see_other, notice: "Review deleted."
+    end
+
+    protected
+
+    def reviews_scope
+      Review.order(updated_at: :desc)
+    end
+
+    def review_scope
+      Review.includes(review_includes)
+    end
+
+    def review_index_includes
+      [ :documents, :review_threads ]
+    end
+
+    def review_includes
+      [ { documents: { review_threads: :comments } }, { review_threads: :comments } ]
+    end
+
+    def permitted_review_attributes
+      %i[title description]
+    end
+
+    def review_redirect_path(review)
+      review_path(review, document_id: @selected_document&.id, view: @view_mode)
+    end
+
+    def reviews_index_path
+      reviews_path
+    end
+
+    def review_transition_failure_message(review)
+      review.errors.full_messages.to_sentence.presence || "Unable to update the review."
+    end
+
+    private
+
+    def set_review
+      @review = review_scope.find(params[:id])
+    end
+
+    def set_review_display_state
+      @view_mode = permitted_view_mode
+      @selected_document = selected_document
+      @open_thread_line_code = params[:open_thread].presence
+      @open_thread_side = permitted_thread_side
+    end
+
+    def permitted_view_mode
+      params[:view] == "unified" ? "unified" : "split"
+    end
+
+    def selected_document
+      requested_document = review_documents_scope.find_by(id: params[:document_id]) if params[:document_id].present?
+      requested_document || review_documents_scope.first
+    end
+
+    def permitted_thread_side
+      return "old" if params[:thread_side] == "old"
+      return "new" if params[:thread_side] == "new"
+
+      nil
+    end
+
+    def set_thread_index
+      @thread_index = selected_document_threads_scope.group_by { |thread| [ thread.document_id, thread.line_code ] }
+    end
+
+    def review_params
+      params.require(:review).permit(*permitted_review_attributes)
+    end
+
+    def transition_review!(method_name, flash_type, message)
+      @review.public_send(method_name)
+      redirect_to review_redirect_path(@review), status: :see_other, flash_type => message
+    rescue ActiveRecord::RecordInvalid => error
+      @review = error.record
+      flash.now[:alert] = review_transition_failure_message(@review)
+      render :show, status: :unprocessable_content
+    end
+
+    def review_documents_scope
+      @review.documents
+    end
+
+    def selected_document_threads_scope
+      @review.review_threads.includes(:comments)
+             .where(document: @selected_document)
+             .order(:created_at)
+    end
+  end
+end

data/app/helpers/reviewkit/application_helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  module ApplicationHelper
+    include AssetHelper
+    include DiffHelper
+    include FlashHelper
+    include FrameHelper
+    include IconHelper
+    include ReviewThreadHelper
+  end
+end

data/app/helpers/reviewkit/asset_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  module AssetHelper
+    include Importmap::ImportmapTagsHelper
+
+    def reviewkit_assets(importmap: false, entry_point: "reviewkit/application")
+      tags = [ reviewkit_stylesheet_tag ]
+
+      if importmap
+        tags << javascript_importmap_tags(entry_point)
+      else
+        tags << javascript_import_module_tag(entry_point)
+      end
+
+      safe_join(tags, "\n")
+    end
+
+    def reviewkit_page_assets(entry_point: "reviewkit/application")
+      if controller.respond_to?(:reviewkit_engine_layout?, true) && controller.send(:reviewkit_engine_layout?)
+        reviewkit_assets(importmap: true, entry_point: entry_point)
+      else
+        reviewkit_stylesheet_tag
+      end
+    end
+
+    def reviewkit_page_module_tag(entry_point: "reviewkit/application")
+      return "".html_safe if controller.respond_to?(:reviewkit_engine_layout?, true) && controller.send(:reviewkit_engine_layout?)
+
+      javascript_import_module_tag(entry_point)
+    end
+
+    private
+
+    def reviewkit_stylesheet_tag
+      stylesheet_link_tag("reviewkit/application", media: "all", "data-turbo-track": "reload")
+    end
+  end
+end