metanorma-standoc 1.11.4 → 2.0.3

data/lib/metanorma/standoc/ref.rb

@@ -0,0 +1,248 @@
+require_relative "ref_utility"
+
+module Metanorma
+  module Standoc
+    module Refs
+      def iso_publisher(bib, code)
+        code.sub(/ .*$/, "").split("/").each do |abbrev|
+          bib.contributor do |c|
+            c.role **{ type: "publisher" }
+            c.organization do |org|
+              organization(org, abbrev, true)
+            end
+          end
+        end
+      end
+
+      def isorefrender1(bib, match, year, allp = "")
+        bib.title(**plaintxt) { |i| i << ref_normalise(match[:text]) }
+        docid(bib, match[:usrlbl]) if match[:usrlbl]
+        docid(bib, id_and_year(match[:code], year) + allp)
+        docnumber(bib, match[:code])
+      end
+
+      def isorefmatchescode(match)
+        yr = norm_year(match[:year])
+        { code: match[:code], year: yr, match: match,
+          title: match[:text], usrlbl: match[:usrlbl],
+          lang: (@lang || :all) }
+      end
+
+      def isorefmatchesout(item, xml)
+        if item[:doc] then use_retrieved_relaton(item, xml)
+        else
+          xml.bibitem **attr_code(ref_attributes(item[:ref][:match])) do |t|
+            isorefrender1(t, item[:ref][:match], item[:ref][:year])
+            item[:ref][:year] and t.date **{ type: "published" } do |d|
+              set_date_range(d, item[:ref][:year])
+            end
+            iso_publisher(t, item[:ref][:match][:code])
+          end
+        end
+      end
+
+      def isorefmatches2code(match)
+        { code: match[:code], no_year: true,
+          note: match[:fn], year: nil, match: match,
+          title: match[:text], usrlbl: match[:usrlbl],
+          lang: (@lang || :all) }
+      end
+
+      def isorefmatches2out(item, xml)
+        if item[:doc] then use_retrieved_relaton(item, xml)
+        else isorefmatches2_1(xml, item[:ref][:match])
+        end
+      end
+
+      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, match[:code])
+          unless match[:fn].nil?
+            t.note(**plaintxt.merge(type: "Unpublished-Status")) do |p|
+              p << (match[:fn]).to_s
+            end
+          end
+        end
+      end
+
+      def isorefmatches3code(match)
+        yr = norm_year(match[:year])
+        hasyr = !yr.nil? && yr != "--"
+        { code: match[:code], match: match, yr: yr, hasyr: hasyr,
+          year: hasyr ? yr : nil,
+          all_parts: true, no_year: yr == "--",
+          text: match[:text], usrlbl: match[:usrlbl],
+          lang: (@lang || :all) }
+      end
+
+      def isorefmatches3out(item, xml)
+        if item[:doc] then use_retrieved_relaton(item, xml)
+        else
+          isorefmatches3_1(xml, item[:ref][:match], item[:ref][:yr],
+                           item[:ref][:hasyr], item[:doc])
+        end
+      end
+
+      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 << (match[:fn]).to_s
+            end
+          end
+          t.extent **{ type: "part" } do |e|
+            e.referenceFrom "all"
+          end
+        end
+      end
+
+      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
+        code[:id].sub!(/[:-](19|20)[0-9][0-9]$/, "")
+        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, match, code)
+        xml.bibitem **attr_code(id: match[:anchor],
+                                hidden: code[:hidden]) do |t|
+          t.formattedref **{ format: "application/x-isodoc+xml" } do |i|
+            i << ref_normalise_no_format(match[:text])
+          end
+          yr_match = /[:-](?<year>(19|20)[0-9][0-9])\b/.match(code[:id])
+          refitem_render1(match, code, t)
+          docnumber(t, code[:id]) unless /^\d+$|^\(.+\)$/.match?(code[:id])
+          conditional_date(t, yr_match || match, false)
+        end
+      end
+
+      # TODO: alternative where only title is available
+      def refitemcode(item, node)
+        m = NON_ISO_REF.match(item) and return refitem1code(item, m).compact
+        m = NON_ISO_REF1.match(item) and return refitem1code(item, m).compact
+        @log.add("AsciiDoc Input", node, "#{MALFORMED_REF}: #{item}")
+        {}
+      end
+
+      def refitem1code(_item, match)
+        code = analyse_ref_code(match[:code])
+        ((code[:id] && code[:numeric]) || code[:nofetch]) and
+          return { code: nil, match: match, analyse_code: code,
+                   hidden: code[:hidden] }
+        year = refitem1yr(code[:id])
+        { code: code[:id], analyse_code: code,
+          year: year,
+          title: match[:text], match: match, hidden: code[:hidden],
+          usrlbl: match[:usrlbl], lang: (@lang || :all) }
+      end
+
+      def refitem1yr(code)
+        yr_match = /[:-](?<year>(19|20)[0-9][0-9])\b/.match(code)
+        yr_match ? yr_match[:year] : nil
+      end
+
+      def refitemout(item, xml)
+        return nil if item[:ref][:match].nil?
+
+        item[:doc] or return refitem_render(xml, item[:ref][:match],
+                                            item[:ref][:analyse_code])
+        use_retrieved_relaton(item, xml)
+      end
+
+      ISO_REF =
+        %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9-]+|IEV)
+      (:(?<year>[0-9][0-9-]+))?\]</ref>,?\s*(?<text>.*)$}xm.freeze
+
+      ISO_REF_NO_YEAR =
+        %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9-]+):
+      (--|&\#821[12];)\]</ref>,?\s*
+        (<fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>)?,?\s?(?<text>.*)$}xm
+          .freeze
+
+      ISO_REF_ALL_PARTS =
+        %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9]+)
+      (:(?<year>--|&\#821[12];|[0-9][0-9-]+))?\s
+      \(all\sparts\)\]</ref>,?\s*
+        (<fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>,?\s?)?(?<text>.*)$}xm.freeze
+
+      NON_ISO_REF = %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[(?<usrlbl>\([^)]+\))?(?<code>.+?)\]</ref>,?\s*(?<text>.*)$}xm
+        .freeze
+
+      NON_ISO_REF1 = %r{^<ref\sid="(?<anchor>[^"]+)">
+      (?<usrlbl>\([^)]+\))?(?<code>.+?)</ref>,?\s*(?<text>.*)$}xm
+        .freeze
+
+      def reference1_matches(item)
+        matched = ISO_REF.match item
+        matched2 = ISO_REF_NO_YEAR.match item
+        matched3 = ISO_REF_ALL_PARTS.match item
+        [matched, matched2, matched3]
+      end
+
+      def reference1code(item, node)
+        matched, matched2, matched3 = reference1_matches(item)
+        if matched3.nil? && matched2.nil? && matched.nil?
+          refitemcode(item, node).merge(process: 0)
+        elsif !matched.nil? then isorefmatchescode(matched).merge(process: 1)
+        elsif !matched2.nil? then isorefmatches2code(matched2).merge(process: 2)
+        elsif !matched3.nil? then isorefmatches3code(matched3).merge(process: 3)
+        end
+      end
+
+      def reference1out(item, xml)
+        case item[:ref][:process]
+        when 0 then refitemout(item, xml)
+        when 1 then isorefmatchesout(item, xml)
+        when 2 then isorefmatches2out(item, xml)
+        when 3 then isorefmatches3out(item, xml)
+        end
+      end
+
+      def reference_preproc(node)
+        refs = node.items.each_with_object([]) do |b, m|
+          m << reference1code(b.text, node)
+        end
+        results = refs.each_with_index.with_object(Queue.new) do |(ref, i), res|
+          fetch_ref_async(ref.merge(ord: i), i, res)
+        end
+        [refs, results]
+      end
+
+      def reference(node)
+        refs, results = reference_preproc(node)
+        ret = reference_queue(refs, results)
+        noko do |xml|
+          ret.each { |b| reference1out(b, xml) }
+        end.join
+      end
+
+      def reference_queue(refs, results)
+        refs.each.with_object([]) do |_, m|
+          ref, i, doc = results.pop
+          m[i.to_i] = { ref: ref }
+          if doc.is_a?(RelatonBib::RequestError)
+            @log.add("Bibliography", nil, "Could not retrieve #{ref[:code]}: "\
+                                          "no access to online site")
+          else m[i.to_i][:doc] = doc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/ref_sect.rb

