metanorma-utils 1.11.8 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a99bb7fdd555d6d2fff452c36700104b7d80fab5ceefa37c271bd8f8a99b0d1
-  data.tar.gz: e35dd105b562b8fd16a2d8695f0bf9c84bee7a946c404a3ffadc34eebb51a4e7
+  metadata.gz: 3356c5d36c4605ce33d895949bb01b4bc59c823ef73fa6974844746578347087
+  data.tar.gz: 13f3f9e75e204cb1c152186e9c0feae34b02542dde612626535d598022a8cd50
 SHA512:
-  metadata.gz: b99789e9ff3abf5ab4f6d39db2a93f3b0c4edd8cd15667bcb9679328e17535c3c4a8246bb474fce4fbe1e61644573c42b0143803c8557dd5c4cbe0ecacb8a8b3
-  data.tar.gz: 794cefd11516d460c5f3cd2d73b13cec42c097b6e7cc28cb32fa10097c8b89c6257a7c290313f0311d63145dd15f4d28e32f5c2d1df869282d3687ae76db504c
+  metadata.gz: f90ebfb556dadc68dde7ed04ed93f44819e69a60fe0daab2775d9cb61726b12222cfe187456770f92399a250dd6d52b079a56f6ad6a2da0a253b72ca7a7a7c03
+  data.tar.gz: 25a38f448ca9883380623391f12f8ee6c83b1ed8f4556cab5f6eca39baea3fd79cbbdd8553cc42b265a2b64dbd2e1078a1e7c392a28f9f98a27479f0d0019b86

data/lib/utils/log.rb

@@ -1,19 +1,26 @@
 require "htmlentities"
+require_relative "log_html"
 
 module Metanorma
   module Utils
     class Log
       attr_writer :xml, :suppress_log
 
-      def initialize
+      # messages: hash of message IDs to {error, severity, category}
+      # severity: 0: abort; 1: serious; 2: not serious; 3: info only
+      def initialize(messages = {})
         @log = {}
         @c = HTMLEntities.new
         @mapid = {}
         @suppress_log = { severity: 4, category: [] }
+        @msg = messages.each_value do |v|
+          v[:error] = v[:error]
+            .encode("UTF-8", invalid: :replace, undef: :replace)
+        end
       end
 
-      def to_ncname(tag)
-        ::Metanorma::Utils.to_ncname(tag)
+      def add_msg(messages)
+        @msg.merge!(messages)
       end
 
       def save_to(filename, dir = nil)
@@ -24,21 +31,28 @@ module Metanorma
         @htmlfilename = "#{b}.html"
       end
 
-      # severity: 0: abort; 1: serious; 2: not serious; 3: info only
-      def add(category, loc, msg, severity: 2, display: true)
-        @novalid || suppress_log?(category, severity, msg) and return
-        @log[category] ||= []
-        item = create_entry(loc, msg, severity)
-        @log[category] << item
+      def add_prep(id)
+        id = id.to_sym
+        @msg[id] or raise "Logging: Error #{id} is not defined!"
+        @novalid || suppress_log?(id) and return nil
+        @log[@msg[id][:category]] ||= []
+        @msg[id]
+      end
+
+      def add(id, loc, display: true, params: [])
+        m = add_prep(id) or return
+        msg = create_entry(loc, m[:error],
+                           m[:severity], params)
+        @log[m[:category]] << msg
         loc = loc.nil? ? "" : "(#{current_location(loc)}): "
-        suppress_display?(category, loc, msg, display) or
-          warn "#{category}: #{loc}#{msg}"
+        suppress_display?(m[:category], loc, msg, display) or
+          warn "#{m[:category]}: #{loc}#{msg[:error]}"
       end
 
       def abort_messages
         @log.values.each_with_object([]) do |v, m|
           v.each do |e|
-            e[:severity].zero? and m << e[:message]
+            e[:severity].zero? and m << e[:error]
           end
         end
       end
@@ -51,9 +65,10 @@ module Metanorma
         end
       end
 
-      def suppress_log?(category, severity, msg)
-        category == "Relaton" && /^Fetching /.match?(msg) ||
-          @suppress_log[:severity] <= severity ||
+      def suppress_log?(id)
+        category =  @msg[id][:category]
+        category && /^Fetching /.match?(@msg[id][:error]) ||
+          @suppress_log[:severity] <= @msg[id][:severity] ||
           @suppress_log[:category].include?(category)
       end
 
