metanorma 2.0.0 → 2.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40466d3eca9782461819ef5828d00dcdc4203e000cc0a6762e658ac75fab81c2
-  data.tar.gz: ff68a9e27dd193c8e1263bcb1200f76d87eaf10363ef4c4eb32b9719e9b82eee
+  metadata.gz: 66371f7ab35ebb13e3b57cd0dbbaa3ef8a9c0c5d57e99efe4bd1c3452d4055f0
+  data.tar.gz: 6bade47b39a3b31a3f74cea3fb119196dd4bf6d87356d39af3f17a5c7dd0fb8e
 SHA512:
-  metadata.gz: 77388c12e9b2067cd0e319cdacc3ea914984e5185ce130ea5b6dbc893ab4d1d851294b7f3833811235b3952b50c98ad4830614c87a472dac9a26dc644b48f031
-  data.tar.gz: 749c67ae8b9c967a0a2446847fb04fc9b045d5f42d4046a66aa79ce0abd5dc373545af2a1520559fa3fb0db4065a51aa2f043fcbe3007b84990ab89b99a286b9
+  metadata.gz: 88a35f0eb4334353cb0ae728b82b489ed75514d037b05c66a404d15e230090d10b64dc149487dc65a6f5abb8531807e9b707ec4015de773bf63685f6ae0dc18a
+  data.tar.gz: 9ef18c46695f5789fb89e697aeeebb14ef271f411dd11ddecb4a898b3138075fb354f0ece2f1b885987b7d9a852e4627f78f9887c23ee0a605a67325204f9c65

data/.envrc

@@ -0,0 +1 @@
+use flake

data/.gitignore

@@ -22,3 +22,6 @@ relaton/
 .vscode/
 
 .rubocop-https--*
+
+# direnv
+.direnv/

data/.rubocop.yml

@@ -1,10 +1,31 @@
 # Auto-generated by Cimas: Do not edit it manually!
 # See https://github.com/metanorma/cimas
 inherit_from:
-  - https://raw.githubusercontent.com/riboseinc/oss-guides/master/ci/rubocop.yml
+  - https://raw.githubusercontent.com/riboseinc/oss-guides/main/ci/rubocop.yml
+  # .rubocop_todo.yml MUST be the last entry. inherit_from is last-wins:
+  # if listed before oss-guides, the shared config's stricter Metrics/
+  # (MethodLength, BlockLength, etc.) rules override the todo's per-file
+  # grandfathering, and the todo becomes inert on those cops. Empirically
+  # verified on suma 2026-07-06: with todo listed first, 34 Metrics/* offenses
+  # remained; moved last, cleared. Every gem in the metanorma-org fleet
+  # already ships a `.rubocop_todo.yml` on its live tree (audited 2026-07-06,
+  # 54/54 have it), so this reference is safe to emit unconditionally.
+  - .rubocop_todo.yml
+
+# Rubocop plugins enabled centrally so every metanorma-org gem picks them up
+# on cimas sync — best practice belongs at the shared-template layer, not
+# per-repo. Per ronaldtse feedback on metanorma/ci#332.
+plugins:
+  - rubocop-rspec
+  - rubocop-performance
+  - rubocop-rake
 
 # local repo-specific modifications
 # ...
 
 AllCops:
-  TargetRubyVersion: 2.5
+  # 3.3 matches the org-wide minimum being pushed via #274 (Raise minimum
+  # Ruby version to 3.3 due to EOL of 3.2 on 2026-03-31). Was 3.4 before
+  # this commit — 3.4 was above the org's stated minimum and would have
+  # applied Rubocop rules that fail-close on gems still targeting 3.3.
+  TargetRubyVersion: 3.3

data/Gemfile

@@ -6,8 +6,25 @@ git_source(:github) { |repo| "https://github.com/#{repo}" }
 
 gemspec
 
+# TEMPORARY cross-PR pin (metanorma-core#18): Compile resolves via Core::Flavors
+gem "metanorma-core", github: "metanorma/metanorma-core", branch: "feat/flavor-table"
+
 begin
   eval_gemfile("Gemfile.devel")
 rescue StandardError
   nil
 end
+
+gem "debug"
+gem "equivalent-xml"
+#gem "metanorma-iho"
+#gem "metanorma-iso", ">= 3.2.0"
+gem "mnconvert"
+gem "pry"
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"
+gem "rspec-command", "~> 1.0"
+gem "rubocop", "~> 1"
+gem "rubocop-performance"
+gem "sassc-embedded", "~> 1"
+gem "simplecov", "~> 0.15"