@@ -0,0 +1,153 @@
+module Metanorma
+  module Standoc
+    module Section
+      def in_biblio?
+        @biblio
+      end
+
+      def in_norm_ref?
+        @norm_ref
+      end
+
+      def bibliography_parse(attrs, xml, node)
+        x = biblio_prep(attrs, xml, node) and return x
+        @biblio = true
+        attrs = attrs.merge(normative: node.attr("normative") || false)
+        xml.references **attr_code(attrs) do |xml_section|
+          xml_section.title { |t| t << node.title }
+          xml_section << node.content
+        end
+        @biblio = false
+      end
+
+      def bibitem_parse(attrs, xml, node)
+        norm_ref = @norm_ref
+        biblio = @biblio
+        @biblio = false
+        @norm_ref = false
+        ret = clause_parse(attrs, xml, node)
+        @biblio = biblio
+        @norm_ref = norm_ref
+        ret
+      end
+
+      def norm_ref_parse(attrs, xml, node)
+        x = biblio_prep(attrs, xml, node) and return x
+        @norm_ref = true
+        attrs = attrs.merge(normative: node.attr("normative") || true)
+        xml.references **attr_code(attrs) do |xml_section|
+          xml_section.title { |t| t << node.title }
+          xml_section << node.content
+        end
+        @norm_ref = false
+      end
+
+      def biblio_prep(attrs, xml, node)
+        if node.option? "bibitem"
+          bibitem_parse(attrs, xml, node)
+        else
+          node.attr("style") == "bibliography" or
+            @log.add("AsciiDoc Input", node,
+                     "Section not marked up as [bibliography]!")
+          nil
+        end
+      end
+
+      def global_ievcache_name
+        "#{Dir.home}/.iev/cache"
+      end
+
+      def local_ievcache_name(cachename)
+        return nil if cachename.nil?
+
+        cachename += "_iev" unless cachename.empty?
+        cachename = "iev" if cachename.empty?
+        "#{cachename}/cache"
+      end
+
+      def fetch_ref(xml, code, year, **opts)
+        return nil if opts[:no_year]
+
+        code = code.sub(/^\([^)]+\)/, "")
+        hit = @bibdb&.fetch(code, year, opts)
+        return nil if hit.nil?
+
+        xml.parent.add_child(smart_render_xml(hit, code, opts))
+        xml
+      rescue RelatonBib::RequestError
+        @log.add("Bibliography", nil, "Could not retrieve #{code}: "\
+                                      "no access to online site")
+        nil
+      end
+
+      def fetch_ref_async(ref, idx, res)
+        if ref[:code].nil? || ref[:no_year] || @bibdb.nil?
+          res << [ref, idx, nil]
+        else
+          @bibdb.fetch_async(ref[:code], ref[:year], ref) do |doc|
+            res << [ref, idx, doc]
+          end
+        end
+      end
+
+      def emend_biblio(xml, code, title, usrlbl)
+        unless xml.at("/bibitem/docidentifier[not(@type = 'DOI')][text()]")
+          @log.add("Bibliography", nil,
+                   "ERROR: No document identifier retrieved for #{code}")
+          xml.root << "<docidentifier>#{code}</docidentifier>"
+        end
+        unless xml.at("/bibitem/title[text()]")
+          @log.add("Bibliography", nil,
+                   "ERROR: No title retrieved for #{code}")
+          xml.root << "<title>#{title || '(MISSING TITLE)'}</title>"
+        end
+        usrlbl and xml.at("/bibitem/docidentifier").next =
+                     "<docidentifier type='metanorma'>#{mn_code(usrlbl)}</docidentifier>"
+      end
+
+      def smart_render_xml(xml, code, opts)
+        xml.respond_to? :to_xml or return nil
+        xml = Nokogiri::XML(xml.to_xml(lang: opts[:lang]))
+        emend_biblio(xml, code, opts[:title], opts[:usrlbl])
+        xml.xpath("//date").each { |d| Metanorma::Utils::endash_date(d) }
+        xml.traverse do |n|
+          n.text? and n.replace(Metanorma::Utils::smartformat(n.text))
+        end
+        xml.to_xml.sub(/<\?[^>]+>/, "")
+      end
+
+      def use_retrieved_relaton(item, xml)
+        xml.parent.add_child(smart_render_xml(item[:doc], item[:ref][:code],
+                                              item[:ref]))
+        use_my_anchor(xml, item[:ref][:match][:anchor], item.dig(:ref, :analyse_code, :hidden))
+      end
+
+      def init_bib_caches(node)
+        return if @no_isobib
+
+        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(
+          local_cache: local,
+          flush_caches: node.attr("flush-caches"),
+          global_cache: global,
+        )
+      end
+
+      def init_iev_caches(node)
+        unless @no_isobib_cache || @no_isobib
+          node.attr("local-cache-only") or
+            @iev_globalname = global_ievcache_name
+          @iev_localname = local_ievcache_name(node.attr("local-cache") ||
+                                               node.attr("local-cache-only"))
+          if node.attr("flush-caches")
+            FileUtils.rm_f @iev_globalname unless @iev_globalname.nil?
+            FileUtils.rm_f @iev_localname unless @iev_localname.nil?
+          end
+        end
+        # @iev = Iev::Db.new(globalname, localname) unless @no_isobib
+      end
+    end
+  end
+end

