reviewkit 0.1.0

data/app/helpers/reviewkit/diff_helper.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "rouge"
+
+module Reviewkit
+  module DiffHelper
+    def reviewkit_document_badge_class(document)
+      case document.status
+      when "added"
+        "bg-emerald-100 text-emerald-800"
+      when "removed"
+        "bg-rose-100 text-rose-800"
+      when "modified"
+        "bg-amber-100 text-amber-900"
+      else
+        "bg-slate-200 text-slate-700"
+      end
+    end
+
+    def reviewkit_status_pill_class(review_or_status)
+      status = review_or_status.respond_to?(:status) ? review_or_status.status : review_or_status.to_s
+
+      case status
+      when "approved"
+        "reviewkit-status-pill reviewkit-status-pill--approved"
+      when "rejected"
+        "reviewkit-status-pill reviewkit-status-pill--rejected"
+      when "closed"
+        "reviewkit-status-pill reviewkit-status-pill--closed"
+      when "resolved"
+        "reviewkit-status-pill reviewkit-status-pill--resolved"
+      when "outdated"
+        "reviewkit-status-pill reviewkit-status-pill--outdated"
+      when "draft"
+        "reviewkit-status-pill reviewkit-status-pill--draft"
+      else
+        "reviewkit-status-pill"
+      end
+    end
+
+    def reviewkit_diff_row_class(row)
+      "reviewkit-line reviewkit-line--#{row.fetch("kind")}"
+    end
+
+    def reviewkit_unified_group_rows(row, document: nil)
+      inline_changes =
+        if reviewkit_inline_source_kind(row) == "changed"
+          reviewkit_inline_changes(row, document: document)
+        else
+          row["inline_changes"]
+        end
+
+      case row.fetch("kind")
+      when "changed"
+        [
+          reviewkit_unified_row_payload(row, side: "old", kind: "removed", line: row["old_line"], text: row["old_text"], inline_changes: inline_changes),
+          reviewkit_unified_row_payload(row, side: "new", kind: "added", line: row["new_line"], text: row["new_text"], inline_changes: inline_changes)
+        ]
+      when "removed"
+        [ reviewkit_unified_row_payload(row, side: "old", kind: "removed", line: row["old_line"], text: row["old_text"], inline_changes: inline_changes) ]
+      when "added"
+        [ reviewkit_unified_row_payload(row, side: "new", kind: "added", line: row["new_line"], text: row["new_text"], inline_changes: inline_changes) ]
+      else
+        [ reviewkit_unified_row_payload(row, side: "context", kind: "context", line: row["new_line"] || row["old_line"], text: row["new_text"].presence || row["old_text"], inline_changes: inline_changes) ]
+      end
+    end
+
+    def reviewkit_inline_ranges(row, side:, document: nil)
+      return [] unless reviewkit_inline_source_kind(row) == "changed"
+
+      normalized_side = side.to_s
+      return [] unless %w[old new].include?(normalized_side)
+
+      Array(reviewkit_inline_changes(row, document: document)[normalized_side])
+    end
+
+    def reviewkit_highlight_line(text, language, inline_ranges: nil, inline_side: nil)
+      return " ".html_safe if text.blank?
+
+      lexer = Rouge::Lexer.find_fancy(language.to_s, text) || Rouge::Lexers::PlainText.new
+      formatter = Rouge::Formatters::HTML.new
+      highlighted_html = formatter.format(lexer.lex(text))
+      rendered_html = reviewkit_apply_inline_ranges(highlighted_html, inline_ranges, inline_side)
+
+      content_tag(:span, rendered_html, class: "highlight")
+    end
+
+    def reviewkit_line_number(value)
+      value.presence || " ".html_safe
+    end
+
+    def reviewkit_render_comment_body(comment)
+      simple_format(h(comment.body), class: "reviewkit-comment-body")
+    end
+
+    private
+
+    def reviewkit_unified_row_payload(row, side:, kind:, line:, text:, inline_changes:)
+      {
+        "kind" => kind,
+        "line_code" => row.fetch("line_code"),
+        "new_line" => side == "old" ? nil : row["new_line"],
+        "new_text" => side == "old" ? "" : row["new_text"].to_s,
+        "old_line" => side == "new" ? nil : row["old_line"],
+        "old_text" => side == "new" ? "" : row["old_text"].to_s,
+        "inline_changes" => inline_changes,
+        "side" => side,
+        "source_kind" => row.fetch("kind"),
+        "text" => text.to_s,
+        "line" => line
+      }
+    end
+
+    def reviewkit_inline_source_kind(row)
+      row["source_kind"].presence || row["kind"].to_s
+    end
+
+    def reviewkit_inline_changes(row, document: nil)
+      row["inline_changes"] ||= begin
+        context = reviewkit_intraline_context(document)
+        old_text = row["old_text"].to_s
+        new_text = row["new_text"].to_s
+
+        if Reviewkit::Diffs::IntralineBudget.allow?(
+          old_text: old_text,
+          new_text: new_text,
+          review_document_count: context[:review_document_count],
+          changed_row_count: context[:changed_row_count]
+        )
+          Reviewkit::Diffs::IntralineDiff.call(old_text:, new_text:)
+        else
+          reviewkit_empty_inline_changes
+        end
+      end
+    end
+
+    def reviewkit_intraline_context(document)
+      return {} if document.blank?
+
+      document.instance_variable_get(:@reviewkit_intraline_context) || begin
+        context = {
+          changed_row_count: document.diff_rows.count { |row| row["kind"] == "changed" },
+          review_document_count: document.review&.documents&.size
+        }
+        document.instance_variable_set(:@reviewkit_intraline_context, context)
+      end
+    end
+
+    def reviewkit_empty_inline_changes
+      { "old" => [], "new" => [] }
+    end
+
+    def reviewkit_apply_inline_ranges(highlighted_html, inline_ranges, inline_side)
+      normalized_side = inline_side.to_s
+      normalized_ranges = reviewkit_merge_inline_ranges(Array(inline_ranges))
+      return highlighted_html.html_safe if normalized_ranges.empty? || !%w[old new].include?(normalized_side)
+
+      fragment = Nokogiri::HTML::DocumentFragment.parse(highlighted_html)
+      document = fragment.document
+      text_offset = 0
+      range_index = 0
+
+      fragment.xpath(".//text()").each do |node|
+        node_text = node.text
+        node_start = text_offset
+        node_end = node_start + node_text.length
+        text_offset = node_end
+
+        next if node_text.empty?
+
+        range_index += 1 while range_index < normalized_ranges.length && normalized_ranges[range_index].fetch("end") <= node_start
+
+        node_ranges = []
+        index = range_index
+
+        while index < normalized_ranges.length && normalized_ranges[index].fetch("start") < node_end
+          node_ranges << normalized_ranges[index]
+          index += 1
+        end
+
+        next if node_ranges.empty?
+
+        cursor = 0
+        node_ranges.each do |range|
+          local_start = [ range.fetch("start") - node_start, 0 ].max
+          local_end = [ range.fetch("end") - node_start, node_text.length ].min
+          next if local_start >= local_end
+
+          if local_start > cursor
+            node.add_previous_sibling(Nokogiri::XML::Text.new(node_text[cursor...local_start], document))
+          end
+
+          wrapper = Nokogiri::XML::Node.new("span", document)
+          wrapper["class"] = "reviewkit-inline-change reviewkit-inline-change--#{normalized_side}"
+          wrapper.content = node_text[local_start...local_end]
+          node.add_previous_sibling(wrapper)
+          cursor = local_end
+        end
+
+        if cursor < node_text.length
+          node.add_previous_sibling(Nokogiri::XML::Text.new(node_text[cursor..], document))
+        end
+
+        node.remove
+      end
+
+      fragment.to_html.html_safe
+    end
+
+    def reviewkit_merge_inline_ranges(ranges)
+      ranges
+        .map do |range|
+          {
+            "start" => range["start"] || range[:start],
+            "end" => range["end"] || range[:end]
+          }
+        end
+        .select { |range| range["start"].present? && range["end"].present? && range["start"] < range["end"] }
+        .sort_by { |range| [ range.fetch("start"), range.fetch("end") ] }
+        .each_with_object([]) do |range, merged|
+          if merged.empty? || range.fetch("start") > merged.last.fetch("end")
+            merged << range
+          else
+            merged.last["end"] = [ merged.last.fetch("end"), range.fetch("end") ].max
+          end
+        end
+    end
+  end
+end

