metanorma 2.1.7 → 2.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9a70c61c914359e1637bfdf33edb5e2e560b92d2dd3922db64cec7fecaa5e32
-  data.tar.gz: fd5c55fe248e1a36e2ec0f25689aeb4b149ba94200daea52edea4a73065db69f
+  metadata.gz: b6f662b6213511d30fb8f16f0bc51bb4209959a4f17ac385d81bdd02f1135088
+  data.tar.gz: 4021db66267ad5cbc213058d7b2252d6a2f9572e6efd686df2f84ba1f1965cbb
 SHA512:
-  metadata.gz: 237cff4f2cb22825906017cd7286b7a3578603f0816b3b4c699117eb212b384fef8fac5d8d68a31ba6261b6b525db7375d2a796b4f0d4b689563026fecfa9381
-  data.tar.gz: 9a72304008e8e4c5d5571210d6a704389b88dbf85223f16709ace9c878fb761161f1aca7549642dd91a4a5030fa648d7203b43b3a2983f6a445bd1dfcd82a761
+  metadata.gz: 6ba138f8fd28e6e4ee1d0fcc786f49b17b816483c39a6d2dda89643b9611bed93068ac8f3e700ba199a01f0f0446ce2c46be97d4a7e705a67df04e6b1d898432
+  data.tar.gz: 45a50ed06452ff4e598bc95ce07412eeca39b33afe7158a48f17080381417cda79ba4ed4286901652a6e4f6311d0ad70e083388aba4e3150c22f543f56825dde

data/lib/metanorma/collection/collection.rb

@@ -172,7 +172,7 @@ module Metanorma
     def fetch_flavor
       docid = @bibdata.docidentifier.first or return
       f = docid.type.downcase || docid.id.sub(/\s.*$/, "").downcase or return
-      require ::Metanorma::Compile.new.stdtype2flavor(f)
+      require ::Metanorma::Compile.new.stdtype2flavor_gem(f)
       f
     rescue LoadError
       nil

data/lib/metanorma/collection/document/document.rb

@@ -68,6 +68,8 @@ module Metanorma
         def from_xml(xml)
           b = xml.at("//xmlns:bibitem|//xmlns:bibdata")
           r = mn2relaton_parser(xml.root.name)
+          # Relaton doesn't understand Pres XML tags
+          b.xpath("//xmlns:fmt-identifier").each(&:remove)
           r.from_xml(b.to_xml)
         end
 

data/lib/metanorma/collection/filelookup/filelookup.rb

@@ -18,6 +18,7 @@ module Metanorma
         @parent = parent
         @xml = parent.xml
         @isodoc = parent.isodoc
+        @isodoc_presxml = parent.isodoc_presxml
         @path = path
         @compile = parent.compile
         @documents = parent.documents
@@ -131,7 +132,7 @@ module Metanorma
 
       def add_document_suffix(identifier, doc)
         document_suffix = Metanorma::Utils::to_ncname(identifier)
-        Metanorma::Utils::anchor_attributes.each do |(tag_name, attr_name)|
+        Util::anchor_id_attributes.each do |(tag_name, attr_name)|
           Util::add_suffix_to_attrs(doc, document_suffix, tag_name, attr_name,
                                     @isodoc)
         end
@@ -230,7 +231,6 @@ module Metanorma
         ret = {}
         xml.traverse do |x|
           x.text? and next
-          /^semantic__/.match?(x.name) and next
           x["id"] and ret[x["id"]] = true
         end
         ret

data/lib/metanorma/collection/filelookup/filelookup_sectionsplit.rb

@@ -110,8 +110,9 @@ module Metanorma
         @sectionsplit = ::Metanorma::Collection::Sectionsplit
           .new(input: file, base: @files[ident][:out_path],
                dir: File.dirname(file), output: @files[ident][:out_path],
-               compile_opts: @parent.compile_options,
-               fileslookup: self, ident: ident, isodoc: @isodoc,
+               compile_opts: @parent.compile_options, ident: ident,
+               fileslookup: self, isodoc: @isodoc,
+               isodoc_presxml: @isodoc_presxml,
                document_suffix: @files[ident][:document_suffix])
         coll = @sectionsplit.sectionsplit.sort_by { |f| f[:order] }
         xml = Nokogiri::XML(File.read(file, encoding: "UTF-8"), &:huge)

data/lib/metanorma/collection/renderer/fileparse.rb

@@ -16,8 +16,6 @@ module Metanorma
       # @return [String] XML content
       def update_xrefs(file, docid, internal_refs)
         xml, sso = update_xrefs_prep(file, docid)
-        #require "debug"; binding.b if /This document is also unrelated/.match?(xml.to_xml)
-        #warn (/fmt-title/.match?(xml.to_xml) ? "*** PRESENTATION" : "*** SEMANTIC")
         @nested || sso or
           Metanorma::Collection::XrefProcess::xref_process(xml, xml, nil, docid,
                                                            @isodoc, sso)
@@ -26,7 +24,7 @@ module Metanorma
         @files.add_document_suffix(docid, xml)
         @nested or update_sectionsplit_refs_to_docs(xml, internal_refs, sso)
         update_direct_refs_to_docs(xml, docid, sso)
-        hide_refs(xml)
+        ::Metanorma::Collection::Util::hide_refs(xml)
         sso and eref2link(xml, sso)
         @nested or svgmap_resolve(xml, docid, sso)
         xml.to_xml
@@ -109,7 +107,6 @@ module Metanorma
             else no_anchor[k] << e end
           end
         end
-        #require "debug"; binding.b
         [erefs, no_anchor, anchors, Util::gather_bibitemids(docxml, presxml)]
       end
 
@@ -128,8 +125,9 @@ module Metanorma
 
       # Resolve erefs to a container of ids in another doc,
       # to an anchor eref (direct link)
-      def update_indirect_refs_to_docs(docxml, _docidentifier, internal_refs, presxml)
-        bib, erefs, doc_suffix, doc_type, f = update_indirect_refs_prep(docxml, presxml)
+      def update_indirect_refs_to_docs(docxml, _docid, internal_refs, presxml)
+        bib, erefs, doc_suffix, doc_type, f = update_indirect_refs_prep(docxml,
+                                                                        presxml)
         internal_refs.each do |schema, ids|
           add_suffix = doc_suffix && doc_type && doc_type != schema
           ids.each do |id, file|
@@ -149,37 +147,15 @@ module Metanorma
          docxml.root["document_suffix"], docxml.root["type"], {}]
       end
 
-      # KILL
-      def indirect_ref_key(schema, id, doc_suffix, doc_type)
-        /^#{schema}_/.match?(id) and return id
-        key = [schema, id, doc_suffix, doc_type].join("::")
-        x = @indirect_keys[key] and return x
-        ret = "#{schema}_#{id}"
-        doc_suffix && doc_type && doc_type != schema and
-          ret = "#{ret}_#{doc_suffix}"
-        @indirect_keys[key] = ret
-        ret
-      end
-
       def indirect_ref_key(schema, id, doc_suffix, add_suffix)
         /^#{schema}_/.match?(id) and return id
