metanorma-document 0.5.1 → 0.5.2.pre.alpha.1

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

@@ -64,6 +64,11 @@ module Metanorma
             "renderterm" => nil,
             "origin" => "semx",
           }
+          # refterm is semantic-only inside <concept>, but a related-term
+          # semx renders it as escaped literal text (native parity).
+          if node.is_a?(Metanorma::Document::Components::Inline::SemxElement)
+            skip_after = skip_after.except("refterm")
+          end
           skip = {}
           node.element_order.each_with_index do |el, i|
             next unless el.element?
@@ -183,6 +188,24 @@ module Metanorma
           render_liquid("_br.html.liquid", {})
         end
 
+        def render_ruby(ruby)
+          annotation = safe_attr(ruby, :pronunciation) ||
+            safe_attr(ruby, :annotation)
+          annotation_value = annotation && safe_attr(annotation, :value)
+          annotation_value ||= Array(safe_attr(ruby, :ruby_text)).join
+          render_liquid("_ruby.html.liquid",
+                        "base" => ruby_base_text(ruby),
+                        "annotation" => annotation_value)
+        end
+
+        # Semantic form: the annotated text is the ruby's own mixed
+        # content; presentation form: the rb element carries it.
+        def ruby_base_text(ruby)
+          base = safe_attr(ruby, :ruby_base)
+          source = base || ruby
+          Array(safe_attr(source, :text)).join
+        end
+
         def render_tab(*)
           "  "
         end
@@ -206,10 +229,53 @@ module Metanorma
           nil
         end
 
+        # Semantic <stem> blocks (StemInlineElement) carry canonical math;
+        # isodoc renders them as a stem span holding the MathML (whose
+        # text nodes stay part of the page text) or the AsciiMath source.
+        def render_stem_inline(el)
+          return nil if el.nil?
+
+          math = Array(el.math).filter_map do |m|
+            m.to_xml if m.respond_to?(:to_xml)
+          end.join
+          unless math.empty?
+            return render_liquid("_stem_span.html.liquid",
+                                 { "data_attrs" => "", "text" => math })
+          end
+
+          text = Array(el.asciimath).filter_map do |a|
+            a.is_a?(String) ? a : a.text
+          end.join
+          return nil if text.empty?
+
+          render_liquid("_stem_span.html.liquid",
+                        { "data_attrs" => "", "text" => escape_html(text) })
+        end
+
         def render_semx_inline(el)
           render_semx_content(el)
         end
 
+        # Native parity: a <refterm> outside <concept> (failed related-term
+        # lookup) renders as escaped literal markup text.
+        def render_refterm(el)
+          text = safe_attr(el, :text).to_s
+          return "" if text.empty?
+
+          "&lt;refterm&gt;#{escape_html(text)}&lt;/refterm&gt;"
+        end
+
+        def render_fmt_preferred_inline(el)
+          parts = []
+          safe_attr(el, :semx)&.each do |s|
+            parts << (render_inline_element(s) || "")
+          end
+          safe_attr(el, :p)&.each do |p|
+            parts << (coordinator.render_paragraph(p) || "")
+          end
+          parts.join
+        end
+
         def render_fmt_xref(el)
           target = safe_attr(el, :target) || safe_attr(el, :to_attr)
           if target
