metanorma-standoc 2.2.0 → 2.2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d1015766df2dd6accbfd8de285d762403a1d874fcac93a3d6829055602f2904
-  data.tar.gz: b185321cbbbcb6de4bfb9cea996dec314e585f54fbdf7baf31fcce616be60ef5
+  metadata.gz: 90287c74936b7e6fa5c54537833e425fdc78deb260ce3a9f083cc53530ad66fc
+  data.tar.gz: 273eb7dcaf62e8b9a8578f932b3ab45377bdf0b57ad254cab80b16b10e584586
 SHA512:
-  metadata.gz: 9aa957125f263ab18defd53ff0086519c43de991346bbf1775ae10907a9a06e551b3b3ddc5bf078dc968f6cbbfb863f6690643d093ad8d29b22f490815e745cc
-  data.tar.gz: d687658d8b5d8e6194655f3e40605d9f5e610c599631e5bf13de586daaeefa0f57a22614884e71321abdc248f55dd42113fdc068e4ceb296cc88102f27db6acf
+  metadata.gz: 167db30a6cbf87a30f2e1d97eeaafffb63e94699a7f077556ec23604de443fcfabc1a1de091e7fbb93ddf528482e980e0b23c976abbf2e7aae8ebbfbddbb686c
+  data.tar.gz: 1925f23438f2cc30fcd898c4ceeb8aea39442a8b0575d2cf8fa91954e229a2384b954670e75a66fe052486ff12a6b3394512d49ae84d38ac5f5253cde3591715

data/lib/metanorma/standoc/base.rb

@@ -9,6 +9,7 @@ require "fileutils"
 require "metanorma-utils"
 require "isodoc/xslfo_convert"
 require_relative "render"
+require "mn-requirements"
 
 module Metanorma
   module Standoc
@@ -29,6 +30,7 @@ module Metanorma
         init_vars
         init_misc(node)
         init_processing(node)
+        init_reqt(node)
         init_toc(node)
         init_output(node)
         init_i18n(node)
@@ -42,7 +44,10 @@ module Metanorma
         @anchors = {}
         @internal_eref_namespaces = []
         @seen_headers = []
+        @seen_headers_canonical = []
         @embed_hdr = []
+        @reqt_model = nil
+        @preface = true
       end
 
       def init_misc(node)
@@ -63,6 +68,13 @@ module Metanorma
         @datauriimage = node.attr("data-uri-image") != "false"
       end
 
+      def init_reqt(node)
+        @default_requirement_model = (node.attr("requirements-model") ||
+                                        default_requirement_model)
+        @reqt_models = Metanorma::Requirements
+          .new({ default: @default_requirement_model })
+      end
+
       def init_toc(node)
         @htmltoclevels = node.attr("htmltoclevels")
         @doctoclevels = node.attr("doctoclevels")

data/lib/metanorma/standoc/blocks.rb

@@ -34,7 +34,7 @@ module Metanorma
       # We append each contained block to its parent
       def open(node)
         role = node.role || node.attr("style")
-        reqt_subpart(role) and return requirement_subpart(node)
+        reqt_subpart?(role) and return requirement_subpart(node)
         role == "form" and return form(node)
         role == "definition" and return termdefinition(node)
         result = []
@@ -88,26 +88,37 @@ module Metanorma
       end
 
       def example(node)
-        return term_example(node) if in_terms? || node.option?("termexample")
-
+        (in_terms? || node.option?("termexample")) and return term_example(node)
         role = node.role || node.attr("style")
-        %w(recommendation requirement permission).include?(role) and
-          return requirement(node, role)
-        return pseudocode_example(node) if role == "pseudocode"
-        return svgmap_example(node) if role == "svgmap"
-        return form(node) if role == "form"
-        return termdefinition(node) if role == "definition"
-        return figure_example(node) if role == "figure"
-
-        reqt_subpart(role) and return requirement_subpart(node)
+        ret = example_to_requirement(node, role) ||
+          example_by_role(node, role) and return ret
+        reqt_subpart?(role) and return requirement_subpart(node)
         example_proper(node)
       end
 
+      def example_by_role(node, role)
+        case role
+        when "pseudocode" then pseudocode_example(node)
+        when "svgmap" then svgmap_example(node)
+        when "form" then form(node)
+        when "definition" then termdefinition(node)
+        when "figure" then figure_example(node)
+        end
+      end
+
+      def example_to_requirement(node, role)
+        return unless @reqt_models.requirement_roles.key?(role&.to_sym)
+
+        # need to call here for proper recursion ordering
+        select_requirement_model(node)
+        requirement(node,
+                    @reqt_models.requirement_roles[role.to_sym], role)
+      end
+
       def svgmap_attrs(node)
         attr_code(id_attr(node)
-          .merge(id: node.id,
+          .merge(id: node.id, number: node.attr("number"),
                  unnumbered: node.option?("unnumbered") ? "true" : nil,
-                 number: node.attr("number"),
                  subsequence: node.attr("subsequence"))
         .merge(keep_attrs(node)))
       end
@@ -225,7 +236,6 @@ module Metanorma
                          filename: node.attr("filename"))))
       end
 
