metanorma-standoc 2.8.11 → 2.9.1

data/lib/metanorma/standoc/lists.rb

@@ -41,7 +41,7 @@ module Metanorma
             list_caption(node, xml_ul)
             node.items.each { |item| ul_li(xml_ul, item) }
           end
-        end.join("\n")
+        end.join("")
       end
 
       def olist_style(style)
@@ -67,7 +67,7 @@ module Metanorma
             list_caption(node, xml_ol)
             node.items.each { |item| li(xml_ol, item) }
           end
-        end.join("\n")
+        end.join("")
       end
 
       def dt(terms, xml_dl)
@@ -107,7 +107,7 @@ module Metanorma
               dd(dd, xml_dl)
             end
           end
-        end.join("\n")
+        end.join("")
       end
 
       def colist(node)
@@ -117,7 +117,7 @@ module Metanorma
               xml_li.p { |p| p << item.text }
             end
           end
-        end.join("\n")
+        end.join("")
       end
 
       def list_caption(node, out)

data/lib/metanorma/standoc/macros.rb

@@ -7,6 +7,7 @@ require_relative "macros_terms"
 require_relative "macros_form"
 require_relative "macros_note"
 require_relative "macros_embed"
+require_relative "macros_link"
 require_relative "datamodel/attributes_table_preprocessor"
 require_relative "datamodel/diagram_preprocessor"
 require "metanorma-plugin-datastruct"
@@ -52,13 +53,19 @@ module Metanorma
     class NamedEscapePreprocessor < Asciidoctor::Extensions::Preprocessor
       def process(document, reader)
         c = HTMLEntities.new
+        p = Metanorma::Utils::LineStatus.new
         lines = reader.lines.map do |l|
-          l.split(/(&[A-Za-z][^&;]*;)/).map do |s|
-            /^&[A-Za-z]/.match?(s) ? c.encode(c.decode(s), :hexadecimal) : s
-          end.join
+          p.process(l)
+          p.pass ? l : convert(l, c)
         end
         ::Asciidoctor::PreprocessorReader.new document, lines
       end
+
+      def convert(line, esc)
+        line.split(/(&[A-Za-z][^&;]*;)/).map do |s|
+          /^&[A-Za-z]/.match?(s) ? esc.encode(esc.decode(s), :hexadecimal) : s
+        end.join
+      end
     end
 
     class ColumnBreakBlockMacro < Asciidoctor::Extensions::BlockMacroProcessor
@@ -74,51 +81,16 @@ module Metanorma
     # Not using TreeProcessor because that is still too close to
     # inline expressions being processed on access (e.g. titles)
     class LinkProtectPreprocessor < Asciidoctor::Extensions::Preprocessor
-      def init
-        pass = true # process as passthrough: init = true until
-        # hit end of doc header
-        is_delim = false # current line is a no-substititon block delimiter
-        pass_delim = false # current line is a passthrough delimiter
-        delimln = "" # delimiter line of current block(s);
-        # init value looks for end of doc header
-        { pass: pass, is_delim: is_delim, pass_delim: pass_delim,
-          delimln: delimln }
-      end
-
       def process(document, reader)
-        p = init
+        p = Metanorma::Utils::LineStatus.new
         lines = reader.lines.map do |t|
-          p = pass_status(p, t.rstrip)
-          !p[:pass] && t.include?(":") and t = inlinelinkmacro(inlinelink(t))
+          p.process(t)
+          !p.pass && t.include?(":") and t = inlinelinkmacro(inlinelink(t))
           t
         end
         ::Asciidoctor::PreprocessorReader.new document, lines
       end
 
