commenter 0.2.2 → 0.3.0

data/lib/commenter/comment.rb

@@ -2,7 +2,9 @@
 
 module Commenter
   class Comment
-    attr_accessor :id, :body, :locality, :type, :comments, :proposed_change, :observations, :github
+    attr_accessor :id, :body, :locality, :type, :comments, :proposed_change, :observations, :github,
+                  :user_name, :comment_type, :resolution_status, :resolution_date, :feedbacks,
+                  :motivation, :created_date, :stage_code
 
     def initialize(attributes = {})
       # Normalize input to symbols
@@ -11,11 +13,33 @@ module Commenter
       @id = attrs[:id]
       @body = attrs[:body]
       @locality = symbolize_keys(attrs[:locality] || {})
-      @type = attrs[:type]
+      @type = expand_comment_type(attrs[:type])
       @comments = attrs[:comments]
       @proposed_change = attrs[:proposed_change]
       @observations = attrs[:observations]
       @github = symbolize_keys(attrs[:github] || {})
+
+      # OSD-specific fields
+      @user_name = attrs[:user_name]
+      @comment_type = attrs[:comment_type]
+      @resolution_status = attrs[:resolution_status]
+      @resolution_date = attrs[:resolution_date]
+      @feedbacks = attrs[:feedbacks]
+      @motivation = attrs[:motivation]
+      @created_date = attrs[:created_date]
+      @stage_code = attrs[:stage_code]
+    end
+
+    # Expands short type codes to full names. One-way by design: already
+    # expanded values pass through unchanged so that reloading YAML output
+    # stays stable.
+    def expand_comment_type(type)
+      case type&.downcase
+      when "ge" then "general"
+      when "te" then "technical"
+      when "ed" then "editorial"
+      else type
+      end
     end
 
     def line_number
@@ -108,6 +132,14 @@ module Commenter
         comments: @comments,
         proposed_change: @proposed_change,
         observations: @observations,
+        user_name: @user_name,
+        comment_type: @comment_type,
+        resolution_status: @resolution_status,
+        resolution_date: @resolution_date,
+        feedbacks: @feedbacks,
+        motivation: @motivation,
+        created_date: @created_date,
+        stage_code: @stage_code,
         github: @github.empty? ? nil : @github
       }.compact
     end

data/lib/commenter/comment_sheet.rb

@@ -4,7 +4,7 @@ require_relative "comment"
 
 module Commenter
   class CommentSheet
-    attr_accessor :version, :date, :document, :project, :stage, :comments
+    attr_accessor :version, :date, :document, :project, :stage, :comments, :title_en, :title_fr
 
     def initialize(attributes = {})
       # Normalize input to symbols
@@ -15,6 +15,8 @@ module Commenter
       @document = attrs[:document]
       @project = attrs[:project]
       @stage = attrs[:stage]
+      @title_en = attrs[:title_en]
+      @title_fr = attrs[:title_fr]
       @comments = (attrs[:comments] || []).map { |c| c.is_a?(Comment) ? c : Comment.from_hash(c) }
     end
 
@@ -29,12 +31,18 @@ module Commenter
         document: @document,
         project: @project,
         stage: @stage,
+        title_en: @title_en,
+        title_fr: @title_fr,
         comments: @comments.map(&:to_h)
       }
     end
 
     def to_yaml_h
-      stringify_keys(to_h.merge(comments: @comments.map(&:to_yaml_h)))
+      hash = to_h.merge(comments: @comments.map(&:to_yaml_h))
+      # Remove nil-valued keys for cleaner YAML output
+      hash.delete(:title_en) if hash[:title_en].nil?
+      hash.delete(:title_fr) if hash[:title_fr].nil?
+      stringify_keys(hash)
     end
 
     def self.from_hash(hash)

data/lib/commenter/github_integration.rb

@@ -16,6 +16,7 @@ module Commenter
 
       @title_template = load_liquid_template(title_template_path || default_title_template_path)
       @body_template = load_liquid_template(body_template_path || default_body_template_path)
+      @unique_id_template = load_unique_id_template
     end
 
     def create_issues_from_yaml(yaml_file, options = {})
