metanorma 2.0.0 → 2.5.5

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

@@ -1,84 +1,90 @@
-require "shale"
-require_relative "../../shale_monkeypatch"
+require "lutaml/model"
 require_relative "../../array_monkeypatch"
 require_relative "compile_options"
 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
-      require "shale/adapter/nokogiri"
-      ::Shale.xml_adapter = ::Shale::Adapter::Nokogiri
+      Lutaml::Model::Config.configure do |config|
+        config.xml_adapter_type = :nokogiri
+      end
 
-      class Config < ::Shale::Mapper
+      class Config < ::Lutaml::Model::Serializable
         attr_accessor :path, :collection, :from_xml
 
         attribute :bibdata, Bibdata
         attribute :directive, Directive, collection: true
         attribute :manifest, Manifest
-        attribute :format, ::Shale::Type::String, collection: true,
-                                                  default: -> { [:html] }
-        attribute :output_folder, ::Shale::Type::String
-        attribute :coverpage, ::Shale::Type::String, default: -> {
-                                                                "cover.html"
-                                                              }
+        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, ::Shale::Type::String
-        attribute :final_content, ::Shale::Type::String
-        attribute :documents, Bibdata, collection: true
-        attribute :xmlns, ::Shale::Type::String, default: -> { "http://metanorma.org" }
+        attribute :prefatory_content, :string, raw: true
+        attribute :final_content, :string, raw: true
+        attribute :documents, DocContainer, collection: true
+        attribute :xmlns, :string, default: -> { "http://metanorma.org" }
 
         yaml do
-          map "directives", using: { from: :directives_from_yaml,
-                                     to: :directives_to_yaml }
-          map "bibdata", using: { from: :bibdata_from_yaml,
-                                  to: :bibdata_to_yaml }
+          map "directives", to: :directive, with: { from: :directives_from_yaml,
+                                                    to: :directives_to_yaml }
+          map "bibdata", to: :bibdata, with: { from: :bibdata_from_yaml,
+                                               to: :bibdata_to_yaml }
           map "manifest", to: :manifest
-          map "format", to: :format
+          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
-          map "compile", to: :compile
+          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
-          map_element "bibdata", using: { from: :bibdata_from_xml,
-                                          to: :bibdata_to_xml }
-          map_element "directive", using: { from: :directive_from_xml,
-                                            to: :directive_to_xml }
-          map_element "entry", using: { from: :manifest_from_xml,
-                                        to: :manifest_to_xml }
-          map_element "format", to: :format
+          element "metanorma-collection"
+          namespace MetanormaCollectionNamespace
+          map_element "bibdata", to: :bibdata, with: { from: :bibdata_from_xml,
+                                                       to: :bibdata_to_xml }
+          map_element "directive", to: :directive
+          map_element "entry", to: :manifest, with: { from: :manifest_from_xml,
+                                                      to: :manifest_to_xml }
+          map_element "format", to: :format, render_default: true
           map_element "output_folder", to: :output_folder
-          map_element "coverpage", to: :coverpage
-          map_element "compile", to: :compile
-          map_element "prefatory-content", using: { from: :prefatory_from_xml,
-                                                    to: :prefatory_to_xml }
-          map_element "doc-container",
-                      using: { from: :documents_from_xml,
-                               to: :documents_to_xml }
-          map_element "final-content", using: { from: :final_from_xml,
-                                                to: :final_to_xml }
+          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
+          map_element "final-content",
+                      to: :final_content,
+                      with: { from: :final_from_xml,
+                              to: :final_to_xml }
         end
 
         def manifest_from_xml(model, node)
           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)
-          model.prefatory_content = node.to_xml
+          model.prefatory_content = node.children.map(&:to_xml).join
         end
 
         def prefatory_to_xml(model, parent, doc)
@@ -89,32 +95,21 @@ 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 then 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)
-          model.final_content = node.to_xml
-        end
-
-        def directive_from_xml(model, node)
-          model.directive ||= []
-          model.directive << Directive.from_xml(node.to_xml)
-        end
-
-        def directive_to_xml(model, parent, doc)
-          Array(model.directive).each do |e|
-            elem = e.to_xml
-            doc.add_element(parent, elem)
-          end
+          model.final_content = node.children.map(&:to_xml).join
         end
 
         def directives_from_yaml(model, value)
@@ -134,26 +129,29 @@ module Metanorma
           end
         end
 
-        def documents_from_xml(model, value)
-          x = if value.is_a?(Shale::Adapter::Nokogiri::Node)
-                value.content
-              else Nokogiri::XML(value)
-              end
-          model.documents = x.xpath(".//bibdata")
-            .each_with_object([]) do |b, m|
-            m << Bibdata.from_xml(b.to_xml)
-          end
+        def entry_from_yaml(model, value)
+          model.manifest ||= value
         end
 
