commenter 0.2.1 → 0.2.2

data/spec/commenter/comment_sheet_spec.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Commenter::CommentSheet do
+  describe "#initialize" do
+    it "creates a comment sheet with all attributes" do
+      attributes = {
+        version: "2012-03",
+        date: "2024-06-04",
+        document: "ISO 80000-2:2019",
+        project: "Mathematics review",
+        stage: "DIS",
+        comments: [
+          {
+            id: "US-001",
+            body: "US",
+            locality: { clause: "5.1" },
+            type: "te",
+            comments: "Test comment",
+            proposed_change: "Test change"
+          }
+        ]
+      }
+
+      sheet = described_class.new(attributes)
+
+      expect(sheet.version).to eq("2012-03")
+      expect(sheet.date).to eq("2024-06-04")
+      expect(sheet.document).to eq("ISO 80000-2:2019")
+      expect(sheet.project).to eq("Mathematics review")
+      expect(sheet.stage).to eq("DIS")
+      expect(sheet.comments).to be_an(Array)
+      expect(sheet.comments.length).to eq(1)
+      expect(sheet.comments.first).to be_a(Commenter::Comment)
+    end
+
+    it "handles string keys in attributes" do
+      attributes = {
+        "version" => "2012-03",
+        "stage" => "CD",
+        "comments" => []
+      }
+
+      sheet = described_class.new(attributes)
+
+      expect(sheet.version).to eq("2012-03")
+      expect(sheet.stage).to eq("CD")
+    end
+
+    it "sets default version when not provided" do
+      sheet = described_class.new({})
+
+      expect(sheet.version).to eq("2012-03")
+    end
+
+    it "converts comment hashes to Comment objects" do
+      attributes = {
+        comments: [
+          {
+            id: "US-001",
+            locality: { clause: "5.1" }
+          }
+        ]
+      }
+
+      sheet = described_class.new(attributes)
+
+      expect(sheet.comments.first).to be_a(Commenter::Comment)
+      expect(sheet.comments.first.id).to eq("US-001")
+    end
+
+    it "preserves existing Comment objects" do
+      comment = Commenter::Comment.new(id: "US-001")
+      attributes = { comments: [comment] }
+
+      sheet = described_class.new(attributes)
+
+      expect(sheet.comments.first).to be(comment)
+    end
+  end
+
+  describe "#add_comment" do
+    let(:sheet) { described_class.new({}) }
+
+    it "adds a Comment object" do
+      comment = Commenter::Comment.new(id: "US-001")
+      sheet.add_comment(comment)
+
+      expect(sheet.comments).to include(comment)
+    end
+
+    it "converts hash to Comment object" do
+      comment_hash = { id: "US-001", locality: { clause: "5.1" } }
+      sheet.add_comment(comment_hash)
+
+      expect(sheet.comments.length).to eq(1)
+      expect(sheet.comments.first).to be_a(Commenter::Comment)
+      expect(sheet.comments.first.id).to eq("US-001")
+    end
+  end
+
+  describe "#to_h" do
+    it "converts comment sheet to hash including stage" do
+      sheet = described_class.new(
+        version: "2012-03",
+        date: "2024-06-04",
+        document: "Test Document",
+        project: "Test Project",
+        stage: "DIS",
+        comments: [
+          Commenter::Comment.new(id: "US-001", locality: { clause: "5.1" })
+        ]
+      )
+
+      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)
+    end
+
+    it "includes nil stage when not set" do
+      sheet = described_class.new({})
+      hash = sheet.to_h
+
+      expect(hash).to have_key(:stage)
+      expect(hash[:stage]).to be_nil
+    end
+  end
+
+  describe "#to_yaml_h" do
+    it "converts to YAML-friendly hash with string keys" do
+      sheet = described_class.new(
+        stage: "DIS",
+        comments: [
+          Commenter::Comment.new(id: "US-001")
+        ]
+      )
+
+      yaml_hash = sheet.to_yaml_h
+
+      expect(yaml_hash["stage"]).to eq("DIS")
+      expect(yaml_hash["comments"]).to be_an(Array)
+      expect(yaml_hash["comments"].first).to be_a(Hash)
+      expect(yaml_hash["comments"].first["id"]).to eq("US-001")
+    end
+  end
+
+  describe ".from_hash" do
+    it "creates comment sheet from hash" do
+      hash = {
+        version: "2012-03",
+        stage: "CD",
+        comments: [
+          { id: "US-001", locality: { clause: "5.1" } }
+        ]
+      }
+
+      sheet = described_class.from_hash(hash)
+
+      expect(sheet).to be_a(described_class)
+      expect(sheet.version).to eq("2012-03")
+      expect(sheet.stage).to eq("CD")
+      expect(sheet.comments.length).to eq(1)
+    end
+  end
+
+  describe "stage validation" do
+    it "accepts valid stage values" do
+      valid_stages = %w[WD CD DIS FDIS PRF PUB]
+
+      valid_stages.each do |stage|
+        sheet = described_class.new(stage: stage)
+        expect(sheet.stage).to eq(stage)
+      end
+    end
+
+    it "accepts nil stage" do
+      sheet = described_class.new(stage: nil)
+      expect(sheet.stage).to be_nil
+    end
+
+    it "accepts custom stage values" do
+      sheet = described_class.new(stage: "CUSTOM")
+      expect(sheet.stage).to eq("CUSTOM")
+    end
+  end
+end