data/lib/{asciidoctor/standoc/ref_date_id.rb → metanorma/standoc/ref_utility.rb}

@@ -1,4 +1,4 @@
-module Asciidoctor
+module Metanorma
   module Standoc
     module Refs
       def set_date_range(date, text)
@@ -31,8 +31,9 @@ module Asciidoctor
         end
       end
 
-      def use_my_anchor(ref, id)
+      def use_my_anchor(ref, id, hidden)
         ref.parent.elements.last["id"] = id
+        hidden and ref.parent.elements.last["hidden"] = hidden
         ref
       end
 
@@ -55,7 +56,9 @@ module Asciidoctor
       end
 
       def mn_code(code)
-        code.sub(/^\(/, "[").sub(/\).*$/, "]").sub(/^nofetch\((.+)\)$/, "\\1")
+        code.sub(/^\(/, "[").sub(/\).*$/, "]")
+          .sub(/^hidden\((.+)\)$/, "\\1")
+          .sub(/^nofetch\((.+)\)$/, "\\1")
       end
 
       def analyse_ref_nofetch(ret)
@@ -64,9 +67,16 @@ module Asciidoctor
         ret.merge(id: m[:id], nofetch: true)
       end
 
+      def analyse_ref_hidden(ret)
+        return ret unless m = /^hidden\((?<id>.+)\)$/.match(ret[:id])
+
+        ret.merge(id: m[:id], hidden: true)
+      end
+
       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)
