metanorma-document 0.3.0 → 0.4.0

data/lib/metanorma/standard_document/metadata/unitsml/time.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module StandardDocument
+    module Metadata
+      module Unitsml
+        class Time < Lutaml::Model::Serializable
+          include BaseQuantityAttributes
+
+          xml do
+            element "Time"
+            namespace Unitsml::Namespace
+            BaseQuantityXmlMapping.apply(self)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standard_document/metadata/unitsml/unit.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module StandardDocument
+    module Metadata
+      module Unitsml
+        class Unit < Lutaml::Model::Serializable
+          attribute :dimension_url, :string
+          attribute :id, :string
+          attribute :semx_id, :string
+
+          attribute :unit_system, UnitSystem
+          attribute :unit_name, UnitName
+          attribute :unit_symbol, UnitSymbol, collection: true
+          attribute :root_units, RootUnits
+
+          xml do
+            element "Unit"
+            namespace Unitsml::Namespace
+            map_attribute "dimensionURL", to: :dimension_url
+            map_attribute "id", to: :id
+            map_attribute "semx-id", to: :semx_id
+            map_element "UnitSystem", to: :unit_system
+            map_element "UnitName", to: :unit_name
+            map_element "UnitSymbol", to: :unit_symbol
+            map_element "RootUnits", to: :root_units
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standard_document/metadata/unitsml/unit_name.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module StandardDocument
+    module Metadata
+      module Unitsml
+        class UnitName < Lutaml::Model::Serializable
+          attribute :lang, :string
+          attribute :text, :string
+
+          xml do
+            element "UnitName"
+            namespace Unitsml::Namespace
+            map_attribute "lang", to: :lang
+            map_content to: :text
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standard_document/metadata/unitsml/unit_set.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module StandardDocument
+    module Metadata
+      module Unitsml
+        class UnitSet < Lutaml::Model::Serializable
+          attribute :unit, Unit, collection: true
+
+          xml do
+            element "UnitSet"
+            namespace Unitsml::Namespace
+            map_element "Unit", to: :unit
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standard_document/metadata/unitsml/unit_symbol.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "mml"
+require "mml/v3"
+
+module Metanorma
+  module StandardDocument
+    module Metadata
+      module Unitsml
+        # Unit symbol. type="HTML" symbols can carry inline markup
+        # (e.g. "nmol mol <sup>−1</sup>"), type="MathMl" symbols carry a
+        # MathML <math> child, so this is a mixed-content model.
+        class UnitSymbol < Lutaml::Model::Serializable
+          attribute :type, :string
+          attribute :text, :string, collection: true
+          attribute :sup, Metanorma::Document::Components::Inline::SupElement,
+                    collection: true
+          attribute :sub, Metanorma::Document::Components::Inline::SubElement,
+                    collection: true
+          attribute :math, "Mml::V3::Math", collection: true
+
+          xml do
+            element "UnitSymbol"
+            namespace Unitsml::Namespace
+            mixed_content
+            map_attribute "type", to: :type
+            map_content to: :text
+            map_element "sup", to: :sup
+            map_element "sub", to: :sub
+            map_element "math", to: :math
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standard_document/metadata/unitsml/unit_system.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module StandardDocument
+    module Metadata
+      module Unitsml
+        class UnitSystem < Lutaml::Model::Serializable
+          attribute :name, :string
+          attribute :type, :string
+          attribute :lang, :string
+
+          xml do
+            element "UnitSystem"
+            namespace Unitsml::Namespace
+            map_attribute "name", to: :name
+            map_attribute "type", to: :type
+            map_attribute "lang", to: :lang
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standard_document/metadata/unitsml/unitsml_root.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module StandardDocument
+    module Metadata
+      module Unitsml
+        # Root <UnitsML> element embedded in metanorma-extension.
+        # Child sets serialize in schema order:
+        # UnitSet, QuantitySet, DimensionSet, PrefixSet.
+        class UnitsmlRoot < Lutaml::Model::Serializable
+          attribute :unit_set, UnitSet
+          attribute :quantity_set, QuantitySet
+          attribute :dimension_set, DimensionSet
+          attribute :prefix_set, PrefixSet
+
+          xml do
+            element "UnitsML"
+            namespace Unitsml::Namespace
+            map_element "UnitSet", to: :unit_set
+            map_element "QuantitySet", to: :quantity_set
+            map_element "DimensionSet", to: :dimension_set
+            map_element "PrefixSet", to: :prefix_set
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standard_document/metadata/unitsml.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module StandardDocument
+    module Metadata
+      module Unitsml
+        autoload :AmountOfSubstance, "#{__dir__}/unitsml/amount_of_substance"
+        autoload :BaseQuantityAttributes, "#{__dir__}/unitsml/base_quantity"
+        autoload :BaseQuantityXmlMapping, "#{__dir__}/unitsml/base_quantity"
+        autoload :Dimension, "#{__dir__}/unitsml/dimension"
+        autoload :DimensionSet, "#{__dir__}/unitsml/dimension_set"
+        autoload :ElectricCurrent, "#{__dir__}/unitsml/electric_current"
+        autoload :EnumeratedRootUnit, "#{__dir__}/unitsml/enumerated_root_unit"
+        autoload :Length, "#{__dir__}/unitsml/length"
+        autoload :LuminousIntensity, "#{__dir__}/unitsml/luminous_intensity"
+        autoload :Mass, "#{__dir__}/unitsml/mass"
+        autoload :Namespace, "#{__dir__}/unitsml/namespace"
+        autoload :PlaneAngle, "#{__dir__}/unitsml/plane_angle"
+        autoload :Prefix, "#{__dir__}/unitsml/prefix"
+        autoload :PrefixName, "#{__dir__}/unitsml/prefix_name"
+        autoload :PrefixSet, "#{__dir__}/unitsml/prefix_set"
+        autoload :PrefixSymbol, "#{__dir__}/unitsml/prefix_symbol"
+        autoload :Quantity, "#{__dir__}/unitsml/quantity"
+        autoload :QuantityName, "#{__dir__}/unitsml/quantity_name"
+        autoload :QuantitySet, "#{__dir__}/unitsml/quantity_set"
+        autoload :RootUnits, "#{__dir__}/unitsml/root_units"
+        autoload :ThermodynamicTemperature,
+                 "#{__dir__}/unitsml/thermodynamic_temperature"
+        autoload :Time, "#{__dir__}/unitsml/time"
+        autoload :Unit, "#{__dir__}/unitsml/unit"
+        autoload :UnitName, "#{__dir__}/unitsml/unit_name"
+        autoload :UnitSet, "#{__dir__}/unitsml/unit_set"
+        autoload :UnitSymbol, "#{__dir__}/unitsml/unit_symbol"
+        autoload :UnitSystem, "#{__dir__}/unitsml/unit_system"
+        autoload :UnitsmlRoot, "#{__dir__}/unitsml/unitsml_root"
+      end
+    end
+  end
+end