-        def documents_to_xml(model, parent, doc)
-          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 do |x|
-            doc.add_element(parent, x)
-          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

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

@@ -1,29 +1,113 @@
-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
+
+        # 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 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_yaml(model, doc)
-          doc["bibdata"] = model.bibdata&.to_hash
+          return unless model.bibdata
+
+          doc["bibdata"] = YAML.safe_load(model.bibdata.to_yaml,
+                                          permitted_classes: [Date, Symbol])
         end
 
         def bibdata_from_xml(model, node)
-          model.bibdata = Relaton::Cli.parse_xml(node.content)
+          node or return
+          force_primary_docidentifier_xml(node.adapter_node.native)
+          model.bibdata = Relaton::Cli.parse_xml(node.adapter_node.native)
+        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 bibdata_to_xml(model, parent, doc)
+        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)
+          add_raw_xml_element(doc, b.to_xml(bibdata: true, date_format: :full))
         end
 
         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
+          el.raw_content = src.children.map(&:to_xml).join
+          el
+        end
       end
     end
   end

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

@@ -1,9 +1,15 @@
 module Metanorma
   class Collection
     module Config
-      class Directive < ::Shale::Mapper
-        attribute :key, ::Shale::Type::String
-        attribute :value, ::Shale::Type::String
+      class Directive < ::Lutaml::Model::Serializable
+        attribute :key, :string
+        attribute :value, :string
+
+        xml do
+          root "directive"
+          map_element "key", to: :key
+          map_element "value", to: :value
+        end
       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 "shale"
-require_relative "../../shale_monkeypatch"
+require "lutaml/model"
 require_relative "../../array_monkeypatch"
 require_relative "converters"
 require_relative "bibdata"
@@ -7,68 +6,99 @@ require_relative "bibdata"
 module Metanorma
   class Collection
     module Config
-      require "shale/adapter/nokogiri"
-      ::Shale.xml_adapter = ::Shale::Adapter::Nokogiri
+      Lutaml::Model::Config.configure do |config|
+        config.xml_adapter_type = :nokogiri
+      end
 
-      class Manifest < ::Shale::Mapper
-        attribute :identifier, ::Shale::Type::String,
+      class Manifest < ::Lutaml::Model::Serializable
+        attribute :identifier, :string,
                   default: -> { UUIDTools::UUID.random_create.to_s }
-        attribute :id, ::Shale::Type::String
+        attribute :id, :string
         attribute :bibdata, Bibdata
-        attribute :type, ::Shale::Type::String
-        attribute :title, ::Shale::Type::String
-        attribute :url, ::Shale::Type::String
-        attribute :attachment, ::Shale::Type::Boolean
-        attribute :sectionsplit, ::Shale::Type::Boolean
-        attribute :index, ::Shale::Type::Boolean, default: -> { true }
+        attribute :type, :string
+        attribute :title, :string
+        attribute :url, :string
+        attribute :level, :string
+        attribute :attachment, :boolean
+        attribute :sectionsplit, :boolean
+        attribute :index, :boolean, default: -> { true }
         attribute :entry, Manifest, collection: true
-        attribute :file, ::Shale::Type::String
+        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", using: { from: :level_from_yaml, to: :nop_to_yaml }
+          map "level", to: :level,
+                       with: { from: :level_from_yaml, to: :nop_to_yaml }
           map "title", to: :title
           map "url", to: :url
           map "attachment", to: :attachment
           map "sectionsplit", to: :sectionsplit
           map "index", to: :index
           map "file", to: :file
-          map "fileref", using: { from: :fileref_from_yaml, to: :nop_to_yaml }
+          map "fileref", to: :file,
+                         with: { from: :fileref_from_yaml, to: :nop_to_yaml }
           map "entry", to: :entry
-          map "docref", using: { from: :docref_from_yaml, to: :nop_to_yaml }
-          map "manifest", using: { from: :docref_from_yaml, to: :nop_to_yaml }
-          map "bibdata", using: { from: :bibdata_from_yaml,
-                                  to: :bibdata_to_yaml }
+          map "docref", to: :entry,
+                        with: { from: :docref_from_yaml, to: :nop_to_yaml }
+          map "manifest", to: :entry,
+                          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
           root "entry"
-          map_attribute "id", to: :id
+          map_attribute "target", to: :id
           map_attribute "attachment", to: :attachment
           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
+          map_element "identifier", to: :identifier, render_default: true
           map_element "type", to: :type
           map_element "title", to: :title
-          map_element "bibdata", using: { from: :bibdata_from_xml,
-                                          to: :bibdata_to_xml }
-          map_element "entry", to: :entry # using: { from: :entry_from_xml, to: :entry_to_xml }
+          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.content)
+          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

@@ -1,3 +1,5 @@
+require "relaton-cli"
+
 module Metanorma
   class Collection
     class Document
@@ -46,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
 
@@ -111,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
 
@@ -123,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