metanorma-document 0.2.1 → 0.2.3

data/lib/metanorma/html/iso_renderer.rb

@@ -8,22 +8,6 @@ module Metanorma
     # Extends StandardRenderer with ISO-specific cover page, boilerplate,
     # foreword, introduction, annex formatting, and ISO term entries.
     class IsoRenderer < StandardRenderer
-      class << self
-        def doc_types
-          @doc_types ||= []
-          if superclass <= IsoRenderer && superclass != IsoRenderer
-            superclass.doc_types + @doc_types
-          else
-            @doc_types.dup
-          end
-        end
-
-        def registers_doc_type(klass)
-          @doc_types ||= []
-          @doc_types << klass
-        end
-      end
-
       # --- Public hooks for flavor customization ---
 
       def flavor_publishers(_doc_id)
@@ -67,45 +51,20 @@ module Metanorma
         end
       end
 
-      def render(node, **)
-        case node
-        when Metanorma::IsoDocument::Root
-          render_document(node, **)
-        when Metanorma::IsoDocument::Sections::IsoPreface
-          render_preface(node, **)
-        when Metanorma::IsoDocument::Sections::IsoSections
-          render_sections(node, **)
-        when Metanorma::IsoDocument::Sections::IsoClauseSection
-          render_clause(node, **)
-        when Metanorma::IsoDocument::Sections::IsoAnnexSection
-          render_annex(node, **)
-        when Metanorma::IsoDocument::Sections::IsoTermsSection
-          render_terms_section(node, **)
-        when Metanorma::IsoDocument::Sections::IsoForewordSection
-          render_foreword(node, **)
-        when Metanorma::IsoDocument::Sections::IsoAbstractSection
-          render_abstract(node, **)
-        when Metanorma::IsoDocument::Terms::IsoTerm
-          render_term(node, **)
-        when Metanorma::IsoDocument::Terms::TermNote
-          render_term_note(node, **)
-        when Metanorma::IsoDocument::Terms::TermExample
-          render_term_example(node, **)
-        when Metanorma::IsoDocument::Boilerplate
-          render_boilerplate(node, **)
-        else
-          super
-        end
-      end
+      register_render Metanorma::IsoDocument::Root, :render_document
+      register_render Metanorma::IsoDocument::Sections::IsoPreface, :render_preface
+      register_render Metanorma::IsoDocument::Sections::IsoSections, :render_sections
+      register_render Metanorma::IsoDocument::Sections::IsoClauseSection, :render_clause
+      register_render Metanorma::IsoDocument::Sections::IsoAnnexSection, :render_annex
+      register_render Metanorma::IsoDocument::Sections::IsoTermsSection, :render_terms_section
+      register_render Metanorma::IsoDocument::Sections::IsoForewordSection, :render_foreword
+      register_render Metanorma::IsoDocument::Sections::IsoAbstractSection, :render_abstract
+      register_render Metanorma::IsoDocument::Terms::IsoTerm, :render_term
+      register_render Metanorma::IsoDocument::Terms::TermNote, :render_term_note
+      register_render Metanorma::IsoDocument::Terms::TermExample, :render_term_example
+      register_render Metanorma::IsoDocument::Boilerplate, :render_boilerplate
 
-      def render_inline_element(element)
-        case element
-        when Metanorma::IsoDocument::Terms::TermOrigin
-          render_term_origin(element)
-        else
-          super
-        end
-      end
+      register_inline_render Metanorma::IsoDocument::Terms::TermOrigin, :render_term_origin
 
       def render_term_origin(element)
         text = extract_text_value(element)
@@ -585,32 +544,6 @@ module Metanorma
         end
       end
 