-      # NOTE: html escaping is performed by Nokogiri
       def listing(node)
         fragment = ::Nokogiri::XML::Builder.new do |xml|
           xml.sourcecode **listing_attrs(node) do |s|

data/lib/metanorma/standoc/cleanup_biblio.rb

@@ -145,7 +145,7 @@ module Metanorma
           when "publisher"
             ret[:contributor] << { role: "publisher", entity: "organization",
                                    name: s[:val] }
-          when "surname", "initials", "givenname"
+          when "surname", "initials", "givenname", "formatted-initials"
             ret[:contributor] = spans_preprocess_contrib(s, ret[:contributor])
           end
         end
@@ -153,6 +153,8 @@ module Metanorma
       end
 
       def spans_preprocess_contrib(span, contrib)
+        span[:key] = "formatted-initials" if span[:key] == "initials"
+
         spans_preprocess_new_contrib?(span, contrib) and
           contrib << { role: span[:type] || "author", entity: "person" }
         contrib[-1][span[:key].to_sym] = span[:val]
@@ -162,7 +164,7 @@ module Metanorma
       def spans_preprocess_new_contrib?(span, contrib)
         contrib.empty? ||
           (if span[:key] == "surname" then contrib[-1][:surname]
-           else (contrib[-1][:initials] || contrib[-1][:givenname])
+           else (contrib[-1][:"formatted-initials"] || contrib[-1][:givenname])
            end) ||
           contrib[-1][:role] != (span[:type] || "author")
       end
@@ -190,15 +192,19 @@ module Metanorma
       def span_to_contrib(span)
         e = if span[:entity] == "organization"
               "<organization><name>#{span[:name]}</name></organization>"
-            else
-              pre = (span[:initials] and
-                     "<initial>#{span[:initials]}</initial>") ||
-                "<forename>#{span[:givenname]}</forename>"
-              "<person><name>#{pre}<surname>#{span[:surname]}</surname></name>"\
-                "</person>"
+            else span_to_person(span)
             end
         "<contributor><role type='#{span[:role]}'/>#{e}</contributor>"
       end
+
+      def span_to_person(span)
+        pre = (span[:"formatted-initials"] and
+                     "<formatted-initials>"\
+                     "#{span[:"formatted-initials"]}</formatted-initials>") ||
+          "<forename>#{span[:givenname]}</forename>"
+        "<person><name>#{pre}<surname>#{span[:surname]}</surname></name>"\
+          "</person>"
+      end
     end
   end
 end

data/lib/metanorma/standoc/cleanup_reqt.rb

@@ -2,142 +2,9 @@ module Metanorma
   module Standoc
     module Cleanup
       def requirement_cleanup(xmldoc)
