metanorma-utils 1.11.8 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a99bb7fdd555d6d2fff452c36700104b7d80fab5ceefa37c271bd8f8a99b0d1
-  data.tar.gz: e35dd105b562b8fd16a2d8695f0bf9c84bee7a946c404a3ffadc34eebb51a4e7
+  metadata.gz: a291c816aab2db45409cc9c255e5dc4214cac348b2161941226f6dcea35068f0
+  data.tar.gz: c9d66f40e1f454cb59dca034a5db883f28b7fe625d9a83a29b7d0142721234da
 SHA512:
-  metadata.gz: b99789e9ff3abf5ab4f6d39db2a93f3b0c4edd8cd15667bcb9679328e17535c3c4a8246bb474fce4fbe1e61644573c42b0143803c8557dd5c4cbe0ecacb8a8b3
-  data.tar.gz: 794cefd11516d460c5f3cd2d73b13cec42c097b6e7cc28cb32fa10097c8b89c6257a7c290313f0311d63145dd15f4d28e32f5c2d1df869282d3687ae76db504c
+  metadata.gz: 7a84e5fd6d93b9ed55259e1702214bf00183fa739f057533efb456e0350c54fb1b7f7c0166e11687f610adf8be5e344d5117ea187c876b29e762d17a283b3e51
+  data.tar.gz: 73a7acbae9dfa698a47e93e7d5dc3b0175df6c6430458160a3a8b5c6fc75a5d4f11c553200235e3d4321959b0d18b85d075e0d87a3ed8cf802f0f73e8f562a84

data/lib/metanorma-utils.rb

@@ -6,3 +6,4 @@ require_relative "utils/linestatus"
 require_relative "utils/log"
 require_relative "utils/xml"
 require_relative "utils/anchor"
+require_relative "utils/anchor_ranges"

data/lib/utils/anchor_ranges.rb

@@ -0,0 +1,148 @@
+module Metanorma
+  module Utils
+    # AnchorRanges provides efficient range checking for nodes based on
+    # anchor positions in a document. It determines whether an arbitrary node
+    # falls within the range # defined by two anchor points (A-B), where
+    # the range includes node A through all descendants of node B.
+    class AnchorRanges
+      attr_reader :anchor_map
+
+      # Initialize with a Nokogiri document
+      # @param doc [Nokogiri::XML::Document] The document to process
+      def initialize(doc)
+        @anchor_map = build_anchor_id_map(doc)
+        @anchor_to_ord = nil
+        @anchor_to_last_ord = nil
+        @id_to_ord = nil
+      end
+
+      # Get mapping of anchor to ord
+      # @return [Hash] anchor => ord
+      def anchor_to_ord
+        @anchor_to_ord ||= build_anchor_to_ord
+      end
+
+      # Get mapping of anchor to last descendant ord
+      # @return [Hash] anchor => last_ord
+      def anchor_to_last_ord
+        @anchor_to_last_ord ||= build_anchor_to_last_ord
+      end
+
+      # Get mapping of id to ord
+      # @return [Hash] id => ord
+      def id_to_ord
+        @id_to_ord ||= build_id_to_ord
+      end
+
+      # Check if a node (by id or anchor) is within the range A-B
+      # @param node_id_or_anchor [String] The id or anchor of the node to check
+      # @param anchor_a [String] The anchor defining the start of the range
+      # @param anchor_b [String] The anchor defining the end of the range
+      # @return [Boolean] true if the node is within the range A-B
+      def in_range?(node_id_or_anchor, anchor_a, anchor_b)
+        node_ord = find_node_ord(node_id_or_anchor)
+        return false if node_ord.nil?
+
+        start_ord = anchor_to_ord[anchor_a]
+        end_ord = anchor_to_last_ord[anchor_b]
+
+        return false if start_ord.nil? || end_ord.nil?
+
+        node_ord >= start_ord && node_ord <= end_ord
+      end
+
+      # Get the ordinal range for an anchor (start to last descendant)
+      # @param anchor [String] The anchor to get the range for
+      # @return [Range, nil] The range of ordinals, or nil if anchor not found
+      def anchor_range(anchor)
+        start_ord = anchor_to_ord[anchor]
+        end_ord = anchor_to_last_ord[anchor]
+        return nil if start_ord.nil? || end_ord.nil?
+
+        (start_ord..end_ord)
+      end
+
+      private
+
+      # Generate a map of all nodes with anchor or id attributes,
+      # recording their linear order and the next non-descendant anchor
+      # @return [Array<Hash>] Array of hashes with keys: :anchor, :id, :ord, :next_anchor
+      def build_anchor_id_map(doc)
+        nodes = doc.xpath("//*[@id or @anchor]")
+        nodes.each_with_index.map do |node, i|
+          {
+            anchor: node["anchor"],
+            id: node["id"],
+            ord: i,
+            next_anchor: find_next_non_descendant_anchor(nodes, i),
+          }
+        end
+      end
+
+      # Find the anchor attribute of the next node that is not a descendant
+      # of the node at the given index
+      #
+      # @param nodes [Nokogiri::XML::NodeSet] All nodes with anchor or id
+      # @param current_index [Integer] Index of the current node
+      # @return [String, nil] The anchor attribute of the next non-descendant node
+      def find_next_non_descendant_anchor(nodes, current_index)
+        current_node = nodes[current_index]
+        current_path = current_node.path
+
+        # Look through subsequent nodes
+        ((current_index + 1)...nodes.length).each do |i|
+          next_node = nodes[i]
+          next_path = next_node.path
+
+          # Check if next_node is a descendant of current_node
+          # A node is a descendant if its path starts with the current path
+          # followed by a path separator
+          unless next_path.start_with?("#{current_path}/")
+            return next_node["anchor"]
+          end
+        end
+
+        nil # No non-descendant node found
+      end
+
+      def build_anchor_to_ord
+        hash = {}
+        @anchor_map.each do |entry|
+          hash[entry[:anchor]] = entry[:ord] if entry[:anchor]
+        end
+        hash
+      end
+
+      def build_id_to_ord
+        hash = {}
+        @anchor_map.each do |entry|
+          hash[entry[:id]] = entry[:ord] if entry[:id]
+        end
+        hash
+      end
+
+      def build_anchor_to_last_ord
+        hash = {}
+        @anchor_map.each do |entry|
+          next unless entry[:anchor]
+
+          # The last descendant is the ord right before the next_anchor
+          # If there's no next_anchor, it's the last node in the map
+          if entry[:next_anchor]
+            next_ord = anchor_to_ord[entry[:next_anchor]]
+            hash[entry[:anchor]] = next_ord - 1 if next_ord
+          else
+            # No next anchor means this extends to the end of the document
+            hash[entry[:anchor]] = @anchor_map.last[:ord]
+          end
+        end
+        hash
+      end
+
+      def find_node_ord(node_id_or_anchor)
+        # Try as anchor first, then as id
+        anchor_to_ord[node_id_or_anchor] || id_to_ord[node_id_or_anchor]
+      end
+    end
+  end
+end