-      def pass_status(status, text)
-        text == "++++" && !status[:delimln] and status[:pass] = !status[:pass]
-        status[:midline_docattr] && !/^:[^ :]+: /.match?(text) and
-          status[:midline_docattr] = false
-        if (status[:is_delim] && /^(-+|\*+|=+|_+)$/.match?(text)) ||
-            (!status[:is_delim] && !status[:delimln] && /^-----*$|^\.\.\.\.\.*$/.match?(text))
-          status[:delimln] = text
-          status[:pass] = true
-        elsif status[:pass_delim]
-          status[:delimln] = "" # end of paragraph for paragraph with [pass]
-        elsif status[:delimln] && text == status[:delimln]
-          status[:pass] = false
-          status[:delimln] = nil
-        elsif /^:[^ :]+: /.match?(text) &&
-            (status[:prev_line].empty? || status[:midline_docattr])
-          status[:pass] = true
-          status[:midline_docattr] = true
-        end
-        status[:is_delim] = /^\[(source|listing|literal|pass)\b/.match?(text)
-        status[:pass_delim] = /^\[(pass)\b/.match?(text)
-        status[:prev_line] = text.strip
-        status
-      end
-
       PASS_INLINE_MACROS = %w(pass pass-format identifier std-link stem)
         .join("|").freeze
 
@@ -132,7 +104,7 @@ module Metanorma
           \\[.*?(?<!\\\\)\\]                     # [ ... ] not preceded by \\
         )
       REGEX
-      PASS_INLINE_MACRO_RX = /#{PASS_INLINE_MACRO_STR}/xo.freeze
+      PASS_INLINE_MACRO_RX = /#{PASS_INLINE_MACRO_STR}/xo
 
       def pass_inline_split(text)
         text.split(PASS_INLINE_MACRO_RX).each.map do |x|
@@ -142,7 +114,7 @@ module Metanorma
 
       # InlineLinkRx = %r((^|link:|#{CG_BLANK}|&lt;|[>\(\)\[\];"'])(\\?(?:https?|file|ftp|irc)://)(?:([^\s\[\]]+)\[(|#{CC_ALL}*?[^\\])\]|([^\s\[\]<]*([^\s,.?!\[\]<\)]))))m
       #
-      InlineLinkRx = %r((^|(?<![-\\])\blink:(?!\+)|\p{Blank}|&lt;|[<>\(\)\[\];"'])((?:https?|file|ftp|irc)://)(?:([^\s\[\]]+)(?:(\[(|.*?[^\\])\])|([^\s\[\]<]*([^\s,.?!\[\]<\)])))))m.freeze
+      InlineLinkRx = %r((^|(?<![-\\])\blink:(?!\+)|\p{Blank}|&lt;|[<>\(\)\[\];"'])((?:https?|file|ftp|irc)://)(?:([^\s\[\]]+)(?:(\[(|.*?[^\\])\])|([^\s\[\]<]*([^\s,.?!\[\]<\)])))))m
 
       def inlinelink(text)
         text.include?("://") or return text
@@ -172,7 +144,7 @@ module Metanorma
         (|[^:\\s\\[][^\\s\\[]*)          # link: ... up to [
         (\\[(|.*?[^\\\\])\\])            # [ ... ], no ]
       REGEX
-      InlineLinkMacroRx = /#{InlineLinkMacroRx1}/x.freeze
+      InlineLinkMacroRx = /#{InlineLinkMacroRx1}/x
 
       def inlinelinkmacro(text)
         (text.include?("[") &&

data/lib/metanorma/standoc/macros_embed.rb

@@ -37,18 +37,19 @@ module Metanorma
       def process(doc, reader)
         reader.eof? and return reader
         r = ::Asciidoctor::PreprocessorNoIfdefsReader.new doc, reader.lines
+        p = Metanorma::Utils::LineStatus.new
         lines = r.readlines
         headings = lines.grep(/^== /).map(&:strip)
         ret = lines.each_with_object(embed_acc(doc, r)) do |line, m|
-          process_line(line, m, headings)
+          process_line(line, m, headings, p)
         end
         return_to_document(doc, ret)
       end
 
       def embed_acc(doc, reader)
         { lines: [], hdr: [], id: [],
-          orig: doc, doc: doc, file: nil, path: nil,
-          reader: reader, prev: nil }
+          orig: doc, doc:, file: nil, path: nil,
+          reader:, prev: nil }
       end
 
       # presupposes single embed
@@ -93,13 +94,14 @@ module Metanorma
 
       def update_embeds(lines, acc, emb)
         lines.empty? or
-          acc << { file: emb[:file], path: emb[:path], lines: lines }
+          acc << { file: emb[:file], path: emb[:path], lines: }
         [[], acc]
       end
 
-      def process_line(line, acc, headings)
-        if /^embed::/.match?(line)
-          e = embed(line, acc, headings)
+      def process_line(line, acc, headings, status)
+        status.process(line)
+        if !status.pass && /^embed::/.match?(line)
+          e = embed(line, acc, headings, status)
           acc = process_embed(acc, e, acc[:prev])
         else
           acc[:lines] << line
@@ -148,7 +150,7 @@ module Metanorma
         end
       end
 
-      def embed(line, acc, headings)
+      def embed(line, acc, headings, status)
         fname, inc_path = filename(line, acc)
         lines = filter_sections(read(inc_path), headings)
         n = Asciidoctor::Document
@@ -158,12 +160,12 @@ module Metanorma
           .merge(file: fname, path: inc_path, orig: acc[:orig])
         ret[:hdr] or
           raise "Embedding an incomplete document with no header: #{ret[:path]}"
-        embed_recurse(ret, n, r, headings)
+        embed_recurse(ret, n, r, headings, status)
       end
 
-      def embed_recurse(ret, doc, reader, headings)
+      def embed_recurse(ret, doc, reader, headings, status)
         ret1 = ret[:lines].each_with_object(embed_acc(doc, reader)) do |line, m|
-          process_line(line, m, headings)
+          process_line(line, m, headings, status)
         end
         ret.merge(
           { lines: ret1[:lines], id: ret[:id] + ret1[:id],
@@ -172,7 +174,7 @@ module Metanorma
       end
 
       def strip_header(lines)
-        return { lines: lines, hdr: nil } unless !lines.empty? &&
+        return { lines:, hdr: nil } unless !lines.empty? &&
           lines.first.start_with?("= ")
 
         skip = true

data/lib/metanorma/standoc/macros_inline.rb

@@ -1,3 +1,5 @@
+require_relative "utils"
+
 module Metanorma
   module Standoc
     class InheritInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
@@ -12,49 +14,6 @@ module Metanorma
       end
     end
 
-    class IndexXrefInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :index
-
-      def preprocess_attrs(attrs)
-        ret = { primary: attrs[1], target: attrs[attrs.size] }
-        ret[:secondary] = attrs[2] if attrs.size > 2
-        ret[:tertiary] = attrs[3] if attrs.size > 3
-        ret
-      end
-
-      def validate(parent, target, attrs)
-        attrs.size > 1 && attrs.size < 5 and return true
-        e = "invalid index \"#{target}\" cross-reference: wrong number of " \
-            "attributes in `index:#{target}[#{attrs.values.join(',')}]`"
-        parent.converter.log.add("Crossreferences", parent, e, severity: 0)
-        false
-      end
-
-      def process(parent, target, attr)
-        validate(parent, target, attr) or return
-        args = preprocess_attrs(attr)
-        ret = "<index-xref also='#{target == 'also'}'>" \
-              "<primary>#{args[:primary]}</primary>"
-        ret += "<secondary>#{args[:secondary]}</secondary>" if args[:secondary]
-        ret += "<tertiary>#{args[:tertiary]}</tertiary>" if args[:tertiary]
-        ret + "<target>#{args[:target]}</target></index-xref>"
-      end
-    end
-
-    class IndexRangeInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :"index-range"
-      parse_content_as :text
-
-      def process(parent, target, attr)
-        text = attr["text"]
-        text = "((#{text}))" unless /^\(\(.+\)\)$/.match?(text)
-        out = parent.sub_macros(text)
-        out.sub("<index>", "<index to='#{target}'>")
-      end
-    end
-
     class HTML5RubyMacro < Asciidoctor::Extensions::InlineMacroProcessor
       use_dsl
       named :ruby
@@ -151,23 +110,6 @@ module Metanorma
       end
     end
 
-    class ToCInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :toc
-      parse_content_as :text
-      using_format :short
-
-      def process(parent, _target, attrs)
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-        content = CSV.parse_line(out).map do |x|
-          x.sub!(/^(["'])(.+)\1/, "\\2")
-          m = /^(.*?)(:\d+)?$/.match(x)
-          %{<toc-xpath depth='#{m[2]&.sub(':', '') || 1}'>#{m[1]}</toc-xpath>}
-        end.join
-        "<toc>#{content}</toc>"
-      end
-    end
-
     # inject ZWNJ to prevent Asciidoctor from attempting regex substitutions
     class PassInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
       use_dsl
@@ -194,32 +136,53 @@ module Metanorma
       end
     end
 
-    class StdLinkInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+    class SpanInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
       use_dsl
-      named :"std-link"
+      named :span
       parse_content_as :text
-      using_format :short
 
-      def process(parent, _target, attrs)
-        t = attrs["text"]
-        t = if /,/.match?(t)
-              t.sub(/,/, "%")
-            else
-              "#{t}%"
-            end
-        create_anchor(parent, "hidden=#{t}",
-                      type: :xref, target: "_#{UUIDTools::UUID.random_create}")
+      def process(parent, target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<span class="#{target}">#{out}</span>}
       end
     end
 
-    class SpanInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+    class NumberInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      include ::Metanorma::Standoc::Utils
+
       use_dsl
-      named :span
+      named :number
       parse_content_as :text
 
+      MATHML_NS = "http://www.w3.org/1998/Math/MathML".freeze
+
+      def unquote(str)
+        str.sub(/^(["'])(.+)\1$/, "\\2")
+      end
+
+      def format(attrs)
+        # a="," => "a=,"
+        quoted_csv_split(attrs || "", ",").map do |x|
+          m = /^(.+?)=(.+)?$/.match(x) or next
+          "#{m[1]}='#{m[2]}'"
+        end.join(",")
+      end
+
+      def number(text)
+        n = BigDecimal(text)
+        trailing_zeroes = 0
+        m = /\.[1-9]*(0+)/.match(text) and trailing_zeroes += m[1].size
+        n.to_s("E").sub("e", "0" * trailing_zeroes + "e")
+      end
+
       def process(parent, target, attrs)
         out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-        %{<span class="#{target}">#{out}</span>}
+        fmt = format(out)
+        fmt.empty? and fmt = "notation='basic'"
+        fmt = %( data-metanorma-numberformat="#{fmt}")
+        <<~OUTPUT
+          <stem type="MathML"><math xmlns='#{MATHML_NS}'><mn#{fmt}>#{number(target)}</mn></math></stem>
+        OUTPUT
       end
     end
   end

data/lib/metanorma/standoc/macros_link.rb

@@ -0,0 +1,81 @@
+module Metanorma
+  module Standoc
+    class IndexXrefInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :index
+
+      def preprocess_attrs(attrs)
+        ret = { primary: attrs[1], target: attrs[attrs.size] }
+        ret[:secondary] = attrs[2] if attrs.size > 2
+        ret[:tertiary] = attrs[3] if attrs.size > 3
+        ret
+      end
+
+      def validate(parent, target, attrs)
+        attrs.size > 1 && attrs.size < 5 and return true
+        e = "invalid index \"#{target}\" cross-reference: wrong number of " \
+            "attributes in `index:#{target}[#{attrs.values.join(',')}]`"
+        parent.converter.log.add("Crossreferences", parent, e, severity: 0)
+        false
+      end
+
+      def process(parent, target, attr)
+        validate(parent, target, attr) or return
+        args = preprocess_attrs(attr)
+        ret = "<index-xref also='#{target == 'also'}'>" \
+              "<primary>#{args[:primary]}</primary>"
+        ret += "<secondary>#{args[:secondary]}</secondary>" if args[:secondary]
+        ret += "<tertiary>#{args[:tertiary]}</tertiary>" if args[:tertiary]
+        ret + "<target>#{args[:target]}</target></index-xref>"
+      end
+    end
+
+    class IndexRangeInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :"index-range"
+      parse_content_as :text
+
+      def process(parent, target, attr)
+        text = attr["text"]
+        text = "((#{text}))" unless /^\(\(.+\)\)$/.match?(text)
+        out = parent.sub_macros(text)
+        out.sub("<index>", "<index to='#{target}'>")
+      end
+    end
+
+    class ToCInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :toc
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        content = CSV.parse_line(out).map do |x|
+          x.sub!(/^(["'])(.+)\1/, "\\2")
+          m = /^(.*?)(:\d+)?$/.match(x)
+          %{<toc-xpath depth='#{m[2]&.sub(':', '') || 1}'>#{m[1]}</toc-xpath>}
+        end.join
+        "<toc>#{content}</toc>"
+      end
+    end
+
+    class StdLinkInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :"std-link"
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        t = attrs["text"]
+        t = if /,/.match?(t)
+              t.sub(/,/, "%")
+            else
+              "#{t}%"
+            end
+        create_anchor(parent, "hidden=#{t}",
+                      type: :xref, target: "_#{UUIDTools::UUID.random_create}")
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/ref.rb

@@ -27,7 +27,7 @@ module Metanorma
       def isorefmatchescode(match, _item)
         code = analyse_ref_code(match[:code])
         yr = norm_year(match[:year])
-        { code: match[:code], year: yr, match: match,
+        { code: match[:code], year: yr, match:,
           title: match[:text], usrlbl: match[:usrlbl] || code[:usrlabel],
           analyse_code: code, lang: @lang || :all }
       end
@@ -47,7 +47,7 @@ module Metanorma
       def isorefmatches2code(match, _item)
         code = analyse_ref_code(match[:code])
         { code: match[:code], no_year: true, lang: @lang || :all,
-          note: match[:fn], year: nil, match: match, analyse_code: code,
+          note: match[:fn], year: nil, match:, analyse_code: code,
           title: match[:text], usrlbl: match[:usrlbl] || code[:usrlabel] }
       end
 
@@ -77,7 +77,7 @@ module Metanorma
         code = analyse_ref_code(match[:code])
         yr = norm_year(match[:year])
         hasyr = !yr.nil? && yr != "--"
-        { code: match[:code], match: match, yr: yr, hasyr: hasyr,
+        { code: match[:code], match:, yr:, hasyr:,
           year: hasyr ? yr : nil, lang: @lang || :all,
           all_parts: true, no_year: yr == "--",
           title: match[:text], usrlbl: match[:usrlbl] || code[:usrlabel] }
@@ -162,11 +162,11 @@ module Metanorma
       def refitem1code(_item, match)
         code = analyse_ref_code(match[:code])
         ((code[:id] && code[:numeric]) || code[:nofetch]) and
-          return { code: nil, match: match, analyse_code: code,
+          return { code: nil, match:, analyse_code: code,
                    hidden: code[:hidden] }
         { code: code[:id], analyse_code: code, localfile: code[:localfile],
           year: (m = refitem1yr(code[:id])) ? m[:year] : nil,
-          title: match[:text], match: match, hidden: code[:hidden],
+          title: match[:text], match:, hidden: code[:hidden],
           usrlbl: match[:usrlbl] || code[:usrlabel], lang: @lang || :all }
       end
 
@@ -187,29 +187,26 @@ module Metanorma
       ISO_REF =
         %r{^<ref\sid="(?<anchor>[^"]+)">
       \[(?<usrlbl>\([^)]+\))?(?<code>(?:ISO|IEC)[^0-9]*\s[0-9-]+|IEV)
-      (?::(?<year>[0-9][0-9-]+))?\]</ref>,?\s*(?<text>.*)$}xm.freeze
+      (?::(?<year>[0-9][0-9-]+))?\]</ref>,?\s*(?<text>.*)$}xm
 
       ISO_REF_NO_YEAR =
         %r{^<ref\sid="(?<anchor>[^"]+)">
       \[(?<usrlbl>\([^)]+\))?(?<code>(?:ISO|IEC)[^0-9]*\s[0-9-]+):
-      (?:--|&\#821[12];)\]</ref>,?\s*
+      (?:--|–|—|&\#821[12];)\]</ref>,?\s*
         (?:<fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>)?,?\s?(?<text>.*)$}xm
-          .freeze
 
       ISO_REF_ALL_PARTS =
         %r{^<ref\sid="(?<anchor>[^"]+)">
       \[(?<usrlbl>\([^)]+\))?(?<code>(?:ISO|IEC)[^0-9]*\s[0-9]+)
-      (?::(?<year>--|&\#821[12];|[0-9][0-9-]+))?\s
+      (?::(?<year>--|–|—|&\#821[12];|[0-9][0-9-]+))?\s
       \(all\sparts\)\]</ref>,?\s*
-        (?:<fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>,?\s?)?(?<text>.*)$}xm.freeze
+        (?:<fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>,?\s?)?(?<text>.*)$}xm
 
       NON_ISO_REF = %r{^<ref\sid="(?<anchor>[^"]+)">
       \[(?<usrlbl>\([^)]+\))?(?<code>.+?)\]</ref>,?\s*(?<text>.*)$}xm
-        .freeze
 
       NON_ISO_REF1 = %r{^<ref\sid="(?<anchor>[^"]+)">
       (?<usrlbl>\([^)]+\))?(?<code>.+?)</ref>,?\s*(?<text>.*)$}xm
-        .freeze
 
       def reference1_matches(item)
         matched = ISO_REF.match item

data/lib/metanorma/standoc/ref_queue.rb

@@ -122,16 +122,14 @@ module Metanorma
       end
 
       def local_ievcache_name(cachename)
-        return nil if cachename.nil?
-
+        cachename.nil? and return nil
         cachename += "_iev" unless cachename.empty?
         cachename = "iev" if cachename.empty?
         "#{cachename}/cache"
       end
 
       def fetch_ref(xml, code, year, **opts)
-        return nil if opts[:no_year]
-
+        opts[:no_year] and return nil
         code = code.sub(/^\([^)]+\)/, "")
         hit = fetch_ref1(code, year, opts) or return nil
         xml.parent.add_child(smart_render_xml(hit, code, opts))

data/lib/metanorma/standoc/ref_utility.rb

@@ -200,8 +200,8 @@ module Metanorma
 
       MALFORMED_REF = <<~REF.freeze
         no anchor on reference, markup may be malformed: see
-        https://www.metanorma.com/author/topics/document-format/bibliography/ ,
-        https://www.metanorma.com/author/iso/topics/markup/#bibliographies
+        https://www.metanorma.org/author/topics/sections/bibliography/ ,
+        https://www.metanorma.org/author/iso/topics/markup/#bibliographies
       REF
 
       def ref_normalise(ref)

data/lib/metanorma/standoc/section.rb

@@ -16,8 +16,7 @@ module Metanorma
             .gsub(%r{<index>.*?</index>}m, "")
             .gsub(%r{<fn[^>]*>.*?</fn>}m, "")
             .gsub(/<[^>]+>/, "")
-            .strip.downcase
-            .sub(/\.$/, "")
+            .strip.downcase.sub(/\.$/, "")
       end
 
       def sectiontype(node, level = true)
@@ -41,7 +40,8 @@ module Metanorma
           "terms, definitions and abbreviated terms"
           "terms and definitions"
         when "symbols and abbreviated terms",
-          "symbols", "abbreviated terms", "abbreviations"
+          "symbols", "abbreviated terms", "abbreviations",
+          "symbols and abbreviations"
           "symbols and abbreviated terms"
         when "acknowledgements", "acknowledgments"
           "acknowledgements"

data/lib/metanorma/standoc/terms.rb

@@ -170,7 +170,7 @@ module Metanorma
             seen_xref = Nokogiri::XML.fragment(matched[:xref])
             add_term_source(node, xml_t, seen_xref, matched)
           end
-        end.join("\n")
+        end.join("")
       end
 
       def termdefinition(node)
@@ -178,7 +178,7 @@ module Metanorma
           xml.definition **attr_code(type: node.attr("type")) do |d|
             d << node.content
           end
-        end.join("\n")
+        end.join("")
       end
     end
   end

data/lib/metanorma/standoc/utils.rb

@@ -17,8 +17,8 @@ module Metanorma
         nil
       end
 
-      def noko(&block)
-        Metanorma::Utils::noko(@script, &block)
+      def noko(&)
+        Metanorma::Utils::noko(@script, &)
       end
 
       def attr_code(attributes)
@@ -30,6 +30,26 @@ module Metanorma
           .map { |x| @c.encode(x, :basic, :hexadecimal) }
       end
 
+      def quoted_csv_split(text, delim = ",", eql = "=")
+        # quoted strings: key="va,lue",
+        c = HTMLEntities.new
+        text = c.decode(text).gsub(/([a-zA-Z_]+)#{eql}(["'])(.+?)\2/,
+                                   %("\\1#{eql}\\3"))
+        Metanorma::Utils::csv_split(text, delim)
+          .map do |x|
+            c.encode(x.sub(/^(["'])(.+)\1$/, "\\2"), :basic, :hexadecimal)
+          end
+      end
+
+      def kv_parse(text, delim = ",", eql = "=")
+        text or return {}
+        c = HTMLEntities.new
+        quoted_csv_split(text, delim).each_with_object({}) do |k, m|
+          x = k.split(eql, 2)
+          m[x[0]] = c.decode(x[1])
+        end
+      end
+
       def wrap_in_para(node, out)
         Metanorma::Utils::wrap_in_para(node, out)
       end

data/lib/metanorma/standoc/validate.rb

@@ -48,7 +48,6 @@ module Metanorma
       def mathml_sanitise(math)
         math.to_xml(encoding: "US-ASCII").gsub(/ xmlns=["'][^"']+["']/, "")
           .gsub(%r{<[^:/>]+:}, "<").gsub(%r{</[^:/>]+:}, "</")
-        # .gsub(/&#([^;]+);/) { |x| "&#x#{$1.to_i.to_s(16)};" }
       end
 
       def math_validate_error(math, elem, error)
@@ -133,7 +132,7 @@ module Metanorma
         doc.xpath(WILDCARD_ATTRS, "m" => SVG_NS).each do |n|
           n.elements.each do |e|
             e.traverse do |e1|
-              e1.element? and e1.each { |k, _v| e1.delete(k) }
+              e1.element? and e1.each { |k, _v| e1.delete(k) } # rubocop:disable Style/HashEachMethods
             end
           end
         end
@@ -143,6 +142,7 @@ module Metanorma
 
       def image_validate(doc)
         image_exists(doc)
+        image_toobig(doc)
         png_validate(doc)
       end
 
@@ -183,6 +183,18 @@ module Metanorma
                  "Corrupt PNG image detected: #{e.message}")
       end
 
+      TOO_BIG_IMG_ERR = <<~ERR.freeze
+        Image too large for Data URI encoding: disable Data URI encoding (`:data-uri-image: false`), or set `:data-uri-maxsize: 0`
+      ERR
+
+      def image_toobig(doc)
+        @dataurimaxsize.zero? and return
+        doc.xpath("//image").each do |i|
+          i["src"].size > @dataurimaxsize and
+            @log.add("Images", i.parent, TOO_BIG_IMG_ERR, severity: 0)
+        end
+      end
+
       def validate(doc)
         content_validate(doc)
         schema_validate(formattedstr_strip(doc.dup),