metanorma-utils 1.0.8 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 366ab5765fb28315b8c4258b6d766b04733ffbc69c912fd718f2229a5d5a9303
-  data.tar.gz: abdcfed1228161a42c79d748b4a50b36ef29c08f9b028c1ee86ce14b053db482
+  metadata.gz: 52b94adefc23d35f664e35438604432f951f29d15ccb5622f64447a79eaa14d0
+  data.tar.gz: 5e68045ce2aaf9c6a34ec8793d8f75b1e3bb065fe4a733db84101f4bee31cf2d
 SHA512:
-  metadata.gz: 620d77ee112d112ee72e2fc90257692ff39120f6fa0e2e8d219e0a2790435e750ec2b6742c7a75cfb2a195e1e41bc5afe33d8b5aa015f616eac559ad9e6c9944
-  data.tar.gz: 42591f0ed4cdc91895f154c7f3c50d5e572b9870c77604367207ab1567025a7fbb07c3d9ca90965f8e688188ed91d894ded759db07eabc5008c6c3da5642c118
+  metadata.gz: b5e47154cf50378f9960ddd1f782d3ec35c4c92395d3e74a0f734ad7f77c510c401ad26e46fa4aae96b30784e0263e407e93b6d58daf97070b9f2628a72b57ff
+  data.tar.gz: adec26a807cb648a9b6ad5d6cc3e6251f0b79eba52e1901f99cf102ef61db425bb6ea3e1676e51af1a5d9ab9a0b5aeda1e0c6f071ff48238e2fa103fae0b7d48

data/.gitignore

@@ -0,0 +1 @@
+.rubocop-https--*

data/.rubocop.yml

@@ -1,6 +1,14 @@
 # This project follows the Ribose OSS style guide.
 # https://github.com/riboseinc/oss-guides
 # All project-specific additions and overrides should be specified in this file.
-
 inherit_from:
-  - https://raw.githubusercontent.com/riboseinc/oss-guides/master/ci/rubocop.yml
+  - https://raw.githubusercontent.com/riboseinc/oss-guides/master/ci/rubocop.yml
+
+# local repo-specific modifications
+
+AllCops:
+  DisplayCopNames: false
+  StyleGuideCopsOnly: false
+  TargetRubyVersion: 2.4
+Rails:
+  Enabled: true

data/lib/metanorma-utils.rb

@@ -1,3 +1,4 @@
 require_relative "utils/version"
 require_relative "utils/main"
+require_relative "utils/image"
 require_relative "utils/log"

data/lib/utils/image.rb

