commenter 0.3.1 → 0.4.0

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

data/spec/commenter/filler_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "nokogiri"
+require "zip"
+
+RSpec.describe Commenter::Filler do
+  let(:template_path) { File.expand_path("../../data/iso_comment_template_2012-03.docx", __dir__) }
+
+  def comment(attrs)
+    Commenter::Comment.new({ body: "US", type: "technical", comments: "Text" }.merge(attrs))
+  end
+
+  def header_xml(output_path)
+    Zip::File.open(output_path) do |zip|
+      zip.entries.find { |entry| entry.name == "word/header2.xml" }.get_input_stream(&:read)
+    end
+  end
+
+  def body_xml(output_path)
+    Zip::File.open(output_path) do |zip|
+      zip.entries.find { |entry| entry.name == "word/document.xml" }.get_input_stream(&:read)
+    end
+  end
+
+  # Rows of the comment table as arrays of cell text. Read via Nokogiri over
+  # the extracted XML rather than Docx::Document, whose open zip handle keeps
+  # the file locked on Windows and breaks Dir.mktmpdir teardown.
+  def body_rows(output_path)
+    document = Nokogiri::XML(body_xml(output_path))
+    document.xpath("//w:tbl").flat_map { |table| table.xpath("./w:tr") }.map do |row|
+      row.xpath("./w:tc").map { |cell| cell.xpath(".//w:t").map(&:text).join }
+    end
+  end
+
+  it "writes comment rows into the template table" do
+    Dir.mktmpdir do |dir|
+      output = File.join(dir, "filled.docx")
+      described_class.new.fill(template_path, output, [
+                                 comment(id: "US-001", locality: { clause: "5.2.1", element: "Table 3", line_number: "45" },
+                                         proposed_change: "Fix them", observations: "Accepted")
+                               ])
+
+      row = body_rows(output).first
+      expect(row[0]).to include("US-001")
+      expect(row[1]).to include("45")
+      expect(row[2]).to include("5.2.1")
+      expect(row[3]).to include("Table 3")
+      expect(row[4]).to include("technical")
+      expect(row[5]).to include("Text")
+      expect(row[6]).to include("Fix them")
+      expect(row[7]).to include("Accepted")
+    end
+  end
+
+  it "keeps multiple comments in input order and accepts plain hashes" do
+    Dir.mktmpdir do |dir|
+      output = File.join(dir, "filled.docx")
+      described_class.new.fill(template_path, output, [
+                                 { "id" => "DE-001", "comments" => "First" },
+                                 comment(id: "US-001", comments: "Second")
+                               ])
+
+      rows = body_rows(output)
+      expect(rows.length).to eq(2)
+      expect(rows[0][0]).to include("DE-001")
+      expect(rows[1][0]).to include("US-001")
+    end
+  end
+
+  it "fills the header metadata labels in the page header" do
+    Dir.mktmpdir do |dir|
+      output = File.join(dir, "filled.docx")
+      described_class.new.fill(template_path, output, [comment(id: "US-001")],
+                               date: "2026-08-28", document: "ISO 2533:2026", project: "Ballot review")
+
+      header = header_xml(output)
+      expect(header).to include("Date: 2026-08-28")
+      expect(header).to include("Document: ISO 2533:2026")
+      expect(header).to include("Project: Ballot review")
+    end
+  end
+
+  it "leaves header labels untouched when no metadata is given" do
+    Dir.mktmpdir do |dir|
+      output = File.join(dir, "filled.docx")
+      described_class.new.fill(template_path, output, [comment(id: "US-001")])
+
+      header = header_xml(output)
+      expect(header).to include(">Date: <")
+      expect(header).to include(">Document:<")
+      expect(header).to include(">Project:<")
+    end
+  end
+
+  it "escapes XML special characters in metadata values" do
+    Dir.mktmpdir do |dir|
+      output = File.join(dir, "filled.docx")
+      described_class.new.fill(template_path, output, [comment(id: "US-001")],
+                               document: "A&B <standard>")
+
+      expect(header_xml(output)).to include("Document: A&amp;B &lt;standard&gt;")
+    end
+  end
+
+  it "shades observation cells according to disposition status" do
+    Dir.mktmpdir do |dir|
+      output = File.join(dir, "filled.docx")
+      described_class.new.fill(template_path, output, [
+                                 comment(id: "US-001", observations: "Accepted"),
+                                 comment(id: "US-002", observations: "Not accepted")
+                               ], shading: true)
+
+      xml = body_xml(output)
+      expect(xml).to include('w:fill="92D050"')
+      expect(xml).to include('w:fill="FF99CC"')
+    end
+  end
+end

data/spec/commenter/osd_xlsx_parser_spec.rb

@@ -27,7 +27,8 @@ RSpec.describe Commenter::Parser::OsdXlsxParser do
 
         expect(comment.id).to eq("1")
         expect(comment.body).to eq("John Doe")
-        expect(comment.locality).to eq({ clause: "5.2.1", element: "Requirements" })
+        expect(comment.locality.clause).to eq("5.2.1")
+        expect(comment.locality.element).to eq("Requirements")
         expect(comment.comments).to eq("The values in Table 3 are inconsistent.")
         expect(comment.proposed_change).to eq("Correct the values in column 2.")
         expect(comment.comment_type).to eq("Editorial")
@@ -62,7 +63,7 @@ RSpec.describe Commenter::Parser::OsdXlsxParser do
         comments = described_class.new.parse(path).comments
 
         expect(comments.length).to eq(2)
