metanorma-document 0.2.12 → 0.4.0

data/lib/metanorma/html/iso_renderer.rb

@@ -330,148 +330,6 @@ module Metanorma
 
       # --- ISO Term rendering ---
 
-      def render_term(term, **_opts)
-        term_name = extract_term_name(term)
-        term_def = extract_term_definition(term)
-        data_attrs = {}
-        if term_name && !term_name.empty?
-          data_attrs["data-term-name"] = term_name
-        end
-        if term_def && !term_def.empty?
-          data_attrs["data-term-definition"] = term_def
-        end
-        attrs = element_attrs(id: safe_attr(term, :id), **data_attrs)
-        fmt_name = safe_attr(term, :fmt_name)
-        fmt_preferred = safe_attr(term, :fmt_preferred)
-        fmt_admitted = safe_attr(term, :fmt_admitted)
-        fmt_deprecates = safe_attr(term, :fmt_deprecates)
-        fmt_definition = safe_attr(term, :fmt_definition)
-        fmt_termsource = safe_attr(term, :fmt_termsource)
-        term_number = safe_attr(term, :term_number)
-        term_p = safe_attr(term, :p)
-        term_note = safe_attr(term, :termnote) || Array(safe_attr(term, :note))
-        term_example = safe_attr(term,
-                                 :termexample) || Array(safe_attr(term,
-                                                                  :example))
-        term_termsource = safe_attr(term, :termsource)
-        term_admonition = safe_attr(term, :admonition)
-        term_nested = safe_attr(term, :term)
-
-        parts = []
-        if fmt_name
-          tn_content = render_inline_element(fmt_name)
-          parts << render_liquid("_term_number.html.liquid",
-                                 { "content" => tn_content })
-        elsif term_number
-          tn_text = if term_number.is_a?(String)
-                      term_number
-                    else
-                      extract_text_value(term_number)
-                    end
-          parts << render_liquid("_term_number.html.liquid",
-                                 { "content" => escape_html(tn_text) })
-        end
-
-        if fmt_preferred && !fmt_preferred.empty?
-          fmt_preferred.each do |fp|
-            fp.p&.each { |para| parts << (render_paragraph(para) || "") }
-          end
-        elsif term.preferred && !term.preferred.empty?
-          term.preferred&.each do |designation|
-            parts << (render_term_designation(designation, "preferred") || "")
-          end
-        end
-
-        if fmt_admitted && !fmt_admitted.empty?
-          fmt_admitted.each do |fa|
-            fa.p&.each { |para| parts << (render_paragraph(para) || "") }
-          end
-        elsif term.admitted && !term.admitted.empty?
-          term.admitted&.each do |designation|
-            parts << (render_term_designation(designation, "admitted") || "")
-          end
-        end
-
-        if fmt_deprecates
-          fmt_deprecates.p&.each do |para|
-            parts << (render_paragraph(para) || "")
-          end
-        elsif term.deprecates && !term.deprecates.empty?
-          term.deprecates&.each do |designation|
-            parts << (render_term_designation(designation, "deprecated") || "")
-          end
-        end
-
-        if term.domain && !fmt_definition
-          domain_text = safe_attr(term.domain, :text)
-          if domain_text
-            parts << render_liquid("_term_domain.html.liquid", {
-                                     "text" => escape_html(domain_text),
-                                   })
-          end
-        end
-
-        if fmt_definition
-          parts << (render_ordered_content(fmt_definition) || "")
-        else
-          term_p&.each { |para| parts << (render_paragraph(para) || "") }
-          term.definition&.each do |defn|
-            parts << (render_term_definition(defn) || "")
-          end
-        end
-
-        term_note&.each { |note| parts << (render_term_note(note) || "") }
-        term_example&.each { |ex| parts << (render_term_example(ex) || "") }
-
-        if fmt_termsource && !fmt_termsource.empty?
-          fmt_termsource.each do |fts|
-            src_content = render_mixed_inline(fts)
-            parts << render_liquid("_paragraph.html.liquid", {
-                                     "attrs" => " class=\"term-source\"",
-                                     "content" => src_content,
-                                   })
-          end
-        else
-          term.source&.each { |src| parts << (render_term_source(src) || "") }
-          term_termsource&.each do |src|
-            parts << (render_term_source_element(src) || "")
-          end
-        end
-
-        term_admonition&.each { |adm| parts << (render_admonition(adm) || "") }
-        term_nested&.each { |sub| parts << (render_term(sub) || "") }
-
-        render_liquid("_element.html.liquid", "tag" => "div",
-                                              "extra_attrs" => attrs, "content" => parts.join)
-      end
-
-      def extract_term_name(term)
-        fmt_pref = safe_attr(term, :fmt_preferred)
-        if fmt_pref && !fmt_pref.empty?
-          fp = fmt_pref.first
-          if fp.p && !fp.p.empty?
-            return extract_plain_text(fp.p.first)
-          end
-        end
-        if term.preferred && !term.preferred.empty?
-          return extract_designation_name(term.preferred.first).to_s
-        end
-
-        safe_attr(term, :id).to_s.delete_prefix("term-")
-      end
-
-      def extract_term_definition(term)
-        fmt_def = safe_attr(term, :fmt_definition)
-        return extract_plain_text(fmt_def) if fmt_def
-
-        term_p = safe_attr(term, :p)
-        if term_p && !term_p.empty?
-          text = term_p.map { |para| extract_plain_text(para) }.join(" ")
-          return text.strip unless text.strip.empty?
-        end
-        nil
-      end
-
       def render_term_designation(designation, type)
         css_class = type == "deprecated" ? "term-deprecated" : "term-name"
         name = extract_designation_name(designation)

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/block_renderer.rb

