commenter 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90d4268c6a071ae365af24ef05a5c19dcdfd6fe03545c05a84767f91f70dc411
-  data.tar.gz: b44468b6f9cc18e0726c1df1c1433247e8fc19f6ff9fafc4c3f0eff341a21785
+  metadata.gz: e569c1e1d181c27078d97e4bcaa8a63c54b055aa7aff5dff88646be1237c6a65
+  data.tar.gz: 5d156b1e49c82c9b8002e47f7ab870d98e133622b4830768e02b9bf32c2db993
 SHA512:
-  metadata.gz: 00d4838eadd5c0751199832ff6401a753b2bc4c27cd94d02f6c0d2bab6392a629c216c6cc350766c0d35920f871b4e2bd74102967460e370ebc15fc005a17e9c
-  data.tar.gz: '09420029845d4e6b776eeb40b726326486a409dd8f0ec33be792dcc193e30f5d5774e99777cd64e85c31a5137a69d2648eac4ab06bde2a5ea93a7d2569d0e90a'
+  metadata.gz: 66daebbb66df3c881828bccd0a36c8cb0e1c524d74c19efef579770f707a366c2f48a51b2871041dd3519db0b26ad4431f0065395b02d85685f08eed9862e39e
+  data.tar.gz: 6ea9b41315c94d87c8356350be9b55235d1dfd07e341bbbc133a6feea27b807f36ac9df05bc32430ed314c73c5b5c8a25d9e1ff5066beb0f36f90032c3b9330a

data/.rubocop.yml

@@ -16,3 +16,7 @@ Metrics/ModuleLength:
 Metrics/BlockLength:
   Exclude:
     - "spec/**/*"
+
+Metrics/ClassLength:
+  Exclude:
+    - "lib/commenter/cli.rb"

data/CONTEXT.md

@@ -23,5 +23,13 @@ keep this current when concepts sharpen.
   from ISO/CS editors; also carries reviewer remark threads.
 - **OSD** — ISO Online Standards Development; its XLSX comment exports come
   in resolved and unresolved variants.
+- **Stage Comparison** — how the comment set evolved between two ballots
+  (new, withdrawn, repeated, revised; resolved = disposition recorded).
+  `BallotDiff`.
+- **GitHub Sync** — reconciliation of the comment YAML with GitHub issues
+  (YAML as source of truth): create missing, refresh content per conflict
+  policy, close dispositioned issues. `GitHubSync`.
 - **Unique ID** — stage-aware identity of a comment's GitHub issue
   (`[DIS] GB-001` by default), used for duplicate detection.
+- **Out of scope** — CEN/CENELEC comment exports (decided 2026-08-29: we
+  don't have CEN; do not propose a CEN adapter again).

data/README.adoc

@@ -234,6 +234,33 @@ issue counts as *open*; no disposition at all counts as *undecided*). Use
 `--format yaml` for machine-readable output, and `-o report.md` to write to a
 file — the Markdown pastes directly into a GitHub issue or WG minutes.
 
+=== Comparing ballots between stages
+
+The same comment ID (`DE-001`) recurs at every ballot stage; comparing two
+ballot sheets shows how the set evolved between CD and DIS:
+
+[source,shell]
+----
+commenter diff cd-ballot.yaml dis-ballot.yaml
+----
+
+Comments are matched by ID and classified as new, withdrawn, repeated
+(unchanged text), or revised; a comment whose later version carries a
+disposition counts as resolved. Markdown (default) or `--format yaml`.
+
+=== Exporting the final disposition document
+
+One command for the ballot's last step — pull the observations recorded in
+GitHub issues and write the completed comment sheet:
+
+[source,shell]
+----
+commenter export comments.yaml --config github_config.yaml -o disposition.docx --shading
+----
+
+Retrieves observations from closed issues (updating the YAML), then fills the
+template with sheet metadata, comments, observations, and status shading.
+
 === Filling DOCX templates from YAML
 
 This gem contains a command-line utility to fill a DOCX template with comments
@@ -464,6 +491,35 @@ The `unique_id` is available as a variable in title and body templates:
 
 This renders to: `[DIS] GB-001: Clause 5.1 summary (ISO/DIS 2533)`
 