@@ -70,7 +71,26 @@ module Commenter
       raise "Template file not found: #{template_path}"
     end
 
+    def load_unique_id_template
+      unique_id_config = @config.dig("github", "templates", "unique_id")
+
+      if unique_id_config
+        # Check if it's a file path or inline template
+        if File.exist?(unique_id_config)
+          load_liquid_template(unique_id_config)
+        else
+          Liquid::Template.parse(unique_id_config)
+        end
+      else
+        # Default unique_id pattern: "[STAGE] COMMENT_ID"
+        Liquid::Template.parse("[{{ stage | upcase }}] {{ comment_id }}")
+      end
+    end
+
     def template_variables(comment, comment_sheet)
+      # Render unique_id first so it can be used in other templates
+      unique_id = render_unique_id(comment, comment_sheet)
+
       {
         # Comment sheet variables
         "stage" => comment_sheet.stage || "",
@@ -95,17 +115,30 @@ module Commenter
         "line_number" => comment.line_number || "",
 
         # Computed variables
+        "unique_id" => unique_id,
         "has_observations" => !comment.observations.nil? && !comment.observations.strip.empty?,
         "has_proposed_change" => !comment.proposed_change.nil? && !comment.proposed_change.strip.empty?,
         "locality_summary" => format_locality(comment)
       }
     end
 
+    def render_unique_id(comment, comment_sheet)
+      base_variables = {
+        "stage" => comment_sheet.stage || "",
+        "document" => comment_sheet.document || "",
+        "project" => comment_sheet.project || "",
+        "comment_id" => comment.id || "",
+        "body" => comment.body || "",
+        "type" => comment.type || ""
+      }
+      @unique_id_template.render(base_variables).strip
+    end
+
     def expand_comment_type(type)
       case type&.downcase
-      when "ge" then "General"
-      when "te" then "Technical"
-      when "ed" then "Editorial"
+      when "ge", "general" then "General"
+      when "te", "technical" then "Technical"
+      when "ed", "editorial" then "Editorial"
       else type || "Unknown"
       end
     end
@@ -119,9 +152,11 @@ module Commenter
     end
 
     def create_issue(comment, comment_sheet, options = {})
-      # Check if issue already exists
-      existing_issue = find_existing_issue(comment)
+      puts "[GitHubIssueCreator] Creating issue for comment ID: #{comment.id}"
+      # Check if issue already exists (stage-aware)
+      existing_issue = find_existing_issue(comment, comment_sheet)
       if existing_issue
+        puts "[GitHubIssueCreator] Issue already exists for comment ID: #{comment.id} at stage #{comment_sheet.stage}, skipping creation."
         return {
           comment_id: comment.id,
           status: :skipped,
@@ -139,8 +174,10 @@ module Commenter
         milestone: determine_milestone(comment, comment_sheet, options)
       }.compact
 
+      puts "[GitHubIssueCreator] Creating issue with title: #{title}"
       begin
         issue = @github_client.create_issue(@repo, title, body, issue_options)
+        puts "[GitHubIssueCreator] Issue created successfully: #{issue.html_url}"
         {
           comment_id: comment.id,
           status: :created,
@@ -148,6 +185,7 @@ module Commenter
           issue_url: issue.html_url
         }
       rescue Octokit::Error => e
+        puts "[GitHubIssueCreator] Error creating issue for comment ID: #{comment.id} - #{e.message}"
         {
           comment_id: comment.id,
           status: :error,
@@ -157,6 +195,8 @@ module Commenter
     end
 
     def preview_issue(comment, comment_sheet)
+      puts "[GitHubIssueCreator] Previewing issue for comment ID: #{comment.id}"
+
       title = @title_template.render(template_variables(comment, comment_sheet))
       body = @body_template.render(template_variables(comment, comment_sheet))
 
@@ -170,9 +210,13 @@ module Commenter
       }
     end
 
