metanorma-document 0.2.12 → 0.4.0

data/lib/metanorma/html/concerns/presentation_validation.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Concerns
+      # Presentation-XML validation mixed into BaseRenderer. HTML
+      # generation requires Presentation XML input — semantic XML does not
+      # contain the formatting data needed for HTML — so the document is
+      # checked for presentation markers before rendering begins.
+      module PresentationValidation
+        def validate_presentation_xml!
+          has_presentation = check_presentation_markers(@document)
+          return if has_presentation
+
+          raise ArgumentError,
+                "HTML generation requires Presentation XML input. " \
+                "Semantic XML does not contain formatting data needed for HTML. " \
+                "Use a '.presentation.xml' file instead."
+        end
+
+        # Name kept for API stability (public renderer API); the boolean
+        # return predates the Naming/PredicateMethod convention.
+        # rubocop:disable Naming/PredicateMethod
+        def check_presentation_markers(node)
+          return false unless node
+          return false if node.is_a?(String)
+
+          if node.is_a?(Lutaml::Model::Serializable)
+            node_attrs = node.class.attributes
+            if node_attrs.key?(:type) && node.type == "presentation"
+              return true
+            end
+            if node_attrs.key?(:fmt_title) && node.fmt_title
+              return true
+            end
+            if node_attrs.key?(:displayorder) && node.displayorder
+              return true
+            end
+
+            %i[preface sections annex bibliography].each do |attr|
+              next unless node_attrs.key?(attr)
+
+              val = node.public_send(attr)
+              next unless val
+
+              Array(val).each { |v| return true if check_presentation_markers(v) }
+            end
+
+            node.each_mixed_content do |child|
+              next if child.is_a?(String)
+              return true if check_presentation_markers(child)
+            end
+          end
+
+          false
+        end
+        # rubocop:enable Naming/PredicateMethod
+      end
+    end
+  end
+end