data/Gemfile.devel

@@ -0,0 +1,10 @@
+# Local development pins (eval'd by Gemfile; not committed workflow state)
+gem "metanorma-document", github: "metanorma/metanorma-document", branch: "feat/model-validation-l1-declarations"
+gem "metanorma-standoc", github: "metanorma/metanorma-standoc", branch: "feat/move-standard-document"
+gem "metanorma-iso", github: "metanorma/metanorma-iso", branch: "feat/model-validation-migration"
+gem "isodoc", github: "metanorma/isodoc", branch: "main"
+gem "pubid", ">= 2.0.0.pre.alpha.9"
+gem "relaton-cli", ">= 3.0.0.pre.alpha.1"
+gem "glossarist", "~> 2.13"
+gem "lutaml-model", "~> 0.8.0", "< 0.8.20"
+gem "metanorma-plugin-glossarist", "0.3.9"

data/README.adoc

@@ -2,7 +2,7 @@
 
 image:https://img.shields.io/gem/v/metanorma.svg["Gem Version", link="https://rubygems.org/gems/metanorma"]
 image:https://github.com/metanorma/metanorma/workflows/rake/badge.svg["Build Status", link="https://github.com/metanorma/metanorma/actions?workflow=rake"]
-image:https://codeclimate.com/github/metanorma/metanorma/badges/gpa.svg["Code Climate", link="https://codeclimate.com/github/metanorma/metanorma"]
+// image:https://codeclimate.com/github/metanorma/metanorma/badges/gpa.svg["Code Climate", link="https://codeclimate.com/github/metanorma/metanorma"]
 image:https://img.shields.io/github/issues-pr-raw/metanorma/metanorma.svg["Pull Requests", link="https://github.com/metanorma/metanorma/pulls"]
 image:https://img.shields.io/github/commits-since/metanorma/metanorma/latest.svg["Commits since latest",link="https://github.com/metanorma/metanorma/releases"]
 