-        expect(comments.last.locality).to eq({})
+        expect(comments.last.locality.clause).to be_nil
         expect(comments.last.proposed_change).to be_nil
       end
     end

data/spec/support/redline_docx_builder.rb

@@ -25,10 +25,17 @@ module RedlineDocxBuilder
   private_constant :HEADING_LEVEL_STYLE, :CHANGE_TAG
 
   def self.write(path, paragraphs, comments: [])
-    zip = Zip::File.new(path, create: true)
-    zip.get_output_stream("word/document.xml") { |stream| stream.write(document_xml(paragraphs)) }
-    zip.get_output_stream("word/comments.xml") { |stream| stream.write(comments_xml(comments)) }
-    zip.close
+    # Written via an in-memory buffer and File.binwrite rather than
+    # Zip::File#create + close: rubyzip commits the latter with File.rename,
+    # which fails with EACCES on Windows when the caller still holds an open
+    # handle on the destination (e.g. an unclosed Tempfile).
+    buffer = Zip::OutputStream.write_buffer do |out|
+      out.put_next_entry("word/document.xml")
+      out.write(document_xml(paragraphs))
+      out.put_next_entry("word/comments.xml")
+      out.write(comments_xml(comments))
+    end
+    File.binwrite(path, buffer.string)
     path
   end
 

data/spec/support/xlsx_builder.rb

@@ -18,22 +18,27 @@ module XlsxBuilder
     shared = []
     worksheets = sheets.map { |name, rows| [name, worksheet_xml(rows, shared)] }
 
-    zip = Zip::File.new(path, create: true)
-    write_entry(zip, "[Content_Types].xml", content_types_xml(worksheets.size))
-    write_entry(zip, "_rels/.rels", root_rels_xml)
-    write_entry(zip, "xl/workbook.xml", workbook_xml(worksheets.map(&:first)))
-    write_entry(zip, "xl/_rels/workbook.xml.rels", workbook_rels_xml(worksheets.size))
-    write_entry(zip, "xl/sharedStrings.xml", shared_strings_xml(shared))
-    write_entry(zip, "xl/styles.xml", styles_xml)
-    worksheets.each_with_index do |(_name, xml), index|
-      write_entry(zip, "xl/worksheets/sheet#{index + 1}.xml", xml)
+    # In-memory buffer + File.binwrite rather than Zip::File#create + close:
+    # rubyzip commits the latter with File.rename, which fails with EACCES on
+    # Windows when the caller still holds an open handle on the destination.
+    buffer = Zip::OutputStream.write_buffer do |out|
+      write_entry(out, "[Content_Types].xml", content_types_xml(worksheets.size))
+      write_entry(out, "_rels/.rels", root_rels_xml)
+      write_entry(out, "xl/workbook.xml", workbook_xml(worksheets.map(&:first)))
+      write_entry(out, "xl/_rels/workbook.xml.rels", workbook_rels_xml(worksheets.size))
+      write_entry(out, "xl/sharedStrings.xml", shared_strings_xml(shared))
+      write_entry(out, "xl/styles.xml", styles_xml)
+      worksheets.each_with_index do |(_name, xml), index|
+        write_entry(out, "xl/worksheets/sheet#{index + 1}.xml", xml)
+      end
     end
-    zip.close
+    File.binwrite(path, buffer.string)
     path
   end
 
-  def self.write_entry(zip, name, content)
-    zip.get_output_stream(name) { |stream| stream.write(content) }
+  def self.write_entry(out, name, content)
+    out.put_next_entry(name)
+    out.write(content)
   end
 
   def self.worksheet_xml(rows, shared)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: commenter
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-27 00:00:00.000000000 Z
+date: 2026-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: lutaml-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: octokit
   requirement: !ruby/object:Gem::Requirement
@@ -125,6 +139,7 @@ files:
 - ".rubocop_todo.yml"
 - CLAUDE.md
 - CODE_OF_CONDUCT.md
+- CONTEXT.md
 - Gemfile
 - README.adoc
 - Rakefile
@@ -136,11 +151,16 @@ files:
 - data/iso_comment_template_2012-03.docx
 - exe/commenter
 - lib/commenter.rb
+- lib/commenter/ballot.rb
+- lib/commenter/ballot_report.rb
 - lib/commenter/cli.rb
 - lib/commenter/comment.rb
+- lib/commenter/comment_locality.rb
 - lib/commenter/comment_sheet.rb
 - lib/commenter/comment_type.rb
+- lib/commenter/disposition_status.rb
 - lib/commenter/filler.rb
+- lib/commenter/github_info.rb
 - lib/commenter/github_integration.rb
 - lib/commenter/github_session.rb
 - lib/commenter/parser.rb
@@ -150,10 +170,14 @@ files:
 - schema/iso_comment_2012-03.yaml
 - schema/iso_comment_osd.yaml
 - sig/commenter.rbs
+- spec/commenter/ballot_report_spec.rb
+- spec/commenter/ballot_spec.rb
 - spec/commenter/cli_spec.rb
 - spec/commenter/comment_sheet_spec.rb
 - spec/commenter/comment_spec.rb
 - spec/commenter/comment_type_spec.rb
+- spec/commenter/disposition_status_spec.rb
+- spec/commenter/filler_spec.rb
 - spec/commenter/github_integration_spec.rb
 - spec/commenter/osd_xlsx_parser_spec.rb
 - spec/commenter/track_change_docx_parser_spec.rb