metanorma-document 0.2.12 → 0.3.0

data/lib/metanorma/html/generator.rb

@@ -3,18 +3,22 @@
 module Metanorma
   module Html
     class Generator
-      @renderers = []
       @tastes = []
       @setup = false
 
       class << self
-        def register(model_class, renderer_class)
-          @renderers << [model_class, renderer_class]
+        # Returns the full FlavorRegistry built from setup!. Read-only
+        # access for BaseRenderer, PubidRenderer, and any consumer that
+        # needs flavor identity.
+        def flavors
+          setup! unless @setup
+          @flavors
         end
 
-        # Register a taste: same document model, different renderer based on publisher.
-        # When the document's first author publisher abbreviation matches,
-        # the taste renderer takes precedence over the model-based renderer.
+        # Register a taste: same document model, different renderer based
+        # on publisher. When the document's first author publisher
+        # abbreviation matches, the taste renderer takes precedence over
+        # the model-based renderer.
         def register_taste(model_class, publisher_abbrev, renderer_class)
           @tastes << [model_class, publisher_abbrev, renderer_class]
         end
@@ -27,15 +31,11 @@ module Metanorma
         def renderer_for(document)
           setup! unless @setup
 
-          # Check tastes first (publisher-based dispatch)
           taste_renderer = find_taste(document)
           return taste_renderer if taste_renderer
 
-          # Fall back to model-based dispatch (most specific last)
-          @renderers.reverse_each do |model_class, renderer_class|
-            return renderer_class if document.is_a?(model_class)
-          end
-          BaseRenderer
+          flavor = @flavors.find_for(document.class)
+          flavor&.renderer_class || BaseRenderer
         end
 
         private
@@ -79,6 +79,7 @@ module Metanorma
           return if @setup
 
           @setup = true
+          @flavors = build_flavor_registry
 
           # Trigger autoloads by referencing constants
           BaseRenderer
@@ -97,27 +98,103 @@ module Metanorma
           PdfaRenderer
           RiboseRenderer
 
-          # Register renderers (most general first, most specific last)
-          register Metanorma::Document::Root,           BaseRenderer
-          register Metanorma::StandardDocument::Root,   StandardRenderer
-          register Metanorma::IsoDocument::Root,        IsoRenderer
-          register Metanorma::BipmDocument::Root,       BipmRenderer
-          register Metanorma::CcDocument::Root,         CcRenderer
-          register Metanorma::IecDocument::Root,        IecRenderer
-          register Metanorma::IeeeDocument::Root,       IeeeRenderer
-          register Metanorma::IetfDocument::Root,       IetfRenderer
-          register Metanorma::IhoDocument::Root,        IhoRenderer
-          register Metanorma::ItuDocument::Root,        ItuRenderer
-          register Metanorma::OgcDocument::Root,        OgcRenderer
-          register Metanorma::OimlDocument::Root,       OimlRenderer
-          register Metanorma::RiboseDocument::Root,     RiboseRenderer
-
           # Register tastes (publisher-based dispatch within same model)
-          register_taste Metanorma::IsoDocument::Root,    "ICC",
-                         IccRenderer
+          register_taste Metanorma::IsoDocument::Root, "ICC", IccRenderer
           register_taste Metanorma::RiboseDocument::Root, "PDF Association",
                          PdfaRenderer
         end
