metanorma 2.0.0 → 2.5.5

data/lib/metanorma/compile/compile_options.rb

@@ -2,101 +2,208 @@ require "csv"
 
 module Metanorma
   class Compile
-    def require_libraries(options)
-      options&.dig(:require)&.each { |r| require r }
-    end
+    module CompileOptions
+      def require_libraries(options)
+        options&.dig(:require)&.each { |r| require r }
+      end
 
-    def xml_options_extract(file)
-      xml = Nokogiri::XML(file, &:huge)
-      if xml.root
-        @registry.root_tags.each do |k, v|
-          return { type: k } if v == xml.root.name
+      def extract_xml_options(file)
+        xml = Nokogiri::XML(file, &:huge)
+        if xml.root
+          @registry.root_tags.each do |k, v|
+            return { type: k } if v == xml.root.name
+          end
         end
+        {}
       end
-      {}
-    end
 
-    def options_extract(filename, options)
-      content = read_file(filename)
-      o = Metanorma::Input::Asciidoc.new.extract_metanorma_options(content)
-        .merge(xml_options_extract(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]
-      options[:sourcecode] ||= File.join(dir, o[:sourcecode]) if o[:sourcecode]
-      options[:extension_keys] ||= o[:extensions]&.split(/, */)&.map(&:to_sym)
-      options[:extension_keys] = nil if options[:extension_keys] == [:all]
-      options[:format] ||= :asciidoc
-      options[:filename] = filename
-      options[:fontlicenseagreement] ||= "no-install-fonts"
-      options[:novalid] = o[:novalid] if o[:novalid]
-      options
-    end
+      def extract_options(filename, options)
+        o = options_in_file(filename)
+        extract_flavor_options(options, o)
+        extract_dir_options(options, o, filename)
+        extract_extension_options(options, o)
+        options[:format] ||= :asciidoc
+        options[:filename] = filename
+        options[:fontlicenseagreement] ||= "no-install-fonts"
+        options[:novalid] = o[:novalid] if o[:novalid]
+        options
+      end
 
-    def get_extensions(options)
-      ext = extract_extensions(options)
-      !ext.include?(:presentation) && ext.any? do |e|
-        @processor.use_presentation_xml(e)
-      end and ext << :presentation
-      !ext.include?(:rxl) && options[:site_generate] and
-        ext << :rxl
-      ext
-    end
+      def extract_extension_options(opt, doc_opt)
+        opt[:extension_keys] == [:all] and opt[:extension_keys] = []
+        ext = opt[:extension_keys] || []
+        doc_opt[:extensions] == "all" and doc_opt[:extensions] = ""
+        ext1 = (doc_opt[:extensions] || "").split(/, */).map(&:to_sym)
+        !ext1.empty? && ext.empty? and opt[:extension_keys] = ext1
+        opt[:extension_keys]&.empty? and opt[:extension_keys] = nil
+      end
+
+      def options_in_file(filename)
+        # the adoc preprocessing path re-extracts options from a Tempfile
+        filename = filename.path if filename.is_a?(Tempfile)
+        content = read_file(filename)
+        # XML inputs carry no AsciiDoc header options; booting the adoc
+        # pipeline for them only drags every plugin into the compile.
+        return extract_xml_options(content) if filename.end_with?(".xml")
+
+        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)
+        filename.is_a?(Tempfile) and return
+        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
+
+      # Document-model transformer specs contributed by the active taste
+      # (+options[:supplied_type]+), or +{}+. Lets a taste (e.g. OIML) make its
+      # own output format selectable and choose its presentation/semantic leg,
+      # via the taste-aware metanorma-core Processor (metanorma-core#12).
+      def taste_transformers(options)
+        taste = options[:supplied_type]
+        return {} unless taste && defined?(Metanorma::TasteRegister) &&
+          Metanorma::TasteRegister.respond_to?(:document_transformers_for)
+
+        Metanorma::TasteRegister.document_transformers_for(taste) || {}
+      end
+
+      # Harness formats available to every flavor, regardless of the
+      # processor's own list. MKO (metanorma-document) is resolved via
+      # Core::Flavors, so it needs nothing from the flavor gems.
+      HARNESS_OUTPUT_FORMATS = { mko: "mko" }.freeze
+
+      # Formats a flavor offers by default: its own list plus
+      # taste-contributed document-model formats. The harness formats
+      # (mko) are deliberately absent — they are opt-in via
+      # --extensions, never a surprise default output.
+      def default_output_formats(options)
+        @processor.output_formats
+                  .merge(
+                    taste_transformers(options)
+                      .transform_values { |spec| spec[:suffix] }.compact,
+                  )
+      end
 