data/lib/metanorma/standard_document/metadata.rb

@@ -7,6 +7,9 @@ module Metanorma
       autoload :IcsType, "#{__dir__}/metadata/ics_type"
       autoload :MetanormaExtension,
                "#{__dir__}/metadata/metanorma_extension"
+      autoload :PresentationMetadata,
+               "#{__dir__}/metadata/presentation_metadata"
+      autoload :SemanticMetadata, "#{__dir__}/metadata/semantic_metadata"
       autoload :StandardBibData, "#{__dir__}/metadata/standard_bib_data"
       autoload :StandardBibDataExtensionType,
                "#{__dir__}/metadata/standard_bib_data_extension_type"
@@ -14,6 +17,7 @@ module Metanorma
                "#{__dir__}/metadata/structured_identifier_type"
       autoload :TechnicalCommitteeType,
                "#{__dir__}/metadata/technical_committee_type"
+      autoload :Unitsml, "#{__dir__}/metadata/unitsml"
     end
   end
 end

data/lib/metanorma/standard_document/sections/misc_container.rb

@@ -3,13 +3,15 @@
 module Metanorma
   module StandardDocument
     module Sections
-      # Extension point for extraneous elements that need to be added to standards document
-      # from other schemas, e.g. UnitsML.
+      # Extension point for extraneous elements that need to be added to
+      # standards documents from other schemas.
       #