data/spec/commenter/comment_spec.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Commenter::Comment do
+  describe "#initialize" do
+    it "creates a comment with all attributes" do
+      attributes = {
+        id: "US-001",
+        body: "US",
+        locality: { clause: "5.1", element: "Table 1", line_number: "42" },
+        type: "te",
+        comments: "Test comment",
+        proposed_change: "Test change",
+        observations: "Test observations"
+      }
+
+      comment = described_class.new(attributes)
+
+      expect(comment.id).to eq("US-001")
+      expect(comment.body).to eq("US")
+      expect(comment.clause).to eq("5.1")
+      expect(comment.element).to eq("Table 1")
+      expect(comment.line_number).to eq("42")
+      expect(comment.type).to eq("te")
+      expect(comment.comments).to eq("Test comment")
+      expect(comment.proposed_change).to eq("Test change")
+      expect(comment.observations).to eq("Test observations")
+    end
+
+    it "handles string keys in attributes" do
+      attributes = {
+        "id" => "US-001",
+        "locality" => { "clause" => "5.1" }
+      }
+
+      comment = described_class.new(attributes)
+
+      expect(comment.id).to eq("US-001")
+      expect(comment.clause).to eq("5.1")
+    end
+  end
+
+  describe "#brief_summary" do
+    context "with locality information" do
+      it "includes clause and element" do
+        comment = described_class.new(
+          locality: { clause: "5.1", element: "Table 1" },
+          comments: "This is a test comment"
+        )
+
+        summary = comment.brief_summary
+
+        expect(summary).to include("Clause 5.1")
+        expect(summary).to include("Table 1")
+        expect(summary).to include("This is a test comment")
+      end
+
+      it "includes line number when present" do
+        comment = described_class.new(
+          locality: { clause: "5.1", line_number: "42" },
+          comments: "Test comment"
+        )
+
+        summary = comment.brief_summary
+
+        expect(summary).to include("Clause 5.1")
+        expect(summary).to include("Line 42")
+      end
+
+      it "handles empty locality gracefully" do
+        comment = described_class.new(
+          locality: { clause: "" },
+          comments: "Test comment"
+        )
+
+        summary = comment.brief_summary
+
+        expect(summary).to eq("Test comment")
+      end
+    end
+
+    context "with comment text" do
+      it "uses first sentence when short enough" do
+        comment = described_class.new(
+          locality: { clause: "5.1" },
+          comments: "Short comment. This is ignored."
+        )
+
+        summary = comment.brief_summary
+
+        expect(summary).to include("Short comment")
+        expect(summary).not_to include("This is ignored")
+      end
+
+      it "truncates long text" do
+        long_text = "This is a very long comment that exceeds the typical length limit and should be truncated appropriately"
+        comment = described_class.new(
+          locality: { clause: "5.1" },
+          comments: long_text
+        )
+
+        summary = comment.brief_summary(80)
+
+        expect(summary.length).to be <= 80
+        expect(summary).to include("Clause 5.1")
+      end
+
+      it "handles empty comments" do
+        comment = described_class.new(
+          locality: { clause: "5.1" },
+          comments: ""
+        )
+
+        summary = comment.brief_summary
+
+        expect(summary).to eq("Clause 5.1")
+      end
+
+      it "handles nil comments" do
+        comment = described_class.new(
+          locality: { clause: "5.1" },
+          comments: nil
+        )
+
+        summary = comment.brief_summary
+
+        expect(summary).to eq("Clause 5.1")
+      end
+    end
+
+    context "without locality or comments" do
+      it "returns default message" do
+        comment = described_class.new(
+          locality: { clause: "" },
+          comments: ""
+        )
+
+        summary = comment.brief_summary
+
+        expect(summary).to eq("No description")
+      end
+    end
+
+    context "respects max_length parameter" do
+      it "truncates to specified length" do
+        comment = described_class.new(
+          locality: { clause: "5.1" },
+          comments: "This is a test comment"
+        )
+
+        summary = comment.brief_summary(20)
+
+        expect(summary.length).to be <= 20
+      end
+    end
+  end
+
+  describe "#to_h" do
+    it "converts comment to hash" do
+      comment = described_class.new(
+        id: "US-001",
+        body: "US",
+        locality: { clause: "5.1" },
+        type: "te",
+        comments: "Test",
+        proposed_change: "Change",
+        observations: "Obs"
+      )
+
+      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("te")
+      expect(hash[:comments]).to eq("Test")
+      expect(hash[:proposed_change]).to eq("Change")
+      expect(hash[:observations]).to eq("Obs")
+    end
+  end
+
+  describe "#to_yaml_h" do
+    it "converts to YAML-friendly hash with string keys" do
+      comment = described_class.new(
+        id: "US-001",
+        locality: { clause: "5.1" },
+        observations: nil
+      )
+
+      yaml_hash = comment.to_yaml_h
+
+      expect(yaml_hash["id"]).to eq("US-001")
+      expect(yaml_hash["locality"]["clause"]).to eq("5.1")
+      expect(yaml_hash).not_to have_key("observations") # nil observations removed
+    end
+
+    it "removes empty observations" do
+      comment = described_class.new(observations: "")
+      yaml_hash = comment.to_yaml_h
+
+      expect(yaml_hash).not_to have_key("observations")
+    end
+  end
+
+  describe ".from_hash" do
+    it "creates comment from hash" do
+      hash = {
+        id: "US-001",
+        locality: { clause: "5.1" }
+      }
+
+      comment = described_class.from_hash(hash)
+
+      expect(comment).to be_a(described_class)
+      expect(comment.id).to eq("US-001")
+      expect(comment.clause).to eq("5.1")
+    end
+  end
+end

