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

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

@@ -4,11 +4,18 @@ module Metanorma
   module Html
     module Drops
       class ExampleDrop < BlockElementDrop
+        LABEL_CLASS = "example-label"
+        private_constant :LABEL_CLASS
+
         def self.from_model(example, renderer:)
           id = renderer.safe_attr(example, :id)
           label = renderer.extract_block_label(example, "EXAMPLE")
 
-          content_html = renderer.render_full_block_children(example) || ""
+          content_html = renderer.render_full_block_children(
+            example,
+            first_paragraph_label: label,
+            first_paragraph_label_class: LABEL_CLASS,
+          ) || ""
 
           new(
             id: id,

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

@@ -14,7 +14,7 @@ module Metanorma
         end
 
         def label
-          @entry.reference
+          @entry.fmt_label.to_s.empty? ? @entry.reference : @entry.fmt_label
         end
 
         def content_html

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

@@ -4,26 +4,53 @@ module Metanorma
   module Html
     module Drops
       class NoteDrop < BlockElementDrop
+        LABEL_CLASS = "note-label"
+        private_constant :LABEL_CLASS
+
         def self.from_model(note, renderer:)
           id = renderer.safe_attr(note, :id)
           label = renderer.extract_block_label(note, "NOTE")
 
           content_parts = []
+          label_rendered = label.nil?
+
           if note.content && !note.content.empty?
             note.content.each do |para|
-              content_parts << (renderer.render_paragraph(para) || "")
+              if label_rendered
+                content_parts << (renderer.render_paragraph(para) || "")
+              else
+                content_parts << (renderer.render_paragraph(para,
+                                                            label: label,
+                                                            label_class: LABEL_CLASS) || "")
+                label_rendered = true
+              end
             end
           else
             inline = renderer.render_mixed_inline(note)
-            content_parts << inline if inline
+            if inline
+              if label_rendered
+                content_parts << inline
+              else
+                content_parts << renderer.render_label_paragraph(inline,
+                                                                 label: label,
+                                                                 label_class: LABEL_CLASS)
+                label_rendered = true
+              end
+            end
           end
+
           content_parts << (renderer.render_note_children(note) || "")
-          content_html = content_parts.join
+
+          if !label_rendered
+            content_parts.unshift(renderer.render_label_paragraph("",
+                                                                  label: label,
+                                                                  label_class: LABEL_CLASS))
+          end
 
           new(
             id: id,
             label_html: renderer.escape_html(label),
-            content_html: content_html,
+            content_html: content_parts.join,
             css_class: "note-block",
           )
         end

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