-    def extract_extensions(options)
-      options[:extension_keys] ||=
-        @processor.output_formats.reduce([]) { |memo, (k, _)| memo << k }
-      options[:extension_keys].reduce([]) do |memo, e|
-        if @processor.output_formats[e] then memo << e
-        else
-          unsupported_format_error(e)
-          memo
+      # The default formats merged with the harness formats, so those
+      # pass extension validation and get an output suffix.
+      def effective_output_formats(options)
+        default_output_formats(options).merge(HARNESS_OUTPUT_FORMATS)
+      end
+
+      # Whether +ext+ is generated from presentation XML, honouring both the
+      # processor's own answer and a taste transformer's +:presentation+ flag.
+      def uses_presentation_xml?(ext, options)
+        ext == :mko || # unit numbering comes from the presentation model
+          @processor.use_presentation_xml(ext) ||
+          (taste_transformers(options)[ext] || {})[:presentation] == true
+      end
+
+      def get_extensions(options)
+        ext = extract_extensions(options)
+        !ext.include?(:presentation) && ext.any? do |e|
+          uses_presentation_xml?(e, options)
+        end and ext << :presentation
+        !ext.include?(:rxl) && options[:site_generate] and
+          ext << :rxl
+        # Keep options[:extension_keys] in sync: get_isodoc_options filters
+        # output_formats by extension_keys, and presentation is an implicit
+        # dependency of html/doc/pdf — if it is only on the local +ext+ array,
+        # the filter strips it from the formats table (and, when the processor
+        # hands out a live hash, permanently from the flavor config).
+        options[:extension_keys] = ext
+        ext
+      end
+
+      def extract_extensions(options)
+        formats = effective_output_formats(options)
+        options[:extension_keys] ||=
+          default_output_formats(options).reduce([]) { |memo, (k, _)| memo << k }
+        options[:extension_keys].reduce([]) do |memo, e|
+          if formats[e] then memo << e
+          else
+            unsupported_format_error(e)
+            memo
+          end
         end
       end
-    end
 
-    def font_install(opt)
-      @fontist_installed or
-        Util::FontistHelper.install_fonts(@processor, opt)
-      @fontist_installed = true
-    end
+      def font_install(opt)
+        @fontist_installed or
+          Util::FontistHelper.install_fonts(@processor, opt)
+        @fontist_installed = true
+      end
 
-    private
+      private
 
-    def unsupported_format_error(ext)
-      message = "[metanorma] Error: #{ext} format is not supported " \
-                "for this standard."
-      @errors << message
-      Util.log(message, :error)
-    end
+      def unsupported_format_error(ext)
+        message = "[metanorma] Error: #{ext} format is not supported " \
+          "for this standard."
+        @errors << message
+        Util.log(message, :error)
+      end
 
-    def get_isodoc_options(file, options, ext)
-      ret = @processor.extract_options(file)
-      copy_isodoc_options_attrs(options, ret)
-      font_manifest_mn2pdf(options, ret, ext)
-      ret[:output_formats]&.select! do |k, _|
-        options[:extension_keys].include?(k)
+      def get_isodoc_options(file, options, ext)
+        ret = @processor.extract_options(file)
+        get_isodoc_fileparams(options, ret)
+        copy_isodoc_options_attrs(options, ret)
+        font_manifest_mn2pdf(options, ret, ext)
+        # Filter a COPY — never select! the processor's live formats table.
+        # Generic (and any flavor that returns configuration.formats directly)
+        # would otherwise permanently lose :presentation after the first
+        # html/doc request that did not list presentation in extension_keys.
+        if ret[:output_formats]
+          keys = options[:extension_keys] || []
+          ret[:output_formats] = ret[:output_formats]
+            .select { |k, _| keys.include?(k) }
+        end
+        ret[:log] = @log
+        ret
       end
-      ret
-    end
 
