metanorma 2.1.7 → 2.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9a70c61c914359e1637bfdf33edb5e2e560b92d2dd3922db64cec7fecaa5e32
-  data.tar.gz: fd5c55fe248e1a36e2ec0f25689aeb4b149ba94200daea52edea4a73065db69f
+  metadata.gz: b2491a406715a008c828e167a72d00c415af554237517bcbfdeb76818545d548
+  data.tar.gz: 5e7a842f9fa86b6cbd8ec4ff5730489ba3ff89330d4d74aa6a7de1f4ece68f0d
 SHA512:
-  metadata.gz: 237cff4f2cb22825906017cd7286b7a3578603f0816b3b4c699117eb212b384fef8fac5d8d68a31ba6261b6b525db7375d2a796b4f0d4b689563026fecfa9381
-  data.tar.gz: 9a72304008e8e4c5d5571210d6a704389b88dbf85223f16709ace9c878fb761161f1aca7549642dd91a4a5030fa648d7203b43b3a2983f6a445bd1dfcd82a761
+  metadata.gz: 42c9068a65961a2c785b0ee3d5cfcdc9710bcfffeb8309b4bb91b7b213cd9fa97ffff220586f1d9b52d2b230c9cb4743180d3e25209a9e4dfb22cb14d6f89468
+  data.tar.gz: de9167c3dddad4904aba5101a9cea1864654eea8549a6d45eff4fe6bc8d266ea927356b769ef6090126f0177d4c725d0f9059be2c9de0ec7816f3e68c5976081

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/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.8".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.8
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-14 00:00:00.000000000 Z
+date: 2025-04-29 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