data/lib/metanorma/collection/artifact_store.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "digest"
+
+module Metanorma
+  class Collection
+    # Durable, content-addressed store for staged collection-build artefacts.
+    #
+    # Enables incremental (batched) builds and resumption across runs: an
+    # artefact is named +<docid-slug>.<content-hash>.<stage>.<format>+, so a
+    # document already built with identical inputs is detected by filename alone
+    # and reused, and an interrupted run resumes by recomputing which artefacts
+    # are already present.
+    #
+    # Reuse is keyed on the caller-supplied content hash of the document's
+    # *input closure* (source + resolved includes + templates + referenced
+    # schemas + tool versions + options) -- never on file presence alone. See
+    # metanorma/iso-10303#455 for why presence-keyed reuse of compiled XML is
+    # unsound; the store deliberately requires a content hash it does not infer.
+    #
+    # Disabled by default: the collection renderer uses NullArtifactStore unless
+    # an incremental build is explicitly requested (opt-in, never default).
+    class ArtifactStore
+      DEFAULT_DIRNAME = ".metanorma-collection-cache"
+
+      # The artefact-stage vocabulary, and the one non-redundant property each
+      # stage carries: the format it is serialised as (also its file extension).
+      # THIS IS ITS HOME: every producer and consumer names its stage from this
+      # table by symbol, never a bare string literal elsewhere; an unknown stage
+      # raises (KeyError via +fetch+), so the vocabulary cannot drift outside
+      # this file. The stage's *name* is the filename token, so it is not stored
+      # here -- that would just restate the key. The stages trace the pipeline
+      # (isolated compile -> index -> reinflate); each role is documented inline:
+      STAGE_FORMATS = {
+        # Compiled Semantic XML, unresolved cross-document repo:() references
+        # PRESERVED as deterministic stubs (neither stripped nor resolved). The
+        # unit of an isolated per-document compile; a pure function of the
+        # document's input closure, hence content-addressable and reusable.
+        semantic: "xml",
+        # This document's contribution to the global anchor index: its anchors
+        # and ids (type => {label/UUID => anchor-id}). Aggregated across all
+        # documents to build the anchor -> owning-document index used at
+        # reinflation.
+        anchors: "json",
+        # Reinflated Presentation XML: the preserved stubs resolved against the
+        # global index into real cross-document links. Shared source for the PDF
+        # and Word collection outputs, and per-document for HTML.
+        presentation: "xml",
+      }.freeze
+
+      attr_reader :dir
+
+      def initialize(dir)
+        @dir = dir
+        FileUtils.mkdir_p(@dir)
+      end
+
+      # <docid-slug>.<content-hash>.<stage>.<format>
+      # +stage+ must be a key of STAGE_FORMATS; an unknown stage raises KeyError.
+      def path(docid, content_hash, stage)
+        format = STAGE_FORMATS.fetch(stage)
+        File.join(@dir, "#{slug(docid)}.#{content_hash}.#{stage}.#{format}")
+      end
+
+      # Is this exact (document, input-closure, stage) artefact already present?
+      # This is the resumption / skip predicate: a hit is byte-identical to a
+      # fresh build because the hash covers every input that determines output.
+      def key?(docid, content_hash, stage)
+        File.exist?(path(docid, content_hash, stage))
+      end
+
+      def read(docid, content_hash, stage)
+        f = path(docid, content_hash, stage)
+        File.exist?(f) ? File.read(f, encoding: "UTF-8") : nil
+      end
+
+      # Idempotent write: the same (docid, content_hash, stage) always maps to
+      # the same path and the content is a pure function of the hash, so a re-run
+      # overwrites with identical bytes -- no side effects on repeat.
+      def write(docid, content_hash, stage, content)
+        f = path(docid, content_hash, stage)
+        File.write(f, content, encoding: "UTF-8")
+        f
+      end
+
+      # Remove every stored version of this document whose content hash is not
+      # +keep_hash+ -- the superseded artefacts left behind when the document's
+      # content changed. Keeps exactly one (current) version per document per
+      # stage, bounding disk to current state without losing the cache the next
+      # build resumes from.
+      def prune_superseded(docid, keep_hash)
+        STAGE_FORMATS.each do |stage, ext|
+          keep = path(docid, keep_hash, stage)
+          Dir[File.join(@dir, "#{slug(docid)}.*.#{stage}.#{ext}")].each do |f|
+            f == keep or File.delete(f)
+          end
+        end
+      end
+
+      # Wipe the entire store. The escape hatch when inputs the content hash
+      # cannot see -- imported EXPRESS schemas, templates, included files -- have
+      # changed, so the cache can no longer be trusted; the next build recompiles
+      # everything. Tracking such shared-input changes is the collection
+      # maintainer's responsibility, not the build's.
+      def clear
+        FileUtils.rm_rf(@dir)
+        FileUtils.mkdir_p(@dir)
+      end
+
+      # SHA256 over the input closure, truncated to 16 hex (64 bits -- ample for
+      # a per-collection store, and short enough to stay well inside filename
+      # length limits). Each input is hashed to a fixed-width digest and the
+      # digests concatenated before the final hash, so no two distinct closures
+      # collide on the pre-truncation digest. The caller assembles the closure;
+      # the store does not infer it.
+      def self.content_hash(*inputs)
+        digests = inputs.map { |i| Digest::SHA256.hexdigest(i.to_s) }
+        Digest::SHA256.hexdigest(digests.join)[0, 16]
+      end
+
+      private
+
+      def slug(docid)
+        docid.to_s.gsub(/[^A-Za-z0-9._-]+/, "-")
+          .gsub(/-{2,}/, "-").gsub(/\A-|-\z/, "")
+      end
+    end
+
+    # Null object: the store disabled (the default). Never reports a hit, never
+    # writes. Lets the renderer treat "no incremental build" as the no-store
+    # path without a conditional at every call site (open/closed).
+    class NullArtifactStore
+      def path(*_args) = nil
+      def key?(*_args) = false
+      def read(*_args) = nil
+      def write(*_args) = nil
+      def prune_superseded(*_args) = nil
+      def clear(*_args) = nil
+    end
+  end
+end

data/lib/metanorma/collection/collection.rb

@@ -1,26 +1,28 @@
-# frozen_string_literal: true
-
-require "relaton"
-require "relaton/cli"
+require "relaton-cli"
 require "metanorma-utils"
 require_relative "util/util"
 require_relative "util/disambig_files"
 require_relative "config/config"
 require_relative "config/manifest"
+require_relative "helpers"
 
 module Metanorma
   class FileNotFoundException < StandardError; end
 
   class AdocFileNotFoundException < StandardError; end
 
+  # One or more collection members failed to render (#586)
+  class RenderFailureException < StandardError; end
+
   # Metanorma collection of documents
   class Collection