-      # Content is stored as raw XML text since the children come from external
-      # vocabularies not defined in the metanorma schema.
+      # Observed payload: legacy-serialization <presentation-metadata>
+      # name/value pairs (e.g. metanorma/demo-ab import_from_metanorma).
       class MiscContainer < Lutaml::Model::Serializable
-        attribute :content, :string
+        attribute :presentation_metadata,
+                  Metanorma::StandardDocument::Metadata::PresentationMetadata,
+                  collection: true
 
         attribute :semx_id, :string
         attribute :original_id, :string
@@ -17,7 +19,7 @@ module Metanorma
 
         xml do
           element "misc-container"
-          map_content to: :content
+          map_element "presentation-metadata", to: :presentation_metadata
 
           map_attribute "semx-id", to: :semx_id
           map_attribute "original-id", to: :original_id

data/lib/metanorma/standard_document/sections/sections.rb

@@ -27,11 +27,18 @@ module Metanorma
         attribute :semx_id, :string
         attribute :displayorder, :integer
 
+        # Loose paragraphs directly under <sections> (e.g. the ITU
+        # zzSTDTitle1 title paragraph at the start of sections).
+        attribute :p,
+                  Metanorma::Document::Components::Paragraphs::ParagraphBlock,
+                  collection: true
+
         xml do
           element "sections"
           ordered
 
           Metanorma::StandardDocument::SectionXmlMapping.apply_sections_elements(self)
+          map_element "p", to: :p
           Metanorma::StandardDocument::SectionXmlMapping.apply_sections_attributes(self)
         end
       end

data/lib/metanorma/un_document/blocks/un_admonition_block.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module UnDocument
+    module Blocks
+      # Admonition block of a UN document.
+      # Corresponds to un.rng:
+      #   AdmonitionType = danger | caution | warning | important |
+      #                    "safety precautions"
+      #   AdmonitionBody = tname?,
+      #     ( paragraph-with-footnote | table | formula | ol | ul | dl |
+      #       figure | quote | sourcecode | example | review )+,
+      #     note*
+      # The UN grammar widens the isodoc admonition body from paragraphs only
+      # to most block types, with notes permitted after the body.
+      # `uri` keeps the base model's element mapping (the current basicdoc
+      # grammar declares it an attribute — a base-level divergence affecting
+      # all flavors, left as-is here).
+      class UnAdmonitionBlock < Metanorma::Document::Components::MultiParagraph::AdmonitionBlock
+        # UN restricts AdmonitionType to five values.
+        attribute :type, :string,
+                  values: ["danger", "caution", "warning", "important",
+                           "safety precautions"]
+
+        attribute :tables,
+                  Metanorma::Document::Components::Tables::TableBlock,
+                  collection: true
+        attribute :formulas,
+                  Metanorma::Document::Components::AncillaryBlocks::FormulaBlock,
+                  collection: true
+        attribute :ordered_lists,
+                  Metanorma::Document::Components::Lists::OrderedList,
+                  collection: true
+        attribute :unordered_lists,
+                  Metanorma::Document::Components::Lists::UnorderedList,
+                  collection: true
+        attribute :definition_lists,
+                  Metanorma::Document::Components::Lists::DefinitionList,
+                  collection: true
+        attribute :figures,
+                  Metanorma::Document::Components::AncillaryBlocks::FigureBlock,
+                  collection: true
+        attribute :quote_blocks,
+                  Metanorma::Document::Components::MultiParagraph::QuoteBlock,
+                  collection: true
+        attribute :sourcecode_blocks,
+                  Metanorma::Document::Components::AncillaryBlocks::SourcecodeBlock,
+                  collection: true
+        attribute :examples,
+                  Metanorma::Document::Components::AncillaryBlocks::ExampleBlock,
+                  collection: true
+        attribute :reviews,
+                  Metanorma::Document::Components::MultiParagraph::ReviewBlock,
+                  collection: true
+        attribute :notes,
+                  Metanorma::Document::Components::Blocks::NoteBlock,
+                  collection: true
+
+        xml do
+          element "admonition"
+          ordered
+
+          map_attribute "id",         to: :id
+          map_attribute "type",       to: :type
+          map_attribute "class",      to: :block_class
+          map_attribute "unnumbered", to: :unnumbered
+
+          map_element "name",         to: :name
+          map_element "fmt-name",     to: :fmt_name
+          map_element "p",            to: :paragraphs
+          map_element "table",        to: :tables
+          map_element "formula",      to: :formulas
+          map_element "ol",           to: :ordered_lists
+          map_element "ul",           to: :unordered_lists
+          map_element "dl",           to: :definition_lists
+          map_element "figure",       to: :figures
+          map_element "quote",        to: :quote_blocks
+          map_element "sourcecode",   to: :sourcecode_blocks
+          map_element "example",      to: :examples
+          map_element "review",       to: :reviews
+          map_element "note",         to: :notes
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/un_document/blocks.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module UnDocument
+    module Blocks
+      autoload :UnAdmonitionBlock, "#{__dir__}/blocks/un_admonition_block"
+    end
+  end
+end

