RubyGems - metanorma-utils - Versions diffs - 1.5.5 → 1.6.0 - Mend

metanorma-utils 1.5.5 → 1.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50f2a20d06ec82c5937a8d16a79b62b854785c9bfd3722bba88cf40025297658
-  data.tar.gz: d86977e61ba4c279304676b6108b62f238aad069dde209061bc7699fb8481c74
+  metadata.gz: 3234e3bc74a4ba02f150016c23db7e9b3d03386ae9f78ac42e3a64d78e31556e
+  data.tar.gz: 5ac7ae07a58d238b199f7e4cb9b79175e6ea0e99dfa5185358fffb579906de0f
 SHA512:
-  metadata.gz: 703b2fc422a54647b6a88807df7f7e6a6da30e78a1579cc7682e4e0a9dee19ec0a6886f78520002865ffad4151749543c96ceca7ee74d72f6b6988c087a3ae81
-  data.tar.gz: 7f74c2033f7e5cf5fff92c58540402db7d745ee111206da68f0b69e9c29beaf88f8b7c7a90e8ce9c10f2b77791865d8ba9909b8dd1447b7b5e7f1aa07f1b251d
+  metadata.gz: fc1e64c876f4d3bafd6996bd10421c810370ca3b512f702a1a09079a49d242773c90206f68a8f1187a574f13a7fbd9c7b4ec6dd122be18b9e7d6568785483066
+  data.tar.gz: dde8f1ea187e9cf6e9d80972c3b785c499a2c55fd6c8e9f3550e666a6b0e69ae711ba27c3e604d0c5e9f0fbe085a28ee45c240e5f969995497a5fd5b81c4aa59

data/lib/utils/log.rb CHANGED Viewed

@@ -1,30 +1,57 @@
+require "htmlentities"
 module Metanorma
   module Utils
     class Log
+      attr_writer :xml
       def initialize
         @log = {}
+        @c = HTMLEntities.new
+        @mapid = {}
       end
       def add(category, loc, msg)
-        return if @novalid
-        @log[category] = [] unless @log[category]
-        @log[category] << { location: current_location(loc), message: msg,
-                            context: context(loc) }
+        @novalid and return
+        @log[category] ||= []
+        item = create_entry(loc, msg)
+        @log[category] << item
         loc = loc.nil? ? "" : "(#{current_location(loc)}): "
         warn "#{category}: #{loc}#{msg}"
       end
