commenter 0.3.1 → 0.5.0

data/lib/commenter/github_integration.rb

@@ -19,8 +19,7 @@ module Commenter
     end
 
     def create_issues_from_yaml(yaml_file, options = {})
-      data = YAML.load_file(yaml_file)
-      comment_sheet = CommentSheet.from_hash(data)
+      comment_sheet = CommentSheet.from_yaml(File.read(yaml_file))
 
       # Override stage if provided
       comment_sheet.stage = options[:stage] if options[:stage]
@@ -251,8 +250,12 @@ module Commenter
         puts "[GitHubIssueCreator] Using milestone number: #{milestone_config["number"]}"
         milestone_config["number"]
       elsif milestone_config["name"]
-        puts "[GitHubIssueCreator] Using milestone name: #{milestone_config["name"]}"
-        resolve_milestone_by_name_or_number(milestone_config["name"])
+        # Resolved once per run and memoized: resolving per comment caused
+        # duplicated milestone fetches (see 3a06c3d).
+        @milestone_number ||= begin
+          puts "[GitHubIssueCreator] Using milestone name: #{milestone_config["name"]}"
+          resolve_milestone_by_name_or_number(milestone_config["name"])
+        end
       end
     end
 
@@ -277,16 +280,14 @@ module Commenter
     def update_yaml_with_github_info(yaml_file, comment_sheet, results, options)
       # Update comments with GitHub information
       results.each do |result|
-        next unless result[:status] == :created
+        next unless result[:issue_number]
 
         comment = comment_sheet.comments.find { |c| c.id == result[:comment_id] }
         next unless comment
 
-        # Add GitHub information to the comment
-        comment.github[:issue_number] = result[:issue_number]
-        comment.github[:issue_url] = result[:issue_url]
-        comment.github[:status] = "open"
-        comment.github[:created_at] = Time.now.utc.iso8601
+        comment.record_github_issue(issue_number: result[:issue_number], issue_url: result[:issue_url],
+                                    status: result[:status] == :created ? "open" : comment.github_status,
+                                    created_at: comment.github_created_at || Time.now.utc.iso8601)
       end
 
       # Write updated YAML
@@ -304,8 +305,7 @@ module Commenter
     end
 
     def retrieve_observations_from_yaml(yaml_file, options = {})
-      data = YAML.load_file(yaml_file)
-      comment_sheet = CommentSheet.from_hash(data)
+      comment_sheet = CommentSheet.from_yaml(File.read(yaml_file))
 
       results = []
       comment_sheet.comments.each do |comment|
@@ -349,8 +349,8 @@ module Commenter
         if observation
           # Update comment with observation and current status
           comment.observations = observation