-      def render_term_note(note)
-        attrs = element_attrs(id: safe_attr(note, :id), class: "note-block")
-        tag("div", attrs) do
-          label = extract_termnote_label(note)
-          @output << "<p><span class=\"term-note-label\">#{escape_html(label)}: </span>"
-          note.p&.each { |para| render_mixed_inline(para) }
-          @output << "</p>"
-          note.ul&.each { |ul| render_unordered_list(ul) }
-          note.ol&.each { |ol| render_ordered_list(ol) }
-          note.dl&.then { |dl| render_definition_list(dl) }
-        end
-      end
-
-      def render_term_example(example)
-        attrs = element_attrs(id: safe_attr(example, :id), class: "example")
-        tag("div", attrs) do
-          label = extract_block_label(example, "EXAMPLE")
-          @output << "<p><span class=\"example-label\">#{escape_html(label)}</span>&nbsp;"
-          example.p&.each { |para| render_mixed_inline(para) }
-          @output << "</p>"
-          example.ul&.each { |ul| render_unordered_list(ul) }
-          example.ol&.each { |ol| render_ordered_list(ol) }
-          example.dl&.then { |dl| render_definition_list(dl) }
-        end
-      end
-
       # --- Boilerplate rendering ---
 
       def render_boilerplate(boilerplate, **_opts)
@@ -685,45 +618,6 @@ module Metanorma
         @output << "</#{h}>"
       end
 
-      # Collect all renderable children from a section, sorted by displayorder.
-      # Uses element_order directly because each_mixed_content returns early
-      # when the model class doesn't declare mixed_content (mixed? is false).
-      def collect_ordered_children(section)
-        children = gather_element_order_children(section)
-
-        # Also gather typed attributes that may not appear in element_order
-        %i[terms definitions].each do |attr|
-          val = safe_attr(section, attr)
-          next if val.nil?
-
-          Array(val).each do |v|
-            children << v unless children.include?(v)
-          end
-        end
-
-        # Sort by displayorder (non-nil first, then nil at end)
-        children.compact!
-        children.sort_by do |node|
-          order = begin
-            node.displayorder
-          rescue StandardError
-            nil
-          end
-          order &&= order.to_i
-          order || Float::INFINITY
-        end
-      end
-
-      def render_ordered_content(section, level = 1)
-        children = collect_ordered_children(section)
-        children.each do |node|
-          next if node.is_a?(String)
-          next if is_title_element?(node, section)
-
-          render(node, level: level + 1)
-        end
-      end
-
       # Collect all document-level children (sections, normative refs, annexes,
       # bibliography) sorted by displayorder for correct document order.
       # Top-level paragraphs in sections (title paragraphs) are excluded —
@@ -731,87 +625,19 @@ module Metanorma
       def collect_document_children(doc)
         items = []
 
-        # Main sections children (clauses, terms, etc.)
         if doc.sections
-          section_children = gather_element_order_children(doc.sections)
-          # Title paragraphs are ParagraphBlock objects at the top level of
-          # sections. They are rendered by render_doc_title, so skip them here.
+          section_children = collect_ordered_children(doc.sections)
           section_children.reject! do |node|
             node.is_a?(Metanorma::Document::Components::Paragraphs::ParagraphBlock)
           end
           items.concat(section_children)
-          # Also add typed attributes that may not be in element_order
-          %i[terms definitions].each do |attr|
-            val = safe_attr(doc.sections, attr)
-            next if val.nil?
-
-            Array(val).each { |v| items << v unless items.include?(v) }
-          end
         end
 
-        # Normative references from bibliography (may have displayorder)
         doc.bibliography&.references&.each { |r| items << r }
-
-        # Annexes
         doc.annex&.each { |a| items << a }
 
-        # Non-normative bibliography (no displayorder = goes at end)
-        if doc.bibliography&.references
-          # Already included above; filter normative vs non-normative below
-        end
-
         items.compact!
-        items.sort_by do |node|
-          order = begin
-            node.displayorder
-          rescue StandardError
-            nil
-          end
-          order &&= order.to_i
-          order || Float::INFINITY
-        end
-      end
-
-      # Iterate element_order directly, bypassing each_mixed_content which
-      # requires mixed?/ordered? to be true (many section models aren't).
-      def gather_element_order_children(node)
-        children = []
-        return children unless node.is_a?(Lutaml::Model::Serializable)
-        return children unless node.element_order && !node.element_order.empty?
-
-        xml_mapping = node.class.mappings_for(:xml, node.lutaml_register)
-        return children unless xml_mapping
-
-        element_to_attr = {}
-        xml_mapping.mapping_elements_hash.each_value do |rule_or_array|
-          Array(rule_or_array).each do |rule|
-            element_to_attr[rule.name] = rule.to
-            element_to_attr[rule.name.to_s] = rule.to if rule.name.is_a?(Symbol)
-          end
-        end
-
-        indices = Hash.new(0)
-
-        node.element_order.each do |el|
-          if el.text?
-            children << el.text_content if el.text_content
-          elsif el.element?
-            attr_name = element_to_attr[el.name]
-            next unless attr_name
-
-            coll = node.send(attr_name)
-            obj = if coll.is_a?(Array)
-                    idx = indices[attr_name]
-                    indices[attr_name] += 1
-                    coll[idx]
-                  else
-                    coll
-                  end
-            children << obj if obj
-          end
-        end
-
-        children
+        sort_by_displayorder(items)
       end
 
       def publisher_logos_html(_doc)