-    def copy_isodoc_options_attrs(options, ret)
-      ret[:datauriimage] = true if options[:datauriimage]
-      ret[:sourcefilename] = options[:filename]
-      %i(bare sectionsplit install_fonts baseassetpath aligncrosselements
-         tocfigures toctables tocrecommendations strict)
-        .each { |x| ret[x] ||= options[x] }
-    end
+      def get_isodoc_fileparams(options, ret)
+        %i(i18nyaml relatonrenderconfig).each do |k|
+          dir = File.dirname(options[:filename])
+          ret[k] or next
+          (Pathname.new ret[k]).absolute? or
+            ret[k] = File.join(dir, ret[k])
+        end
+      end
+
+      def copy_isodoc_options_attrs(options, ret)
+        ret[:datauriimage] = true if options[:datauriimage]
+        ret[:sourcefilename] = options[:filename]
+        # Carry the active taste through to Processor#output, so its taste-aware
+        # document_transformers resolve there (metanorma-core#12).
+        ret[:supplied_type] = options[:supplied_type]
+        %i(bare sectionsplit sectionsplit_filename install_fonts baseassetpath
+           aligncrosselements tocfigures toctables tocrecommendations tocexamples
+           strict fonts)
+          .each { |x| ret[x] ||= options[x] }
+      end
 
-    def font_manifest_mn2pdf(options, ret, ext)
-      custom_fonts = Util::FontistHelper
-        .has_custom_fonts?(@processor, options, ret)
+      def font_manifest_mn2pdf(options, ret, ext)
+        custom_fonts = Util::FontistHelper
+          .has_custom_fonts?(@processor, options, ret)
 
-      ext == :pdf && custom_fonts and
-        ret[:mn2pdf] = {
-          font_manifest: Util::FontistHelper.location_manifest(@processor, ret),
-        }
+        ext == :pdf && custom_fonts and
+          ret[:mn2pdf] = {
+            font_manifest: Util::FontistHelper
+              .location_manifest(@processor, ret),
+          }
+      end
     end
   end
 end

data/lib/metanorma/compile/extract.rb

@@ -1,71 +1,88 @@
+# frozen_string_literal: true
+
+require_relative "writeable"
+
 module Metanorma
   class Compile
-    def relaton_export(isodoc, options)
-      return unless options[:relaton]
+    module Extract
+      # @param isodoc [String] the XML document
+      # @param dirname [String, nil] the directory to extract to
+      # @param extract_types [Array<Symbol>, nil] the types to extract
+      # @return [void]
+      def self.extract(isodoc, dirname, extract_types)
+        dirname or return
+        extract_types.nil? || extract_types.empty? and
+          extract_types = %i[sourcecode image requirement]
+        FileUtils.rm_rf dirname
+        FileUtils.mkdir_p dirname
+        xml = Nokogiri::XML(isodoc, &:huge)
+        extract_types.each do |type|
+          case type
+          when :sourcecode
+            export_sourcecode(xml, dirname)
+          when :image
+            export_image(xml, dirname)
+          when :requirement
+            export_requirement(xml, dirname)
+          end
+        end
+      end
 
-      xml = Nokogiri::XML(isodoc, &:huge)
-      bibdata = xml.at("//bibdata") || xml.at("//xmlns:bibdata")
-      # docid = bibdata&.at("./xmlns:docidentifier")&.text || options[:filename]
-      # outname = docid.sub(/^\s+/, "").sub(/\s+$/, "").gsub(/\s+/, "-") + ".xml"
-      File.open(options[:relaton], "w:UTF-8") { |f| f.write bibdata.to_xml }
-    end
+      class << self
+        include Writeable
 
-    def clean_sourcecode(xml)
-      xml.xpath(".//callout | .//annotation | .//xmlns:callout | "\
-                ".//xmlns:annotation").each(&:remove)
-      xml.xpath(".//br | .//xmlns:br").each { |x| x.replace("\n") }
-      HTMLEntities.new.decode(xml.children.to_xml)
-    end
+        private
 
-    def extract(isodoc, dirname, extract_types)
-      return unless dirname
+        # @param xml [Nokogiri::XML::Document] the XML document
+        # @return [String] the cleaned sourcecode
+        def clean_sourcecode(xml)
+          xml.xpath(".//callout | .//callout-annotation | .//xmlns:callout | "\
+                    ".//xmlns:callout-annotation").each(&:remove)
+          xml.xpath(".//br | .//xmlns:br").each { |x| x.replace("\n") }
+          a = xml.at("./body | ./xmlns:body") and xml = a
+          HTMLEntities.new.decode(xml.children.to_xml)
+        end
 