data/lib/metanorma/un_document/root.rb

@@ -18,6 +18,14 @@ module Metanorma
                 Metanorma::StandardDocument::Sections::AnnexSection,
                 collection: true
 
+      # Validates the parsed document against the UN grammar restrictions
+      # the model does not enforce structurally (currently: the UN
+      # TextElement inline subset). Walks the model graph and returns an
+      # array of error strings; empty when the document is valid.
+      def grammar_errors
+        Metanorma::UnDocument::UnTextElement.validate(self)
+      end
+
       xml do
         element "metanorma"
         namespace Metanorma::StandardDocument::Namespace

data/lib/metanorma/un_document/sections/un_abstract_section.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module UnDocument
+    module Sections
+      # Abstract of a UN document.
+      # Corresponds to un.rng:
+      #   abstract = element abstract { Basic-Section }
+      #   Basic-Section = Basic-Section-Attributes, section-title?, BasicBlock+
+      # Unlike the isodoc default (Content-Section), a UN abstract contains
+      # no subsections, so no `clause` mapping is declared. Composed from the
+      # shared mixins rather than inheriting ContentSection, because
+      # lutaml-model deep-duplicates a parent's XML mappings into subclasses
+      # (inheriting would keep the Content-Section `clause` mapping).
+      class UnAbstractSection < Lutaml::Model::Serializable
+        include Metanorma::StandardDocument::BlockAttributes
+        include Metanorma::StandardDocument::PresentationAttributes
+
+        attribute :id, :string
+        attribute :obligation, :string
+        attribute :title,
+                  Metanorma::Document::Components::Inline::TitleWithAnnotationElement
+
+        xml do
+          element "abstract"
+          ordered
+
+          map_attribute "id",           to: :id
+          map_attribute "obligation",   to: :obligation
+          map_attribute "anchor",       to: :anchor
+          map_attribute "semx-id",      to: :semx_id
+          map_attribute "autonum",      to: :autonum
+          map_attribute "displayorder", to: :displayorder
+
+          map_element "title",                to: :title
+          map_element "variant-title",        to: :variant_title
+          map_element "fmt-title",            to: :fmt_title
+          map_element "fmt-xref-label",       to: :fmt_xref_label
+
+          Metanorma::StandardDocument::BlockXmlMapping.apply_block_mappings(self)
+
+          map_element "fmt-annotation-start", to: :fmt_annotation_start
+          map_element "fmt-annotation-end",   to: :fmt_annotation_end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/un_document/sections/un_preface.rb

@@ -4,9 +4,26 @@ module Metanorma
   module UnDocument
     module Sections
       # UN preface with only abstract, foreword, introduction.
-      # Corresponds to un.rnc:
+      # Corresponds to un.rng:
       #   preface = element preface { abstract?, foreword?, introduction? }