-    def find_existing_issue(comment)
-      # Search for existing issues with the comment ID in the title
-      query = "repo:#{@repo} in:title #{comment.id}"
+    def find_existing_issue(comment, comment_sheet)
+      unique_id = render_unique_id(comment, comment_sheet)
+      puts "[GitHubIssueCreator] Searching for existing issue with unique_id: #{unique_id}"
+
+      # Search for existing issues with the unique_id in the title
+      # The unique_id is configurable and defaults to "[STAGE] COMMENT_ID"
+      query = "repo:#{@repo} in:title \"#{unique_id}\""
       results = @github_client.search_issues(query)
       results.items.first
     rescue Octokit::Error
@@ -212,26 +256,25 @@ module Commenter
       assignees.compact.uniq
     end
 
-    def determine_milestone(_comment, comment_sheet, options)
-      # Check for override in options
-      return resolve_milestone_by_name_or_number(options[:milestone]) if options[:milestone]
-
-      # Check for stage-specific milestone
-      if comment_sheet.stage
-        stage_milestone = @config.dig("github", "stage_milestones", comment_sheet.stage)
-        if stage_milestone
-          milestone_number = resolve_milestone_by_name_or_number(stage_milestone)
-          return milestone_number if milestone_number
-        end
-      end
+    def determine_milestone(_comment, _comment_sheet, _options)
+      # # Check for stage-specific milestone
+      # if comment_sheet.stage
+      #   stage_milestone = @config.dig("github", "stage_milestones", comment_sheet.stage)
+      #   if stage_milestone
+      #     milestone_number = resolve_milestone_by_name_or_number(stage_milestone)
+      #     return milestone_number if milestone_number
+      #   end
+      # end
 
       # Use configured milestone
       milestone_config = @config.dig("github", "milestone")
       return nil unless milestone_config
 
       if milestone_config["number"]
+        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"])
       end
     end
@@ -246,6 +289,8 @@ module Commenter
 
     def find_milestone_by_name(name)
       milestones = @github_client.milestones(@repo, state: "all")
+
+      puts "[GitHubIssueCreator] Found #{milestones.size} milestones in repository #{@repo}" if milestones.any?
       milestone = milestones.find { |m| m.title == name }
       milestone&.number
     rescue Octokit::Error
@@ -411,7 +456,8 @@ module Commenter
       end
 
       # Fallback to last comment if configured and no magic comment found
-      return comments.last.body.strip if @config.dig("github", "retrieval", "fallback_to_last_comment") && !comments.empty?
+      return comments.last.body.strip if @config.dig("github", "retrieval",
+                                                     "fallback_to_last_comment") && !comments.empty?
 
       nil
     rescue Octokit::Error