data/app/helpers/reviewkit/flash_helper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  module FlashHelper
+    def reviewkit_flash_class(type)
+      base_class = "reviewkit-flash"
+
+      case type.to_s
+      when "notice"
+        "#{base_class} #{base_class}--notice"
+      when "alert"
+        "#{base_class} #{base_class}--alert"
+      else
+        base_class
+      end
+    end
+
+    def reviewkit_flash_shell_class
+      base_class = "reviewkit-flash-shell"
+
+      if reviewkit_frame_request?
+        "#{base_class} #{base_class}--inline"
+      else
+        "#{base_class} #{base_class}--page"
+      end
+    end
+
+    def reviewkit_flash_label(type)
+      type.to_s.humanize
+    end
+
+    def reviewkit_flash_role(type)
+      type.to_s == "alert" ? "alert" : "status"
+    end
+  end
+end

data/app/helpers/reviewkit/frame_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  module FrameHelper
+    def reviewkit_requested_frame_id
+      request.headers["Turbo-Frame"].presence || params[:reviewkit_frame_id].presence
+    end
+
+    def reviewkit_frame_request?
+      reviewkit_requested_frame_id.present?
+    end
+
+    def reviewkit_wrap_in_frame(&block)
+      content = capture(&block)
+      frame_id = reviewkit_requested_frame_id
+      return content if frame_id.blank?
+
+      turbo_frame_tag(frame_id) { content }
+    end
+
+    def reviewkit_document_anchor(document)
+      "document-#{document.id}"
+    end
+
+    def reviewkit_review_frame_id(review)
+      reviewkit_requested_frame_id.presence || dom_id(review, :review)
+    end
+
+    def reviewkit_document_path_parts(document_or_path)
+      path = document_or_path.respond_to?(:path) ? document_or_path.path.to_s : document_or_path.to_s
+      directory = File.dirname(path)
+      directory = nil if directory.blank? || directory == "."
+
+      [ directory ? "#{directory}/" : nil, File.basename(path) ]
+    end
+  end
+end