+==== Synchronizing with GitHub issues
+
+`github-create` is one-shot: it creates missing issues and skips existing
+ones. `github-sync` keeps the YAML and the issues in step, treating the YAML
+as the source of truth:
+
+[source,shell]
+----
+commenter github-sync --config github_config.yaml comments.yaml
+----
+
+For each comment it creates a missing issue, refreshes issue content from
+the YAML, and reconciles issue state. Two policies govern the parts that
+can collide:
+
+`--conflict yaml` (default):: Re-render the issue title and body from the
+YAML when they differ (YAML wins).
+`--conflict github`:: Leave differing issue content untouched (edits made
+on GitHub win).
+`--conflict skip`:: Take no action on differing content; the result is
+reported as a conflict.
+
+By default an open issue whose comment has a recorded disposition
+(`observations`) is closed — that is what keeps the
+`github-retrieve` round-trip working, since observations are retrieved from
+closed issues. Disable with `--no-close-on-disposition`.
+
+The milestone is resolved once per run and reused for every issue.
+
 ==== Retrieving observations from GitHub issues
 
 ===== Basic usage

data/lib/commenter/ballot_diff.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Commenter
+  # Stage-to-stage comparison of two ballots: how the comment set evolved
+  # between e.g. CD and DIS — new comments, withdrawn comments, repeated
+  # unchanged comments, and revised ones. Comments are matched by ID (member
+  # body + number), which repeats across stages.
+  module BallotDiff
+    module_function
+
+    def diff(before_sheet, after_sheet)
+      before_comments = indexed(before_sheet)
+      after_comments = indexed(after_sheet)
+
+      result = { new: [], withdrawn: [], repeated: [], revised: [], resolved: [] }
+      after_comments.each do |id, after|
+        before = before_comments[id]
+        if before.nil?
+          result[:new] << id
+        elsif identical?(before, after)
+          result[:repeated] << id
+        else
+          result[:revised] << id
+        end
+        result[:resolved] << id if dispositioned?(after)
+      end
+      before_comments.each_key { |id| result[:withdrawn] << id unless after_comments.key?(id) }
+
+      result.each_value(&:sort!)
+      result
+    end
+
+    def to_markdown(before_sheet, after_sheet)
+      data = diff(before_sheet, after_sheet)
+      lines = []
+      lines << "| Category | Count | Comments |"
+      lines << "|----------|-------|----------|"
+      data.each do |category, ids|
+        label = category.to_s.tr("_", " ").capitalize
+        listed = ids.length <= 10 ? ids.join(", ") : "#{ids.first(10).join(", ")} …"
+        lines << "| #{label} | #{ids.length} | #{listed} |"
+      end
+      lines << ""
+      lines << "Resolved (disposition recorded in the later stage): #{data[:resolved].length}"
+      lines.join("\n")
+    end
+
+    def indexed(sheet)
+      sheet.comments.each_with_object({}) do |comment, index|
+        key = comment.id.to_s
+        index[key] = comment unless key.empty?
+      end
+    end
+
+    def identical?(before, after)
+      before.comments == after.comments && before.proposed_change == after.proposed_change
+    end
+
+    def dispositioned?(comment)
+      observation = comment.observations.to_s.strip
+      !observation.empty? || DispositionStatus.match(comment.resolution_status)
+    end
+  end
+end

data/lib/commenter/cli.rb

@@ -65,6 +65,27 @@ module Commenter
       end
     end
 
+    desc "diff BEFORE.yaml AFTER.yaml", "Compare two ballots (e.g. CD vs DIS) by comment ID"
+    option :output, type: :string, aliases: :o, desc: "Output file (default: stdout)"
+    option :format, type: :string, default: "markdown", enum: %w[markdown yaml], desc: "Report format"
+    def diff(before_yaml, after_yaml)
+      before_sheet = CommentSheet.from_yaml(File.read(before_yaml))
+      after_sheet = CommentSheet.from_yaml(File.read(after_yaml))
+
+      report = if options[:format] == "yaml"
+                 BallotDiff.diff(before_sheet, after_sheet).to_yaml
+               else
+                 BallotDiff.to_markdown(before_sheet, after_sheet)
+               end
+
+      if options[:output]
+        File.write(options[:output], report)
+        puts "Wrote comparison to #{options[:output]}"
+      else
+        puts report
+      end
+    end
+
     desc "fill INPUT.yaml", "Fill DOCX template from YAML comments"
     option :output, type: :string, aliases: :o, default: "filled_comments.docx", desc: "Output DOCX file"
     option :template, type: :string, aliases: :t, desc: "Custom template file"