data/lib/metanorma/html/concerns/svg_processing.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Concerns
+      # SVG logo loading and normalization mixed into BaseRenderer.
+      # Logos ship as standalone SVG files; for inline embedding the xml
+      # prolog and leading comments are stripped, a CSS class is added,
+      # and width/height are normalized to the requested display height.
+      module SvgProcessing
+        def load_logo_svg(filename, height: 32)
+          path = theme.resolve_asset(filename) || File.join(BaseRenderer::LOGO_DIR, filename)
+          return nil unless File.exist?(path)
+
+          svg = File.read(path)
+          svg = svg.sub(/\A<\?xml[^?]*\?>\s*/, "")
+          svg = svg.sub(/\A\s*<!--.*?-->\s*/m, "")
+          svg = svg.sub(/<svg\s/, '<svg class="header-logo" ')
+          svg = if svg.match?(/<svg[^>]*\sheight="[^"]*"/)
+                  svg.sub(/(<svg[^>]*?)(\sheight="[^"]*")/,
+                          "\\1 height=\"#{height}\"")
+                else
+                  svg.sub(/(<svg\b)/, "\\1 height=\"#{height}\"")
+                end
+          svg.sub(/(<svg[^>]*?)\swidth="[^"]*"/, '\1')
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/concerns/text_extraction.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Concerns
+      # Plain-text extraction from model nodes, mixed into BaseRenderer.
+      # Used wherever rendered output needs a text-only form (titles,
+      # labels, captions, ToC entries). Walks `element_order` and typed
+      # attributes directly on the model — never strips tags from
+      # rendered HTML.
+      module TextExtraction
+        def extract_plain_text(node)
+          return node.to_s if node.is_a?(String)
+          return extract_text_value(node).to_s unless node.is_a?(Lutaml::Model::Serializable)
+
+          parts = []
+          xml_mapping = node.class.mappings_for(:xml, node.lutaml_register)
+
+          if node.element_order.is_a?(Array) && xml_mapping
+            element_to_attr =
+              Renderers::ElementOrderTraversal.element_to_attr_map(xml_mapping)
+
+            indices = Hash.new(0)
+            node.element_order.each do |el|
+              next unless el.is_a?(Lutaml::Xml::Element)
+
+              if el.text?
+                parts << el.text_content.to_s
+              elsif el.name == "tab"
+                parts << " "
+              # rubocop:disable Lint/DuplicateBranch
+              elsif el.name == "br"
+                parts << " "
+              # rubocop:enable Lint/DuplicateBranch
+              elsif el.element?
+                attr_name = element_to_attr[el.name]
+                if attr_name
+                  coll = node.public_send(attr_name)
+                  obj = if coll.is_a?(Array)
+                          idx = indices[attr_name]
+                          indices[attr_name] += 1
+                          coll[idx]
+                        else
+                          coll
+                        end
+                  text = extract_plain_text(obj)
+                  parts << (text.empty? ? " " : text)
+                elsif el.name == "span"
+                  parts << " "
+                end
+              end
+            end
+          end
+
+          if parts.join.strip.empty?
+            t = safe_attr(node, :text)
+            parts << (t.is_a?(Array) ? t.join : t.to_s) if t
+          end
+
+          parts.join.strip.gsub(" ", " ")
+        end
+
+        def extract_text_value(val)
+          return nil if val.nil?
+          return val if val.is_a?(String)
+
+          if val.is_a?(Array)
+            val.map { |v| extract_text_value(v) }.join
+          elsif val.is_a?(Lutaml::Model::Serializable)
+            c = safe_attr(val, :content)
+            if c && !c.equal?(val)
+              extract_text_value(c)
+            else
+              t = safe_attr(val, :text)
+              if t
+                extract_text_value(t)
+              else
+                v = safe_attr(val, :value)
+                if v
+                  extract_text_value(v)
+                else
+                  val.to_s
+                end
+              end
+            end
+          else
+            val.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/concerns/toc_registry.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    module Concerns
+      # Table-of-contents entry collection and ToC rendering, mixed into
+      # BaseRenderer. Sub-renderers register section/figure/table entries
+      # as they walk the document; assemble_document renders the collected
+      # entries through the _toc.html.liquid template.
+      module TocRegistry
+        def toc_entries
+          @toc_entries
+        end
+
+        def build_toc_html(entries)
+          entry_drops = entries.map { |e| Drops::TocEntryDrop.new(e) }
+          figure_drops = @figure_entries.map { |f| Drops::FigureListEntryDrop.new(f) }
+          table_drops = @table_entries.map { |t| Drops::FigureListEntryDrop.new(t) }
+          has_special_lists = !@figure_entries.empty? || !@table_entries.empty?
+
+          render_liquid("_toc.html.liquid", {
+                          "entries" => entry_drops,
+                          "figures" => figure_drops,
+                          "tables" => table_drops,
+                          "has_special_lists" => has_special_lists,
+                        })
+        end
+
+        def register_toc_entry(id:, level:, text:)
+          @toc_entries << { id: id, level: level, text: text }
+        end
+
+        def register_figure_entry(id:, text:)
+          @figure_entries << { id: id, text: text }
+        end
+
+        def figure_entries
+          @figure_entries
+        end
+
+        def register_table_entry(id:, text:)
+          @table_entries << { id: id, text: text }
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/html/csa_renderer.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    class CsaRenderer < IsoRenderer
+      register_render Metanorma::CsaDocument::Root, :render_document
+    end
+  end
+end

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

@@ -47,24 +47,47 @@ module Metanorma
           end
           sub_figures_html = sub_figures_parts.join
 
-          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,
             image_html: image_html,
             caption_html: caption_html,
-            key_html: key_html,
+            key_html: build_key_html(figure, renderer),
             sub_figures_html: sub_figures_html,
             css_class: "figure",
           )
         end