data/lib/metanorma/html/itu_renderer.rb

@@ -4,7 +4,6 @@ module Metanorma
   module Html
     # ITU brand: #0e99d5 blue from logo
     class ItuRenderer < IsoRenderer
-      registers_doc_type Metanorma::ItuDocument::Root
 
       def flavor_publishers(_doc_id)
         ["ITU"]

data/lib/metanorma/html/ogc_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders OgcDocument components to HTML.
     # Extends IsoRenderer with OGC-specific branding (geospatial, OGC cyan-blue #00b1ff).
     class OgcRenderer < IsoRenderer
-      registers_doc_type Metanorma::OgcDocument::Root
 
       def flavor_publishers(_doc_id)
         ["OGC"]

data/lib/metanorma/html/oiml_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders OimlDocument (OIML) components to HTML.
     # Extends IsoRenderer with OIML branding.
     class OimlRenderer < IsoRenderer
-      registers_doc_type Metanorma::OimlDocument::Root
 
       def flavor_publishers(_doc_id)
         ["OIML"]

data/lib/metanorma/html/pdfa_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders PDF Association (PDFA) taste documents to HTML.
     # PDFA brand: #cf9c1d gold + #d03544 red + #4992b2 steel blue from logo
     class PdfaRenderer < IsoRenderer
-      registers_doc_type Metanorma::RiboseDocument::Root
 
       def flavor_publishers(_doc_id)
         ["PDF Association"]

data/lib/metanorma/html/ribose_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders RiboseDocument components to HTML.
     # Extends IsoRenderer with Ribose branding.
     class RiboseRenderer < IsoRenderer
-      registers_doc_type Metanorma::RiboseDocument::Root
 
       def flavor_publishers(_doc_id)
         ["Ribose"]

data/lib/metanorma/html/standard_renderer.rb

@@ -5,38 +5,19 @@ module Metanorma
     # Renders StandardDocument components to HTML.
     # Extends BaseRenderer with terms, bibliography, and standard sections.
     class StandardRenderer < BaseRenderer
-      def render(node, **)
-        case node
-        when Metanorma::StandardDocument::Root
-          render_standard_document(node, **)
-        when Metanorma::StandardDocument::Terms::Term
-          render_term(node, **)
-        when Metanorma::StandardDocument::Sections::TermsSection
-          render_terms_section(node, **)
-        when Metanorma::StandardDocument::Sections::StandardReferencesSection
-          render_references_section(node, **)
-        when Metanorma::StandardDocument::Sections::BibliographySection
-          render_bibliography(node, **)
-        when Metanorma::StandardDocument::Sections::ClauseSection
-          render_clause_section(node, **)
-        when Metanorma::StandardDocument::Sections::AnnexSection
-          render_annex_section(node, **)
-        when Metanorma::StandardDocument::Sections::StandardSection
-          render_standard_section(node, **)
-        when Metanorma::StandardDocument::Sections::Abstract
-          render_abstract_section(node, **)
-        when Metanorma::StandardDocument::Sections::Foreword
-          render_foreword_section(node, **)
-        when Metanorma::StandardDocument::Sections::Introduction
-          render_introduction_section(node, **)
-        when Metanorma::StandardDocument::Sections::FloatingTitle
-          render_floating_title(node, **)
-        when Metanorma::StandardDocument::Blocks::AmendBlock
-          render_amend_block(node, **)
-        else
-          super
-        end
-      end
+      register_render Metanorma::StandardDocument::Root, :render_standard_document
+      register_render Metanorma::StandardDocument::Terms::Term, :render_term
+      register_render Metanorma::StandardDocument::Sections::TermsSection, :render_terms_section
+      register_render Metanorma::StandardDocument::Sections::StandardReferencesSection, :render_references_section
+      register_render Metanorma::StandardDocument::Sections::BibliographySection, :render_bibliography
+      register_render Metanorma::StandardDocument::Sections::ClauseSection, :render_clause_section
+      register_render Metanorma::StandardDocument::Sections::AnnexSection, :render_annex_section
+      register_render Metanorma::StandardDocument::Sections::StandardSection, :render_standard_section
+      register_render Metanorma::StandardDocument::Sections::Abstract, :render_abstract_section
+      register_render Metanorma::StandardDocument::Sections::Foreword, :render_foreword_section
+      register_render Metanorma::StandardDocument::Sections::Introduction, :render_introduction_section
+      register_render Metanorma::StandardDocument::Sections::FloatingTitle, :render_floating_title
+      register_render Metanorma::StandardDocument::Blocks::AmendBlock, :render_amend_block
 
       private
 