+
+        # Single source of truth for flavor identity. Each Flavor ties
+        # together the model class, the renderer, the symbolic name, and
+        # (if applicable) the Pubid module. Adding a new flavor = one
+        # entry here.
+        def build_flavor_registry
+          FlavorRegistry.new.tap do |registry|
+            registry.register(Flavor.new(
+                                name: nil,
+                                model_class: Metanorma::Document::Root,
+                                renderer_class: BaseRenderer,
+                              ))
+            registry.register(Flavor.new(
+                                name: nil,
+                                model_class: Metanorma::StandardDocument::Root,
+                                renderer_class: StandardRenderer,
+                              ))
+            registry.register(Flavor.new(
+                                name: :iso,
+                                model_class: Metanorma::IsoDocument::Root,
+                                renderer_class: IsoRenderer,
+                                pubid_module: :"Pubid::Iso",
+                              ))
+            registry.register(Flavor.new(
+                                name: :bipm,
+                                model_class: Metanorma::BipmDocument::Root,
+                                renderer_class: BipmRenderer,
+                              ))
+            registry.register(Flavor.new(
+                                name: :cc,
+                                model_class: Metanorma::CcDocument::Root,
+                                renderer_class: CcRenderer,
+                              ))
+            registry.register(Flavor.new(
+                                name: :iec,
+                                model_class: Metanorma::IecDocument::Root,
+                                renderer_class: IecRenderer,
+                                pubid_module: :"Pubid::Iec",
+                              ))
+            registry.register(Flavor.new(
+                                name: :ieee,
+                                model_class: Metanorma::IeeeDocument::Root,
+                                renderer_class: IeeeRenderer,
+                                pubid_module: :"Pubid::Ieee",
+                              ))
+            registry.register(Flavor.new(
+                                name: :ietf,
+                                model_class: Metanorma::IetfDocument::Root,
+                                renderer_class: IetfRenderer,
+                              ))
+            registry.register(Flavor.new(
+                                name: :iho,
+                                model_class: Metanorma::IhoDocument::Root,
+                                renderer_class: IhoRenderer,
+                                pubid_module: :"Pubid::Iho",
+                              ))
+            registry.register(Flavor.new(
+                                name: :itu,
+                                model_class: Metanorma::ItuDocument::Root,
+                                renderer_class: ItuRenderer,
+                                pubid_module: :"Pubid::Ithu",
+                              ))
+            registry.register(Flavor.new(
+                                name: :ogc,
+                                model_class: Metanorma::OgcDocument::Root,
+                                renderer_class: OgcRenderer,
+                              ))
+            registry.register(Flavor.new(
+                                name: :oiml,
+                                model_class: Metanorma::OimlDocument::Root,
+                                renderer_class: OimlRenderer,
+                                pubid_module: :"Pubid::Oiml",
+                              ))
+            registry.register(Flavor.new(
+                                name: :pdfa,
+                                model_class: Metanorma::RiboseDocument::Root,
+                                renderer_class: PdfaRenderer,
+                              ))
+            registry.register(Flavor.new(
+                                name: :ribose,
+                                model_class: Metanorma::RiboseDocument::Root,
+                                renderer_class: RiboseRenderer,
+                              ))
+          end
+        end
+
+        def safe_attr(node, attr_name)
+          return nil unless node.is_a?(Lutaml::Model::Serializable)
+          return nil unless node.class.attributes.key?(attr_name)
+
+          node.public_send(attr_name)
+        end
       end
     end
   end

data/lib/metanorma/html/renderer_delegation.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    # Shared forwarding methods for narrowing wrappers around a
+    # renderer. Both RendererContext (used by Drop factories) and
+    # Component::Base (used by Component renderers) include this
+    # module so the shared forwarding surface is declared in one
+    # place. Adding a new shared method is one edit here, not two.
+    #
+    # Per-class-specific forwarders stay declared in each wrapper.
+    module RendererDelegation
+      def safe_attr(...)        = @renderer.safe_attr(...)
+      def escape_html(...)      = @renderer.escape_html(...)
+      def extract_block_label(...)= @renderer.extract_block_label(...)
+      def extract_plain_text(...) = @renderer.extract_plain_text(...)
+      def render_mixed_inline(...)= @renderer.render_mixed_inline(...)
+      def render_liquid(...) = @renderer.render_liquid(...)
+    end
+  end
+end