-      extract_types.nil? || extract_types.empty? and
-        extract_types = %i[sourcecode image requirement]
-      FileUtils.rm_rf dirname
-      FileUtils.mkdir_p dirname
-      xml = Nokogiri::XML(isodoc, &:huge)
-      sourcecode_export(xml, dirname) if extract_types.include? :sourcecode
-      image_export(xml, dirname) if extract_types.include? :image
-      extract_types.include?(:requirement) and
-        requirement_export(xml, dirname)
-    end
+        def export_sourcecode(xml, dirname)
+          xml.at("//sourcecode | //xmlns:sourcecode") or return
+          FileUtils.mkdir_p "#{dirname}/sourcecode"
+          xml.xpath("//sourcecode | //xmlns:sourcecode").each_with_index do |s, i|
+            filename = s["filename"] || sprintf("sourcecode-%04d.txt", i)
+            export_output("#{dirname}/sourcecode/#{filename}",
+                          clean_sourcecode(s.dup))
+          end
+        end
 
-    def sourcecode_export(xml, dirname)
-      xml.at("//sourcecode | //xmlns:sourcecode") or return
-      FileUtils.mkdir_p "#{dirname}/sourcecode"
-      xml.xpath("//sourcecode | //xmlns:sourcecode").each_with_index do |s, i|
-        filename = s["filename"] || sprintf("sourcecode-%04d.txt", i)
-        export_output("#{dirname}/sourcecode/#{filename}",
-                      clean_sourcecode(s.dup))
-      end
-    end
-
-    def image_export(xml, dirname)
-      xml.at("//image | //xmlns:image") or return
-      FileUtils.mkdir_p "#{dirname}/image"
-      xml.xpath("//image | //xmlns:image").each_with_index do |s, i|
-        next unless /^data:image/.match? s["src"]
+        def export_image(xml, dirname)
+          xml.at("//image | //xmlns:image") or return
+          FileUtils.mkdir_p "#{dirname}/image"
+          xml.xpath("//image | //xmlns:image").each_with_index do |s, i|
+            next unless /^data:image/.match? s["src"]
 
-        %r{^data:image/(?<imgtype>[^;]+);base64,(?<imgdata>.+)$} =~ s["src"]
-        fn = s["filename"] || sprintf("image-%<num>04d.%<name>s",
-                                      num: i, name: imgtype)
-        export_output("#{dirname}/image/#{fn}", Base64.strict_decode64(imgdata),
-                      binary: true)
-      end
-    end
+            %r{^data:image/(?<imgtype>[^;]+);base64,(?<imgdata>.+)$} =~ s["src"]
+            fn = s["filename"] || sprintf("image-%<num>04d.%<name>s",
+                                          num: i, name: imgtype)
+            export_output(
+              "#{dirname}/image/#{fn}",
+              Base64.strict_decode64(imgdata),
+              binary: true,
+            )
+          end
+        end
 
-    REQUIREMENT_XPATH =
-      "//requirement | //xmlns:requirement | //recommendation | "\
-      "//xmlns:recommendation | //permission | //xmlns:permission".freeze
+        REQUIREMENT_XPATH =
+          "//requirement | //xmlns:requirement | //recommendation | "\
+          "//xmlns:recommendation | //permission | //xmlns:permission"
 
-    def requirement_export(xml, dirname)
-      xml.at(REQUIREMENT_XPATH) or return
-      FileUtils.mkdir_p "#{dirname}/requirement"
-      xml.xpath(REQUIREMENT_XPATH).each_with_index do |s, i|
-        fn = s["filename"] ||
-          sprintf("%<name>s-%<num>04d.xml", name: s.name, num: i)
-        export_output("#{dirname}/requirement/#{fn}", s)
+        def export_requirement(xml, dirname)
+          xml.at(REQUIREMENT_XPATH) or return
+          FileUtils.mkdir_p "#{dirname}/requirement"
+          xml.xpath(REQUIREMENT_XPATH).each_with_index do |s, i|
+            fn = s["filename"] ||
+              sprintf("%<name>s-%<num>04d.xml", name: s.name, num: i)
+            export_output("#{dirname}/requirement/#{fn}", s)
+          end
+        end
       end
     end
   end

data/lib/metanorma/compile/flavor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Metanorma
+  class Compile
+    # Thin adapter: taste resolution reads the core table; gem loading
+    # stays on FlavorLoader so the existing SystemExit / processor-
+    # registration contract is byte-identical to main.
+    module Flavor
+      def load_flavor(stdtype)
+        Metanorma::Core::FlavorLoader.load_flavor(taste2flavor(stdtype))
+      end
+
+      def taste2flavor(stdtype)
+        entry = Metanorma::Core::Flavors.find(stdtype)
+        return entry.base_flavor if entry&.taste?
+
+        Metanorma::Core::FlavorLoader.taste2flavor(stdtype)
+      end
+
+      def stdtype2flavor_gem(stdtype)
+        entry = Metanorma::Core::Flavors.find(stdtype)
+        return entry.gem if entry && !entry.taste?
+
+        Metanorma::Core::FlavorLoader.stdtype2flavor_gem(stdtype)
+      end
+    end
+  end
+end