@@ -138,63 +119,46 @@ module Metanorma
 
       # --- Section rendering ---
 
-      def render_clause_section(clause, level: 1, **_opts)
-        attrs = element_attrs(id: safe_attr(clause, :id))
+      def render_section(section, level: 1, title_class: nil, with_subsections: false, with_terms: false)
+        attrs = element_attrs(id: safe_attr(section, :id))
         tag("div", attrs) do
-          render_standard_title(clause, level)
-          render_standard_section_blocks(clause, level)
-          render_subsections(clause, level)
+          if title_class
+            render_standard_title(section, level, default_class: title_class)
+          else
+            render_standard_title(section, level)
+          end
+          render_standard_section_blocks(section, level)
+          render_subsections(section, level) if with_subsections
+          section.terms&.each { |term| render_term(term) } if with_terms
         end
       end
 
-      def render_annex_section(annex, level: 1, **_opts)
-        attrs = element_attrs(id: safe_attr(annex, :id))
-        tag("div", attrs) do
-          render_standard_title(annex, level)
-          render_standard_section_blocks(annex, level)
-          render_subsections(annex, level)
-        end
+      def render_clause_section(section, level: 1, **)
+        render_section(section, level: level, with_subsections: true)
       end
 
-      def render_standard_section(section, level: 1, **_opts)
-        attrs = element_attrs(id: safe_attr(section, :id))
-        tag("div", attrs) do
-          render_standard_title(section, level)
-          render_standard_section_blocks(section, level)
-        end
+      def render_annex_section(section, level: 1, **)
+        render_section(section, level: level, with_subsections: true)
       end
 
-      def render_terms_section(terms, level: 1, **_opts)
-        attrs = element_attrs(id: safe_attr(terms, :id))
-        tag("div", attrs) do
-          render_standard_title(terms, level)
-          render_standard_section_blocks(terms, level)
-          terms.terms&.each { |term| render_term(term) }
-        end
+      def render_standard_section(section, level: 1, **)
+        render_section(section, level: level)
       end
 
-      def render_abstract_section(section, level: 1, **_opts)
-        attrs = element_attrs(id: safe_attr(section, :id))
-        tag("div", attrs) do
-          render_standard_title(section, level, default_class: "intro-title")
-          render_standard_section_blocks(section, level)
-        end
+      def render_terms_section(section, level: 1, **)
+        render_section(section, level: level, with_terms: true)
       end
 
-      def render_foreword_section(section, level: 1, **_opts)
-        attrs = element_attrs(id: safe_attr(section, :id))
-        tag("div", attrs) do
-          render_standard_title(section, level, default_class: "foreword-title")
-          render_standard_section_blocks(section, level)
-        end
+      def render_abstract_section(section, level: 1, **)
+        render_section(section, level: level, title_class: "intro-title")
       end
 