data/lib/metanorma/html/renderers/element_order_traversal.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Renderers
+      # Builds the reverse lookup `{ xml_element_name => attribute_name }`
+      # from a node's xml mapping. Shared between walkers that iterate
+      # element_order: InlineRenderer#walk_ordered (renders in document
+      # order) and BaseRenderer#extract_plain_text (extracts text).
+      #
+      # Both walkers previously reimplemented this hash construction
+      # inline; the construction is the genuinely-shared traversal
+      # concern. Per-element handling (recursion, span emission, tab/br
+      # spacing) differs and stays in each walker.
+      module ElementOrderTraversal
+        module_function
+
+        # Returns `{ xml_element_name => attr_name }` including both
+        # symbol and string keys for each mapped element, so callers
+        # can look up by either el.name form.
+        def element_to_attr_map(xml_mapping)
+          {}.tap do |map|
+            xml_mapping.mapping_elements_hash.each_value do |rule_or_array|
+              Array(rule_or_array).each do |rule|
+                map[rule.name] = rule.to
+                map[rule.name.to_s] = rule.to if rule.name.is_a?(Symbol)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/renderers/inline_renderer.rb

@@ -15,16 +15,8 @@ module Metanorma
           xml_mapping = node.class.mappings_for(:xml, node.lutaml_register)
           return false 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
-              if rule.name.is_a?(Symbol)
-                element_to_attr[rule.name.to_s] =
-                  rule.to
-              end
-            end
-          end
+          element_to_attr =
+            Renderers::ElementOrderTraversal.element_to_attr_map(xml_mapping)
 
           skip_indices = build_semx_skip_set(node)
 
@@ -299,13 +291,14 @@ module Metanorma
             parts << escape_html(texts)
           end
 
-          inline_attrs = %i[em strong smallcap sub sup tt underline strike
-                            xref eref link span stem concept fn br tab keyword
-                            fmt_annotation_start fmt_annotation_end
-                            fmt_stem fmt_fn_label fmt_concept
-                            bookmark image semx fmt_xref_label]
-          inline_attrs.each do |attr|
-            values = safe_attr(node, attr)
+          # Derive the element-mapped attribute list from the node's own
+          # xml_mapping rather than maintaining a parallel hardcoded list.
+          # The model is the single source of truth; adding a new inline
+          # element type via map_element on the model class is enough.
+          node.class.mappings[:xml].elements.each do |rule|
+            next if rule.to == :text
+
+            values = safe_attr(node, rule.to)
             next if values.nil?
 
             Array(values).each { |v| parts << (render_inline_element(v) || "") }
@@ -541,50 +534,44 @@ module Metanorma
           nil
         end
 
+        # Stem content formats in priority order. Each entry binds an
+        # attribute reader on the stem element to the value-render path
+        # (raw XML when serializable, escaped text otherwise). Adding a
+        # new format = one entry here.
+        STEM_FORMATS = [
+          { attr: :math, raw_xml: true },
+          { attr: :asciimath },
+          { attr: :latexmath },
+        ].freeze
+
         def render_stem_content(stem)
           return nil if stem.nil?
 
-          if stem.is_a?(Metanorma::Document::Components::Inline::StemInlineElement)
-            return nil
-          end
-
-          if stem.is_a?(Metanorma::Document::Components::Inline::FmtStemElement)
-            return nil
-          end
-
-          if stem.is_a?(Metanorma::Document::Components::TextElements::StemElement)
-            if stem.math
-              math_val = stem.math
-              if math_val.is_a?(Lutaml::Model::Serializable)
-                return math_val.to_xml
-              end
+          return nil if stem.is_a?(Metanorma::Document::Components::Inline::StemInlineElement) ||
+            stem.is_a?(Metanorma::Document::Components::Inline::FmtStemElement)
 