data/lib/commenter/parser/osd_xlsx_parser.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require "roo"
+require_relative "../comment_sheet"
+require_relative "../comment"
+
+module Commenter
+  class Parser
+    # Parser for ISO Online Standards Development (OSD) XLSX exports.
+    #
+    # Supports two variants, detected from the header row:
+    #   - "resolved": single "Comments (N)" sheet with resolution data
+    #     (columns: Comment ID, User name, Clause nb, ..., Resolution status,
+    #     Motivation, Resolution Date, Stage code)
+    #   - "unresolved": multi-sheet format with "Comments (N)",
+    #     "Unresolved comments (N)", "Resolved comments (N)" sheets
+    #     (columns: User name, Clause nb, ..., Comment type, Comment/Motivation,
+    #     Comment on text, Proposal on Text, Proposed change, Replies,
+    #     Resolution status, Justification, Resolution Date, Date, Comment number)
+    #
+    # Both variants share the same header structure in the first rows:
+    #   Row 0: [Date, Reference, nil, "", Title EN, nil, nil, Title FR, ...]
+    #   Row 1: ["2026-04-21", "ISO/DIS 5843-6(en)", ...]
+    #   Row 2: empty
+    #   Row 3: column headers
+    #   Row 4+: data
+    class OsdXlsxParser
+      # Header names are mapped per variant onto common attribute keys so both
+      # variants share a single comment builder. Headers are mapped by real
+      # column position, tolerating gaps in the header row.
+      RESOLVED_COLUMN_KEYS = {
+        "Comment ID" => :id,
+        "User name" => :user_name,
+        "Clause nb" => :clause,
+        "Clause Title" => :clause_title,
+        "Subtype" => :comment_type,
+        "Comment" => :comment_text,
+        "Proposal on Text" => :proposal_on_text,
+        "Proposed change" => :proposed_change,
+        "Feedbacks" => :feedbacks,
+        "Created Date" => :created_date,
+        "Resolution status" => :resolution_status,
+        "Motivation" => :motivation,
+        "Resolution Date" => :resolution_date,
+        "Stage code" => :stage_code
+      }.freeze
+
+      UNRESOLVED_COLUMN_KEYS = {
+        "User name" => :user_name,
+        "Clause nb" => :clause,
+        "Clause Title" => :clause_title,
+        "Comment type" => :comment_type,
+        "Comment/Motivation" => :comment_text,
+        "Proposal on Text" => :proposal_on_text,
+        "Proposed change" => :proposed_change,
+        "Replies" => :feedbacks,
+        "Resolution status" => :resolution_status,
+        "Justification" => :motivation,
+        "Resolution Date" => :resolution_date,
+        "Date" => :created_date,
+        "Comment number" => :id
+      }.freeze
+
+      def parse(xlsx_path, options = {})
+        xlsx = Roo::Spreadsheet.open(xlsx_path)
+
+        sheet_name = select_sheet(xlsx, options)
+        sheet = xlsx.sheet(sheet_name)
+        header_row_num = find_header_row(sheet)
+        variant = detect_variant(sheet.row(header_row_num))
+
+        comments = parse_comments(sheet, header_row_num, variant, options)
+        CommentSheet.new(version: "osd", **extract_metadata(xlsx, sheet_name), comments: comments)
+      end
+
+      private
+
+      def select_sheet(xlsx, options)
+        sheets = xlsx.sheets
+
+        if options[:sheet]
+          raise "Sheet '#{options[:sheet]}' not found. Available: #{sheets.join(", ")}" unless sheets.include?(options[:sheet])
+
+          return options[:sheet]
+        end
+
+        if options[:resolved_only]
+          sheets.find { |s| s.start_with?("Resolved") } || sheets.find { |s| s.start_with?("Comments") }
+        elsif options[:unresolved_only]
+          sheets.find { |s| s.start_with?("Unresolved") } || sheets.find { |s| s.start_with?("Comments") }
+        else
+          sheets.first # Default: first sheet (usually "Comments (N)" with all comments)
+        end
+      end
+
+      def find_header_row(sheet)
+        (1..10).each do |row_num|
+          headers = sheet.row(row_num).to_a.compact.map(&:to_s)
+          return row_num if headers.include?("User name") || headers.include?("Comment ID")
+        end
+
+        raise "Could not find header row in XLSX sheet"
+      end
+
+      def detect_variant(header_row)
+        headers = header_row.to_a.compact.map(&:to_s)
+        if headers.include?("Comment ID") || headers.include?("Subtype")
+          :resolved
+        elsif headers.include?("Comment/Motivation") || headers.include?("Comment type")
+          :unresolved
+        else
+          headers.length >= 15 ? :resolved : :unresolved
+        end
+      end
+
+      def extract_metadata(xlsx, sheet_name)
+        values = xlsx.sheet(sheet_name).row(2)
+        metadata = { date: nil, document: nil, project: nil, stage: nil, title_en: nil, title_fr: nil }
+        return metadata if values.nil?
+
+        metadata[:date] = header_value(values[0], "Date")
+
+        reference = header_value(values[1], "Reference")
+        if reference
+          metadata[:document] = reference
+          metadata[:stage] = extract_stage(reference)
+          metadata[:project] = extract_project(reference)
+        end
+
+        metadata[:title_en] = header_value(values[4], "Title EN")
+        metadata[:title_fr] = header_value(values[7], "Title FR")
+        metadata
+      end
+
+      def header_value(raw, label)
+        return nil if raw.nil?
+
+        value = raw.is_a?(Date) ? raw.strftime("%Y-%m-%d") : raw.to_s.strip
+        value.empty? || value == label ? nil : value
+      end
+
+      def extract_stage(reference)
+        case reference
+        when %r{/WD\b}i then "WD"
+        when %r{/CD\b}i then "CD"
+        when %r{/DIS\b}i then "DIS"
+        when %r{/FDIS\b}i then "FDIS"
+        end
+      end
+
+      def extract_project(reference)
+        # Extract ISO number from reference like "ISO/DIS 5843-6(en)"
+        match = reference.match(%r{(ISO[\s/]*\w*\s*\d+[\d-]*)})
+        match ? match[1].strip.gsub(/\s+/, " ") : nil
+      end
+
+      def parse_comments(sheet, header_row_num, variant, options)
+        column_keys = variant == :resolved ? RESOLVED_COLUMN_KEYS : UNRESOLVED_COLUMN_KEYS
+        col_map = build_column_map(sheet.row(header_row_num), column_keys)
+
+        comments = []
+        (header_row_num + 1..sheet.last_row).each do |row_num|
+          row = sheet.row(row_num)
+          next if row.nil? || row.to_a.compact.empty?
+
+          comment = build_comment(row, col_map, options)
+          comments << comment if comment
+        end
+        comments
+      end
+
+      def build_column_map(header_row, column_keys)
+        header_row.to_a.each_with_index.with_object({}) do |(header, index), map|
+          key = column_keys[header.to_s.strip]
+          map[key] = index if key
+        end
+      end
+
+      def build_comment(row, col_map, options)
+        id = cell_value(row, col_map[:id])
+        return nil if id.nil?
+
+        id_str = id.is_a?(Float) ? id.to_i.to_s : id.to_s
+        comment_text = cell_value(row, col_map[:comment_text]) || ""
+        return nil if comment_text.strip.empty? && id_str.empty?
+
+        attrs = base_attributes(row, col_map, id_str, comment_text)
+                .merge(resolution_attributes(row, col_map))
+        attrs[:observations] = resolution_observations(row, col_map) unless options[:exclude_observations]
+        Comment.new(attrs)
+      end
+
+      def base_attributes(row, col_map, id_str, comment_text)
+        user_name = cell_value_str(row, col_map[:user_name]).to_s
+        clause = cell_value_str(row, col_map[:clause]).to_s
+        clause_title = cell_value_str(row, col_map[:clause_title]).to_s
+        {
+          id: id_str,
+          body: user_name,
+          locality: {
+            clause: clause.empty? ? nil : clause,
+            element: clause_title.empty? ? nil : clause_title
+          }.compact,
+          type: normalize_comment_type(cell_value_str(row, col_map[:comment_type]).to_s),
+          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])
+        }
+      end
+
+      def resolution_attributes(row, col_map)
+        {
+          user_name: cell_value_str(row, col_map[:user_name]).to_s,
+          comment_type: cell_value_str(row, col_map[:comment_type]).to_s,
+          resolution_status: cell_value_str(row, col_map[:resolution_status]),
+          resolution_date: cell_value_str(row, col_map[:resolution_date]),
+          feedbacks: cell_value_str(row, col_map[:feedbacks]),
+          motivation: cell_value_str(row, col_map[:motivation]),
+          created_date: cell_value_str(row, col_map[:created_date]),
+          stage_code: cell_value_str(row, col_map[:stage_code])
+        }
+      end
+
+      def resolution_observations(row, col_map)
+        parts = [cell_value_str(row, col_map[:resolution_status]),
+                 cell_value_str(row, col_map[:motivation])].compact
+        parts.empty? ? nil : parts.join(". ")
+      end
+
+      def normalize_comment_type(type_str)
+        case type_str.strip.downcase
+        when "editorial", "ed" then "ed"
+        when "technical", "te" then "te"
+        when "general", "ge" then "ge"
+        else type_str.strip
+        end
+      end
+
+      def cell_value(row, index)
+        return nil if index.nil? || row.length <= index
+
+        value = row[index]
+        value.is_a?(String) && value.strip.empty? ? nil : value
+      end
+
+      def cell_value_str(row, index)
+        value = cell_value(row, index)
+        value.nil? || value.to_s.strip.empty? ? nil : value.to_s.strip
+      end
+    end
+  end
+end