metanorma 2.0.0 → 2.5.5

data/lib/metanorma/collection/helpers.rb

@@ -0,0 +1,82 @@
+module Metanorma
+  class Collection
+    class << self
+      # @param Block [Proc]
+      # @note allow user-specific function to run in pre-parse model stage
+      def set_pre_parse_model(&block)
+        @pre_parse_model_proc = block
+      end
+
+      # @param Block [Proc]
+      # @note allow user-specific function to resolve identifier
+      def set_identifier_resolver(&block)
+        @identifier_resolver = block
+      end
+
+      # @param Block [Proc]
+      # @note allow user-specific function to resolve fileref
+      # NOTE: MUST ALWAYS RETURN PATH relative to working directory
+      # (initial YAML file location). @fileref_resolver.call(ref_folder, fileref)
+      # fileref is not what is in the YAML, but the resolved path
+      # relative to the working directory
+      def set_fileref_resolver(&block)
+        @fileref_resolver = block
+      end
+
+      def unset_fileref_resolver
+        @fileref_resolver = nil
+      end
+
+      # @param collection_model [Hash{String=>String}]
+      def pre_parse_model(collection_model)
+        @pre_parse_model_proc or return
+        @pre_parse_model_proc.call(collection_model)
+      end
+
+      # @param identifier [String]
+      # @return [String]
+      def resolve_identifier(identifier)
+        @identifier_resolver or return identifier
+        @identifier_resolver.call(identifier)
+      end
+
+      # @param fileref [String]
+      # @return [String]
+      def resolve_fileref(ref_folder, fileref)
+        warn ref_folder
+        warn fileref
+        unless @fileref_resolver
+          (Pathname.new fileref).absolute? or
+            fileref = File.join(ref_folder, fileref)
+          return fileref
+        end
+
+        @fileref_resolver.call(ref_folder, fileref)
+      end
+
+      # @param filepath
+      # @raise [FileNotFoundException]
+      def check_file_existence(filepath)
+        unless File.exist?(filepath)
+          error_message = "#{filepath} not found!"
+          ::Metanorma::Util.log("[metanorma] Error: #{error_message}", :error)
+          raise FileNotFoundException.new error_message.to_s
+        end
+      end
+
+      def parse(file)
+        # need @dirname initialised before collection object initialisation
+        @dirname = File.expand_path(File.dirname(file))
+        config = case file
+                 when /\.xml$/
+                   ::Metanorma::Collection::Config::Config.from_xml(File.read(file))
+                 when /.ya?ml$/
+                   y = YAML.safe_load(File.read(file))
+                   pre_parse_model(y)
+                   ::Metanorma::Collection::Config::Config.from_yaml(y.to_yaml)
+                 end
+        new(file: file, config: config)
+      end
+    end
+  end
+end

data/lib/metanorma/collection/log.rb

@@ -0,0 +1,24 @@
+module Metanorma
+  class Collection
+    METANORMA_LOG_MESSAGES = {
+      # rubocop:disable Naming/VariableNumber
+      "METANORMA_1": { category: "Cross-References",
+                       error: "Missing cross-reference: %s",
+                       severity: 2 },
+      "METANORMA_2": { category: "Cross-References",
+                       error: "[metanorma] Cannot find crossreference to document %s in document %s.",
+                       severity: 2 },
+      "METANORMA_3": { category: "Cross-References",
+                       error: "<strong>** Unresolved reference to document %s from eref</strong>",
+                       severity: 2 },
+      "METANORMA_4": { category: "Rendering",
+                       error: "Collection member %s: expected output " \
+                              "file not generated: %s",
+                       severity: 0 },
+      "METANORMA_5": { category: "Rendering",
+                       error: "Collection member %s: rendering error: %s",
+                       severity: 0 },
+    }.freeze
+    # rubocop:enable Naming/VariableNumber
+  end
+end

data/lib/metanorma/collection/manifest/manifest.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "../../util/util"
+require "metanorma-core"
 
 module Metanorma
   class Collection
     class Manifest
       # @return [Metanorma::Collection]
-      attr_reader :collection, :config
+      attr_reader :collection, :config, :lang, :script
 
       # @param level [String]
       # @param dir [String]
@@ -20,9 +20,16 @@ module Metanorma
         @config = manifest_postprocess(config)
       end
 