@@ -307,7 +373,8 @@ module Metanorma
           parts = []
           display_attrs = %i[text fmt_xref fmt_link fmt_concept span strong em sup p semx
                              asciimath math sub_child tt_child br_child tab_child
-                             stem_child figure_child formula_child sourcecode_child]
+                             stem_child figure_child formula_child sourcecode_child
+                             fn_child refterm fmt_preferred ol ul]
           label_stripped = false
 
           walked = walk_ordered(element,
@@ -323,6 +390,8 @@ module Metanorma
             when :element
               parts << if obj.is_a?(Metanorma::Document::Components::Paragraphs::ParagraphBlock)
                          coordinator.render_paragraph(obj) || ""
+                       elsif coordinator.block_element?(obj)
+                         coordinator.render(obj) || ""
                        else
                          render_inline_element(obj) || ""
                        end
@@ -374,9 +443,8 @@ module Metanorma
         def render_link(link)
           target = safe_attr(link, :target) || safe_attr(link, :href)
           attrs = element_attrs(href: target, id: safe_attr(link, :id))
-          content = safe_attr(link, :content)
-          if content && !Array(content).join.strip.empty?
-            inner = render_mixed_inline(link)
+          inner = render_mixed_inline(link)
+          if inner && !inner.strip.empty?
             render_liquid("_link.html.liquid", {
                             "attrs" => attrs,
                             "content" => inner,
@@ -395,42 +463,96 @@ module Metanorma
           attrs = element_attrs(href: "##{escape_html(target)}",
                                 id: safe_attr(xref, :id))
           content = render_mixed_inline(xref)
+          # Cross-references carry no computed labels in this pipeline, so
+          # unresolvable targets keep isodoc's literal "[id]" fallback,
+          # emitted ahead of the link text like the native presentation.
+          text = if content.empty?
+                   "[#{escape_html(target.to_s)}]"
+                 else
+                   "[#{escape_html(target.to_s)}] #{content}"
+                 end
           render_liquid("_link.html.liquid", {
                           "attrs" => attrs,
-                          "content" => content,
+                          "content" => text,
                         })
         end
 
         def render_eref(eref)
           citeas = safe_attr(eref, :citeas)
-          if citeas
+          content = render_mixed_inline(eref)
+          if !content.empty?
+            content
+          elsif citeas
             escape_html(citeas)
-          else
-            render_mixed_inline(eref)
           end
         end
 
         def render_fn(fn)
-          fn_id = safe_attr(fn, :id)
-          number = coordinator.footnote_collector.register(fn)
-
-          label = safe_attr(fn, :fn_label) || safe_attr(fn, :reference)
+          label = footnote_label_text(fn) || safe_attr(fn, :reference)
           return nil unless label
 
-          popup_parts = Array(fn.p).map do |para|
-            render_mixed_inline(para) || ""
+          if (ctx = coordinator.table_fn_context)
+            # Table-scoped <fn>: the native render shows the reference
+            # letter in the cell and lifts the definition into a visible
+            # tfoot block (TableFootnote), not an endnote popup.
+            ctx[:fns] << fn
+            assigns = {
+              "attrs" => element_attrs(
+                id: safe_attr(fn, :id) || "table-fn-#{ctx[:fns].size}",
+                class: "fn-marker",
+              ),
+              "number" => ctx[:fns].size,
+              "label" => escape_html(label.to_s),
+              "popup_html" => nil,
+            }
+            return render_liquid("_fn_marker.html.liquid", assigns)
           end
-          popup_html = popup_parts.join
+
+          fn_id = safe_attr(fn, :id)
+          entry = coordinator.footnote_collector.register(
+            fn, label_text: footnote_label_text(fn)
+          )
+
+          label = entry.fmt_label || entry.reference || label
+          popup_html = fn_content_html(fn)
 
           assigns = {
             "attrs" => element_attrs(id: fn_id, class: "fn-marker"),
-            "number" => number,
+            "number" => entry.number,
             "label" => escape_html(label.to_s),
             "popup_html" => popup_html.strip.empty? ? nil : popup_html,
           }
           render_liquid("_fn_marker.html.liquid", assigns)
         end
 
+        # The rendered body of a footnote: its paragraphs plus any block
+        # children (bibliography notes carry lists).
+        def fn_content_html(fn)
+          popup_parts = Array(fn.p).map do |para|
+            render_mixed_inline(para) || ""
+          end
+          %i[ul ol table].each do |attr|
+            next unless fn.respond_to?(attr)
+
+            Array(fn.send(attr)).each do |block|
+              popup_parts << (coordinator.render(block) || "")
+            end
+          end
+          popup_parts.join
+        end
+
+        # The presentation autonum label of a footnote ("19" for
+        # <fmt-fn-label><span><sup>19</sup></span></fmt-fn-label>), which
+        # native footnotes display instead of a renumbered sequence.
+        def footnote_label_text(fn)
+          fmt = safe_attr(fn, :fmt_fn_label)
+          return nil unless fmt
+
+          html = render_mixed_inline(fmt).to_s
+          text = html.gsub(/<[^>]+>/, "").strip
+          text.empty? ? nil : text
+        end
+
         def render_concept(concept)
           render_mixed_inline(concept)
         end
@@ -522,7 +644,12 @@ module Metanorma
             return escape_html(element)
           end
 
-          method = coordinator.lookup_dispatch(element.class, :inline_registry)
+          # A block container nested in a mixed-content position (e.g. a
+          # definition list inside a <dd>) has no inline dispatch of its
+          # own; fall through to the block registry so it renders instead
+          # of being dropped.
+          method = coordinator.lookup_dispatch(element.class, :inline_registry) ||
+            coordinator.lookup_dispatch(element.class, :render_registry)
           if method
             coordinator.public_send(method, element)
           elsif element.is_a?(Lutaml::Model::Serializable) && element.mixed?

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

@@ -151,8 +151,18 @@ module Metanorma
 
           coordinator.register_toc_entry(id: "preface", level: 1,
                                          text: "Preface")
-          content = clauses.filter_map do |cl|
-            coordinator.render(cl, level: 2)
+          # Render in the theme's declared order: the named preface
+          # sections (foreword, introduction, abstract, ...) AND the
+          # clauses — the others were previously only emptiness-checked,
+          # silently dropping every non-clause preface section.
+          content = order.filter_map do |name|
+            if name == "clause"
+              clauses.filter_map { |cl| coordinator.render(cl, level: 2) }.join
+            else
+              out = Array(safe_attr(preface, name.to_sym))
+                .filter_map { |sec| coordinator.render(sec, level: 2) }.join
+              out.empty? ? nil : out
+            end
           end.join
           render_liquid("_wrapped_preface.html.liquid", content: content)
         end