-        requirement_metadata(xmldoc)
-        requirement_inherit(xmldoc)
-        requirement_descriptions(xmldoc)
-        requirement_identifier(xmldoc)
-      end
-
-      REQRECPER = "//requirement | //recommendation | //permission".freeze
-
-      def requirement_identifier(xmldoc)
-        xmldoc.xpath(REQRECPER).each do |r|
-          r.xpath("./identifier[link] | ./inherit[link]").each do |i|
-            i.children = i.at("./link/@target").text
-          end
-        end
-      end
-
-      def requirement_inherit(xmldoc)
-        xmldoc.xpath(REQRECPER).each do |r|
-          ins = requirement_inherit_insert(r)
-          r.xpath("./*//inherit").each { |i| ins.previous = i }
-        end
-      end
-
-      def requirement_inherit_insert(reqt)
-        ins = reqt.at("./classification") || reqt.at(
-          "./description | ./measurementtarget | ./specification | "\
-          "./verification | ./import | ./description | ./component | "\
-          "./requirement | ./recommendation | ./permission",
-        ) and return ins
-        requirement_inherit_insert1(reqt)
-      end
-
-      def requirement_inherit_insert1(reqt)
-        if t = reqt.at("./title")
-          t.next = " "
-          t.next
-        else
-          if reqt.children.empty? then reqt.add_child(" ")
-          else reqt.children.first.previous = " "
-          end
-          reqt.children.first
-        end
-      end
-
-      def requirement_descriptions(xmldoc)
-        xmldoc.xpath(REQRECPER).each do |r|
-          r.xpath(".//p[not(./*)][normalize-space(.)='']").each(&:remove)
-          r.children.each do |e|
-            requirement_description_wrap(r, e)
-          end
-          requirement_description_cleanup1(r)
-        end
-      end
-
-      def requirement_description_wrap(reqt, text)
-        return if (text.element? && (reqt_subpart(text.name) ||
-                %w(requirement recommendation
-                   permission).include?(text.name))) ||
-          (text.text.strip.empty? && !text.at(".//xref | .//eref | .//link"))
-
-        t = Nokogiri::XML::Element.new("description", reqt.document)
-        text.before(t)
-        t.children = text.remove
-      end
-
-      def requirement_description_cleanup1(reqt)
-        while d = reqt.at("./description[following-sibling::*[1]"\
-                          "[self::description]]")
-          n = d.next.remove
-          d << n.children
-        end
-        reqt.xpath("./description[normalize-space(.)='']").each do |r|
-          r.replace("\n")
-        end
-      end
-
-      def requirement_metadata(xmldoc)
-        xmldoc.xpath(REQRECPER).each do |r|
-          dl = r&.at("./dl[@metadata = 'true']")&.remove or next
-          requirement_metadata1(r, dl, r.at("./title"))
-        end
-      end
-
-      def requirement_metadata1_attrs
-        %w(obligation model type)
-      end
-
-      def requirement_metadata1_tags
-        %w(identifier subject inherit)
-      end
-
-      def requirement_metadata_component_tags
-        []
-      end
-
-      def requirement_metadata1(reqt, dlist, ins)
-        unless ins
-          reqt.children.first.previous = " "
-          ins = reqt.children.first
-        end
-        requirement_metadata1_attrs.each do |a|
-          dl_to_attrs(reqt, dlist, a)
-        end
-        requirement_metadata1_tags.each do |a|
-          ins = dl_to_elems(ins, reqt, dlist, a)
-        end
-        ins = reqt_dl_to_classif(ins, reqt, dlist)
-        reqt_dl_to_classif1(ins, reqt, dlist)
-      end
-
-      def reqt_dl_to_classif(ins, reqt, dlist)
-        if a = reqt.at("./classification[last()]") then ins = a end
-        dlist.xpath("./dt[text()='classification']").each do |e|
-          val = e.at("./following::dd/p") || e.at("./following::dd")
-          req_classif_parse(val.children.to_xml).each do |r|
-            ins.next = "<classification><tag>#{r[0]}</tag>"\
-                       "<value>#{r[1]}</value></classification>"
-            ins = ins.next
-          end
-        end
-        ins
-      end
-
-      def reqt_dl_to_classif1(ins, reqt, dlist)
-        if a = reqt.at("./classification[last()]") then ins = a end
-        dlist.xpath("./dt").each do |e|
-          next if (requirement_metadata1_attrs + requirement_metadata1_tags +
-                   requirement_metadata_component_tags + %w(classification))
-            .include?(e.text)
-
-          val = e.at("./following::dd/p") || e.at("./following::dd")
-          ins.next = "<classification><tag>#{e.text}</tag>"\
-                     "<value>#{val.children.to_xml}</value></classification>"
-          ins = ins.next
-        end
-        ins
+        @reqt_models ||=
+          Metanorma::Requirements.new({ default: @default_requirement_model })
+        @reqt_models.requirement_cleanup(xmldoc)
       end
     end
   end

data/lib/metanorma/standoc/front.rb

@@ -3,6 +3,7 @@ require "nokogiri"
 require "htmlentities"
 require "pathname"
 require_relative "./front_contributor"
+require "isoics"
 
 module Metanorma
   module Standoc
@@ -48,7 +49,11 @@ module Metanorma
       def metadata_ics(node, xml)
         ics = node.attr("library-ics")
         ics&.split(/,\s*/)&.each do |i|
-          xml.ics { |elem| elem.code i }
+          xml.ics do |elem|
+            elem.code i
+            icsdata = Isoics.fetch i
+            elem.text_ icsdata.description
+          end
         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/macros_inline.rb

@@ -182,7 +182,7 @@ module Metanorma
 
     class SpanInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
       use_dsl
-      named :s
+      named :span
       parse_content_as :text
 
       def process(parent, target, attrs)

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 identifier 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 = []
-        @c.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("identifier") and out.identifier 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 = @c.decode(node.attr("inherit")) and
-          csv_split(a)&.each do |i|
-            out.inherit do |inh|
-              inh << @c.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/section.rb

@@ -10,19 +10,26 @@ module Metanorma
       @norm_ref = false
 
       def sectiontype1(node)
+        return "abstract" if node.attr("style") == "abstract"
+
         node&.attr("heading")&.downcase ||