+
+        class << self
+          private
+
+          # Notes, plain definition lists, and figure.key (e.g.
+          # <key class="formula_dl">) — symbol/footnote definitions
+          # belonging to the figure.
+          def build_key_html(figure, renderer)
+            parts = []
+            renderer.safe_attr(figure, :note)&.each do |n|
+              parts << (renderer.render_note(n) || "")
+            end
+            renderer.safe_attr(figure, :dl)&.then do |dl|
+              parts << (renderer.render_definition_list(dl) || "")
+            end
+            append_figure_key(parts, renderer.safe_attr(figure, :key), renderer)
+            parts.join
+          end
+
+          def append_figure_key(parts, key, renderer)
+            return unless key
+
+            name = renderer.safe_attr(key, :name)
+            parts << (renderer.render_inline_element(name) || "") if name
+            if renderer.safe_attr(key, :dl)
+              parts << (renderer.render_definition_list(key.dl) || "")
+            end
+            renderer.safe_attr(key, :p)&.each do |para|
+              parts << (renderer.render_paragraph(para) || "")
+            end
+          end
+        end
       end
     end
   end

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

@@ -23,22 +23,19 @@ css_class: nil)
                         renderer.render_inline_element(sc.name)
                       end
 
-          code_text = if sc.body&.content
-                        Array(sc.body.content).join
+          code_text = if sc.body
+                        sc.body.decoded_content
                       elsif sc.content
                         Array(sc.content).join
                       else
                         ""
                       end
-          raw_text = code_text.gsub("&lt;", "<").gsub("&gt;", ">").gsub("&amp;", "&").gsub(
-            "&quot;", "\""
-          )
 
           new(
             id: id,
             lang: lang,
             name_html: name_html,
-            code_html: renderer.escape_html(raw_text),
+            code_html: renderer.escape_html(code_text),
             css_class: "sourcecode",
           )
         end

data/lib/metanorma/html/flavor.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "pubid"
+
+module Metanorma
+  module Html
+    # A flavor ties together the four concepts that identify a Metanorma
+    # document variant:
+    # - a symbolic name (used for theme loading, CSS class names)
+    # - a model class (the typed root class for the flavor)
+    # - a renderer class (the HTML renderer that handles the flavor)
+    # - an optional Pubid module (for parsing identifiers like ISO/IEC/etc.)
+    #
+    # Flavor centralizes flavor identity so BaseRenderer, PubidRenderer,
+    # and Generator all read from the same source of truth. Adding a new
+    # flavor is one Flavor entry in the registry, not three coordinated
+    # edits across three files.
+    class Flavor
+      attr_reader :name, :model_class, :renderer_class, :pubid_module
+
+      def initialize(name:, model_class:, renderer_class:, pubid_module: nil)
+        @name = name
+        @model_class = model_class
+        @renderer_class = renderer_class
+        @pubid_module = pubid_module
+      end
+
+      # Match by ancestry: a document whose class is the flavor's model
+      # class, or any descendant of it, belongs to this flavor. Walks
+      # parent classes via is_a? to support subclassing.
+      def matches?(document_class)
+        return false unless document_class.is_a?(Class)
+
+        # `<=` returns nil for unrelated classes; coerce to boolean.
+        !!(document_class <= model_class)
+      end
+
+      def pubid_module_const
+        return nil unless pubid_module
+
+        Object.const_get(pubid_module.to_s)
+      rescue NameError
+        raise ArgumentError,
+              "Flavor #{name.inspect}: pubid module #{pubid_module} could " \
+              "not be resolved — fix the registration in " \
+              "Html::Generator.build_flavor_registry"
+      end
+    end
+  end
+end

