metanorma-standoc 1.10.8 → 1.11.2

data/lib/asciidoctor/standoc/cleanup_terms.rb

@@ -1,66 +1,81 @@
 require_relative "term_lookup_cleanup"
+require_relative "cleanup_terms_designations"
 
 module Asciidoctor
   module Standoc
     module Cleanup
-      def termdef_stem_cleanup(xmldoc)
-        xmldoc.xpath("//term/p/stem").each do |a|
-          if a.parent.elements.size == 1 # para contains just a stem expression
-            t = Nokogiri::XML::Element.new("admitted", xmldoc)
-            parent = a.parent
-            t.children = a.remove
-            parent.replace(t)
-          end
-        end
-      end
-
       def termdomain_cleanup(xmldoc)
         xmldoc.xpath("//p/domain").each do |a|
-          prev = a.parent.previous
+          parent = a.parent
+          prev = parent.previous
           prev.next = a.remove
+          parent.text.strip.empty? and parent.remove
         end
       end
 
       def termdomain1_cleanup(xmldoc)
-        xmldoc.xpath("//domain").each do |d|
-          defn = d.at("../definition") and
-            defn.previous = d.remove
+        xmldoc.xpath("//term").each do |t|
+          d = t.xpath("./domain | ./subject").last or next
+          defn = d.at("../definition") and defn.previous = d.remove
         end
       end
 
       def termdefinition_cleanup(xmldoc)
+        generate_termdefinitions(xmldoc)
+        split_termdefinitions(xmldoc)
+        alternate_termdefinitions(xmldoc)
+      end
+
+      TERMDEF_BLOCKS =
+        "./p | ./ol | ./dl | ./ul | ./figure | ./formula | ./table".freeze
+
+      def generate_termdefinitions(xmldoc)
         xmldoc.xpath("//term[not(definition)]").each do |d|
-          first_child = d.at("./p | ./figure | ./formula") || next
+          first_child = d.at(TERMDEF_BLOCKS) || next
           t = Nokogiri::XML::Element.new("definition", xmldoc)
           first_child.replace(t)
           t << first_child.remove
-          d.xpath("./p | ./figure | ./formula").each { |n| t << n.remove }
+          d.xpath(TERMDEF_BLOCKS).each do |n|
+            t << n.remove
+          end
         end
       end
 
-      def termdef_unnest_cleanup(xmldoc)
-        # release termdef tags from surrounding paras
-        nodes = xmldoc.xpath("//p/admitted | //p/deprecates")
-        while !nodes.empty?
-          nodes[0].parent.replace(nodes[0].parent.children)
-          nodes = xmldoc.xpath("//p/admitted | //p/deprecates")
+      def split_termdefinitions(xmldoc)
+        xmldoc.xpath("//definition").each do |d|
+          if d.at("./p | ./ol | ./dl | ./ul")
+            d.children = "<verbal-definition>#{d.children}</verbal-definition>"
+          else
+            d.children = "<non-verbal-representation>"\
+                         "#{d.children}</non-verbal-representation>"
+          end
         end
       end
 
-      def termdef_subclause_cleanup(xmldoc)
-        xmldoc.xpath("//terms[terms]").each { |t| t.name = "clause" }
+      def alternate_termdefinitions(xmldoc)
+        xmldoc.xpath("//term").each do |t|
+          t.xpath("./definition").each do |d|
+            d1 = d.next_element or next
+            if (v = d.at("./verbal-definition")) &&
+                !d.at("./non-verbal-representation") &&
+                !d1.at("./verbal-definition") &&
+                nv = d1.at("./non-verbal-representation")
+              v.next = nv.remove
+              d1.remove
+            end
+          end
+        end
       end
 
       def termdocsource_cleanup(xmldoc)
         f = xmldoc.at("//preface | //sections")
-        xmldoc.xpath("//termdocsource").each do |s|
-          f.previous = s.remove
-        end
+        xmldoc.xpath("//termdocsource").each { |s| f.previous = s.remove }
       end
 
       def term_children_cleanup(xmldoc)
+        xmldoc.xpath("//terms[terms]").each { |t| t.name = "clause" }
         xmldoc.xpath("//term").each do |t|
