metanorma-standoc 1.4.4 → 1.6.0

data/lib/asciidoctor/standoc/ref.rb

@@ -42,8 +42,7 @@ module Asciidoctor
 
       def docid(t, code)
         type, code1 = /^\[\d+\]$|^\([^)]+\).*$/.match(code) ?
-          ["metanorma", mn_code(code)] :
-          @bibdb&.docid_type(code) || [nil, code]
+          ["metanorma", mn_code(code)] : @bibdb&.docid_type(code) || [nil, code]
         code1.sub!(/^nofetch\((.+)\)$/, "\\1")
         t.docidentifier **attr_code(type: type) do |d|
           d << code1
@@ -61,10 +60,10 @@ module Asciidoctor
       end
 
       def isorefrender1(t, m, yr, allp = "")
-          t.title(**plaintxt) { |i| i << ref_normalise(m[:text]) }
-          docid(t, m[:usrlbl]) if m[:usrlbl]
-          docid(t, id_and_year(m[:code], yr) + allp)
-          docnumber(t, m[:code])
+        t.title(**plaintxt) { |i| i << ref_normalise(m[:text]) }
+        docid(t, m[:usrlbl]) if m[:usrlbl]
+        docid(t, id_and_year(m[:code], yr) + allp)
+        docnumber(t, m[:code])
       end
 
       def isorefmatches(xml, m)
@@ -84,6 +83,10 @@ module Asciidoctor
         ref = fetch_ref xml, m[:code], nil, no_year: true, note: m[:fn],
           title: m[:text], usrlbl: m[:usrlbl]
         return use_my_anchor(ref, m[:anchor]) if ref
+        isorefmatches2_1(xml, m)
+      end
+
+      def isorefmatches2_1(xml, m)
         xml.bibitem **attr_code(ref_attributes(m)) do |t|
           isorefrender1(t, m, "--")
           t.date **{ type: "published" } do |d|
@@ -106,15 +109,17 @@ module Asciidoctor
 
       def isorefmatches3(xml, m)
         yr = norm_year(m[:year])
-        hasyr =  m.names.include?("year") && yr != "--"
-        noyr =  m.names.include?("year") && yr == "--"
-        ref = fetch_ref xml, m[:code], hasyr ? yr : nil,
-          all_parts: true, no_year: noyr, text: m[:text], usrlbl: m[:usrlbl]
+        hasyr = !yr.nil? && yr != "--"
+        ref = fetch_ref xml, m[:code], hasyr ? yr : nil, all_parts: true, 
+          no_year: yr == "--", text: m[:text], usrlbl: m[:usrlbl]
         return use_my_anchor(ref, m[:anchor]) if ref
+        isorefmatches3_1(xml, m, yr, hasyr, ref)
+      end
 
+      def isorefmatches3_1(xml, m, yr, hasyr, ref)
         xml.bibitem(**attr_code(ref_attributes(m))) do |t|
           isorefrender1(t, m, yr, " (all parts)")
-          conditional_date(t, m, noyr)
+          conditional_date(t, m, yr == "--")
           iso_publisher(t, m[:code])
           m.names.include?("fn") && m[:fn] and
             t.note(**plaintxt.merge(type: "ISO DATE")) { |p| p << "#{m[:fn]}" }
@@ -146,43 +151,32 @@ module Asciidoctor
       end
 
       MALFORMED_REF = "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".freeze
+        "https://www.metanorma.com/author/topics/document-format/"\
+        "bibliography/ , https://www.metanorma.com/author/iso/topics/markup/"\
+        "#bibliographies".freeze
 
       def analyse_ref_nofetch(ret)
-        if m = /^nofetch\((?<id>.+)\)$/.match(ret[:id])
-          ret[:id] = m[:id]
-          ret[:nofetch] = true
-        end
-        ret
+        return ret unless m = /^nofetch\((?<id>.+)\)$/.match(ret[:id])
+        ret.merge(id: m[:id], nofetch: true)
       end
-     
+
       def analyse_ref_repo_path(ret)
-         if m = /^(?<type>repo|path):\((?<key>[^,]+),(?<id>.+)\)$/.match(ret[:id])
-          ret[:id] = m[:id]
-          ret[:type] = m[:type]
-          ret[:key] = m[:key]
-          ret[:nofetch] = true
-        end
-         ret
+        return ret unless m =
+          /^(?<type>repo|path):\((?<key>[^,]+),(?<id>.+)\)$/.match(ret[:id])
+        ret.merge(id: m[:id], type: m[:type], key: m[:key], nofetch: true)
       end
 
       def analyse_ref_numeric(ret)
-        if /^\d+$/.match(ret[:id])
-          ret[:numeric] = true
-        end
-        ret
+        return ret unless /^\d+$/.match(ret[:id])
+        ret.merge(numeric: true)
       end
 
       # ref id = (usrlbl)code[:-]year