-        #key = "#{schema}_#{id}"
         x = @indirect_keys.dig(schema, id) and return x
         @indirect_keys[schema] ||= {}
         @indirect_keys[schema][id] = if add_suffix
-                                  "#{schema}_#{id}_#{doc_suffix}"
-                                else
-                                   "#{schema}_#{id}"
-                                end
-      end
-
-      # KILL
-      def indirect_ref_keyx(schema, id, doc_suffix, doc_type)
-        /^#{schema}_/.match?(id) and return id
-        ret = "#{schema}_#{id}"
-        doc_suffix && doc_type && doc_type != schema and
-          ret = "#{ret}_#{doc_suffix}"
-        ret
+                                       "#{schema}_#{id}_#{doc_suffix}"
+                                     else
+                                       "#{schema}_#{id}"
+                                     end
       end
 
       def update_indirect_refs_to_docs1(filec, key, file, bibitems, erefs)
@@ -196,13 +172,10 @@ module Metanorma
         parentid and file = "#{parentid}_#{file}"
         existing = a.text
         anchor = if url then existing
-                   else 
-                     #suffix_anchor_indirect(existing, suffix)
-                     #k = "#{existing}_#{file}"
-        #@ncnames[k] ||= Metanorma::Utils::to_ncname(k)
-        @indirect_keys[existing] ||= {}
-        @indirect_keys[existing][file] ||= Metanorma::Utils::to_ncname("#{existing}_#{file}")
-                   end
+                 else
+                   @indirect_keys[existing] ||= {}
+                   @indirect_keys[existing][file] ||= Metanorma::Utils::to_ncname("#{existing}_#{file}")
+                 end
         @updated_anchors[existing] or a.children = anchor
         @updated_anchors[anchor] = true
       end

data/lib/metanorma/collection/renderer/renderer.rb

@@ -15,7 +15,7 @@ module Metanorma
     class Renderer
       FORMATS = %i[html xml doc pdf].freeze
 
-      attr_accessor :isodoc, :nested
+      attr_accessor :isodoc, :isodoc_presxml, :nested
       attr_reader :xml, :compile, :compile_options, :documents, :outdir,
                   :manifest
 
@@ -45,6 +45,8 @@ module Metanorma
 
         # output processor for flavour
         @isodoc = Util::isodoc_create(@flavor, @lang, @script, @xml)
+        @isodoc_presxml = Util::isodoc_create(@flavor, @lang, @script, @xml,
+                                              presxml: true)
         @outdir = dir_name_cleanse(options[:output_folder])
         @coverpage = options[:coverpage] || collection.coverpage
         @format = ::Metanorma::Util.sort_extensions_execution(options[:format])

data/lib/metanorma/collection/renderer/utils.rb

@@ -17,6 +17,7 @@ module Metanorma
         newbib["hidden"] = "true"
         newbib&.at("./*[local-name() = 'ext']")&.remove
         newbib["id"] = bib["id"]
+        bib["anchor"] and newbib["anchor"] = bib["anchor"]
         newbib
       end
 
@@ -37,17 +38,10 @@ module Metanorma
         end
       end
 
-      def hide_refs(docxml)
-        docxml.xpath(ns("//references[bibitem][not(./bibitem[not(@hidden) or " \
-                        "@hidden = 'false'])]")).each do |f|
-          f["hidden"] = "true"
-        end
-      end
-
       def new_hidden_ref(xmldoc)
         ins = xmldoc.at(ns("bibliography")) or
           xmldoc.root << "<bibliography/>" and ins = xmldoc.at(ns("bibliography"))
-        ins.at(ns("./referenced[@hidden = 'true']")) or
+        ins.at(ns("./references[@hidden = 'true']")) or
           ins.add_child("<references hidden='true' normative='false'/>").first
       end
 
@@ -81,7 +75,7 @@ module Metanorma
         refs.each do |k, v|
           url = @files.url(v, {})
           ins << <<~XML
-            <bibitem id="#{k}">#{docid_xml(v)}<uri type='citation'>#{url}</uri></bibitem>
+            <bibitem id="#{k}" anchor="#{k}">#{docid_xml(v)}<uri type='citation'>#{url}</uri></bibitem>
           XML
         end
       end

data/lib/metanorma/collection/sectionsplit/collection.rb

@@ -39,6 +39,7 @@ module Metanorma
       end
 
       def collectionyaml(files, xml)