data/lib/utils/log.rb

@@ -1,19 +1,33 @@
 require "htmlentities"
+require_relative "log_html"
 
 module Metanorma
   module Utils
     class Log
-      attr_writer :xml, :suppress_log
+      attr_accessor :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: [] }
+        @suppress_log = { severity: 4, category: [], error_ids: [],
+                          locations: [] }
+        @msg = messages.each_value do |v|
+          v[:error] = v[:error]
+            .encode("UTF-8", invalid: :replace, undef: :replace)
+        end
+      end
+
+      def add_msg(messages)
+        @msg.merge!(messages)
       end
 
-      def to_ncname(tag)
-        ::Metanorma::Utils.to_ncname(tag)
+      # pass Nokogiri XML in, to record where all the anchors and ids
+      # are in the target document
+      def add_error_ranges(xml)
+        @anchor_ranges = AnchorRanges.new(xml)
       end
 
       def save_to(filename, dir = nil)
@@ -24,21 +38,27 @@ 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], id, 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,10 +71,12 @@ module Metanorma
         end
       end
 
-      def suppress_log?(category, severity, msg)
-        category == "Relaton" && /^Fetching /.match?(msg) ||
-          @suppress_log[:severity] <= severity ||
-          @suppress_log[:category].include?(category)
+      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) ||
+          @suppress_log[:error_ids].include?(id.to_s)
       end
 
       def suppress_display?(category, _loc, _msg, display)
@@ -62,48 +84,72 @@ module Metanorma
           !display
       end
 
