metanorma 2.1.4 → 2.5.4

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

@@ -1,21 +1,38 @@
+# frozen_string_literal: true
+
 require "fileutils"
 require "nokogiri"
 require "htmlentities"
 require "yaml"
 require "fontist"
-require "fontist/manifest/install"
-require_relative "compile_validate"
+require "fontist/manifest"
+require "metanorma-taste"
+require_relative "writeable"
+require_relative "validator"
 require_relative "compile_options"
 require_relative "../util/fontist_helper"
-require_relative "../util/util"
+require "metanorma-core"
 require_relative "extract"
 require_relative "../collection/sectionsplit/sectionsplit"
 require_relative "../util/worker_pool"
+require_relative "output_filename"
+require_relative "output_filename_config"
+require_relative "flavor"
+require_relative "relaton_drop"
+require_relative "render"
 
 module Metanorma
   class Compile
+    include Validator
+    include CompileOptions
+    include Flavor
+    include Writeable
+
+    DEFAULT_NUM_WORKERS = 3
+
     # @return [Array<String>]
-    attr_reader :errors, :processor
+    attr_reader :errors
+    attr_reader :processor
 
     def initialize
       @registry = Metanorma::Registry.instance
@@ -25,22 +42,43 @@ module Metanorma
       @log = Metanorma::Utils::Log.new
     end
 
+    # Main compile method that orchestrates the document conversion process
+    # @param filename [String] path to the input file
+    # @param options [Hash] compilation options
     def compile(filename, options = {})
-      options_process(filename, options)
+      process_options!(filename, options)
       @processor = @registry.find_processor(options[:type].to_sym)
-      (file, isodoc = process_input(filename, options)) or return nil
-      extensions = get_extensions(options) or return nil
-      relaton_export(isodoc, options)
-      extract(isodoc, options[:extract], options[:extract_type])
-      process_exts(filename, extensions, file, isodoc, options)
+
+      # Step 1: Generate Semantic XML
+      semantic_result = generate_semantic_xml(filename, options) or return nil
+      source_file, semantic_xml = semantic_result
+
+      # Step 2: Prepare output paths
+      xml = Nokogiri::XML(semantic_xml, &:huge)
+      bibdata = extract_relaton_metadata(xml)
+      output_paths = prepare_output_paths(filename, bibdata, options)
+
+      # Step 3: Determine which output formats to generate
+      extensions = get_extensions(options)
+      @extensions = extensions # Capture extensions for later access
+      extensions or return nil
+
+      # Step 4: Extract information from Semantic XML if requested
+      extract_information(semantic_xml, bibdata, options)
+
+      # Step 5: Generate output formats from Semantic XML
+      generate_outputs(
+        source_file, semantic_xml, bibdata, extensions, output_paths,
+        options
+      )
     ensure
       clean_exit(options)
     end
 
-    def options_process(filename, options)
+    def process_options!(filename, options)
       require_libraries(options)
-      options = options_extract(filename, options)
-      validate_options(options)
+      options = extract_options(filename, options)
+      validate_options!(options)
       @log.save_to(filename, options[:output_dir])
       options[:log] = @log
     end
@@ -50,7 +88,11 @@ module Metanorma
       @log.write
     end
 
-    def process_input(filename, options)
+    # Step 1: Generate Semantic XML from input file
+    # @param filename [String] input file path
+    # @param options [Hash] compilation options
+    # @return [Array, nil] tuple of [source_file, semantic_xml] or nil on failure
+    def generate_semantic_xml(filename, options)
       case extname = File.extname(filename)
       when ".adoc" then process_input_adoc(filename, options)
       when ".xml" then process_input_xml(filename, options)
@@ -61,184 +103,157 @@ module Metanorma
       end
     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")
-      dir = File.dirname(filename)
-      dir != "." and
-        file = file.gsub(/^include::/, "include::#{dir}/")
-          .gsub(/^embed::/, "embed::#{dir}/")
-      [file, @processor.input_to_isodoc(file, filename, options)]
-    end
-
-    def process_input_xml(filename, _options)
-      Util.log("[metanorma] Processing: Metanorma XML input.", :info)
-      # TODO NN: this is a hack -- we should provide/bridge the
-      # document attributes in Metanorma XML
-      ["", read_file(filename)]
+    # Step 2: Prepare output paths for generated files
+    # Use default filename template if empty string is provided.
+    #
+    # @param filename [String] input file path
+    # @param bibdata [Nokogiri::XML::Element] the bibliographic data element
+    # @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?
+                   filename.sub(/\.[^.]+$/, "")
+                 else
+                   drop = RelatonDrop.new(bibdata)
+                   config = OutputFilenameConfig.new(options[:filename_template])
+                   config.generate_filename(drop)
+                 end
+      @output_filename = OutputFilename.new(
+        basename, options[:output_dir], @processor
+      )
+      {
+        xml: @output_filename.semantic_xml,
+        orig_filename: filename,
+        presentationxml: @output_filename.presentation_xml,
+      }
     end
 