-    attr_reader :file
+    attr_reader :file, :prefatory, :final
 
     # @return [Array<String>] documents-inline to inject the XML into
     #   the collection manifest; documents-external to keeps them outside
-    attr_accessor :directives, :documents, :bibdatas, :coverpage, :dirname
-    attr_accessor :disambig, :manifest, :bibdata, :compile, :config
+    attr_accessor :directives, :documents, :bibdatas, :coverpage,
+                  :coverpage_pdf_portfolio, :dirname,
+                  :disambig, :manifest, :bibdata, :compile, :config
 
     # @param file [String] path to source file
     # @param config [Metanorma::Collection::Config]
@@ -28,11 +30,16 @@ module Metanorma
     def initialize(**args)
       @file = args[:file]
       @dirname = File.expand_path(File.dirname(@file)) # feeds @manifest
-      @documents = args[:documents] || {} # feeds initialize_directives
+      @documents = args[:documents] || {} # feeds initialize_directives, initialize_docs
       @bibdatas = args[:documents] || {}
       initialize_vars
       initialize_config(args[:config])
       initialize_directives
+      initialize_docs
+      validate_flavor(flavor)
+    end
+
+    def initialize_docs
       @documents.merge! @manifest.documents
       @bibdatas.merge! @manifest.documents
       @documents.transform_keys { |k| Util::key(k) }
@@ -42,23 +49,29 @@ module Metanorma
     def initialize_vars
       @compile = Metanorma::Compile.new # feeds @manifest
       @log = Metanorma::Utils::Log.new
+      @log.suppress_log = { severity: 4, category: [], error_ids: [],
+                            locations: [] }
       @disambig = Util::DisambigFiles.new
     end
 
     def initialize_config(config)
       @config = config
-      @directives = config.directive || [] # feeds initialize_directives
+      @directives = (config.directive || []).dup # feeds initialize_directives
       @bibdata = config.bibdata
       @prefatory = config.prefatory_content
       @final = config.final_content
       @manifest = ::Metanorma::Collection::Manifest
         .new(config.manifest, self, @dirname) # feeds initialize_directives
+      @format = config.format.map(&:to_sym)
+      @format&.empty? and @format = nil
     end
 
     def initialize_directives
       d = @directives.each_with_object({}) { |x, m| m[x.key] = x.value }
       @coverpage = d["coverpage"]
+      @coverpage_pdf_portfolio = d["coverpage-pdf-portfolio"]
       @coverpage_style = d["coverpage-style"]
+      @flavor = d["flavor"]
       if (@documents.any? || @manifest) && !d.key?("documents-inline") &&
           !d.key?("documents-external")
         @directives << ::Metanorma::Collection::Config::Directive
@@ -66,6 +79,10 @@ module Metanorma
       end
     end
 
+    def validate_flavor(flavor)
+      ::Metanorma::Compile.new.load_flavor(flavor)
+    end
+
     def clean_exit
       @log.write(File.join(@dirname,
                            "#{File.basename(@file, '.*')}.err.html"))
@@ -75,151 +92,172 @@ module Metanorma
     def to_xml
       c = ::Metanorma::Collection::Config::Config
         .new(directive: @directives, bibdata: @bibdata,
-             manifest: @manifest.config, documents: @documents,
+             manifest: @manifest.config, documents: doc_containers,
              prefatory_content: @prefatory, final_content: @final)
       c.collection = self
-      c.to_xml # .sub("<metanorma-collection", "<metanorma-collection xmlns='http://metanorma.org'")
+      c.to_xml
+    end
+
+    # Populate the Config#documents collection with DocContainer wrappers.
+    # Only emit them when the `documents-inline` directive is set; otherwise
+    # the manifest's <entry fileref=…> already references them externally.
+    def doc_containers
+      @directives.detect { |d| d.key == "documents-inline" } or return []
+      @documents.each_with_index.map do |(_, d), idx|
+        ::Metanorma::Collection::Config::DocContainer.new(
+          id: format("doc%<index>09d", index: idx),
+          content: doccontainer1_inner(d),
+        )
+      end
+    end
+
+    # Inner XML of a single <doc-container> as a string. The body is either
+    # the document's <metanorma> presentation root (with its own xmlns) or
+    # an attachment payload.
+    def doccontainer1_inner(doc)
+      b = Nokogiri::XML::Builder.new do |xml|
+        xml.send(:wrapper) do |w|
+          if doc.attachment
+            doc.bibitem and w << doc.bibitem.root.to_xml
+            w.attachment Vectory::Utils::datauri(doc.file)
+          else
+            doc.to_xml w
+            w.parent.children.first["flavor"] = Util::taste2flavor(flavor)
+          end
+        end
+      end
+      b.parent.elements.first.children.map(&:to_xml).join
     end
 
     def render(opts)