-              text = escape_html(coordinator.extract_text_value(math_val))
+          unless stem.is_a?(Metanorma::Document::Components::TextElements::StemElement)
+            text = coordinator.extract_text_value(stem)
+            unless text.empty?
               return render_liquid("_stem_span.html.liquid", {
                                      "data_attrs" => "",
-                                     "text" => text,
-                                   })
-            elsif stem.asciimath
-              text = escape_html(coordinator.extract_text_value(stem.asciimath))
-              return render_liquid("_stem_span.html.liquid", {
-                                     "data_attrs" => "",
-                                     "text" => text,
-                                   })
-            end
-            if stem.latexmath
-              text = escape_html(coordinator.extract_text_value(stem.latexmath))
-              return render_liquid("_stem_span.html.liquid", {
-                                     "data_attrs" => "",
-                                     "text" => text,
+                                     "text" => escape_html(text),
                                    })
             end
+            return nil
           end
 
-          text = coordinator.extract_text_value(stem)
-          unless text.empty?
+          STEM_FORMATS.each do |format|
+            value = stem.public_send(format[:attr])
+            next unless value
+
+            if format[:raw_xml] && value.is_a?(Lutaml::Model::Serializable)
+              return value.to_xml
+            end
+
             return render_liquid("_stem_span.html.liquid", {
                                    "data_attrs" => "",
-                                   "text" => escape_html(text),
+                                   "text" => escape_html(coordinator.extract_text_value(value)),
                                  })
           end
           nil

data/lib/metanorma/html/renderers/pubid_renderer.rb

@@ -4,15 +4,6 @@ module Metanorma
   module Html
     module Renderers
       class PubidRenderer
-        FLAVOR_PUBID_MAP = {
-          "IsoDocument" => :"Pubid::Iso",
-          "IecDocument" => :"Pubid::Iec",
-          "IeeeDocument" => :"Pubid::Ieee",
-          "IhoDocument" => :"Pubid::Iho",
-          "ItuDocument" => :"Pubid::Ithu",
-          "OimlDocument" => :"Pubid::Oiml",
-        }.freeze
-
         def initialize(coordinator)
           @coordinator = coordinator
         end
@@ -44,24 +35,11 @@ module Metanorma
           @coordinator.escape_html(text)
         end
 
+        # Flavor identity comes from the shared FlavorRegistry via the
+        # coordinator — no local duplicate of the flavor-to-pubid-module
+        # map.
         def resolve_pubid_module
-          flavor_name = @coordinator.flavor_name
-          return nil unless flavor_name
-
-          @coordinator.class.ancestors.each do |ancestor|
-            next unless ancestor.is_a?(Class)
-
-            ns = ancestor.name&.split("::")&.detect do |n|
-              FLAVOR_PUBID_MAP.key?(n)
-            end
-            next unless ns
-
-            mod = FLAVOR_PUBID_MAP[ns]
-            return Object.const_get(mod.to_s)
-          end
-          nil
-        rescue NameError
-          nil
+          @coordinator.pubid_module
         end
       end
     end

data/lib/metanorma/html/renderers.rb

@@ -3,6 +3,8 @@
 module Metanorma
   module Html
     module Renderers
+      autoload :ElementOrderTraversal,
+               "metanorma/html/renderers/element_order_traversal"
     end
   end
 end

data/lib/metanorma/html/standard_renderer.rb

@@ -454,11 +454,13 @@ module Metanorma
         [prefix_text, rest.empty? ? nil : rest]
       end
 
+      PREFERRED_LINK_TYPES = %w[src citation].freeze
+
       def bibitem_url(item)
         links = Array(item.link)
         return nil if links.empty?
 
-        preferred = links.find { |l| ["src", "citation"].include?(l.type) }
+        preferred = links.find { |l| PREFERRED_LINK_TYPES.include?(l.type) }
         return preferred.content.to_s if preferred && !preferred.content.to_s.empty?
 
         non_rss = links.find do |l|

data/lib/metanorma/html.rb