-      def create_entry(loc, msg, severity)
-        msg = msg.encode("UTF-8", invalid: :replace, undef: :replace)
-        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)
+      def create_entry(loc, msg, severity, error_id, params)
+        loc_str, anchor, node_id = current_location(loc)
+        item = { error_id: error_id, location: loc_str, severity: severity,
+                 error: interpolate_msg(msg, params), context: context(loc),
+                 line: line(loc, msg), anchor: anchor, id: node_id }
+        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}"
-        elsif node.respond_to?(:id) && node.id.nil? && node.respond_to?(:parent)
-          while !node.nil? && node.id.nil?
-            node = node.parent
-          end
-          node.nil? ? "" : "ID #{node.id}"
-        elsif node.respond_to?(:to_xml) && node.respond_to?(:parent)
-          while !node.nil? && node["id"].nil? && node.respond_to?(:parent)
-            node = node.parent
-          end
-          node.respond_to?(:parent) ? "ID #{node['anchor'] || node['id']}" : ""
-        elsif node.is_a? String then node
-        elsif node.respond_to?(:lineno) && !node.lineno.nil? &&
-            !node.lineno.empty?
-          "Asciidoctor Line #{'%06d' % node.lineno}"
-        elsif node.respond_to?(:line) && !node.line.nil?
-          "XML Line #{'%06d' % node.line}"
-        elsif node.respond_to?(:parent)
-          while !node.nil? &&
-              (!node.respond_to?(:level) || node.level.positive?) &&
-              (!node.respond_to?(:context) || node.context != :section)
-            node = node.parent
-            return "Section: #{node.title}" if node.respond_to?(:context) &&
-              node&.context == :section
-          end
-          "??"
-        else "??"
+        anchor = nil
+        id = nil
+        ret = if node.nil? then ""
+              elsif node.respond_to?(:id) && !node.id.nil? then "ID #{node.id}"
+              elsif node.respond_to?(:id) && node.id.nil? &&
+                  node.respond_to?(:parent)
+                while !node.nil? && node.id.nil?
+                  node = node.parent
+                end
+                node.nil? ? "" : "ID #{node.id}"
+              elsif node.respond_to?(:to_xml) && node.respond_to?(:parent)
+                loc, anchor, id = xml_current_location(node)
+                loc
+              elsif node.is_a? String then node
+              elsif node.respond_to?(:lineno) && !node.lineno.nil? &&
+                  !node.lineno.empty?
+                "Asciidoctor Line #{'%06d' % node.lineno}"
+              elsif node.respond_to?(:line) && !node.line.nil?
+                "XML Line #{'%06d' % node.line}"
+              elsif node.respond_to?(:parent)
+                while !node.nil? &&
+                    (!node.respond_to?(:level) || node.level.positive?) &&
+                    (!node.respond_to?(:context) || node.context != :section)
+                  node = node.parent
+                  node.respond_to?(:context) && node&.context == :section and
+                    return "Section: #{node.title}"
+                end
+                "??"
+              else "??"
+              end
+        [ret, anchor, id]
+      end
+
+      def xml_current_location(node)
+        while !node.nil? && node["id"].nil? && node.respond_to?(:parent)
+          node = node.parent
         end
+        anchor = node["anchor"]
+        id = node["id"]
+        loc = node.respond_to?(:parent) ? "ID #{anchor || id}" : ""
+        [loc, anchor, id]
       end
 
       def line(node, msg)
@@ -134,111 +180,38 @@ module Metanorma
         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
+      def filter_locations?
+        @suppress_log[:locations] && !@suppress_log[:locations].empty? or return
+        @anchor_ranges or return
+        true
       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))
+      def filter_locations
+        filter_locations? or return
+        @log.transform_values! do |entries|
+          entries.reject do |entry|
+            # Use anchor if present, otherwise use id
+            entry_in_suppress_range?(entry, entry[:anchor] || entry[:id])
+          end
         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]
+      def entry_in_suppress_range_prep(entry)
+        entry[:to] ||= entry[:from]
+        entry[:error_ids] ||= []
+        entry
       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
+      def entry_in_suppress_range?(entry, id)
+        # Use anchor if present, otherwise use id
+        id.nil? and return false
+        @suppress_log[:locations].each do |loc|
+          entry_in_suppress_range_prep(loc)
+          @anchor_ranges.in_range?(id, loc[:from], loc[:to]) or next
+          loc[:error_ids].empty? || loc[:error_ids]
+            .include?(entry[:error_id].to_s) and return true
+        end
+        false
       end
     end
   end

data/lib/utils/log_html.rb

@@ -0,0 +1,165 @@
+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|
+          error = s[k] == 1 ? "error" : "errors"
+          "Severity #{k}: <b>#{s[k]}</b> #{error}"
+        end.join("; ")
+      end
+
+      def write(file = nil)
+        (!file && @filename) or save_to(file || "metanorma", nil)
+        filter_locations
+        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="10%">Error</th>
+          <th width="20%">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_id]}</td>
+          <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\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].gsub("\n", ' ')}"
+      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.1".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.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-09-29 00:00:00.000000000 Z
+date: 2025-11-17 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
 
   '
@@ -308,11 +308,13 @@ files:
 - lib/metanorma-utils.rb
 - lib/sterile/sterile.rb
 - lib/utils/anchor.rb
+- lib/utils/anchor_ranges.rb
 - lib/utils/cjk.rb
 - lib/utils/hash_transform_keys.rb
 - 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