metanorma-standoc 1.10.1 → 1.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5a985aefd39dadc19549ad39c23e0849bac873ea5883e50762ca911c8bd3aad
-  data.tar.gz: b7560f906a1e50fc4032f3261a44d1edcb2e691872b3e85d14a0363d7668b575
+  metadata.gz: 69e06ff811f3411ddd5ddccb1bfd52b82c92b49e1458d781fcfffac4397c1062
+  data.tar.gz: c600a5d9e17f3f271d176cefb5c6d3f860d887369efac0f2ad03ec5bf78b01a7
 SHA512:
-  metadata.gz: 437c04558d97c828a200ca21668a0e74e7e9fe5b5581ab759955f9ada241a0a87ccfddf114b7bd616430107e5869ce785c547715d627a08b87e35a30237b0516
-  data.tar.gz: 11d70602d2bd7733e9daab869ec22e3bf58ff6397378b38734711d46cb8f6e04b25e5b5fbcd3b5cd1e36b8e58a1061c92a87502fab945ea8a8c573205e25b126
+  metadata.gz: 785c49c3ef49c5bdc393f1f10f44fb2cf3a59e10583b08f1b40ecf282ebe015b1b98a0c9d8f3c796c81d2495e7e1273ba28d15b5a6ad4c6b543dbbe42dbae47f
+  data.tar.gz: a55c32649ba87a57dd417802ea70f91efbbae57dc786b294cc08704fbfce0b2ecf03a90827578a7bcc7c138402f0cb87992309fe3aa6397702a400a426cb5640

data/lib/asciidoctor/standoc/cleanup.rb

@@ -62,6 +62,7 @@ module Asciidoctor
         bibdata_cleanup(xmldoc)
         svgmap_cleanup(xmldoc)
         boilerplate_cleanup(xmldoc)
+        toc_cleanup(xmldoc)
         smartquotes_cleanup(xmldoc)
         variant_cleanup(xmldoc)
         para_cleanup(xmldoc)
@@ -84,6 +85,30 @@ module Asciidoctor
       end
 
       def smartquotes_cleanup1(xmldoc)
