metanorma-document 0.2.9 → 0.2.12

data/lib/metanorma/html/bipm_renderer.rb

@@ -2,151 +2,22 @@
 
 module Metanorma
   module Html
-    # Renders BipmDocument components to HTML.
-    # Extends IsoRenderer with BIPM-specific branding (institutional navy, scientific precision).
     class BipmRenderer < IsoRenderer
-      def flavor_publishers(_doc_id)
-        ["BIPM"]
-      end
-
-      def flavor_publisher_name
-        "BIPM"
-      end
-
-      def publisher_logo_map
-        { "BIPM" => "bipm-logo.svg" }
-      end
-
-      # Strip redundant publisher prefix from doc identifiers.
-      # XML has "BIPM BIPM-2015/02" but we already show the BIPM logo.
-      def clean_doc_id(raw_id)
-        raw_id.to_s.gsub(/\ABIPM\s+/, "").strip
-      end
-
-      # BIPM logo: white fill for dark header
-      def load_logo_svg(filename, **opts)
-        svg = super
-        svg = svg.gsub("fill:#0f3c80", "fill:white") if svg
-        svg
-      end
-
-      # Strip BIPM prefix from doc IDs shown in header
-      def extract_primary_doc_id
-        raw = super
-        clean_doc_id(raw)
-      end
-
-      # Override cover page to show clean doc ID (without redundant "BIPM " prefix)
-      def render_coverpage(doc)
-        bibdata = doc.bibdata
-        return unless bibdata
-
-        @output << "<div class=\"title-section\">"
-        @output << "<div class=\"cover-grid\">"
-        @output << "<div class=\"cover-meta\">"
-
-        # Publisher logos
-        logos = publisher_logos_html(doc)
-        if logos && !logos.empty?
-          @output << "<div class=\"cover-publishers\">"
-          logos.each do |svg|
-            @output << "<span class=\"cover-logo\">#{svg}</span>"
-          end
-          @output << "</div>"
-        end
-
-        identifiers = Array(bibdata.doc_identifier).compact
-        cover_ids = identifiers.select do |di|
-          safe_attr(di, :type) == "iso-reference"
-        end
-        cover_ids = [identifiers.first].compact if cover_ids.empty?
-
-        cover_ids.each do |di|
-          id = clean_doc_id(extract_text_value(di))
-          next if id.to_s.empty?
-
-          @output << "<p class=\"cover-doc-id\">#{escape_html(id)}</p>"
-        end
-
-        bibdata.date&.each do |date|
-          date_type = extract_text_value(safe_attr(date,
-                                                   :type_attr) || safe_attr(
-                                                     date, :type
-                                                   ))
-          date_val = extract_text_value(date.is_a?(Metanorma::Document::Relaton::BibliographicDate) ? date.on : safe_attr(
-            date, :text
-          ))
-          if date_type == "published" && date_val
-            @output << "<p class=\"cover-date\">#{escape_html(date_val)}</p>"
-          end
-        end
-
-        @output << "</div>"
-        @output << "<div class=\"cover-body\">"
-
-        title_text = extract_display_title(bibdata)
-        if title_text && !title_text.empty?
-          @output << "<div class=\"cover-title\"><span>#{escape_html(title_text)}</span></div>"
-        end
-
-        if bibdata.status&.stage
-          stages = Array(bibdata.status.stage)
-          stage_text = stages.map { |s| Array(s.value).join }.join(" ")
-          unless stage_text.empty?
-            @output << "<div class=\"cover-stage\"><p>#{escape_html(stage_text)}</p></div>"
-          end
-        end
-
-        @output << "</div>"
-        @output << "</div>"
-        @output << "</div><hr class=\"cover-separator\" />"
-      end
-
-      def theme
-        @theme ||= Theme.new.tap do |t|
-          t.primary        = "#0f3c80"
-          t.accent         = "#3d7ec7"
-          t.accent_deep    = "#1a5a9e"
-          t.gradient       = "linear-gradient(135deg, #082247 0%, #0f3c80 50%, #1a5a9e 100%)"
-          t.primary_light  = "#edf1f7"
-          t.accent_light   = "#e8f0fa"
-          t.warm           = "#7a6952"
-          t.warm_light     = "#f5f0e8"
-          t.sidebar_bg     = "#f4f6fa"
-          t.font_body      = '"Crimson Pro", "Georgia", "Times New Roman", serif'
-          t.font_sans      = '"IBM Plex Sans", "Helvetica Neue", Arial, sans-serif'
-          t.font_mono      = '"IBM Plex Mono", "Fira Code", "Courier New", monospace'
-          t.font_url       = "https://fonts.googleapis.com/css2?family=Crimson+Pro:ital,wght@0,300;0,400;0,500;0,600;0,700;1,400&family=IBM+Plex+Sans:ital,wght@0,400;0,500;0,600;0,700;1,400&family=IBM+Plex+Mono:wght@400;500&display=swap"
-          t.header_background = "linear-gradient(135deg, #082247 0%, #0f3c80 50%, #1a5a9e 100%)"
-          t.cover_background  = "linear-gradient(175deg, #04122a 0%, #0a2e5c 25%, #0f3c80 55%, #1a5a9e 80%, #3d7ec7 100%)"
-          t.cover_before_bg   = "background: radial-gradient(ellipse at 25% 15%, rgba(61,126,199,0.15) 0%, transparent 50%), radial-gradient(ellipse at 75% 85%, rgba(15,60,128,0.18) 0%, transparent 40%), radial-gradient(circle at 50% 50%, rgba(255,255,255,0.02) 0%, transparent 70%)"
-          t.cover_after_bg    = "height: 3px; background: linear-gradient(90deg, transparent, #3d7ec7 20%, #0f3c80 50%, #3d7ec7 80%, transparent)"
-          t.progress_bar_color = "#3d7ec7"
-          t.note_border     = "#3d7ec7"
-          t.note_bg         = "#edf1f7"
-          t.note_color      = "#3d7ec7"
-          t.example_border  = "#0f3c80"
-          t.example_bg      = "#f5f0e8"
-          t.example_color   = "#7a6952"
-          t.admonition_border = "#7a6952"
-          t.admonition_bg = "#f5f0e8"
-          t.admonition_color = "#7a6952"
-          t.footer_border_color = "#3d7ec7"
-          t.cover_separator_color = "rgba(61,126,199,0.25)"
-          t.dark_note_bg    = "#0d1520"
-          t.dark_example_bg = "#14100e"
-          t.dark_admonition_bg = "#141210"
-          t.extra_css = <<~CSS
-            .sourcecode pre { background: #0a1628; border-color: #1a2d4a; }
-            .reading-progress { box-shadow: 0 0 10px rgba(61,126,199,0.4); }
-            mark.search-match { background: #edf1f7; box-shadow: 0 0 0 1px rgba(15,60,128,0.25); }
-            mark.search-match.search-current { background: #3d7ec7; color: #fff; }
-            [data-theme="dark"] .sourcecode pre { background: #060a14; border-color: #1a2040; }
-            [data-theme="dark"] mark.search-match { background: #0d1a30; box-shadow: 0 0 0 1px rgba(61,126,199,0.4); }
-            [data-theme="dark"] mark.search-match.search-current { background: #1a5a9e; }
-          CSS
-        end
-      end
+      register_render Metanorma::BipmDocument::Root, :render_document
+      register_render Metanorma::StandardDocument::Sections::Preface,
+                      :render_preface
+      register_render Metanorma::StandardDocument::Sections::ClauseSection,
+                      :render_clause
+      register_render Metanorma::StandardDocument::Sections::AnnexSection,
+                      :render_annex
+      register_render Metanorma::StandardDocument::Sections::ContentSection,
+                      :render_clause
+      register_render Metanorma::StandardDocument::Sections::TermsSection,
+                      :render_terms_section
+      register_render Metanorma::StandardDocument::Sections::BibliographySection,
+                      :render_clause
+      register_render Metanorma::StandardDocument::Sections::DefinitionSection,
+                      :render_clause
     end
   end
 end

data/lib/metanorma/html/cc_renderer.rb

@@ -2,52 +2,8 @@
 
 module Metanorma
   module Html
-    # Renders CcDocument (CalConnect) components to HTML.
-    # Extends IsoRenderer with CalConnect branding.
     class CcRenderer < IsoRenderer
-      def flavor_publishers(_doc_id)
-        ["CalConnect"]
-      end
-
-      def flavor_publisher_name
-        "CalConnect"
-      end
-
-      def publisher_logo_map
-        {}
-      end
-
-      def theme
-        @theme ||= Theme.new.tap do |t|
-          t.font_body      = '"Lora", "Georgia", serif'
-          t.font_sans      = '"Karla", "Helvetica Neue", Arial, sans-serif'
-          t.font_mono      = '"JetBrains Mono", "Fira Code", monospace'
-          t.font_url       = "https://fonts.googleapis.com/css2?family=Lora:ital,wght@0,400;0,500;0,600;0,700;1,400&family=Karla:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap"
-          t.primary        = "#003d7c"
-          t.accent         = "#0078d4"
-          t.accent_deep    = "#005fa3"
-          t.gradient       = "linear-gradient(135deg, #002244 0%, #003d7c 50%, #0078d4 100%)"
-          t.primary_light  = "#edf3fa"
-          t.accent_light   = "#e0effc"
-          t.warm           = "#c9982e"
-          t.warm_light     = "#fdf8ec"
-          t.header_background = "linear-gradient(135deg, #002244 0%, #003d7c 50%, #0078d4 100%)"
-          t.cover_background  = "linear-gradient(175deg, #001a33 0%, #003d7c 40%, #0078d4 80%, #0092d6 100%)"
-          t.cover_before_bg   = "background: radial-gradient(ellipse at 25% 15%, rgba(0,120,212,0.2) 0%, transparent 50%), radial-gradient(ellipse at 75% 85%, rgba(201,152,46,0.15) 0%, transparent 40%)"
-          t.cover_after_bg    = "height: 3px; background: linear-gradient(90deg, transparent, #c9982e, transparent)"
-          t.progress_bar_color = "#0078d4"
-          t.note_border     = "#0078d4"
-          t.note_bg         = "#e0effc"
-          t.note_color      = "#0078d4"
-          t.example_border  = "#003d7c"
-          t.example_bg      = "#edf3fa"
-          t.example_color   = "#003d7c"
-          t.admonition_border = "#c9982e"
-          t.admonition_color  = "#c9982e"
-          t.footer_border_color = "#0078d4"
-          t.cover_separator_color = "rgba(0,120,212,0.25)"
-        end
-      end
+      register_render Metanorma::CcDocument::Root, :render_document
     end
   end
 end

data/lib/metanorma/html/component/base.rb

@@ -38,11 +38,6 @@ module Metanorma
           raise NotImplementedError, "#{self.class}#render not implemented"
         end
 
-        def output
-          renderer.instance_variable_get(:@output)
-        end
-
-        def tag(...) = renderer.tag(...)
         def escape_html(...) = renderer.escape_html(...)
         def render_mixed_inline(...) = renderer.render_mixed_inline(...)
         def render_mixed_content_in_order(...) = renderer.render_mixed_content_in_order(...)
@@ -50,9 +45,9 @@ module Metanorma
         def safe_attr(obj, method_name) = renderer.safe_attr(obj, method_name)
         def extract_plain_text(node) = renderer.extract_plain_text(node)
         def extract_text_value(val) = renderer.extract_text_value(val)
+        def render_liquid(...) = renderer.render_liquid(...)
 
-        def extract_block_label(block,
-default)
+        def extract_block_label(block, default)
           renderer.extract_block_label(block, default)
         end
 

data/lib/metanorma/html/component/index_section.rb

@@ -7,24 +7,28 @@ module Metanorma
         def render(collector, **_opts)
           return if collector.nil? || collector.empty?
 
-          output << tag(:div,
-                        %( id="index" class="index-section" data-component="index")) do
-            html = tag(:h2) { "Index" }
-            html << render_quicknav(collector.sorted_groups)
-            html << render_letter_groups(collector.sorted_groups)
-            html
-          end
+          quicknav = render_quicknav(collector.sorted_groups)
+          letter_groups = render_letter_groups(collector.sorted_groups)
+          content = quicknav + letter_groups
+
+          attrs = %( id="index" class="index-section" data-component="index")
+          index_html = render_liquid("_element.html.liquid", "tag" => "div",
+                                                             "extra_attrs" => attrs, "content" => content)
 
           renderer.register_toc_entry(id: "index", level: 1, text: "Index")
+          index_html
         end
 
         private
 
         def render_quicknav(groups)
           links = groups.filter_map do |g|
-            %(<a href="#index-letter-#{escape_html(g.letter)}">#{escape_html(g.letter)}</a>)
+            letter = escape_html(g.letter)
+            render_liquid("_link.html.liquid",
+                          "attrs" => %( href="#index-letter-#{letter}"), "display_text" => letter)
           end.join
-          %(<div class="index-quicknav">#{links}</div>)
+          render_liquid("_element.html.liquid", "tag" => "div",
+                                                "extra_attrs" => " class=\"index-quicknav\"", "content" => links)
         end
 
         def render_letter_groups(groups)
@@ -32,54 +36,48 @@ module Metanorma
         end
 
         def render_letter_group(group)
-          tag(:div,
-              %( class="index-letter-group" id="index-letter-#{escape_html(group.letter)}")) do
-            html = tag(:h3, %( class="index-letter")) { group.letter }
-            html << group.entries.map { |e| render_entry(e, "primary") }.join
-            html
-          end
+          letter = escape_html(group.letter)
+          heading = render_liquid("_heading.html.liquid", "tag" => "h3",
+                                                          "class_attr" => " class=\"index-letter\"", "content" => letter)
+          entries = group.entries.map { |e| render_entry(e, "primary") }.join
+          render_liquid("_element.html.liquid", "tag" => "div",
+                                                "extra_attrs" => %( class="index-letter-group" id="index-letter-#{letter}"), "content" => "#{heading}#{entries}")
         end
 
         def render_entry(entry, level)
-          tag(:div, %( class="index-entry index-entry--#{level}")) do
-            html = +""
-            html << tag(:span, %( class="index-term")) do
-              escape_html(entry.term)
-            end
-            html << render_locators(entry.locators)
-            html << render_see(entry.see) if entry.see
-            html << render_see_also(entry.see_also_entries) unless entry.see_also_entries.empty?
-            unless entry.children.empty?
-              html << entry.children.map { |c|
-                render_entry(c, next_level(level))
-              }.join
-            end
-            html
+          term_html = render_liquid("_element.html.liquid", "tag" => "span",
+                                                            "extra_attrs" => " class=\"index-term\"", "content" => escape_html(entry.term))
+          locators_html = render_locators(entry.locators)
+          inner = term_html + locators_html
+          inner << render_see(entry.see) if entry.see
+          inner << render_see_also(entry.see_also_entries) unless entry.see_also_entries.empty?
+          unless entry.children.empty?
+            inner << entry.children.map { |c|
+              render_entry(c, next_level(level))
+            }.join
           end
+          render_liquid("_element.html.liquid", "tag" => "div",
+                                                "extra_attrs" => %( class="index-entry index-entry--#{level}"), "content" => inner)
         end
 
         def render_locators(locators)
           links = locators.map do |loc|
-            tag(:a, %( href="##{escape_html(loc.id)}")) do
-              escape_html(loc.text)
-            end
-          end
-          tag(:span, %( class="index-locator")) { links.join(", ") }
+            render_liquid("_link.html.liquid",
+                          "attrs" => %( href="##{escape_html(loc.id)}"), "display_text" => escape_html(loc.text))
+          end.join(", ")
+          render_liquid("_element.html.liquid", "tag" => "span",
+                                                "extra_attrs" => " class=\"index-locator\"", "content" => links)
         end
 
         def render_see(term)
-          tag(:div, %( class="index-see")) do
-            "<em>see</em> #{escape_html(term)}"
-          end
+          render_liquid("_element.html.liquid", "tag" => "div",
+                                                "extra_attrs" => " class=\"index-see\"", "content" => "<em>see</em> #{escape_html(term)}")
         end
 
         def render_see_also(terms)
-          tag(:div,
-              %( class="index-see-also")) do
-            "<em>see also</em> #{terms.map do |t|
-              escape_html(t)
-            end.join(', ')}"
-          end
+          text = terms.map { |t| escape_html(t) }.join(", ")
+          render_liquid("_element.html.liquid", "tag" => "div",
+                                                "extra_attrs" => " class=\"index-see-also\"", "content" => "<em>see also</em> #{text}")
         end
 
         def next_level(level)

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

@@ -8,10 +8,7 @@ module Metanorma
           type = renderer.safe_attr(admonition, :type) || "note"
           id = renderer.safe_attr(admonition, :id)
 
-          content_html = renderer.capture_output do
-            renderer.render_block_children(admonition,
-                                           children: BaseRenderer::SIMPLE_CHILDREN)
-          end
+          content_html = renderer.render_simple_children(admonition) || ""
 
           new(
             id: id,

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Drops
+      class BiblioEntryDrop < Liquid::Drop
+        def initialize(attrs)
+          @id = attrs[:id]
+          @css_class = attrs[:css_class]
+          @ordinal_html = attrs[:ordinal_html]
+          @pubid_html = attrs[:pubid_html]
+          @url = attrs[:url]
+          @content_html = attrs[:content_html]
+        end
+
+        def id
+          @id
+        end
+
+        def css_class
+          @css_class
+        end
+
+        def ordinal_html
+          @ordinal_html
+        end
+
+        def pubid_html
+          @pubid_html
+        end
+
+        def url
+          @url
+        end
+
+        def content_html
+          @content_html
+        end
+
+        def has_ordinal
+          !@ordinal_html.nil? && !@ordinal_html.empty?
+        end
+
+        def has_url
+          !@url.nil? && !@url.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -6,8 +6,13 @@ module Metanorma
       class BlockElementDrop < Liquid::Drop
         attr_reader :id, :type, :label_html, :content_html, :css_class
 
-        def initialize(attrs = {})
-          attrs.each { |k, v| instance_variable_set(:"@#{k}", v) }
+        def initialize(id: nil, type: nil, label_html: nil, content_html: nil,
+css_class: nil)
+          @id = id
+          @type = type
+          @label_html = label_html
+          @content_html = content_html
+          @css_class = css_class
         end
 
         # Subclasses override to build from model + RendererContext

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

@@ -8,10 +8,7 @@ module Metanorma
           id = renderer.safe_attr(example, :id)
           label = renderer.extract_block_label(example, "EXAMPLE")
 
-          content_html = renderer.capture_output do
-            renderer.render_block_children(example,
-                                           children: BaseRenderer::BLOCK_CHILDREN)
-          end
+          content_html = renderer.render_full_block_children(example) || ""
 
           new(
             id: id,

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

@@ -6,6 +6,16 @@ module Metanorma
       class FigureDrop < BlockElementDrop
         attr_reader :image_html, :caption_html, :key_html, :sub_figures_html
 
+        def initialize(id: nil, image_html: nil, caption_html: nil, key_html: nil,
+                       sub_figures_html: nil, css_class: nil)
+          @id = id
+          @image_html = image_html
+          @caption_html = caption_html
+          @key_html = key_html
+          @sub_figures_html = sub_figures_html
+          @css_class = css_class
+        end
+
         def self.from_model(figure, renderer:)
           id = renderer.safe_attr(figure, :id)
           fig_name = renderer.safe_attr(figure,
@@ -17,35 +27,34 @@ module Metanorma
                                            text: renderer.extract_plain_text(fig_name))
           end
 
-          image_html = renderer.capture_output do
-            if figure.image
-              renderer.render_image(figure.image)
-            elsif renderer.safe_attr(figure, :source)
-              src = renderer.safe_attr(figure, :source)
-              @output << %(<img src="#{renderer.escape_html(src)}" />)
-            end
-          end
+          image_html = if figure.image
+                         renderer.render_image(figure.image)
+                       elsif renderer.safe_attr(figure, :source)
+                         src = renderer.safe_attr(figure, :source)
+                         renderer.render_liquid("_image.html.liquid",
+                                                "attrs" => %( src="#{renderer.escape_html(src)}"))
+                       end
 
           caption_html = if fig_name || renderer.safe_attr(figure, :name)
-                           renderer.capture_output do
-                             el = renderer.safe_attr(figure,
-                                                     :fmt_name) || figure.name
-                             renderer.render_inline_element(el)
-                           end
+                           el = renderer.safe_attr(figure,
+                                                   :fmt_name) || figure.name
+                           renderer.render_inline_element(el)
                          end
 
-          sub_figures_html = renderer.capture_output do
-            figure.figure&.each { |sub| renderer.render_figure(sub) }
+          sub_figures_parts = []
+          figure.figure&.each do |sub|
+            sub_figures_parts << (renderer.render_figure(sub) || "")
           end
+          sub_figures_html = sub_figures_parts.join
 
-          key_html = renderer.capture_output do
-            renderer.safe_attr(figure, :note)&.each do |n|
-              renderer.render_note(n)
-            end
-            renderer.safe_attr(figure, :dl)&.then do |dl|
-              renderer.render_definition_list(dl)
-            end
+          key_parts = []
+          renderer.safe_attr(figure, :note)&.each do |n|
+            key_parts << (renderer.render_note(n) || "")
+          end
+          renderer.safe_attr(figure, :dl)&.then do |dl|
+            key_parts << (renderer.render_definition_list(dl) || "")
           end
+          key_html = key_parts.join
 
           new(
             id: id,

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

@@ -13,7 +13,7 @@ module Metanorma
           @entry.number
         end
 
-        def reference
+        def label
           @entry.reference
         end
 

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

@@ -4,45 +4,74 @@ module Metanorma
   module Html
     module Drops
       class FormulaDrop < BlockElementDrop
-        attr_reader :stem_html, :where_html, :number_html
+        attr_reader :stem_html, :where_html, :where_label, :number_html
+
+        def initialize(id: nil, stem_html: nil, where_html: nil, where_label: nil,
+                       number_html: nil, css_class: nil)
+          @id = id
+          @stem_html = stem_html
+          @where_html = where_html
+          @where_label = where_label
+          @number_html = number_html
+          @css_class = css_class
+        end
 
         def self.from_model(formula, renderer:)
           id = renderer.safe_attr(formula, :id)
 
-          stem_html = renderer.capture_output do
-            renderer.render_stem_content(formula.stem) if formula.stem
-          end
+          stem_html = if formula.stem
+                        renderer.render_stem_content(formula.stem)
+                      end
 
-          where_html = renderer.capture_output do
-            if formula.key
-              if formula.key.dl
-                @output = renderer.capture_output {}
-                # "where" label rendered in template, just render the dl
-                renderer.render_definition_list(formula.key.dl)
-              end
-              formula.key.p&.each { |para| renderer.render_paragraph(para) }
+          where_parts = []
+          if formula.key
+            if formula.key.dl
+              where_parts << (renderer.render_definition_list(formula.key.dl) || "")
+            end
+            formula.key.p&.each do |para|
+              where_parts << (renderer.render_paragraph(para) || "")
             end
-            formula.dl&.then { |dl| renderer.render_definition_list(dl) }
           end
+          formula.dl&.then do |dl|
+            where_parts << (renderer.render_definition_list(dl) || "")
+          end
+          formula.p&.each do |para|
+            next if renderer.safe_attr(para, :keep_with_next)
+
+            where_parts << (renderer.render_paragraph(para) || "")
+          end
+          where_html = where_parts.join
+
+          needs_where_label = !formula.key.nil? || !formula.dl.nil? ||
+            has_where_paragraph?(formula, renderer)
 
           name_el = renderer.safe_attr(formula,
                                        :fmt_name) || renderer.safe_attr(
                                          formula, :name
                                        )
           number_html = if name_el
-                          renderer.capture_output do
-                            renderer.render_inline_element(name_el)
-                          end
+                          renderer.render_inline_element(name_el)
                         end
 
           new(
             id: id,
             stem_html: stem_html,
             where_html: where_html,
+            where_label: needs_where_label,
             number_html: number_html,
             css_class: "formula",
           )
         end
+
+        class << self
+          private
+
+          def has_where_paragraph?(formula, renderer)
+            Array(formula.p).any? do |para|
+              renderer.safe_attr(para, :keep_with_next)
+            end
+          end
+        end
       end
     end
   end