reviewkit 0.1.0

data/app/models/reviewkit/review_thread.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  class ReviewThread < ApplicationRecord
+    include NotifiesLifecycleEvents
+
+    enum :status, {
+      open: "open",
+      resolved: "resolved",
+      outdated: "outdated"
+    }, validate: true
+
+    belongs_to :review, inverse_of: :review_threads
+    belongs_to :document, inverse_of: :review_threads
+    belongs_to :resolved_by, polymorphic: true, optional: true
+    has_many :comments, -> { order(:created_at, :id) }, dependent: :destroy, inverse_of: :review_thread
+
+    validates :line_code, presence: true
+    validates :side, presence: true
+    validates :side, inclusion: { in: %w[old new] }
+    validate :anchor_line_must_match_side
+    validate :document_must_belong_to_review
+    validate :metadata_must_be_hash
+
+    before_validation :assign_review_from_document
+    before_validation :normalize_metadata
+
+    scope :open, -> { where(status: "open") }
+    scope :outdated, -> { where(status: "outdated") }
+    scope :resolved, -> { where(status: "resolved") }
+
+    def resolve!
+      update!(status: "resolved", resolved_at: Time.current, resolved_by: Reviewkit::Current.actor)
+    end
+
+    def reopen!
+      update!(status: "open", resolved_at: nil, resolved_by: nil)
+    end
+
+    def mark_outdated!
+      update!(status: "outdated", resolved_at: nil, resolved_by: nil)
+    end
+
+    private
+
+    def assign_review_from_document
+      self.review ||= document&.review
+    end
+
+    def normalize_metadata
+      self.metadata = metadata.deep_stringify_keys if metadata.is_a?(Hash)
+    end
+
+    def anchor_line_must_match_side
+      return if side.blank?
+      return if side == "old" && old_line.present?
+      return if side == "new" && new_line.present?
+
+      errors.add(:base, "must include a #{side} line anchor")
+    end
+
+    def document_must_belong_to_review
+      return if review.blank? || document.blank?
+      return if document.review_id == review_id
+
+      errors.add(:document, "must belong to the same review")
+    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/services/reviewkit/diffs/intraline_budget.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  module Diffs
+    class IntralineBudget
+      def self.allow?(...)
+        new(...).allow?
+      end
+
+      def initialize(old_text:, new_text:, review_document_count: nil, changed_row_count: nil, limits: Reviewkit.config.intraline_limits)
+        @old_text = old_text.to_s
+        @new_text = new_text.to_s
+        @review_document_count = review_document_count
+        @changed_row_count = changed_row_count
+        @limits = limits
+      end
+
+      def allow?
+        return false unless @limits.enabled
+        return false if exceeds_limit?(@review_document_count, @limits.max_review_files)
+        return false if exceeds_limit?(@changed_row_count, @limits.max_changed_lines)
+        return false if exceeds_line_length_limit?
+
+        true
+      end
+
+      private
+
+      def exceeds_limit?(value, limit)
+        value.present? && limit.present? && value > limit
+      end
+
+      def exceeds_line_length_limit?
+        return false unless @limits.max_line_length.present?
+
+        [ @old_text.length, @new_text.length ].max > @limits.max_line_length
+      end
+    end
+  end
+end