@@ -65,7 +65,10 @@ module Metanorma
     end
 
     autoload :BaseRenderer, "metanorma/html/base_renderer"
+    autoload :Flavor, "metanorma/html/flavor"
+    autoload :FlavorRegistry, "metanorma/html/flavor_registry"
     autoload :Generator, "metanorma/html/generator"
+    autoload :RendererDelegation, "metanorma/html/renderer_delegation"
     autoload :Theme, "metanorma/html/theme"
     autoload :AssetPipeline, "metanorma/html/asset_pipeline"
     autoload :Component, "metanorma/html/component"

data/lib/metanorma/mirror/handlers/inline/catalog.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Handlers
+      module Inline
+        # Shared declarative table of inline marks whose HTML rendering is
+        # a fixed tag with optional static attrs. Two adapters consume it:
+        #
+        # - RichHtmlRenderer: renders Metanorma XML elements to HTML
+        #   directly (the fallback / attribute-value path).
+        # - Output::HtmlRenderers::MarkRenderers: renders mirror Model marks
+        #   to HTML (the primary SSR path).
+        #
+        # Both adapters must produce visually equivalent HTML for the same
+        # mark type — the table is the single source of truth for the
+        # mark-name to tag-and-attrs mapping. Marks whose attrs vary per
+        # instance (link, xref, eref, span) carry data in mark.attrs and
+        # are not in this table; each adapter keeps custom handlers for
+        # those.
+        module Catalog
+          SIMPLE_WRAPS = {
+            "emphasis" => { tag: :em },
+            "strong" => { tag: :strong },
+            "subscript" => { tag: :sub },
+            "superscript" => { tag: :sup },
+            "code" => { tag: :code },
+            "underline" => { tag: :u },
+            "strike" => { tag: :s },
+            "smallcap" => { tag: :span, style: "font-variant: small-caps" },
+            "concept" => { tag: :span, class: "concept" },
+            "bcp14" => { tag: :span, class: "bcp14" },
+            "footnote" => { tag: :sup, class: "footnote-inline" },
+            "stem" => { tag: :span, class: "stem" },
+          }.freeze
+
+          # XML element classes that render via SIMPLE_WRAPS without
+          # per-instance attrs. Maps element class → mark type (catalog
+          # key). RichHtmlRenderer uses this to dispatch simple elements
+          # through the shared table.
+          SIMPLE_ELEMENTS = {
+            Metanorma::Document::Components::Inline::EmRawElement => "emphasis",
+            Metanorma::Document::Components::Inline::StrongRawElement => "strong",
+            Metanorma::Document::Components::Inline::SubElement => "subscript",
+            Metanorma::Document::Components::Inline::SupElement => "superscript",
+            Metanorma::Document::Components::Inline::TtElement => "code",
+            Metanorma::Document::Components::TextElements::UnderlineElement => "underline",
+            Metanorma::Document::Components::TextElements::StrikeElement => "strike",
+            Metanorma::Document::Components::Inline::SmallCapElement => "smallcap",
+            Metanorma::Document::Components::Inline::Bcp14Element => "bcp14",
+            Metanorma::Document::Components::Inline::ConceptElement => "concept",
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/mirror/handlers/inline/rich_html_renderer.rb

@@ -10,35 +10,15 @@ module Metanorma
         # representation of inline content is required (e.g., attribute values,
         # fallback rendering). All HTML construction goes through
         # Nokogiri::HTML5::Builder to guarantee well-formed, escaped output.
+        #
+        # Simple-wrap elements (em, strong, sub, sup, code, u, s, smallcap,
+        # bcp14, concept) share their tag-and-attrs mapping with the Model-side
+        # renderer via Inline::Catalog, so the XML→HTML and Model→HTML paths
+        # produce visually equivalent output for the same mark type.
         module RichHtmlRenderer
-          RENDERERS = {
-            Metanorma::Document::Components::Inline::EmRawElement => ->(el) {
-              wrap { |d| d.em { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::Inline::StrongRawElement => ->(el) {
-              wrap { |d| d.strong { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::Inline::SubElement => ->(el) {
-              wrap { |d| d.sub { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::Inline::SupElement => ->(el) {
-              wrap { |d| d.sup { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::Inline::TtElement => ->(el) {
-              wrap { |d| d.code { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::TextElements::UnderlineElement => ->(el) {
-              wrap { |d| d.u { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::TextElements::StrikeElement => ->(el) {
-              wrap { |d| d.s { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::Inline::SmallCapElement => ->(el) {
-              wrap { |d| d.span { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::Inline::Bcp14Element => ->(el) {
-              wrap { |d| d.span { d << raw(extract(el)) } }
-            },
+          # Complex element handlers — these have per-instance attrs or
+          # multi-step rendering and bypass the shared Catalog.
+          COMPLEX_RENDERERS = {
             Metanorma::Document::Components::Inline::StemInlineElement => ->(el) {
               for_stem(el)
             },
@@ -57,9 +37,6 @@ module Metanorma
             Metanorma::Document::Components::Inline::FnElement => ->(el) {
               for_fn(el)
             },
-            Metanorma::Document::Components::Inline::ConceptElement => ->(el) {
-              wrap { |d| d.span(class: "concept") { d << raw(extract(el)) } }
-            },
             Metanorma::Document::Components::Inline::SpanElement => ->(el) {
               for_span(el)
             },
@@ -93,8 +70,25 @@ module Metanorma
           end
 
           def self.render_element(element)
-            renderer = RENDERERS[element.class]
-            renderer ? renderer.call(element) : extract(element)
+            complex = COMPLEX_RENDERERS[element.class]
+            return complex.call(element) if complex
+
+            mark_type = Catalog::SIMPLE_ELEMENTS[element.class]
+            return render_simple(mark_type, element) if mark_type
+
+            extract(element)
+          end
+
+          def self.render_simple(mark_type, element)
+            spec = Catalog::SIMPLE_WRAPS[mark_type]
+            attrs = spec.except(:tag)
+            wrap do |d|
+              if attrs.empty?
+                d.public_send(spec[:tag]) { d << raw(extract(element)) }
+              else
+                d.public_send(spec[:tag], attrs) { d << raw(extract(element)) }
+              end
+            end
           end
 
           def self.for_stem(element)
@@ -105,7 +99,10 @@ module Metanorma
               .sub(/\s*xmlns(:\w+)?="[^"]*"\s*/, " ")
               .gsub(/\s+/, " ")
               .strip
-            wrap { |d| d.span(class: "inline-math") { d << raw(mathml) } }
+            spec = Catalog::SIMPLE_WRAPS["stem"]
+            wrap do |d|
+              d.public_send(spec[:tag], spec.except(:tag)) { d << raw(mathml) }
+            end
           end
 
           def self.for_xref(element)
@@ -130,7 +127,10 @@ module Metanorma
 
           def self.for_fn(element)
             reference = SafeAttr.read(element, :reference) || ""
-            wrap { |d| d.sup(class: "footnote-inline") { d.text reference } }
+            spec = Catalog::SIMPLE_WRAPS["footnote"]
+            wrap do |d|
+              d.public_send(spec[:tag], spec.except(:tag)) { d.text reference }
+            end
           end
 
           def self.for_span(element)

data/lib/metanorma/mirror/handlers/inline.rb

@@ -6,6 +6,7 @@ module Metanorma
       module Inline
         autoload :TextExtractor, "#{__dir__}/inline/text_extractor"
         autoload :RichHtmlRenderer, "#{__dir__}/inline/rich_html_renderer"
+        autoload :Catalog, "#{__dir__}/inline/catalog"
 
         MARK_BUILDERS = {
           Metanorma::Document::Components::Inline::EmRawElement => ->(_el) {