-          comment.github[:status] = issue.state
-          comment.github[:updated_at] = Time.now.utc.iso8601
+          comment.github.status = issue.state
+          comment.github.updated_at = Time.now.utc.iso8601
 
           {
             comment_id: comment.id,

data/lib/commenter/github_sync.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Commenter
+  # Synchronizes the comment YAML with GitHub issues, treating the YAML as
+  # the source of truth: comments without an issue get one, issue content is
+  # refreshed from the YAML (per the conflict policy), and issues whose
+  # comment has a recorded disposition can be closed.
+  class GitHubSync < GitHubIssueCreator
+    # Returns the sync actions for one comment by comparing the rendered
+    # issue content against the issue's current state. Pure — no network —
+    # so the conflict matrix is directly specifiable.
+    #
+    # conflict policy:
+    #   yaml   - re-render title/body over the issue (YAML wins)
+    #   github - leave differing issue content untouched (GitHub wins)
+    #   skip   - take no action on differing content, report the conflict
+    def self.reconcile_actions(issue:, rendered:, disposition:, conflict: "yaml",
+                               close_on_disposition: true)
+      actions = []
+      differing = [rendered[:title].to_s.strip, rendered[:body].to_s.strip] !=
+                  [issue[:title].to_s.strip, issue[:body].to_s.strip]
+
+      if differing
+        case conflict
+        when "yaml" then actions << :update_content
+        when "github" then actions << :keep_github_content
+        when "skip" then actions << :conflict
+        end
+      end
+
+      actions << :close if close_on_disposition && issue[:state] == "open" && disposition && !disposition.strip.empty?
+
+      actions
+    end
+
+    def sync(yaml_file, options = {})
+      comment_sheet = CommentSheet.from_yaml(File.read(yaml_file))
+      comment_sheet.stage = options[:stage] if options[:stage]
+
+      results = comment_sheet.comments.map do |comment|
+        options[:dry_run] ? plan(comment, options) : reconcile(comment, comment_sheet, options)
+      end
+
+      update_yaml_with_github_info(yaml_file, comment_sheet, results, options) unless options[:dry_run]
+      results
+    end
+
+    private
+
+    # Dry-run preview, offline: comments with a known issue are planned from
+    # the last state recorded in the YAML, not from a live fetch.
+    def plan(comment, options)
+      return { comment_id: comment.id, actions: [:create] } unless comment.has_github_issue?
+
+      actions = [:reconcile]
+      if close_on_disposition?(options) && comment.github_status == "open" &&
+         comment.observations && !comment.observations.strip.empty?
+        actions << :close
+      end
+      { comment_id: comment.id, issue_number: comment.github_issue_number, actions: actions }
+    end
+
+    def reconcile(comment, comment_sheet, options)
+      issue = find_existing_issue(comment, comment_sheet)
+      return create_issue(comment, comment_sheet, options) unless issue
+
+      title = @title_template.render(template_variables(comment, comment_sheet))
+      body = @body_template.render(template_variables(comment, comment_sheet))
+      actions = self.class.reconcile_actions(
+        issue: { title: issue.title, body: issue.body, state: issue.state },
+        rendered: { title: title, body: body },
+        disposition: comment.observations,
+        conflict: options[:conflict] || "yaml",
+        close_on_disposition: close_on_disposition?(options)
+      )
+
+      apply(comment, issue, title, body, actions)
+    rescue Octokit::Error => e
+      { comment_id: comment.id, status: :error, message: e.message }
+    end
+
+    def apply(comment, issue, title, body, actions)
+      result = { comment_id: comment.id, issue_number: issue.number, status: :unchanged, actions: actions }
+      comment.record_github_issue(issue_number: issue.number, issue_url: issue.html_url, status: issue.state)
+
+      if actions.include?(:update_content)
+        @github_client.update_issue(@repo, issue.number, title: title, body: body)
+        result[:status] = :updated
+      end
+
+      if actions.include?(:close)
+        @github_client.close_issue(@repo, issue.number)
+        comment.github.status = "closed"
+        comment.github.updated_at = Time.now.utc.iso8601
+        result[:status] = actions.include?(:update_content) ? :updated_and_closed : :closed
+      end
+
+      result
+    end
+
+    def close_on_disposition?(options)
+      options.fetch(:close_on_disposition, true)
+    end
+  end
+end

data/lib/commenter/parser/osd_xlsx_parser.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "roo"
-require_relative "../comment_sheet"
-require_relative "../comment"
 
 module Commenter
   class Parser
@@ -201,7 +199,7 @@ module Commenter
             clause: clause.empty? ? nil : clause,
             element: clause_title.empty? ? nil : clause_title
           }.compact,
-          type: CommentType.code(cell_value_str(row, col_map[:comment_type]).to_s),
+          type: CommentType.full_name(cell_value_str(row, col_map[:comment_type])),
           comments: comment_text.to_s.strip,
           proposed_change: cell_value_str(row, col_map[:proposed_change]) ||
             cell_value_str(row, col_map[:proposal_on_text])

data/lib/commenter/parser/track_change_docx_parser.rb

@@ -2,8 +2,6 @@
 
 require "zip"
 require "nokogiri"
-require_relative "../comment"
-require_relative "../comment_sheet"
 
 module Commenter
   class Parser
@@ -54,7 +52,7 @@ module Commenter
           raise Commenter::Error, "word/document.xml not found in #{path}" unless entry
 
           remarks = read_remarks(zip)