-          node.title.gsub(%r{<index>.*?</index>}m, "").gsub(/<[^>]+>/, "")
+          node.title
+            .gsub(%r{<index>.*?</index>}m, "")
+            .gsub(%r{<fn[^>]*>.*?</fn>}m, "")
+            .gsub(/<[^>]+>/, "")
             .strip.downcase
+            .sub(/\.$/, "")
       end
 
       def sectiontype(node, level = true)
         ret = sectiontype1(node)
-        ret1 = sectiontype_streamline(ret)
+        ret1 = preface_main_filter(sectiontype_streamline(ret), node)
         return ret1 if ret1 == "symbols and abbreviated terms"
         return nil unless !level || node.level == 1
         return nil if @seen_headers.include? ret
 
-        @seen_headers << ret
+        @seen_headers << ret unless ret1.nil?
+        @seen_headers_canonical << ret1 unless ret1.nil?
         ret1
       end
 
@@ -45,6 +52,31 @@ module Metanorma
         end
       end
 
+      PREFACE_CLAUSE_NAMES = %w(abstract foreword introduction
+                                acknowledgements).freeze
+
+      MAIN_CLAUSE_NAMES =
+        ["normative references", "terms and definitions", "scope",
+         "symbols and abbreviated terms", "clause", "bibliography"].freeze
+
+      def start_main_section(ret, node)
+        @preface = false if self.class::MAIN_CLAUSE_NAMES.include?(ret) &&
+          node.role != "preface" && node.attr("style") != "preface"
+        @preface = false if (self.class::PREFACE_CLAUSE_NAMES)
+          .intersection(@seen_headers_canonical + [ret]).empty?
+      end
+
+      def preface_main_filter(ret, node)
+        start_main_section(ret, node)
+        if @preface
+          self.class::MAIN_CLAUSE_NAMES.include?(ret) and return nil
+        else
+          self.class::PREFACE_CLAUSE_NAMES.include?(ret) and return nil
+        end
+
+        ret
+      end
+
       def section_attributes(node)
         ret = { id: Metanorma::Utils::anchor_or_uuid(node),
                 language: node.attributes["language"],

data/lib/metanorma/standoc/utils.rb

@@ -17,43 +17,20 @@ module Metanorma
         nil
       end
 
-      NOKOHEAD = <<~HERE.freeze
-        <!DOCTYPE html SYSTEM
-        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-        <html xmlns="http://www.w3.org/1999/xhtml">
-        <head> <title></title> <meta charset="UTF-8" /> </head>
-        <body> </body> </html>
-      HERE
-
-      # block for processing XML document fragments as XHTML,
-      # to allow for HTMLentities
-      # Unescape special chars used in Asciidoctor substitution processing
       def noko(&block)
-        doc = ::Nokogiri::XML.parse(NOKOHEAD)
-        fragment = doc.fragment("")
-        ::Nokogiri::XML::Builder.with fragment, &block
-        fragment.to_xml(encoding: "US-ASCII", indent: 0,
-                        save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
-          .lines.map do |l|
-          l.gsub(/>\n$/, ">").gsub(/\s*\n$/m, " ").gsub("&#150;", "\u0096")
-            .gsub("&#151;", "\u0097").gsub("&#x96;", "\u0096")
-            .gsub("&#x97;", "\u0097")
-        end
+        Metanorma::Utils::noko(&block)
       end
 
       def attr_code(attributes)
-        attributes.compact.transform_values do |v|
-          v.is_a?(String) ? HTMLEntities.new.decode(v) : v
-        end
+        Metanorma::Utils::attr_code(attributes)
+      end
+
+      def csv_split(text, delim = ";")
+        Metanorma::Utils::csv_split(text, delim)
       end
 
-      # if the contents of node are blocks, output them to out;
-      # else, wrap them in <p>
       def wrap_in_para(node, out)
-        if node.blocks? then out << node.content
-        else
-          out.p { |p| p << node.content }
-        end
+        Metanorma::Utils::wrap_in_para(node, out)
       end
 
       SUBCLAUSE_XPATH = "//clause[not(parent::sections)]"\
@@ -67,22 +44,11 @@ module Metanorma
       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
-        elem[name] = val.text
+        Metanorma::Utils::dl_to_attrs(elem, dlist, name)
       end
 
       def dl_to_elems(ins, elem, dlist, name)
-        a = elem.at("./#{name}[last()]")
-        ins = a if a
-        dlist.xpath("./dt[text()='#{name}']").each do |e|
-          v = e.at("./following::dd")
-          e = v.elements and e.size == 1 && e.first.name == "p" and v = e.first
-          v.name = name
-          ins.next = v
-          ins = ins.next
-        end
-        ins
+        Metanorma::Utils::dl_to_elems(ins, elem, dlist, name)
       end
 
       def term_expr(elem)