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

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

@@ -16,6 +16,9 @@ module Metanorma
           figure: :render_figure,
           quote: :render_quote,
           formula: :render_formula,
+          requirement: :render_nested_requirement,
+          recommendation: :render_nested_requirement,
+          permission: :render_nested_requirement,
         }.freeze
 
         SIMPLE_CHILDREN = {
@@ -24,17 +27,40 @@ module Metanorma
 
         NOTE_CHILDREN = {
           paragraphs: :render_paragraph,
+          semx: :render_note_semx_content,
           ul: :render_unordered_list,
           ol: :render_ordered_list,
           dl: :render_definition_list,
           quote: :render_quote,
         }.freeze
 
+        # Admonitions carry the full block range (BSI commentary lists,
+        # NIST historical quotes with attributions).
+        ADMONITION_CHILDREN = {
+          paragraphs: :render_paragraph,
+          semx: :render_note_semx_content,
+          ul: :render_unordered_list,
+          ol: :render_ordered_list,
+          dl: :render_definition_list,
+          quote: :render_quote,
+          table: :render_table,
+          formula: :render_formula,
+        }.freeze
+
+        def render_admonition_children(model)
+          render_block_children(model, children: ADMONITION_CHILDREN)
+        end
+
+        # Presentation notes whose body arrives wrapped in a semx slice.
+        def render_note_semx_content(semx)
+          coordinator.render_semx_content(semx)
+        end
+
         def initialize(coordinator)
           @coordinator = coordinator
         end
 
-        def render_paragraph(p, **_opts)
+        def render_paragraph(p, label: nil, label_class: nil, **_opts)
           attrs = element_attrs(id: safe_attr(p, :id),
                                 style: coordinator.alignment_style(safe_attr(p,
                                                                              :alignment)))
@@ -42,6 +68,21 @@ module Metanorma
           render_liquid("_paragraph.html.liquid", {
                           "attrs" => attrs,
                           "content" => content,
+                          "label" => label,
+                          "label_class" => label_class,
+                        })
+        end
+
+        # Wraps an already-rendered HTML fragment in a `<p>` opened by the
+        # given label span. Used by NoteDrop / ExampleDrop when a note has
+        # no paragraph child to host the label (e.g. inline-only content or
+        # an empty note). All markup is emitted by `_paragraph.html.liquid`.
+        def render_label_paragraph(content_html, label:, label_class:)
+          render_liquid("_paragraph.html.liquid", {
+                          "attrs" => "",
+                          "content" => content_html,
+                          "label" => label,
+                          "label_class" => label_class,
                         })
         end
 
@@ -63,27 +104,25 @@ module Metanorma
                             render_table_colgroup(table.colgroup)
                           end
 
-          thead_html = if table.thead
-                         render_table_section(table.thead, "thead")
-                       end
-
-          tbody_html = if table.tbody
-                         render_table_section(table.tbody, "tbody")
-                       end
-
-          tfoot_html = nil
-          if table.tfoot || (table.note && !table.note.empty?)
-            tfoot_inner = render_table_section_rows(table.tfoot) if table.tfoot
-            notes_html = nil
-            if table.note && !table.note.empty?
-              notes_inner = table.note.filter_map { |n| render_note(n) }.join
-              notes_html = render_liquid("_element.html.liquid", "tag" => "tr", "extra_attrs" => "",
-                                                                 "content" => render_liquid("_element.html.liquid", "tag" => "td", "extra_attrs" => %( colspan="#{col_count}" class="table-notes"), "content" => notes_inner))
-            end
-            tfoot_html = render_liquid("_element.html.liquid", "tag" => "tfoot", "extra_attrs" => "",
-                                                               "content" => "#{tfoot_inner}#{notes_html}")
+          # <fn>s inside cells collect here while the sections render,
+          # then lift into a visible tfoot block like the native render.
+          table_fns = []
+          saved_ctx = coordinator.table_fn_context
+          coordinator.table_fn_context = { fns: table_fns }
+          begin
+            thead_html = if table.thead
+                           render_table_section(table.thead, "thead")
+                         end
+
+            tbody_html = if table.tbody
+                           render_table_section(table.tbody, "tbody")
+                         end
+          ensure
+            coordinator.table_fn_context = saved_ctx
           end
 
+          tfoot_html = table_tfoot_html(table, table_fns, col_count)
+
           render_liquid("_table.html.liquid", {
                           "attrs" => attrs,
                           "caption" => caption_html,
@@ -94,6 +133,45 @@ module Metanorma
                         })
         end
 
+        def table_tfoot_html(table, table_fns, col_count)
+          return nil unless table.tfoot || (table.note && !table.note.empty?) ||
+            table_fns.any?
+
+          tfoot_inner = render_table_section_rows(table.tfoot) if table.tfoot
+          notes_html = table_notes_row(table, col_count)
+          table_fn_html = table_footnotes_row(table_fns, col_count)
+          render_liquid("_element.html.liquid", "tag" => "tfoot", "extra_attrs" => "",
+                                                "content" => "#{tfoot_inner}#{notes_html}#{table_fn_html}")
+        end
+
+        def table_notes_row(table, col_count)
+          return nil unless table.note && !table.note.empty?
+
+          notes_inner = table.note.filter_map { |n| render_note(n) }.join
+          render_liquid("_element.html.liquid", "tag" => "tr", "extra_attrs" => "",
+                                                "content" => render_liquid("_element.html.liquid", "tag" => "td", "extra_attrs" => %( colspan="#{col_count}" class="table-notes"), "content" => notes_inner))
+        end
+
+        # Native parity: <fn>s used inside a table render as visible
+        # TableFootnote blocks in a spanning tfoot row.
+        def table_footnotes_row(fns, col_count)
+          items = fns.filter_map do |fn|
+            label = coordinator.footnote_label_text(fn) ||
+              safe_attr(fn, :reference)
+            next unless label
+
+            body = coordinator.fn_content_html(fn)
+            next if body.to_s.empty?
+
+            %(<p class="TableFootnote"><span><span class="TableFootnoteRef">#{escape_html(label.to_s)}</span>&#xA0; </span>#{body}</p>)
+          end
+          return nil if items.empty?
+
+          inner = %(<div class="TableFootnote">#{items.join}</div>)
+          render_liquid("_element.html.liquid", "tag" => "tr", "extra_attrs" => "",
+                                                "content" => render_liquid("_element.html.liquid", "tag" => "td", "extra_attrs" => %( colspan="#{col_count}" class="table-footnotes"), "content" => inner))
+        end
+
         def table_column_count(table)
           if table.colgroup&.col && !table.colgroup.col.empty?
             return table.colgroup.col.size
@@ -160,11 +238,7 @@ module Metanorma
           items = ul.listitem&.filter_map do |li|
             render_list_item_content(li, labeled: labeled)
           end || []
-          render_liquid("_list.html.liquid", {
-                          "list_tag" => "ul",
-                          "attrs" => attrs,
-                          "items" => items,
-                        })
+          render_list_with_attached_notes(ul, items, "ul", attrs)
         end
 
         def render_table_cell(cell, force_tag = nil)
@@ -191,11 +265,30 @@ module Metanorma
           items = ol.listitem&.filter_map do |li|
             render_list_item_content(li, labeled: labeled)
           end || []
-          render_liquid("_list.html.liquid", {
-                          "list_tag" => "ol",
-                          "attrs" => attrs,
-                          "items" => items,
-                        })
+          render_list_with_attached_notes(ol, items, "ol", attrs)
+        end
+
+        # Lists can carry attached notes (e.g. <note> siblings of the
+        # <li> children); render them after the list items so they are
+        # not dropped.
+        def render_list_with_attached_notes(list, items, list_tag, attrs)
+          items_html = render_liquid("_list.html.liquid", {
+                                       "list_tag" => list_tag,
+                                       "attrs" => attrs,
+                                       "items" => items,
+                                     })
+          notes = safe_attr(list, :note)
+          note_parts = Array(notes).filter_map { |note| coordinator.render(note) || "" }
+          return items_html if note_parts.empty?
+
+          note_html = render_liquid("_element.html.liquid", {
+                                      "tag" => "div",
+                                      "extra_attrs" => element_attrs(
+                                        class: "list-attached-notes",
+                                      ),
+                                      "content" => note_parts.join,
+                                    })
+          items_html + note_html
         end
 
         def render_list_item_content(li, labeled: false)
@@ -236,10 +329,27 @@ module Metanorma
             dd_html = dd ? coordinator.render_mixed_inline(dd) : nil
             { "dt" => dt_html, "dd" => dd_html }
           end || []
-          render_liquid("_definition_list.html.liquid", {
-                          "attrs" => attrs,
-                          "terms" => terms,
-                        })
+          html = render_liquid("_definition_list.html.liquid", {
+                                 "attrs" => attrs,
+                                 "terms" => terms,
+                               })
+          attached_notes_html(dl, html)
+        end
+
+        # Notes attached to a rendered list container (dl notes are not
+        # list items); emitted after the list body so they are not dropped.
+        def attached_notes_html(list, html)
+          note_parts = Array(safe_attr(list, :note))
+            .filter_map { |note| coordinator.render(note) || "" }
+          return html if note_parts.empty?
+
+          html + render_liquid("_element.html.liquid", {
+                                 "tag" => "div",
+                                 "extra_attrs" => element_attrs(
+                                   class: "list-attached-notes",
+                                 ),
+                                 "content" => note_parts.join,
+                               })
         end
 
         def render_figure(figure, **_opts)
@@ -248,11 +358,41 @@ module Metanorma
           render_liquid("_figure.html.liquid", { "block" => drop })
         end
 
+        # Image maps render as their wrapped figure(s): the href
+        # rewriting they carry is an SVG asset transformation, not
+        # page markup.
+        def render_svgmap(svgmap, **)
+          render_wrapped_figures(svgmap, **)
+        end
+
+        def render_imagemap(imagemap, **)
+          render_wrapped_figures(imagemap, **)
+        end
+
+        def render_wrapped_figures(container, **opts)
+          Array(safe_attr(container, :figure)).map do |fig|
+            render_figure(fig, **opts)
+          end.join
+        end
+
         def render_image(image)
-          src_val = image_source(image)
+          svg_xml = safe_attr(image, :inline_svg)
+          if svg_xml && !svg_xml.empty?
+            # Native parity: isodoc inlines embedded SVG markup (its text
+            # nodes are page text), not a base64 <img> data URI.
+            return render_liquid("_element.html.liquid", {
+                                   "tag" => "span",
+                                   "extra_attrs" => element_attrs(
+                                     id: safe_attr(image, :id),
+                                     class: "figure-svg",
+                                   ),
+                                   "content" => svg_xml,
+                                 })
+          end
+
           attrs = element_attrs(
             id: safe_attr(image, :id),
-            src: src_val,
+            src: image_source(image),
             alt: safe_attr(image, :alt),
             height: safe_attr(image, :height),
             width: safe_attr(image, :width),
@@ -319,21 +459,24 @@ module Metanorma
           render_liquid("_formula.html.liquid", { "block" => drop })
         end
 
+        QUOTE_CHILDREN = {
+          paragraphs: %i[self render_paragraph],
+          ul: %i[self render_unordered_list],
+          ol: %i[self render_ordered_list],
+          dl: %i[self render_definition_list],
+          table: %i[self render_table],
+          formula: %i[self render_formula],
+          note: %i[coordinator render_note],
+          bookmark: %i[coordinator render_bookmark],
+        }.freeze
+
         def render_quote(quote, **_opts)
           attrs = element_attrs(id: safe_attr(quote, :id), class: "quote")
-          content_parts = []
-          quote.paragraphs&.each do |para|
-            content_parts << (render_paragraph(para) || "")
-          end
-          quote.ul&.each do |ul|
-            content_parts << (render_unordered_list(ul) || "")
-          end
-          quote.ol&.each do |ol|
-            content_parts << (render_ordered_list(ol) || "")
-          end
-          content = content_parts.join
+          content = quote_children_html(quote)
           attribution_html = if quote.attribution
                                coordinator.render_mixed_inline(quote.attribution)
+                             else
+                               quote_author_source_attribution(quote)
                              end
           render_liquid("_quote.html.liquid", {
                           "attrs" => attrs,
@@ -342,6 +485,31 @@ module Metanorma
                         })
         end
 
+        def quote_children_html(quote)
+          QUOTE_CHILDREN.flat_map do |attr, (receiver, method)|
+            values = safe_attr(quote, attr)
+            next [] unless values
+
+            target = receiver == :coordinator ? coordinator : self
+            Array(values).map { |child| target.public_send(method, child) || "" }
+          end.join
+        end
+
+        # Quotes carry the attribution as author + source children
+        # (native: "— {author}, {source}").
+        def quote_author_source_attribution(quote)
+          author = safe_attr(safe_attr(quote, :author), :text)
+          source = safe_attr(quote, :source)
+          source_text = if source
+                          rendered = coordinator.render_mixed_inline(source)
+                          rendered.to_s.gsub(/<[^>]+>/, "").strip
+                        end
+          parts = [author, source_text].compact.reject(&:empty?)
+          return nil if parts.empty?
+
+          "— #{parts.join(', ')}"
+        end
+
         def render_admonition(admonition, **_opts)
           drop = Drops::AdmonitionDrop.from_model(admonition,
                                                   renderer: coordinator.renderer_context)
@@ -354,16 +522,33 @@ module Metanorma
                         })
         end
 
-        def render_block_children(model, children:)
+        def render_block_children(model, children:, first_paragraph_label: nil,
+                                 first_paragraph_label_class: nil)
           parts = []
+          label_applied = first_paragraph_label.nil?
+
           children.each do |attr, render_method|
             values = safe_attr(model, attr)
             next if values.nil?
 
             Array(values).each do |v|
-              parts << (public_send(render_method, v) || "")
+              if !label_applied && render_method == :render_paragraph
+                parts << (render_paragraph(v,
+                                           label: first_paragraph_label,
+                                           label_class: first_paragraph_label_class) || "")
+                label_applied = true
+              else
+                parts << (public_send(render_method, v) || "")
+              end
             end
           end
+
+          unless label_applied
+            parts.unshift(render_label_paragraph("",
+                                                 label: first_paragraph_label,
+                                                 label_class: first_paragraph_label_class))
+          end
+
           parts.join
         end
 
@@ -375,8 +560,18 @@ module Metanorma
           render_block_children(model, children: SIMPLE_CHILDREN)
         end
 
-        def render_full_block_children(model)
-          render_block_children(model, children: BLOCK_CHILDREN)
+        # Requirements nested in a block container (conformance-class
+        # requirements inside annex examples) dispatch through the main
+        # renderer's registered requirement render.
+        def render_nested_requirement(req)
+          coordinator.render(req)
+        end
+
+        def render_full_block_children(model, first_paragraph_label: nil,
+                                       first_paragraph_label_class: nil)
+          render_block_children(model, children: BLOCK_CHILDREN,
+                                       first_paragraph_label: first_paragraph_label,
+                                       first_paragraph_label_class: first_paragraph_label_class)
         end
 
         private

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