data/app/helpers/reviewkit/icon_helper.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  module IconHelper
+    def reviewkit_file_icon(class_name: "reviewkit-file-icon")
+      content_tag(
+        :svg,
+        safe_join([
+          tag.path(
+            d: "M4.75 1.5h4.9L12.5 4.35v7.9a1.25 1.25 0 0 1-1.25 1.25h-6.5A1.25 1.25 0 0 1 3.5 12.25v-9.5A1.25 1.25 0 0 1 4.75 1.5Z",
+            fill: "none",
+            stroke: "currentColor",
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            "stroke-width": "1.1"
+          ),
+          tag.path(
+            d: "M9.5 1.75v2.5H12",
+            fill: "none",
+            stroke: "currentColor",
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            "stroke-width": "1.1"
+          )
+        ]),
+        class: class_name,
+        viewBox: "0 0 16 16",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg",
+        "aria-hidden": "true"
+      )
+    end
+
+    def reviewkit_chevron_right_icon(class_name: "reviewkit-inline-icon")
+      content_tag(
+        :svg,
+        tag.path(
+          d: "M8.22 5.22a.75.75 0 0 1 1.06 0l4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.75.75 0 1 1-1.06-1.06L11.94 10 8.22 6.28a.75.75 0 0 1 0-1.06Z",
+          "clip-rule": "evenodd",
+          "fill-rule": "evenodd"
+        ),
+        class: class_name,
+        viewBox: "0 0 20 20",
+        fill: "currentColor",
+        "aria-hidden": "true"
+      )
+    end
+
+    def reviewkit_pencil_icon(class_name: "reviewkit-inline-icon")
+      content_tag(
+        :svg,
+        safe_join([
+          tag.path(
+            d: "M16.862 3.487a2.25 2.25 0 0 0-3.182 0l-8.25 8.25a2.25 2.25 0 0 0-.588 1.06l-.74 3.333a.75.75 0 0 0 .895.895l3.333-.74a2.25 2.25 0 0 0 1.06-.588l8.25-8.25a2.25 2.25 0 0 0 0-3.182Z",
+            fill: "none",
+            stroke: "currentColor",
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            "stroke-width": "1.5"
+          ),
+          tag.path(
+            d: "m12.75 4.5 2.75 2.75",
+            fill: "none",
+            stroke: "currentColor",
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            "stroke-width": "1.5"
+          )
+        ]),
+        class: class_name,
+        viewBox: "0 0 20 20",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg",
+        "aria-hidden": "true"
+      )
+    end
+
+    def reviewkit_trash_icon(class_name: "reviewkit-inline-icon")
+      content_tag(
+        :svg,
+        safe_join([
+          tag.path(
+            d: "M7.5 2.75h5a.75.75 0 0 1 .75.75V5h3.25a.75.75 0 0 1 0 1.5h-.69l-.63 9.12A2.25 2.25 0 0 1 12.94 17.75H7.06a2.25 2.25 0 0 1-2.24-2.13L4.19 6.5H3.5a.75.75 0 0 1 0-1.5h3.25V3.5a.75.75 0 0 1 .75-.75Z",
+            fill: "none",
+            stroke: "currentColor",
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            "stroke-width": "1.5"
+          ),
+          tag.path(
+            d: "M8.5 8.25v5.5M11.5 8.25v5.5",
+            fill: "none",
+            stroke: "currentColor",
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            "stroke-width": "1.5"
+          )
+        ]),
+        class: class_name,
+        viewBox: "0 0 20 20",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg",
+        "aria-hidden": "true"
+      )
+    end
+  end
+end