-    def read_file(filename)
-      File.read(filename, encoding: "utf-8").gsub("\r\n", "\n")
+    # Step 4: Extract information from Semantic XML
+    # @param semantic_xml [String] semantic XML content
+    # @param options [Hash] compilation options
+    def extract_information(semantic_xml, bibdata, options)
+      # Extract Relaton bibliographic data
+      export_relaton_from_bibdata(bibdata, options) if options[:relaton]
+      # Extract other components (sourcecode, images, requirements)
+      if options[:extract]
+        Extract.extract(
+          semantic_xml, options[:extract], options[:extract_type]
+        )
+      end
     end
 
-    def relaton_export(isodoc, options)
-      return unless options[:relaton]
-
-      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 }
+    # Step 5: Generate output formats from Semantic XML
+    # @param source_file [String] source file content
+    # @param semantic_xml [String] semantic XML content
+    # @param bibdata [Nokogiri::XML::Element] the bibliographic data element
+    # @param extensions [Array<Symbol>] output formats to generate
+    # @param output_paths [Hash] paths for output files
+    # @param options [Hash] compilation options
+    def generate_outputs(
+      source_file, semantic_xml, bibdata, extensions, output_paths, options
+    )
+      if extensions == %i(presentation)
+        # Just generate presentation XML
+        generate_presentation_xml(
+          source_file, semantic_xml, bibdata, output_paths, options
+        )
+      else
+        # Generate multiple output formats with parallel processing
+        generate_outputs_parallel(
+          source_file, semantic_xml, bibdata, extensions, output_paths, options
+        )
+      end
     end
 
-    def export_output(fname, content, **options)
-      mode = options[:binary] ? "wb" : "w:UTF-8"
-      File.open(fname, mode) { |f| f.write content }
+    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 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
+    def process_input_adoc_overrides(attrs, options)
+      Metanorma::TasteRegister.instance.available_tastes
+        .include?(options[:supplied_type]) or return
+      c = Metanorma::TasteRegister.get(options[:supplied_type])
+      c.process_input_adoc_overrides(attrs, options)
     end
 
-    # isodoc is Raw Metanorma XML
-    def process_exts(filename, extensions, file, isodoc, options)
-      f = File.expand_path(change_output_dir(options))
-      fnames = { xml: f.sub(/\.[^.]+$/, ".xml"), f: f,
-                 orig_filename: File.expand_path(filename),
-                 presentationxml: f.sub(/\.[^.]+$/, ".presentation.xml") }
-      if extensions == %i(presentation)
-        process_ext(:presentation, file, isodoc, fnames, options)
-      else
-      process_exts_queue(fnames, extensions, file, isodoc, options)
-      end
+    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_exts_queue(fnames, extensions, file, isodoc, options)
-      @queue = ::Metanorma::Util::WorkersPool
-        .new(ENV["METANORMA_PARALLEL"]&.to_i || 3)
-      gather_and_install_fonts(file, options.dup, extensions)
-      process_exts_run(fnames, file, isodoc, extensions, options)
-      @queue.shutdown
+    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)
+      update_options_after_preprocessing(file, options)
+      [file, @processor.input_to_isodoc(file, filename, options)]
     end
 
-    def process_exts_run(fnames, file, isodoc, extensions, options)
-      Util.sort_extensions_execution(extensions).each do |ext|
-        process_ext(ext, file, isodoc, fnames, options) or break
+    # need to update options, for any content added;
+    # e.g. new attributes from Metanorma taste
+    def update_options_after_preprocessing(file, options)
+      new_options = { extension_keys: options[:extension_keys] }
+      Tempfile.open(["tmp", ".adoc"], encoding: "UTF-8") do |f|
+        f.write(file)
+        f.close
+        new_options = extract_options(f, new_options)
       end
+      new_options.compact!
+      new_options.delete(:filename)
+      options.merge!(new_options)
     end
 