-      ::Metanorma::Collection::Renderer.render self, opts.merge(log: @log)
+      opts[:format].nil? || opts[:format].empty? and
+        opts[:format] = @format || [:html]
+      opts[:log] = @log
+      opts[:flavor] = @flavor
+      output_folder(opts)
+      cr = ::Metanorma::Collection::Renderer.render self, opts
       clean_exit
+      render_failures_abort(cr)
+      cr
     end
 
-    # @return [String, nil]
-    attr_reader :prefatory, :final
-
-    # @return [String]
-    def dummy_header
-      <<~DUMMY
-        = X
-        A
+    # A member whose rendering fails no longer lets the collection
+    # report success with the document missing from the output (#586).
+    # Every member is rendered before aborting, so one run reports all
+    # failures; the raise makes callers (CLI, suma) exit non-zero. Runs
+    # after clean_exit so the failures are in the written log.
+    def render_failures_abort(renderer)
+      f = renderer.fatal_errors
+      f.empty? and return
+      raise RenderFailureException.new(
+        "Collection render failed for #{f.size} document(s):\n" +
+        f.join("\n"),
+      )
+    end
 
-      DUMMY
+    def output_folder(opts)
+      opts[:output_folder] ||= config.output_folder
+      opts[:output_folder] && !Pathname.new(opts[:output_folder]).absolute? and
+        opts[:output_folder] = File.join(@dirname, opts[:output_folder])
+      warn opts[:output_folder]
     end
 
     # @param elm [String] 'prefatory' or 'final'
     # @param builder [Nokogiri::XML::Builder]
     def content_to_xml(elm, builder)
       (cnt = send(elm)) or return
-      @compile.load_flavor(doctype)
-      out = sections(dummy_header + cnt.strip)
+      @compile.load_flavor(Util::taste2flavor(flavor))
+      out = prefatory_parse(
+        Util::asciidoc_dummy_header(
+          docidentifier: dummy_header_docidentifier,
+        ) + cnt.strip,
+      )
       builder.send("#{elm}-content") { |b| b << out }
     end
 
-    # @param cnt [String] prefatory/final content
-    # @return [String] XML
-    def sections(cnt)
-      c = Asciidoctor.convert(cnt, backend: doctype.to_sym, header_footer: true)
-      Nokogiri::XML(c, &:huge).at("//xmlns:sections").children.to_xml
+    # Pick a real docidentifier value for the prefatory dummy header so
+    # the flavor's metadata_id has something pubid-parseable to put into
+    # the bibdata, instead of falling back to its (Liquid-templated)
+    # docid_template (issue #558). Prefer the first manifest document's
+    # docidentifier (concrete, e.g. "IHO S-97"); fall back to the
+    # collection's own (which may carry suffixes like "(all parts)" that
+    # pubid won't parse). Both candidates are wrapped because the
+    # bibitem field may be a parsed Relaton BibliographicItem in some
+    # phases and a Nokogiri::XML::Document in others.
+    def dummy_header_docidentifier
+      first_doc_docid || @bibdata&.docidentifier&.first&.content
     end
 
-    # @param builder [Nokogiri::XML::Builder]
-    def doccontainer(builder)
-      # Array(@directives).include? "documents-inline" or return
-      @directives.detect { |d| d.key == "documents-inline" } or return
-      documents.each_with_index do |(_, d), i|
-        doccontainer1(builder, d, i)
+    def first_doc_docid
+      bib = documents.values.first&.bibitem or return nil
+      if bib.respond_to?(:docidentifier)
+        bib.docidentifier&.first&.content
+      elsif bib.respond_to?(:at) # Nokogiri (rendering-phase shape)
+        # Use local-name() so the match works regardless of whether the
+        # rendering-phase document carries a default namespace, without
+        # tripping Nokogiri's "undefined namespace prefix" error when
+        # it doesn't.
+        bib.at("//*[local-name()='docidentifier']")&.text
       end
     end
 