data/app/helpers/reviewkit/review_thread_helper.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  module ReviewThreadHelper
+    def reviewkit_actor_label(actor)
+      return "System" unless actor
+      return actor.name if actor.respond_to?(:name) && actor.name.present?
+      return actor.email if actor.respond_to?(:email) && actor.email.present?
+
+      actor.to_s
+    end
+
+    def reviewkit_thread_bucket_id(document, line_code)
+      "reviewkit-document-#{document.id}-line-#{line_code}"
+    end
+
+    def reviewkit_thread_bucket_row_id(document, line_code)
+      "#{reviewkit_thread_bucket_id(document, line_code)}-row"
+    end
+
+    def reviewkit_threads_for(thread_index, document, row)
+      Array(thread_index[[ document.id, row.fetch("line_code") ]])
+    end
+
+    def reviewkit_thread_starter_comment(thread)
+      thread.comments.min_by { |comment| [ comment.created_at, comment.id ] }
+    end
+
+    def reviewkit_thread_preview(thread)
+      truncate(reviewkit_thread_starter_comment(thread)&.body.to_s, length: 120)
+    end
+
+    def reviewkit_thread_manageable?(thread)
+      starter_comment = reviewkit_thread_starter_comment(thread)
+      return false unless starter_comment
+
+      reviewkit_comment_manageable?(starter_comment)
+    end
+
+    def reviewkit_comment_manageable?(comment)
+      comment.author == reviewkit_current_actor
+    end
+
+    def reviewkit_comment_destroyable?(comment)
+      return false unless reviewkit_comment_manageable?(comment)
+
+      comment.review_thread.comments.size > 1 || comment.review_thread.comments.first == comment
+    end
+
+    def reviewkit_comment_edited?(comment)
+      comment.updated_at.present? && comment.created_at.present? && comment.updated_at > comment.created_at
+    end
+  end
+end

data/app/models/concerns/reviewkit/notifies_lifecycle_events.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  module NotifiesLifecycleEvents
+    extend ActiveSupport::Concern
+
+    included do
+      after_create_commit -> { instrument_reviewkit_event(:created) }
+      after_update_commit :instrument_reviewkit_update_events
+      after_destroy_commit -> { instrument_reviewkit_event(:destroyed) }
+    end
+
+    private
+
+    def instrument_reviewkit_update_events
+      instrument_reviewkit_event(:updated)
+      return unless respond_to?(:saved_change_to_status?) && saved_change_to_status?
+
+      from, to = saved_change_to_status
+      instrument_reviewkit_event(:status_changed, from:, to:)
+    end
+
+    def instrument_reviewkit_event(event, **payload)
+      ActiveSupport::Notifications.instrument(
+        "reviewkit.#{self.class.model_name.element}.#{event}",
+        reviewkit_notification_payload.merge(payload.compact)
+      )
+    end
+
+    def reviewkit_notification_payload
+      {
+        actor: Reviewkit::Current.actor,
+        controller: Reviewkit::Current.controller,
+        record: self,
+        source: Reviewkit::Current.source
+      }.compact
+    end
+  end
+end

