commenter 0.3.0 → 0.4.0

data/lib/commenter/comment.rb

@@ -1,180 +1,157 @@
 # frozen_string_literal: true
 
+require "lutaml/model"
+
 module Commenter
-  class Comment
-    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
-      attrs = symbolize_keys(attributes)
-
-      @id = attrs[:id]
-      @body = attrs[:body]
-      @locality = symbolize_keys(attrs[:locality] || {})
-      @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.
+  # A single comment on a reviewed document. (De)serialization is declared
+  # with lutaml-model; the only custom mapping logic is the type expansion
+  # (short codes to full names) and empty-observation omission, both at the
+  # YAML boundary.
+  class Comment < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :body, :string
+    attribute :locality, CommentLocality
+    attribute :type, :string
+    attribute :comments, :string
+    attribute :proposed_change, :string
+    attribute :observations, :string
+
+    # OSD-specific fields
+    attribute :user_name, :string
+    attribute :comment_type, :string
+    attribute :resolution_status, :string
+    attribute :resolution_date, :string
+    attribute :feedbacks, :string
+    attribute :motivation, :string
+    attribute :created_date, :string
+    attribute :stage_code, :string
+
+    attribute :github, GithubInfo
+
+    yaml do
+      map "id", to: :id
+      map "body", to: :body
+      map "locality", to: :locality
+      map "type", with: { to: :type_to_yaml, from: :type_from_yaml }
+      map "comments", to: :comments
+      map "proposed_change", to: :proposed_change
+      map "observations", with: { to: :observations_to_yaml, from: :observations_from_yaml }
+      map "user_name", to: :user_name
+      map "comment_type", to: :comment_type
+      map "resolution_status", to: :resolution_status
+      map "resolution_date", to: :resolution_date
+      map "feedbacks", to: :feedbacks
+      map "motivation", to: :motivation
+      map "created_date", to: :created_date
+      map "stage_code", to: :stage_code
+      map "github", to: :github
+    end
+
+    def type_from_yaml(model, value)
+      model.type = CommentType.full_name(value)
+    end
+
+    def type_to_yaml(model, doc)
+      doc["type"] = model.type if model.type && !model.type.empty?
+    end
+
+    def observations_from_yaml(model, value)
+      model.observations = value.to_s.empty? ? nil : value
+    end
+
+    def observations_to_yaml(model, doc)
+      doc["observations"] = model.observations if model.observations && !model.observations.empty?
+    end
+
     def expand_comment_type(type)
-      case type&.downcase
-      when "ge" then "general"
-      when "te" then "technical"
-      when "ed" then "editorial"
-      else type
-      end
+      CommentType.full_name(type)
+    end
+
+    def to_h
+      Comment.to_hash(self)
     end
 
+    alias to_yaml_h to_h
+
     def line_number
-      @locality[:line_number]
+      locality&.line_number
     end
 
     def line_number=(value)
-      @locality[:line_number] = value
+      self.locality = CommentLocality.new if locality.nil?
+      locality.line_number = value
     end
 
     def clause
-      @locality[:clause]
+      locality&.clause
     end
 
     def clause=(value)
-      @locality[:clause] = value
+      self.locality = CommentLocality.new if locality.nil?
+      locality.clause = value
     end
 
     def element
-      @locality[:element]
+      locality&.element
     end
 
     def element=(value)
-      @locality[:element] = value
+      self.locality = CommentLocality.new if locality.nil?
+      locality.element = value
     end
 
-    def brief_summary(max_length = 80)
-      parts = []
-
-      # Add locality information first
-      parts << "Clause #{clause}" if clause && !clause.strip.empty?
-      parts << element if element && !element.strip.empty?
-      parts << "Line #{line_number}" if line_number && !line_number.strip.empty?
+    def brief_summary(max_length = 60)
+      description = comments.to_s.split(/[.!?\n]/).map(&:strip).reject(&:empty?).first.to_s
+      locality_text = format_locality
 
-      locality_text = parts.join(", ")
-
-      # Add description from comment text
-      if @comments && !@comments.strip.empty?
-        # Extract first sentence or truncate
-        clean_text = @comments.strip.gsub(/\s+/, " ")
-        first_sentence = clean_text.split(/[.!?]/).first&.strip
-        description = if first_sentence && first_sentence.length < max_length
-                        first_sentence
-                      else
-                        clean_text[0...50]
-                      end
-
-        if locality_text.empty?
-          description
-        else
-          # Combine locality + description, respecting max_length
-          combined = "#{locality_text}: #{description}"
-          combined.length <= max_length ? combined : "#{locality_text}: #{description[0...(max_length - locality_text.length - 2)]}"
-        end
-      else
+      if description.empty?
         locality_text.empty? ? "No description" : locality_text