-      class UnPreface < Metanorma::StandardDocument::Sections::Preface
+      #
+      # This class deliberately does NOT inherit StandardDocument::Preface:
+      # lutaml-model deep-duplicates a parent's XML mappings into subclasses,
+      # so inheriting would keep the isodoc-level acknowledgements,
+      # executivesummary and clause mappings that the UN grammar forbids.
+      # Attributes are composed directly instead.
+      #
+      # The UN abstract is a Basic-Section (UnAbstractSection); foreword and
+      # introduction keep the isodoc Content-Section model.
+      class UnPreface < Lutaml::Model::Serializable
+        attribute :abstract, UnAbstractSection
+        attribute :foreword, Metanorma::StandardDocument::Sections::ContentSection
+        attribute :introduction, Metanorma::StandardDocument::Sections::ContentSection
+
+        # Presentation-specific attributes
+        attribute :semx_id, :string
+        attribute :displayorder, :integer
+
         xml do
           element "preface"
           ordered

data/lib/metanorma/un_document/sections.rb

@@ -3,6 +3,7 @@
 module Metanorma
   module UnDocument
     module Sections
+      autoload :UnAbstractSection, "#{__dir__}/sections/un_abstract_section"
       autoload :UnPreface, "#{__dir__}/sections/un_preface"
       autoload :UnSections, "#{__dir__}/sections/un_sections"
     end

data/lib/metanorma/un_document/un_text_element.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module UnDocument
+    # UN TextElement restriction, per the current UN grammar
+    # (metanorma-un, lib/metanorma/un/un.rng v1.2.1):
+    #
+    #   TextElement = text | em | eref | erefstack | strong | stem | sub |
+    #                 sup | tt | strike | smallcap | xref | br | hyperlink |
+    #                 bookmark
+    #
+    # UN allows only a strict subset of the isodoc inline vocabulary.
+    # Enforcing this structurally would require a UN-specific variant of every
+    # block type carrying inline content; instead this module validates the
+    # parsed model graph, flagging instances of excluded inline element
+    # classes found in inline content.
+    #
+    # Grammar-inline productions with no model class (date_inline) cannot be
+    # flagged here; the parser drops them before validation can see them.
+    module UnTextElement
+      # Inline element names (grammar names) permitted in UN inline content.
+      # `hyperlink` is the grammar production for the `<link>` element.
+      ALLOWED_ELEMENTS = %w[
+        em eref erefstack strong stem sub sup tt strike smallcap
+        xref br link bookmark
+      ].freeze
+
+      # Model classes of the isodoc TextElement productions the UN grammar
+      # excludes, mapped to their grammar (XML element) names.
+      EXCLUDED_ELEMENTS = {
+        Metanorma::Document::Components::TextElements::UnderlineElement => "underline",
+        Metanorma::Document::Components::TextElements::KeywordElement => "keyword",
+        Metanorma::Document::Components::TextElements::RubyElement => "ruby",
+        Metanorma::Document::Components::EmptyElements::HorizontalRuleElement => "hr",
+        Metanorma::Document::Components::EmptyElements::PageBreakElement => "pagebreak",
+        Metanorma::Document::Components::IdElements::Image => "image",
+        Metanorma::Document::Components::EmptyElements::IndexElement => "index",
+        Metanorma::Document::Components::ReferenceElements::IndexXrefElement => "index-xref",
+        Metanorma::Document::Components::Inline::ConceptElement => "concept",
+        Metanorma::Document::Elements::Add => "add",
+        Metanorma::Document::Elements::Del => "del",
+        Metanorma::Document::Components::Inline::SpanElement => "span",
+      }.freeze
+
+      # Model classes whose content model is inline text; an excluded instance
+      # under one of these is an inline use. Block-level occurrences (e.g.
+      # Image under FigureBlock, PageBreakElement under ClauseSection) are
+      # legal. ParagraphWithFootnote inherits from ParagraphBlock.
+      INLINE_CONTAINERS = [
+        Metanorma::Document::Components::Paragraphs::ParagraphBlock,
+        Metanorma::Document::Components::Inline::TitleWithAnnotationElement,
+        Metanorma::Document::Components::Inline::VariantTitleElement,
+        Metanorma::Document::Components::TextElements::TextElement,
+        Metanorma::Document::Components::Lists::DtElement,
+        Metanorma::Document::Components::Tables::TableCell,
+      ].freeze
+
+      # fmt-* classes wrap presentation-rendered copies of content, where
+      # `<span>` is rendering furniture rather than semantic inline markup.
+      FURNITURE_CLASS_PATTERN = /(^|::)Fmt/
+
+      # Returns an array of human-readable error strings for every excluded
+      # inline element instance in the given model tree; empty when valid.
+      def self.validate(model)
+        errors = []
+        walk(model, false, errors, {}.compare_by_identity)
+        errors
+      end
+
+      def self.walk(node, inline, errors, visited)
+        return unless node.is_a?(Lutaml::Model::Serializable)
+        return if visited[node]
+
+        visited[node] = true
+
+        furniture = furniture?(node)
+        excluded = furniture ? nil : excluded_name(node)
+        if inline && excluded
+          errors << "UN grammar forbids <#{excluded}> in inline " \
+                    "content (#{node.class.name})"
+        end
+
+        child_inline = furniture ? false : inline || inline_container?(node)
+        each_child(node) { |child| walk(child, child_inline, errors, visited) }
+      end
+
+      # Iterates the model-valued children of a node. Attribute values are
+      # read via instance_variable_get, mirroring lutaml-model's own
+      # attribute access (Serialize#validate_attribute!) — the project's
+      # invariant specs forbid dynamic dispatch methods in model code.
+      def self.each_child(node)
+        node.class.attributes.each_key do |name|
+          value = node.instance_variable_get(:"@#{name}")
+          if value.is_a?(Enumerable) && !value.is_a?(String)
+            value.each { |item| yield item if item.is_a?(Lutaml::Model::Serializable) }
+          elsif value.is_a?(Lutaml::Model::Serializable)
+            yield value
+          end
+        end
+      end
+
+      def self.excluded_name(node)
+        pair = EXCLUDED_ELEMENTS.find { |klass, _| node.is_a?(klass) }
+        pair&.last
+      end
+
+      def self.inline_container?(node)
+        INLINE_CONTAINERS.any? { |klass| node.is_a?(klass) }
+      end
+
+      def self.furniture?(node)
+        FURNITURE_CLASS_PATTERN.match?(node.class.name)
+      end
+    end
+  end
+end

