metanorma-document 0.2.6 → 0.2.8

data/lib/metanorma/plateau_document/metadata.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module PlateauDocument
+    module Metadata
+      autoload :PlateauBibliographicItem,
+               "#{__dir__}/metadata/plateau_bibliographic_item"
+    end
+  end
+end

data/lib/metanorma/plateau_document/root.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module PlateauDocument
+    class Root < Lutaml::Model::Serializable
+      include Metanorma::StandardDocument::RootAttributes
+
+      def self.lutaml_default_register
+        :plateau_document
+      end
+
+      attribute :bibdata, Metadata::PlateauBibliographicItem
+      attribute :preface,
+                Metanorma::IsoDocument::Sections::IsoPreface
+      attribute :sections,
+                Metanorma::IsoDocument::Sections::IsoSections
+      attribute :annex,
+                Metanorma::JisDocument::Sections::JisAnnexSection,
+                collection: true
+
+      xml do
+        element "metanorma"
+        namespace Metanorma::StandardDocument::Namespace
+
+        Metanorma::StandardDocument::RootXmlMapping.apply(self)
+      end
+    end
+  end
+end

data/lib/metanorma/plateau_document.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module PlateauDocument
+    autoload :Metadata, "metanorma/plateau_document/metadata"
+    autoload :Root, "metanorma/plateau_document/root"
+  end
+end
+
+Metanorma::Registers::Setup.setup_plateau_register