-          %w(termnote termexample termsource).each do |w|
+          %w(termnote termexample termsource term).each do |w|
             t.xpath("./#{w}").each { |n| t << n.remove }
           end
         end
@@ -75,69 +90,29 @@ module Asciidoctor
       end
 
       def termnote_example_cleanup(xmldoc)
-        xmldoc.xpath("//termnote[not(ancestor::term)]").each do |x|
-          x.name = "note"
-        end
-        xmldoc.xpath("//termexample[not(ancestor::term)]").each do |x|
-          x.name = "example"
+        %w(note example).each do |w|
+          xmldoc.xpath("//term#{w}[not(ancestor::term)]").each do |x|
+            x.name = w
+          end
         end
       end
 
       def termdef_cleanup(xmldoc)
+        termdef_unnest_cleanup(xmldoc)
         Asciidoctor::Standoc::TermLookupCleanup.new(xmldoc, @log).call
+        term_nonverbal_designations(xmldoc)
+        term_dl_to_metadata(xmldoc)
+        term_termsource_to_designation(xmldoc)
+        term_designation_reorder(xmldoc)
         termdef_from_termbase(xmldoc)
-        termdef_unnest_cleanup(xmldoc)
-        termdef_stem_cleanup(xmldoc)
         termdomain_cleanup(xmldoc)
+        termdef_stem_cleanup(xmldoc)
         termdefinition_cleanup(xmldoc)
         termdomain1_cleanup(xmldoc)
         termnote_example_cleanup(xmldoc)
-        termdef_subclause_cleanup(xmldoc)
         term_children_cleanup(xmldoc)
         termdocsource_cleanup(xmldoc)
       end
