metanorma-standoc 1.10.2 → 1.10.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca8e0e987187b1a9c3e36246671b4c8566746c6178034c55e0cba34164f64bbf
-  data.tar.gz: af58564b53587bff140ecec89f1ca9d2e051859befbcbabd9842ed3e84fda039
+  metadata.gz: a43a3db1e4ef2ae43a1b2c7ecd980384cac2ee645668e414c73fd8e53dee3859
+  data.tar.gz: 6f026c1bd2e1d0c5f2f327cdc345af6635ff1c1454479fd42709b9d18fda5e60
 SHA512:
-  metadata.gz: e711720551cfcfe47d425fcd3172c5bc07eb727dc9f08e2f9fe02cfa4edd1f9bffe5587b9a4215f470951149cc36a970ca669e217226a52fa812c07fb70ee1c5
-  data.tar.gz: acef9c690a20986928c0c26508787ba362022ee9970f35d9e9c4fe47c55aebf3a0dafac1e3d2c684bbecf602d0a750583948921bd65e04e791d462f20707448c
+  metadata.gz: 7b20738029106d832a852db8eabf340058cdcbf75d8ce16def000478733c3633ad1144ac1aa2f736a637423c19f90491429fbec591987bc2f4af58bb3c8df087
+  data.tar.gz: 69f3e40acdca71435cda97dbcd33e862ffbacbb4eeaff97e543b971ec2744c72227115013ef2ac3ee88552c64bf413a36c060adf3af58e6ebb86c6b85997b070

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,29 @@ 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|
+          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(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 +190,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

@@ -47,6 +47,8 @@ module Asciidoctor
         inline_macro Asciidoctor::Standoc::FormTextareaMacro
         inline_macro Asciidoctor::Standoc::FormSelectMacro
         inline_macro Asciidoctor::Standoc::FormOptionMacro
+        inline_macro Asciidoctor::Standoc::ToCInlineMacro
+        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

@@ -1254,6 +1254,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>[^"]+)">