@@ -89,6 +110,27 @@ module Commenter
       puts "Filled template to #{output_docx}"
     end
 
+    desc "export INPUT.yaml", "Retrieve observations from GitHub issues and write the final disposition DOCX"
+    option :config, type: :string, aliases: :c, required: true, desc: "GitHub configuration YAML file"
+    option :output, type: :string, aliases: :o, default: "disposition_comments.docx", desc: "Output DOCX file"
+    option :template, type: :string, aliases: :t, desc: "Custom template file"
+    option :shading, type: :boolean, aliases: :s, desc: "Apply status-based shading"
+    option :include_open, type: :boolean, desc: "Include observations from open issues (not recommended)"
+    def export(input_yaml)
+      retriever = GitHubIssueRetriever.new(options[:config])
+      retriever.retrieve_observations_from_yaml(input_yaml, include_open: options[:include_open])
+
+      comment_sheet = CommentSheet.from_yaml(File.read(input_yaml))
+      raise "No comments found in YAML file" if comment_sheet.comments.empty?
+
+      template_path = options[:template] || File.join(__dir__, "../../data/iso_comment_template_2012-03.docx")
+      fill_options = options.merge(
+        date: comment_sheet.date, document: comment_sheet.document, project: comment_sheet.project
+      ).compact
+      Filler.new.fill(template_path, options[:output], comment_sheet.comments, fill_options)
+      puts "Retrieved observations and wrote disposition sheet to #{options[:output]}"
+    end
+
     desc "github-create INPUT.yaml", "Create GitHub issues from comments"
     option :config, type: :string, aliases: :c, required: true, desc: "GitHub configuration YAML file"
     option :output, type: :string, aliases: :o, desc: "Output YAML file (default: update original)"
@@ -160,6 +202,66 @@ module Commenter
       exit 1
     end
 
+    desc "github-sync INPUT.yaml", "Synchronize comments with GitHub issues (YAML is the source of truth)"
+    option :config, type: :string, aliases: :c, required: true, desc: "GitHub configuration YAML file"
+    option :output, type: :string, aliases: :o, desc: "Output YAML file (default: update original)"
+    option :stage, type: :string, desc: "Override approval stage (WD/CD/DIS/FDIS/PRF/PUB)"
+    option :milestone, type: :string, desc: "Override milestone name or number"
+    option :assignee, type: :string, desc: "Override assignee GitHub handle"
+    option :title_template, type: :string, desc: "Custom title template"
+    option :body_template, type: :string, desc: "Custom body template"
+    option :dry_run, type: :boolean, desc: "Preview sync actions without applying them"
+    option :conflict, type: :string, default: "yaml", enum: %w[yaml github skip],
+                      desc: "Conflict policy: yaml re-renders the issue, " \
+                            "github keeps the issue content, skip reports and leaves it"
+    option :close_on_disposition, type: :boolean, default: true,
+                                  desc: "Close open issues whose comment has a recorded " \
+                                        "disposition"
+    def github_sync(input_yaml)
+      sync = GitHubSync.new(options[:config], options[:title_template], options[:body_template])
+
+      sync_options = {
+        stage: options[:stage],
+        milestone: options[:milestone],
+        assignee: options[:assignee],
+        conflict: options[:conflict],
+        close_on_disposition: options[:close_on_disposition],
+        dry_run: options[:dry_run],
+        output: options[:output]
+      }.compact
+      results = sync.sync(input_yaml, sync_options)
+
+      if options[:dry_run]
+        puts "DRY RUN - Planned sync actions:"
+        puts "=" * 50
+        results.each do |result|
+          issue = result[:issue_number] ? "issue ##{result[:issue_number]}" : "no issue yet"
+          puts "#{result[:comment_id]} (#{issue}): #{result[:actions].join(", ")}"
+        end
+        puts "-" * 30
+        puts "Based on the issue state last recorded in the YAML; run without --dry-run for a live pass."
+      else
+        puts "GitHub sync results:"
+        puts "=" * 40
+        results.each do |result|
+          case result[:status]
+          when :created then puts "\u2713 #{result[:comment_id]}: Created issue ##{result[:issue_number]} " \
+                                   "(#{result[:issue_url]})"
+          when :updated then puts "\u21bb #{result[:comment_id]}: Updated issue ##{result[:issue_number]} " \
+                                   "(#{result[:actions].join(", ")})"
+          when :closed then puts "\u2713 #{result[:comment_id]}: Closed issue ##{result[:issue_number]} (disposition recorded)"
+          when :updated_and_closed then puts "\u21bb\u2713 #{result[:comment_id]}: Updated and closed issue ##{result[:issue_number]}"
+          when :unchanged then puts "- #{result[:comment_id]}: Issue ##{result[:issue_number]} in sync"
+          when :error then puts "\u2717 #{result[:comment_id]}: Error - #{result[:message]}"
+          end
+        end
+        puts "Updated YAML file: #{options[:output] || input_yaml}"
+      end
+    rescue StandardError => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+
     desc "github-retrieve INPUT.yaml", "Retrieve observations from GitHub issues"
     option :config, type: :string, aliases: :c, required: true, desc: "GitHub configuration YAML file"
     option :output, type: :string, aliases: :o, desc: "Output YAML file (default: update original)"