data/app/services/reviewkit/diffs/intraline_diff.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "diff/lcs"
+
+module Reviewkit
+  module Diffs
+    class IntralineDiff
+      SIMILARITY_THRESHOLD = 0.5
+      TOKEN_PATTERN = /\s+|[[:alnum:]_]+|[^[:alnum:]_\s]+/
+
+      def self.call(...)
+        new(...).call
+      end
+
+      def initialize(old_text:, new_text:)
+        @old_text = old_text.to_s
+        @new_text = new_text.to_s
+      end
+
+      def call
+        return empty_ranges if @old_text == @new_text
+
+        old_tokens = tokenize(@old_text)
+        new_tokens = tokenize(@new_text)
+        ranges = empty_ranges
+        pending_old = []
+        pending_new = []
+        old_index = 0
+        new_index = 0
+        shared_non_whitespace_chars = 0
+
+        Diff::LCS.sdiff(token_texts(old_tokens), token_texts(new_tokens)).each do |change|
+          case change.action
+          when "="
+            shared_non_whitespace_chars += append_group_ranges(ranges, pending_old, pending_new)
+            pending_old = []
+            pending_new = []
+            shared_non_whitespace_chars += non_whitespace_character_count(old_tokens.fetch(old_index).fetch("text"))
+            old_index += 1
+            new_index += 1
+          when "!"
+            pending_old << old_tokens.fetch(old_index)
+            pending_new << new_tokens.fetch(new_index)
+            old_index += 1
+            new_index += 1
+          when "-"
+            pending_old << old_tokens.fetch(old_index)
+            old_index += 1
+          when "+"
+            pending_new << new_tokens.fetch(new_index)
+            new_index += 1
+          end
+        end
+
+        shared_non_whitespace_chars += append_group_ranges(ranges, pending_old, pending_new)
+        normalized_ranges = normalize_ranges(ranges)
+
+        return normalized_ranges if meets_similarity_threshold?(shared_non_whitespace_chars)
+
+        empty_ranges
+      end
+
+      private
+
+      def tokenize(text)
+        cursor = 0
+
+        text.to_enum(:scan, TOKEN_PATTERN).map do
+          token_text = Regexp.last_match(0)
+          token = {
+            "kind" => token_kind(token_text),
+            "text" => token_text,
+            "start" => cursor,
+            "end" => cursor + token_text.length
+          }
+          cursor = token.fetch("end")
+          token
+        end
+      end
+
+      def token_texts(tokens)
+        tokens.map { |token| token.fetch("text") }
+      end
+
+      def token_kind(token_text)
+        return "whitespace" if token_text.match?(/\A\s+\z/)
+        return "word" if token_text.match?(/\A[[:alnum:]_]+\z/)
+
+        "punctuation"
+      end
+
+      def append_group_ranges(ranges, old_tokens, new_tokens)
+        return 0 if old_tokens.empty? && new_tokens.empty?
+
+        if old_tokens.empty?
+          ranges["new"] << range_from_tokens(new_tokens)
+          return 0
+        end
+
+        if new_tokens.empty?
+          ranges["old"] << range_from_tokens(old_tokens)
+          return 0
+        end
+
+        if refine_single_token_pair?(old_tokens, new_tokens)
+          return append_character_ranges(ranges, old_tokens.first, new_tokens.first)
+        end
+
+        ranges["old"] << range_from_tokens(old_tokens)
+        ranges["new"] << range_from_tokens(new_tokens)
+        0
+      end
+
+      def refine_single_token_pair?(old_tokens, new_tokens)
+        return false unless old_tokens.one? && new_tokens.one?
+
+        old_token = old_tokens.first
+        new_token = new_tokens.first
+        return true if old_token.fetch("kind") == "whitespace" || new_token.fetch("kind") == "whitespace"
+        return false unless old_token.fetch("kind") == new_token.fetch("kind")
+
+        old_text = old_token.fetch("text")
+        new_text = new_token.fetch("text")
+
+        old_text.start_with?(new_text) ||
+          new_text.start_with?(old_text) ||
+          old_text.end_with?(new_text) ||
+          new_text.end_with?(old_text) ||
+          common_prefix_length(old_text, new_text).positive? ||
+          common_suffix_length(old_text, new_text).positive?
+      end
+
+      def append_character_ranges(ranges, old_token, new_token)
+        old_offset = old_token.fetch("start")
+        new_offset = new_token.fetch("start")
+        old_index = 0
+        new_index = 0
+        shared_non_whitespace_chars = 0
+
+        Diff::LCS.sdiff(old_token.fetch("text").chars, new_token.fetch("text").chars).each do |change|
+          case change.action
+          when "="
+            shared_non_whitespace_chars += 1 unless change.old_element.match?(/\s/)
+            old_index += 1
+            new_index += 1
+          when "!"
+            ranges["old"] << build_range(old_offset + old_index, old_offset + old_index + 1)
+            ranges["new"] << build_range(new_offset + new_index, new_offset + new_index + 1)
+            old_index += 1
+            new_index += 1
+          when "-"
+            ranges["old"] << build_range(old_offset + old_index, old_offset + old_index + 1)
+            old_index += 1
+          when "+"
+            ranges["new"] << build_range(new_offset + new_index, new_offset + new_index + 1)
+            new_index += 1
+          end
+        end
+
+        shared_non_whitespace_chars
+      end
+
+      def range_from_tokens(tokens)
+        build_range(tokens.first.fetch("start"), tokens.last.fetch("end"))
+      end
+
+      def normalize_ranges(ranges)
+        {
+          "old" => merge_ranges(Array(ranges["old"])),
+          "new" => merge_ranges(Array(ranges["new"]))
+        }
+      end
+
+      def merge_ranges(ranges)
+        ranges
+          .map { |range| build_range(range.fetch("start"), range.fetch("end")) }
+          .reject { |range| range.fetch("start") >= range.fetch("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
+
+      def build_range(start_index, end_index)
+        { "start" => start_index, "end" => end_index }
+      end
+
+      def meets_similarity_threshold?(shared_non_whitespace_chars)
+        denominator = [
+          non_whitespace_character_count(@old_text),
+          non_whitespace_character_count(@new_text)
+        ].max
+
+        return true if denominator.zero?
+
+        (shared_non_whitespace_chars.to_f / denominator) >= SIMILARITY_THRESHOLD
+      end
+
+      def non_whitespace_character_count(text)
+        text.each_char.count { |character| !character.match?(/\s/) }
+      end
+
+      def common_prefix_length(old_text, new_text)
+        old_text.chars.zip(new_text.chars).take_while { |old_char, new_char| old_char == new_char }.size
+      end
+
+      def common_suffix_length(old_text, new_text)
+        old_text.chars.reverse.zip(new_text.chars.reverse).take_while { |old_char, new_char| old_char == new_char }.size
+      end
+
+      def empty_ranges
+        { "old" => [], "new" => [] }
+      end
+    end
+  end
+end

data/app/services/reviewkit/diffs/split_diff.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+require "diff/lcs"
+
+module Reviewkit
+  module Diffs
+    class SplitDiff
+      def self.call(...)
+        new(...).call
+      end
+
+      def initialize(old_content:, new_content:, review_document_count: nil)
+        @old_content = old_content.to_s
+        @new_content = new_content.to_s
+        @review_document_count = review_document_count
+      end
+
+      def call
+        old_line_number = 0
+        new_line_number = 0
+        stats = { "additions" => 0, "deletions" => 0, "changes" => 0, "context" => 0 }
+        changes = Diff::LCS.sdiff(lines(@old_content), lines(@new_content)).to_a
+        changed_row_count = changes.count { |change| change.action == "!" }
+
+        rows = changes.map do |change|
+          case change.action
+          when "="
+            old_line_number += 1
+            new_line_number += 1
+            stats["context"] += 1
+            build_row("context", old_line_number, new_line_number, change.old_element, change.new_element)
+          when "!"
+            old_line_number += 1
+            new_line_number += 1
+            stats["changes"] += 1
+            stats["additions"] += 1
+            stats["deletions"] += 1
+            inline_changes = build_inline_changes(
+              change.old_element,
+              change.new_element,
+              changed_row_count: changed_row_count
+            )
+
+            build_row(
+              "changed",
+              old_line_number,
+              new_line_number,
+              change.old_element,
+              change.new_element,
+              inline_changes: inline_changes
+            )
+          when "-"
+            old_line_number += 1
+            stats["deletions"] += 1
+            build_row("removed", old_line_number, nil, change.old_element, nil)
+          when "+"
+            new_line_number += 1
+            stats["additions"] += 1
+            build_row("added", nil, new_line_number, nil, change.new_element)
+          end
+        end.compact
+
+        { "rows" => rows, "stats" => stats }
+      end
+
+      private
+
+      def build_row(kind, old_line, new_line, old_text, new_text, inline_changes: nil)
+        normalized_old = old_text.to_s
+        normalized_new = new_text.to_s
+
+        row = {
+          "kind" => kind,
+          "line_code" => Digest::SHA1.hexdigest(
+            [ kind, old_line, new_line, normalized_old, normalized_new ].join("\u0000")
+          ),
+          "new_line" => new_line,
+          "new_text" => normalized_new,
+          "old_line" => old_line,
+          "old_text" => normalized_old
+        }
+
+        row["inline_changes"] = inline_changes if inline_changes_present?(inline_changes)
+        row
+      end
+
+      def lines(content)
+        return [] if content.empty?
+
+        content.lines(chomp: true)
+      end
+
+      def build_inline_changes(old_text, new_text, changed_row_count:)
+        return unless Reviewkit::Diffs::IntralineBudget.allow?(
+          old_text: old_text,
+          new_text: new_text,
+          review_document_count: @review_document_count,
+          changed_row_count: changed_row_count
+        )
+
+        Reviewkit::Diffs::IntralineDiff.call(old_text:, new_text:)
+      end
+
+      def inline_changes_present?(inline_changes)
+        return false if inline_changes.blank?
+
+        inline_changes.values.any?(&:present?)
+      end
+    end
+  end
+end

data/app/services/reviewkit/reviews/create.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Reviewkit
+  module Reviews
+    class Create
+      def self.call(...)
+        new(...).call
+      end
+
+      def initialize(title:, description: nil, creator: nil, reviewable: nil, external_reference: nil, metadata: {}, review_attributes: {}, status: "draft", documents: [])
+        @title = title
+        @description = description
+        @creator = creator
+        @reviewable = reviewable
+        @external_reference = external_reference
+        @metadata = metadata
+        @review_attributes = review_attributes
+        @status = status
+        @documents = documents
+      end
+
+      def call
+        Reviewkit::Current.set(actor: @creator, source: self.class.name) do
+          Review.transaction do
+            review = Review.new(
+              {
+                title: @title,
+                description: @description,
+                status: @status,
+                external_reference: @external_reference,
+                metadata: @metadata,
+                reviewable: @reviewable
+              }.merge(@review_attributes)
+            )
+            review.creator = @creator
+            review.save!
+
+            @documents.each_with_index do |document, index|
+              payload = document.to_h.with_indifferent_access
+              review.documents.create!(
+                intraline_review_document_count: @documents.size,
+                path: payload.fetch(:path),
+                language: payload.fetch(:language, "plaintext"),
+                old_content: payload.fetch(:old_content, ""),
+                new_content: payload.fetch(:new_content, ""),
+                metadata: payload.fetch(:metadata, {}),
+                position: payload.fetch(:position, index)
+              )
+            end
+
+            review
+          end
+        end
+      end
+    end
+  end
+end

data/app/views/layouts/reviewkit/application.html.erb

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>Reviewkit</title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+    <%= yield :head %>
+  </head>
+
+  <body class="min-h-screen bg-slate-50 text-slate-950 antialiased">
+    <%= render "reviewkit/shared/flash" %>
+    <%= yield %>
+  </body>
+</html>

data/app/views/reviewkit/comments/_comment.html.erb

@@ -0,0 +1,53 @@
+<% review_frame_id = local_assigns[:frame_id] || dom_id(comment.review_thread.review, :review) %>
+
+<%= turbo_frame_tag dom_id(comment) do %>
+  <article class="reviewkit-comment-card">
+    <header class="reviewkit-comment-header">
+      <div class="reviewkit-comment-meta">
+        <span class="text-[13px] font-semibold text-slate-900">
+          <%= reviewkit_actor_label(comment.author) %>
+        </span>
+
+        <% if reviewkit_comment_edited?(comment) %>
+          <span class="reviewkit-comment-edited">edited</span>
+        <% end %>
+      </div>
+
+      <div class="flex items-center gap-2">
+        <div class="text-[11px] text-slate-500">
+          <%= time_ago_in_words(comment.created_at) %> ago
+        </div>
+
+        <% if reviewkit_comment_manageable?(comment) %>
+          <div class="reviewkit-inline-actions" aria-label="Comment actions">
+            <%= link_to edit_review_thread_comment_path(comment.review_thread, comment),
+              class: "reviewkit-inline-icon-button",
+              data: { turbo_frame: dom_id(comment) },
+              aria: { label: "Edit comment" },
+              title: "Edit comment" do %>
+              <%= reviewkit_pencil_icon %>
+            <% end %>
+
+            <% if reviewkit_comment_destroyable?(comment) %>
+              <%= link_to review_thread_comment_path(comment.review_thread, comment, frame_id: review_frame_id, view: local_assigns[:view_mode]),
+                class: "reviewkit-inline-icon-button reviewkit-inline-icon-button--danger",
+                data: {
+                  turbo_method: :delete,
+                  turbo_frame: review_frame_id,
+                  turbo_confirm: "Delete this comment?"
+                },
+                aria: { label: "Delete comment" },
+                title: "Delete comment" do %>
+                <%= reviewkit_trash_icon %>
+              <% end %>
+            <% end %>
+          </div>
+        <% end %>
+      </div>
+    </header>
+
+    <div class="mt-1.5 text-[13px] leading-5 text-slate-700">
+      <%= reviewkit_render_comment_body(comment) %>
+    </div>
+  </article>
+<% end %>

data/app/views/reviewkit/comments/_edit_form.html.erb

@@ -0,0 +1,26 @@
+<%= turbo_frame_tag dom_id(comment) do %>
+  <%= form_with model: [comment.review_thread, comment], class: "reviewkit-comment-edit-form" do |form| %>
+    <% if comment.errors.any? %>
+      <div class="reviewkit-comment-error">
+        <%= safe_join(comment.errors.full_messages.map { |error| content_tag(:div, error) }) %>
+      </div>
+    <% end %>
+
+    <label class="block">
+      <span class="mb-1 block text-[11px] font-semibold uppercase tracking-[0.14em] text-slate-500">Edit comment</span>
+      <%= form.text_area :body,
+        rows: 3,
+        class: "reviewkit-textarea",
+        autofocus: true %>
+    </label>
+
+    <div class="flex items-center justify-end gap-2">
+      <%= link_to "Cancel",
+        review_thread_comment_path(comment.review_thread, comment),
+        class: "reviewkit-button reviewkit-button--ghost reviewkit-button--small",
+        data: { turbo_frame: dom_id(comment) } %>
+      <%= form.submit "Save",
+        class: "reviewkit-button reviewkit-button--primary reviewkit-button--small" %>
+    </div>
+  <% end %>
+<% end %>

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

@@ -0,0 +1,16 @@
+<%= form_with model: [thread, Reviewkit::Comment.new], class: "space-y-2 border-t border-slate-200 bg-slate-50 px-3 py-2.5" do |form| %>
+  <%= form.hidden_field :frame_id, value: local_assigns[:frame_id] %>
+  <%= form.hidden_field :view, value: local_assigns[:view_mode] %>
+  <label class="block">
+    <span class="mb-1 block text-[11px] font-semibold uppercase tracking-[0.14em] text-slate-500">Reply</span>
+    <%= form.text_area :body,
+      rows: 2,
+      class: "reviewkit-textarea",
+      placeholder: "Add to the conversation..." %>
+  </label>
+
+  <div class="flex justify-end">
+    <%= form.submit "Reply",
+      class: "reviewkit-button reviewkit-button--secondary reviewkit-button--small" %>
+  </div>
+<% end %>

data/app/views/reviewkit/review_threads/_bucket.html.erb

@@ -0,0 +1,53 @@
+<div class="reviewkit-thread-stack">
+  <% threads.each do |thread| %>
+    <%= render "reviewkit/review_threads/thread",
+      expanded: composer_open,
+      frame_id: frame_id,
+      review: review,
+      thread: thread,
+      view_mode: view_mode %>
+  <% end %>
+
+  <div
+    class="<%= [("hidden" unless composer_open), "reviewkit-thread-composer"].compact.join(" ") %>"
+  >
+    <% if thread_errors.present? %>
+      <div class="mb-2 border border-rose-200 bg-rose-50 px-2.5 py-1.5 text-xs text-rose-700">
+        <%= safe_join(thread_errors.map { |error| content_tag(:div, error) }) %>
+      </div>
+    <% end %>
+
+    <%= form_with url: review_review_threads_path(review), scope: :review_thread, class: "space-y-2" do |form| %>
+      <%= form.hidden_field :document_id, value: document.id %>
+      <%= form.hidden_field :frame_id, value: frame_id %>
+      <%= form.hidden_field :line_code, value: line_code %>
+      <%= form.hidden_field :view, value: view_mode %>
+      <%= form.hidden_field :side,
+        value: composer_side.presence || (row&.dig("new_line").present? ? "new" : "old") %>
+      <%= form.hidden_field :old_line, value: row&.dig("old_line") %>
+      <%= form.hidden_field :new_line, value: row&.dig("new_line") %>
+      <%= form.hidden_field :old_text, value: row&.dig("old_text") %>
+      <%= form.hidden_field :new_text, value: row&.dig("new_text") %>
+
+      <label class="block">
+        <span class="mb-1 block text-[11px] font-semibold uppercase tracking-[0.14em] text-slate-500">
+          Start a discussion on the <%= (composer_side.presence || (row&.dig("new_line").present? ? "new" : "old")) %> side
+        </span>
+        <%= form.text_area :body,
+          rows: 3,
+          class: "reviewkit-textarea",
+          placeholder: "Leave a review comment for this line...",
+          autofocus: composer_open %>
+      </label>
+
+      <div class="flex items-center justify-end gap-2">
+        <%= link_to "Cancel",
+          review_path(review, document_id: document.id, view: view_mode),
+          class: "reviewkit-button reviewkit-button--secondary reviewkit-button--small",
+          data: { turbo_frame: frame_id } %>
+        <%= form.submit "Comment",
+          class: "reviewkit-button reviewkit-button--primary reviewkit-button--small" %>
+      </div>
+    <% end %>
+  </div>
+</div>

data/app/views/reviewkit/review_threads/_bucket_frame.html.erb

@@ -0,0 +1,13 @@
+<%= turbo_frame_tag reviewkit_thread_bucket_id(document, line_code) do %>
+  <%= render "reviewkit/review_threads/bucket",
+    composer_open: local_assigns.fetch(:composer_open, false),
+    composer_side: local_assigns[:composer_side],
+    document: document,
+    frame_id: local_assigns[:frame_id],
+    review: review,
+    row: row,
+    thread_errors: thread_errors,
+    threads: threads,
+    line_code: line_code,
+    view_mode: local_assigns[:view_mode] %>
+<% end %>