data/lib/metanorma/registers/setup.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Registers
+    module Setup
+      class << self
+        # ============================================================
+        # ISO-family registers — fallback to :iso_document
+        # ============================================================
+
+        def setup_iso_register
+          sd = Metanorma::StandardDocument
+          iso = Metanorma::IsoDocument
+          reg = Lutaml::Model::Register.new(:iso_document)
+          Lutaml::Model::GlobalRegister.register(reg)
+
+          reg.register_global_type_substitution(
+            from_type: sd::Sections::ClauseSection,
+            to_type: iso::Sections::IsoClauseSection,
+          )
+          reg.register_global_type_substitution(
+            from_type: sd::Sections::AnnexSection,
+            to_type: iso::Sections::IsoAnnexSection,
+          )
+          reg.register_global_type_substitution(
+            from_type: sd::Sections::Sections,
+            to_type: iso::Sections::IsoSections,
+          )
+          reg.register_global_type_substitution(
+            from_type: sd::Sections::Preface,
+            to_type: iso::Sections::IsoPreface,
+          )
+        end
+
+        def setup_iec_register
+          reg = Lutaml::Model::Register.new(:iec_document,
+                                            fallback: [:iso_document])
+          Lutaml::Model::GlobalRegister.register(reg)
+        end
+
+        def setup_oiml_register
+          reg = Lutaml::Model::Register.new(:oiml_document,
+                                            fallback: [:iso_document])
+          Lutaml::Model::GlobalRegister.register(reg)
+        end
+
+        def setup_bsi_register
+          iso = Metanorma::IsoDocument
+          reg = Lutaml::Model::Register.new(:bsi_document,
+                                            fallback: [:iso_document])
+          Lutaml::Model::GlobalRegister.register(reg)
+
+          reg.register_global_type_substitution(
+            from_type: iso::Sections::IsoSections,
+            to_type: Metanorma::BsiDocument::Sections::BsiSections,
+          )
+          reg.register_global_type_substitution(
+            from_type: iso::Sections::IsoClauseSection,
+            to_type: Metanorma::BsiDocument::Sections::BsiClauseSection,
+          )
+          reg.register_global_type_substitution(
+            from_type: iso::Sections::IsoAnnexSection,
+            to_type: Metanorma::BsiDocument::Sections::BsiAnnexSection,
+          )
+        end
+
+        def setup_jis_register
+          iso = Metanorma::IsoDocument
+          reg = Lutaml::Model::Register.new(:jis_document,
+                                            fallback: [:iso_document])
+          Lutaml::Model::GlobalRegister.register(reg)
+
+          reg.register_global_type_substitution(
+            from_type: iso::Sections::IsoAnnexSection,
+            to_type: Metanorma::JisDocument::Sections::JisAnnexSection,
+          )
+        end
+
+        def setup_gb_register
+          reg = Lutaml::Model::Register.new(:gb_document,
+                                            fallback: [:iso_document])
+          Lutaml::Model::GlobalRegister.register(reg)
+        end
+
+        def setup_m3d_register
+          reg = Lutaml::Model::Register.new(:m3d_document)
+          Lutaml::Model::GlobalRegister.register(reg)
+        end
+
+        def setup_plateau_register
+          reg = Lutaml::Model::Register.new(:plateau_document,
+                                            fallback: [:jis_document])
+          Lutaml::Model::GlobalRegister.register(reg)
+        end
+
+        # ============================================================
+        # Isodoc-family registers — no ISO fallback
+        # ============================================================
+
+        def setup_ieee_register
+          sd = Metanorma::StandardDocument
+          reg = Lutaml::Model::Register.new(:ieee_document)
+          Lutaml::Model::GlobalRegister.register(reg)
+
+          reg.register_global_type_substitution(
+            from_type: sd::Sections::Sections,
+            to_type: Metanorma::IeeeDocument::Sections::IeeeSections,
+          )
+        end
+
+        def setup_ietf_register
+          sd = Metanorma::StandardDocument
+          reg = Lutaml::Model::Register.new(:ietf_document)
+          Lutaml::Model::GlobalRegister.register(reg)
+
+          reg.register_global_type_substitution(
+            from_type: sd::Sections::Sections,
+            to_type: Metanorma::IetfDocument::Sections::IetfSections,
+          )
+          reg.register_global_type_substitution(
+            from_type: sd::Sections::ContentSection,
+            to_type: Metanorma::IetfDocument::Sections::IetfContentSection,
+          )
+          reg.register_global_type_substitution(
+            from_type: sd::Sections::ClauseSection,
+            to_type: Metanorma::IetfDocument::Sections::IetfClauseSection,
+          )
+          reg.register_global_type_substitution(
+            from_type: sd::Sections::AnnexSection,
+            to_type: Metanorma::IetfDocument::Sections::IetfAnnexSection,
+          )
+        end
+
+        def setup_nist_register
+          sd = Metanorma::StandardDocument
+          reg = Lutaml::Model::Register.new(:nist_document)
+          Lutaml::Model::GlobalRegister.register(reg)
+
+          reg.register_global_type_substitution(
+            from_type: sd::Sections::Preface,
+            to_type: Metanorma::NistDocument::Sections::NistPreface,
+          )
+        end
+
+        def setup_un_register
+          sd = Metanorma::StandardDocument
+          reg = Lutaml::Model::Register.new(:un_document)
+          Lutaml::Model::GlobalRegister.register(reg)
+
+          reg.register_global_type_substitution(
+            from_type: sd::Sections::Sections,
+            to_type: Metanorma::UnDocument::Sections::UnSections,
+          )
+          reg.register_global_type_substitution(
+            from_type: sd::Sections::Preface,
+            to_type: Metanorma::UnDocument::Sections::UnPreface,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/registers.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Registers
+    autoload :Setup, "#{__dir__}/registers/setup"
+  end
+end

data/lib/metanorma/ribose_document/root.rb

@@ -1,67 +1,25 @@
 # frozen_string_literal: true
 
-require "metanorma/standard_document"
-require "metanorma/iso_document"
-
 module Metanorma
   module RiboseDocument
-    # Most basic document flavor — uses StandardDocument metadata
-    # but ISO document structure for sections/blocks.
-    class Root < Metanorma::StandardDocument::Root
-      attribute :version, :string
-      attribute :type, :string
-      attribute :schema_version, :string
-      attribute :flavor, :string
+    class Root < Lutaml::Model::Serializable
+      include Metanorma::StandardDocument::RootAttributes
 
       attribute :bibdata,
                 Metanorma::RiboseDocument::Metadata::RiboseBibliographicItem
-
-      attribute :term_sources,
-                Metanorma::Document::Components::ReferenceElements::Citation,
+      attribute :preface,
+                Metanorma::StandardDocument::Sections::Preface
+      attribute :sections,
+                Metanorma::StandardDocument::Sections::Sections
+      attribute :annex,
+                Metanorma::StandardDocument::Sections::AnnexSection,
                 collection: true
 
-      attribute :preface, Metanorma::IsoDocument::Sections::IsoPreface
-      attribute :sections, Metanorma::IsoDocument::Sections::IsoSections
-      attribute :annex, Metanorma::IsoDocument::Sections::IsoAnnexSection,
-                collection: true
-      attribute :bibliography,
-                Metanorma::StandardDocument::Sections::BibliographySection
-      attribute :boilerplate, Metanorma::IsoDocument::Boilerplate
-      attribute :metanorma_extension,
-                Metanorma::IsoDocument::Metadata::MetanormaExtension
-      attribute :annotation_container, Metanorma::IsoDocument::AnnotationContainer
-      attribute :indexsect,
-                Metanorma::Document::Components::Sections::BasicSection
-      attribute :autonum, :string
-      attribute :fmt_xref_label, :string
-      attribute :localized_strings,
-                Metanorma::Document::Components::Inline::LocalizedStringsElement
-      attribute :fmt_footnote_container,
-                Metanorma::Document::Components::Inline::FmtFootnoteContainerElement
-      attribute :colophon, Metanorma::IsoDocument::Sections::Colophon
-
       xml do
         element "metanorma"
         namespace Metanorma::StandardDocument::Namespace
-        map_attribute "type", to: :type
-        map_attribute "version", to: :version
-        map_attribute "schema-version", to: :schema_version
-        map_attribute "flavor", to: :flavor
-        map_element "bibdata", to: :bibdata
-        map_element "termdocsource", to: :term_sources
-        map_element "metanorma-extension", to: :metanorma_extension
-        map_element "boilerplate", to: :boilerplate
-        map_element "preface", to: :preface
-        map_element "sections", to: :sections
-        map_element "annex", to: :annex
-        map_element "bibliography", to: :bibliography
-        map_element "annotation-container", to: :annotation_container
-        map_element "indexsect", to: :indexsect
-        map_element "localized-strings", to: :localized_strings
-        map_element "fmt-footnote-container", to: :fmt_footnote_container
-        map_element "colophon", to: :colophon
-        map_attribute "autonum", to: :autonum
-        map_attribute "fmt-xref-label", to: :fmt_xref_label
+
+        Metanorma::StandardDocument::RootXmlMapping.apply(self)
       end
     end
   end

data/lib/metanorma/ribose_document.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "metanorma/standard_document"
-
 module Metanorma
   module RiboseDocument
     autoload :Metadata, "metanorma/ribose_document/metadata"

data/lib/metanorma/standard_document/annotation_container.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module StandardDocument
+    class AnnotationContainer < Lutaml::Model::Serializable
+      attribute :content, :string
+
+      xml do
+        element "annotation-container"
+        map_all_content to: :content
+      end
+    end
+  end
+end

data/lib/metanorma/standard_document/block_attributes.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module StandardDocument
+    # Mixin that declares individually-typed block collection attributes
+    # for section-level models (ClauseSection, AnnexSection, ContentSection, etc.).
+    #
+    # Include this module in any Serializable class that represents a section
+    # body containing heterogeneous block-level content (paragraphs, tables,
+    # figures, etc.).
+    module BlockAttributes
+      def self.included(base)
+        base.class_eval do
+          attribute :paragraphs,
+                    Metanorma::Document::Components::Paragraphs::ParagraphBlock,
+                    collection: true
+          attribute :unordered_lists,
+                    Metanorma::Document::Components::Lists::UnorderedList,
+                    collection: true
+          attribute :ordered_lists,
+                    Metanorma::Document::Components::Lists::OrderedList,
+                    collection: true
+          attribute :tables,
+                    Metanorma::Document::Components::Tables::TableBlock,
+                    collection: true
+          attribute :figures,
+                    Metanorma::Document::Components::AncillaryBlocks::FigureBlock,
+                    collection: true
+          attribute :formulas,
+                    Metanorma::Document::Components::AncillaryBlocks::FormulaBlock,
+                    collection: true
+          attribute :examples,
+                    Metanorma::Document::Components::AncillaryBlocks::ExampleBlock,
+                    collection: true
+          attribute :notes,
+                    Metanorma::Document::Components::Blocks::NoteBlock,
+                    collection: true
+          attribute :admonitions,
+                    Metanorma::Document::Components::MultiParagraph::AdmonitionBlock,
+                    collection: true
+          attribute :sourcecode_blocks,
+                    Metanorma::Document::Components::AncillaryBlocks::SourcecodeBlock,
+                    collection: true
+          attribute :quote_blocks,
+                    Metanorma::Document::Components::MultiParagraph::QuoteBlock,
+                    collection: true
+          attribute :definition_lists,
+                    Metanorma::Document::Components::Lists::DefinitionList,
+                    collection: true
+        end
+      end
+    end
+
+    # Provides `blocks` method for ordered-content section types.
+    # Returns child nodes in document order via `each_mixed_content`.
+    module OrderedContent
+      def blocks
+        @blocks ||=
+          begin
+            result = []
+            each_mixed_content do |node|
+              result << node unless node.is_a?(String)
+            end
+            result
+          end
+      end
+    end
+
+    # Presentation/formatting attributes shared by all section types.
+    # Include in any section class that supports presentation metadata.
+    module PresentationAttributes
+      def self.included(base)
+        base.class_eval do
+          attribute :anchor, :string
+          attribute :semx_id, :string
+          attribute :autonum, :string
+          attribute :displayorder, :integer
+          attribute :fmt_title,
+                    Metanorma::Document::Components::Inline::FmtTitleElement
+          attribute :fmt_xref_label,
+                    Metanorma::Document::Components::Inline::FmtXrefLabelElement,
+                    collection: true
+          attribute :variant_title,
+                    Metanorma::Document::Components::Inline::VariantTitleElement,
+                    collection: true
+          attribute :fmt_annotation_start,
+                    Metanorma::Document::Components::Inline::FmtAnnotationStartElement,
+                    collection: true
+          attribute :fmt_annotation_end,
+                    Metanorma::Document::Components::Inline::FmtAnnotationEndElement,
+                    collection: true
+        end
+      end
+    end
+
+    # Adds XML element mappings for block-level content to a mapping builder.
+    # Call inside an `xml do` block:
+    #
+    #   xml do
+    #     element "clause"
+    #     ordered
+    #     BlockXmlMapping.apply_block_mappings(self)
+    #     # ... additional mappings
+    #   end
+    module BlockXmlMapping
+      BLOCK_MAPPINGS = {
+        "p" => :paragraphs,
+        "ul" => :unordered_lists,
+        "ol" => :ordered_lists,
+        "table" => :tables,
+        "figure" => :figures,
+        "formula" => :formulas,
+        "example" => :examples,
+        "note" => :notes,
+        "admonition" => :admonitions,
+        "sourcecode" => :sourcecode_blocks,
+        "quote" => :quote_blocks,
+        "dl" => :definition_lists,
+      }.freeze
+
+      def self.apply_block_mappings(mapping)
+        BLOCK_MAPPINGS.each do |element_name, attr_name|
+          mapping.map_element(element_name, to: attr_name)
+        end
+      end
+    end
+
+    # Shared XML mapping helpers for section-level elements.
+    # Extracts the common attribute/element mappings duplicated across
+    # ClauseSection, AnnexSection, and their flavor-specific subclasses.
+    module SectionXmlMapping
+      # Common XML attribute mappings for clause sections.
+      def self.apply_clause_attributes(mapping)
+        mapping.map_attribute "id",            to: :id
+        mapping.map_attribute "anchor",        to: :anchor
+        mapping.map_attribute "type",          to: :type
+        mapping.map_attribute "number",        to: :number
+        mapping.map_attribute "obligation",    to: :obligation
+        mapping.map_attribute "inline-header", to: :inline_header
+        mapping.map_attribute "unnumbered",    to: :unnumbered
+        mapping.map_attribute "toc",           to: :toc
+        mapping.map_attribute "class",         to: :class_attr
+        mapping.map_attribute "semx-id",       to: :semx_id
+        mapping.map_attribute "autonum",       to: :autonum
+        mapping.map_attribute "displayorder",  to: :displayorder
+      end
+
+      # Common XML element mappings for clause sections.
+      def self.apply_clause_elements(mapping)
+        mapping.map_element "title",                to: :title
+        mapping.map_element "variant-title",        to: :variant_title
+        mapping.map_element "fmt-title",            to: :fmt_title
+        mapping.map_element "fmt-xref-label",       to: :fmt_xref_label
+
+        BlockXmlMapping.apply_block_mappings(mapping)
+
+        mapping.map_element "amend",                to: :amend
+        mapping.map_element "clause",               to: :clause
+        mapping.map_element "terms",                to: :terms
+        mapping.map_element "definitions",          to: :definitions
+        mapping.map_element "references",           to: :references
+        mapping.map_element "floating-title",       to: :floating_title
+        mapping.map_element "form",                 to: :form
+        mapping.map_element "requirement",          to: :requirement
+        mapping.map_element "recommendation",       to: :recommendation
+        mapping.map_element "permission",           to: :permission
+        mapping.map_element "pagebreak",            to: :pagebreak
+        mapping.map_element "bookmark",             to: :bookmark
+        mapping.map_element "fmt-annotation-start", to: :fmt_annotation_start
+        mapping.map_element "fmt-annotation-end",   to: :fmt_annotation_end
+      end
+
+      # Common XML attribute mappings for annex sections.
+      def self.apply_annex_attributes(mapping)
+        mapping.map_attribute "id",            to: :id
+        mapping.map_attribute "number",        to: :number
+        mapping.map_attribute "obligation",    to: :obligation,
+                                               render_empty: true
+        mapping.map_attribute "unnumbered",    to: :unnumbered
+        mapping.map_attribute "toc",           to: :toc
+        mapping.map_attribute "anchor",        to: :anchor
+        mapping.map_attribute "semx-id",       to: :semx_id
+        mapping.map_attribute "autonum",       to: :autonum
+        mapping.map_attribute "displayorder",  to: :displayorder
+        mapping.map_attribute "inline-header", to: :inline_header
+        mapping.map_attribute "language",      to: :language, render_empty: true
+        mapping.map_attribute "script",        to: :script, render_empty: true
+      end
+
+      # Common XML element mappings for annex sections.
+      def self.apply_annex_elements(mapping)
+        mapping.map_element "title",                to: :title
+        mapping.map_element "variant-title",        to: :variant_title
+        mapping.map_element "fmt-title",            to: :fmt_title
+        mapping.map_element "fmt-xref-label",       to: :fmt_xref_label
+
+        BlockXmlMapping.apply_block_mappings(mapping)
+
+        mapping.map_element "clause",               to: :clause
+        mapping.map_element "appendix",             to: :appendix
+        mapping.map_element "terms",                to: :terms
+        mapping.map_element "definitions",          to: :definitions
+        mapping.map_element "references",           to: :references
+        mapping.map_element "floating-title",       to: :floating_title
+        mapping.map_element "pagebreak",            to: :pagebreak
+        mapping.map_element "fmt-annotation-start", to: :fmt_annotation_start
+        mapping.map_element "fmt-annotation-end",   to: :fmt_annotation_end
+      end
+
+      # Common XML element/attribute mappings for the sections container.
+      def self.apply_sections_elements(mapping)
+        mapping.map_element "clause",         to: :clause
+        mapping.map_element "terms",          to: :terms
+        mapping.map_element "definitions",    to: :definitions
+        mapping.map_element "floating-title", to: :floating_title
+        mapping.map_element "references",     to: :references
+      end
+
+      def self.apply_sections_attributes(mapping)
+        mapping.map_attribute "semx-id",      to: :semx_id
+        mapping.map_attribute "displayorder", to: :displayorder
+      end
+
+      # Common XML element/attribute mappings for preface containers.
+      def self.apply_preface_elements(mapping)
+        mapping.map_element "abstract",          to: :abstract
+        mapping.map_element "foreword",          to: :foreword
+        mapping.map_element "introduction",      to: :introduction
+        mapping.map_element "acknowledgements",  to: :acknowledgements
+        mapping.map_element "executivesummary",  to: :executivesummary
+      end
+
+      def self.apply_preface_attributes(mapping)
+        mapping.map_attribute "semx-id",      to: :semx_id
+        mapping.map_attribute "displayorder", to: :displayorder
+      end
+
+      # Common XML attribute/element mappings for ContentSection subclasses.
+      def self.apply_content_section_attributes(mapping)
+        mapping.map_attribute "id",             to: :id
+        mapping.map_attribute "anchor",         to: :anchor
+        mapping.map_attribute "type",           to: :type
+        mapping.map_attribute "number",         to: :number
+        mapping.map_attribute "obligation",     to: :obligation
+        mapping.map_attribute "inline-header",  to: :inline_header
+        mapping.map_attribute "unnumbered",     to: :unnumbered
+        mapping.map_attribute "toc",            to: :toc
+        mapping.map_attribute "class",          to: :class_attr
+        mapping.map_attribute "semx-id",        to: :semx_id
+        mapping.map_attribute "autonum",        to: :autonum
+        mapping.map_attribute "displayorder",   to: :displayorder
+      end
+
+      def self.apply_content_section_elements(mapping)
+        mapping.map_element "title",                to: :title
+        mapping.map_element "variant-title",        to: :variant_title
+        mapping.map_element "fmt-title",            to: :fmt_title
+        mapping.map_element "fmt-xref-label",       to: :fmt_xref_label
+
+        BlockXmlMapping.apply_block_mappings(mapping)
+
+        mapping.map_element "clause",               to: :subsection
+        mapping.map_element "fmt-annotation-start", to: :fmt_annotation_start
+        mapping.map_element "fmt-annotation-end",   to: :fmt_annotation_end
+      end
+    end
+  end
+end

data/lib/metanorma/standard_document/blocks/passthrough.rb

@@ -1,20 +1,3 @@
 # frozen_string_literal: true
 
-module Metanorma
-  module StandardDocument
-    module Blocks
-      # Wrapper around raw markup to be transferred into one or more nominated output formats
-      # during processing.
-      class Passthrough < Metanorma::StandardDocument::Blocks::StandardBlockNoNotes
-        attribute :formats, :string
-        attribute :content, :string
-
-        xml do
-          element "passthrough"
-          map_attribute "formats", to: :formats
-          map_content to: :content
-        end
-      end
-    end
-  end
-end
+Metanorma::StandardDocument::Blocks::Passthrough = Metanorma::Document::Components::Blocks::Passthrough