data/lib/commenter/github_integration.rb

@@ -250,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
 
@@ -276,13 +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
 
         comment.record_github_issue(issue_number: result[:issue_number], issue_url: result[:issue_url],
-                                    status: "open", created_at: Time.now.utc.iso8601)
+                                    status: result[:status] == :created ? "open" : comment.github_status,
+                                    created_at: comment.github_created_at || Time.now.utc.iso8601)
       end
 
       # Write updated YAML

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/version.rb

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

data/lib/commenter.rb

@@ -13,6 +13,7 @@ module Commenter
   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"
@@ -20,4 +21,5 @@ module Commenter
   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/cli_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require "zip"
 require "commenter/cli"
 require_relative "../support/osd_fixtures"
 require_relative "../support/xlsx_builder"
@@ -74,3 +75,29 @@ RSpec.describe Commenter::Cli do
     end
   end
 end
+
+RSpec.describe Commenter::Cli do
+  describe "#export" do
+    it "retrieves observations and writes the disposition DOCX" do
+      Dir.mktmpdir do |dir|
+        config = File.join(dir, "config.yaml")
+        File.write(config, { "github" => { "repository" => "t/t", "token" => "dummy" } }.to_yaml)
+        input = File.join(dir, "comments.yaml")
+        File.write(input, {
+          "version" => "2012-03", "date" => "2026-08-29", "document" => "ISO 2533:2026",
+          "comments" => [{ "id" => "DE-001", "body" => "DE", "comments" => "Remark",
+                           "observations" => "Accepted." }]
+        }.to_yaml)
+        output = File.join(dir, "disposition.docx")
+
+        described_class.start(["export", input, "--config", config, "--output", output])
+
+        expect(File).to exist(output)
+        header = Zip::File.open(output) do |zip|
+          zip.entries.find { |e| e.name == "word/header2.xml" }.get_input_stream(&:read)
+        end
+        expect(header).to include("Date: 2026-08-29")
+      end
+    end
+  end
+end

