metanorma-document 0.2.0

data/lib/metanorma/html/bipm_renderer.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    # Renders BipmDocument components to HTML.
+    # Extends IsoRenderer with BIPM-specific branding (institutional navy, scientific precision).
+    class BipmRenderer < IsoRenderer
+      registers_doc_type Metanorma::BipmDocument::Root
+
+      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 { |svg| @output << "<span class=\"cover-logo\">#{svg}</span>" }
+          @output << "</div>"
+        end
+
+        identifiers = Array(bibdata.doc_identifier).compact
+        cover_ids = identifiers.select { |di| safe_attr(di, :type) == "iso-reference" }
+        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 && 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
+    end
+  end
+end

data/lib/metanorma/html/cc_renderer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    # Renders CcDocument (CalConnect) components to HTML.
+    # Extends IsoRenderer with CalConnect branding.
+    class CcRenderer < IsoRenderer
+      registers_doc_type Metanorma::CcDocument::Root
+
+      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
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Component
+      class Base
+        attr_reader :renderer
+
+        def initialize(renderer)
+          @renderer = renderer
+        end
+
+        def self.handles(*model_classes)
+          @handled_classes = model_classes
+        end
+
+        def self.handled_classes
+          @handled_classes || []
+        end
+
+        def self.requires_css(*names)
+          @css_deps = names
+        end
+
+        def self.css_dependencies
+          @css_deps || []
+        end
+
+        def self.requires_js(*names)
+          @js_deps = names
+        end
+
+        def self.js_dependencies
+          @js_deps || []
+        end
+
+        def render(node, **opts)
+          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(...)
+        def element_attrs(...) = renderer.element_attrs(...)
+        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 extract_block_label(block, default) = renderer.extract_block_label(block, default)
+
+        def self.register_in(registry)
+          handled_classes.each do |klass|
+            registry.register(klass, self)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Component
+      # Collects footnote content encountered during rendering.
+      # Deduplicates by reference letter/number so each footnote definition
+      # appears once, even when referenced from multiple locations.
+      class FootnoteCollector
+        def initialize
+          @footnotes = []
+          @ref_map = {}
+          @id_map = {}
+        end
+
+        # Register a footnote and return its sequential number.
+        # Deduplicates by reference: same reference = same footnote number.
+        def register(fn)
+          fn_id = fn.id || fn.reference.to_s
+          ref = fn.reference.to_s
+
+          # If we've seen this reference before, reuse its number
+          if @ref_map.key?(ref)
+            return @ref_map[ref]
+          end
+
+          number = @footnotes.size + 1
+          @ref_map[ref] = number
+          @id_map[fn_id] = number
+          @footnotes << FootnoteEntry.new(
+            id: fn_id,
+            number: number,
+            reference: ref,
+            content: fn.p,
+            fmt_label: fn.fmt_fn_label
+          )
+          number
+        end
+
+        def empty?
+          @footnotes.empty?
+        end
+
+        def each(&blk)
+          @footnotes.each(&blk)
+        end
+
+        def to_a
+          @footnotes
+        end
+      end
+
+      FootnoteEntry = Struct.new(:id, :number, :reference, :content, :fmt_label,
+                                 keyword_init: true)
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Component
+      class IndexSection < Base
+        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
+
+          renderer.register_toc_entry(id: "index", level: 1, text: "Index")
+        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>)
+          end.join
+          %(<div class="index-quicknav">#{links}</div>)
+        end
+
+        def render_letter_groups(groups)
+          groups.map { |g| render_letter_group(g) }.join
+        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
+        end
+
+        def render_entry(entry, level)
+          tag(:div, %( class="index-entry index-entry--#{level}")) do
+            html = +""
+            html << tag(:span, %( class="index-term")) { escape_html(entry.term) }
+            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?
+            html << entry.children.map { |c| render_entry(c, next_level(level)) }.join unless entry.children.empty?
+            html
+          end
+        end
+
+        def render_locators(locators)
+          links = locators.map do |loc|
+            tag(:a, %( href="##{escape_html(loc.id)}")) { escape_html(loc.text) }
+          end
+          tag(:span, %( class="index-locator")) { links.join(", ") }
+        end
+
+        def render_see(term)
+          tag(:div, %( class="index-see")) { "<em>see</em> #{escape_html(term)}" }
+        end
+
+        def render_see_also(terms)
+          tag(:div, %( class="index-see-also")) { "<em>see also</em> #{terms.map { |t| escape_html(t) }.join(', ')}" }
+        end
+
+        def next_level(level)
+          { "primary" => "secondary", "secondary" => "tertiary" }[level] || "tertiary"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Component
+      class IndexTermCollector
+        def initialize
+          @terms = []
+        end
+
+        def add(primary:, secondary: nil, tertiary: nil,
+                see: nil, see_also: nil, target_id: nil, target_text: nil)
+          @terms << IndexTerm.new(
+            primary: primary,
+            secondary: secondary,
+            tertiary: tertiary,
+            see: see,
+            see_also: see_also,
+            target_id: target_id,
+            target_text: target_text
+          )
+        end
+
+        def empty?
+          @terms.empty?
+        end
+
+        def sorted_groups
+          grouped = @terms
+            .group_by { |t| t.primary[0].upcase }
+            .sort_by { |letter, _| letter }
+
+          grouped.map do |letter, terms|
+            IndexLetterGroup.new(letter: letter, entries: merge_entries(terms))
+          end
+        end
+
+        private
+
+        def merge_entries(terms)
+          primary_map = {}
+          terms.each do |term|
+            key = term.primary.downcase
+            primary_map[key] ||= IndexEntry.new(term: term.primary)
+            entry = primary_map[key]
+            entry.add_locator(term.target_id, term.target_text)
+            entry.see ||= term.see
+            entry.add_see_also(term.see_also) if term.see_also
+
+            if term.secondary
+              sec = entry.find_or_add_child(term.secondary)
+              sec.add_locator(term.target_id, term.target_text)
+
+              if term.tertiary
+                ter = sec.find_or_add_child(term.tertiary)
+                ter.add_locator(term.target_id, term.target_text)
+              end
+            end
+          end
+
+          primary_map.values.sort_by { |e| e.term.downcase }
+        end
+      end
+
+      IndexTerm = Struct.new(:primary, :secondary, :tertiary,
+                             :see, :see_also, :target_id, :target_text,
+                             keyword_init: true)
+
+      IndexEntry = Struct.new(:term, :locators, :see, :see_also_entries, :children,
+                               keyword_init: true) do
+        def initialize(*)
+          super
+          self.locators ||= []
+          self.see_also_entries ||= []
+          self.children ||= []
+        end
+
+        def add_locator(id, text)
+          locators << IndexLocator.new(id: id, text: text) if id && !locators.any? { |l| l.id == id }
+        end
+
+        def add_see_also(term)
+          see_also_entries << term if term
+        end
+
+        def find_or_add_child(term_name)
+          existing = children.find { |c| c.term.downcase == term_name.downcase }
+          existing || begin
+            child = IndexEntry.new(term: term_name)
+            children << child
+            child
+          end
+        end
+      end
+
+      IndexLocator = Struct.new(:id, :text, keyword_init: true)
+      IndexLetterGroup = Struct.new(:letter, :entries, keyword_init: true)
+    end
+  end
+end

data/lib/metanorma/html/component.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Component
+      autoload :Base, "metanorma/html/component/base"
+      autoload :IndexTermCollector, "metanorma/html/component/index_term_collector"
+      autoload :IndexSection, "metanorma/html/component/index_section"
+      autoload :FootnoteCollector, "metanorma/html/component/footnote_collector"
+    end
+  end
+end

data/lib/metanorma/html/component_registry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    class ComponentRegistry
+      def initialize
+        @map = {}
+      end
+
+      def register(model_class, component_class)
+        @map[model_class] = component_class
+      end
+
+      def lookup(model_class)
+        @map[model_class] ||
+          model_class.ancestors
+            .drop(1)
+            .filter_map { |a| @map[a] }
+            .first ||
+          nil
+      end
+
+      def component_for(renderer, model_class)
+        component_class = lookup(model_class)
+        component_class&.new(renderer)
+      end
+
+      def register_all(component_module)
+        component_module.constants.each do |const|
+          klass = component_module.const_get(const)
+          next unless klass.is_a?(Class) && klass < Component::Base
+          klass.register_in(self)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Drops
+      class FootnoteDrop < Liquid::Drop
+        def initialize(entry, content_html)
+          @entry = entry
+          @content_html = content_html
+        end
+
+        def number
+          @entry.number
+        end
+
+        def reference
+          @entry.reference
+        end
+
+        def content_html
+          @content_html
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/drops.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Drops
+      autoload :FootnoteDrop, "metanorma/html/drops/footnote_drop"
+    end
+  end
+end