data/lib/metanorma/compile/output_filename.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Metanorma
+  class Compile
+    class OutputFilename
+      # Returns an instance of OutputFilename from the source filename
+      # @param source_filename [String] the source filename
+      # @param output_dir [String, nil] the output directory
+      # @param processor [Metanorma::Processor, nil] the processor
+      # @return [OutputFilename] the instance of OutputFilename
+      def self.from_filename(source_filename, output_dir = nil, processor = nil)
+        new(strip_ext(source_filename), output_dir, processor)
+      end
+
+      class << self
+        private
+
+        def strip_ext(filename)
+          filename.sub(/\.[^.]*$/, "")
+        end
+      end
+
+      # @param noext_filename [String] the path (absolute/relative) of the source file, without extension (e.g., "/a/b/c/test")
+      # @param output_dir [String, nil] the output directory
+      # @param processor [Metanorma::Processor, nil] the processor
+      # @return [OutputFilename] the instance of OutputFilename
+      def initialize(noext_filename, output_dir = nil, processor = nil)
+        @noext_filename = noext_filename
+        @output_dir = output_dir
+        @processor = processor
+      end
+
+      # Returns the full file path name with the semantic XML extension
+      # @return [String] the full file path name with the semantic XML extension
+      def semantic_xml
+        with_extension("xml")
+      end
+
+      # Returns the full file path name with the presentation XML extension
+      # @return [String] the full file path name with the presentation XML extension
+      def presentation_xml
+        with_extension("presentation.xml")
+      end
+
+      # Returns the full file path name with the given format extension
+      # @param format [Symbol] the format
+      # @return [String, nil] the full file path name with the format extension
+      def for_format(format)
+        ext = @processor&.output_formats&.[](format)
+        ext ? with_extension(ext) : nil
+      end
+
+      # Returns the full file path name with the given extension
+      # @param ext [String] the extension
+      # @return [String] the full file path name with the extension
+      def with_extension(ext)
+        file = change_output_dir
+        "#{file}.#{ext}"
+      end
+
+      private
+
+      def change_output_dir
+        File.expand_path(if !@output_dir.nil?
+                           File.join(
+                             @output_dir,
+                             File.basename(@noext_filename),
+                           )
+                         else
+                           @noext_filename
+                         end)
+      end
+    end
+  end
+end

data/lib/metanorma/compile/output_filename_config.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Metanorma
+  class Compile
+    class OutputFilenameConfig
+      DEFAULT_TEMPLATE =
+        "{{ document.docidentifier | downcase" \
+        " | replace: '/' , '-'" \
+        " | replace: ' ' , '-' }}"
+
+      attr_reader :template
+
+      def initialize(template)
+        @template = if template.nil? || template.empty?
+                      DEFAULT_TEMPLATE
+                    else
+                      template
+                    end
+      end
+
+      def generate_filename(relaton_data)
+        template = Liquid::Template.parse(@template)
+        template.render("document" => relaton_data)
+      end
+    end
+  end
+end

data/lib/metanorma/compile/relaton_drop.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "liquid"
+
+module Metanorma
+  class Compile
+    class RelatonDrop < Liquid::Drop
+      def initialize(relaton_data)
+        @relaton = relaton_data
+      end
+
+      def docidentifier
+        at("./docidentifier")
+      end
+
+      def title
+        at("./title")
+      end
+
+      def date
+        at("./date/on")
+      end
+
+      def publisher
+        at("./contributor[role/@type = 'publisher']/organization/name")
+      end
+
+      def language
+        at("./language")
+      end
+
+      def script
+        at("./script")
+      end
+
+      def version
+        at("./version")
+      end
+
+      def slugify
+        docidentifier&.downcase
+          &.gsub(/[^a-z0-9]+/, "-")
+          &.gsub(/-+/, "-")
+          &.gsub(/^-|-$/, "")
+      end
+
+      private
+
+      def at(xpath)
+        @relaton.at(xpath)&.text
+      end
+    end
+  end
+end
+
+