-          changes = stream_changes(entry.get_input_stream, anchors)
+          changes = entry.get_input_stream { |stream| stream_changes(stream, anchors) }
         end
 
         CommentSheet.new(
@@ -80,7 +78,7 @@ module Commenter
         entry = zip.glob("word/comments.xml").first
         return {} unless entry
 
-        document = Nokogiri::XML(entry.get_input_stream)
+        document = entry.get_input_stream { |stream| Nokogiri::XML(stream) }
         document.xpath("//w:comment", "w" => W_NS).each_with_object({}) do |node, remarks|
           remarks[node["w:id"]] = {
             author: node["w:author"],
@@ -102,7 +100,7 @@ module Commenter
             id: format("%<body>s-%03<index>d", body: body, index: index + 1),
             body: body,
             locality: { clause: change[:clause], line_number: nil, element: change[:element] },
-            type: options[:type] || "te",
+            type: CommentType.full_name(options[:type] || "te"),
             comments: "Track change (#{KIND_COMMENT.fetch(kind, kind)})",
             proposed_change: "#{KIND_LABEL.fetch(kind, kind)}: \"#{change[:text].strip}\"",
             observations: observations_for(options)

data/lib/commenter/parser.rb

@@ -2,13 +2,12 @@
 
 require "docx"
 require "pathname"
-require_relative "comment_sheet"
-require_relative "comment"
-require_relative "parser/osd_xlsx_parser"
-require_relative "parser/track_change_docx_parser"
 
 module Commenter
   class Parser
+    autoload :OsdXlsxParser, "commenter/parser/osd_xlsx_parser"
+    autoload :TrackChangeDocxParser, "commenter/parser/track_change_docx_parser"
+
     def parse(input_path, options = {})
       format = detect_format(input_path, options)
 
@@ -90,7 +89,7 @@ module Commenter
           clause: presence(cells[2]),
           element: presence(cells[3])
         },
-        type: CommentType.code(cells[4]),
+        type: CommentType.full_name(cells[4]),
         comments: cells[5] || "",
         proposed_change: presence(cells[6]),
         user_name: cells[0].to_s.strip

data/lib/commenter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Commenter
-  VERSION = "0.3.1"
+  VERSION = "0.5.0"
 end

data/lib/commenter.rb

@@ -1,11 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "commenter/version"
-require_relative "commenter/comment"
-require_relative "commenter/comment_sheet"
-require_relative "commenter/parser"
-require_relative "commenter/filler"
-require_relative "commenter/github_integration"
 
 # Commenter converts ISO comment sheets (DOCX/XLSX) to structured YAML and
 # syncs comments to GitHub issues.
@@ -13,5 +8,18 @@ module Commenter
   class Error < StandardError; end
 
   autoload :CommentType, "commenter/comment_type"
+  autoload :CommentLocality, "commenter/comment_locality"
+  autoload :GithubInfo, "commenter/github_info"
+  autoload :DispositionStatus, "commenter/disposition_status"
+  autoload :Ballot, "commenter/ballot"
+  autoload :BallotReport, "commenter/ballot_report"
+  autoload :BallotDiff, "commenter/ballot_diff"
+  autoload :Comment, "commenter/comment"
+  autoload :CommentSheet, "commenter/comment_sheet"
   autoload :GitHubSession, "commenter/github_session"
+  autoload :Parser, "commenter/parser"
+  autoload :Filler, "commenter/filler"
+  autoload :GitHubIssueCreator, "commenter/github_integration"
+  autoload :GitHubIssueRetriever, "commenter/github_integration"
+  autoload :GitHubSync, "commenter/github_sync"
 end

data/spec/commenter/ballot_diff_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Commenter::BallotDiff do
+  def sheet(comments)
+    Commenter::CommentSheet.new(comments: comments)
+  end
+
+  def comment(id, text: "Text for #{id}", observations: nil)
+    Commenter::Comment.new(id: id, body: id.split("-").first, comments: text, observations: observations)
+  end
+
+  let(:cd) do
+    sheet([
+            comment("DE-001"),
+            comment("DE-002", text: "Old wording"),
+            comment("US-001")
+          ])
+  end
+
+  let(:dis) do
+    sheet([
+            comment("DE-001"),
+            comment("DE-002", text: "Revised wording"),
+            comment("US-001", observations: "Accepted."),
+            comment("JP-001")
+          ])
+  end
+
+  it "classifies new, withdrawn, repeated, and revised comments" do
+    result = described_class.diff(cd, dis)
+
+    expect(result[:new]).to eq(["JP-001"])
+    expect(result[:withdrawn]).to eq([]) # US-001 present in both
+    expect(result[:repeated]).to eq(%w[DE-001 US-001])
+    expect(result[:revised]).to eq(["DE-002"])
+  end
+
+  it "counts comments with a disposition in the later stage as resolved" do
+    result = described_class.diff(cd, dis)
+
+    expect(result[:resolved]).to eq(["US-001"])
+  end
+
+  it "reports withdrawn comments" do
+    result = described_class.diff(dis, cd)
+
+    expect(result[:withdrawn]).to eq(["JP-001"])
+    expect(result[:new]).to eq([])
+  end
+
+  it "renders a markdown table" do
+    markdown = described_class.to_markdown(cd, dis)
+
+    expect(markdown).to start_with("| Category | Count | Comments |")
+    expect(markdown).to include("| New | 1 | JP-001 |")
+    expect(markdown).to include("| Revised | 1 | DE-002 |")
+    expect(markdown).to include("Resolved (disposition recorded in the later stage): 1")
+  end
+end

data/spec/commenter/ballot_report_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Commenter::BallotReport do
+  def comment(body:, observations: nil, resolution_status: nil, github: {}, type: "technical")
+    Commenter::Comment.new(
+      id: "#{body}-1", body: body, type: type,
+      comments: "A comment", observations: observations,
+      resolution_status: resolution_status, github: github
+    )
+  end
+
+  let(:sheet) do
+    Commenter::CommentSheet.new(comments: [
+                                  comment(body: "DE", observations: "Accepted."),
+                                  comment(body: "DE", observations: "Accept with modifications"),
+                                  comment(body: "US", observations: "Noted"),
+                                  comment(body: "US", observations: "Rejected"),
+                                  comment(body: "US"),
+                                  comment(body: "CS", resolution_status: "Not accepted"),
+                                  comment(body: "CS", github: { status: "open" })
+                                ])
+  end
+
+  describe ".status_for" do
+    it "prefers observation text, then resolution status, then GitHub state" do
+      comments = sheet.comments
+      expect(described_class.status_for(comments[0])).to eq(:accepted)
+      expect(described_class.status_for(comments[4])).to eq(:undecided)
+      expect(described_class.status_for(comments[5])).to eq(:rejected)
+      expect(described_class.status_for(comments[6])).to eq(:open)
+    end
+  end
+
+  describe ".counts" do
+    it "counts per member body, disposition, and type" do
+      counts = described_class.counts(sheet)
+
+      expect(counts[:total]).to eq(7)
+      expect(counts[:bodies]["DE"][:total]).to eq(2)
+      expect(counts[:bodies]["DE"][:accepted]).to eq(1)
+      expect(counts[:bodies]["DE"][:accept_with_modifications]).to eq(1)
+      expect(counts[:bodies]["US"][:noted]).to eq(1)
+      expect(counts[:bodies]["US"][:rejected]).to eq(1)
+      expect(counts[:bodies]["US"][:undecided]).to eq(1)
+      expect(counts[:bodies]["CS"][:open]).to eq(1)
+      expect(counts[:types]["technical"]).to eq(7)
+    end
+  end
+
+  describe ".to_markdown" do
+    it "renders a ballot report table with totals" do
+      markdown = described_class.to_markdown(sheet)
+
+      expect(markdown).to start_with("| Body | Total | Accepted | AWM | Noted | Rejected | TODO | Open | Undecided |")
+      expect(markdown).to include("| DE | 2 | 1 | 1 | 0 | 0 | 0 | 0 | 0 |")
+      expect(markdown).to include("| **Total** | **7** | **1** | **1** | **1** | **2** | **0** | **1** | **1** |")
+      expect(markdown).to include("Comment types: technical 7")
+    end
+  end
+end

data/spec/commenter/ballot_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Commenter::Ballot do
+  def sheet(body:, ids:, document: nil, stage: nil)
+    Commenter::CommentSheet.new(
+      version: "2012-03",
+      document: document,
+      stage: stage,
+      comments: ids.map do |id|
+        Commenter::Comment.new(id: id, body: body, comments: "Comment #{id} from #{body}")
+      end
+    )
+  end
+
+  it "combines comments from all sheets in input order" do
+    merged = described_class.new([
+                                   sheet(body: "DE", ids: %w[DE-001 DE-002]),
+                                   sheet(body: "US", ids: %w[US-001])
+                                 ]).merge
+
+    expect(merged.comments.map(&:id)).to eq(%w[DE-001 DE-002 US-001])
+    expect(merged.comments.map(&:body)).to eq(%w[DE DE US])
+  end
+
+  it "takes metadata from the first sheet that provides it" do
+    merged = described_class.new([
+                                   sheet(body: "DE", ids: %w[DE-001], stage: nil),
+                                   sheet(body: "US", ids: %w[US-001], document: "ISO 2533:2026", stage: "DIS")
+                                 ]).merge
+
+    expect(merged.version).to eq("2012-03")
+    expect(merged.document).to eq("ISO 2533:2026")
+    expect(merged.stage).to eq("DIS")
+  end
+
+  it "silently deduplicates identical comments sharing an ID" do
+    duplicate = Commenter::Comment.new(id: "DE-001", body: "DE", comments: "Same text", proposed_change: "Same change")
+
+    merged = described_class.new([
+                                   Commenter::CommentSheet.new(comments: [duplicate]),
+                                   Commenter::CommentSheet.new(comments: [
+                                                                 Commenter::Comment.new(id: "DE-001", body: "DE", comments: "Same text",
+                                                                                        proposed_change: "Same change")
+                                                               ])
+                                 ]).merge
+
+    expect(merged.comments.map(&:id)).to eq(["DE-001"])
+  end
+
+  it "raises when the same ID carries differing content" do
+    conflicting = Commenter::Comment.new(id: "DE-001", body: "DE", comments: "Different text entirely")
+
+    expect do
+      described_class.new([
+                            sheet(body: "DE", ids: %w[DE-001]),
+                            Commenter::CommentSheet.new(comments: [conflicting])
+                          ]).merge
+    end.to raise_error(Commenter::Error, /DE-001/)
+  end
+
+  it "returns an empty sheet when no input sheets are given" do
+    merged = described_class.new([]).merge
+
+    expect(merged.comments).to eq([])
+  end
+end

data/spec/commenter/cli_spec.rb

@@ -32,4 +32,45 @@ RSpec.describe Commenter::Cli do
       end
     end
   end
+
+  describe "#merge" do
+    it "writes a combined sheet with schema reference" do
+      Dir.mktmpdir do |dir|
+        one = File.join(dir, "de.yaml")
+        two = File.join(dir, "us.yaml")
+        File.write(one, { "version" => "2012-03", "comments" => [
+          { "id" => "DE-001", "body" => "DE", "comments" => "First" }
+        ] }.to_yaml)
+        File.write(two, { "comments" => [
+          { "id" => "US-001", "body" => "US", "comments" => "Second" }
+        ] }.to_yaml)
+        output = File.join(dir, "out", "merged.yaml")
+        schema_dir = File.join(dir, "out", "schema")
+
+        described_class.start(["merge", one, two, "--output", output, "--schema-dir", schema_dir])
+
+        data = YAML.safe_load_file(output)
+        expect(data["comments"].map { |comment| comment["id"] }).to eq(%w[DE-001 US-001])
+        expect(File).to exist(File.join(schema_dir, "iso_comment_2012-03.yaml"))
+      end
+    end
+  end
+
+  describe "#stats" do
+    it "prints a markdown disposition report" do
+      Dir.mktmpdir do |dir|
+        input = File.join(dir, "comments.yaml")
+        File.write(input, { "comments" => [
+          { "id" => "DE-001", "body" => "DE", "comments" => "A", "observations" => "Accepted." },
+          { "id" => "US-001", "body" => "US", "comments" => "B", "observations" => "Noted" }
+        ] }.to_yaml)
+
+        expect { described_class.start(["stats", input]) }
+          .to output(a_string_including(
+                       "| DE | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |",
+                       "| US | 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 |"
+                     )).to_stdout
+      end
+    end
+  end
 end

data/spec/commenter/comment_sheet_spec.rb

@@ -115,21 +115,21 @@ RSpec.describe Commenter::CommentSheet do
 
       hash = sheet.to_h
 
-      expect(hash[:version]).to eq("2012-03")
-      expect(hash[:date]).to eq("2024-06-04")
-      expect(hash[:document]).to eq("Test Document")
-      expect(hash[:project]).to eq("Test Project")
-      expect(hash[:stage]).to eq("DIS")
-      expect(hash[:comments]).to be_an(Array)
-      expect(hash[:comments].first).to be_a(Hash)
+      expect(hash["version"]).to eq("2012-03")
+      expect(hash["date"]).to eq("2024-06-04")
+      expect(hash["document"]).to eq("Test Document")
+      expect(hash["project"]).to eq("Test Project")
+      expect(hash["stage"]).to eq("DIS")
+      expect(hash["comments"]).to be_an(Array)
+      expect(hash["comments"].first).to be_a(Hash)
     end
 
-    it "includes nil stage when not set" do
+    it "omits unset attributes from the hash" do
       sheet = described_class.new({})
       hash = sheet.to_h
 
-      expect(hash).to have_key(:stage)
-      expect(hash[:stage]).to be_nil
+      expect(hash).not_to have_key("stage")
+      expect(sheet.version).to eq("2012-03")
     end
   end
 

data/spec/commenter/comment_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe Commenter::Comment do
         id: "US-001",
         body: "US",
         locality: { clause: "5.1", element: "Table 1", line_number: "42" },
-        type: "te",
+        type: "technical",
         comments: "Test comment",
         proposed_change: "Test change",
         observations: "Test observations"
@@ -28,6 +28,19 @@ RSpec.describe Commenter::Comment do
       expect(comment.observations).to eq("Test observations")
     end
 
+    it "expands short type codes when loaded from YAML" do
+      yaml = <<~YAML
+        ---
+        id: US-009
+        type: te
+      YAML
+
+      comment = described_class.from_yaml(yaml)
+
+      expect(comment.id).to eq("US-009")
+      expect(comment.type).to eq("technical")
+    end
+
     it "handles string keys in attributes" do
       attributes = {
         "id" => "US-001",
@@ -162,7 +175,7 @@ RSpec.describe Commenter::Comment do
         id: "US-001",
         body: "US",
         locality: { clause: "5.1" },
-        type: "te",
+        type: "technical",
         comments: "Test",
         proposed_change: "Change",
         observations: "Obs"
@@ -170,13 +183,13 @@ RSpec.describe Commenter::Comment do
 
       hash = comment.to_h
 
-      expect(hash[:id]).to eq("US-001")
-      expect(hash[:body]).to eq("US")
-      expect(hash[:locality][:clause]).to eq("5.1")
-      expect(hash[:type]).to eq("technical")
-      expect(hash[:comments]).to eq("Test")
-      expect(hash[:proposed_change]).to eq("Change")
-      expect(hash[:observations]).to eq("Obs")
+      expect(hash["id"]).to eq("US-001")
+      expect(hash["body"]).to eq("US")
+      expect(hash["locality"]["clause"]).to eq("5.1")
+      expect(hash["type"]).to eq("technical")
+      expect(hash["comments"]).to eq("Test")
+      expect(hash["proposed_change"]).to eq("Change")
+      expect(hash["observations"]).to eq("Obs")
     end
   end
 

data/spec/commenter/disposition_status_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Commenter::DispositionStatus do
+  describe ".match" do
+    it "classifies accepted dispositions" do
+      expect(described_class.match("Accepted")).to eq(:accepted)
+      expect(described_class.match("accepted.")).to eq(:accepted)
+      expect(described_class.match("Partially accepted")).to eq(:accepted)
+    end
+
+    it "classifies accept-with-modifications before the bare accept pattern" do
+      expect(described_class.match("Accept with modifications")).to eq(:accept_with_modifications)
+      expect(described_class.match("Accepted with modifications")).to eq(:accept_with_modifications)
+      expect(described_class.match("Accepted, with changes")).to eq(:accept_with_modifications)
+      expect(described_class.match("AWM")).to eq(:accept_with_modifications)
+    end
+
+    it "classifies rejection including the 'not accepted' phrasing" do
+      expect(described_class.match("Rejected")).to eq(:rejected)
+      expect(described_class.match("Not accepted")).to eq(:rejected)
+    end
+
+    it "classifies noted, todo, and non-matching text" do
+      expect(described_class.match("Noted")).to eq(:noted)
+      expect(described_class.match("TODO: review")).to eq(:todo)
+      expect(described_class.match("Deferred to next revision")).to be_nil
+      expect(described_class.match("")).to be_nil
+      expect(described_class.match(nil)).to be_nil
+    end
+  end
+
+  describe ".statuses" do
+    it "lists the canonical statuses" do
+      expect(described_class.statuses)
+        .to eq(%i[accept_with_modifications rejected accepted noted todo])
+    end
+  end
+end