metanorma 2.1.4 → 2.5.4

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

@@ -5,12 +5,14 @@ require_relative "converters"
 require_relative "bibdata"
 require_relative "directive"
 require_relative "manifest"
+require_relative "namespaces"
+require_relative "doc_container"
 
 module Metanorma
   class Collection
     module Config
       Lutaml::Model::Config.configure do |config|
-        config.xml_adapter = Lutaml::Model::XmlAdapter::NokogiriAdapter
+        config.xml_adapter_type = :nokogiri
       end
 
       class Config < ::Lutaml::Model::Serializable
@@ -20,12 +22,13 @@ module Metanorma
         attribute :directive, Directive, collection: true
         attribute :manifest, Manifest
         attribute :coverpage, :string, default: -> { "cover.html" }
+        attribute :coverpage_pdf_portfolio, :string
         attribute :format, :string, collection: true, default: -> { [:html] }
         attribute :output_folder, :string
         attribute :compile, CompileOptions
         attribute :prefatory_content, :string, raw: true
         attribute :final_content, :string, raw: true
-        attribute :documents, Bibdata, collection: true
+        attribute :documents, DocContainer, collection: true
         attribute :xmlns, :string, default: -> { "http://metanorma.org" }
 
         yaml do
@@ -34,18 +37,21 @@ module Metanorma
           map "bibdata", to: :bibdata, with: { from: :bibdata_from_yaml,
                                                to: :bibdata_to_yaml }
           map "manifest", to: :manifest
+          map "entry", to: :manifest, with: { from: :entry_from_yaml,
+                                              to: :nop_to_yaml }
           map "format", to: :format, render_default: true
           map "output_folder", to: :output_folder
           map "coverpage", to: :coverpage, render_default: true
+          map "coverpage-pdf-portfolio", to: :coverpage_pdf_portfolio,
+                                         render_default: true
           map "compile", to: :compile, render_default: true
           map "prefatory-content", to: :prefatory_content
           map "final-content", to: :final_content
         end
 
         xml do
-          root "metanorma-collection"
-          # namespace "http://metanorma.org", "m"
-          # map_attribute "xmlns", to: :xmlns
+          element "metanorma-collection"
+          namespace MetanormaCollectionNamespace
           map_element "bibdata", to: :bibdata, with: { from: :bibdata_from_xml,
                                                        to: :bibdata_to_xml }
           map_element "directive", to: :directive
@@ -54,15 +60,14 @@ module Metanorma
           map_element "format", to: :format, render_default: true
           map_element "output_folder", to: :output_folder
           map_element "coverpage", to: :coverpage, render_default: true
+          map_element "coverpage-pdf-portfolio", to: :coverpage_pdf_portfolio,
+                                                 render_default: true
           map_element "compile", to: :compile, render_default: true
           map_element "prefatory-content",
                       to: :prefatory_content,
                       with: { from: :prefatory_from_xml,
                               to: :prefatory_to_xml }
