metanorma-document 0.3.0 → 0.5.0

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "pubid"
+
 module Metanorma
   module Html
     # A flavor ties together the four concepts that identify a Metanorma
@@ -38,7 +40,10 @@ module Metanorma
 
         Object.const_get(pubid_module.to_s)
       rescue NameError
-        nil
+        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

data/lib/metanorma/html/generator.rb

@@ -87,6 +87,7 @@ module Metanorma
           IsoRenderer
           BipmRenderer
           CcRenderer
+          CsaRenderer
           IccRenderer
           IecRenderer
           IeeeRenderer
@@ -94,7 +95,6 @@ module Metanorma
           IhoRenderer
           ItuRenderer
           OgcRenderer
-          OimlRenderer
           PdfaRenderer
           RiboseRenderer
 
@@ -136,6 +136,12 @@ module Metanorma
                                 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,
@@ -163,19 +169,13 @@ module Metanorma
                                 name: :itu,
                                 model_class: Metanorma::ItuDocument::Root,
                                 renderer_class: ItuRenderer,
-                                pubid_module: :"Pubid::Ithu",
+                                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,

data/lib/metanorma/html/iso_renderer.rb

@@ -330,148 +330,6 @@ module Metanorma
 
       # --- ISO Term rendering ---
 
-      def render_term(term, **_opts)
-        term_name = extract_term_name(term)
-        term_def = extract_term_definition(term)
-        data_attrs = {}
-        if term_name && !term_name.empty?
-          data_attrs["data-term-name"] = term_name
-        end
-        if term_def && !term_def.empty?
-          data_attrs["data-term-definition"] = term_def
-        end
-        attrs = element_attrs(id: safe_attr(term, :id), **data_attrs)
-        fmt_name = safe_attr(term, :fmt_name)
-        fmt_preferred = safe_attr(term, :fmt_preferred)
-        fmt_admitted = safe_attr(term, :fmt_admitted)
-        fmt_deprecates = safe_attr(term, :fmt_deprecates)
-        fmt_definition = safe_attr(term, :fmt_definition)
-        fmt_termsource = safe_attr(term, :fmt_termsource)
-        term_number = safe_attr(term, :term_number)
-        term_p = safe_attr(term, :p)
-        term_note = safe_attr(term, :termnote) || Array(safe_attr(term, :note))
-        term_example = safe_attr(term,
-                                 :termexample) || Array(safe_attr(term,
-                                                                  :example))
-        term_termsource = safe_attr(term, :termsource)
-        term_admonition = safe_attr(term, :admonition)
-        term_nested = safe_attr(term, :term)
-
-        parts = []
-        if fmt_name
-          tn_content = render_inline_element(fmt_name)
-          parts << render_liquid("_term_number.html.liquid",
-                                 { "content" => tn_content })
-        elsif term_number
-          tn_text = if term_number.is_a?(String)
-                      term_number
-                    else
-                      extract_text_value(term_number)
-                    end
-          parts << render_liquid("_term_number.html.liquid",
-                                 { "content" => escape_html(tn_text) })
-        end
-
-        if fmt_preferred && !fmt_preferred.empty?
-          fmt_preferred.each do |fp|
-            fp.p&.each { |para| parts << (render_paragraph(para) || "") }
-          end
-        elsif term.preferred && !term.preferred.empty?
-          term.preferred&.each do |designation|
-            parts << (render_term_designation(designation, "preferred") || "")
-          end
-        end
-
-        if fmt_admitted && !fmt_admitted.empty?
-          fmt_admitted.each do |fa|
-            fa.p&.each { |para| parts << (render_paragraph(para) || "") }
-          end
-        elsif term.admitted && !term.admitted.empty?
-          term.admitted&.each do |designation|
-            parts << (render_term_designation(designation, "admitted") || "")
-          end
-        end
-
-        if fmt_deprecates
-          fmt_deprecates.p&.each do |para|
-            parts << (render_paragraph(para) || "")
-          end
-        elsif term.deprecates && !term.deprecates.empty?
-          term.deprecates&.each do |designation|
-            parts << (render_term_designation(designation, "deprecated") || "")
-          end
-        end
-
-        if term.domain && !fmt_definition
-          domain_text = safe_attr(term.domain, :text)
-          if domain_text
-            parts << render_liquid("_term_domain.html.liquid", {
-                                     "text" => escape_html(domain_text),
-                                   })
-          end
-        end
-
-        if fmt_definition
-          parts << (render_ordered_content(fmt_definition) || "")
-        else
-          term_p&.each { |para| parts << (render_paragraph(para) || "") }
-          term.definition&.each do |defn|
-            parts << (render_term_definition(defn) || "")
-          end
-        end
-
-        term_note&.each { |note| parts << (render_term_note(note) || "") }
-        term_example&.each { |ex| parts << (render_term_example(ex) || "") }
-
-        if fmt_termsource && !fmt_termsource.empty?
-          fmt_termsource.each do |fts|
-            src_content = render_mixed_inline(fts)
-            parts << render_liquid("_paragraph.html.liquid", {
-                                     "attrs" => " class=\"term-source\"",
-                                     "content" => src_content,
-                                   })
-          end
-        else
-          term.source&.each { |src| parts << (render_term_source(src) || "") }
-          term_termsource&.each do |src|
-            parts << (render_term_source_element(src) || "")
-          end
-        end
-
-        term_admonition&.each { |adm| parts << (render_admonition(adm) || "") }
-        term_nested&.each { |sub| parts << (render_term(sub) || "") }
-
-        render_liquid("_element.html.liquid", "tag" => "div",
-                                              "extra_attrs" => attrs, "content" => parts.join)
-      end
-
-      def extract_term_name(term)
-        fmt_pref = safe_attr(term, :fmt_preferred)
-        if fmt_pref && !fmt_pref.empty?
-          fp = fmt_pref.first
-          if fp.p && !fp.p.empty?
-            return extract_plain_text(fp.p.first)
-          end
-        end
-        if term.preferred && !term.preferred.empty?
-          return extract_designation_name(term.preferred.first).to_s
-        end
-
-        safe_attr(term, :id).to_s.delete_prefix("term-")
-      end
-
-      def extract_term_definition(term)
-        fmt_def = safe_attr(term, :fmt_definition)
-        return extract_plain_text(fmt_def) if fmt_def
-
-        term_p = safe_attr(term, :p)
-        if term_p && !term_p.empty?
-          text = term_p.map { |para| extract_plain_text(para) }.join(" ")
-          return text.strip unless text.strip.empty?
-        end
-        nil
-      end
-
       def render_term_designation(designation, type)
         css_class = type == "deprecated" ? "term-deprecated" : "term-name"
         name = extract_designation_name(designation)