data/lib/metanorma/html/flavor_registry.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Html
+    # Registry of known flavors. Queried by:
+    # - Generator — to pick the renderer for a document
+    # - BaseRenderer — to resolve flavor_name for theme loading
+    # - PubidRenderer — to resolve the Pubid module
+    #
+    # Single source of truth for flavor identity. Adding a flavor is
+    # one Flavor entry via #register.
+    class FlavorRegistry
+      include Enumerable
+
+      def initialize
+        @flavors = []
+      end
+
+      def register(flavor)
+        @flavors << flavor
+        self
+      end
+
+      def each(&)
+        @flavors.each(&)
+      end
+
+      # Returns the most-specific Flavor whose model_class matches the
+      # given document class (by ancestry). Most-specific = registered
+      # last. We scan in reverse so general flavors (registered first)
+      # only match if no more specific flavor does.
+      def find_for(document_class)
+        @flavors.reverse_each.find { |f| f.matches?(document_class) }
+      end
+
+      def name_for(document_class)
+        find_for(document_class)&.name
+      end
+
+      def renderer_for(document_class)
+        find_for(document_class)&.renderer_class
+      end
+
+      def pubid_module_for(document_class)
+        find_for(document_class)&.pubid_module_const
+      end
+    end
+  end
+end

data/lib/metanorma/html/generator.rb

@@ -3,18 +3,22 @@
 module Metanorma
   module Html
     class Generator
-      @renderers = []
       @tastes = []
       @setup = false
 
       class << self
-        def register(model_class, renderer_class)
-          @renderers << [model_class, renderer_class]
+        # 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.
+        # 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
@@ -27,15 +31,11 @@ module Metanorma
         def renderer_for(document)
           setup! unless @setup
 
-          # Check tastes first (publisher-based dispatch)
           taste_renderer = find_taste(document)
           return taste_renderer if taste_renderer
 
-          # Fall back to model-based dispatch (most specific last)
-          @renderers.reverse_each do |model_class, renderer_class|
-            return renderer_class if document.is_a?(model_class)
-          end
-          BaseRenderer
+          flavor = @flavors.find_for(document.class)
+          flavor&.renderer_class || BaseRenderer
         end
 
         private
@@ -79,6 +79,7 @@ module Metanorma
           return if @setup
 
           @setup = true
+          @flavors = build_flavor_registry
 
           # Trigger autoloads by referencing constants
           BaseRenderer
@@ -86,6 +87,7 @@ module Metanorma
           IsoRenderer
           BipmRenderer
           CcRenderer
+          CsaRenderer
           IccRenderer
           IecRenderer
           IeeeRenderer
@@ -97,27 +99,109 @@ module Metanorma
           PdfaRenderer
           RiboseRenderer
 
-          # Register renderers (most general first, most specific last)
-          register Metanorma::Document::Root,           BaseRenderer
-          register Metanorma::StandardDocument::Root,   StandardRenderer
-          register Metanorma::IsoDocument::Root,        IsoRenderer
-          register Metanorma::BipmDocument::Root,       BipmRenderer
-          register Metanorma::CcDocument::Root,         CcRenderer
-          register Metanorma::IecDocument::Root,        IecRenderer
-          register Metanorma::IeeeDocument::Root,       IeeeRenderer
-          register Metanorma::IetfDocument::Root,       IetfRenderer
-          register Metanorma::IhoDocument::Root,        IhoRenderer
-          register Metanorma::ItuDocument::Root,        ItuRenderer
-          register Metanorma::OgcDocument::Root,        OgcRenderer
-          register Metanorma::OimlDocument::Root,       OimlRenderer
-          register Metanorma::RiboseDocument::Root,     RiboseRenderer
-
           # Register tastes (publisher-based dispatch within same model)
-          register_taste Metanorma::IsoDocument::Root,    "ICC",
-                         IccRenderer
+          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: :oiml,
+                                model_class: Metanorma::OimlDocument::Root,
+                                renderer_class: OimlRenderer,
+                                pubid_module: :"Pubid::Oiml",
+                              ))
+            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)
+        end
       end
     end
   end