@@ -79,12 +89,41 @@ module Asciidoctor
       end
 
       # ref id = (usrlbl)code[:-]year
-      # code = nofetch(code) | (repo|path):(key,code) | \[? number \]? | ident
+      # code = nofetch(code) | hidden(code) | (repo|path):(key,code) |
+      # \[? number \]? | ident
       def analyse_ref_code(code)
         ret = { id: code }
         return ret if code.blank?
 
-        analyse_ref_nofetch(analyse_ref_repo_path(analyse_ref_numeric(ret)))
+        analyse_ref_nofetch(
+          analyse_ref_hidden(analyse_ref_repo_path(analyse_ref_numeric(ret))),
+        )
+      end
+
+      # if no year is supplied, interpret as no_year reference
+      def no_year_generic_ref(code)
+        /^(BSI|BS)\b/.match?(code)
+      end
+
+      def plaintxt
+        { format: "text/plain" }
+      end
+
+      def ref_attributes(match)
+        { id: match[:anchor], type: "standard" }
+      end
+
+      MALFORMED_REF =
+        "no anchor on reference, markup may be malformed: see "\
+        "https://www.metanorma.com/author/topics/document-format/bibliography/ , "\
+        "https://www.metanorma.com/author/iso/topics/markup/#bibliographies".freeze
+
+      def ref_normalise(ref)
+        ref.gsub(/&amp;amp;/, "&amp;").gsub(%r{^<em>(.*)</em>}, "\\1")
+      end
+
+      def ref_normalise_no_format(ref)
+        ref.gsub(/&amp;amp;/, "&amp;")
       end
     end
   end

data/lib/metanorma/standoc/render.rb