@@ -0,0 +1,177 @@
+require "asciidoctor"
+require "tempfile"
+require "marcel"
+require "mime/types"
+require "base64"
+
+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>[^;]+);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"])
+          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
+      end
+
+      def svgmap_rewrite0_path(src, localdirectory)
+        if /^data:/.match?(src)
+          save_dataimage(src)
+        else
+          File.file?(src) ? src : localdirectory + src
+        end
+      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
+      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
+      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
+      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)
+      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
+      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("#%s_%09d", i, idx))
+              .gsub(%r(\[id\s*=\s*['"]?#{i}['"]?\]), sprintf("[id='%s_%09d']", i, idx))
+          end
+          s.children = c
+        end
+      end
+
+      # sources/plantuml/plantuml20200524-90467-1iqek5i.png
+      # already includes localdir
+      def datauri(uri, localdirectory = ".")
+        return uri if /^data:/.match?(uri)
+
+        path = datauri_path(uri, localdirectory)
+        return path unless File.exist?(path)
+
+        types = MIME::Types.type_for(path)
+        type = types ? types.first.to_s : 'text/plain; charset="utf-8"'
+        bin = File.open(path, "rb", &:read)
+        data = Base64.strict_encode64(bin)
+        "data:#{type};base64,#{data}"
+      end
+
+      def datauri_path(uri, localdirectory)
+        path = if %r{^([A-Z]:)?/}.match?(uri) then uri
+               else
+                 File.exist?(uri) ? uri : File.join(localdirectory, uri)
+               end
+        unless File.exist?(path)
+          warn "image at #{path} not found"
+          return uri
+        end
+        path
+      end
+
+      def datauri2mime(uri)
+        %r{^data:image/(?<imgtype>[^;]+);base64,(?<imgdata>.+)$} =~ uri
+        type = nil
+        imgtype = "png" unless /^[a-z0-9]+$/.match? imgtype
+        ::Tempfile.open(["imageuri", ".#{imgtype}"]) do |file|
+          type = datauri2mime1(file, imgdata)
+        end
+        [type]
+      end
+
+      def datauri2mime1(file, imgdata)
+        type = nil
+        begin
+          file.binmode
+          file.write(Base64.strict_decode64(imgdata))
+          file.rewind
+          type = Marcel::MimeType.for file
+        ensure
+          file.close!
+        end
+        type
+      end
+    end
+  end
+end

data/lib/utils/log.rb

@@ -7,48 +7,51 @@ module Metanorma
 
       def add(category, loc, msg)
         return if @novalid
+
         @log[category] = [] unless @log[category]
         @log[category] << { location: current_location(loc), message: msg,
                             context: context(loc) }
         loc = loc.nil? ? "" : "(#{current_location(loc)}): "
-        warn "#{category}: #{loc}#{msg}" 
+        warn "#{category}: #{loc}#{msg}"
       end
 
-      def current_location(n)
-        return "" if n.nil?
-        return n if n.is_a? String
-        return "Asciidoctor Line #{"%06d" % n.lineno}" if n.respond_to?(:lineno) &&
-          !n.lineno.nil? && !n.lineno.empty?
-        return "XML Line #{"%06d" % n.line}" if n.respond_to?(:line) &&
-          !n.line.nil?
-        return "ID #{n.id}" if n.respond_to?(:id) && !n.id.nil?
-        while !n.nil? &&
-            (!n.respond_to?(:level) || n.level.positive?) &&
-            (!n.respond_to?(:context) || n.context != :section)
-          n = n.parent
-          return "Section: #{n.title}" if n&.respond_to?(:context) &&
-            n&.context == :section
+      def current_location(node)
+        if node.nil? then ""
+        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
+          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
+          "??"
         end
-        "??"
       end
 
-      def context(n)
-        return nil if n.is_a? String
-        n.respond_to?(:to_xml) and return n.to_xml
-        n.respond_to?(:to_s) and return n.to_s
+      def context(node)
+        return nil if node.is_a? String
+
+        node.respond_to?(:to_xml) and return node.to_xml
+        node.respond_to?(:to_s) and return node.to_s
         nil
       end
 
       def write(file)
         File.open(file, "w:UTF-8") do |f|
           f.puts "#{file} errors"
-          @log.keys.each do |key|
+          @log.each_key do |key|
             f.puts "\n\n== #{key}\n\n"
-            @log[key].sort do |a, b|
-              a[:location] <=> b[:location]
-            end.each do |n|
+            @log[key].sort_by { |a| a[:location] }.each do |n|
               loc = n[:location] ? "(#{n[:location]}): " : ""
-              f.puts "#{loc}#{n[:message]}" 
+              f.puts "#{loc}#{n[:message]}"
               n[:context]&.split(/\n/)&.first(5)&.each { |l| f.puts "\t#{l}" }
             end
           end

data/lib/utils/main.rb

@@ -2,56 +2,61 @@ require "asciidoctor"
 require "tempfile"
 require "sterile"
 require "uuidtools"
-require "mimemagic"
-require "mime/types"
-require "base64"
 
 module Metanorma
   module Utils
-      NAMECHAR = "\u0000-\u0022\u0024\u002c\u002f\u003a-\u0040\\u005b-\u005e"\
-        "\u0060\u007b-\u00b6\u00b8-\u00bf\u00d7\u00f7\u037e\u2000-\u200b"\
-        "\u200e-\u203e\u2041-\u206f\u2190-\u2bff\u2ff0-\u3000".freeze
-      #"\ud800-\uf8ff\ufdd0-\ufdef\ufffe-\uffff".freeze
-      NAMESTARTCHAR = "\\u002d\u002e\u0030-\u0039\u00b7\u0300-\u036f"\
-        "\u203f-\u2040".freeze
+    NAMECHAR = "\u0000-\u0022\u0024\u002c\u002f\u003a-\u0040\\u005b-\u005e"\
+      "\u0060\u007b-\u00b6\u00b8-\u00bf\u00d7\u00f7\u037e\u2000-\u200b"\
+      "\u200e-\u203e\u2041-\u206f\u2190-\u2bff\u2ff0-\u3000".freeze
+    NAMESTARTCHAR = "\\u002d\u002e\u0030-\u0039\u00b7\u0300-\u036f"\
+      "\u203f-\u2040".freeze
 
     class << self
-      def to_ncname(s)
-        start = s[0]
-        ret1 = %r([#{NAMECHAR}#]).match(start) ? "_" :
-          (%r([#{NAMESTARTCHAR}#]).match(start) ? "_#{start}" : start)
-        ret2 = s[1..-1] || ""
-        ret = (ret1 || "") + ret2.gsub(%r([#{NAMECHAR}#]), "_")
-        ret
+      def to_ncname(tag)
+        start = tag[0]
+        ret1 = if %r([#{NAMECHAR}#]).match?(start)
+                 "_"
+               else
+                 (%r([#{NAMESTARTCHAR}#]).match?(start) ? "_#{start}" : start)
+               end
+        ret2 = tag[1..-1] || ""
+        (ret1 || "") + ret2.gsub(%r([#{NAMECHAR}#]), "_")
       end
 
       def anchor_or_uuid(node = nil)
         uuid = UUIDTools::UUID.random_create
-        node.nil? || node.id.nil? || node.id.empty? ? "_" + uuid : node.id
+        node.nil? || node.id.nil? || node.id.empty? ? "_#{uuid}" : node.id
       end
 
-      def asciidoc_sub(x)
-        return nil if x.nil?
-        return "" if x.empty?
-        d = Asciidoctor::Document.new(x.lines.entries, { header_footer: false, backend: :html })
+      def asciidoc_sub(text, flavour = :standoc)
+        return nil if text.nil?
+        return "" if text.empty?
+
+        d = Asciidoctor::Document.new(
+          text.lines.entries,
+          { header_footer: false, backend: flavour }
+        )
         b = d.parse.blocks.first
         b.apply_subs(b.source)
       end
 
       def localdir(node)
         docfile = node.attr("docfile")
-        docfile.nil? ? './' : Pathname.new(docfile).parent.to_s + '/'
+        docfile.nil? ? "./" : "#{Pathname.new(docfile).parent}/"
       end
 
       # TODO needs internationalisation
-      def smartformat(n)
-        n.gsub(/ --? /, "&#8201;&#8212;&#8201;").
-          gsub(/--/, "&#8212;").smart_format.gsub(/</, "&lt;").gsub(/>/, "&gt;")
+      def smartformat(text)
+        text.gsub(/ --? /, "&#8201;&#8212;&#8201;")
+          .gsub(/--/, "&#8212;").smart_format.gsub(/</, "&lt;")
+          .gsub(/>/, "&gt;")
       end
 
       def endash_date(elem)
         elem.traverse do |n|
-          n.text? and n.replace(n.text.gsub(/\s+--?\s+/, "&#8211;").gsub(/--/, "&#8211;"))
+          next unless n.text?
+
+          n.replace(n.text.gsub(/\s+--?\s+/, "&#8211;").gsub(/--/, "&#8211;"))
         end
       end
 
@@ -60,95 +65,34 @@ module Metanorma
       def set_nested_value(hash, keys, new_val)
         key = keys[0]
         if keys.length == 1
-          hash[key] = hash[key].is_a?(Array) ?  (hash[key] << new_val) :
-            hash[key].nil? ?  new_val : [hash[key], new_val]
+          hash[key] = if hash[key].is_a?(Array)
+                        (hash[key] << new_val)
+                      else
+                        hash[key].nil? ? new_val : [hash[key], new_val]
+                      end
+        elsif hash[key].is_a?(Array)
+          hash[key][-1] = {} if !hash[key].empty? && hash[key][-1].nil?
+          hash[key] << {} if hash[key].empty? || !hash[key][-1].is_a?(Hash)
+          set_nested_value(hash[key][-1], keys[1..-1], new_val)
+        elsif hash[key].nil? || hash[key].empty?
+          hash[key] = {}
+          set_nested_value(hash[key], keys[1..-1], new_val)
+        elsif hash[key].is_a?(Hash) && !hash[key][keys[1]]
+          set_nested_value(hash[key], keys[1..-1], new_val)
+        elsif !hash[key][keys[1]]
+          hash[key] = [hash[key], {}]
+          set_nested_value(hash[key][-1], keys[1..-1], new_val)
         else
-          if hash[key].is_a?(Array)
-            hash[key][-1] = {} if !hash[key].empty? && hash[key][-1].nil?
-            hash[key] << {} if hash[key].empty? || !hash[key][-1].is_a?(Hash)
-            set_nested_value(hash[key][-1], keys[1..-1], new_val)
-          elsif hash[key].nil? || hash[key].empty?
-            hash[key] = {}
-            set_nested_value(hash[key], keys[1..-1], new_val)
-          elsif hash[key].is_a?(Hash) && !hash[key][keys[1]]
-            set_nested_value(hash[key], keys[1..-1], new_val)
-          elsif !hash[key][keys[1]]
-            hash[key] = [hash[key], {}]
-            set_nested_value(hash[key][-1], keys[1..-1], new_val)
-          else
-            set_nested_value(hash[key], keys[1..-1], new_val)
-          end
+          set_nested_value(hash[key], keys[1..-1], new_val)
         end
         hash
       end
 
-      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>[^;]+);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 do |s|
-          next unless svgmap_rewrite0(s, n, localdirectory)
-          next if s.at(n.ns("./target/eref"))
-          s.replace(s.at(n.ns("./figure")))
-        end
-      end
-
-      def svgmap_rewrite0(s, n, localdirectory)
-        if i = s.at(n.ns(".//image")) and src = i["src"]
-          path = /^data:/.match(src) ? save_dataimage(src) : File.file?(src) ? src : localdirectory + src
-          File.file?(path) or return false
-          svgmap_rewrite1(s, Nokogiri::XML(File.read(path, encoding: "utf-8")), path, n)
-          /^data:/.match(src) and i["src"] = datauri(path)
-        elsif i = s.at(".//m:svg", "m" => SVG_NS)
-          svgmap_rewrite1(s, i, nil, n)
-        else
-          return false
-        end                 
-        true
-      end
-
-      def svgmap_rewrite1(s, svg, path, n)
-        targets = s.xpath(n.ns("./target")).each_with_object({}) do |t, m|
-          x = t.at(n.ns("./xref")) and m[File.expand_path(t["href"])] = "##{x['target']}"
-          x = t.at(n.ns("./link")) and m[File.expand_path(t["href"])] = x['target']
-          t.remove if t.at(n.ns("./xref | ./link"))
-        end
-        svg.xpath(".//m:a", "m" => SVG_NS).each do |a|
-          a["xlink:href"] and x = targets[File.expand_path(a["xlink:href"])] and a["xlink:href"] = x
-          a["href"] and x = targets[File.expand_path(a["href"])] and a["href"] = x
-        end
-        path and File.open(path, "w", encoding: "utf-8") { |f| f.write(svg.to_xml) }
-      end
-
       # not currently used
       def flatten_rawtext_lines(node, result)
         node.lines.each do |x|
-          if node.respond_to?(:context) && (node.context == :literal || node.context == :listing)
+          if node.respond_to?(:context) &&
+              (node.context == :literal || node.context == :listing)
             result << x.gsub(/</, "&lt;").gsub(/>/, "&gt;")
           else
             # strip not only HTML <tag>, and Asciidoc xrefs <<xref>>
@@ -174,45 +118,6 @@ module Metanorma
         end
         result.reject(&:empty?)
       end
-
-      #   sources/plantuml/plantuml20200524-90467-1iqek5i.png already includes localdir
-      def datauri(uri, localdirectory = ".")
-        return uri if /^data:/.match(uri)
-        path = %r{^([A-Z]:)?/}.match?(uri) ? uri : 
-          File.exist?(uri) ? uri : File.join(localdirectory, uri)
-        unless File.exist?(path)
-          warn "image at #{path} not found"
-          return uri
-        end
-        types = MIME::Types.type_for(path)
-        type = types ? types.first.to_s : 'text/plain; charset="utf-8"'
-        bin = File.open(path, 'rb', &:read)
-        data = Base64.strict_encode64(bin)
-        "data:#{type};base64,#{data}"
-      end
-
-      def datauri2mime(uri)
-        %r{^data:image/(?<imgtype>[^;]+);base64,(?<imgdata>.+)$} =~ uri
-        type = nil
-        imgtype = "png" unless /^[a-z0-9]+$/.match imgtype
-        ::Tempfile.open(["imageuri", ".#{imgtype}"]) do |file|
-          type = datauri2mime1(file, imgdata)
-        end
-        [type]
-      end
-
-      def datauri2mime1(file, imgdata)
-        type = nil
-        begin
-          file.binmode
-          file.write(Base64.strict_decode64(imgdata))
-          file.rewind
-          type = MimeMagic.by_magic(file)
-        ensure
-          file.close!
-        end
-        type
-      end
     end
   end
 end