-          map_element "doc-container",
-                      to: :documents,
-                      with: { from: :documents_from_xml,
-                              to: :documents_to_xml }
+          map_element "doc-container", to: :documents
           map_element "final-content",
                       to: :final_content,
                       with: { from: :final_from_xml,
@@ -73,9 +78,9 @@ module Metanorma
           model.manifest = Manifest.from_xml(node.to_xml)
         end
 
-        def manifest_to_xml(model, parent, doc)
+        def manifest_to_xml(model, _parent, doc)
           model.collection&.manifest&.clean_manifest(model.manifest)
-          doc.add_element(parent, model.manifest.to_xml)
+          add_raw_xml_element(doc, model.manifest.to_xml)
         end
 
         def prefatory_from_xml(model, node)
@@ -90,17 +95,17 @@ module Metanorma
           content_to_xml(model, parent, doc, "final")
         end
 
-        def content_to_xml(model, parent, doc, type)
+        def content_to_xml(model, _parent, doc, type)
           x = model.send("#{type}_content") or return
           n = Nokogiri::XML(x)
-          elem = if n.elements.size == 1
-                   "<#{type}-content>#{x}</#{type}-content>" # n.root
-                 else
-                   b = Nokogiri::XML::Builder.new
-                   model.collection.content_to_xml(type, b)
-                   b.parent.elements.first
-                 end
-          doc.add_element(parent, elem)
+          raw = if n.elements.size == 1
+                  "<#{type}-content>#{x}</#{type}-content>"
+                else
+                  b = Nokogiri::XML::Builder.new
+                  model.collection.content_to_xml(type, b)
+                  b.parent.elements.first.to_xml
+                end
+          add_raw_xml_element(doc, raw)
         end
 
         def final_from_xml(model, node)
@@ -124,6 +129,31 @@ module Metanorma
           end
         end
 
+        def entry_from_yaml(model, value)
+          model.manifest ||= value
+        end
+
+        def self.flavor_from_yaml(yaml)
+          yaml["directives"]&.detect do |x|
+            x.is_a?(Hash) && x.has_key?("flavor")
+          end&.dig("flavor")&.upcase
+        end
+
+        def self.flavor_to_bibdata(file)
+          # propagate flavor from directives to bibdata
+          yaml = YAML.safe_load(file)
+          flavor = flavor_from_yaml(yaml) or return file
+          yaml["bibdata"] or return file
+          yaml["bibdata"]["ext"] ||= {}
+          yaml["bibdata"]["ext"]["flavor"] ||= flavor
+          yaml.to_yaml
+        end
+
+        def self.from_yaml(file)
+          file = flavor_to_bibdata(file)
+          super
+        end
+
         include Converters
       end
     end

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

@@ -1,54 +1,112 @@
-require "relaton-cli"
+require "relaton/bib"
+require "relaton/bib/hash_parser_v1"
+require_relative "namespaces"
 
 module Metanorma
   class Collection
     module Config
       module Converters
+        # Keys present only in 1.x YAML format — unambiguously absent in 2.x
+        V1_BIBDATA_KEYS = %w[docid link biblionote].freeze
+
         def bibdata_from_yaml(model, value)
-          value and !value.empty? or return
-          model.bibdata = Relaton::Cli::YAMLConvertor.convert_single_file(value)
+          (value and !value.empty?) or return
+          if value.is_a?(String)
+            value = YAML.safe_load_file(value,
+                                        permitted_classes: [Date,
+                                                            Symbol])
+          end
+          force_primary_docidentifier_yaml(value)
+          model.bibdata = if bibdata_yaml_v1_format?(value)
+                            # 1.x YAML format (docid:/link:/biblionote: present) —
+                            # bridge via HashParserV1 for backward compatibility
+                            h = Relaton::Bib::HashParserV1.hash_to_bib(value)
+                            Relaton::Bib::ItemData.new(**h)
+                          else
+                            # 2.x YAML format (docidentifier:/uri:/note: keys) —
+                            # parse directly with lutaml-model
+                            Relaton::Bib::Item.from_yaml(value.to_yaml)
+                          end
         end
 
-        def bibdata_to_yaml(model, doc)
-          doc["bibdata"] = model.bibdata&.to_hash
+        # Recursively detect 1.x-format YAML by presence of renamed keys.
+        # Checks the entire nested structure so relation:/contributor: entries
+        # are also detected.
+        def bibdata_yaml_v1_format?(obj)
+          case obj
+          when Hash
+            return true if (obj.keys.map(&:to_s) & V1_BIBDATA_KEYS).any?
+
+            obj.values.any? { |v| bibdata_yaml_v1_format?(v) }
+          when Array
+            obj.any? { |v| bibdata_yaml_v1_format?(v) }
+          else
+            false
+          end
         end
 
-        def bibdata_from_xml(model, node)
-          node and
-            model.bibdata = Relaton::Cli.parse_xml(node.adapter_node)
+        def force_primary_docidentifier_yaml(value)
+          case value["docid"]
+          when Array
+            value["docid"].empty? ||
+              value["docid"].none? do |x|
+                x["primary"] == "true"
+              end or
+              value["docid"].first["primary"] = "true"
+          when Hash
+            value["docid"]["primary"] ||= "true"
+          end
         end
 
-        def bibdata_to_xml(model, parent, doc)
-          b = model.bibdata or return
-          elem = b.to_xml(bibdata: true, date_format: :full)
-          doc.add_element(parent, elem)
+        def bibdata_to_yaml(model, doc)
+          return unless model.bibdata
+
+          doc["bibdata"] = YAML.safe_load(model.bibdata.to_yaml,
+                                          permitted_classes: [Date, Symbol])
         end
 
-        def nop_to_yaml(model, doc); end
+        def bibdata_from_xml(model, node)
+          node or return
+          force_primary_docidentifier_xml(node.adapter_node.native)
+          model.bibdata = Relaton::Cli.parse_xml(node.adapter_node.native)
+        end
 
-        def documents_from_xml(model, value)
-          model.documents = value
-            .each_with_object([]) do |b, m|
-            m << b
-          end
+        def force_primary_docidentifier_xml(node)
+          node.at("//docidentifier[@primary = 'true']") and return node
+          d = node.at("//docidentifier") or return node
+          d["primary"] = "true"
         end
 
-        def documents_to_xml(model, parent, doc)
-          documents_to_xml?(doc) or return
-          b = Nokogiri::XML::Builder.new do |xml|
-            xml.document do |m|
-              model.collection.doccontainer(m) or return
-            end
-          end
-          b.parent.elements.first.elements
-            .each { |x| doc.add_element(parent, x) }
+        def bibdata_to_xml(model, _parent, doc)
+          b = model.bibdata or return
+          add_raw_xml_element(doc, b.to_xml(bibdata: true, date_format: :full))
         end
 
-        def documents_to_xml?(doc)
-          ret = doc.parent.elements.detect do |x|
-            x.name == "doc-container"
+        def nop_to_yaml(model, doc); end
+        def nop_to_xml(model, parent, doc); end
+
+        # Add a single-element XML string as a child of the wrapper's current
+        # context, preserving inline namespace declarations.
+        #
+        # The custom-method `doc.add_element(parent, str)` path under
+        # lutaml-model 0.8 routes through Moxml fragment parsing, whose graft
+        # (`CustomMethodWrapper#add_fragment_children_to_parent`) discards
+        # xmlns declarations on grafted DataModel children. The
+        # `create_and_add_element` + `raw_content` path goes through the XML
+        # adapter's raw-content handler, which uses Nokogiri's native fragment
+        # parser and keeps xmlns intact. Tag the new element with
+        # MetanormaCollectionNamespace so it inherits cleanly from the
+        # metanorma-collection root rather than emitting `xmlns=""`.
+        def add_raw_xml_element(doc, raw)
+          parsed = Nokogiri::XML.fragment(raw)
+          src = parsed.elements.first or return
+          el = doc.create_and_add_element(src.name)
+          el.namespace_class = MetanormaCollectionNamespace
+          src.attribute_nodes.each do |a|
+            doc.add_attribute(el, a.name, a.value)
           end
-          !ret
+          el.raw_content = src.children.map(&:to_xml).join
+          el
         end
       end
     end

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

@@ -0,0 +1,28 @@
+require "lutaml/model"
+require_relative "namespaces"
+
+module Metanorma
+  class Collection
+    module Config
+      # Serializable wrapper for a single <doc-container> element.
+      #
+      # The body of a doc-container is the inline presentation XML of an
+      # individual document, in a flavour-specific namespace (e.g. bipm,
+      # iso, ietf). We round-trip it as an opaque string via `map_all`
+      # so the underlying XML adapter (Nokogiri) preserves the inner xmlns
+      # declaration; if we let lutaml-model parse the body into typed
+      # children it would lose the inner namespace.
+      class DocContainer < ::Lutaml::Model::Serializable
+        attribute :id, :string
+        attribute :content, :string
+
+        xml do
+          element "doc-container"
+          namespace MetanormaCollectionNamespace
+          map_attribute "id", to: :id
+          map_all to: :content
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,4 @@
 require "lutaml/model"
-require "lutaml/model/xml_adapter/nokogiri_adapter"
 require_relative "../../array_monkeypatch"
 require_relative "converters"
 require_relative "bibdata"
@@ -8,12 +7,12 @@ module Metanorma
   class Collection
     module Config
       Lutaml::Model::Config.configure do |config|
-        config.xml_adapter = Lutaml::Model::XmlAdapter::NokogiriAdapter
+        config.xml_adapter_type = :nokogiri
       end
 
       class Manifest < ::Lutaml::Model::Serializable
         attribute :identifier, :string,
-          default: -> { UUIDTools::UUID.random_create.to_s }
+                  default: -> { UUIDTools::UUID.random_create.to_s }
         attribute :id, :string
         attribute :bibdata, Bibdata
         attribute :type, :string
@@ -25,9 +24,15 @@ module Metanorma
         attribute :index, :boolean, default: -> { true }
         attribute :entry, Manifest, collection: true
         attribute :file, :string
+        attribute :pdffile, :string
+        attribute :format, :string, collection: true
+        attribute :output_filename, :string
+        attribute :sectionsplit_filename, :string
+        attribute :sectionsplit_output, :boolean
 
         yaml do
           map "identifier", to: :identifier
+          map "pdf-file", to: :pdffile
           map "type", to: :type
           map "level", to: :level,
                        with: { from: :level_from_yaml, to: :nop_to_yaml }
@@ -46,6 +51,10 @@ module Metanorma
                           with: { from: :docref_from_yaml, to: :nop_to_yaml }
           map "bibdata", to: :bibdata, with: { from: :bibdata_from_yaml,
                                                to: :bibdata_to_yaml }
+          map "format", to: :format, render_default: true
+          map "output-filename", to: :output_filename
+          map "sectionsplit-filename", to: :sectionsplit_filename
+          map "sectionsplit-output", to: :sectionsplit_output
         end
 
         xml do
@@ -55,26 +64,41 @@ module Metanorma
           map_attribute "sectionsplit", to: :sectionsplit
           map_attribute "index", to: :index
           map_attribute "url", to: :url
+          map_attribute "pdf-file", to: :pdffile
           map_attribute "fileref", to: :file
           map_element "identifier", to: :identifier, render_default: true
           map_element "type", to: :type
           map_element "title", to: :title
+          map_element "format", to: :format
           map_element "bibdata", to: :bibdata, with: { from: :bibdata_from_xml,
                                                        to: :bibdata_to_xml }
           map_element "entry", to: :entry
+          map_element "output-filename", to: :output_filename,
+                                         with: { from: :output_filename_from_xml,
+                                                 to: :nop_to_xml }
+          map_element "sectionsplit-filename", to: :sectionsplit_filename,
+                                               with: { from: :sectionsplit_filename_from_xml,
+                                                       to: :nop_to_xml }
         end
 
         def entry_from_xml(model, node)
           model.entry = Manifest.from_xml(node.node.to_xml)
         end
 
-        def entry_to_xml(model, parent, doc)
+        def entry_to_xml(model, _parent, doc)
           Array(model.entry).each do |e|
-            elem = e.to_xml
-            doc.add_element(parent, elem)
+            add_raw_xml_element(doc, e.to_xml)
           end
         end
 
+        def output_filename_from_xml(model, node)
+          model.output_filename ||= node.content
+        end
+
+        def sectionsplit_filename_from_xml(model, node)
+          model.sectionsplit_filename ||= node.content
+        end
+
         def level_from_yaml(model, value)
           model.type ||= value
         end

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

@@ -0,0 +1,12 @@
+require "lutaml/xml"
+
+module Metanorma
+  class Collection
+    module Config
+      class MetanormaCollectionNamespace < ::Lutaml::Xml::Namespace
+        uri "http://metanorma.org"
+        element_form_default :qualified
+      end
+    end
+  end
+end

data/lib/metanorma/collection/document/document.rb

@@ -48,26 +48,65 @@ module Metanorma
 
         private
 
+        # Select the appropriate Relaton parser class for the given flavor tag.
+        # Uses the flavor's Item class (not Bibdata) because in Relaton 2.x,
+        # Bibdata.from_xml produces a generic Relaton::Bib::ItemData instance
+        # (due to BibdataShared resolving `model ItemData` in the definer's scope),
+        # while Item.from_xml correctly produces a flavor-specific ItemData instance.
+        # @param tag [String, nil] flavor tag (e.g. "iso", "ietf")
+        # @return [Class] Relaton Item parser class
         def mn2relaton_parser(tag)
-          case tag.sub(/-standard/, "")
-          when "bipm" then ::RelatonBipm::XMLParser
-          when "bsi" then ::RelatonBsi::XMLParser
-          when "ietf" then ::RelatonIetf::XMLParser
-          when "iho" then ::RelatonIho::XMLParser
-          when "itu" then ::RelatonItu::XMLParser
-          when "iec" then ::RelatonIec::XMLParser
-          when "iso" then ::RelatonIsoBib::XMLParser
-          when "nist" then ::RelatonNist::XMLParser
-          when "ogc" then ::RelatonOgc::XMLParser
-          else ::RelatonBib::XMLParser
+          case tag
+          when "bipm"
+            require "relaton/bipm" unless defined?(::Relaton::Bipm::Item)
+            ::Relaton::Bipm::Item
+          when "bsi"
+            require "relaton/bsi" unless defined?(::Relaton::Bsi::Item)
+            ::Relaton::Bsi::Item
+          when "ietf"
+            require "relaton/ietf" unless defined?(::Relaton::Ietf::Item)
+            ::Relaton::Ietf::Item
+          when "iho"
+            require "relaton/iho" unless defined?(::Relaton::Iho::Item)
+            ::Relaton::Iho::Item
+          when "itu"
+            require "relaton/itu" unless defined?(::Relaton::Itu::Item)
+            ::Relaton::Itu::Item
+          when "iec"
+            require "relaton/iec" unless defined?(::Relaton::Iec::Item)
+            ::Relaton::Iec::Item
+          when "iso"
+            require "relaton/iso" unless defined?(::Relaton::Iso::Item)
+            ::Relaton::Iso::Item
+          when "nist"
+            require "relaton/nist" unless defined?(::Relaton::Nist::Item)
+            ::Relaton::Nist::Item
+          when "ogc"
+            require "relaton/ogc" unless defined?(::Relaton::Ogc::Item)
+            ::Relaton::Ogc::Item
+          else
+            ::Relaton::Bib::Item
           end
+        rescue LoadError => e
+          warn "Warning: Failed to load relaton gem for '#{tag}': #{e.message}. Falling back to Relaton::Bib::Item"
+          ::Relaton::Bib::Item
         end
 
         # #param xml [Nokogiri::XML::Document, Nokogiri::XML::Element]
         # @return [RelatonBib::BibliographicItem,RelatonIso::IsoBibliographicItem]
         def from_xml(xml)
           b = xml.at("//xmlns:bibitem|//xmlns:bibdata")
-          r = mn2relaton_parser(xml.root.name)
+          # <bibitem> elements are always flavor-independent: use the base
+          # Relaton::Bib::Bibitem regardless of collection flavor.
+          # <bibdata> elements carry flavor-specific metadata (<ext> etc.) and
+          # must be parsed with the appropriate flavor Bibdata class.
+          r = if b.name == "bibitem"
+                ::Relaton::Bib::Bibitem
+              else
+                mn2relaton_parser(xml.root["flavor"])
+              end
+          # Relaton doesn't understand Pres XML tags
+          b.xpath("//xmlns:fmt-identifier").each(&:remove)
           r.from_xml(b.to_xml)
         end
 
@@ -113,9 +152,9 @@ module Metanorma
 
       # @return [String]
       def type
-        first = @bibitem.docidentifier.first
+        first = @bibitem.docidentifier&.first
         @type ||= (first&.type&.downcase ||
-                   first&.id&.match(/^[^\s]+/)&.to_s)&.downcase ||
+                   first&.content&.match(/^[^\s]+/)&.to_s)&.downcase ||
           "standoc"
       end
 
@@ -125,7 +164,7 @@ module Metanorma
         if @raw
           builder.parent.add_child(@bibitem.root)
         else
-          builder.send("#{type}-standard") do |b|
+          builder.send(:metanorma) do |b|
             b << @bibitem.to_xml(bibdata: true)
           end
         end