@@ -271,6 +271,16 @@ module Metanorma
           render_liquid("_example.html.liquid", { "block" => drop })
         end
 
+        def render_form(form, **_opts)
+          attrs = element_attrs(id: safe_attr(form, :id), class: "form")
+          content = coordinator.render_ordered_content(form)
+          render_liquid("_element.html.liquid", {
+                          "tag" => "div",
+                          "extra_attrs" => attrs,
+                          "content" => content,
+                        })
+        end
+
         def render_sourcecode(sc, **_opts)
           drop = Drops::SourcecodeDrop.from_model(sc,
                                                   renderer: coordinator.renderer_context)

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

@@ -0,0 +1,48 @@
+# 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
+
+        # The map depends only on the model class's xml mapping, which is
+        # immutable after class definition — cache one map per mapping
+        # object instead of rebuilding it for every rendered node.
+        @cache = {}.compare_by_identity
+
+        def element_to_attr_map(xml_mapping)
+          @cache[xml_mapping] ||= build_map(xml_mapping)
+        end
+
+        # Test/benchmark hook: drop all memoized maps.
+        def reset_cache!
+          @cache.clear
+        end
+
+        # 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 build_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)
 
@@ -112,13 +104,6 @@ module Metanorma
         end
 
         def render_mixed_inline(node)
-          if raw_content_node?(node)
-            raw = node.content
-            if raw.is_a?(String) && !raw.strip.empty?
-              return render_raw_content(raw)
-            end
-          end
-
           if node.is_a?(Lutaml::Model::Serializable) && node.element_order && !node.element_order.empty?
             render_ordered_inline(node)
           elsif node.is_a?(Lutaml::Model::Serializable)
@@ -137,13 +122,6 @@ module Metanorma
           end
         end
 
-        def raw_content_node?(node)
-          node.is_a?(Lutaml::Model::Serializable) &&
-            node.content.is_a?(String)
-        rescue NoMethodError
-          false
-        end
-
         def render_ordered_inline(node)
           parts = []
           walked = walk_ordered(node) do |type, obj|
@@ -251,8 +229,19 @@ module Metanorma
           ", "
         end
 
+        # Form inputs render as disabled HTML inputs — this is a document
+        # rendering, not an interactive form.
+        def render_input(el)
+          attrs = element_attrs(
+            type: safe_attr(el, :type) || "text",
+            disabled: "disabled",
+            checked: safe_attr(el, :checked) ? "checked" : nil,
+          )
+          "<input#{attrs}>"
+        end
+
         def render_math(el)
-          el.content.to_s
+          el.to_xml
         end
 
         def render_asciimath(el)
@@ -299,13 +288,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) || "") }
@@ -381,65 +371,6 @@ module Metanorma
                         })
         end
 
-        def render_raw_content(raw_xml)
-          doc = Nokogiri::XML.fragment(raw_xml)
-          doc.css("fmt-link").each do |el|
-            target = el["target"] || el["href"]
-            if target
-              display_text = target.delete_prefix("mailto:")
-              a = doc.document.create_element("a", display_text,
-                                              "href" => target)
-              el.replace(a)
-            else
-              el.replace(el.children)
-            end
-          end
-          doc.traverse do |node|
-            next unless node.element?
-            next unless %w[xref eref stem link].include?(node.name)
-
-            next_sib = node.next_sibling
-            while next_sib.is_a?(Nokogiri::XML::Text) && next_sib.text.strip.empty?
-              next_sib = next_sib.next_sibling
-            end
-            next unless next_sib&.element? && next_sib.name == "semx"
-
-            deduplicate_semx_label(node, next_sib)
-            node.remove
-          end
-          %w[semx fmt-xref].each do |tag|
-            doc.css(tag).each { |el| el.replace(el.children) }
-          end
-          doc.css("[class]").each do |el|
-            el["class"] = el["class"].split(/\s+/).map do |c|
-              html_class_for_span(c)
-            end.join(" ")
-          end
-          doc.inner_html
-        end
-
-        def deduplicate_semx_label(source_node, semx_node)
-          first_text = semx_node.children.find do |c|
-            c.text? && !c.text.strip.empty?
-          end
-          return unless first_text
-
-          semx_prefix = first_text.text[/\A(\s*\S+)/, 1]
-          return unless semx_prefix && !semx_prefix.strip.empty?
-
-          prev = source_node.previous_sibling
-          return unless prev.is_a?(Nokogiri::XML::Text)
-
-          label = semx_prefix.strip
-          prev_text = prev.text.rstrip
-          return unless prev_text.end_with?(label)
-
-          prev.content = prev_text.sub(/#{Regexp.escape(label)}\s*\z/, "")
-          first_text.content = first_text.text.sub(
-            /\A\s*#{Regexp.escape(label)}\s*/, ""
-          )
-        end
-
         def render_link(link)
           target = safe_attr(link, :target) || safe_attr(link, :href)
           attrs = element_attrs(href: target, id: safe_attr(link, :id))
@@ -524,7 +455,7 @@ module Metanorma
           end
 
           if math_items.any?
-            content = math_items.map { |m| m.content.to_s }.join
+            content = math_items.map(&:to_xml).join
             unless content.empty?
               return render_liquid("_math_container.html.liquid", {
                                      "data_attrs" => data_attrs,
@@ -541,50 +472,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))
-              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))
+          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,
+                                     "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