+      elsif locality_text.empty?
+        combined = description
+        combined.length <= max_length ? combined : "#{combined[0...(max_length - 3)]}..."
+      else
+        combined = "#{locality_text}: #{description}"
+        combined.length <= max_length ? combined : "#{locality_text}: #{description[0...(max_length - locality_text.length - 2)]}"
       end
     end
 
     def github_issue_number
-      @github[:issue_number]
+      github&.issue_number
     end
 
     def github_issue_url
-      @github[:issue_url]
+      github&.issue_url
     end
 
     def github_status
-      @github[:status]
+      github&.status
     end
 
     def github_created_at
-      @github[:created_at]
+      github&.created_at
     end
 
     def github_updated_at
-      @github[:updated_at]
+      github&.updated_at
     end
 
     def has_github_issue?
-      !@github[:issue_number].nil?
+      !github&.issue_number.nil?
     end
 
-    def to_h
-      {
-        id: @id,
-        body: @body,
-        locality: @locality,
-        type: @type,
-        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
-
-    def to_yaml_h
-      hash = to_h
-      # Remove observations if it's nil or empty
-      hash.delete(:observations) if hash[:observations].nil? || hash[:observations] == ""
-      stringify_keys(hash)
-    end
-
-    def self.from_hash(hash)
-      new(hash)
+    def record_github_issue(issue_number:, issue_url:, status:, created_at: nil)
+      self.github = GithubInfo.new(issue_number: issue_number, issue_url: issue_url,
+                                   status: status, created_at: created_at)
     end
 
     private
 
-    def symbolize_keys(hash)
-      return hash unless hash.is_a?(Hash)
-
-      hash.each_with_object({}) do |(key, value), result|
-        new_key = key.to_sym
-        new_value = value.is_a?(Hash) ? symbolize_keys(value) : value
-        result[new_key] = new_value
-      end
-    end
-
-    def stringify_keys(hash)
-      return hash unless hash.is_a?(Hash)
-
-      hash.each_with_object({}) do |(key, value), result|
-        new_key = key.to_s
-        new_value = value.is_a?(Hash) ? stringify_keys(value) : value
-        result[new_key] = new_value
-      end
+    def format_locality
+      parts = []
+      parts << "Clause #{clause}" if clause && !clause.strip.empty?
+      parts << element if element && !element.strip.empty?
+      parts << "Line #{line_number}" if line_number && !line_number.strip.empty?
+      parts.join(", ")
     end
   end
 end

data/lib/commenter/comment_locality.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Commenter
+  # Location of a comment within the reviewed document.
+  class CommentLocality < Lutaml::Model::Serializable
+    attribute :line_number, :string
+    attribute :clause, :string
+    attribute :element, :string
+
+    yaml do
+      map "line_number", to: :line_number
+      map "clause", to: :clause
+      map "element", to: :element
+    end
+  end
+end

data/lib/commenter/comment_sheet.rb

@@ -1,81 +1,49 @@
 # frozen_string_literal: true
 
-require_relative "comment"
+require "lutaml/model"
 
 module Commenter
-  class CommentSheet
-    attr_accessor :version, :date, :document, :project, :stage, :comments, :title_en, :title_fr
-
-    def initialize(attributes = {})
-      # Normalize input to symbols
-      attrs = symbolize_keys(attributes)
-
-      @version = attrs[:version] || "2012-03"
-      @date = attrs[:date]
-      @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) }
+  # One ballot submission: metadata plus its comments. Serialization is
+  # declared with lutaml-model.
+  class CommentSheet < Lutaml::Model::Serializable
+    attribute :version, :string, default: -> { "2012-03" }
+    attribute :date, :string
+    attribute :document, :string
+    attribute :project, :string
+    attribute :stage, :string
+    attribute :title_en, :string
+    attribute :title_fr, :string
+    attribute :comments, Comment, collection: true
+
+    yaml do
+      map "version", to: :version
+      map "date", to: :date
+      map "document", to: :document
+      map "project", to: :project
+      map "stage", to: :stage
+      map "title_en", to: :title_en
+      map "title_fr", to: :title_fr
+      map "comments", to: :comments
     end
 
     def add_comment(comment)
