metanorma-utils 1.6.4 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57cdd3eb9d930975ba70e75b1a93fa61b071ad0a84f6d9acb9173f39e4ab9461
-  data.tar.gz: 7d7db96c6baf145635b80c7538191582c98acde5d47698e0f5743b706e5c9a8b
+  metadata.gz: d976aa0a315c0de6418c649e96065e3b5f0792a232e55ed9b2a6044ed7257491
+  data.tar.gz: 50829e2e03b2c4da90cbccf7773309c4e6a88dfc5e3eaeb9d93f33608fe36539
 SHA512:
-  metadata.gz: f32fd8887a434a77e6f99ad81c5dafb8677096787c7fbae70cf4aeac4d5d264913639a9f216aa0793f8f3b7637ff78303372d7c8ee5072c516ca983436a3c47e
-  data.tar.gz: d9434cdece35bd9f95f9366a987d11995c19dca2bf2cd348ab1cf877a3fff96c66f69dc137cebc9d548a3b8c7a01ef3f0d196993b3873e62d58cceea9c277a21
+  metadata.gz: fbee4963987764258501a416f9cf662612240b15f53f169fe2f104738d8bda20c83f9fa7a782077e9668b9764ea1ac968a6a155709e0bc4d04bc15f0a8a2507c
+  data.tar.gz: e25371b4a3c0efa083a7086495207fede9ac7c8df0524b49a5951f83557e8367ecbf52de7aea34d0cb73103180acc077e0afe9b6fe964816aa42c49d1cda339f

data/Gemfile

@@ -6,6 +6,4 @@ git_source(:github) { |repo| "https://github.com/#{repo}" }
 
 gemspec
 
-if File.exist? "Gemfile.devel"
-  eval File.read("Gemfile.devel"), nil, "Gemfile.devel" # rubocop:disable Security/Eval
-end
+eval_gemfile("Gemfile.devel") rescue nil

data/lib/utils/image.rb

@@ -1,187 +1,68 @@
 require "tempfile"
 require "marcel"
 require "base64"
+require "image_size"
+require_relative "namespace"
 
 module Metanorma
   module Utils
     class << self