data/spec/commenter/github_integration_spec.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tempfile"
+require "yaml"
+
+RSpec.describe Commenter::GitHubIssueCreator do
+  let(:config_data) do
+    {
+      "github" => {
+        "repository" => "test-org/test-repo",
+        "token" => "test-token",
+        "default_labels" => ["comment-review"],
+        "stage_labels" => {
+          "DIS" => ["draft-international-standard"]
+        },
+        "default_assignee" => "test-assignee",
+        "milestone" => {
+          "name" => "Test Milestone"
+        }
+      }
+    }
+  end
+
+  let(:config_file) do
+    file = Tempfile.new(["config", ".yaml"])
+    file.write(config_data.to_yaml)
+    file.close
+    file
+  end
+
+  let(:title_template_file) do
+    file = Tempfile.new(["title", ".liquid"])
+    file.write("{{ comment_id }}: {{ brief_summary }}")
+    file.close
+    file
+  end
+
+  let(:body_template_file) do
+    file = Tempfile.new(["body", ".liquid"])
+    file.write("Comment: {{ comments }}\nType: {{ type_full_name }}")
+    file.close
+    file
+  end
+
+  let(:yaml_data) do
+    {
+      "version" => "2012-03",
+      "stage" => "DIS",
+      "document" => "Test Document",
+      "project" => "Test Project",
+      "comments" => [
+        {
+          "id" => "US-001",
+          "body" => "US",
+          "locality" => {
+            "clause" => "5.1",
+            "element" => "Table 1"
+          },
+          "type" => "te",
+          "comments" => "Test comment text",
+          "proposed_change" => "Test proposed change"
+        }
+      ]
+    }
+  end
+
+  let(:yaml_file) do
+    file = Tempfile.new(["comments", ".yaml"])
+    file.write(yaml_data.to_yaml)
+    file.close
+    file
+  end
+
+  after do
+    config_file.unlink
+    title_template_file.unlink
+    body_template_file.unlink
+    yaml_file.unlink
+  end
+
+  describe "#initialize" do
+    it "loads configuration and creates GitHub client" do
+      expect { described_class.new(config_file.path, title_template_file.path, body_template_file.path) }
+        .not_to raise_error
+    end
+
+    it "raises error when config file not found" do
+      expect { described_class.new("nonexistent.yaml") }
+        .to raise_error("Configuration file not found: nonexistent.yaml")
+    end
+
+    it "raises error when repository not specified" do
+      config_without_repo = config_data.dup
+      config_without_repo["github"].delete("repository")
+
+      file = Tempfile.new(["config", ".yaml"])
+      file.write(config_without_repo.to_yaml)
+      file.close
+
+      expect { described_class.new(file.path) }
+        .to raise_error("GitHub repository not specified in config")
+
+      file.unlink
+    end
+  end
+
+  describe "#create_issues_from_yaml" do
+    let(:creator) { described_class.new(config_file.path, title_template_file.path, body_template_file.path) }
+
+    context "with dry_run option" do
+      it "returns preview data without creating issues" do
+        results = creator.create_issues_from_yaml(yaml_file.path, dry_run: true)
+
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(1)
+
+        result = results.first
+        expect(result[:comment_id]).to eq("US-001")
+        expect(result[:title]).to eq("US-001: Clause 5.1, Table 1: Test comment text")
+        expect(result[:body]).to include("Comment: Test comment text")
+        expect(result[:body]).to include("Type: Technical")
+        expect(result[:labels]).to include("comment-review", "draft-international-standard", "te")
+        expect(result[:assignees]).to eq(["test-assignee"])
+      end
+    end
+
+    it "processes stage override" do
+      results = creator.create_issues_from_yaml(yaml_file.path, dry_run: true, stage: "CD")
+
+      result = results.first
+      expect(result[:labels]).not_to include("draft-international-standard")
+    end
+  end
+
+  describe "template variable generation" do
+    let(:creator) { described_class.new(config_file.path, title_template_file.path, body_template_file.path) }
+    let(:comment_sheet) { Commenter::CommentSheet.from_hash(yaml_data) }
+    let(:comment) { comment_sheet.comments.first }
+
+    it "generates correct template variables" do
+      variables = creator.send(:template_variables, comment, comment_sheet)
+
+      expect(variables["stage"]).to eq("DIS")
+      expect(variables["document"]).to eq("Test Document")
+      expect(variables["comment_id"]).to eq("US-001")
+      expect(variables["type"]).to eq("te")
+      expect(variables["type_full_name"]).to eq("Technical")
+      expect(variables["clause"]).to eq("5.1")
+      expect(variables["element"]).to eq("Table 1")
+      expect(variables["comments"]).to eq("Test comment text")
+      expect(variables["brief_summary"]).to include("Clause 5.1")
+      expect(variables["has_proposed_change"]).to be true
+    end
+  end
+
+  describe "label determination" do
+    let(:creator) { described_class.new(config_file.path, title_template_file.path, body_template_file.path) }
+    let(:comment_sheet) { Commenter::CommentSheet.from_hash(yaml_data) }
+    let(:comment) { comment_sheet.comments.first }
+
+    it "combines default, stage-specific, and comment type labels" do
+      labels = creator.send(:determine_labels, comment, comment_sheet)
+
+      expect(labels).to include("comment-review") # default
+      expect(labels).to include("draft-international-standard") # stage-specific
+      expect(labels).to include("te") # comment type
+      expect(labels.uniq).to eq(labels) # no duplicates
+    end
+  end
+
+  describe "comment type expansion" do
+    let(:creator) { described_class.new(config_file.path, title_template_file.path, body_template_file.path) }
+
+    it "expands comment type codes correctly" do
+      expect(creator.send(:expand_comment_type, "ge")).to eq("General")
+      expect(creator.send(:expand_comment_type, "te")).to eq("Technical")
+      expect(creator.send(:expand_comment_type, "ed")).to eq("Editorial")
+      expect(creator.send(:expand_comment_type, "unknown")).to eq("unknown")
+      expect(creator.send(:expand_comment_type, nil)).to eq("Unknown")
+    end
+  end
+end

data/spec/commenter_spec.rb

@@ -4,5 +4,4 @@ RSpec.describe Commenter do
   it "has a version number" do
     expect(Commenter::VERSION).not_to be nil
   end
-
 end