metanorma-standoc 2.1.5 → 2.2.1

data/lib/metanorma/standoc/converter.rb

@@ -29,6 +29,7 @@ module Metanorma
         preprocessor Metanorma::Plugin::Lutaml::LutamlUmlAttributesTablePreprocessor
         preprocessor Metanorma::Plugin::Lutaml::LutamlUmlDatamodelDescriptionPreprocessor
         inline_macro Metanorma::Standoc::PreferredTermInlineMacro
+        inline_macro Metanorma::Standoc::SpanInlineMacro
         inline_macro Metanorma::Standoc::AltTermInlineMacro
         inline_macro Metanorma::Standoc::AdmittedTermInlineMacro
         inline_macro Metanorma::Standoc::DeprecatedTermInlineMacro
@@ -93,6 +94,7 @@ module Metanorma
         basebackend "html"
         outfilesuffix ".xml"
         @libdir = File.dirname(self.class::_file || __FILE__)
+                @c = HTMLEntities.new
       end
 
       class << self

data/lib/metanorma/standoc/front.rb

@@ -121,7 +121,7 @@ module Metanorma
 
       def metadata_getrelation(node, xml, type, desc = nil)
         docs = node.attr(desc || type) or return
-        HTMLEntities.new.decode(docs).split(/;\s*/).each do |d|
+        @c.decode(docs).split(/;\s*/).each do |d|
           metadata_getrelation1(d, xml, type, desc)
         end
       end

data/lib/metanorma/standoc/front_contributor.rb

@@ -44,16 +44,6 @@ module Metanorma
         node.attr("pub-uri") and person.uri node.attr("pub-uri")
       end
 