data/app/models/reviewkit/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/reviewkit/comment.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  class Comment < ApplicationRecord
+    include NotifiesLifecycleEvents
+
+    belongs_to :review_thread, inverse_of: :comments
+    belongs_to :author, polymorphic: true, optional: true
+
+    delegate :document, :review, to: :review_thread
+
+    validates :body, presence: true
+    validate :metadata_must_be_hash
+
+    before_validation :normalize_metadata
+
+    private
+
+    def normalize_metadata
+      self.metadata = metadata.deep_stringify_keys if metadata.is_a?(Hash)
+    end
+
+    def metadata_must_be_hash
+      return if metadata.nil? || metadata.is_a?(Hash)
+
+      errors.add(:metadata, "must be a hash")
+    end
+  end
+end

data/app/models/reviewkit/current.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :actor, :controller, :source
+  end
+end

data/app/models/reviewkit/document.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  class Document < ApplicationRecord
+    attr_accessor :intraline_review_document_count
+
+    enum :status, {
+      added: "added",
+      removed: "removed",
+      modified: "modified",
+      unchanged: "unchanged"
+    }, validate: true
+
+    belongs_to :review, inverse_of: :documents
+    has_many :review_threads, dependent: :destroy, inverse_of: :document
+
+    validates :language, presence: true
+    validates :path, presence: true
+    validates :position, numericality: { greater_than_or_equal_to: 0 }
+    validates :path, uniqueness: { scope: :review_id }
+    validate :metadata_must_be_hash
+
+    before_validation :assign_status
+    before_validation :refresh_diff_cache
+    before_validation :normalize_metadata
+
+    def additions_count
+      diff_cache.dig("stats", "additions").to_i
+    end
+
+    def deletions_count
+      diff_cache.dig("stats", "deletions").to_i
+    end
+
+    def diff_rows
+      Array(diff_cache["rows"])
+    end
+
+    private
+
+    def assign_status
+      self.status =
+        if old_content.blank? && new_content.present?
+          "added"
+        elsif old_content.present? && new_content.blank?
+          "removed"
+        elsif old_content == new_content
+          "unchanged"
+        else
+          "modified"
+        end
+    end
+
+    def refresh_diff_cache
+      self.diff_cache = Reviewkit::Diffs::SplitDiff.call(
+        old_content: old_content.to_s,
+        new_content: new_content.to_s,
+        review_document_count: resolved_review_document_count
+      )
+    end
+
+    def resolved_review_document_count
+      return intraline_review_document_count if intraline_review_document_count.present?
+      return unless review
+
+      review.documents.size
+    end
+
+    def normalize_metadata
+      self.metadata = metadata.deep_stringify_keys if metadata.is_a?(Hash)
+    end
+
+    def metadata_must_be_hash
+      return if metadata.nil? || metadata.is_a?(Hash)
+
+      errors.add(:metadata, "must be a hash")
+    end
+  end
+end

data/app/models/reviewkit/review.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  class Review < ApplicationRecord
+    include NotifiesLifecycleEvents
+
+    enum :status, {
+      draft: "draft",
+      open: "open",
+      approved: "approved",
+      rejected: "rejected",
+      closed: "closed"
+    }, validate: true
+
+    belongs_to :reviewable, polymorphic: true, optional: true
+    belongs_to :creator, polymorphic: true, optional: true
+    has_many :documents, -> { order(:position, :id) }, dependent: :destroy, inverse_of: :review
+    has_many :review_threads, dependent: :destroy, inverse_of: :review
+
+    validates :description, length: { maximum: 10_000 }, allow_blank: true
+    validates :title, presence: true
+    validate :metadata_must_be_hash
+
+    validate :final_status_requires_all_threads_resolved, if: :will_save_change_to_status?
+    before_validation :normalize_metadata
+
+    def open_threads_count
+      review_threads.open.count
+    end
+
+    def resolved_threads_count
+      review_threads.resolved.count
+    end
+
+    def approve!
+      update!(status: "approved")
+    end
+
+    def reject!
+      update!(status: "rejected")
+    end
+
+    def close!
+      update!(status: "closed")
+    end
+
+    private
+
+    def normalize_metadata
+      self.metadata = metadata.deep_stringify_keys if metadata.is_a?(Hash)
+    end
+
+    def final_status_requires_all_threads_resolved
+      return unless approved? || closed?
+      return unless review_threads.open.exists?
+
+      errors.add(:status, "cannot change while open threads remain")
+    end
+
+    def metadata_must_be_hash
+      return if metadata.nil? || metadata.is_a?(Hash)
+
+      errors.add(:metadata, "must be a hash")
+    end
+  end
+end