-      # code = nofetch(code) | (repo|path):(key,code) | \[? number \]? | identifier
+      # code = nofetch(code) | (repo|path):(key,code) | \[? number \]? | ident
       def analyse_ref_code(code)
         ret = {id: code}
         return ret if code.nil? || code.empty?
-        ret = analyse_ref_nofetch(ret)
-        ret = analyse_ref_repo_path(ret)
-        ret = analyse_ref_numeric(ret)
-        ret
+        analyse_ref_nofetch(analyse_ref_repo_path(analyse_ref_numeric(ret)))
       end
 
       # TODO: alternative where only title is available
@@ -191,6 +185,10 @@ module Asciidoctor
           @log.add("AsciiDoc Input", node, "#{MALFORMED_REF}: #{item}")
           return
         end
+        refitem1(xml, item, m)
+      end
+
+      def refitem1(xml, item, m)
         code = analyse_ref_code(m[:code])
         unless code[:id] && code[:numeric] || code[:nofetch]
           ref = fetch_ref xml, code[:id],
@@ -215,23 +213,25 @@ module Asciidoctor
         (?<text>.*)$}xm
 
         ISO_REF_NO_YEAR = %r{^<ref\sid="(?<anchor>[^"]+)">
-      \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9-]+):(--|\&\#821[12]\;)\]</ref>,?\s*
+      \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9-]+):
+      (--|\&\#821[12]\;)\]</ref>,?\s*
         (<fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>)?,?\s?(?<text>.*)$}xm
 
         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
+        \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9]+)
+        (:(?<year>--|\&\#821[12]\;|[0-9][0-9-]+))?\s
         \(all\sparts\)\]</ref>,?\s*
           (<fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>,?\s?)?(?<text>.*)$}xm
 
           NON_ISO_REF = %r{^<ref\sid="(?<anchor>[^"]+)">
-        \[(?<usrlbl>\([^)]+\))?(?<code>[^\]]+?)([:-](?<year>(19|20)[0-9][0-9]))?\]</ref>,?\s*
-          (?<text>.*)$}xm
-
-          def reference1_matches(item)
-            matched = ISO_REF.match item
-            matched2 = ISO_REF_NO_YEAR.match item
-            matched3 = ISO_REF_ALL_PARTS.match item
-            [matched, matched2, matched3]
+        \[(?<usrlbl>\([^)]+\))?(?<code>[^\]]+?)
+        ([:-](?<year>(19|20)[0-9][0-9]))?\]</ref>,?\s*(?<text>.*)$}xm
+
+        def reference1_matches(item)
+          matched = ISO_REF.match item
+          matched2 = ISO_REF_NO_YEAR.match item
+          matched3 = ISO_REF_ALL_PARTS.match item
+          [matched, matched2, matched3]
         end
 
         def reference1(node, item, xml)

data/lib/asciidoctor/standoc/section.rb

@@ -13,9 +13,13 @@ module Asciidoctor
         @term_def
       end
 
-      def sectiontype(node, level = true)
-        ret = node&.attr("heading")&.downcase ||
+      def sectiontype1(node)
+        node&.attr("heading")&.downcase ||
           node.title.gsub(/<[^>]+>/, "").downcase
+      end
+
+      def sectiontype(node, level = true)
+        ret = sectiontype1(node)
         ret1 = sectiontype_streamline(ret)
         return ret1 if "symbols and abbreviated terms" == ret1
         return nil unless !level || node.level == 1
@@ -42,7 +46,7 @@ module Asciidoctor
       end
 
       def section_attributes(node)
-        { id: Utils::anchor_or_uuid(node),
+        ret = { id: Utils::anchor_or_uuid(node),
           language: node.attributes["language"],
           script: node.attributes["script"],
           annex: (
@@ -51,8 +55,13 @@ module Asciidoctor
           ),
           preface: (
             (node.role == "preface" || node.attr("style") == "preface") ?
-            true : nil),
-        }
+            true : nil) }
+        return ret unless node.attributes["change"]
+        ret.merge(change: node.attributes["change"],
+                  path: node.attributes["path"],
+                  path_end: node.attributes["path_end"],
+                  title: node.attributes["title"],
+        )
       end
 
       def section(node)
@@ -61,16 +70,18 @@ module Asciidoctor
           case sectiontype(node)
           when "introduction" then introduction_parse(a, xml, node)
           when "foreword" then foreword_parse(a, xml, node)
+          when "scope" then scope_parse(a, xml, node)
           when "normative references" then norm_ref_parse(a, xml, node)
           when "terms and definitions"
             @term_def = true
             term_def_parse(a, xml, node, true)
             @term_def = false
           when "symbols and abbreviated terms"
-            symbols_parse(a, xml, node)
+            symbols_parse(symbols_attrs(node, a), xml, node)
           when "acknowledgements"
             acknowledgements_parse(a, xml, node)