data/lib/metanorma/html/renderers/block_renderer.rb

@@ -154,9 +154,11 @@ module Metanorma
         end
 
         def render_unordered_list(ul, **_opts)
-          attrs = element_attrs(id: safe_attr(ul, :id))
+          labeled = ul.listitem&.any? { |li| list_label(li) } || false
+          attrs = element_attrs(id: safe_attr(ul, :id),
+                                class: labeled ? "mn-labeled-list" : nil)
           items = ul.listitem&.filter_map do |li|
-            render_list_item_content(li)
+            render_list_item_content(li, labeled: labeled)
           end || []
           render_liquid("_list.html.liquid", {
                           "list_tag" => "ul",
@@ -182,10 +184,12 @@ module Metanorma
         end
 
         def render_ordered_list(ol, **_opts)
+          labeled = ol.listitem&.any? { |li| list_label(li) } || false
           attrs = element_attrs(id: safe_attr(ol, :id),
+                                class: labeled ? "mn-labeled-list" : nil,
                                 start: safe_attr(ol, :start), type: safe_attr(ol, :type_attr))
           items = ol.listitem&.filter_map do |li|
-            render_list_item_content(li)
+            render_list_item_content(li, labeled: labeled)
           end || []
           render_liquid("_list.html.liquid", {
                           "list_tag" => "ol",
@@ -194,14 +198,36 @@ module Metanorma
                         })
         end
 
-        def render_list_item_content(li)
+        def render_list_item_content(li, labeled: false)
           li_id = safe_attr(li, :id)
           attrs = li_id ? %( id="#{escape_html(li_id)}") : ""
-          inner = coordinator.render_mixed_content_in_order(li)
+          label = labeled ? list_label(li) : nil
+          inner = if label
+                    coordinator.render_mixed_content_in_order(
+                      li,
+                      skip_classes: [Metanorma::Document::Components::Inline::FmtNameElement],
+                    )
+                  else
+                    coordinator.render_mixed_content_in_order(li)
+                  end
           render_liquid("_list_item.html.liquid", "attrs" => attrs,
+                                                  "label" => label && escape_html(label),
                                                   "content" => inner)
         end
 
+        # Label glyph for a list item, taken from the presentation XML
+        # (the item's fmt-name/autonum). The presentation XML is
+        # authoritative for the bullet or number; when present it is
+        # rendered as the item marker and the browser's own list-style
+        # marker is suppressed (see components/lists.css).
+        def list_label(li)
+          fmt_name = coordinator.safe_attr(li, :fmt_name)
+          return nil unless fmt_name
+
+          label = coordinator.extract_plain_text(fmt_name).strip
+          label.empty? ? nil : label
+        end
+
         def render_definition_list(dl, **_opts)
           attrs = element_attrs(id: safe_attr(dl, :id))
           terms = dl.dt&.each_with_index&.map do |dt, i|
@@ -271,6 +297,16 @@ module Metanorma
           render_liquid("_example.html.liquid", { "block" => drop })
         end
 
+        def render_form(form, **_opts)
+          attrs = element_attrs(id: safe_attr(form, :id), class: "form")
+          content = coordinator.render_ordered_content(form)
+          render_liquid("_element.html.liquid", {
+                          "tag" => "div",
+                          "extra_attrs" => attrs,
+                          "content" => content,
+                        })
+        end
+
         def render_sourcecode(sc, **_opts)
           drop = Drops::SourcecodeDrop.from_model(sc,
                                                   renderer: coordinator.renderer_context)

data/lib/metanorma/html/renderers/element_order_traversal.rb

@@ -15,10 +15,24 @@ module Metanorma
       module ElementOrderTraversal
         module_function
 
+        # The map depends only on the model class's xml mapping, which is
+        # immutable after class definition — cache one map per mapping
+        # object instead of rebuilding it for every rendered node.
+        @cache = {}.compare_by_identity
+
+        def element_to_attr_map(xml_mapping)
+          @cache[xml_mapping] ||= build_map(xml_mapping)
+        end
+
+        # Test/benchmark hook: drop all memoized maps.
+        def reset_cache!
+          @cache.clear
+        end
+
         # Returns `{ xml_element_name => attr_name }` including both
         # symbol and string keys for each mapped element, so callers
         # can look up by either el.name form.
-        def element_to_attr_map(xml_mapping)
+        def build_map(xml_mapping)
           {}.tap do |map|
             xml_mapping.mapping_elements_hash.each_value do |rule_or_array|
               Array(rule_or_array).each do |rule|