-    def gather_and_install_fonts(file, options, extensions)
-      Util.sort_extensions_execution(extensions).each do |ext|
-        isodoc_options = get_isodoc_options(file, options, ext)
-        font_install(isodoc_options.merge(options))
-      end
+    def process_input_xml(filename, _options)
+      Util.log("[metanorma] Processing: Metanorma XML input.", :info)
+      # TODO NN: this is a hack -- we should provide/bridge the
+      # document attributes in Metanorma XML
+      ["", read_file(filename)]
     end
 
-    def process_ext(ext, file, isodoc, fnames, options)
-      fnames[:ext] = @processor.output_formats[ext]
-      fnames[:out] = fnames[:f].sub(/\.[^.]+$/, ".#{fnames[:ext]}")
-      isodoc_options = get_isodoc_options(file, options, ext)
-      thread = true
-      unless process_ext_simple(ext, isodoc, fnames, options,
-                                isodoc_options)
-        thread = process_exts1(ext, fnames, isodoc, options, isodoc_options)
-      end
-      thread
-    end
-
-    def process_ext_simple(ext, isodoc, fnames, options, isodoc_options)
-      if ext == :rxl
-        relaton_export(isodoc, options.merge(relaton: fnames[:out]))
-      elsif options[:passthrough_presentation_xml] && ext == :presentation
-        #f = File.exist?(fnames[:f]) ? fnames[:f] : fnames[:orig_filename]
-        f = File.exist?(fnames[:orig_filename]) ? fnames[:orig_filename] : fnames[:f]
-        FileUtils.cp f, fnames[:presentationxml]
-      elsif ext == :html && options[:sectionsplit]
-        sectionsplit_convert(fnames[:xml], isodoc, fnames[:out],
-                             isodoc_options)
-      else return false
-      end
-      true
+    def read_file(filename)
+      File.read(filename, encoding: "utf-8").gsub("\r\n", "\n")
     end
 
-    def process_exts1(ext, fnames, isodoc, options, isodoc_options)
-      if @processor.use_presentation_xml(ext)
-        @queue.schedule(ext, fnames.dup, options.dup,
-                        isodoc_options.dup) do |a, b, c, d|
-          process_output_threaded(a, b, c, d)
+    # Returns a mapping of format types to file suffixes based on the
+    # extensions that were determined during compilation.
+    # This method is only available after compile() has been called and
+    # reached Step 3 where extensions are finalized.
+    #
+    # @return [Hash] mapping of format symbols to file extensions
+    #   e.g., { html: "html", doc: "doc", pdf: "pdf" }
+    # @return [Hash] empty hash if extensions haven't been captured yet
+    def output_format_mapping
+      @extensions && @processor or return {}
+      @extensions.each_with_object({}) do |ext, mapping|
+        if @processor.output_formats[ext]
+          mapping[ext] = @processor.output_formats[ext]
         end
-      else
-        process_output_unthreaded(ext, fnames, isodoc, isodoc_options)
       end
     end
 
-    def process_output_threaded(ext, fnames1, options1, isodoc_options1)
-      @processor.output(nil, fnames1[:presentationxml], fnames1[:out], ext,
-                        isodoc_options1)
-      wrap_html(options1, fnames1[:ext], fnames1[:out])
-    rescue StandardError => e
-      strict = ext == :presentation || isodoc_options1[:strict] == true
-      isodoc_error_process(e, strict, false)
-    end
-
-    def process_output_unthreaded(ext, fnames, isodoc, isodoc_options)
-      @processor.output(isodoc, fnames[:xml], fnames[:out], ext,
-                        isodoc_options)
-      true # return as Thread
-    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
-        File.open(input_filename, "w:UTF-8") { |f| f.write(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
+    def process_compile_dummy(flavor)
+      file = Tempfile.new(%w(tmp .adoc))
+      file.write <<~OUTPUT
+        Document Title
+        :flavor: #{flavor}
+        :mn-output-extensions: xml, presentation
+
+      OUTPUT
+      file.close
+      compile(file.path, agree_to_terms: true)
     end
 
-    # @param options [Hash]
-    # @return [String]
-    def change_output_dir(options)
-      if options[:output_dir]
-        File.join options[:output_dir], File.basename(options[:filename])
-      else options[:filename]
-      end
+    def extract_log_messages(flavor)
+      process_compile_dummy(flavor)
+      @log.display_messages
     end
   end
 end