+        uninterrupt_quotes_around_xml(xmldoc)
+        dumb2smart_quotes(xmldoc)
+      end
+
+      # "abc<tag/>", def => "abc",<tag/> def
+      def uninterrupt_quotes_around_xml(xmldoc)
+        xmldoc.xpath("//*[following::text()[1]"\
+                     "[starts-with(., '\"') or starts-with(., \"'\")]]")
+          .each do |x|
+          next if !x.ancestors("pre, tt, sourcecode, stem, figure").empty?
+          uninterrupt_quotes_around_xml1(x)
+        end
+      end
+
+      def uninterrupt_quotes_around_xml1(elem)
+        prev = elem.at(".//preceding::text()[1]") or return
+        /\S$/.match?(prev.text) or return
+        foll = elem.at(".//following::text()[1]")
+        m = /^(["'][[:punct:]]*)(\s|$)/.match(HTMLEntities.new.decode(foll&.text)) or return
+        foll.content = foll.text.sub(/^(["'][[:punct:]]*)/, "")
+        prev.content = "#{prev.text}#{m[1]}"
+      end
+
+      def dumb2smart_quotes(xmldoc)
         (xmldoc.xpath("//*[child::text()]") - xmldoc.xpath(IGNORE_DUMBQUOTES))
           .each do |x|
           x.children.each do |n|
@@ -166,6 +191,42 @@ module Asciidoctor
           end
         end
       end
+
+      def toc_cleanup(xmldoc)
+        xmldoc.xpath("//p[toc]").each do |x|
+          x.xpath("./toc").reverse.each do |t|
+            x.next = t
+          end
+          x.remove if x.text.strip.empty?
+        end
+        xmldoc.xpath("//toc").each { |t| toc_cleanup1(t, xmldoc) }
+      end
+
+      def toc_index(toc, xmldoc)
+        depths = toc.xpath("./toc-xpath").each_with_object({}) do |x, m|
+          m[x.text] = x["depth"]
+        end
+        depths.keys.each_with_object([]) do |key, arr|
+          xmldoc.xpath(key).each do |x|
+            arr << { text: x.children.to_xml, depth: depths[key].to_i,
+                     target: x.xpath("(./ancestor-or-self::*/@id)[last()]")[0].text,
+                     line: x.line }
+          end
+        end.sort_by { |a| a[:line] }
+      end
+
+      def toc_cleanup1(toc, xmldoc)
+        depth = 1
+        ret = ""
+        toc_index(toc, xmldoc).each do |x|
+          if depth > x[:depth] then ret += "</ul></li>" * (depth - x[:depth])
+          elsif depth < x[:depth] then ret += "<li><ul>" * (x[:depth] - depth)
+          end
+          ret += "<li><xref target='#{x[:target]}'>#{x[:text]}</xref></li>"
+          depth = x[:depth]
+        end
+        toc.children = "<ul>#{ret}</ul>"
+      end
     end
   end
 end

data/lib/asciidoctor/standoc/converter.rb

@@ -27,6 +27,7 @@ module Asciidoctor
         preprocessor Metanorma::Plugin::Datastruct::Yaml2TextPreprocessor
         preprocessor Metanorma::Plugin::Lutaml::LutamlPreprocessor
         preprocessor Metanorma::Plugin::Lutaml::LutamlUmlAttributesTablePreprocessor
+        preprocessor Metanorma::Plugin::Lutaml::LutamlUmlDatamodelDescriptionPreprocessor
         inline_macro Asciidoctor::Standoc::AltTermInlineMacro
         inline_macro Asciidoctor::Standoc::DeprecatedTermInlineMacro
         inline_macro Asciidoctor::Standoc::DomainTermInlineMacro
@@ -47,6 +48,9 @@ module Asciidoctor
         inline_macro Asciidoctor::Standoc::FormTextareaMacro
         inline_macro Asciidoctor::Standoc::FormSelectMacro
         inline_macro Asciidoctor::Standoc::FormOptionMacro
+        inline_macro Asciidoctor::Standoc::ToCInlineMacro
+        inline_macro Metanorma::Plugin::Lutaml::LutamlFigureInlineMacro
+        block_macro Metanorma::Plugin::Lutaml::LutamlDiagramBlockMacro
         block Asciidoctor::Standoc::ToDoAdmonitionBlock
         treeprocessor Asciidoctor::Standoc::ToDoInlineAdmonitionBlock
         block Asciidoctor::Standoc::PlantUMLBlockMacro

data/lib/asciidoctor/standoc/datamodel/diagram_preprocessor.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require 'erb'
-require 'asciidoctor/standoc/datamodel/plantuml_renderer'
+require "erb"
+require "asciidoctor/standoc/datamodel/plantuml_renderer"
 
 module Asciidoctor
   module Standoc
     module Datamodel
       class DiagramPreprocessor < Asciidoctor::Extensions::Preprocessor
-        BLOCK_START_REGEXP = /\{(.+?)\.\*,(.+),(.+)\}/
-        BLOCK_END_REGEXP = /\A\{[A-Z]+\}\z/
-        MARCO_REGEXP = /\[datamodel_diagram,([^,]+),?(.+)?\]/
-        TEMPLATES_PATH = File.expand_path('../views/datamodel', __dir__).freeze
+        BLOCK_START_REGEXP = /\{(.+?)\.\*,(.+),(.+)\}/.freeze
+        BLOCK_END_REGEXP = /\A\{[A-Z]+\}\z/.freeze
+        MARCO_REGEXP = /\[datamodel_diagram,([^,]+),?(.+)?\]/.freeze
+        TEMPLATES_PATH = File.expand_path("../views/datamodel", __dir__).freeze
         # search document for block `datamodel_diagram`
         #  read include derectives that goes after that in block and transform
         #  into plantuml block
@@ -33,7 +33,7 @@ module Asciidoctor
         end
 
         def parse_datamodel_marco(yaml_path, include_path, document)
-          include_path ||= File.join(File.dirname(yaml_path), '..', 'models')
+          include_path ||= File.join(File.dirname(yaml_path), "..", "models")
           include_path = yaml_relative_path(include_path, document)
           yaml_relative_to_doc_path = yaml_relative_path(yaml_path, document)
           view_hash = YAML.safe_load(File.read(yaml_relative_to_doc_path))
@@ -43,7 +43,7 @@ module Asciidoctor
         end
 
         def yaml_relative_path(file_path, document)
-          docfile = document.attributes['docfile'] || '.'
+          docfile = document.attributes["docfile"] || "."
           docfile_directory = File.dirname(docfile)
           document.path_resolver.system_path(file_path, docfile_directory)
         end
@@ -51,11 +51,11 @@ module Asciidoctor
         def import_format(include_path, import_name, values)
           include_content = File.read(File.join(
                                         include_path,
-                                        "#{import_name}.yml"
-          ))
+                                        "#{import_name}.yml",
+                                      ))
           content = YAML.safe_load(include_content)
           if values
-            content['skipSection'] = values['skipSection']
+            content["skipSection"] = values["skipSection"]
           end
           content
         end
@@ -63,36 +63,37 @@ module Asciidoctor
         def format_import_directives(imports, include_path)
           imports
             .each_with_object({}) do |(import_name, values), res|
-              full_model_name = import_name.split('/').join
+              full_model_name = import_name.split("/").join
               content = import_format(include_path, import_name, values)
-              res[content['name'] || full_model_name] = content
+              res[content["name"] || full_model_name] = content
             end.compact
         end
 
         def prepare_view_hash(view_hash, all_imports)
           view_hash.merge!(
-            'classes' => model_type(all_imports, 'class'),
-            'enums' => model_type(all_imports, 'enum'),
-            'relations' => view_hash['relations'] || [],
-            'fidelity' => (view_hash['fidelity'] || {})
-                          .merge!('classes' => model_type(all_imports, 'class'))
+            "classes" => model_type(all_imports, "class"),
+            "enums" => model_type(all_imports, "enum"),
+            "relations" => view_hash["relations"] || [],
+            "fidelity" => (view_hash["fidelity"] || {})
+                          .merge!("classes" => model_type(all_imports,
+                                                          "class")),
           )
         end
 
         def model_type(imports, type)
           imports
             .select do |_name, elem|
-              elem['modelType'] == type
+              elem["modelType"] == type
             end
         end
 
         def plantuml_representations(view_hash, view_path, include_path)
           yaml_directory = File.dirname(view_path)
-          all_imports = format_import_directives(view_hash['imports'],
+          all_imports = format_import_directives(view_hash["imports"],
                                                  include_path)
           prepare_view_hash(view_hash, all_imports)
           Asciidoctor::Datamodel::PlantumlRenderer
-            .new(view_hash, File.join(yaml_directory, '..'))
+            .new(view_hash, File.join(yaml_directory, ".."))
             .render
             .split("\n")
         end

data/lib/asciidoctor/standoc/isodoc.rng

@@ -1011,8 +1011,14 @@
       <ref name="imagemap"/>
       <ref name="svgmap"/>
       <ref name="inputform"/>
+      <ref name="toc"/>
     </choice>
   </define>
+  <define name="toc">
+    <element name="toc">
+      <ref name="ul"/>
+    </element>
+  </define>
   <define name="inputform">
     <element name="form">
       <attribute name="id">
@@ -1254,6 +1260,12 @@
     <optional>
       <attribute name="type"/>
     </optional>
+    <optional>
+      <attribute name="identifier"/>
+    </optional>
+    <optional>
+      <attribute name="prefix"/>
+    </optional>
     <text/>
   </define>
   <define name="ics">

data/lib/asciidoctor/standoc/macros.rb

@@ -2,6 +2,7 @@ require "asciidoctor/extensions"
 require "fileutils"
 require "uuidtools"
 require "yaml"
+require "csv"
 require_relative "./macros_plantuml"
 require_relative "./macros_terms"
 require_relative "./macros_form"
@@ -211,5 +212,22 @@ module Asciidoctor
         %{<del>#{out}</del>}
       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
   end
 end

data/lib/asciidoctor/standoc/ref.rb

@@ -4,7 +4,7 @@ module Asciidoctor
   module Standoc
     module Refs
       def iso_publisher(bib, code)
-        code.sub(/ .*$/, "").split(/\//).each do |abbrev|
+        code.sub(/ .*$/, "").split("/").each do |abbrev|
           bib.contributor do |c|
             c.role **{ type: "publisher" }
             c.organization do |org|
@@ -18,75 +18,78 @@ module Asciidoctor
         { format: "text/plain" }
       end
 
-      def ref_attributes(m)
-        { id: m[:anchor], type: "standard" }
+      def ref_attributes(match)
+        { id: match[:anchor], type: "standard" }
       end
 
-      def isorefrender1(bib, m, yr, allp = "")
-        bib.title(**plaintxt) { |i| i << ref_normalise(m[:text]) }
-        docid(bib, m[:usrlbl]) if m[:usrlbl]
-        docid(bib, id_and_year(m[:code], yr) + allp)
-        docnumber(bib, m[:code])
+      def isorefrender1(bib, match, yr, 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)
+        docnumber(bib, match[:code])
       end
 
-      def isorefmatches(xml, m)
-        yr = norm_year(m[:year])
-        ref = fetch_ref xml, m[:code], yr, title: m[:text], usrlbl: m[:usrlbl],
-          lang: (@lang || :all)
-        return use_my_anchor(ref, m[:anchor]) if ref
+      def isorefmatches(xml, 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(m)) do |t|
-          isorefrender1(t, m, yr)
+        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)
           end
-          iso_publisher(t, m[:code])
+          iso_publisher(t, match[:code])
         end
       end
 
-      def isorefmatches2(xml, m)
-        ref = fetch_ref xml, m[:code], nil, no_year: true, note: m[:fn],
-          title: m[:text], usrlbl: m[:usrlbl], lang: (@lang || :all)
-        return use_my_anchor(ref, m[:anchor]) if ref
+      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
 
-        isorefmatches2_1(xml, m)
+        isorefmatches2_1(xml, match)
       end
 
-      def isorefmatches2_1(xml, m)
-        xml.bibitem **attr_code(ref_attributes(m)) do |t|
-          isorefrender1(t, m, "--")
+      def isorefmatches2_1(xml, match)
+        xml.bibitem **attr_code(ref_attributes(match)) do |t|
+          isorefrender1(t, match, "--")
           t.date **{ type: "published" } do |d|
             d.on "--"
           end
-          iso_publisher(t, m[:code])
-          unless m[:fn].nil?
+          iso_publisher(t, match[:code])
+          unless match[:fn].nil?
             t.note(**plaintxt.merge(type: "Unpublished-Status")) do |p|
-            p << (m[:fn]).to_s
+              p << (match[:fn]).to_s
             end
           end
         end
       end
 
-      def isorefmatches3(xml, m)
-        yr = norm_year(m[:year])
+      def isorefmatches3(xml, match)
+        yr = norm_year(match[:year])
         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],
+        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, m[:anchor]) if ref
+        return use_my_anchor(ref, match[:anchor]) if ref
 
-        isorefmatches3_1(xml, m, yr, hasyr, ref)
+        isorefmatches3_1(xml, match, 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, yr == "--")
-          iso_publisher(t, m[:code])
-          if m.names.include?("fn") && m[:fn]
+      def isorefmatches3_1(xml, match, yr, _hasyr, _ref)
+        xml.bibitem(**attr_code(ref_attributes(match))) do |t|
+          isorefrender1(t, match, yr, " (all parts)")
+          conditional_date(t, match, yr == "--")
+          iso_publisher(t, match[:code])
+          if match.names.include?("fn") && match[:fn]
             t.note(**plaintxt.merge(type: "Unpublished-Status")) do |p|
-              p << (m[:fn]).to_s
+              p << (match[:fn]).to_s
             end
           end
           t.extent **{ type: "part" } do |e|
@@ -95,23 +98,23 @@ module Asciidoctor
         end
       end
 
-      def refitem_render1(m, code, bib)
+      def refitem_render1(match, code, bib)
         if code[:type] == "path"
           bib.uri code[:key].sub(/\.[a-zA-Z0-9]+$/, ""), **{ type: "URI" }
           bib.uri code[:key].sub(/\.[a-zA-Z0-9]+$/, ""), **{ type: "citation" }
         end
-        docid(bib, m[:usrlbl]) if m[:usrlbl]
+        docid(bib, match[:usrlbl]) if match[:usrlbl]
         docid(bib, /^\d+$/.match?(code[:id]) ? "[#{code[:id]}]" : code[:id])
         code[:type] == "repo" and
           bib.docidentifier code[:key], **{ type: "repository" }
       end
 
-      def refitem_render(xml, m, code)
-        xml.bibitem **attr_code(id: m[:anchor]) do |t|
+      def refitem_render(xml, match, code)
+        xml.bibitem **attr_code(id: match[:anchor]) do |t|
           t.formattedref **{ format: "application/x-isodoc+xml" } do |i|
-            i << ref_normalise_no_format(m[:text])
+            i << ref_normalise_no_format(match[:text])
           end
-          refitem_render1(m, code, t)
+          refitem_render1(match, code, t)
           docnumber(t, code[:id]) unless /^\d+$|^\(.+\)$/.match?(code[:id])
         end
       end
@@ -128,7 +131,7 @@ module Asciidoctor
 
       def analyse_ref_repo_path(ret)
         return ret unless m =
-          /^(?<type>repo|path):\((?<key>[^,]+),?(?<id>.*)\)$/.match(ret[:id])
+                            /^(?<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)
@@ -156,16 +159,17 @@ module Asciidoctor
         nil
       end
 
-      def refitem1(xml, _item, m)
-        code = analyse_ref_code(m[:code])
+      def refitem1(xml, _item, match)
+        code = analyse_ref_code(match[:code])
         unless code[:id] && code[:numeric] || code[:nofetch]
           ref = fetch_ref(xml, code[:id],
-                          m.names.include?("year") ? m[:year] : nil,
-                          title: m[:text],
-                          usrlbl: m[:usrlbl], lang: (@lang || :all))
-          return use_my_anchor(ref, m[:anchor]) if ref
+                          match.names.include?("year") ? match[:year] : nil,
+                          title: match[:text],
+                          usrlbl: match[:usrlbl], lang: (@lang || :all)) and
+            return use_my_anchor(ref, match[:anchor])
         end
-        refitem_render(xml, m, code)
+
+        refitem_render(xml, match, code)
       end
 
       def ref_normalise(ref)
@@ -186,7 +190,7 @@ module Asciidoctor
       \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9-]+):
       (--|&\#821[12];)\]</ref>,?\s*
         (<fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>)?,?\s?(?<text>.*)$}xm
-        .freeze
+          .freeze
 
       ISO_REF_ALL_PARTS =
         %r{^<ref\sid="(?<anchor>[^"]+)">