@@ -0,0 +1,115 @@
+module Metanorma
+  module Standoc
+    module Base
+      def html_extract_attributes(node)
+        {
+          script: node.attr("script"),
+          bodyfont: node.attr("body-font"),
+          headerfont: node.attr("header-font"),
+          monospacefont: node.attr("monospace-font"),
+          i18nyaml: node.attr("i18nyaml"),
+          scope: node.attr("scope"),
+          htmlstylesheet: node.attr("htmlstylesheet"),
+          htmlstylesheet_override: node.attr("htmlstylesheet-override"),
+          htmlcoverpage: node.attr("htmlcoverpage"),
+          htmlintropage: node.attr("htmlintropage"),
+          scripts: node.attr("scripts"),
+          scripts_override: node.attr("scripts-override"),
+          scripts_pdf: node.attr("scripts-pdf"),
+          datauriimage: node.attr("data-uri-image") != "false",
+          htmltoclevels: node.attr("htmltoclevels") || node.attr("toclevels"),
+          doctoclevels: node.attr("doctoclevels") || node.attr("toclevels"),
+          break_up_urls_in_tables: node.attr("break-up-urls-in-tables"),
+          suppressasciimathdup: node.attr("suppress-asciimath-dup"),
+          bare: node.attr("bare"),
+          sectionsplit: node.attr("sectionsplit"),
+          baseassetpath: node.attr("base-asset-path"),
+          aligncrosselements: node.attr("align-cross-elements"),
+        }
+      end
+
+      def html_converter(node)
+        IsoDoc::HtmlConvert.new(html_extract_attributes(node))
+      end
+
+      def pdf_converter(node)
+        return nil if node.attr("no-pdf")
+
+        IsoDoc::Standoc::PdfConvert.new(pdf_extract_attributes(node))
+      end
+
+      def doc_extract_attributes(node)
+        attrs = {
+          script: node.attr("script"),
+          bodyfont: node.attr("body-font"),
+          headerfont: node.attr("header-font"),
+          monospacefont: node.attr("monospace-font"),
+          i18nyaml: node.attr("i18nyaml"),
+          scope: node.attr("scope"),
+          wordstylesheet: node.attr("wordstylesheet"),
+          wordstylesheet_override: node.attr("wordstylesheet-override"),
+          standardstylesheet: node.attr("standardstylesheet"),
+          header: node.attr("header"),
+          wordcoverpage: node.attr("wordcoverpage"),
+          wordintropage: node.attr("wordintropage"),
+          ulstyle: node.attr("ulstyle"),
+          olstyle: node.attr("olstyle"),
+          htmltoclevels: node.attr("htmltoclevels") || node.attr("toclevels"),
+          doctoclevels: node.attr("doctoclevels") || node.attr("toclevels"),
+          break_up_urls_in_tables: node.attr("break-up-urls-in-tables"),
+          suppressasciimathdup: node.attr("suppress-asciimath-dup"),
+          bare: node.attr("bare"),
+          baseassetpath: node.attr("base-asset-path"),
+          aligncrosselements: node.attr("align-cross-elements"),
+        }
+
+        if fonts_manifest = node.attr(FONTS_MANIFEST)
+          attrs[IsoDoc::XslfoPdfConvert::MN2PDF_OPTIONS] = {
+            IsoDoc::XslfoPdfConvert::MN2PDF_FONT_MANIFEST => fonts_manifest,
+          }
+        end
+
+        attrs
+      end
+
+      def pdf_extract_attributes(node)
+        %w(pdf-encrypt pdf-encryption-length pdf-user-password
+           pdf-owner-password pdf-allow-copy-content pdf-allow-edit-content
+           pdf-allow-assemble-document pdf-allow-edit-annotations
+           pdf-allow-print pdf-allow-print-hq pdf-allow-fill-in-forms
+           pdf-allow-access-content pdf-encrypt-metadata)
+          .each_with_object({}) do |x, m|
+          m[x.gsub(/-/, "").to_i] = node.attr(x)
+        end
+      end
+
+      def doc_converter(node)
+        IsoDoc::WordConvert.new(doc_extract_attributes(node))
+      end
+
+      def presentation_xml_converter(node)
+        IsoDoc::PresentationXMLConvert.new(html_extract_attributes(node))
+      end
+
+      def default_fonts(node)
+        b = node.attr("body-font") ||
+          (node.attr("script") == "Hans" ? '"Source Han Sans",serif' : '"Cambria",serif')
+        h = node.attr("header-font") ||
+          (node.attr("script") == "Hans" ? '"Source Han Sans",sans-serif' : '"Cambria",serif')
+        m = node.attr("monospace-font") || '"Courier New",monospace'
+        "$bodyfont: #{b};\n$headerfont: #{h};\n$monospacefont: #{m};\n"
+      end
+
+      def outputs(node, ret)
+        File.open("#{@filename}.xml", "w:UTF-8") { |f| f.write(ret) }
+        presentation_xml_converter(node).convert("#{@filename}.xml")
+        html_converter(node).convert("#{@filename}.presentation.xml",
+                                     nil, false, "#{@filename}.html")
+        doc_converter(node).convert("#{@filename}.presentation.xml",
+                                    nil, false, "#{@filename}.doc")
+        pdf_converter(node)&.convert("#{@filename}.presentation.xml",
+                                     nil, false, "#{@filename}.pdf")
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/reqt.rb

@@ -0,0 +1,90 @@
+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))
+      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
+      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
+      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 requirement_elems(node, out)
+        node.title and out.title { |t| t << node.title }
+        a = node.attr("label") and out.label do |l|
+          l << a
+        end
+        a = node.attr("subject") and csv_split(a)&.each do |subj|
+          out.subject { |s| s << subj }
+        end
+        a = HTMLEntities.new.decode(node.attr("inherit")) and
+          csv_split(a)&.each do |i|
+            out.inherit { |inh| inh << i }
+          end
+        classif = node.attr("classification") and
+          requirement_classification(classif, out)
+      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")
+      end
+    end
+  end
+end