metanorma-document 0.3.0 → 0.4.0

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
@@ -136,6 +137,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,7 +170,7 @@ 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,

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

@@ -271,6 +271,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|

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

@@ -104,13 +104,6 @@ module Metanorma
         end
 
         def render_mixed_inline(node)
-          if raw_content_node?(node)
-            raw = node.content
-            if raw.is_a?(String) && !raw.strip.empty?
-              return render_raw_content(raw)
-            end
-          end
-
           if node.is_a?(Lutaml::Model::Serializable) && node.element_order && !node.element_order.empty?
             render_ordered_inline(node)
           elsif node.is_a?(Lutaml::Model::Serializable)
@@ -129,13 +122,6 @@ module Metanorma
           end
         end
 
-        def raw_content_node?(node)
-          node.is_a?(Lutaml::Model::Serializable) &&
-            node.content.is_a?(String)
-        rescue NoMethodError
-          false
-        end
-
         def render_ordered_inline(node)
           parts = []
           walked = walk_ordered(node) do |type, obj|
@@ -243,8 +229,19 @@ module Metanorma
           ", "
         end
 
+        # Form inputs render as disabled HTML inputs — this is a document
+        # rendering, not an interactive form.
+        def render_input(el)
+          attrs = element_attrs(
+            type: safe_attr(el, :type) || "text",
+            disabled: "disabled",
+            checked: safe_attr(el, :checked) ? "checked" : nil,
+          )
+          "<input#{attrs}>"
+        end
+
         def render_math(el)
-          el.content.to_s
+          el.to_xml
         end
 
         def render_asciimath(el)
@@ -374,65 +371,6 @@ module Metanorma
                         })
         end
 
-        def render_raw_content(raw_xml)
-          doc = Nokogiri::XML.fragment(raw_xml)
-          doc.css("fmt-link").each do |el|
-            target = el["target"] || el["href"]
-            if target
-              display_text = target.delete_prefix("mailto:")
-              a = doc.document.create_element("a", display_text,
-                                              "href" => target)
-              el.replace(a)
-            else
-              el.replace(el.children)
-            end
-          end
-          doc.traverse do |node|
-            next unless node.element?
-            next unless %w[xref eref stem link].include?(node.name)
-
-            next_sib = node.next_sibling
-            while next_sib.is_a?(Nokogiri::XML::Text) && next_sib.text.strip.empty?
-              next_sib = next_sib.next_sibling
-            end
-            next unless next_sib&.element? && next_sib.name == "semx"
-
-            deduplicate_semx_label(node, next_sib)
-            node.remove
-          end
-          %w[semx fmt-xref].each do |tag|
-            doc.css(tag).each { |el| el.replace(el.children) }
-          end
-          doc.css("[class]").each do |el|
-            el["class"] = el["class"].split(/\s+/).map do |c|
-              html_class_for_span(c)
-            end.join(" ")
-          end
-          doc.inner_html
-        end
-
-        def deduplicate_semx_label(source_node, semx_node)
-          first_text = semx_node.children.find do |c|
-            c.text? && !c.text.strip.empty?
-          end
-          return unless first_text
-
-          semx_prefix = first_text.text[/\A(\s*\S+)/, 1]
-          return unless semx_prefix && !semx_prefix.strip.empty?
-
-          prev = source_node.previous_sibling
-          return unless prev.is_a?(Nokogiri::XML::Text)
-
-          label = semx_prefix.strip
-          prev_text = prev.text.rstrip
-          return unless prev_text.end_with?(label)
-
-          prev.content = prev_text.sub(/#{Regexp.escape(label)}\s*\z/, "")
-          first_text.content = first_text.text.sub(
-            /\A\s*#{Regexp.escape(label)}\s*/, ""
-          )
-        end
-
         def render_link(link)
           target = safe_attr(link, :target) || safe_attr(link, :href)
           attrs = element_attrs(href: target, id: safe_attr(link, :id))
@@ -517,7 +455,7 @@ module Metanorma
           end
 
           if math_items.any?
-            content = math_items.map { |m| m.content.to_s }.join
+            content = math_items.map(&:to_xml).join
             unless content.empty?
               return render_liquid("_math_container.html.liquid", {
                                      "data_attrs" => data_attrs,