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

data/lib/metanorma/html/drops/sourcecode_drop.rb

@@ -4,23 +4,26 @@ module Metanorma
   module Html
     module Drops
       class SourcecodeDrop < BlockElementDrop
-        attr_reader :lang, :name_html, :code_html
+        attr_reader :lang, :name_html, :code_html, :annotations_html
 
         def initialize(id: nil, lang: nil, name_html: nil, code_html: nil,
-css_class: nil)
+css_class: nil, annotations_html: nil)
           @id = id
           @lang = lang
           @name_html = name_html
           @code_html = code_html
           @css_class = css_class
+          @annotations_html = annotations_html
         end
 
         def self.from_model(sc, renderer:)
           id = renderer.safe_attr(sc, :id)
           lang = renderer.safe_attr(sc, :lang)
 
-          name_html = if sc.name
-                        renderer.render_inline_element(sc.name)
+          name_html = if renderer.safe_attr(sc, :fmt_name) || sc.name
+                        renderer.render_inline_element(
+                          renderer.safe_attr(sc, :fmt_name) || sc.name,
+                        )
                       end
 
           code_text = if sc.body
@@ -37,8 +40,23 @@ css_class: nil)
             name_html: name_html,
             code_html: renderer.escape_html(code_text),
             css_class: "sourcecode",
+            annotations_html: annotations_key_html(sc, renderer),
           )
         end
+
+        # Callout annotations render as a Key definition list under the
+        # code, like the native isodoc figdl block. Callouts are numbered
+        # in document order.
+        def self.annotations_key_html(sc, renderer)
+          annotations = Array(renderer.safe_attr(sc, :callout_annotations))
+          return nil if annotations.empty?
+
+          rows = annotations.each_with_index.map do |ann, i|
+            dd = Array(ann.p).map { |para| renderer.render_paragraph(para) }.join
+            %(<dt><span class="c">#{i + 1}</span></dt><dd>#{dd}</dd>)
+          end
+          rows.join
+        end
       end
     end
   end

data/lib/metanorma/html/generator.rb

@@ -3,197 +3,21 @@
 module Metanorma
   module Html
     class Generator
-      @tastes = []
-      @setup = false
-
       class << self
-        # 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.
-        def register_taste(model_class, publisher_abbrev, renderer_class)
-          @tastes << [model_class, publisher_abbrev, renderer_class]
-        end
-
+        # The HTML format adapter over the central flavor registry.
+        # Renderer selection: the most-specific matching flavor that
+        # provides an :html renderer wins (Proc values are flavor-owned
+        # variant resolvers — publisher/doctype/profile selection); with
+        # no flavor match, the harness default by ancestry. Options are
+        # per-call runtime knobs threaded to the resolver.
         def generate(document, **)
-          setup! unless @setup
-          renderer_for(document).new.generate_full_document(document, **)
-        end
-
-        def renderer_for(document)
-          setup! unless @setup
-
-          taste_renderer = find_taste(document)
-          return taste_renderer if taste_renderer
-
-          flavor = @flavors.find_for(document.class)
-          flavor&.renderer_class || BaseRenderer
-        end
-
-        private
-
-        def find_taste(document)
-          @tastes.each do |model_class, publisher_abbrev, renderer_class|
-            next unless document.is_a?(model_class)
-            return renderer_class if taste_publisher?(document,
-                                                      publisher_abbrev)
-          end
-          nil
-        end
-
-        def taste_publisher?(document, abbrev)
-          bibdata = document.bibdata if document.is_a?(Lutaml::Model::Serializable)
-          return false unless bibdata
-
-          contributors = bibdata.contributor
-          return false unless contributors
-
-          contributors.any? do |c|
-            roles = c.role
-            next false unless roles.is_a?(Array)
-            next false unless roles.any? { |r| r&.type == "author" }
-
-            org = c.organization
-            next false unless org
-
-            org_abbrev = org.abbreviation
-            if org_abbrev.is_a?(String)
-              org_abbrev == abbrev
-            elsif org_abbrev.is_a?(Lutaml::Model::Serializable)
-              safe_attr(org_abbrev, :content) == abbrev
-            else
-              org_abbrev.to_s == abbrev
-            end
-          end
+          renderer_for(document, **)
+            .new.generate_full_document(document, **)
         end
 
-        def setup!
-          return if @setup
-
-          @setup = true
-          @flavors = build_flavor_registry
-
-          # Trigger autoloads by referencing constants
-          BaseRenderer
-          StandardRenderer
-          IsoRenderer
-          BipmRenderer
-          CcRenderer
-          CsaRenderer
-          IccRenderer
-          IecRenderer
-          IeeeRenderer
-          IetfRenderer
-          IhoRenderer
-          ItuRenderer
-          OgcRenderer
-          PdfaRenderer
-          RiboseRenderer
-
-          # Register tastes (publisher-based dispatch within same model)
-          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: :csa,
-                                model_class: Metanorma::CsaDocument::Root,
-                                renderer_class: CsaRenderer,
-                                pubid_module: :"Pubid::Csa",
-                              ))
-            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::Itu",
-                              ))
-            registry.register(Flavor.new(
-                                name: :ogc,
-                                model_class: Metanorma::OgcDocument::Root,
-                                renderer_class: OgcRenderer,
-                              ))
-            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)
+        def renderer_for(document, **)
+          Metanorma::Core::Flavors.renderer_for(document, format: :html,
+                                                          **) || BaseRenderer
         end
       end
     end

data/lib/metanorma/html/renderer_delegation.rb

@@ -12,9 +12,9 @@ module Metanorma
     module RendererDelegation
       def safe_attr(...)        = @renderer.safe_attr(...)
       def escape_html(...)      = @renderer.escape_html(...)
-      def extract_block_label(...)= @renderer.extract_block_label(...)
+      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_mixed_inline(...) = @renderer.render_mixed_inline(...)
       def render_liquid(...) = @renderer.render_liquid(...)
     end
   end

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,12 +27,35 @@ 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
@@ -78,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,
@@ -109,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
@@ -175,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)
@@ -206,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)
@@ -251,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)
@@ -263,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),
@@ -334,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,
@@ -357,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)
@@ -407,6 +560,13 @@ module Metanorma
           render_block_children(model, children: SIMPLE_CHILDREN)
         end
 
+        # 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,