-      class Namespace
-        def initialize(xmldoc)
-          @namespace = xmldoc.root.namespace
-        end
-
-        def ns(path)
-          return path if @namespace.nil?
-
-          path.gsub(%r{/([a-zA-z])}, "/xmlns:\\1")
-            .gsub(%r{::([a-zA-z])}, "::xmlns:\\1")
-            .gsub(%r{\[([a-zA-z][a-z0-9A-Z@/]* ?=)}, "[xmlns:\\1")
-            .gsub(%r{\[([a-zA-z][a-z0-9A-Z@/]*\])}, "[xmlns:\\1")
-        end
-      end
-
-      def save_dataimage(uri)
-        %r{^data:(?:image|application)/(?<imgtype>[^;]+);(?:charset=[^;]+;)?base64,(?<imgdata>.+)$} =~ uri
-        imgtype.sub!(/\+[a-z0-9]+$/, "") # svg+xml
-        imgtype = "png" unless /^[a-z0-9]+$/.match? imgtype
-        Tempfile.open(["image", ".#{imgtype}"]) do |f|
-          f.binmode
-          f.write(Base64.strict_decode64(imgdata))
-          f.path
-        end
-      end
-
-      SVG_NS = "http://www.w3.org/2000/svg".freeze
-
-      def svgmap_rewrite(xmldoc, localdirectory = "")
-        n = Namespace.new(xmldoc)
-        xmldoc.xpath(n.ns("//svgmap")).each_with_index do |s, i|
-          next unless svgmap_rewrite0(s, n, localdirectory, i)
-          next if s.at(n.ns("./target/eref"))
-
-          s.replace(s.at(n.ns("./figure")))
-        end
-      end
-
-      def svgmap_rewrite0(svgmap, namespace, localdirectory, idx)
-        if (i = svgmap.at(namespace.ns(".//image"))) &&
-            (src = i["src"]) && !src.empty?
-          path = svgmap_rewrite0_path(src, localdirectory)
-          File.file?(path) or return false
-          svg = Nokogiri::XML(File.read(path, encoding: "utf-8"))
-          i.replace(svgmap_rewrite1(svgmap, svg.root, namespace, idx))
-          /^data:/.match(src) and i["src"] = datauri(path)
-        elsif i = svgmap.at(".//m:svg", "m" => SVG_NS)
-          i.replace(svgmap_rewrite1(svgmap, i, namespace, idx))
-        else return false
-        end
-        true
+      def image_resize(img, path, maxheight, maxwidth)
+        s, realsize = get_image_size(img, path)
+        img.name == "svg" && !img["viewBox"] && s[0] && s[1] and
+          img["viewBox"] = "0 0 #{s[0]} #{s[1]}"
+        s, skip = image_dont_resize(s, realsize)
+        skip and return s
+        s = image_size_fillin(s, realsize)
+        image_shrink(s, maxheight, maxwidth)
       end
 
-      def svgmap_rewrite0_path(src, localdirectory)
-        if /^data:/.match?(src)
-          save_dataimage(src)
-        else
-          File.file?(src) ? src : localdirectory + src
-        end
+      def image_dont_resize(dim, realsize)
+        dim.nil? and return [[nil, nil], true]
+        realsize.nil? and return [dim, true]
+        dim[0] == nil && dim[1] == nil and return [dim, true]
+        [dim, false]
       end
 
-      def svgmap_rewrite1(svgmap, svg, namespace, idx)
-        svg_update_href(svgmap, svg, namespace)
-        svg_update_ids(svg, idx)
-        svg.xpath("processing-instruction()|.//processing-instruction()").remove
-        svg.to_xml
+      def image_size_fillin(dim, realsize)
+        dim[1].zero? && !dim[0].zero? and
+          dim[1] = dim[0] * realsize[1] / realsize[0]
+        dim[0].zero? && !dim[1].zero? and
+          dim[0] = dim[1] * realsize[0] / realsize[1]
+        dim
       end
 
-      def svg_update_href(svgmap, svg, namespace)
-        targ = svgmap_rewrite1_targets(svgmap, namespace)
-        svg.xpath(".//m:a", "m" => SVG_NS).each do |a|
-          ["xlink:href", "href"].each do |p|
-            a[p] and x = targ[File.expand_path(a[p])] and a[p] = x
-          end
-        end
+      def image_shrink(dim, maxheight, maxwidth)
+        dim[1] > maxheight and
+          dim = [(dim[0] * maxheight / dim[1]).ceil, maxheight]
+        dim[0] > maxwidth and
+          dim = [maxwidth, (dim[1] * maxwidth / dim[0]).ceil]
+        dim
       end
 
-      def svgmap_rewrite1_targets(svgmap, namespace)
-        svgmap.xpath(namespace.ns("./target"))
-          .each_with_object({}) do |t, m|
-          x = t.at(namespace.ns("./xref")) and
-            m[File.expand_path(t["href"])] = "##{x['target']}"
-          x = t.at(namespace.ns("./link")) and
-            m[File.expand_path(t["href"])] = x["target"]
-          t.remove if t.at(namespace.ns("./xref | ./link"))
-        end
+      def get_image_size(img, path)
+        realsize = ImageSize.path(path).size
+        s = image_size_interpret(img, realsize || [nil, nil])
+        image_size_zeroes_complete(s, realsize)
       end
 
-      def svg_update_ids(svg, idx)
-        ids = svg.xpath("./@id | .//@id")
-          .each_with_object([]) { |i, m| m << i.value }
-        return if ids.empty?
-
-        svg_update_ids_attrs(svg, ids, idx)
-        svg_update_ids_css(svg, ids, idx)
+      def image_size_interpret(img, realsize)
+        w = image_size_percent(img["width"], realsize[0])
+        h = image_size_percent(img["height"], realsize[1])
+        [w, h]
       end
 
-      def svg_update_ids_attrs(svg, ids, idx)
-        svg.xpath(". | .//*[@*]").each do |a|
-          a.attribute_nodes.each do |x|
-            ids.include?(x.value) and x.value += sprintf("_%09d", idx)
-          end
-        end
+      def image_size_percent(value, real)
+        /%$/.match?(value) && !real.nil? and
+          value = real * (value.sub(/%$/, "").to_f / 100)
+        value.to_i
       end
 
-      def svg_update_ids_css(svg, ids, idx)
-        svg.xpath("//m:style", "m" => SVG_NS).each do |s|
-          c = s.children.to_xml
-          ids.each do |i|
-            c = c.gsub(%r[##{i}\b],
-                       sprintf("#%<id>s_%<idx>09d", id: i, idx: idx))
-              .gsub(%r(\[id\s*=\s*['"]?#{i}['"]?\]),
-                    sprintf("[id='%<id>s_%<idx>09d']", id: i, idx: idx))
-          end
-          s.children = c
+      def image_size_zeroes_complete(dim, realsize)
+        if dim[0].zero? && dim[1].zero?
+          dim = realsize
         end
-      end
-
-      # sources/plantuml/plantuml20200524-90467-1iqek5i.png
-      # already includes localdir
-      # Check whether just the local path or the other specified relative path
-      # works.
-      def datauri(uri, local_dir = ".")
-        (datauri?(uri) || url?(uri)) and return uri
-        options = absolute_path?(uri) ? [uri] : [uri, File.join(local_dir, uri)]
-        path = options.detect do |p|
-          File.exist?(p) ? p : nil
-        end
-        path and return encode_datauri(path)
-        warn "Image specified at `#{uri}` does not exist."
-        uri # Return original provided location
-      end
-
-      def encode_datauri(path)
-        return nil unless File.exist?(path)
-
-        type = Marcel::MimeType.for(Pathname.new(path)) ||
-          'text/plain; charset="utf-8"'
-
-        bin = File.binread(path)
-        data = Base64.strict_encode64(bin)
-        "data:#{type};base64,#{data}"
-      rescue StandardError
-        warn "Data-URI encoding of `#{path}` failed."
-        nil
-      end
-
-      def datauri?(uri)
-        /^data:/.match?(uri)
-      end
-
-      def url?(url)
-        %r{^[A-Z]{2,}://}i.match?(url)
-      end
-
-      def absolute_path?(uri)
-        %r{^/}.match?(uri) || %r{^[A-Z]:/}.match?(uri)
-      end
-
-      def decode_datauri(uri)
-        %r{^data:(?<mimetype>[^;]+);base64,(?<mimedata>.+)$} =~ uri
-        return nil unless mimetype && mimedata
-
-        data = Base64.strict_decode64(mimedata)
-        {
-          type_declared: mimetype,
-          type_detected: Marcel::MimeType.for(data, declared_type: mimetype),
-          data: data,
-        }
-      end
-
-      # FIXME: This method should ONLY return 1 type, remove Array wrapper
-      def datauri2mime(uri)
-        output = decode_datauri(uri)
-        return nil unless output && output[:type_detected]
-
-        [output[:type_detected]]
+        [dim, realsize]
       end
     end
   end

data/lib/utils/log.rb

@@ -11,23 +11,32 @@ module Metanorma
         @mapid = {}
       end
 
-      def add(category, loc, msg)
+      # severity: 0: abort; 1: serious; 2: not serious
+      def add(category, loc, msg, severity: 2)
         @novalid and return
         @log[category] ||= []
-        item = create_entry(loc, msg)
+        item = create_entry(loc, msg, severity)
         @log[category] << item
         loc = loc.nil? ? "" : "(#{current_location(loc)}): "
         suppress_display?(category, loc, msg) or
           warn "#{category}: #{loc}#{msg}"
       end
 
+      def abort_messages
+        @log.values.each_with_object([]) do |v, m|
+          v.each do |e|
+            e[:severity].zero? and m << e[:message]
+          end
+        end
+      end
+
       def suppress_display?(category, _loc, _msg)
         ["Metanorma XML Syntax"].include?(category)
       end
 
-      def create_entry(loc, msg)
+      def create_entry(loc, msg, severity)
         msg = msg.encode("UTF-8", invalid: :replace, undef: :replace)
-        item = { location: current_location(loc),
+        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)
@@ -101,7 +110,11 @@ module Metanorma
         <<~HTML
           <html><head><title>#{file} errors</title>
           <meta charset="UTF-8"/>
-          <style> pre { white-space: pre-wrap; } </style>
+          <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 { }  </style>
           </head><body><h1>#{file} errors</h1>
         HTML
       end
@@ -118,25 +131,31 @@ module Metanorma
       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>
+          <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|
-          write1(file, n)
+          write_entry(file, render_preproc_entry(n))
         end
         file.puts "</tbody></table>\n"
       end
 
-      def write1(file, entry)
-        line = entry[:line]
-        line = nil if line == "000000"
-        loc = loc_link(entry)
-        msg = break_up_long_str(entry[:message], 10, 2)
+      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>")
-        entry[:context] and context = entry[:context].split("\n").first(5)
+        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("><", "> <")
-        write_entry(file, line, loc, msg, context)
       end
 
       def mapid(old, new)
@@ -160,10 +179,12 @@ module Metanorma
         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))
+      def write_entry(file, entry)
+        entry[:context] &&= @c.encode(break_up_long_str(entry[:context], 40, 2))
         file.print <<~HTML
-          <tr><td>#{line}</td><th><code>#{loc}</code></th><td>#{msg}</td><td><pre>#{context}</pre></td></tr>
+          <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

data/lib/utils/namespace.rb

@@ -0,0 +1,26 @@
+module Metanorma
+  module Utils
+    class << self
+      # NOTE: It was used in methods of an eigenclass of Metanorma::Utils.
+      #       Not sure if it's still used somewhere but could be.
+      class Namespace
+        def initialize(xmldoc)
+          @namespace = xmldoc.root.namespace
+        end
+
+        def ns(path)
+          return path if @namespace.nil?
+
+          path.gsub(%r{/([a-zA-Z])}, "/xmlns:\\1")
+            .gsub(%r{::([a-zA-Z])}, "::xmlns:\\1")
+            .gsub(%r{\[([a-zA-Z][a-z0-9A-Z@/]* ?=)}, "[xmlns:\\1")
+            .gsub(%r{\[([a-zA-Z][a-z0-9A-Z@/]*\])}, "[xmlns:\\1")
+        end
+      end
+
+      def create_namespace(xmldoc)
+        Namespace.new(xmldoc)
+      end
+    end
+  end
+end

data/lib/utils/version.rb

@@ -1,5 +1,5 @@
 module Metanorma
   module Utils
-    VERSION = "1.6.4".freeze
+    VERSION = "1.7.0".freeze
   end
 end

data/metanorma-utils.gemspec

@@ -30,6 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "concurrent-ruby"
   spec.add_dependency "csv"
   spec.add_dependency "htmlentities", "~> 4.3.4"
+  spec.add_dependency "image_size", ">= 3.2.0"
   spec.add_dependency "marcel", "~> 1.0.0"
   spec.add_dependency "mime-types"
   spec.add_dependency "nokogiri", ">= 1.11"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-utils
 version: !ruby/object:Gem::Version
-  version: 1.6.4
+  version: 1.7.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-11-20 00:00:00.000000000 Z
+date: 2024-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 4.3.4
+- !ruby/object:Gem::Dependency
+  name: image_size
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
 - !ruby/object:Gem::Dependency
   name: marcel
   requirement: !ruby/object:Gem::Requirement
@@ -324,6 +338,7 @@ files:
 - lib/utils/image.rb
 - lib/utils/log.rb
 - lib/utils/main.rb
+- lib/utils/namespace.rb
 - lib/utils/version.rb
 - lib/utils/xml.rb
 - metanorma-utils.gemspec