-
-      # Indices sort after letter but before any following
-      # letter (x, x_m, x_1, xa); we use colon to force that sort order.
-      # Numbers sort *after* letters; we use thorn to force that sort order.
-      def symbol_key(sym)
-        key = sym.dup
-        key.traverse do |n|
-          next unless n.name == "math"
-
-          n.replace(grkletters(MathML2AsciiMath.m2a(n.to_xml)))
-        end
-        ret = Nokogiri::XML(key.to_xml)
-        HTMLEntities.new.decode(ret.text.downcase)
-          .gsub(/[\[\]{}<>()]/, "").gsub(/\s/m, "")
-          .gsub(/[[:punct:]]|[_^]/, ":\\0").gsub(/`/, "")
-          .gsub(/[0-9]+/, "þ\\0")
-      end
-
-      def grkletters(x)
-        x.gsub(/\b(alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega)\b/i, "&\\1;")
-      end
-
-      def extract_symbols_list(dlist)
-        dl_out = []
-        dlist.xpath("./dt | ./dd").each do |dtd|
-          if dtd.name == "dt"
-            dl_out << { dt: dtd.remove, key: symbol_key(dtd) }
-          else
-            dl_out.last[:dd] = dtd.remove
-          end
-        end
-        dl_out
-      end
-
-      def symbols_cleanup(docxml)
-        docxml.xpath("//definitions/dl").each do |dl|
-          dl_out = extract_symbols_list(dl)
-          dl_out.sort! { |a, b| a[:key] <=> b[:key] || a[:dt] <=> b[:dt] }
-          dl.children = dl_out.map { |d| d[:dt].to_s + d[:dd].to_s }.join("\n")
-        end
-        docxml
-      end
     end
   end
 end

data/lib/asciidoctor/standoc/cleanup_terms_designations.rb

@@ -0,0 +1,179 @@
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def termdef_stem_cleanup(xmldoc)
+        xmldoc.xpath("//term/p/stem").each do |a|
+          if initial_formula(a.parent)
+            parent = a.parent
+            parent.replace("<admitted>#{term_expr(a.to_xml)}</admitted>")
+          end
+        end
+        xmldoc.xpath("//term/formula").each do |a|
+          if initial_formula(a)
+            a.replace("<admitted>#{term_expr(a.children.to_xml)}</admitted>")
+          end
+        end
+        xmldoc.xpath("//term//expression/name[stem]").each do |n|
+          n.parent.name = "letter-symbol"
+        end
+      end
+
+      def initial_formula(elem)
+        elem.elements.size == 1 && # para contains just stem expression
+          !elem.at("./preceding-sibling::p | ./preceding-sibling::dl | "\
+                   "./preceding-sibling::ol | ./preceding-sibling::ul")
+      end
+
+      # release termdef tags from surrounding paras
+      def termdef_unnest_cleanup(xmldoc)
+        desgn = "//p/admitted | //p/deprecates | //p/preferred | //p//related"
+        nodes = xmldoc.xpath(desgn)
+        while !nodes.empty?
+          nodes[0].parent.replace(nodes[0].parent.children)
+          nodes = xmldoc.xpath(desgn)
+        end
+      end
+
+      def term_dl_to_metadata(xmldoc)
+        xmldoc.xpath("//term[dl[@metadata = 'true']]").each do |t|
+          t.xpath("./dl[@metadata = 'true']").each do |dl|
+            prev = dl_to_designation(dl) or next
+            term_dl_to_designation_metadata(prev, dl)
+            term_dl_to_term_metadata(prev, dl)
+            term_dl_to_expression_metadata(prev, dl)
+            dl.remove
+          end
+        end
+      end
+
+      def term_dl_to_term_metadata(prev, dlist)
+        return unless prev.name == "preferred" &&
+          prev.at("./preceding-sibling::preferred").nil?
+
+        ins = term_element_insert_point(prev)
+        %w(domain subject).each do |a|
+          ins = dl_to_elems(ins, prev.parent, dlist, a)
+        end
+      end
+
+      def term_dl_to_designation_metadata(prev, dlist)
+        %w(absent geographic-area).each do |a|
+          dl_to_attrs(related2pref(prev), dlist, a)
+        end
+        %w(field-of-application usage-info).reverse.each do |a|
+          dl_to_elems(prev.at("./expression"), prev, dlist, a)
+        end
+      end
+
+      def term_element_insert_point(prev)
+        ins = prev
+        while %w(preferred admitted deprecates related domain dl)
+            .include? ins&.next_element&.name
+          ins = ins.next_element
+        end
+        ins
+      end
+
+      def term_dl_to_expression_metadata(prev, dlist)
+        %w(language script type isInternational).each do |a|
+          dl_to_attrs(prev, dlist, a)
+        end
+        %w(abbreviation-type pronunciation).reverse.each do |a|
+          dl_to_elems(prev.at("./expression/name"), prev, dlist, a)
+        end
+        g = dlist.at("./dt[text()='grammar']/following::dd//dl") and
+          term_dl_to_expression_grammar(prev, g)
+        term_to_letter_symbol(prev, dlist)
+      end
+
+      def term_dl_to_expression_grammar(prev, dlist)
+        prev.at(".//expression") or return
+        prev.at(".//expression") << "<grammar><sentinel/></grammar>"
+        %w(gender number isPreposition isParticiple isAdjective isAdverb isNoun
+           grammar-value).reverse.each do |a|
+          dl_to_elems(prev.at(".//expression/grammar/*"), prev.elements.last,
+                      dlist, a)
+        end
+        term_dl_to_designation_category(prev, "gender")
+        term_dl_to_designation_category(prev, "number")
+        prev.at(".//expression/grammar/sentinel").remove
+      end
+
+      def term_dl_to_designation_category(prev, category)
+        cat = prev.at(".//expression/grammar/#{category}")
+        /,/.match?(cat&.text) and
+          cat.replace(cat.text.split(/,\s*/)
+            .map { |x| "<#{category}>#{x}</#{category}>" }.join)
+      end
+
+      def term_to_letter_symbol(prev, dlist)
+        ls = dlist.at("./dt[text()='letter-symbol']/following::dd/p")
+        return unless ls&.text == "true"
+
+        prev.at(".//expression").name = "letter-symbol"
+      end
+
+      def dl_to_designation(dlist)
+        prev = dlist.previous_element
+        unless %w(preferred admitted deprecates related).include? prev&.name
+          @log.add("AsciiDoc Input", dlist, "Metadata definition list does "\
+                                            "not follow a term designation")
+          return nil
+        end
+        prev
+      end
+
+      def term_nonverbal_designations(xmldoc)
+        xmldoc.xpath("//term/preferred | //term/admitted | //term/deprecates")
+          .each do |d|
+          d.text.strip.empty? or next
+          n = d.next_element
+          if %w(formula figure).include?(n&.name)
+            term_nonverbal_designations1(d, n)
+          else d.at("./expression/name") or
+            d.children = term_expr("")
+          end
+        end
+      end
+
+      def term_nonverbal_designations1(desgn, elem)
+        desgn = related2pref(desgn)
+        if elem.name == "figure"
+          elem.at("./name").remove
+          desgn.children =
+            "<graphical-symbol>#{elem.remove.to_xml}</graphical-symbol>"
+        else
+          desgn.children = term_expr(elem.at("./stem").to_xml)
+          elem.remove
+        end
+      end
+
+      def term_termsource_to_designation(xmldoc)
+        xmldoc.xpath("//term/termsource").each do |t|
+          p = t.previous_element
+          while %w(domain subject).include? p&.name
+            p = p.previous_element
+          end
+          %w(preferred admitted deprecates related).include?(p&.name) or
+            next
+          related2pref(p) << t.remove
+        end
+      end
+
+      def term_designation_reorder(xmldoc)
+        xmldoc.xpath("//term").each do |t|
+          %w(preferred admitted deprecates related)
+            .each_with_object([]) do |tag, m|
+            t.xpath("./#{tag}").each { |x| m << x.remove }
+          end.reverse.each do |x|
+            t.children.first.previous = x
+          end
+        end
+      end
+
+      def related2pref(elem)
+        elem.name == "related" ? elem = elem.at("./preferred") : elem
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/cleanup_text.rb

@@ -28,6 +28,7 @@ module Asciidoctor
       end
 
       # "abc<tag/>", def => "abc",<tag/> def
+=begin
       def uninterrupt_quotes_around_xml(xmldoc)
         xmldoc.xpath("//*[following::text()[1]"\
                      "[starts-with(., '\"') or starts-with(., \"'\")]]")
@@ -37,6 +38,28 @@ module Asciidoctor
           uninterrupt_quotes_around_xml1(x)
         end
       end
+=end
+=begin
+      def uninterrupt_quotes_around_xml(xmldoc)
+        xmldoc.traverse do |n|
+          next unless n.element? && n&.next&.text? &&
+            n.ancestors("pre, tt, sourcecode, stem, figure").empty?
+          next unless /^['"]/.match?(n.next.text)
+
+          uninterrupt_quotes_around_xml1(n)
+        end
+      end
+=end
+      def uninterrupt_quotes_around_xml(xmldoc)
+        xmldoc.traverse do |n|
+          next unless n.text? && n&.previous&.element?
+          next unless /^['"]/.match?(n.text)
+          next unless n.previous.ancestors("pre, tt, sourcecode, stem, figure")
+            .empty?
+
+          uninterrupt_quotes_around_xml1(n.previous)
+        end
+      end
 
       def uninterrupt_quotes_around_xml1(elem)
         prev = elem.at(".//preceding::text()[1]") or return

data/lib/asciidoctor/standoc/converter.rb

@@ -28,8 +28,10 @@ module Asciidoctor
         preprocessor Metanorma::Plugin::Lutaml::LutamlPreprocessor
         preprocessor Metanorma::Plugin::Lutaml::LutamlUmlAttributesTablePreprocessor
         preprocessor Metanorma::Plugin::Lutaml::LutamlUmlDatamodelDescriptionPreprocessor
+        inline_macro Asciidoctor::Standoc::PreferredTermInlineMacro
         inline_macro Asciidoctor::Standoc::AltTermInlineMacro
         inline_macro Asciidoctor::Standoc::DeprecatedTermInlineMacro
+        inline_macro Asciidoctor::Standoc::RelatedTermInlineMacro
         inline_macro Asciidoctor::Standoc::DomainTermInlineMacro
         inline_macro Asciidoctor::Standoc::InheritInlineMacro
         inline_macro Asciidoctor::Standoc::HTML5RubyMacro

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'erb'
+require "erb"
 
 module Asciidoctor
   module Standoc
@@ -9,7 +9,7 @@ module Asciidoctor
         BLOCK_START_REGEXP = /\{(.+?)\.\*,(.+),(.+)\}/
         BLOCK_END_REGEXP = /\A\{[A-Z]+\}\z/
         MARCO_REGEXP = /\[datamodel_attributes_table,([^,]+),?(.+)?\]/
-        TEMPLATES_PATH = File.expand_path('../views/datamodel', __dir__).freeze
+        TEMPLATES_PATH = File.expand_path("../views/datamodel", __dir__).freeze
         # search document for block `datamodel_attributes_table`
         #  read include derectives that goes after that in block and transform
         #  into yaml2text blocks
@@ -39,16 +39,16 @@ module Asciidoctor
         def model_representation(model_path)
           template = File.read(File.join(
                                  TEMPLATES_PATH,
-                                 'model_representation.adoc.erb'
-          ))
-          file_name = File.basename(model_path).gsub(/\.ya?ml/, '')
+                                 "model_representation.adoc.erb",
+                               ))
+          file_name = File.basename(model_path).gsub(/\.ya?ml/, "")
           ERB
             .new(template)
             .result(binding)
         end
 
         def yaml_relative_path(file_path, document)
-          directory = File.dirname(document.attributes['docfile'] || '.')
+          directory = File.dirname(document.attributes["docfile"] || ".")
           document.path_resolver.system_path(file_path, directory)
         end
       end

data/lib/asciidoctor/standoc/inline.rb

@@ -15,14 +15,10 @@ module Asciidoctor
 
       def inline_anchor(node)
         case node.type
-        when :ref
-          inline_anchor_ref node
-        when :xref
-          inline_anchor_xref node
-        when :link
-          inline_anchor_link node
-        when :bibref
-          inline_anchor_bibref node
+        when :ref then inline_anchor_ref node
+        when :xref then inline_anchor_xref node
+        when :link then inline_anchor_link node
+        when :bibref then inline_anchor_bibref node
         end
       end
 
@@ -50,7 +46,12 @@ module Asciidoctor
         m.nil? and return { target: t, type: "inline", text: node.text }
         droploc = m[:drop].nil? && m[:drop2].nil? ? nil : true
         f = m[:fn].nil? ? "inline" : "footnote"
-        c = %i[case fn drop drop2].any? { |x| !m[x].nil? } ? m[:text] : node.text
+        c = if %i[case fn drop drop2].any? do |x|
+                 !m[x].nil?
+               end
+              m[:text]
+            else node.text
+            end
         { target: t, type: f, case: m[:case]&.sub(/%$/, ""), droploc: droploc,
           text: c }
       end
@@ -58,8 +59,9 @@ module Asciidoctor
       def inline_anchor_link(node)
         contents = node.text
         contents = "" if node.target.gsub(%r{^mailto:}, "") == node.text
-        attributes = { "target": node.target, "alt": node.attr("title"),
-                       "updatetype": node.attr("updatetype") }
+        attributes = { target: node.target, alt: node.attr("title"),
+                       "update-type": node.attr("updatetype") ||
+                         node.attr("update-type") }
         noko do |xml|
           xml.link **attr_code(attributes) do |l|
             l << contents
@@ -170,8 +172,10 @@ module Asciidoctor
           else
             case node.role
               # the following three are legacy, they are now handled by macros
-            when "alt" then xml.admitted { |a| a << node.text }
-            when "deprecated" then xml.deprecates { |a| a << node.text }
+            when "alt"
+              term_designation(xml, node, "admitted", node.text)
+            when "deprecated"
+              term_designation(xml, node, "deprecates", node.text)
             when "domain" then xml.domain { |a| a << node.text }
 
             when "strike" then xml.strike { |s| s << node.text }
@@ -209,7 +213,7 @@ module Asciidoctor
       def inline_image(node)
         noko do |xml|
           xml.image **image_attributes(node)
-        end.join("")
+        end.join
       end
 
       def inline_indexterm(node)
@@ -218,8 +222,8 @@ module Asciidoctor
           terms = (node.attr("terms") || [node.text]).map { |x| xml_encode(x) }
           xml.index do |i|
             i.primary { |x| x << terms[0] }
-            a = terms.dig(1) and i.secondary { |x| x << a }
-            a = terms.dig(2) and i.tertiary { |x| x << a }
+            a = terms[1] and i.secondary { |x| x << a }
+            a = terms[2] and i.tertiary { |x| x << a }
           end
         end.join
       end