@@ -62,18 +77,30 @@ module Metanorma
           !display
       end
 
-      def create_entry(loc, msg, severity)
-        msg = msg.encode("UTF-8", invalid: :replace, undef: :replace)
+      def create_entry(loc, msg, severity, params)
+        interpolated = interpolate_msg(msg, params)
         item = { location: current_location(loc), severity: severity,
-                 message: msg, context: context(loc), line: line(loc, msg) }
-        if item[:message].include?(" :: ")
-          a = item[:message].split(" :: ", 2)
+                 error: interpolated, context: context(loc),
+                 line: line(loc, msg) }
+        if item[:error].include?(" :: ")
+          a = item[:error].split(" :: ", 2)
           item[:context] = a[1]
-          item[:message] = a[0]
+          item[:error] = a[0]
         end
         item
       end
 
+      def interpolate_msg(msg, params)
+        # Count %s placeholders in the message
+        placeholder_count = msg.scan(/%s/).length
+        interpolation_params = if params.empty?
+                                 ::Array.new(placeholder_count, "")
+                               else
+                                 params
+                               end
+        placeholder_count.zero? ? msg : (msg % interpolation_params)
+      end
+
       def current_location(node)
         if node.nil? then ""
         elsif node.respond_to?(:id) && !node.id.nil? then "ID #{node.id}"
@@ -133,113 +160,6 @@ module Metanorma
         end
         ret.to_xml
       end