data/lib/metanorma/un_document.rb

@@ -2,9 +2,11 @@
 
 module Metanorma
   module UnDocument
+    autoload :Blocks, "metanorma/un_document/blocks"
     autoload :Metadata, "metanorma/un_document/metadata"
     autoload :Root, "metanorma/un_document/root"
     autoload :Sections, "metanorma/un_document/sections"
+    autoload :UnTextElement, "metanorma/un_document/un_text_element"
   end
 end
 

data/script/benchmark_render.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Benchmark: parse + HTML-render a presentation XML fixture.
+#
+# Usage:
+#   bundle install          # benchmark-ips is a dev dependency
+#   bundle exec ruby script/benchmark_render.rb [fixture.xml]
+
+require "benchmark/ips"
+require_relative "../lib/metanorma/document"
+require_relative "../lib/metanorma/html"
+
+fixture = ARGV[0] ||
+  File.expand_path("../spec/fixtures/iso/is/document-en.presentation.xml",
+                   __dir__)
+xml = File.read(fixture)
+puts "Fixture: #{fixture} (#{(xml.size / 1024.0).round(1)} KB)"
+
+doc = Metanorma::IsoDocument::Root.from_xml(xml)
+html = Metanorma::Html::Generator.generate(doc)
+puts "Sanity: rendered #{html.size} bytes of HTML"
+
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 1)
+
+  x.report("parse") do
+    Metanorma::IsoDocument::Root.from_xml(xml)
+  end
+
+  x.report("render") do
+    Metanorma::Html::Generator.generate(doc)
+  end
+
+  x.compare!
+end

data/tasks/roundtrip_samples.rake

@@ -49,7 +49,7 @@ module RoundtripSamples
     "ogc"     => Metanorma::OgcDocument::Root,
     "ribose"  => Metanorma::RiboseDocument::Root,
     "ietf"    => Metanorma::IetfDocument::Root,
-    "csa"     => nil,
+    "csa"     => Metanorma::CsaDocument::Root,
     "un"      => nil,
   }.freeze