-          when "bibliography" then bibliography_parse(a, xml, node)
+          when "bibliography" 
+            bibliography_parse(a, xml, node)
           else
             if @term_def then term_def_subclause_parse(a, xml, node)
             elsif @definitions then symbols_parse(a, xml, node)
@@ -106,7 +117,7 @@ module Asciidoctor
       def preamble(node)
         noko do |xml|
           xml.foreword **attr_code(section_attributes(node)) do |xml_abstract|
-            xml_abstract.title { |t| t << (node.blocks[0].title || "Foreword") }
+            xml_abstract.title { |t| t << (node.blocks[0].title || @i18n.foreword) }
             content = node.content
             xml_abstract << content
           end
@@ -119,6 +130,10 @@ module Asciidoctor
         end
       end
 
+      def scope_parse(attrs, xml, node)
+        clause_parse(attrs.merge(type: "scope"), xml, node)
+      end
+
       def clause_parse(attrs, xml, node)
         attrs["inline-header".to_sym] = node.option? "inline-header"
         attrs[:bibitem] = true if node.option? "bibitem"
@@ -140,9 +155,19 @@ module Asciidoctor
       end
 
       def nonterm_symbols_parse(attrs, xml, node)
+        defs = @definitions
         @definitions = false
         clause_parse(attrs, xml, node)
-        @definitions = true
+        @definitions = defs
+      end
+
+      def symbols_attrs(node, a)
+        case sectiontype1(node)
+        when "symbols" then a.merge(type: "symbols")
+        when "abbreviated terms", "abbreviations" then a.merge(type: "abbreviated_terms")
+        else
+          a
+        end
       end
 
       def symbols_parse(attr, xml, node)
@@ -159,13 +184,11 @@ module Asciidoctor
         end
       end
 
-      SYMBOLS_TITLES = ["symbols and abbreviated terms", "symbols",
-                        "abbreviated terms"].freeze
-
       def nonterm_term_def_subclause_parse(attrs, xml, node)
+        defs = @term_def
         @term_def = false
         clause_parse(attrs, xml, node)
-        @term_def = true
+        @term_def = defs
       end
 
       # subclause contains subclauses
@@ -190,23 +213,9 @@ module Asciidoctor
         end
       end
 
-      def term_def_title(toplevel, node)
-        return node.title unless toplevel
-        sub = node.find_by(context: :section) do |s|
-          SYMBOLS_TITLES.include? s.title.downcase
-        end
-        return "Terms and definitions" if sub.empty?
-        sym = /symbol/i.match(node.title)
-        abbrev = /abbreviat/i.match(node.title)
-        sym && abbrev and return "Terms, definitions, symbols and abbreviated terms"
-        sym and return "Terms, definitions and symbols"
-        abbrev and return "Terms, definitions and abbreviated terms"
-        "Terms, definitions, symbols and abbreviated terms"
-      end
-
       def term_def_parse(attrs, xml, node, toplevel)
         xml.terms **attr_code(attrs) do |section|
-          section.title { |t| t << term_def_title(toplevel, node) }
+          section.title { |t| t << node.title }
           (s = node.attr("source")) && s.split(/,/).each do |s1|
             section.termdocsource(nil, **attr_code(bibitemid: s1))
           end
@@ -216,7 +225,7 @@ module Asciidoctor
 
       def introduction_parse(attrs, xml, node)
         xml.introduction **attr_code(attrs) do |xml_section|
-          xml_section.title { |t| t << "Introduction" }
+          xml_section.title { |t| t << @i18n.introduction }
           content = node.content
           xml_section << content
         end
@@ -232,7 +241,7 @@ module Asciidoctor
 
       def acknowledgements_parse(attrs, xml, node)
         xml.acknowledgements **attr_code(attrs) do |xml_section|
-          xml_section.title { |t| t << node.title || "Acknowledgements" }
+          xml_section.title { |t| t << node.title || @i18n.acknowledgements }
           content = node.content
           xml_section << content
         end

data/lib/asciidoctor/standoc/table.rb

@@ -45,8 +45,9 @@ module Asciidoctor
       end
 
       def table_cell(c, xml_tr, tblsec)
-        cell_attributes = { id: c.id, colspan: c.colspan,
-                            rowspan: c.rowspan, align: c.attr("halign") }
+        cell_attributes =
+          { id: c.id, colspan: c.colspan, valign: c.attr("valign"),
+            rowspan: c.rowspan, align: c.attr("halign") }
         cell_tag = "td"
         cell_tag = "th" if tblsec == :head || c.style == :header
         xml_tr.send cell_tag, **attr_code(cell_attributes) do |thd|

data/lib/asciidoctor/standoc/utils.rb

@@ -128,7 +128,8 @@ module Asciidoctor
         ::Nokogiri::XML::Builder.with fragment, &block
         fragment.to_xml(encoding: "US-ASCII", indent: 0).lines.map do |l|
           l.gsub(/>\n$/, ">").gsub(/\s*\n$/m, " ").gsub("–", "\u0096").
-            gsub("—", "\u0097")
+            gsub("—", "\u0097").gsub("–", "\u0096").
+            gsub("—", "\u0097")
         end
       end
 
@@ -173,6 +174,22 @@ module Asciidoctor
 
       SUBCLAUSE_XPATH = "//clause[not(parent::sections)]"\
         "[not(ancestor::boilerplate)]".freeze
+
+       def isodoc(lang, script, i18nyaml = nil)
+        conv = html_converter(EmptyAttr.new)
+        i18n = conv.i18n_init(lang, script, i18nyaml)
+        conv.metadata_init(lang, script, i18n)
+        conv
+      end
+
+       class EmptyAttr
+        def attr(_x)
+          nil
+        end
+        def attributes
+          {}
+        end
+      end
     end
   end
 end

data/lib/asciidoctor/standoc/validate.rb

@@ -8,7 +8,8 @@ module Asciidoctor
   module Standoc
     module Validate
 
-      SOURCELOCALITY = "./termsource/origin//locality[@type = 'clause']/referenceFrom".freeze
+      SOURCELOCALITY = "./termsource/origin//locality[@type = 'clause']/"\
+        "referenceFrom".freeze
 
       def init_iev
         return nil if @no_isobib
@@ -19,13 +20,16 @@ module Asciidoctor
 
       def iev_validate(xmldoc)
         xmldoc.xpath("//term").each do |t|
-          /^IEC 60050-/.match(t&.at("./termsource/origin/@citeas")&.text) or next
-          pref = t.xpath("./preferred").inject([]) { |m, x| m << x&.text&.downcase }
-          locality = t.xpath(SOURCELOCALITY)&.text or next
+          /^IEC 60050-/.match(t&.at("./termsource/origin/@citeas")&.text) &&
+            loc = t.xpath(SOURCELOCALITY)&.text or next
           @iev = init_iev or return
-          iev = @iev.fetch(locality, xmldoc&.at("//language")&.text || "en") or next
+          iev = @iev.fetch(loc, xmldoc&.at("//language")&.text || "en") or next
+          pref = t.xpath("./preferred").inject([]) do |m, x|
+            m << x&.text&.downcase
+          end
           pref.include?(iev.downcase) or
-          @log.add("Bibliography", t, %(Term "#{pref[0]}" does not match IEV #{locality} "#{iev}"))
+            @log.add("Bibliography", t, %(Term "#{pref[0]}" does not match ) +
+                     %(IEV #{loc} "#{iev}"))
         end
       end
 
@@ -35,20 +39,26 @@ module Asciidoctor
         iev_validate(doc.root)
       end
 
+      def repeat_id_validate1(ids, x)
+        if ids[x["id"]]
+          @log.add("Anchors", x, "Anchor #{x['id']} has already been used "\
+                   "at line #{ids[x['id']]}")
+          raise StandardError.new "Error: multiple instances of same ID"
+        else
+          ids[x["id"]] = x.line
+        end
+        ids
+      end
+
       def repeat_id_validate(doc)
         ids = {}
-        crash = false
-        doc.xpath("//*[@id]").each do |x|
-          if ids[x["id"]]
-            @log.add("Anchors", x, "Anchor #{x['id']} has already been used at line #{ids[x['id']]}")
-            crash = true
-          else
-            ids[x["id"]] = x.line
+        begin
+          doc.xpath("//*[@id]").each do |x|
+            ids = repeat_id_validate1(ids, x)
           end
-        end
-        if crash
+        rescue StandardError => e
           clean_exit
-          abort("Cannot deal with multiple instances of same ID")
+          abort(e.message)
         end
       end
 
@@ -59,8 +69,10 @@ module Asciidoctor
             f.close
             errors = Jing.new(schema).validate(f.path)
             warn "Syntax Valid!" if errors.none?
-            errors.each do |error|
-              @log.add("Syntax", "XML Line #{"%06d" % error[:line]}:#{error[:column]}", error[:message])
+            errors.each do |e|
+              @log.add("Metanorma XML Syntax",
+                       "XML Line #{"%06d" % e[:line]}:#{e[:column]}",
+                       e[:message])
             end
           rescue Jing::Error => e
             clean_exit

data/lib/asciidoctor/standoc/validate_section.rb

@@ -22,7 +22,7 @@ module Asciidoctor
       def style_warning(node, msg, text = nil)
         w = msg
         w += ": #{text}" if text
-        @log.add("Style Warning", node, w)
+        @log.add("Metanorma XML Style Warning", node, w)
       end
 
       def asset_title_style(root)