metanorma-utils 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3356c5d36c4605ce33d895949bb01b4bc59c823ef73fa6974844746578347087
-  data.tar.gz: 13f3f9e75e204cb1c152186e9c0feae34b02542dde612626535d598022a8cd50
+  metadata.gz: a291c816aab2db45409cc9c255e5dc4214cac348b2161941226f6dcea35068f0
+  data.tar.gz: c9d66f40e1f454cb59dca034a5db883f28b7fe625d9a83a29b7d0142721234da
 SHA512:
-  metadata.gz: f90ebfb556dadc68dde7ed04ed93f44819e69a60fe0daab2775d9cb61726b12222cfe187456770f92399a250dd6d52b079a56f6ad6a2da0a253b72ca7a7a7c03
-  data.tar.gz: 25a38f448ca9883380623391f12f8ee6c83b1ed8f4556cab5f6eca39baea3fd79cbbdd8553cc42b265a2b64dbd2e1078a1e7c392a28f9f98a27479f0d0019b86
+  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

@@ -4,7 +4,7 @@ require_relative "log_html"
 module Metanorma
   module Utils
     class Log
-      attr_writer :xml, :suppress_log
+      attr_accessor :suppress_log
 
       # messages: hash of message IDs to {error, severity, category}
       # severity: 0: abort; 1: serious; 2: not serious; 3: info only
@@ -12,7 +12,8 @@ module Metanorma
         @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)
@@ -23,6 +24,12 @@ module Metanorma
         @msg.merge!(messages)
       end
 
+      # 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)
         dir ||= File.dirname(filename)
         new_fn = filename.sub(/\.err\.html$/, ".html")
@@ -41,8 +48,7 @@ module Metanorma
 
       def add(id, loc, display: true, params: [])
         m = add_prep(id) or return
-        msg = create_entry(loc, m[:error],
-                           m[:severity], params)
+        msg = create_entry(loc, m[:error], m[:severity], id, params)
         @log[m[:category]] << msg
         loc = loc.nil? ? "" : "(#{current_location(loc)}): "
         suppress_display?(m[:category], loc, msg, display) or
@@ -69,7 +75,8 @@ module Metanorma
         category =  @msg[id][:category]
         category && /^Fetching /.match?(@msg[id][:error]) ||
           @suppress_log[:severity] <= @msg[id][:severity] ||
-          @suppress_log[:category].include?(category)
+          @suppress_log[:category].include?(category) ||
+          @suppress_log[:error_ids].include?(id.to_s)
       end
 
       def suppress_display?(category, _loc, _msg, display)
@@ -77,11 +84,11 @@ module Metanorma
           !display
       end
 
-      def create_entry(loc, msg, severity, params)
-        interpolated = interpolate_msg(msg, params)
-        item = { location: current_location(loc), severity: severity,
-                 error: interpolated, context: context(loc),
-                 line: line(loc, msg) }
+      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]
@@ -102,35 +109,47 @@ module Metanorma
       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)
@@ -160,6 +179,40 @@ module Metanorma
         end
         ret.to_xml
       end
+
+      def filter_locations?
+        @suppress_log[:locations] && !@suppress_log[:locations].empty? or return
+        @anchor_ranges or return
+        true
+      end
+
+      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
+      end
+
+      def entry_in_suppress_range_prep(entry)
+        entry[:to] ||= entry[:from]
+        entry[:error_ids] ||= []
+        entry
+      end
+
+      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
 end

data/lib/utils/log_html.rb

@@ -35,12 +35,14 @@ module Metanorma
           m[e[:severity]] += 1
         end.compact
         s.keys.sort.map do |k|
-          "Severity #{k}: <b>#{s[k]}</b> errors"
+          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) }
@@ -51,8 +53,8 @@ module Metanorma
       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>
+          <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]] }
@@ -107,7 +109,7 @@ module Metanorma
         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[: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
@@ -115,7 +117,7 @@ module Metanorma
       def display_messages
         grouped = group_messages_by_category
         grouped.map { |cat, keys| format_category_section(cat, keys) }
-          .join("\n")
+          .join("\n\n")
       end
 
       def group_messages_by_category
@@ -131,7 +133,7 @@ module Metanorma
 
       def format_error_line(key)
         padded_key = key.to_s.ljust(12)
-        "\t#{padded_key}: #{@msg[key][:error]}"
+        "\t#{padded_key}: #{@msg[key][:error].gsub("\n", ' ')}"
       end
 
       def sort_messages_by_category_and_key

data/lib/utils/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-utils
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-03 00:00:00.000000000 Z
+date: 2025-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -308,6 +308,7 @@ 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