-      # , " => ," : CSV definition does not deal with space followed by quote
-      # at start of field
-      def csv_split(text, delim = ";")
-        return if text.nil?
-
-        CSV.parse_line(text&.gsub(/#{delim} "(?!")/, "#{delim}\""),
-                       liberal_parsing: true,
-                       col_sep: delim)&.compact&.map(&:strip)
-      end
-
       def metadata_author(node, xml)
         csv_split(node.attr("publisher") || default_publisher || "")
           &.each do |p|

data/lib/metanorma/standoc/inline.rb

@@ -79,8 +79,8 @@ module Metanorma
       end
 
       def inline_anchor_bibref(node)
-        eref_contents = HTMLEntities.new
-          .decode(node.text || node.target || node.id)
+        eref_contents =
+          @c.decode(node.text || node.target || node.id)
           &.sub(/^\[?([^\[\]]+?)\]?$/, "[\\1]")
         @refids << (node.target || node.id)
         noko do |xml|
@@ -125,14 +125,14 @@ module Metanorma
       end
 
       def xml_encode(text)
-        HTMLEntities.new.encode(text, :basic, :hexadecimal)
+        @c.encode(text, :basic, :hexadecimal)
           .gsub(/&amp;gt;/, ">").gsub(/&amp;lt;/, "<").gsub(/&amp;amp;/, "&")
           .gsub(/&gt;/, ">").gsub(/&lt;/, "<").gsub(/&amp;/, "&")
           .gsub(/&quot;/, '"').gsub(/&#xa;/, "\n").gsub(/&amp;#/, "&#")
       end
 
       def latex_parse1(text)
-        lxm_input = Unicode2LaTeX.unicode2latex(HTMLEntities.new.decode(text))
+        lxm_input = Unicode2LaTeX.unicode2latex(@c.decode(text))
         results = Latexmath.parse(lxm_input).to_mathml
         results.nil? and
           @log.add("Math", nil,
@@ -191,6 +191,10 @@ module Metanorma
             when "underline" then xml.underline { |s| s << node.text }
             when "smallcap" then xml.smallcap { |s| s << node.text }
             when "keyword" then xml.keyword { |s| s << node.text }
+            when /^css /
+              xml.span **{ style: node.role.sub(/^css /, "") } do |s|
+                s << node.text
+              end
             else
               xml << node.text
             end

data/lib/metanorma/standoc/isodoc.rng

@@ -1285,7 +1285,12 @@
   </define>
   <define name="span">
     <element name="span">
-      <attribute name="class"/>
+      <optional>
+        <attribute name="class"/>
+      </optional>
+      <optional>
+        <attribute name="style"/>
+      </optional>
       <oneOrMore>
         <ref name="TextElement"/>
       </oneOrMore>

data/lib/metanorma/standoc/macros.rb

@@ -3,6 +3,7 @@ require "fileutils"
 require "uuidtools"
 require "yaml"
 require "csv"
+require_relative "./macros_inline"
 require_relative "./macros_plantuml"
 require_relative "./macros_terms"
 require_relative "./macros_form"
@@ -15,54 +16,6 @@ require "metanorma-plugin-lutaml"
 
 module Metanorma
   module Standoc
-    class InheritInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :inherit
-      parse_content_as :text
-      using_format :short
-
-      def process(parent, _target, attrs)
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-        %{<inherit>#{out}</inherit>}
-      end
-    end
-
-    class IndexXrefInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :index
-
-      def preprocess_attrs(attrs)
-        return unless attrs.size > 1 && attrs.size < 5
-
-        ret = { primary: attrs[1], target: attrs[attrs.size] }
-        ret[:secondary] = attrs[2] if attrs.size > 2
-        ret[:tertiary] = attrs[3] if attrs.size > 3
-        ret
-      end
-
-      def process(_parent, target, attr)
-        args = preprocess_attrs(attr) or return
-        ret = "<index-xref also='#{target == 'also'}'>"\
-              "<primary>#{args[:primary]}</primary>"
-        ret += "<secondary>#{args[:secondary]}</secondary>" if args[:secondary]
-        ret += "<tertiary>#{args[:tertiary]}</tertiary>" if args[:tertiary]
-        ret + "<target>#{args[:target]}</target></index-xref>"
-      end
-    end
-
-    class IndexRangeInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :"index-range"
-      parse_content_as :text
-
-      def process(parent, target, attr)
-        text = attr["text"]
-        text = "((#{text}))" unless /^\(\(.+\)\)$/.match?(text)
-        out = parent.sub_macros(text)
-        out.sub(/<index>/, "<index to='#{target}'>")
-      end
-    end
-
     class PseudocodeBlockMacro < Asciidoctor::Extensions::BlockProcessor
       use_dsl
       named :pseudocode
@@ -97,138 +50,6 @@ module Metanorma
       end
     end
 
-    class HTML5RubyMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :ruby
-      parse_content_as :text
-      option :pos_attrs, %w(rpbegin rt rpend)
-
-      # for example, html5ruby:楽聖少女[がくせいしょうじょ]
-      def process(_parent, target, attributes)
-        rpbegin = "("
-        rpend = ")"
-        if (attributes.size == 1) && attributes.key?("text")
-          rt = attributes["text"]
-        elsif (attributes.size == 2) && attributes.key?(1) &&
-            attributes.key?("rpbegin")
-          rt = attributes[1] || ""
-        else
-          rpbegin = attributes["rpbegin"]
-          rt = attributes["rt"]
-          rpend = attributes["rpend"]
-        end
-
-        "<ruby>#{target}<rp>#{rpbegin}</rp><rt>#{rt}</rt>"\
-          "<rp>#{rpend}</rp></ruby>"
-      end
-    end
-
-    class AutonumberInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :autonumber
-      parse_content_as :text
-
-      def process(parent, target, attrs)
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-        %{<autonumber type='#{target}'>#{out}</autonumber>}
-      end
-    end
-
-    class VariantInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :lang
-      parse_content_as :text
-
-      def process(parent, target, attrs)
-        /^(?<lang>[^-]*)(?:-(?<script>.*))?$/ =~ target
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-        if script
-          %{<variant lang='#{lang}' script='#{script}'>#{out}</variant>}
-        else
-          %{<variant lang='#{lang}'>#{out}</variant>}
-        end
-      end
-    end
-
-    class AddMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :add
-      parse_content_as :text
-      using_format :short
-
-      def process(parent, _target, attrs)
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-        %{<add>#{out}</add>}
-      end
-    end
-
-    class DelMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :del
-      parse_content_as :text
-      using_format :short
-
-      def process(parent, _target, attrs)
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-        %{<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
-
-    # inject ZWNJ to prevent Asciidoctor from attempting regex substitutions
-    class PassInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :"pass-format"
-
-      def process(parent, target, attrs)
-        format = target || "metanorma"
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs[1]).convert
-          .gsub(/((?![<>&])[[:punct:]])/, "\\1&#x200c;")
-        %{<passthrough-inline formats="#{format}">#{out}</passthrough-inline>}
-      end
-    end
-
-    class IdentifierInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :identifier
-      parse_content_as :raw
-      using_format :short
-
-      def process(parent, _target, attrs)
-        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-          .gsub(/((?![<>&])[[:punct:]])/, "\\1&#x200c;")
-        %{<identifier>#{out}</identifier>}
-      end
-    end
-
-    class StdLinkInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
-      use_dsl
-      named :"std-link"
-      parse_content_as :text
-      using_format :short
-
-      def process(parent, _target, attrs)
-        create_anchor(parent, "hidden%#{attrs['text']}",
-                      type: :xref, target: "_#{UUIDTools::UUID.random_create}")
-      end
-    end
-
     class NamedEscapePreprocessor < Asciidoctor::Extensions::Preprocessor
       def process(_document, reader)
         c = HTMLEntities.new

data/lib/metanorma/standoc/macros_inline.rb

@@ -0,0 +1,194 @@
+module Metanorma
+  module Standoc
+    class InheritInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :inherit
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<inherit>#{out}</inherit>}
+      end
+    end
+
+    class IndexXrefInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :index
+
+      def preprocess_attrs(attrs)
+        return unless attrs.size > 1 && attrs.size < 5
+
+        ret = { primary: attrs[1], target: attrs[attrs.size] }
+        ret[:secondary] = attrs[2] if attrs.size > 2
+        ret[:tertiary] = attrs[3] if attrs.size > 3
+        ret
+      end
+
+      def process(_parent, target, attr)
+        args = preprocess_attrs(attr) or return
+        ret = "<index-xref also='#{target == 'also'}'>"\
+              "<primary>#{args[:primary]}</primary>"
+        ret += "<secondary>#{args[:secondary]}</secondary>" if args[:secondary]
+        ret += "<tertiary>#{args[:tertiary]}</tertiary>" if args[:tertiary]
+        ret + "<target>#{args[:target]}</target></index-xref>"
+      end
+    end
+
+    class IndexRangeInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :"index-range"
+      parse_content_as :text
+
+      def process(parent, target, attr)
+        text = attr["text"]
+        text = "((#{text}))" unless /^\(\(.+\)\)$/.match?(text)
+        out = parent.sub_macros(text)
+        out.sub(/<index>/, "<index to='#{target}'>")
+      end
+    end
+
+    class HTML5RubyMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :ruby
+      parse_content_as :text
+      option :pos_attrs, %w(rpbegin rt rpend)
+
+      # for example, html5ruby:楽聖少女[がくせいしょうじょ]
+      def process(_parent, target, attributes)
+        rpbegin = "("
+        rpend = ")"
+        if (attributes.size == 1) && attributes.key?("text")
+          rt = attributes["text"]
+        elsif (attributes.size == 2) && attributes.key?(1) &&
+            attributes.key?("rpbegin")
+          rt = attributes[1] || ""
+        else
+          rpbegin = attributes["rpbegin"]
+          rt = attributes["rt"]
+          rpend = attributes["rpend"]
+        end
+
+        "<ruby>#{target}<rp>#{rpbegin}</rp><rt>#{rt}</rt>"\
+          "<rp>#{rpend}</rp></ruby>"
+      end
+    end
+
+    class AutonumberInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :autonumber
+      parse_content_as :text
+
+      def process(parent, target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<autonumber type='#{target}'>#{out}</autonumber>}
+      end
+    end
+
+    class VariantInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :lang
+      parse_content_as :text
+
+      def process(parent, target, attrs)
+        /^(?<lang>[^-]*)(?:-(?<script>.*))?$/ =~ target
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        if script
+          %{<variant lang='#{lang}' script='#{script}'>#{out}</variant>}
+        else
+          %{<variant lang='#{lang}'>#{out}</variant>}
+        end
+      end
+    end
+
+    class AddMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :add
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<add>#{out}</add>}
+      end
+    end
+
+    class DelMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :del
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<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
+
+    # inject ZWNJ to prevent Asciidoctor from attempting regex substitutions
+    class PassInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :"pass-format"
+
+      def process(parent, target, attrs)
+        format = target || "metanorma"
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs[1]).convert
+          .gsub(/((?![<>&])[[:punct:]])/, "\\1&#x200c;")
+        %{<passthrough-inline formats="#{format}">#{out}</passthrough-inline>}
+      end
+    end
+
+    class IdentifierInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :identifier
+      parse_content_as :raw
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+          .gsub(/((?![<>&])[[:punct:]])/, "\\1&#x200c;")
+        %{<identifier>#{out}</identifier>}
+      end
+    end
+
+    class StdLinkInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :"std-link"
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        create_anchor(parent, "hidden%#{attrs['text']}",
+                      type: :xref, target: "_#{UUIDTools::UUID.random_create}")
+      end
+    end
+
+    class SpanInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :span
+      parse_content_as :text
+
+      def process(parent, target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        %{<span class="#{target}">#{out}</span>}
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/ref_sect.rb

@@ -84,7 +84,7 @@ module Metanorma
         if ref[:code].nil? || ref[:no_year] || @bibdb.nil?
           res << [ref, idx, nil]
         else
-          @bibdb.fetch_async(HTMLEntities.new.decode(ref[:code]),
+          @bibdb.fetch_async(@c.decode(ref[:code]),
                              ref[:year], ref) do |doc|
             res << [ref, idx, doc]
           end
@@ -131,7 +131,7 @@ module Metanorma
         global = !@no_isobib_cache && !node.attr("local-cache-only")
         local = node.attr("local-cache") || node.attr("local-cache-only")
         local = nil if @no_isobib_cache
-        @bibdb = Relaton::DbCache.init_bib_caches(
+        @bibdb = Relaton::Db.init_bib_caches(
           local_cache: local,
           flush_caches: node.attr("flush-caches"),
           global_cache: global,

data/lib/metanorma/standoc/ref_utility.rb

@@ -53,7 +53,7 @@ module Metanorma
 
       def docnumber(bib, code)
         bib.docnumber do |d|
-          d << HTMLEntities.new.decode(code).sub(/^[^\d]*/, "")
+          d << @c.decode(code).sub(/^[^\d]*/, "")
         end
       end
 

data/lib/metanorma/standoc/reqt.rb

@@ -1,91 +1,35 @@
-require "htmlentities"
-require "uri" if /^2\./.match?(RUBY_VERSION)
-require "mime/types"
-require "base64"
-
 module Metanorma
   module Standoc
     module Blocks
-      def reqt_subpart(name)
-        %w(specification measurement-target verification import label title
-           description component subject inherit classification).include? name
-      end
-
-      def reqt_subpart_attrs(node, name)
-        klass = node.attr("class") || "component"
-        attr_code(keep_attrs(node)
-          .merge(exclude: node.option?("exclude"),
-                 type: node.attr("type"),
-                 class: name == "component" ? klass : nil))
+      def reqt_subpart?(name)
+        @reqt_model&.reqt_subpart?(name)
       end
 
       def requirement_subpart(node)
-        name = node.role || node.attr("style")
-        noko do |xml|
-          xml.send name, **reqt_subpart_attrs(node, name) do |o|
-            o << node.content
-          end
-        end
+        @reqt_model.requirement_subpart(node, keep_attrs(node))
       end
 
-      def req_classif_parse(classif)
-        ret = []
-        HTMLEntities.new.decode(classif).split(/;\s*/).each do |c|
-          c1 = c.split(/:\s*/)
-          next unless c1.size == 2
-
-          c1[1].split(/,\s*/).each { |v| ret << [c1[0], v] }
-        end
-        ret
+      def default_requirement_model
+        :default
       end
 
-      def requirement_classification(classif, out)
-        req_classif_parse(classif).each do |r|
-          out.classification do |c|
-            c.tag { |t| t << r[0] }
-            c.value { |v| v << r[1] }
-          end
-        end
-      end
-
-      def reqt_attrs(node)
-        attr_code(keep_attrs(node).merge(id_unnum_attrs(node)).merge(
-                    id: Metanorma::Utils::anchor_or_uuid(node),
-                    unnumbered: node.option?("unnumbered") ? "true" : nil,
-                    number: node.attr("number"),
-                    subsequence: node.attr("subsequence"),
-                    obligation: node.attr("obligation"),
-                    filename: node.attr("filename"),
-                    type: node.attr("type"),
-                    model: node.attr("model"),
-                  ))
-      end
+      def select_requirement_model(node)
+        return if @reqt_model
 
-      def requirement_elems(node, out)
-        node.title and out.title { |t| t << node.title }
-        a = node.attr("label") and out.label do |l|
-          l << out.text(a)
-        end
-        a = node.attr("subject") and csv_split(a)&.each do |subj|
-          out.subject { |s| s << out.text(subj) }
-        end
-        a = HTMLEntities.new.decode(node.attr("inherit")) and
-          csv_split(a)&.each do |i|
-            out.inherit do |inh|
-              inh << HTMLEntities.new.encode(i, :hexadecimal)
-            end
-          end
-        classif = node.attr("classification") and
-          requirement_classification(classif, out)
+        @reqt_model_name = node.attr("model") || @default_requirement_model
+        @reqt_model = @reqt_models.model(@reqt_model_name)
       end
 
-      def requirement(node, obligation)
-        noko do |xml|
-          xml.send obligation, **reqt_attrs(node) do |ex|
-            requirement_elems(node, ex)
-            wrap_in_para(node, ex)
-          end
-        end.join("\n")
+      def requirement(node, obligation, type)
+        nested = @reqt_model
+        !node.attr("type") &&
+          !%w(requirement recommendation permission).include?(type) and
+          node.set_attr("type", type)
+        attrs = keep_attrs(node).merge(id_unnum_attrs(node))
+          .merge(model: @reqt_model_name)
+        ret = @reqt_model.requirement(node, obligation, attrs)
+        @reqt_model = nil unless nested
+        ret
       end
     end
   end

data/lib/metanorma/standoc/reqt.rng

@@ -108,7 +108,7 @@
     </element>
   </define>
   <define name="label">
-    <element name="label">
+    <element name="identifier">
       <oneOrMore>
         <ref name="TextElement"/>
       </oneOrMore>