-    def doccontainer1(builder, doc, idx)
-      id = format("doc%<index>09d", index: idx)
-      builder.send(:"doc-container", id: id) do |b|
-        if doc.attachment
-          doc.bibitem and b << doc.bibitem.root.to_xml
-          b.attachment Vectory::Utils::datauri(doc.file)
-        else
-          doc.to_xml b
-        end
-      end
+    # @param cnt [String] prefatory/final content
+    # @return [String] XML
+    def prefatory_parse(cnt)
+      x = prefatory_parse_semantic(cnt)
+      _, filepath = Util::nokogiri_to_temp(x, "foo", ".presentation.xml")
+      c1 = Util::isodoc_create(Util::taste2flavor(@flavor), @manifest.lang,
+                               @manifest.script, x,
+                               presxml: true).convert(filepath, nil, true)
+      presxml = Nokogiri::XML(c1)
+      prefatory_extract_xml(presxml)
     end
 
-    def doctype
-      @doctype ||= fetch_doctype || "standoc"
+    def prefatory_extract_xml(presxml)
+      body = presxml.at("//xmlns:sections")
+      body.at("//xmlns:p[@class = 'zzSTDTitle1']")&.remove
+      body.text.to_s.strip.empty? and body = presxml.at("//xmlns:preface")
+      body.at("//xmlns:clause[@type = 'toc']")&.remove
+      body.children.to_xml
     end
 
-    def fetch_doctype
-      docid = @bibdata.docidentifier.first
-      docid or return
-      docid.type&.downcase || docid.id&.sub(/\s.*$/, "")&.downcase
+    def prefatory_parse_semantic(cnt)
+      c = Asciidoctor.convert(cnt, backend: Util::taste2flavor(flavor).to_sym,
+                                   header_footer: true)
+      x = Nokogiri::XML(c)
+      x.xpath("//xmlns:clause").each { |n| n["unnumbered"] = true }
+      b = x.at("//xmlns:bibdata")
+      prefatory_parse_fix_bibdata(b)
+      b.children = ::Metanorma::Standoc::Cleanup::MergeBibitems
+        .new(b.to_xml, @bibdata.to_xml(bibdata: true)).merge.to_noko.children
+      x
     end
 
-    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)
-        unless @fileref_resolver
-          (Pathname.new fileref).absolute? or
-            fileref = File.join(ref_folder, fileref)
-          return fileref
-        end
-
-        @fileref_resolver.call(ref_folder, fileref)
+    # Stop standoc ownerless copyright from breaking Relaton parse of bibdata
+    def prefatory_parse_fix_bibdata(bibdata)
+      if cop = bibdata.at("//xmlns:copyright")
+        cop.at("./xmlns:owner") or
+          cop.children.first.previous =
+            "<owner><organization><name>SDO</name></organization></owner>"
       end
+      bibdata
+    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 flavor
+      @flavor ||= fetch_flavor || "standoc"
+    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
+    # TODO: retrieve flavor based on @bibdata publisher when lookup implemented
+    # Will still infer based on docid, but will validate it before proceeding
+    def fetch_flavor
+      docid = @bibdata&.docidentifier&.first or return
+      f = docid.type&.downcase || docid.content&.sub(/\s.*$/,
+                                                     "")&.downcase or return
+      f = Util::taste2flavor(f)
+      require ::Metanorma::Compile.new.stdtype2flavor_gem(f)
+      f
+    rescue LoadError, NameError
+      nil
     end
   end
 end

data/lib/metanorma/collection/config/bibdata.rb

@@ -1,11 +1,11 @@
 require "relaton"
-require "shale"
+require "lutaml/model"
 
 module Metanorma
   class Collection
     module Config
-      class Bibdata < ::Shale::Mapper
-        model ::RelatonBib::BibliographicItem
+      class Bibdata < ::Lutaml::Model::Serializable
+        model ::Relaton::Bib::ItemData
       end
     end
   end

data/lib/metanorma/collection/config/compile_options.rb

@@ -1,12 +1,11 @@
-require "shale"
+require "lutaml/model"
 
 module Metanorma
   class Collection
     module Config
-      class CompileOptions < ::Shale::Mapper
-        attribute :no_install_fonts, ::Shale::Type::Boolean,
-                  default: -> { true }
-        attribute :agree_to_terms, ::Shale::Type::Boolean, default: -> { true }
+      class CompileOptions < ::Lutaml::Model::Serializable
+        attribute :install_fonts, :boolean, default: -> { false }
+        attribute :agree_to_terms, :boolean, default: -> { true }
       end
     end
   end