-      def render_introduction_section(section, level: 1, **_opts)
-        attrs = element_attrs(id: safe_attr(section, :id))
-        tag("div", attrs) do
-          render_standard_title(section, level, default_class: "intro-title")
-          render_standard_section_blocks(section, level)
-        end
+      def render_foreword_section(section, level: 1, **)
+        render_section(section, level: level, title_class: "foreword-title")
+      end
+
+      def render_introduction_section(section, level: 1, **)
+        render_section(section, level: level, title_class: "intro-title")
       end
 
       def render_floating_title(title_node, **_opts)
@@ -285,11 +249,7 @@ module Metanorma
         tag("div", attrs) do
           label = extract_termnote_label(note)
           @output << "<p><span class=\"term-note-label\">#{escape_html(label)}: </span>"
-          if note.p && !note.p.empty?
-            note.p.each do |para|
-              render_mixed_inline(para)
-            end
-          end
+          note.p&.each { |para| render_mixed_inline(para) }
           @output << "</p>"
           note.ul&.each { |ul| render_unordered_list(ul) }
           note.ol&.each { |ol| render_ordered_list(ol) }
@@ -302,11 +262,7 @@ module Metanorma
         tag("div", attrs) do
           label = extract_block_label(example, "EXAMPLE")
           @output << "<p><span class=\"example-label\">#{escape_html(label)}</span>&nbsp;"
-          if example.p && !example.p.empty?
-            example.p.each do |para|
-              render_mixed_inline(para)
-            end
-          end
+          example.p&.each { |para| render_mixed_inline(para) }
           @output << "</p>"
           example.ul&.each { |ul| render_unordered_list(ul) }
           example.ol&.each { |ol| render_ordered_list(ol) }
@@ -433,7 +389,7 @@ module Metanorma
           end
           if primary
             id_val = extract_text_value(primary)
-            @output << "<span class=\"std-doc-number\">#{escape_html(id_val)}</span>" unless id_val.to_s.empty?
+            @output << "<span class=\"ref-doc-number\">#{escape_html(id_val)}</span>" unless id_val.to_s.empty?
           end
         end
 
@@ -442,7 +398,7 @@ module Metanorma
             date_on = date.is_a?(Metanorma::Document::Relaton::BibliographicDate) ? date.on : nil
             date_val = extract_text_value(date_on || safe_attr(date, :text))
             if date_val && !date_val.to_s.empty?
-              @output << ":<span class=\"std-year\">#{escape_html(date_val.to_s)}</span>"
+              @output << ":<span class=\"ref-year\">#{escape_html(date_val.to_s)}</span>"
             end
           end
         end

data/lib/metanorma/html.rb

@@ -8,7 +8,6 @@ module Metanorma
     autoload :Generator, "metanorma/html/generator"
     autoload :Theme, "metanorma/html/theme"
     autoload :AssetPipeline, "metanorma/html/asset_pipeline"
-    autoload :ComponentRegistry, "metanorma/html/component_registry"
     autoload :Component, "metanorma/html/component"
     autoload :Drops, "metanorma/html/drops"
     autoload :StandardRenderer, "metanorma/html/standard_renderer"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-document
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.3
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-05 00:00:00.000000000 Z
+date: 2026-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -481,7 +481,6 @@ files:
 - lib/metanorma/html/component/footnote_collector.rb
 - lib/metanorma/html/component/index_section.rb
 - lib/metanorma/html/component/index_term_collector.rb
-- lib/metanorma/html/component_registry.rb
 - lib/metanorma/html/drops.rb
 - lib/metanorma/html/drops/admonition_drop.rb
 - lib/metanorma/html/drops/block_element_drop.rb

data/lib/metanorma/html/component_registry.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Metanorma
-  module Html
-    class ComponentRegistry
-      def initialize
-        @map = {}
-      end
-
-      def register(model_class, component_class)
-        @map[model_class] = component_class
-      end
-
-      def lookup(model_class)
-        @map[model_class] ||
-          model_class.ancestors
-            .drop(1)
-            .filter_map { |a| @map[a] }
-            .first ||
-          nil
-      end
-
-      def component_for(renderer, model_class)
-        component_class = lookup(model_class)
-        component_class&.new(renderer)
-      end
-
-      def register_all(component_module)
-        component_module.constants.each do |const|
-          klass = component_module.const_get(const)
-          next unless klass.is_a?(Class) && klass < Component::Base
-          klass.register_in(self)
-        end
-      end
-    end
-  end
-end