data/spec/commenter/github_sync_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tempfile"
+
+RSpec.describe Commenter::GitHubSync do
+  describe ".reconcile_actions" do
+    def actions(**overrides)
+      described_class.reconcile_actions(
+        issue: { title: "Title", body: "Body", state: "open" },
+        rendered: { title: "Title", body: "Body" },
+        disposition: nil,
+        **overrides
+      )
+    end
+
+    it "reports nothing when the issue is in sync" do
+      expect(actions).to eq([])
+    end
+
+    it "re-renders differing content under the yaml policy" do
+      expect(actions(conflict: "yaml", issue: { title: "Title", body: "Old body", state: "open" })).to eq([:update_content])
+    end
+
+    it "keeps differing GitHub content under the github policy" do
+      expect(actions(conflict: "github", issue: { title: "Title", body: "Edited on GitHub", state: "open" }))
+        .to eq([:keep_github_content])
+    end
+
+    it "reports a conflict under the skip policy" do
+      expect(actions(conflict: "skip", issue: { title: "Edited on GitHub", body: "Body", state: "open" })).to eq([:conflict])
+    end
+
+    it "closes an open issue whose comment has a disposition" do
+      expect(actions(disposition: "Accepted.")).to eq([:close])
+    end
+
+    it "combines content update and close" do
+      expect(actions(issue: { title: "Title", body: "Old", state: "open" }, disposition: "Accepted.")).to eq(%i[update_content close])
+    end
+
+    it "does not close a closed issue, an undispositioned comment, or when disabled" do
+      expect(actions(disposition: "Accepted.", issue: { title: "Title", body: "Body", state: "closed" })).to eq([])
+      expect(actions(disposition: "  ")).to eq([])
+      expect(actions(disposition: "Accepted.", close_on_disposition: false)).to eq([])
+    end
+
+    it "ignores whitespace when comparing content" do
+      expect(actions(issue: { title: "Title", body: "  Body  ", state: "open" })).to eq([])
+    end
+  end
+
+  describe "#sync dry run" do
+    let(:config_file) do
+      file = Tempfile.new(["config", ".yaml"])
+      file.write({ "github" => { "repository" => "test-org/test-repo", "token" => "test-token" } }.to_yaml)
+      file.close
+      file
+    end
+
+    def yaml_file(comments)
+      file = Tempfile.new(["comments", ".yaml"])
+      file.write({ "version" => "2012-03", "stage" => "DIS", "comments" => comments }.to_yaml)
+      file.close
+      file
+    end
+
+    after { config_file.unlink }
+
+    it "plans creation for comments without issues and closure for dispositioned open ones" do
+      input = yaml_file([
+                          { "id" => "US-001", "body" => "US", "comments" => "No issue yet" },
+                          { "id" => "US-002", "body" => "US", "comments" => "Resolved", "observations" => "Accepted.",
+                            "github" => { "issue_number" => 12, "status" => "open" } }
+                        ])
+
+      sync = described_class.new(config_file.path)
+      results = sync.sync(input.path, dry_run: true)
+
+      expect(results[0]).to eq(comment_id: "US-001", actions: [:create])
+      expect(results[1][:issue_number]).to eq(12)
+      expect(results[1][:actions]).to include(:close)
+
+      input.unlink
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: commenter
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Ribose
@@ -152,6 +152,7 @@ files:
 - exe/commenter
 - lib/commenter.rb
 - lib/commenter/ballot.rb
+- lib/commenter/ballot_diff.rb
 - lib/commenter/ballot_report.rb
 - lib/commenter/cli.rb
 - lib/commenter/comment.rb
@@ -163,6 +164,7 @@ files:
 - lib/commenter/github_info.rb
 - lib/commenter/github_integration.rb
 - lib/commenter/github_session.rb
+- lib/commenter/github_sync.rb
 - lib/commenter/parser.rb
 - lib/commenter/parser/osd_xlsx_parser.rb
 - lib/commenter/parser/track_change_docx_parser.rb
@@ -170,6 +172,7 @@ files:
 - schema/iso_comment_2012-03.yaml
 - schema/iso_comment_osd.yaml
 - sig/commenter.rbs
+- spec/commenter/ballot_diff_spec.rb
 - spec/commenter/ballot_report_spec.rb
 - spec/commenter/ballot_spec.rb
 - spec/commenter/cli_spec.rb
@@ -179,6 +182,7 @@ files:
 - spec/commenter/disposition_status_spec.rb
 - spec/commenter/filler_spec.rb
 - spec/commenter/github_integration_spec.rb
+- spec/commenter/github_sync_spec.rb
 - spec/commenter/osd_xlsx_parser_spec.rb
 - spec/commenter/track_change_docx_parser_spec.rb
 - spec/commenter_spec.rb