-      @comments << (comment.is_a?(Comment) ? comment : Comment.from_hash(comment))
-    end
-
-    def to_h
-      {
-        version: @version,
-        date: @date,
-        document: @document,
-        project: @project,
-        stage: @stage,
-        title_en: @title_en,
-        title_fr: @title_fr,
-        comments: @comments.map(&:to_h)
-      }
+      self.comments = (comments || []) + [comment.is_a?(Comment) ? comment : Comment.from_hash(comment)]
     end
 
-    def 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)
+    def schema_name
+      version == "osd" ? "iso_comment_osd.yaml" : "iso_comment_2012-03.yaml"
     end
 
-    def self.from_hash(hash)
-      new(hash)
+    def to_yaml_document(schema_dir = "schema")
+      "# yaml-language-server: $schema=#{File.join(schema_dir.to_s, schema_name)}\n\n#{to_yaml}"
     end
 
-    private
-
-    def symbolize_keys(hash)
-      return hash unless hash.is_a?(Hash)
-
-      hash.each_with_object({}) do |(key, value), result|
-        new_key = key.to_sym
-        new_value = value.is_a?(Hash) ? symbolize_keys(value) : value
-        result[new_key] = new_value
-      end
+    def to_yaml_h
+      CommentSheet.to_hash(self)
     end
 
-    def stringify_keys(hash)
-      return hash unless hash.is_a?(Hash)
-
-      hash.each_with_object({}) do |(key, value), result|
-        new_key = key.to_s
-        new_value = case value
-                    when Hash
-                      stringify_keys(value)
-                    when Array
-                      value.map { |item| item.is_a?(Hash) ? stringify_keys(item) : item }
-                    else
-                      value
-                    end
-        result[new_key] = new_value
-      end
+    def to_h
+      CommentSheet.to_hash(self)
     end
   end
 end

data/lib/commenter/comment_type.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Commenter
+  # Single home for the comment type vocabulary: short codes (ge/te/ed) and
+  # their expanded names (general/technical/editorial). Unrecognized values
+  # pass through unchanged; display_name capitalizes recognized types.
+  module CommentType
+    FULL_NAMES = {
+      "ge" => "general",
+      "te" => "technical",
+      "ed" => "editorial"
+    }.freeze
+
+    CODES = FULL_NAMES.invert.freeze
+
+    DISPLAY_NAMES = FULL_NAMES.each_with_object({}) do |(code, full), display|
+      display[code] = full.capitalize
+      display[full] = full.capitalize
+    end.freeze
+
+    module_function
+
+    def code(type)
+      CODES.fetch(type.to_s.strip.downcase) { type&.to_s&.strip }
+    end
+
+    def full_name(type)
+      return nil if type.nil?
+
+      value = type.to_s.strip
+      downcased = value.downcase
+      FULL_NAMES[downcased] || (FULL_NAMES.values.include?(downcased) ? downcased : value)
+    end
+
+    def display_name(type)
+      DISPLAY_NAMES.fetch(type.to_s.strip.downcase) { type || "Unknown" }
+    end
+  end
+end

data/lib/commenter/disposition_status.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Commenter
+  # Canonical disposition vocabulary, shared by cell shading (Filler) and
+  # ballot statistics (BallotReport). Matches free-text observations and
+  # OSD's structured resolution_status values. One home for the question
+  # "what counts as an accepted disposition".
+  module DispositionStatus
+    PATTERNS = [
+      [:accept_with_modifications, /awm|accept(ed)?[ ,]*with +(modifications|changes)/].freeze,
+      [:rejected, /reject(ed)?|not accepted/].freeze,
+      [:accepted, /accept(ed)?/].freeze,
+      [:noted, /noted/].freeze,
+      [:todo, /todo/].freeze
+    ].freeze
+
+    module_function
+
+    # Returns the canonical status symbol for the given text, or nil when
+    # nothing matches. Order matters: "accept with modifications" and
+    # "not accepted" must be classified before the bare "accept" pattern.
+    def match(text)
+      value = text.to_s.downcase.strip
+      return nil if value.empty?
+
+      PATTERNS.each do |status, pattern|
+        return status if value.match?(pattern)
+      end
+
+      nil
+    end
+
+    def statuses
+      PATTERNS.map(&:first)
+    end
+  end
+end