+        #warn xml.to_xml
         ret = {
           directives: ["presentation-xml", "bare-after-first"],
           bibdata: {

data/lib/metanorma/collection/sectionsplit/sectionsplit.rb

@@ -19,6 +19,7 @@ module Metanorma
         @fileslookup = opts[:fileslookup]
         @ident = opts[:ident]
         @isodoc = opts[:isodoc]
+        @isodoc_presxml = opts[:isodoc_presxml]
         @document_suffix = opts[:document_suffix]
       end
 
@@ -32,18 +33,19 @@ module Metanorma
          ["//bibliography/*[not(@hidden = 'true')]", "bibliography"],
          ["//indexsect", nil], ["//colophon", nil]].freeze
 
-      # Input XML is Semantic
+      # Input XML is Semantic XML
       def sectionsplit
         xml = sectionsplit_prep(File.read(@input_filename), @base, @dir)
         @key = Metanorma::Collection::XrefProcess::xref_preprocess(xml, @isodoc)
         empty = empty_doc(xml)
         empty1 = empty_attachments(empty)
         @mutex = Mutex.new
-        #@pool = Concurrent::FixedThreadPool.new(4)
+        # @pool = Concurrent::FixedThreadPool.new(4)
         @pool = Concurrent::FixedThreadPool.new(1)
         sectionsplit1(xml, empty, empty1, 0)
       end
 
+      # xml is Presentation XML
       def sectionsplit1(xml, empty, empty1, idx)
         ret = SPLITSECTIONS.each_with_object([]) do |n, m|
           conflate_floatingtitles(xml.xpath(ns(n[0]))).each do |s|
@@ -59,12 +61,14 @@ module Metanorma
 
       def sectionsplit2(xml, empty, chunks, parentnode, opt)
         @pool.post do
+          warn "#{@base}.#{opt[:idx]}"
           a = sectionfile(xml, empty, "#{@base}.#{opt[:idx]}", chunks,
                           parentnode)
           @mutex.synchronize { opt[:acc] << a }
         end
       end
 
+      # TODO move to metanorma-utils
       def block?(node)
         %w(p table formula admonition ol ul dl figure quote sourcecode example
            pre note pagebreak hr bookmark requirement recommendation permission
@@ -86,7 +90,6 @@ module Metanorma
         xml, type = sectionsplit_preprocess_semxml(file, filename)
         flags = { format: :asciidoc, extension_keys: [:presentation],
                   type: type }.merge(@compile_opts)
-        #require "debug"; binding.b
         Compile.new.compile(xml, flags)
         f = File.open(xml.sub(/\.xml$/, ".presentation.xml"), encoding: "utf-8")
         r = Nokogiri::XML(f, &:huge)
@@ -109,7 +112,6 @@ module Metanorma
         if c = @fileslookup&.parent
           n = c.nested
           c.nested = true # so unresolved erefs are not deleted
-        #require "debug"; binding.b
           c.update_xrefs(xml, @ident, {})
           c.nested = n
           xml.xpath("//xmlns:svgmap").each { |x| x.name = "svgmap1" }
@@ -125,35 +127,19 @@ module Metanorma
         outname
       end
 
-      def emptydoc(xml, ordinal)
-        out = xml.dup
-        out.xpath(
-          ns("//preface | //sections | //annex | //bibliography/clause | " \
-             "//bibliography/references[not(@hidden = 'true')] | " \
-             "//indexsect | //colophon"),
-        ).each(&:remove)
-        ordinal.zero? or out.xpath(ns("//metanorma-ext//attachment | " \
-                                      "//semantic__metanorma-ext//semantic__attachment"))
-          .each(&:remove) # keep only one copy of attachments
-        out
-      end
-
       def empty_doc(xml)
         out = xml.dup
         out.xpath(
-          ns("//preface | //sections | //annex | //bibliography/clause | " \
-             "//bibliography/references[not(@hidden = 'true')] | " \
-             "//indexsect | //colophon"),
+          ns("//preface | //sections | //annex | " \
+          "//references/bibitem[not(@hidden = 'true')] | " \
+          "//indexsect | //colophon"),
         ).each(&:remove)
+        ::Metanorma::Collection::Util::hide_refs(out)
         out
       end
 
       def empty_attachments(xml)
-        out = xml.dup
-        out.xpath(ns("//metanorma-ext//attachment | " \
-                     "//semantic__metanorma-ext//semantic__attachment"))
-          .each(&:remove) # keep only one copy of attachments
-        out
+        xml.dup
       end
 
       def sectionfile(fulldoc, xml, file, chunks, parentnode)
@@ -164,11 +150,10 @@ module Metanorma
 
       def create_sectionfile(xml, out, file, chunks, parentnode)
         ins = out.at(ns("//metanorma-extension")) || out.at(ns("//bibdata"))
-        #require "debug"; binding.b
         sectionfile_insert(ins, chunks, parentnode)
+        sectionfile_fn_filter(sectionfile_review_filter(out))
         Metanorma::Collection::XrefProcess::xref_process(out, xml, @key,
                                                          @ident, @isodoc, true)
-        #truncate_semxml(out, chunks)
         outname = "#{file}.xml"
         File.open(File.join(@splitdir, outname), "w:UTF-8") do |f|
           f.write(out)
@@ -176,36 +161,86 @@ module Metanorma
         outname
       end
 
-      # KILL
-      def semantic_xml_ids_gather(out)
-        out.at(ns("//semantic__bibdata")) or return
-        SPLITSECTIONS.each_with_object({}) do |s, m|
-          out.xpath(ns(s[0].sub("//", "//semantic__"))).each do |x|
-            x["id"] or next
-            m[x["id"].sub(/^semantic__/, "")] = x
+      def sectionfile_insert(ins, chunks, parentnode)
+        if parentnode
+          ins.next = "<#{parentnode}/>"
+          chunks.each { |c| ins.next.add_child(c.dup) }
+        else chunks.each { |c| ins.next = c.dup }
+        end
+      end
+
+      def sectionfile_fn_filter(xml)
+        ids = sectionfile_fn_filter_prep(xml)
+        xml.root.xpath(ns("./fmt-footnote-container/fmt-fn-body")).each do |f|
+          ids.has_key?(f["id"]) or f.remove
+        end
+        seen = {}
+        xml.root.xpath(ns("/fmt-footnote-container/fmt-fn-body"))
+          .each_with_index do |fnbody, i|
+            sectionfile_fn_filter_renumber(fnbody, i, ids, seen)
           end
+        xml
+      end
+
+      # map fmt-fn-body/@id = fn/@target to fn
+      def sectionfile_fn_filter_prep(xml)
+        xml.xpath(ns("//fn")).each_with_object({}) do |f, m|
+          m[f["target"]] ||= []
+          m[f["target"]] << f
         end
       end
 
-      # KILL
-      def semxml_presxml_nodes_match(nodes, chunks)
-        chunks.each do |x|
-          nodes[x["id"]] and nodes.delete(x["id"])
+      FN_CAPTIONS = ".//fmt-fn-label/span[@class = 'fmt-caption-label']".freeze
+
+      def sectionfile_fn_filter_renumber(fnbody, idx, ids, seen)
+        sectionfile_fn_filter_fn_renumber(fnbody, idx, ids, seen)
+        sectionfile_fn_filter_fnbody_renumber(fnbody, idx, ids)
+      end
+
+      def sectionfile_fn_filter_fn_renumber(fnbody, idx, ids, seen)
+        ids[fnbody["id"]].each do |f|
+          @isodoc_presxml.renumber_document_footnote(f, idx, seen)
+          fnlabel = f.at(ns(FN_CAPTIONS)) and
+            fnlabel.children = @isodoc_presxml.fn_ref_label(f)
         end
       end
 
-      # KILL
-      def truncate_semxml(out, chunks)
-        nodes = semantic_xml_ids_gather(out) or return
-        semxml_presxml_nodes_match(nodes, chunks)
-        nodes.each_value(&:remove)
+      def sectionfile_fn_filter_fnbody_renumber(fnbody, _idx, ids)
+        fnlabel = fnbody.at(ns(FN_CAPTIONS)) or return
+        fnbody["reference"] = ids[fnbody["id"]].first["reference"]
+        fnlabel.children = @isodoc_presxml.fn_body_label(fnbody)
       end
 
-      def sectionfile_insert(ins, chunks, parentnode)
-        if parentnode
-          ins.next = "<#{parentnode}/>"
-          chunks.each { |c| ins.next.add_child(c.dup) }
-        else chunks.each { |c| ins.next = c.dup }
+      # map fmt-review-body/@id = fmt-review-{start/end}/@target
+      # to fmt-review-{stary/end}
+      def sectionfile_review_filter_prep(xml)
+        xml.xpath(ns("//fmt-review-start | //fmt-review-end"))
+          .each_with_object({}) do |f, m|
+            m[f["target"]] ||= []
+            m[f["target"]] << f
+          end
+      end
+
+      def sectionfile_review_filter(xml)
+        ids = sectionfile_review_filter_prep(xml)
+        xml.root.xpath(ns("./review-container/fmt-review-body")).each do |f|
+          ids.has_key?(f["id"]) or f.remove
+        end
+        xml.root.xpath(ns("./review-container/fmt-review-body"))
+          .each_with_index do |fnbody, i|
+            sectionfile_review_filter_renumber(fnbody, i, ids)
+          end
+        xml
+      end
+
+      def sectionfile_review_filter_renumber(fnbody, _idx, ids)
+        ids[fnbody["id"]].each do |f|
+          case f.name
+          when "fmt-review-start"
+            f.children = @isodoc_presxml.comment_bookmark_start_label(f)
+          when "fmt-review-end"
+            f.children = @isodoc_presxml.comment_bookmark_end_label(f)
+          end
         end
       end
 
@@ -214,7 +249,7 @@ module Metanorma
         t = title.dup
         t.xpath(ns(".//tab | .//br")).each { |x| x.replace(" ") }
         t.xpath(ns(".//bookmark")).each(&:remove)
-        t.xpath('.//text()').map(&:text).join
+        t.xpath(".//text()").map(&:text).join
       end
     end
   end

data/lib/metanorma/collection/util/util.rb

@@ -2,6 +2,11 @@ module Metanorma
   class Collection
     module Util
       class << self
+        def anchor_id_attributes
+          Metanorma::Utils::anchor_attributes(presxml: true) +
+            [%w(* id), %w(* anchor), %w(link bibitemid), %w(fmt-link bibitemid)]
+        end
+
         def gather_bibitems(xml)
           xml.xpath("//xmlns:bibitem[@id]").each_with_object({}) do |b, m|
             if m[b["id"]]
@@ -16,7 +21,6 @@ module Metanorma
 
         def gather_bibitemids(xml, presxml)
           xml.xpath("//*[@bibitemid]").each_with_object({}) do |e, m|
-            #/^semantic__/.match?(e.name) and next
             presxml && %w(xref eref link).include?(e.name) and next
             m[e["bibitemid"]] ||= []
             m[e["bibitemid"]] << e
@@ -25,7 +29,6 @@ module Metanorma
 
         def gather_citeases(xml, presxml)
           xml.xpath("//*[@citeas]").each_with_object({}) do |e, m|
-            #/^semantic__/.match?(e.name) and next
             presxml && %w(xref eref link).include?(e.name) and next
             k = key(e["citeas"])
             m[k] ||= []
@@ -36,6 +39,8 @@ module Metanorma
         def add_suffix_to_attrs(doc, suffix, tag_name, attr_name, isodoc)
           (suffix.nil? || suffix.empty?) and return
           doc.xpath(isodoc.ns("//#{tag_name}[@#{attr_name}]")).each do |elem|
+            #warn "#{tag_name} : #{elem.name}" if attr_name == "bibitemid"
+            #require 'debug'; binding.b if attr_name == "bibitemid" && #!%w(eref fmt-eref link fmt-link).include?(elem.name)
             a = elem.attributes[attr_name].value
             /_#{suffix}$/.match?(a) or
               elem.attributes[attr_name].value = "#{a}_#{suffix}"
@@ -55,6 +60,14 @@ module Metanorma
           p.absolute? ? path : File.join(dir, path)
         end
 
+        def hide_refs(docxml)
+          p = "//xmlns:references[xmlns:bibitem]"\
+            "[not(./xmlns:bibitem[not(@hidden) or @hidden = 'false'])]"
+          docxml.xpath(p).each do |f|
+            f["hidden"] = "true"
+          end
+        end
+
         def key(ident)
           @c ||= HTMLEntities.new
           @c.decode(ident).gsub(/(\p{Zs})+/, " ")
@@ -67,20 +80,20 @@ module Metanorma
         def load_isodoc(flavor, presxml: false)
           x = Asciidoctor.load nil, backend: flavor.to_sym
           if presxml
-          x.converter.presentation_xml_converter(Dummy.new)
+            x.converter.presentation_xml_converter(Dummy.new)
           else
-          x.converter.html_converter(Dummy.new) # to obtain Isodoc class
+            x.converter.html_converter(Dummy.new) # to obtain Isodoc class
           end
         end
 
         def isodoc_create(flavor, lang, script, xml, presxml: false)
-        isodoc = Util::load_isodoc(flavor, presxml: presxml)
-        isodoc.i18n_init(lang, script, nil) # read in internationalisation
-        # TODO locale?
-        isodoc.metadata_init(lang, script, nil, isodoc.i18n)
-        isodoc.info(xml, nil)
-        isodoc
-      end
+          isodoc = Util::load_isodoc(flavor, presxml: presxml)
+          isodoc.i18n_init(lang, script, nil) # read in internationalisation
+          # TODO locale?
+          isodoc.metadata_init(lang, script, nil, isodoc.i18n)
+          isodoc.info(xml, nil)
+          isodoc
+        end
       end
     end
   end

data/lib/metanorma/collection/xrefprocess/xrefprocess.rb

@@ -10,8 +10,7 @@ module Metanorma
           @isodoc = isodoc
           key = (0...8).map { rand(65..90).chr }.join # random string
           xml.root["type"] = key
-          Metanorma::Utils::anchor_attributes
-            .each do |(tag_name, attr_name)|
+          Util::anchor_id_attributes.each do |(tag_name, attr_name)|
               #tag_name == "xref" and tag_name = "fmt-xref"
             ::Metanorma::Collection::Util::add_suffix_to_attrs(
               xml, xml.root["document_suffix"], tag_name, attr_name, isodoc
@@ -225,7 +224,7 @@ module Metanorma
 
         def new_indirect_bibitem(ident, prefix)
           <<~BIBENTRY
-            <bibitem id="#{ident}" type="internal">
+            <bibitem id="#{ident}" anchor="#{ident}" type="internal">
             <docidentifier type="repository">#{ident.sub(/^#{prefix}_/, "#{prefix}/")}</docidentifier>
             </bibitem>
           BIBENTRY

data/lib/metanorma/compile/assets/icc-boilerplate.adoc

@@ -0,0 +1,41 @@
+== copyright-statement
+=== Copyright notice
+
+Copyright © 1994-{{docyear}} International Color Consortium®
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+the Specification and associated documentation files (the “Specification”) to
+deal in the Specification without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, and/or sublicense
+copies of the Specification, and to permit persons to whom the Specification is
+furnished to do so, subject to the following conditions.
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Specification.
+
+The Specification is provided "as is", without warranty of any kind, express,
+implied, or otherwise, including but not limited to the warranties of
+merchantability, fitness for a particular purpose and noninfringement. In no
+event shall the International Color Consortium be liable for any claim, damages
+or other liability, whether in an action of contract, tort or otherwise, arising
+from, out of, or in connection with the Specification or the use or other
+dealings in the Specification.
+
+Except as contained in this notice, the name of the International Color
+Consortium shall not be used in advertising or otherwise to promote the use or
+other dealings in this Specification without prior written authorization from
+the International Color Consortium.
+
+== license-statement
+=== Licenses and trademarks
+
+International Color Consortium and the ICC logo are registered trademarks of the
+International Color Consortium. Rather than put a trademark symbol in every
+occurrence of other trademarked names, we state that we are using the names only
+in an editorial fashion, and to the benefit of the trademark owner, with no
+intention of infringement of the trademark.
+
+== feedback-statement
+=== For additional information on the ICC
+
+Visit the ICC Web site: http://www.color.org

data/lib/metanorma/compile/compile.rb

@@ -18,6 +18,7 @@ require_relative "output_filename"
 require_relative "output_filename_config"
 require_relative "flavor"
 require_relative "relaton_drop"
+require_relative "render"
 
 module Metanorma
   class Compile
@@ -114,20 +115,18 @@ module Metanorma
     # @param options [Hash] compilation options
     # @return [Hash] paths for different output formats
     def prepare_output_paths(filename, bibdata, options)
-      basename = if !options[:filename_template].nil?
+      basename = if options[:filename_template].nil?
+                   filename.sub(/\.[^.]+$/, "")
+                 else
                    drop = RelatonDrop.new(bibdata)
                    config = OutputFilenameConfig.new(options[:filename_template])
                    config.generate_filename(drop)
-                 else
-                   filename.sub(/\.[^.]+$/, "")
                  end
-
       @output_filename = OutputFilename.new(
         basename,
         options[:output_dir],
         @processor,
       )
-
       {
         xml: @output_filename.semantic_xml,
         orig_filename: filename,
@@ -175,53 +174,40 @@ module Metanorma
       end
     end
 
-    # Generate presentation XML from semantic XML
-    def generate_presentation_xml(
-      source_file, semantic_xml, bibdata, output_paths, options
-    )
-      process_ext(
-        :presentation, source_file, semantic_xml, bibdata, output_paths, options
-      )
-    end
-
-    # Generate multiple output formats with parallel processing
-    def generate_outputs_parallel(
-      source_file, semantic_xml, bibdata, extensions, output_paths, options
-    )
-      @queue = ::Metanorma::Util::WorkersPool.new(
-        ENV["METANORMA_PARALLEL"]&.to_i || DEFAULT_NUM_WORKERS,
-      )
-
-      # Install required fonts for all extensions
-      gather_and_install_fonts(source_file, options.dup, extensions)
-
-      # Process each extension in order
-      process_extensions_in_order(
-        source_file, semantic_xml, bibdata, extensions, output_paths, options
-      )
-
-      @queue.shutdown
+    def process_input_adoc_hdr(file, options)
+      hdr, rest = Metanorma::Input::Asciidoc.new.header(file)
+      attrs = hdr.split("\n")
+      options[:asciimath] and attrs << ":mn-keep-asciimath:"
+      process_input_adoc_overrides(attrs, options)
+      "#{attrs.join("\n")}\n\n#{rest}"
     end
 
-    def process_extensions_in_order(
-      source_file, semantic_xml, bibdata, extensions, output_paths, options
-    )
-      Util.sort_extensions_execution(extensions).each do |ext|
-        process_ext(
-          ext, source_file, semantic_xml, bibdata, output_paths, options
-        ) or break
+    # TODO: to config
+    def process_input_adoc_overrides(attrs, options)
+      case options[:supplied_type]
+      when :icc
+        f = File.join(File.dirname(__FILE__), "assets", "icc-boilerplate.adoc")
+        [":boilerplate-authority: #{f}",
+         ":publisher: International Color Consortium",
+         ":publisher_abbr: ICC"].each { |a| attrs << a }
+        options[":boilerplate-authority:"] = f
       end
+      attrs
     end
 
-    def process_input_adoc(filename, options)
-      Util.log("[metanorma] Processing: AsciiDoc input.", :info)
-      file = read_file(filename)
-      options[:asciimath] and
-        file.sub!(/^(=[^\n]+\n)/, "\\1:mn-keep-asciimath:\n")
+    def process_input_adoc_includes(file, filename)
       dir = File.dirname(filename)
       dir != "." and
         file = file.gsub(/^include::/, "include::#{dir}/")
           .gsub(/^embed::/, "embed::#{dir}/")
+      file
+    end
+
+    def process_input_adoc(filename, options)
+      Util.log("[metanorma] Processing: AsciiDoc input.", :info)
+      file = read_file(filename)
+      file = process_input_adoc_hdr(file, options)
+      file = process_input_adoc_includes(file, filename)
       [file, @processor.input_to_isodoc(file, filename, options)]
     end
 
@@ -235,166 +221,5 @@ module Metanorma
     def read_file(filename)
       File.read(filename, encoding: "utf-8").gsub("\r\n", "\n")
     end
-
-    # Export given bibliographic data to Relaton XML on disk
-    # @param bibdata [Nokogiri::XML::Element] the bibliographic data element
-    # @param options [Hash] compilation options
-    def export_relaton_from_bibdata(bibdata, options)
-      return unless options[:relaton]
-
-      # docid = bibdata&.at("./xmlns:docidentifier")&.text || options[:filename]
-      # outname = docid.sub(/^\s+/, "").sub(/\s+$/, "").gsub(/\s+/, "-") + ".xml"
-      export_output(options[:relaton], bibdata.to_xml)
-    end
-
-    # @param xml [Nokogiri::XML::Document] the XML document
-    # @return [Nokogiri::XML::Element] the bibliographic data element
-    def extract_relaton_metadata(xml)
-      xml.at("//bibdata") || xml.at("//xmlns:bibdata")
-    end
-
-    def wrap_html(options, file_extension, outfilename)
-      if options[:wrapper] && /html$/.match(file_extension)
-        outfilename = outfilename.sub(/\.html$/, "")
-        FileUtils.mkdir_p outfilename
-        FileUtils.mv "#{outfilename}.html", outfilename
-        FileUtils.mv "#{outfilename}_images", outfilename, force: true
-      end
-    end
-
-    # isodoc is Raw Metanorma XML
-
-    def gather_and_install_fonts(source_file, options, extensions)
-      Util.sort_extensions_execution(extensions).each do |ext|
-        isodoc_options = get_isodoc_options(source_file, options, ext)
-        font_install(isodoc_options.merge(options))
-      end
-    end
-
-    # Process a single extension (output format)
-    def process_ext(ext, source_file, semantic_xml, bibdata, output_paths,
-options)
-      output_paths[:ext] = @processor.output_formats[ext]
-      output_paths[:out] = @output_filename.for_format(ext) ||
-        output_paths[:xml].sub(/\.[^.]+$/, ".#{output_paths[:ext]}")
-      isodoc_options = get_isodoc_options(source_file, options, ext)
-
-      # Handle special cases first
-      return true if process_ext_special(
-        ext, semantic_xml, bibdata, output_paths, options, isodoc_options
-      )
-
-      # Otherwise, determine if it uses presentation XML
-      if @processor.use_presentation_xml(ext)
-        # Format requires presentation XML first, then convert to final format
-        process_via_presentation_xml(ext, output_paths, options, isodoc_options)
-      else
-        # Format can be generated directly from semantic XML
-        process_from_semantic_xml(
-          ext, output_paths, semantic_xml, isodoc_options
-        )
-      end
-    end
-
-    # Process special extensions with custom handling
-    def process_ext_special(
-      ext, semantic_xml, bibdata, output_paths, options, isodoc_options
-    )
-      if ext == :rxl
-
-        # Special case: Relaton export
-        export_relaton_from_bibdata(
-          bibdata,
-          options.merge(relaton: output_paths[:out]),
-        )
-        true
-
-      elsif ext == :presentation && options[:passthrough_presentation_xml]
-
-        # Special case: Pass through presentation XML
-        f = if File.exist?(output_paths[:orig_filename])
-              output_paths[:orig_filename]
-            else
-              output_paths[:xml]
-            end
-
-        FileUtils.cp f, output_paths[:presentationxml]
-        true
-
-      elsif ext == :html && options[:sectionsplit]
-
-        # Special case: Split HTML into sections
-        sectionsplit_convert(
-          output_paths[:xml], semantic_xml, output_paths[:out], isodoc_options
-        )
-        true
-      else
-        false
-      end
-    end
-
-    # Process format that requires presentation XML
-    def process_via_presentation_xml(ext, output_paths, options, isodoc_options)
-      @queue.schedule(ext, output_paths.dup, options.dup,
-                      isodoc_options.dup) do |a, b, c, d|
-        process_output_from_presentation_xml(a, b, c, d)
-      end
-    end
-
-    # Generate output format from presentation XML
-    def process_output_from_presentation_xml(ext, output_paths, options,
-isodoc_options)
-      @processor.output(nil, output_paths[:presentationxml],
-                        output_paths[:out], ext, isodoc_options)
-      wrap_html(options, output_paths[:ext], output_paths[:out])
-    rescue StandardError => e
-      strict = ext == :presentation || isodoc_options[:strict] == true
-      isodoc_error_process(e, strict, false)
-    end
-
-    # Process format directly from semantic XML
-    def process_from_semantic_xml(ext, output_paths, semantic_xml,
-isodoc_options)
-      @processor.output(semantic_xml, output_paths[:xml], output_paths[:out],
-                        ext, isodoc_options)
-      true # Return as Thread equivalent
-    rescue StandardError => e
-      strict = ext == :presentation || isodoc_options[:strict] == "true"
-      isodoc_error_process(e, strict, true)
-      ext != :presentation
-    end
-
-    # assume we pass in Presentation XML, but we want to recover Semantic XML
-    def sectionsplit_convert(input_filename, file, output_filename = nil,
-                             opts = {})
-      @isodoc ||= IsoDoc::PresentationXMLConvert.new({})
-      input_filename += ".xml" unless input_filename.match?(/\.xml$/)
-      File.exist?(input_filename) or
-        export_output(input_filename, file)
-      presxml = File.read(input_filename, encoding: "utf-8")
-      _xml, filename, dir = @isodoc.convert_init(presxml, input_filename, false)
-
-      ::Metanorma::Collection::Sectionsplit.new(
-        input: input_filename,
-        isodoc: @isodoc,
-        xml: presxml,
-        base: File.basename(output_filename || filename),
-        output: output_filename || filename,
-        dir: dir,
-        compile_opts: opts,
-      ).build_collection
-    end
-
-    private
-
-    def isodoc_error_process(err, strict, must_abort)
-      if strict || err.message.include?("Fatal:")
-        @errors << err.message
-      else
-        puts err.message
-      end
-      puts err.backtrace.join("\n")
-      must_abort and 1
-    end
   end
 end

data/lib/metanorma/compile/compile_options.rb

@@ -18,17 +18,9 @@ module Metanorma
       end
 
       def extract_options(filename, options)
-        content = read_file(filename)
-        o = Metanorma::Input::Asciidoc.new.extract_metanorma_options(content)
-          .merge(extract_xml_options(content))
-        options[:type] ||= o[:type]&.to_sym
-        t = @registry.alias(options[:type]) and options[:type] = t
-        dir = filename.sub(%r(/[^/]+$), "/")
-        options[:relaton] ||= File.join(dir, o[:relaton]) if o[:relaton]
-        if o[:sourcecode]
-          options[:sourcecode] ||= File.join(dir,
-                                             o[:sourcecode])
-        end
+        o = options_in_file(filename)
+        extract_flavor_options(options, o)
+        extract_dir_options(options, o, filename)
         options[:extension_keys] ||= o[:extensions]&.split(/, */)&.map(&:to_sym)
         options[:extension_keys] = nil if options[:extension_keys] == [:all]
         options[:format] ||= :asciidoc
@@ -38,6 +30,29 @@ module Metanorma
         options
       end
 
+      def options_in_file(filename)
+        content = read_file(filename)
+        Metanorma::Input::Asciidoc.new.extract_metanorma_options(content)
+          .merge(extract_xml_options(content))
+      end
+
+      def extract_flavor_options(options, options_in_file)
+        options[:type] ||= options_in_file[:type]
+        options[:type] = options[:type]&.to_sym
+        options[:supplied_type] = options[:type]
+        t = @registry.alias(options[:type]) and options[:type] = t
+      end
+
+      def extract_dir_options(options, options_in_file, filename)
+        dir = filename.sub(%r(/[^/]+$), "/")
+        options_in_file[:relaton] and
+          options[:relaton] ||= File.join(dir,
+                                          options_in_file[:relaton])
+        options_in_file[:sourcecode] and
+          options[:sourcecode] ||= File.join(dir,
+                                             options_in_file[:sourcecode])
+      end
+
       def get_extensions(options)
         ext = extract_extensions(options)
         !ext.include?(:presentation) && ext.any? do |e|
@@ -70,7 +85,7 @@ module Metanorma
 
       def unsupported_format_error(ext)
         message = "[metanorma] Error: #{ext} format is not supported " \
-                  "for this standard."
+          "for this standard."
         @errors << message
         Util.log(message, :error)
       end

data/lib/metanorma/compile/flavor.rb

@@ -8,7 +8,7 @@ module Metanorma
       # @return [void]
       def load_flavor(stdtype)
         stdtype = stdtype.to_sym
-        flavor = stdtype2flavor(stdtype)
+        flavor = stdtype2flavor_gem(stdtype)
         @registry.supported_backends.include? stdtype or
           Util.log("[metanorma] Info: Loading `#{flavor}` gem "\
                    "for standard type `#{stdtype}`.", :info)
@@ -21,15 +21,12 @@ module Metanorma
       # Convert the standard type to the flavor gem name
       # @param stdtype [Symbol] the standard type
       # @return [String] the flavor gem name
-      def stdtype2flavor(stdtype)
-        flavor = STDTYPE2FLAVOR[stdtype] || stdtype
-        "metanorma-#{flavor}"
+      def stdtype2flavor_gem(stdtype)
+        "metanorma-#{stdtype}"
       end
 
       private
 
-      STDTYPE2FLAVOR = {}.freeze
-
       def require_flavor(flavor)
         require flavor
         Util.log("[metanorma] Info: gem `#{flavor}` loaded.", :info)

data/lib/metanorma/compile/render.rb

@@ -0,0 +1,178 @@
+module Metanorma
+  class Compile
+    # Generate presentation XML from semantic XML
+    def generate_presentation_xml(source_file, xml, bibdata, output_paths, opt)
+      process_ext(:presentation, source_file, xml, bibdata, output_paths, opt)
+    end
+
+    # Generate multiple output formats with parallel processing
+    def generate_outputs_parallel(
+      source_file, semantic_xml, bibdata, extensions, output_paths, options
+    )
+      @queue = ::Metanorma::Util::WorkersPool.new(
+        ENV["METANORMA_PARALLEL"]&.to_i || DEFAULT_NUM_WORKERS,
+      )
+      # Install required fonts for all extensions
+      gather_and_install_fonts(source_file, options.dup, extensions)
+      # Process each extension in order
+      process_extensions_in_order(
+        source_file, semantic_xml, bibdata, extensions, output_paths, options
+      )
+      @queue.shutdown
+    end
+
+    def process_extensions_in_order(
+      source_file, semantic_xml, bibdata, extensions, output_paths, options
+    )
+      Util.sort_extensions_execution(extensions).each do |ext|
+        process_ext(
+          ext, source_file, semantic_xml, bibdata, output_paths, options
+        ) or break
+      end
+    end
+
+    # Export given bibliographic data to Relaton XML on disk
+    # @param bibdata [Nokogiri::XML::Element] the bibliographic data element
+    # @param options [Hash] compilation options
+    def export_relaton_from_bibdata(bibdata, options)
+      options[:relaton] or return
+      export_output(options[:relaton], bibdata.to_xml)
+    end
+
+    # @param xml [Nokogiri::XML::Document] the XML document
+    # @return [Nokogiri::XML::Element] the bibliographic data element
+    def extract_relaton_metadata(xml)
+      xml.at("//bibdata") || xml.at("//xmlns:bibdata")
+    end
+
+    def wrap_html(options, file_extension, outfilename)
+      if options[:wrapper] && /html$/.match(file_extension)
+        outfilename = outfilename.sub(/\.html$/, "")
+        FileUtils.mkdir_p outfilename
+        FileUtils.mv "#{outfilename}.html", outfilename
+        FileUtils.mv "#{outfilename}_images", outfilename, force: true
+      end
+    end
+
+    # isodoc is Raw Metanorma XML
+    def gather_and_install_fonts(source_file, options, extensions)
+      Util.sort_extensions_execution(extensions).each do |ext|
+        isodoc_options = get_isodoc_options(source_file, options, ext)
+        font_install(isodoc_options.merge(options))
+      end
+    end
+
+    # Process a single extension (output format)
+    def process_ext(ext, source_file, semantic_xml, bibdata, output_paths,
+                    options)
+      output_paths[:ext] = @processor.output_formats[ext]
+      output_paths[:out] = @output_filename.for_format(ext) ||
+        output_paths[:xml].sub(/\.[^.]+$/, ".#{output_paths[:ext]}")
+      isodoc_options = get_isodoc_options(source_file, options, ext)
+
+      # Handle special cases first
+      return true if process_ext_special(
+        ext, semantic_xml, bibdata, output_paths, options, isodoc_options
+      )
+
+      # Otherwise, determine if it uses presentation XML
+      if @processor.use_presentation_xml(ext)
+        # Format requires presentation XML first, then convert to final format
+        process_via_presentation_xml(ext, output_paths, options, isodoc_options)
+      else
+        # Format can be generated directly from semantic XML
+        process_from_semantic_xml(
+          ext, output_paths, semantic_xml, isodoc_options
+        )
+      end
+    end
+
+    # Process special extensions with custom handling
+    def process_ext_special(
+      ext, sem_xml, bibdata, output_paths, options, isodoc_options
+    )
+      if ext == :rxl
+        # Special case: Relaton export
+        export_relaton_from_bibdata(
+          bibdata,
+          options.merge(relaton: output_paths[:out]),
+        )
+        true
+      elsif ext == :presentation && options[:passthrough_presentation_xml]
+        # Special case: Pass through presentation XML
+        f = if File.exist?(output_paths[:orig_filename])
+              output_paths[:orig_filename]
+            else
+              output_paths[:xml]
+            end
+        FileUtils.cp f, output_paths[:presentationxml]
+        true
+      elsif ext == :html && options[:sectionsplit]
+        # Special case: Split HTML into sections
+        sectionsplit_convert(
+          output_paths[:xml], sem_xml, output_paths[:out], isodoc_options
+        )
+        true
+      else
+        false
+      end
+    end
+
+    # Process format that requires presentation XML
+    def process_via_presentation_xml(ext, output_paths, options, isodoc_options)
+      @queue.schedule(ext, output_paths.dup, options.dup,
+                      isodoc_options.dup) do |a, b, c, d|
+                        process_output_from_presentation_xml(a, b, c, d)
+                      end
+    end
+
+    # Generate output format from presentation XML
+    def process_output_from_presentation_xml(ext, output_paths, options,
+                                             isodoc_options)
+      @processor.output(nil, output_paths[:presentationxml],
+                        output_paths[:out], ext, isodoc_options)
+      wrap_html(options, output_paths[:ext], output_paths[:out])
+    rescue StandardError => e
+      strict = ext == :presentation || isodoc_options[:strict] == true
+      isodoc_error_process(e, strict, false)
+    end
+
+    # Process format directly from semantic XML
+    def process_from_semantic_xml(ext, output_paths, sem_xml, isodoc_options)
+      @processor.output(sem_xml, output_paths[:xml], output_paths[:out],
+                        ext, isodoc_options)
+      true # Return as Thread equivalent
+    rescue StandardError => e
+      strict = ext == :presentation || isodoc_options[:strict] == "true"
+      isodoc_error_process(e, strict, true)
+      ext != :presentation
+    end
+
+    # assume we pass in Presentation XML, but we want to recover Semantic XML
+    def sectionsplit_convert(input_filename, file, output_filename = nil,
+                             opts = {})
+      @isodoc ||= IsoDoc::PresentationXMLConvert.new({})
+      input_filename += ".xml" unless input_filename.match?(/\.xml$/)
+      File.exist?(input_filename) or export_output(input_filename, file)
+      presxml = File.read(input_filename, encoding: "utf-8")
+      _xml, filename, dir = @isodoc.convert_init(presxml, input_filename, false)
+      ::Metanorma::Collection::Sectionsplit.new(
+        input: input_filename, isodoc: @isodoc, xml: presxml,
+        base: File.basename(output_filename || filename),
+        output: output_filename || filename, dir: dir, compile_opts: opts
+      ).build_collection
+    end
+
+    private
+
+    def isodoc_error_process(err, strict, must_abort)
+      if strict || err.message.include?("Fatal:")
+        @errors << err.message
+      else
+        puts err.message
+      end
+      puts err.backtrace.join("\n")
+      must_abort and 1
+    end
+  end
+end

data/lib/metanorma/compile/validator.rb

@@ -9,19 +9,17 @@ module Metanorma
       end
 
       def validate_type!(options)
-        unless options[:type]
+        options[:type] or
           Util.log("[metanorma] Error: Please specify a standard type: "\
                    "#{@registry.supported_backends}.", :fatal)
-        end
         stdtype = options[:type].to_sym
         load_flavor(stdtype)
       end
 
       def validate_format!(options)
-        unless options[:format] == :asciidoc
+        options[:format] == :asciidoc or
           Util.log("[metanorma] Error: Only source file format currently "\
                    "supported is 'asciidoc'.", :fatal)
-        end
       end
     end
   end

data/lib/metanorma/input/asciidoc.rb

@@ -13,8 +13,14 @@ module Metanorma
         ::Asciidoctor.convert(file, out_opts)
       end
 
+      def header(file)
+        ret = file.split("\n\n", 2) or return [nil, nil]
+        ret[0] and ret[0] += "\n"
+        [ret[0], ret[1]]
+      end
+
       def extract_metanorma_options(file)
-        hdr = file.sub(/\n\n.*$/m, "\n")
+        hdr, = header(file)
         /\n:(?:mn-)?(?:document-class|flavor):\s+(?<type>\S[^\n]*)\n/ =~ hdr
         /\n:(?:mn-)?output-extensions:\s+(?<extensions>\S[^\n]*)\n/ =~ hdr
         /\n:(?:mn-)?relaton-output-file:\s+(?<relaton>\S[^\n]*)\n/ =~ hdr
@@ -22,7 +28,7 @@ module Metanorma
         /\n(?<novalid>:novalid:[^\n]*)\n/ =~ hdr
         if defined?(asciimath)
           asciimath =
-            !asciimath.nil? && !/keep-asciimath: false/.match?(asciimath)
+            !asciimath.nil? && !/keep-asciimath:\s*false/.match?(asciimath)
         end
         asciimath = nil if asciimath == false
         {
@@ -68,17 +74,17 @@ module Metanorma
       end
 
       def extract_options(file)
-        header = file.sub(/\n\n.*$/m, "\n")
+        hdr, = header(file)
         ret = ADOC_OPTIONS.each_with_object({}) do |w, acc|
-          m = /\n:#{w}:\s+([^\n]+)\n/.match(header) or next
+          m = /\n:#{w}:\s+([^\n]+)\n/.match(hdr) or next
           acc[attr_name_normalise(w)] = m[1]&.strip
         end
         ret2 = EMPTY_ADOC_OPTIONS_DEFAULT_TRUE.each_with_object({}) do |w, acc|
-          m = /\n:#{w}:([^\n]*)\n/.match(header) || [nil, "true"]
+          m = /\n:#{w}:([^\n]*)\n/.match(hdr) || [nil, "true"]
           acc[attr_name_normalise(w)] = (m[1].strip != "false")
         end
         ret3 = EMPTY_ADOC_OPTIONS_DEFAULT_FALSE.each_with_object({}) do |w, acc|
-          m = /\n:#{w}:([^\n]*)\n/.match(header) || [nil, "false"]
+          m = /\n:#{w}:([^\n]*)\n/.match(hdr) || [nil, "false"]
           acc[attr_name_normalise(w)] = !["false"].include?(m[1].strip)
         end
         ret.merge(ret2).merge(ret3).compact

data/lib/metanorma/registry/registry.rb

@@ -11,9 +11,11 @@ module Metanorma
 
     attr_reader :processors
 
+    # TODO: make aliases configurable
     def initialize
       @processors = {}
-      @aliases = { csd: :cc, m3d: :m3aawg, mpfd: :mpfa, csand: :csa }
+      @aliases = { csd: :cc, m3d: :m3aawg, mpfd: :mpfa, csand: :csa,
+                   icc: :iso }
     end
 
     def alias(flavour)
@@ -21,18 +23,14 @@ module Metanorma
     end
 
     def register(processor)
-      raise Error unless processor < ::Metanorma::Processor
-
+      processor < ::Metanorma::Processor or raise Error
       p = processor.new
       # p.short[-1] is the canonical name
       short = Array(p.short)
       @processors[short[-1]] = p
-      short.each do |s|
-        @aliases[s] = short[-1]
-      end
+      short.each { |s| @aliases[s] = short[-1] }
       Array(p.short)
-      Util.log("[metanorma] processor \"#{Array(p.short)[0]}\" registered",
-               :info)
+      Util.log("[metanorma] processor \"#{Array(p.short)[0]}\" registered", :info)
     end
 
     def find_processor(short)

data/lib/metanorma/version.rb

@@ -1,3 +1,3 @@
 module Metanorma
-  VERSION = "2.1.7".freeze
+  VERSION = "2.1.9".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma
 version: !ruby/object:Gem::Version
-  version: 2.1.7
+  version: 2.1.9
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-14 00:00:00.000000000 Z
+date: 2025-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -338,6 +338,7 @@ files:
 - lib/metanorma/collection/util/disambig_files.rb
 - lib/metanorma/collection/util/util.rb
 - lib/metanorma/collection/xrefprocess/xrefprocess.rb
+- lib/metanorma/compile/assets/icc-boilerplate.adoc
 - lib/metanorma/compile/compile.rb
 - lib/metanorma/compile/compile_options.rb
 - lib/metanorma/compile/extract.rb
@@ -345,6 +346,7 @@ files:
 - lib/metanorma/compile/output_filename.rb
 - lib/metanorma/compile/output_filename_config.rb
 - lib/metanorma/compile/relaton_drop.rb
+- lib/metanorma/compile/render.rb
 - lib/metanorma/compile/validator.rb
 - lib/metanorma/compile/writeable.rb
 - lib/metanorma/config/config.rb