-
-      def log_hdr(file)
-        <<~HTML
-          <html><head><title>#{file} errors</title>
-          <meta charset="UTF-8"/>
-          <style> pre { white-space: pre-wrap; }
-          thead th { font-weight: bold; background-color: aqua; }
-          .severity0 { font-weight: bold; background-color: lightpink }
-          .severity1 { font-weight: bold; }
-          .severity2 { }
-          .severity3 { font-style: italic; color: grey; }
-          </style>
-          </head><body><h1>#{file} errors</h1>
-          <ul>#{log_index}</ul>
-        HTML
-      end
-
-      def log_index
-        @log.each_with_object([]) do |(k, v), m|
-          m << <<~HTML
-            <li><p><b><a href="##{to_ncname(k)}">#{k}</a></b>: #{index_severities(v)}</p></li>
-          HTML
-        end.join("\n")
-      end
-
-      def index_severities(entries)
-        s = entries.each_with_object({}) do |e, m|
-          m[e[:severity]] ||= 0
-          m[e[:severity]] += 1
-        end.compact
-        s.keys.sort.map do |k|
-          "Severity #{k}: <b>#{s[k]}</b> errors"
-        end.join("; ")
-      end
-
-      def write(file = nil)
-        (!file && @filename) or save_to(file || "metanorma", nil)
-        File.open(@filename, "w:UTF-8") do |f|
-          f.puts log_hdr(@filename)
-          @log.each_key { |key| write_key(f, key) }
-          f.puts "</body></html>\n"
-        end
-      end
-
-      def write_key(file, key)
-        file.puts <<~HTML
-          <h2 id="#{to_ncname(key)}">#{key}</h2>\n<table border="1">
-          <thead><th width="5%">Line</th><th width="20%">ID</th>
-          <th width="30%">Message</th><th width="40%">Context</th><th width="5%">Severity</th></thead>
-          <tbody>
-        HTML
-        @log[key].sort_by { |a| [a[:line], a[:location], a[:message]] }
-          .each do |n|
-          write_entry(file, render_preproc_entry(n))
-        end
-        file.puts "</tbody></table>\n"
-      end
-
-      def render_preproc_entry(entry)
-        ret = entry.dup
-        ret[:line] = nil if ret[:line] == "000000"
-        ret[:location] = loc_link(entry)
-        ret[:message] = break_up_long_str(entry[:message], 10, 2)
-          .gsub(/`([^`]+)`/, "<code>\\1</code>")
-        ret[:context] = context_render(entry)
-        ret.compact
-      end
-
-      def context_render(entry)
-        entry[:context] or return nil
-        entry[:context].split("\n").first(5)
-          .join("\n").gsub("><", "> <")
-      end
-
-      def mapid(old, new)
-        @mapid[old] = new
-      end
-
-      def loc_link(entry)
-        loc = entry[:location]
-        loc.nil? || loc.empty? and loc = "--"
-        loc, url = loc_to_url(loc)
-        loc &&= break_up_long_str(loc, 10, 2)
-        url and loc = "<a href='#{url}'>#{loc}</a>"
-        loc
-      end
-
-      def loc_to_url(loc)
-        /^ID /.match?(loc) or return [loc, nil]
-        loc.sub!(/^ID /, "")
-        loc = @mapid[loc] while @mapid[loc]
-        url = "#{@htmlfilename}##{to_ncname loc}"
-        [loc, url]
-      end
-
-      def break_up_long_str(str, threshold, punct)
-        Metanorma::Utils.break_up_long_str(str, threshold, punct)
-      end
-
-      def write_entry(file, entry)
-        entry[:context] &&= @c.encode(break_up_long_str(entry[:context], 40, 2))
-        file.print <<~HTML
-          <tr class="severity#{entry[:severity]}">
-          <td>#{entry[:line]}</td><th><code>#{entry[:location]}</code></th>
-          <td>#{entry[:message]}</td><td><pre>#{entry[:context]}</pre></td><td>#{entry[:severity]}</td></tr>
-        HTML
-      end
     end
   end
 end

data/lib/utils/log_html.rb

@@ -0,0 +1,163 @@
+module Metanorma
+  module Utils
+    class Log
+      def to_ncname(tag)
+        ::Metanorma::Utils.to_ncname(tag)
+      end
+
+      def log_hdr(file)
+        <<~HTML
+          <html><head><title>#{file} errors</title>
+          <meta charset="UTF-8"/>
+          <style> pre { white-space: pre-wrap; }
+          thead th { font-weight: bold; background-color: aqua; }
+          .severity0 { font-weight: bold; background-color: lightpink }
+          .severity1 { font-weight: bold; }
+          .severity2 { }
+          .severity3 { font-style: italic; color: grey; }
+          </style>
+          </head><body><h1>#{file} errors</h1>
+          <ul>#{log_index}</ul>
+        HTML
+      end
+
+      def log_index
+        @log.each_with_object([]) do |(k, v), m|
+          m << <<~HTML
+            <li><p><b><a href="##{to_ncname(k)}">#{k}</a></b>: #{index_severities(v)}</p></li>
+          HTML
+        end.join("\n")
+      end
+
+      def index_severities(entries)
+        s = entries.each_with_object({}) do |e, m|
+          m[e[:severity]] ||= 0
+          m[e[:severity]] += 1
+        end.compact
+        s.keys.sort.map do |k|
+          "Severity #{k}: <b>#{s[k]}</b> errors"
+        end.join("; ")
+      end
+
+      def write(file = nil)
+        (!file && @filename) or save_to(file || "metanorma", nil)
+        File.open(@filename, "w:UTF-8") do |f|
+          f.puts log_hdr(@filename)
+          @log.each_key { |key| write_key(f, key) }
+          f.puts "</body></html>\n"
+        end
+      end
+
+      def write_key(file, key)
+        file.puts <<~HTML
+          <h2 id="#{to_ncname(key)}">#{key}</h2>\n<table border="1">
+          <thead><th width="5%">Line</th><th width="20%">ID</th>
+          <th width="30%">Message</th><th width="40%">Context</th><th width="5%">Severity</th></thead>
+          <tbody>
+        HTML
+        @log[key].sort_by { |a| [a[:line], a[:location], a[:error]] }
+          .each do |n|
+          write_entry(file, render_preproc_entry(n))
+        end
+        file.puts "</tbody></table>\n"
+      end
+
+      def render_preproc_entry(entry)
+        ret = entry.dup
+        ret[:line] = nil if ret[:line] == "000000"
+        ret[:location] = loc_link(entry)
+        ret[:error] = break_up_long_str(entry[:error], 10, 2)
+          .gsub(/`([^`]+)`/, "<code>\\1</code>")
+        ret[:context] = context_render(entry)
+        ret.compact
+      end
+
+      def context_render(entry)
+        entry[:context] or return nil
+        entry[:context].split("\n").first(5)
+          .join("\n").gsub("><", "> <")
+      end
+
+      def mapid(old, new)
+        @mapid[old] = new
+      end
+
+      def loc_link(entry)
+        loc = entry[:location]
+        loc.nil? || loc.empty? and loc = "--"
+        loc, url = loc_to_url(loc)
+        loc &&= break_up_long_str(loc, 10, 2)
+        url and loc = "<a href='#{url}'>#{loc}</a>"
+        loc
+      end
+
+      def loc_to_url(loc)
+        /^ID /.match?(loc) or return [loc, nil]
+        loc.sub!(/^ID /, "")
+        loc = @mapid[loc] while @mapid[loc]
+        url = "#{@htmlfilename}##{to_ncname loc}"
+        [loc, url]
+      end
+
+      def break_up_long_str(str, threshold, punct)
+        Metanorma::Utils.break_up_long_str(str, threshold, punct)
+      end
+
+      def write_entry(file, entry)
+        entry[:context] &&= @c.encode(break_up_long_str(entry[:context], 40, 2))
+        file.print <<~HTML
+          <tr class="severity#{entry[:severity]}">
+          <td>#{entry[:line]}</td><th><code>#{entry[:location]}</code></th>
+          <td>#{entry[:error]}</td><td><pre>#{entry[:context]}</pre></td><td>#{entry[:severity]}</td></tr>
+        HTML
+      end
+
+      def display_messages
+        grouped = group_messages_by_category
+        grouped.map { |cat, keys| format_category_section(cat, keys) }
+          .join("\n")
+      end
+
+      def group_messages_by_category
+        sort_messages_by_category_and_key
+          .group_by { |k| @msg[k][:category] }
+          .sort_by { |cat, _| cat }
+      end
+
+      def format_category_section(category, keys)
+        lines = keys.map { |k| format_error_line(k) }
+        "#{category}:\n#{lines.join("\n")}"
+      end
+
+      def format_error_line(key)
+        padded_key = key.to_s.ljust(12)
+        "\t#{padded_key}: #{@msg[key][:error]}"
+      end
+
+      def sort_messages_by_category_and_key
+        @msg.keys.sort do |a, b|
+          cat_cmp = @msg[a][:category] <=> @msg[b][:category]
+          a_parts = parse_message_key(a)
+          b_parts = parse_message_key(b)
+          cat_cmp.zero? ? compare_key_parts(a_parts, b_parts) : cat_cmp
+        end
+      end
+
+      def parse_message_key(key)
+        match = key.to_s.match(/^(.+?)_(\d+)$/)
+        match ? [match[1], match[2].to_i] : [key.to_s, nil]
+      end
+
+      def compare_key_parts(a_parts, b_parts)
+        a_str, a_num = a_parts
+        b_str, b_num = b_parts
+        if a_num.nil? || b_num.nil?
+          a_str <=> b_str
+        else
+          str_cmp = a_str <=> b_str
+          str_cmp.zero? ? a_num <=> b_num : str_cmp
+        end
+      end
+    end
+  end
+end

data/lib/utils/version.rb

@@ -1,5 +1,5 @@
 module Metanorma
   module Utils
-    VERSION = "1.11.8".freeze
+    VERSION = "2.0.0".freeze
   end
 end

data/metanorma-utils.gemspec

@@ -46,6 +46,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "simplecov", "~> 0.15"
   spec.add_development_dependency "timecop", "~> 0.9"
   spec.add_development_dependency "webmock"
-  spec.add_development_dependency "canon"
+  spec.add_development_dependency "canon", "= 0.1.3"
   # spec.metadata["rubygems_mfa_required"] = "true"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-utils
 version: !ruby/object:Gem::Version
-  version: 1.11.8
+  version: 2.0.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-09-29 00:00:00.000000000 Z
+date: 2025-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -280,16 +280,16 @@ dependencies:
   name: canon
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.3
 description: 'metanorma-utils provides utilities for the Metanorma stack
 
   '
@@ -313,6 +313,7 @@ files:
 - lib/utils/image.rb
 - lib/utils/linestatus.rb
 - lib/utils/log.rb
+- lib/utils/log_html.rb
 - lib/utils/main.rb
 - lib/utils/namespace.rb
 - lib/utils/version.rb