+      # Ordered pipeline of in-place tree-walks over the manifest; the order is
+      # load-bearing. expand_yaml must run early because it grafts nested
+      # `fileref` manifests into this tree, so every later pass sees the full
+      # entry set; bibdata sets @lang/@script used downstream; compile_adoc
+      # turns .adoc sources into .xml before filexist verifies them. Each pass
+      # recurses the manifest independently (see the architecture review plan).
       def manifest_postprocess(config)
         manifest_bibdata(config)
         manifest_expand_yaml(config, @dir)
+        manifest_output_filenames(config)
         manifest_compile_adoc(config)
         manifest_filexist(config)
         manifest_sectionsplit(config)
@@ -38,6 +45,17 @@ module Metanorma
 
       GUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
 
+      def manifest_output_filenames(config, parent = nil)
+        config.output_filename ||=
+          parent&.output_filename # || "{basename}.{document-num}"
+        config.sectionsplit_filename ||= parent&.sectionsplit_filename ||
+          "{basename_legacy}.{sectionsplit-num}"
+        # "{basename}-{document-num}.{sectionsplit-num}"
+        Array(config.entry).each do |f|
+          manifest_output_filenames(f, config)
+        end
+      end
+
       def manifest_identifier(config)
         no_id = populate_id_from_doc(config)
         config.identifier =
@@ -67,15 +85,15 @@ module Metanorma
         i = x.at("//xmlns:bibdata/xmlns:docidentifier[@primary = 'true']") ||
           x.at("//xmlns:bibdata/xmlns:docidentifier")
         i or return nil
-        @doctype ||= i["type"]&.downcase || "standoc"
+        @flavor = @collection.flavor
         load_isodoc
         Util::key(@isodoc.docid_prefix(i["type"], i.text))
       end
 
       def load_isodoc
         @isodoc and return
-        @collection.compile.load_flavor(@doctype)
-        @isodoc = Util::load_isodoc(@doctype)
+        @collection.compile.load_flavor(@flavor)
+        @isodoc = Util::load_isodoc(@flavor)
         @isodoc.i18n_init(@lang, @script, nil) # for @i18n.all_parts in docid
       end
 
@@ -127,9 +145,15 @@ module Metanorma
       end
 
       def update_filepaths(entry, prefix)
+        # `manifest_expand_yaml_entry` hands us the loaded sub-manifest's
+        # `entry` collection directly, which is an Array of entries.
+        if entry.is_a?(Array)
+          entry.each { |e| update_filepaths(e, prefix) }
+          return
+        end
         entry.file && !(Pathname.new entry.file).absolute? and
           entry.file = File.join(prefix, entry.file)
-        entry.entry.each do |f|
+        entry&.entry&.each do |f|
           update_filepaths(f, prefix)
         end
       end
@@ -153,7 +177,7 @@ module Metanorma
       def set_adoc2xml(fileref)
         File.join(
           File.dirname(fileref),
-          File.basename(fileref).gsub(/.adoc$/, ".xml"),
+          File.basename(fileref).gsub(/\.adoc$/, ".xml"),
         )
       end
 
@@ -161,15 +185,22 @@ module Metanorma
       # @raise [AdocFileNotFoundException]
       def compile_adoc_file(file)
         f = (Pathname.new file).absolute? ? file : File.join(@dir, file)
-        unless File.exist? f
-          raise AdocFileNotFoundException.new "#{f} not found!"
-        end
-
-        ::Metanorma::Util.log("[metanorma] Info: Compiling #{f}...", :info)
+        File.exist?(f) or raise AdocFileNotFoundException.new "#{f} not found!"
+        compile_adoc_file?(file) or return
+        ::Metanorma::Util.log("[metanorma] Info: Compiling #{f}...", :warning)
         ::Metanorma::Compile.new
-          .compile(f, agree_to_terms: true, no_install_fonts: true,
+          .compile(f, agree_to_terms: true, install_fonts: false,
                       extension_keys: [:xml])
-        ::Metanorma::Util.log("[metanorma] Info: Compiling #{f}...done!", :info)
+        ::Metanorma::Util.log("[metanorma] Info: Compiling #{f}...done!",
+                              :warning)
+      end
+
+      def compile_adoc_file?(file)
+        !File.exist?(file.sub(/\.adoc$/, ".xml")) and return true
+        @collection.directives.detect do |d|
+          d.key == "recompile-xml" && d.value == "false"
+        end and return false
+        true
       end
 
       def documents(mnf = @config)