+      def create_entry(loc, msg)
+        msg = msg.encode("UTF-8", invalid: :replace, undef: :replace)
+        item = { location: current_location(loc),
+                 message: msg, context: context(loc), line: line(loc, msg) }
+        if item[:message].include?(" :: ")
+          a = item[:message].split(" :: ", 2)
+          item[:context] = a[1]
+          item[:message] = a[0]
+        end
+        item
+      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['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?(:id) && !node.id.nil? then "ID #{node.id}"
-        else
+        elsif node.respond_to?(:parent)
           while !node.nil? &&
               (!node.respond_to?(:level) || node.level.positive?) &&
               (!node.respond_to?(:context) || node.context != :section)
@@ -33,6 +60,17 @@ module Metanorma
               node&.context == :section
           end
           "??"
+        else "??"
+        end
+      end
+      def line(node, msg)
+        if node.respond_to?(:line) && !node.line.nil?
+          "#{'%06d' % node.line}"
+        elsif /^XML Line /.match?(msg)
+          msg.sub(/^XML Line /, "").sub(/:.*$/, "")
+        else
+          "000000"
         end
       end
@@ -54,25 +92,73 @@ module Metanorma
         ret.to_xml
       end
+      def log_hdr(file)
+        <<~HTML
+          <html><head><title>#{file} errors</title>
+          <style> pre { white-space: pre-wrap; } </style>
+          </head><body><h1>#{file} errors</h1>
+        HTML
+      end
       def write(file)
+        @filename = file.sub(".err.html", ".html")
         File.open(file, "w:UTF-8") do |f|
-          f.puts "#{file} errors"
-          @log.each_key do |key|
-            f.puts "\n\n== #{key}\n\n"
-            @log[key].sort_by { |a| a[:location] }.each do |n|
-              write1(f, n)
-            end
-          end
+          f.puts log_hdr(file)
+          @log.each_key { |key| write_key(f, key) }
+          f.puts "</body></html>\n"
         end
       end
+      def write_key(file, key)
+        file.puts <<~HTML
+          <h2>#{key}</h2>\n<table border="1">
+          <thead><th width="5%">Line</th><th width="20%">ID</th><th width="30%">Message</th><th width="45%">Context</th></thead>
+          <tbody>
+        HTML
+        @log[key].sort_by { |a| [a[:line], a[:location], a[:message]] }
+          .each do |n|
+          write1(file, n)
+        end
+        file.puts "</tbody></table>\n"
+      end
       def write1(file, entry)
-        loc = entry[:location] ? "(#{entry[:location]}): " : ""
-        file.puts "#{loc}#{entry[:message]}"
-          .encode("UTF-8", invalid: :replace, undef: :replace)
-        entry[:context]&.split(/\n/)&.first(5)&.each do |l|
-          file.puts "\t#{l}"
+        line = entry[:line]
+        line = nil if line == "000000"
+        loc = loc_link(entry)
+        msg = break_up_long_str(entry[:message], 10, 2)
+          .gsub(/`([^`]+)`/, "<code>\\1</code>")
+        entry[:context] and context = entry[:context].split("\n").first(5)
+          .join("\n").gsub("><", "> <")
+        write_entry(file, line, loc, msg, context)
+      end
+      def mapid(old, new)
+        @mapid[old] = new
+      end
+      def loc_link(entry)
+        loc = entry[:location]
+        loc.nil? || loc.empty? and loc = "--"
+        if /^ID /.match?(loc)
+          loc.sub!(/^ID /, "")
+          loc = @mapid[loc] while @mapid[loc]
+          url = "#{@filename}##{loc}"
         end
+        loc &&= break_up_long_str(loc, 10, 2)
+        url and loc = "<a href='#{url}'>#{loc}</a>"
+        loc
+      end
+      def break_up_long_str(str, threshold, punct)
+        Metanorma::Utils.break_up_long_str(str, threshold, punct)
+      end
+      def write_entry(file, line, loc, msg, context)
+        context &&= @c.encode(break_up_long_str(context, 40, 2))
+        file.print <<~HTML
+          <tr><td>#{line}</td><th><code>#{loc}</code></th><td>#{msg}</td><td><pre>#{context}</pre></td></tr>
+        HTML
       end
     end
   end

data/lib/utils/main.rb CHANGED Viewed

@@ -8,12 +8,6 @@ require "csv"
 module Metanorma
   module Utils
     class << self
-      def attr_code(attributes)
-        attributes.compact.transform_values do |v|
-          v.is_a?(String) ? HTMLEntities.new.decode(v) : v
-        end
-      end
       # , " => ," : CSV definition does not deal with space followed by quote
       # at start of field
       def csv_split(text, delim = ";")
@@ -23,15 +17,6 @@ module Metanorma
                        col_sep: delim)&.compact&.map(&:strip)
       end
-      # if the contents of node are blocks, output them to out;
-      # else, wrap them in <p>
-      def wrap_in_para(node, out)
-        if node.blocks? then out << node.content
-        else
-          out.p { |p| p << node.content }
-        end
-      end
       def asciidoc_sub(text, flavour = :standoc)
         return nil if text.nil?
         return "" if text.empty?
@@ -141,29 +126,60 @@ module Metanorma
         %w(Arab Aran Hebr).include? script
       end
-      # convert definition list term/value pair into Nokogiri XML attribute
-      def dl_to_attrs(elem, dlist, name)
-        e = dlist.at("./dt[text()='#{name}']") or return
-        val = e.at("./following::dd/p") || e.at("./following::dd") or return
-        elem[name] = val.text
-      end
-      # convert definition list term/value pairs into Nokogiri XML elements
-      def dl_to_elems(ins, elem, dlist, name)
-        a = elem.at("./#{name}[last()]")
-        ins = a if a
-        dlist.xpath("./dt[text()='#{name}']").each do |e|
-          ins = dl_to_elems1(e, name, ins)
+      LONGSTR_THRESHOLD = 10
+      LONGSTR_NOPUNCT = 2
+      # break on punct every LONGSTRING_THRESHOLD chars, with zero width space
+      # if punct fails, try break on camel case, with soft hyphen
+      # break regardless every LONGSTRING_THRESHOLD * LONGSTR_NOPUNCT,
+      # with soft hyphen
+      def break_up_long_str(text, threshold = LONGSTR_THRESHOLD, nopunct = LONGSTR_NOPUNCT)
+        /^\s*$/.match?(text) and return text
+        text.split(/(?=\s)/).map do |w|
+          if /^\s*$/.match(text) || (w.size < LONGSTR_THRESHOLD) then w
+          else
+            w.scan(/.{,#{LONGSTR_THRESHOLD}}/o).map.with_index do |w1, i|
+              w1.size < LONGSTR_THRESHOLD ? w1 : break_up_long_str1(w1, i + 1)
+            end.join
+          end
+        end.join
+      end
+      STR_BREAKUP_RE = %r{
+       (?<=[=_—–\u2009→?+;]) | # break after any of these
+       (?<=[,.:])(?!\d) | # break on punct only if not preceding digit
+       (?<=[>])(?![>]) | # > not >->
+       (?<=[\]])(?![\]]) | # ] not ]-]
+       (?<=//) | # //
+       (?<=[/])(?![/]) | # / not /-/
+       (?<![<])(?=[<]) | # < not <-<
+       (?<=\p{L})(?=[(\{\[]\p{L}) # letter and bracket, followed by letter
+      }x.freeze
+      CAMEL_CASE_RE = %r{
+        (?<=\p{Ll}\p{Ll})(?=\p{Lu}\p{Ll}\p{Ll}) # 2 lowerc / upperc, 2 lowerc
+      }x.freeze
+      def break_up_long_str1(text, iteration)
+        s, separator = break_up_long_str2(text)
+        if s.size == 1 # could not break up
+          (iteration % LONGSTR_NOPUNCT).zero? and
+            text += "\u00ad" # force soft hyphen
+          text
+        else
+          s[-1] = "#{separator}#{s[-1]}"
+          s.join
         end
-        ins
       end
-      def dl_to_elems1(term, name, ins)
-        v = term.at("./following::dd")
-        e = v.elements and e.size == 1 && e.first.name == "p" and v = e.first
-        v.name = name
-        ins.next = v
-        ins.next
+      def break_up_long_str2(text)
+        s = text.split(STR_BREAKUP_RE, -1)
+        separator = "\u200b"
+        if s.size == 1
+          s = text.split(CAMEL_CASE_RE)
+          separator = "\u00ad"
+        end
+        [s, separator]
       end
     end
   end

data/lib/utils/version.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 module Metanorma
   module Utils
-    VERSION = "1.5.5".freeze
+    VERSION = "1.6.0".freeze
   end
 end

data/lib/utils/xml.rb CHANGED Viewed

@@ -21,8 +21,15 @@ module Metanorma
     HERE
     class << self
+      def attr_code(attributes)
+        attributes.compact.transform_values do |v|
+          v.is_a?(String) ? HTMLEntities.new.decode(v) : v
+        end
+      end
       def to_ncname(tag, asciionly: true)
-        asciionly and tag = HTMLEntities.new.encode(tag, :basic, :hexadecimal)
+        asciionly and tag = HTMLEntities.new.encode(tag, :basic,
+                                                    :hexadecimal)
         start = tag[0]
         ret1 = if %r([#{NAMECHAR}#])o.match?(start)
                  "_"
@@ -88,12 +95,46 @@ module Metanorma
         end.join
       end
+      # if the contents of node are blocks, output them to out;
+      # else, wrap them in <p>
+      def wrap_in_para(node, out)
+        if node.blocks? then out << node.content
+        else
+          out.p { |p| p << node.content }
+        end
+      end
       # all element/attribute pairs that are ID anchors in Metanorma
       def anchor_attributes
         [%w[* id], %w[* bibitemid], %w[review from],
          %w[review to], %w[index to], %w[xref target],
          %w[callout target], %w[location target]]
       end
+      # convert definition list term/value pair into Nokogiri XML attribute
+      def dl_to_attrs(elem, dlist, name)
+        e = dlist.at("./dt[text()='#{name}']") or return
+        val = e.at("./following::dd/p") || e.at("./following::dd") or return
+        elem[name] = val.text
+      end
+      # convert definition list term/value pairs into Nokogiri XML elements
+      def dl_to_elems(ins, elem, dlist, name)
+        a = elem.at("./#{name}[last()]")
+        ins = a if a
+        dlist.xpath("./dt[text()='#{name}']").each do |e|
+          ins = dl_to_elems1(e, name, ins)
+        end
+        ins
+      end
+      def dl_to_elems1(term, name, ins)
+        v = term.at("./following::dd")
+        e = v.elements and e.size == 1 && e.first.name == "p" and v = e.first
+        v.name = name
+        ins.next = v
+        ins.next
+      end
     end
   end
 end

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-utils
 version: !ruby/object:Gem::Version
-  version: 1.5.5
+  version: 1.6.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-28 00:00:00.000000000 Z
+date: 2023-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor