metanorma-standoc 1.11.0.1 → 1.11.4

data/lib/asciidoctor/standoc/ref.rb

@@ -22,37 +22,44 @@ module Asciidoctor
         { id: match[:anchor], type: "standard" }
       end
 
-      def isorefrender1(bib, match, yr, allp = "")
+      def isorefrender1(bib, match, year, allp = "")
         bib.title(**plaintxt) { |i| i << ref_normalise(match[:text]) }
         docid(bib, match[:usrlbl]) if match[:usrlbl]
-        docid(bib, id_and_year(match[:code], yr) + allp)
+        docid(bib, id_and_year(match[:code], year) + allp)
         docnumber(bib, match[:code])
       end
 
-      def isorefmatches(xml, match)
+      def isorefmatchescode(match)
         yr = norm_year(match[:year])
-        ref = fetch_ref xml, match[:code], yr,
-                        title: match[:text], usrlbl: match[:usrlbl],
-                        lang: (@lang || :all)
-        return use_my_anchor(ref, match[:anchor]) if ref
-
-        xml.bibitem **attr_code(ref_attributes(match)) do |t|
-          isorefrender1(t, match, yr)
-          yr and t.date **{ type: "published" } do |d|
-            set_date_range(d, yr)
+        { code: match[:code], year: yr, match: match,
+          title: match[:text], usrlbl: match[:usrlbl],
+          lang: (@lang || :all) }
+      end
+
+      def isorefmatchesout(item, xml)
+        if item[:doc] then use_retrieved_relaton(item, xml)
+        else
+          xml.bibitem **attr_code(ref_attributes(item[:ref][:match])) do |t|
+            isorefrender1(t, item[:ref][:match], item[:ref][:year])
+            item[:ref][:year] and t.date **{ type: "published" } do |d|
+              set_date_range(d, item[:ref][:year])
+            end
+            iso_publisher(t, item[:ref][:match][:code])
           end
-          iso_publisher(t, match[:code])
         end
       end
 
-      def isorefmatches2(xml, match)
-        ref = fetch_ref xml, match[:code], nil,
-                        no_year: true, note: match[:fn],
-                        title: match[:text], usrlbl: match[:usrlbl],
-                        lang: (@lang || :all)
-        return use_my_anchor(ref, match[:anchor]) if ref
+      def isorefmatches2code(match)
+        { code: match[:code], no_year: true,
+          note: match[:fn], year: nil, match: match,
+          title: match[:text], usrlbl: match[:usrlbl],
+          lang: (@lang || :all) }
+      end
 
-        isorefmatches2_1(xml, match)
+      def isorefmatches2out(item, xml)
+        if item[:doc] then use_retrieved_relaton(item, xml)
+        else isorefmatches2_1(xml, item[:ref][:match])
+        end
       end
 
       def isorefmatches2_1(xml, match)
@@ -70,16 +77,22 @@ module Asciidoctor
         end
       end
 
-      def isorefmatches3(xml, match)
+      def isorefmatches3code(match)
         yr = norm_year(match[:year])
         hasyr = !yr.nil? && yr != "--"
-        ref = fetch_ref(xml, match[:code], hasyr ? yr : nil,
-                        all_parts: true, no_year: yr == "--",
-                        text: match[:text], usrlbl: match[:usrlbl],
-                        lang: (@lang || :all))
-        return use_my_anchor(ref, match[:anchor]) if ref
-
-        isorefmatches3_1(xml, match, yr, hasyr, ref)
+        { code: match[:code], match: match, yr: yr, hasyr: hasyr,
+          year: hasyr ? yr : nil,
+          all_parts: true, no_year: yr == "--",
+          text: match[:text], usrlbl: match[:usrlbl],
+          lang: (@lang || :all) }
+      end
+
+      def isorefmatches3out(item, xml)
+        if item[:doc] then use_retrieved_relaton(item, xml)
+        else
+          isorefmatches3_1(xml, item[:ref][:match], item[:ref][:yr],
+                           item[:ref][:hasyr], item[:doc])
+        end
       end
 
       def isorefmatches3_1(xml, match, yr, _hasyr, _ref)
@@ -120,56 +133,34 @@ 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
-
-      def analyse_ref_nofetch(ret)
-        return ret unless m = /^nofetch\((?<id>.+)\)$/.match(ret[:id])
-
-        ret.merge(id: m[:id], nofetch: true)
-      end
-
-      def analyse_ref_repo_path(ret)
-        return ret unless m =
-                            /^(?<type>repo|path):\((?<key>[^,]+),?(?<id>.*)\)$/.match(ret[:id])
-
-        id = m[:id].empty? ? m[:key].sub(%r{^[^/]+/}, "") : m[:id]
-        ret.merge(id: id, type: m[:type], key: m[:key], nofetch: true)
-      end
-
-      def analyse_ref_numeric(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 \]? | ident
-      def analyse_ref_code(code)
-        ret = { id: code }
-        return ret if code.blank?
-
-        analyse_ref_nofetch(analyse_ref_repo_path(analyse_ref_numeric(ret)))
-      end
+                      "https://www.metanorma.com/author/topics/document-format/bibliography/ , "\
+                      "https://www.metanorma.com/author/iso/topics/markup/#bibliographies".freeze
 
       # TODO: alternative where only title is available
-      def refitem(xml, item, node)
-        m = NON_ISO_REF.match(item) and return refitem1(xml, item, m)
+      def refitemcode(item, node)
+        m = NON_ISO_REF.match(item) and return refitem1code(item, m)
         @log.add("AsciiDoc Input", node, "#{MALFORMED_REF}: #{item}")
-        nil
+        {}
       end
 
-      def refitem1(xml, _item, match)
+      def refitem1code(_item, match)
         code = analyse_ref_code(match[:code])
-        unless code[:id] && code[:numeric] || code[:nofetch]
-          ref = fetch_ref(xml, code[:id],
-                          match.names.include?("year") ? match[:year] : nil,
-                          title: match[:text],
-                          usrlbl: match[:usrlbl], lang: (@lang || :all)) and
-            return use_my_anchor(ref, match[:anchor])
+        if (code[:id] && code[:numeric]) || code[:nofetch]
+          { code: nil, match: match, analyse_code: code }
+        else
+          { code: code[:id], analyse_code: code,
+            year: match.names.include?("year") ? match[:year] : nil,
+            title: match[:text], match: match,
+            usrlbl: match[:usrlbl], lang: (@lang || :all) }
         end
+      end
+
+      def refitemout(item, xml)
+        return nil if item[:ref][:match].nil?
 
-        refitem_render(xml, match, code)
+        item[:doc] or return refitem_render(xml, item[:ref][:match],
+                                            item[:ref][:analyse_code])
+        use_retrieved_relaton(item, xml)
       end
 
       def ref_normalise(ref)
@@ -211,15 +202,50 @@ module Asciidoctor
         [matched, matched2, matched3]
       end
 
-      def reference1(node, item, xml)
+      def reference1code(item, node)
         matched, matched2, matched3 = reference1_matches(item)
         if matched3.nil? && matched2.nil? && matched.nil?
-          refitem(xml, item, node)
-        elsif !matched.nil? then isorefmatches(xml, matched)
-        elsif !matched2.nil? then isorefmatches2(xml, matched2)
-        elsif !matched3.nil? then isorefmatches3(xml, matched3)
+          refitemcode(item, node).merge(process: 0)
+        elsif !matched.nil? then isorefmatchescode(matched).merge(process: 1)
+        elsif !matched2.nil? then isorefmatches2code(matched2).merge(process: 2)
+        elsif !matched3.nil? then isorefmatches3code(matched3).merge(process: 3)
         end
       end
+
+      def reference1out(item, xml)
+        case item[:ref][:process]
+        when 0 then refitemout(item, xml)
+        when 1 then isorefmatchesout(item, xml)
+        when 2 then isorefmatches2out(item, xml)
+        when 3 then isorefmatches3out(item, xml)
+        end
+      end
+
+      def reference_preproc(node)
+        refs = node.items.each_with_object([]) do |b, m|
+          m << reference1code(b.text, node)
+        end
+        results = refs.each_with_index.with_object(Queue.new) do |(ref, i), res|
+          fetch_ref_async(ref.merge(ord: i), i, res)
+        end
+        [refs, results]
+      end
+
+      def reference(node)
+        refs, results = reference_preproc(node)
+        noko do |xml|
+          ret = refs.each.with_object([]) do |_, m|
+            ref, i, doc = results.pop
+            m[i.to_i] = { ref: ref }
+            if doc.is_a?(RelatonBib::RequestError)
+              @log.add("Bibliography", nil, "Could not retrieve #{ref[:code]}: "\
+                                            "no access to online site")
+            else m[i.to_i][:doc] = doc
+            end
+          end
+          ret.each { |b| reference1out(b, xml) }
+        end.join
+      end
     end
   end
 end

data/lib/asciidoctor/standoc/ref_date_id.rb

@@ -26,7 +26,7 @@ module Asciidoctor
       def conditional_date(bib, match, noyr)
         if match.names.include?("year") && !match[:year].nil?
           bib.date(**{ type: "published" }) do |d|
-            noyr and d.on "--" or set_date_range(d, norm_year(match[:year]))
+            (noyr and d.on "--") or set_date_range(d, norm_year(match[:year]))
           end
         end
       end
@@ -57,6 +57,35 @@ module Asciidoctor
       def mn_code(code)
         code.sub(/^\(/, "[").sub(/\).*$/, "]").sub(/^nofetch\((.+)\)$/, "\\1")
       end
+
+      def analyse_ref_nofetch(ret)
+        return ret unless m = /^nofetch\((?<id>.+)\)$/.match(ret[:id])
+
+        ret.merge(id: m[:id], nofetch: true)
+      end
+
+      def analyse_ref_repo_path(ret)
+        return ret unless m =
+                            /^(?<type>repo|path):\((?<key>[^,]+),?(?<id>.*)\)$/.match(ret[:id])
+
+        id = m[:id].empty? ? m[:key].sub(%r{^[^/]+/}, "") : m[:id]
+        ret.merge(id: id, type: m[:type], key: m[:key], nofetch: true)
+      end
+
+      def analyse_ref_numeric(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 \]? | ident
+      def analyse_ref_code(code)
+        ret = { id: code }
+        return ret if code.blank?
+
+        analyse_ref_nofetch(analyse_ref_repo_path(analyse_ref_numeric(ret)))
+      end
     end
   end
 end

data/lib/asciidoctor/standoc/ref_sect.rb

@@ -9,12 +9,6 @@ module Asciidoctor
         @norm_ref
       end
 
-      def reference(node)
-        noko do |xml|
-          node.items.each { |item| reference1(node, item.text, xml) }
-        end.join
-      end
-
       def bibliography_parse(attrs, xml, node)
         x = biblio_prep(attrs, xml, node) and return x
         @biblio = true
@@ -86,6 +80,16 @@ module Asciidoctor
         nil
       end
 
+      def fetch_ref_async(ref, idx, res)
+        if ref[:code].nil? || ref[:no_year] || @bibdb.nil?
+          res << [ref, idx, nil]
+        else
+          @bibdb.fetch_async(ref[:code], ref[:year], ref) do |doc|
+            res << [ref, idx, doc]
+          end
+        end
+      end
+
       def emend_biblio(xml, code, title, usrlbl)
         unless xml.at("/bibitem/docidentifier[not(@type = 'DOI')][text()]")
           @log.add("Bibliography", nil,
@@ -112,6 +116,12 @@ module Asciidoctor
         xml.to_xml.sub(/<\?[^>]+>/, "")
       end
 
+      def use_retrieved_relaton(item, xml)
+        xml.parent.add_child(smart_render_xml(item[:doc], item[:ref][:code],
+                                              item[:ref]))
+        use_my_anchor(xml, item[:ref][:match][:anchor])
+      end
+
       def init_bib_caches(node)
         return if @no_isobib
 

data/lib/asciidoctor/standoc/render.rb

@@ -0,0 +1,115 @@
+module Asciidoctor
+  module Standoc
+    module Base
+      def html_extract_attributes(node)
+        {
+          script: node.attr("script"),
+          bodyfont: node.attr("body-font"),
+          headerfont: node.attr("header-font"),
+          monospacefont: node.attr("monospace-font"),
+          i18nyaml: node.attr("i18nyaml"),
+          scope: node.attr("scope"),
+          htmlstylesheet: node.attr("htmlstylesheet"),
+          htmlstylesheet_override: node.attr("htmlstylesheet-override"),
+          htmlcoverpage: node.attr("htmlcoverpage"),
+          htmlintropage: node.attr("htmlintropage"),
+          scripts: node.attr("scripts"),
+          scripts_override: node.attr("scripts-override"),
+          scripts_pdf: node.attr("scripts-pdf"),
+          datauriimage: node.attr("data-uri-image") != "false",
+          htmltoclevels: node.attr("htmltoclevels") || node.attr("toclevels"),
+          doctoclevels: node.attr("doctoclevels") || node.attr("toclevels"),
+          break_up_urls_in_tables: node.attr("break-up-urls-in-tables"),
+          suppressasciimathdup: node.attr("suppress-asciimath-dup"),
+          bare: node.attr("bare"),
+          sectionsplit: node.attr("sectionsplit"),
+          baseassetpath: node.attr("base-asset-path"),
+          aligncrosselements: node.attr("align-cross-elements"),
+        }
+      end
+
+      def html_converter(node)
+        IsoDoc::HtmlConvert.new(html_extract_attributes(node))
+      end
+
+      def pdf_converter(node)
+        return nil if node.attr("no-pdf")
+
+        IsoDoc::Standoc::PdfConvert.new(pdf_extract_attributes(node))
+      end
+
+      def doc_extract_attributes(node)
+        attrs = {
+          script: node.attr("script"),
+          bodyfont: node.attr("body-font"),
+          headerfont: node.attr("header-font"),
+          monospacefont: node.attr("monospace-font"),
+          i18nyaml: node.attr("i18nyaml"),
+          scope: node.attr("scope"),
+          wordstylesheet: node.attr("wordstylesheet"),
+          wordstylesheet_override: node.attr("wordstylesheet-override"),
+          standardstylesheet: node.attr("standardstylesheet"),
+          header: node.attr("header"),
+          wordcoverpage: node.attr("wordcoverpage"),
+          wordintropage: node.attr("wordintropage"),
+          ulstyle: node.attr("ulstyle"),
+          olstyle: node.attr("olstyle"),
+          htmltoclevels: node.attr("htmltoclevels") || node.attr("toclevels"),
+          doctoclevels: node.attr("doctoclevels") || node.attr("toclevels"),
+          break_up_urls_in_tables: node.attr("break-up-urls-in-tables"),
+          suppressasciimathdup: node.attr("suppress-asciimath-dup"),
+          bare: node.attr("bare"),
+          baseassetpath: node.attr("base-asset-path"),
+          aligncrosselements: node.attr("align-cross-elements"),
+        }
+
+        if fonts_manifest = node.attr(FONTS_MANIFEST)
+          attrs[IsoDoc::XslfoPdfConvert::MN2PDF_OPTIONS] = {
+            IsoDoc::XslfoPdfConvert::MN2PDF_FONT_MANIFEST => fonts_manifest,
+          }
+        end
+
+        attrs
+      end
+
+      def pdf_extract_attributes(node)
+        %w(pdf-encrypt pdf-encryption-length pdf-user-password
+           pdf-owner-password pdf-allow-copy-content pdf-allow-edit-content
+           pdf-allow-assemble-document pdf-allow-edit-annotations
+           pdf-allow-print pdf-allow-print-hq pdf-allow-fill-in-forms
+           pdf-allow-access-content pdf-encrypt-metadata)
+          .each_with_object({}) do |x, m|
+          m[x.gsub(/-/, "").to_i] = node.attr(x)
+        end
+      end
+
+      def doc_converter(node)
+        IsoDoc::WordConvert.new(doc_extract_attributes(node))
+      end
+
+      def presentation_xml_converter(node)
+        IsoDoc::PresentationXMLConvert.new(html_extract_attributes(node))
+      end
+
+      def default_fonts(node)
+        b = node.attr("body-font") ||
+          (node.attr("script") == "Hans" ? '"Source Han Sans",serif' : '"Cambria",serif')
+        h = node.attr("header-font") ||
+          (node.attr("script") == "Hans" ? '"Source Han Sans",sans-serif' : '"Cambria",serif')
+        m = node.attr("monospace-font") || '"Courier New",monospace'
+        "$bodyfont: #{b};\n$headerfont: #{h};\n$monospacefont: #{m};\n"
+      end
+
+      def outputs(node, ret)
+        File.open("#{@filename}.xml", "w:UTF-8") { |f| f.write(ret) }
+        presentation_xml_converter(node).convert("#{@filename}.xml")
+        html_converter(node).convert("#{@filename}.presentation.xml",
+                                     nil, false, "#{@filename}.html")
+        doc_converter(node).convert("#{@filename}.presentation.xml",
+                                    nil, false, "#{@filename}.doc")
+        pdf_converter(node)&.convert("#{@filename}.presentation.xml",
+                                     nil, false, "#{@filename}.pdf")
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/reqt.rb

@@ -1,5 +1,5 @@
 require "htmlentities"
-require "uri"
+require "uri" if /^2\./.match?(RUBY_VERSION)
 require "mime/types"
 require "base64"
 

data/lib/asciidoctor/standoc/section.rb

@@ -1,4 +1,4 @@
-require "uri"
+require "uri" if /^2\./.match?(RUBY_VERSION)
 require_relative "ref_sect"
 require_relative "terms"
 
@@ -18,7 +18,7 @@ module Asciidoctor
       def sectiontype(node, level = true)
         ret = sectiontype1(node)
         ret1 = sectiontype_streamline(ret)
-        return ret1 if "symbols and abbreviated terms" == ret1
+        return ret1 if ret1 == "symbols and abbreviated terms"
         return nil unless !level || node.level == 1
         return nil if @seen_headers.include? ret
 
@@ -49,12 +49,17 @@ module Asciidoctor
                 script: node.attributes["script"],
                 number: node.attributes["number"],
                 type: node.attributes["type"],
-                annex: (if (node.attr("style") == "appendix" || node.role == "appendix") &&
+                annex: (if (node.attr("style") == "appendix" ||
+                            node.role == "appendix") &&
                           node.level == 1
                           true
                         end),
-                preface: (
-                           node.role == "preface" || node.attr("style") == "preface" ? true : nil) }
+                tag: node&.attr("tag"),
+                "multilingual-rendering": node&.attr("multilingual-rendering"),
+                preface: (if node.role == "preface" ||
+                          node.attr("style") == "preface"
+                            true
+                          end) }
         return ret unless node.attributes["change"]
 
         ret.merge(change: node.attributes["change"],
@@ -84,13 +89,11 @@ module Asciidoctor
           else
             if @term_def then term_def_subclause_parse(a, xml, node)
             elsif @definitions then symbols_parse(a, xml, node)
-            elsif @norm_ref then norm_ref_parse(a, xml, node)
-            elsif @biblio then bibliography_parse(a, xml, node)
-            elsif node.attr("style") == "bibliography" && sectiontype(node, false) == "normative references"
+            elsif @norm_ref ||
+                (node.attr("style") == "bibliography" &&
+                 sectiontype(node, false) == "normative references")
               norm_ref_parse(a, xml, node)
-            elsif node.attr("style") == "bibliography" && sectiontype(node, false) == "bibliography"
-              bibliography_parse(a, xml, node)
-            elsif node.attr("style") == "bibliography"
+            elsif @biblio || node.attr("style") == "bibliography"
               bibliography_parse(a, xml, node)
             elsif node.attr("style") == "abstract"
               abstract_parse(a, xml, node)
@@ -118,7 +121,9 @@ 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 || @i18n.foreword) }
+            xml_abstract.title do |t|
+              t << (node.blocks[0].title || @i18n.foreword)
+            end
             content = node.content
             xml_abstract << content
           end
@@ -143,7 +148,7 @@ module Asciidoctor
       end
 
       def clause_parse(attrs, xml, node)
-        attrs["inline-header".to_sym] = node.option? "inline-header"
+        attrs[:"inline-header"] = node.option? "inline-header"
         attrs[:bibitem] = true if node.option? "bibitem"
         attrs[:level] = node.attr("level")
         set_obligation(attrs, node)
@@ -154,7 +159,7 @@ module Asciidoctor
       end
 
       def annex_parse(attrs, xml, node)
-        attrs["inline-header".to_sym] = node.option? "inline-header"
+        attrs[:"inline-header"] = node.option? "inline-header"
         set_obligation(attrs, node)
         xml.annex **attr_code(attrs) do |xml_section|
           xml_section.title { |name| name << node.title }
@@ -180,11 +185,24 @@ module Asciidoctor
 
       def acknowledgements_parse(attrs, xml, node)
         xml.acknowledgements **attr_code(attrs) do |xml_section|
-          xml_section.title { |t| t << node.title || @i18n.acknowledgements }
+          xml_section.title { |t| (t << node.title) || @i18n.acknowledgements }
           content = node.content
           xml_section << content
         end
       end
+
+      def floating_title_attrs(node)
+        attr_code(id_attr(node).merge(align: node.attr("align"),
+                                      type: "floating-title"))
+      end
+
+      def floating_title(node)
+        noko do |xml|
+          xml.p **floating_title_attrs(node) do |xml_t|
+            xml_t << node.title
+          end
+        end.join("\n")
+      end
     end
   end
 end

data/lib/asciidoctor/standoc/terms.rb

@@ -105,8 +105,14 @@ module Asciidoctor
         else
           attrs = term_source_attrs(node, seen_xref)
           attrs.delete(:text)
-          xml_t.origin seen_xref.children[0].content, **attr_code(attrs)
+          xml_t.origin **attr_code(attrs) do |o|
+            o << seen_xref.children[0].children.to_xml
+          end
         end
+        add_term_source_mod(xml_t, match)
+      end
+
+      def add_term_source_mod(xml_t, match)
         match[:text] && xml_t.modification do |mod|
           mod.p { |p| p << match[:text].sub(/^\s+/, "") }
         end

data/lib/asciidoctor/standoc/utils.rb

@@ -64,22 +64,6 @@ module Asciidoctor
         conv
       end
 
-      def default_script(lang)
-        case lang
-        when "ar", "fa" then "Arab"
-        when "ur" then "Aran"
-        when "ru", "bg" then "Cyrl"
-        when "hi" then "Deva"
-        when "el" then "Grek"
-        when "zh" then "Hans"
-        when "ko" then "Kore"
-        when "he" then "Hebr"
-        when "ja" then "Jpan"
-        else
-          "Latn"
-        end
-      end
-
       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

data/lib/asciidoctor/standoc/validate.rb

@@ -112,7 +112,7 @@ module Asciidoctor
       def schema_validate1(file, doc, schema)
         file.write(doc.to_xml)
         file.close
-        errors = Jing.new(schema).validate(file.path)
+        errors = Jing.new(schema, encoding: "UTF-8").validate(file.path)
         warn "Syntax Valid!" if errors.none?
         errors.each do |e|
           @log.add("Metanorma XML Syntax",