metanorma-document 0.2.0 → 0.2.2

data/lib/metanorma/html/iso_renderer.rb

@@ -8,22 +8,6 @@ module Metanorma
     # Extends StandardRenderer with ISO-specific cover page, boilerplate,
     # foreword, introduction, annex formatting, and ISO term entries.
     class IsoRenderer < StandardRenderer
-      class << self
-        def doc_types
-          @doc_types ||= []
-          if superclass <= IsoRenderer && superclass != IsoRenderer
-            superclass.doc_types + @doc_types
-          else
-            @doc_types.dup
-          end
-        end
-
-        def registers_doc_type(klass)
-          @doc_types ||= []
-          @doc_types << klass
-        end
-      end
-
       # --- Public hooks for flavor customization ---
 
       def flavor_publishers(_doc_id)
@@ -67,32 +51,32 @@ module Metanorma
         end
       end
 
-      def render(node, **opts)
+      def render(node, **)
         case node
         when Metanorma::IsoDocument::Root
-          render_document(node, **opts)
+          render_document(node, **)
         when Metanorma::IsoDocument::Sections::IsoPreface
-          render_preface(node, **opts)
+          render_preface(node, **)
         when Metanorma::IsoDocument::Sections::IsoSections
-          render_sections(node, **opts)
+          render_sections(node, **)
         when Metanorma::IsoDocument::Sections::IsoClauseSection
-          render_clause(node, **opts)
+          render_clause(node, **)
         when Metanorma::IsoDocument::Sections::IsoAnnexSection
-          render_annex(node, **opts)
+          render_annex(node, **)
         when Metanorma::IsoDocument::Sections::IsoTermsSection
-          render_terms_section(node, **opts)
+          render_terms_section(node, **)
         when Metanorma::IsoDocument::Sections::IsoForewordSection
-          render_foreword(node, **opts)
+          render_foreword(node, **)
         when Metanorma::IsoDocument::Sections::IsoAbstractSection
-          render_abstract(node, **opts)
+          render_abstract(node, **)
         when Metanorma::IsoDocument::Terms::IsoTerm
-          render_term(node, **opts)
+          render_term(node, **)
         when Metanorma::IsoDocument::Terms::TermNote
-          render_term_note(node, **opts)
+          render_term_note(node, **)
         when Metanorma::IsoDocument::Terms::TermExample
-          render_term_example(node, **opts)
+          render_term_example(node, **)
         when Metanorma::IsoDocument::Boilerplate
-          render_boilerplate(node, **opts)
+          render_boilerplate(node, **)
         else
           super
         end
@@ -147,33 +131,35 @@ module Metanorma
 
       # Extract English stage text, deduplicating duplicate language variants.
       def extract_stage(bibdata)
-        return nil unless bibdata.status && bibdata.status.stage
+        return nil unless bibdata.status&.stage
 
         stages = Array(bibdata.status.stage)
         return nil if stages.empty?
 
         # Prefer English-language stage
-        en_stage = stages.find { |s|
+        en_stage = stages.find do |s|
           lang = safe_attr(s, :language)
           lang == "en" if lang
-        }
-        return Array(en_stage.value).join.strip if en_stage && en_stage.value
+        end
+        return Array(en_stage.value).join.strip if en_stage&.value
 
         # Fallback: first non-empty, deduplicated
         seen = Set.new
-        stage_text = stages.filter_map { |s|
+        stage_text = stages.filter_map do |s|
           val = Array(s.value).join.strip
           down = val.downcase
           next if seen.include?(down)
+
           seen << down
           val.empty? ? nil : val
-        }.compact.join(" ")
+        end.compact.join(" ")
         stage_text.empty? ? nil : stage_text
       end
 
       # Extract document type from ext.doctype.
       def extract_doctype(bibdata)
         return nil unless bibdata.respond_to?(:ext)
+
         ext = bibdata.ext
         return nil unless ext
 
@@ -181,11 +167,11 @@ module Metanorma
         return nil unless doctypes && !doctypes.empty?
 
         # Prefer English-language doctype
-        en_dt = doctypes.find { |d|
+        en_dt = doctypes.find do |d|
           lang = safe_attr(d, :language)
           lang == "en" if lang
-        }
-        return en_dt.value.to_s if en_dt && en_dt.value
+        end
+        return en_dt.value.to_s if en_dt&.value
 
         # Fallback: first doctype
         dt = doctypes.first
@@ -216,7 +202,7 @@ module Metanorma
         all_items.each do |node|
           next if node.is_a?(String)
           next if is_title_element?(node, doc.sections)
-          next if is_doc_title_paragraph?(node)
+
           render(node)
         end
 
@@ -254,13 +240,13 @@ module Metanorma
         stage_text = extract_stage(bibdata)
 
         @output << render_liquid("_iso_cover.html.liquid", {
-          "publisher_logos" => logos,
-          "doc_id" => doc_id,
-          "pub_date" => pub_date,
-          "doctype" => doctype,
-          "title" => title_text,
-          "stage" => stage_text,
-        })
+                                   "publisher_logos" => logos,
+                                   "doc_id" => doc_id,
+                                   "pub_date" => pub_date,
+                                   "doctype" => doctype,
+                                   "title" => title_text,
+                                   "stage" => stage_text,
+                                 })
       end
 
       def render_doc_title(doc)
@@ -274,8 +260,8 @@ module Metanorma
         return unless en_title
 
         @output << render_liquid("_iso_doc_title.html.liquid", {
-          "title" => en_title.to_s,
-        })
+                                   "title" => en_title.to_s,
+                                 })
       end
 
       def render_boilerplate_section(doc)
@@ -303,7 +289,7 @@ module Metanorma
             fw_id = safe_attr(fw, :id)
             title_text = extract_plain_text(title)
             register_toc_entry(id: fw_id, level: level, text: title_text)
-            @output << "<h1 class=\"ForewordTitle\">"
+            @output << "<h1 class=\"foreword-title\">"
             render_mixed_inline(title)
             @output << "</h1>"
           end
@@ -319,7 +305,7 @@ module Metanorma
             sec_id = safe_attr(section, :id)
             title_text = extract_plain_text(title)
             register_toc_entry(id: sec_id, level: level, text: title_text)
-            @output << "<h1 class=\"IntroTitle\">"
+            @output << "<h1 class=\"intro-title\">"
             render_mixed_inline(title)
             @output << "</h1>"
           end
@@ -344,7 +330,7 @@ module Metanorma
       # --- Clause rendering ---
 
       def render_clause(clause, level: 1, **_opts)
-        attrs = element_attrs(id: safe_attr(clause, :id), class: safe_attr(clause, :class_attr))
+        attrs = element_attrs(id: safe_attr(clause, :id))
         tag("div", attrs) do
           render_title(clause, level)
           render_ordered_content(clause, level)
@@ -354,7 +340,7 @@ module Metanorma
       # --- Annex rendering ---
 
       def render_annex(annex, level: 1, **_opts)
-        attrs = element_attrs(id: safe_attr(annex, :id), class: "Section3")
+        attrs = element_attrs(id: safe_attr(annex, :id), class: "section-sub")
         tag("div", attrs) do
           render_annex_title(annex, level)
           render_ordered_content(annex, level)
@@ -370,7 +356,7 @@ module Metanorma
         register_toc_entry(id: annex_id, level: level, text: title_text)
 
         h = "h#{[[level, 6].min, 1].max}"
-        @output << "<#{h} class=\"Annex\">"
+        @output << "<#{h} class=\"annex-title\">"
         render_mixed_inline(title_element)
         @output << "</#{h}>"
       end
@@ -398,7 +384,7 @@ module Metanorma
           # In presentation mode, use fmt_* elements
           if term.fmt_name
             # Render term number (e.g. "3.1")
-            @output << "<p class=\"TermNum\">"
+            @output << "<p class=\"term-number\">"
             render_inline_element(term.fmt_name)
             @output << "</p>"
           elsif term.term_number
@@ -408,7 +394,7 @@ module Metanorma
                       else
                         extract_text_value(tn)
                       end
-            @output << "<p class=\"TermNum\">#{escape_html(tn_text)}</p>"
+            @output << "<p class=\"term-number\">#{escape_html(tn_text)}</p>"
           end
 
           # Preferred designations — use fmt-preferred if available
@@ -436,7 +422,7 @@ module Metanorma
           # (fmt-definition already includes domain text in its content)
           if term.domain && !term.fmt_definition
             domain_text = safe_attr(term.domain, :text)
-            @output << "<p class=\"domain\">&lt;#{escape_html(domain_text)}&gt;</p>" if domain_text
+            @output << "<p class=\"term-domain\">&lt;#{escape_html(domain_text)}&gt;</p>" if domain_text
           end
 
           # Definition — use fmt-definition if available
@@ -458,7 +444,7 @@ module Metanorma
           # Source references — use fmt-termsource if available
           if term.fmt_termsource && !term.fmt_termsource.empty?
             term.fmt_termsource.each do |fts|
-              @output << "<p class=\"source\">"
+              @output << "<p class=\"term-source\">"
               render_mixed_inline(fts)
               @output << "</p>"
             end
@@ -485,7 +471,8 @@ module Metanorma
         if term.preferred && !term.preferred.empty?
           return extract_designation_name(term.preferred.first).to_s
         end
-        safe_attr(term, :id).to_s.sub(/\Aterm-/, "")
+
+        safe_attr(term, :id).to_s.delete_prefix("term-")
       end
 
       def extract_term_definition(term)
@@ -502,11 +489,11 @@ module Metanorma
 
       def strip_html(html)
         html.gsub(/<[^>]+>/, "").gsub("&lt;", "<").gsub("&gt;", ">")
-            .gsub("&amp;", "&").gsub("&nbsp;", " ")
+          .gsub("&amp;", "&").gsub("&nbsp;", " ")
       end
 
       def render_term_designation(designation, type)
-        css_class = type == "deprecated" ? "DeprecatedTerms" : "Terms"
+        css_class = type == "deprecated" ? "term-deprecated" : "term-name"
         @output << "<p class=\"#{css_class}\" style=\"text-align:left;\">"
         @output << "<del>" if type == "deprecated"
         @output << "<b><dfn>"
@@ -582,32 +569,6 @@ module Metanorma
         end
       end
 
-      def render_term_note(note)
-        attrs = element_attrs(id: safe_attr(note, :id), class: "Note")
-        tag("div", attrs) do
-          label = extract_termnote_label(note)
-          @output << "<p><span class=\"termnote_label\">#{escape_html(label)}: </span>"
-          note.p&.each { |para| render_mixed_inline(para) }
-          @output << "</p>"
-          note.ul&.each { |ul| render_unordered_list(ul) }
-          note.ol&.each { |ol| render_ordered_list(ol) }
-          note.dl&.then { |dl| render_definition_list(dl) }
-        end
-      end
-
-      def render_term_example(example)
-        attrs = element_attrs(id: safe_attr(example, :id), class: "example")
-        tag("div", attrs) do
-          label = extract_block_label(example, "EXAMPLE")
-          @output << "<p><span class=\"example_label\">#{escape_html(label)}</span>&nbsp;"
-          example.p&.each { |para| render_mixed_inline(para) }
-          @output << "</p>"
-          example.ul&.each { |ul| render_unordered_list(ul) }
-          example.ol&.each { |ol| render_ordered_list(ol) }
-          example.dl&.then { |dl| render_definition_list(dl) }
-        end
-      end
-
       # --- Boilerplate rendering ---
 
       def render_boilerplate(boilerplate, **_opts)
@@ -627,7 +588,13 @@ module Metanorma
           .gsub(/<variant-title[^>]*>.*?<\/variant-title>/m, "")
           .gsub(/<\/?(?:copyright-statement|clause)[^>]*>/, "")
 
-        @output << clean.strip
+        # Remap XML class names to HTML-specific class names
+        boilerplate_doc = Nokogiri::HTML::DocumentFragment.parse(clean)
+        boilerplate_doc.css("[class]").each do |el|
+          el["class"] = el["class"].split(/\s+/).map { |c| html_class_for_span(c) }.join(" ")
+        end
+
+        @output << boilerplate_doc.inner_html.strip
 
         @output << "</div>"
       end
@@ -641,19 +608,19 @@ module Metanorma
             next_sib = next_sib.next_sibling
           end
 
-          display_text = if next_sib && next_sib.element? && next_sib.name == "semx"
-            fmt_link = next_sib.at_css("fmt-link")
-            if fmt_link
-              fmt_target = fmt_link["target"] || fmt_link["href"] || target
-              display_text = fmt_target.to_s.sub(/\Amailto:/, "")
-              next_sib.remove
-              display_text
-            end
-          end
-
-          display_text ||= target.to_s.sub(/\Amailto:/, "")
+          display_text = if next_sib&.element? && next_sib.name == "semx"
+                           fmt_link = next_sib.at_css("fmt-link")
+                           if fmt_link
+                             fmt_target = fmt_link["target"] || fmt_link["href"] || target
+                             display_text = fmt_target.to_s.delete_prefix("mailto:")
+                             next_sib.remove
+                             display_text
+                           end
+                         end
+
+          display_text ||= target.to_s.delete_prefix("mailto:")
           a_tag = Nokogiri::HTML::DocumentFragment.parse(
-            "<a href=\"#{CGI.escapeHTML(target.to_s)}\">#{CGI.escapeHTML(display_text)}</a>"
+            "<a href=\"#{CGI.escapeHTML(target.to_s)}\">#{CGI.escapeHTML(display_text)}</a>",
           )
           link.replace(a_tag)
         end
@@ -676,128 +643,29 @@ module Metanorma
         @output << "</#{h}>"
       end
 
-      # Collect all renderable children from a section, sorted by displayorder.
-      # Uses element_order directly because each_mixed_content returns early
-      # when the model class doesn't declare mixed_content (mixed? is false).
-      def collect_ordered_children(section)
-        children = gather_element_order_children(section)
-
-        # Also gather typed attributes that may not appear in element_order
-        %i[terms definitions].each do |attr|
-          val = safe_attr(section, attr)
-          next if val.nil?
-          Array(val).each do |v|
-            children << v unless children.include?(v)
-          end
-        end
-
-        # Sort by displayorder (non-nil first, then nil at end)
-        children.reject!(&:nil?)
-        children.sort_by do |node|
-          order = node.displayorder rescue nil
-          order &&= order.to_i
-          order || Float::INFINITY
-        end
-      end
-
-      def render_ordered_content(section, level = 1)
-        children = collect_ordered_children(section)
-        children.each do |node|
-          next if node.is_a?(String)
-          next if is_title_element?(node, section)
-
-          render(node, level: level + 1)
-        end
-      end
-
-      private
-
-      # Filter document title paragraphs that are rendered by render_doc_title
-      def is_doc_title_paragraph?(node)
-        return false unless node.respond_to?(:class_attr)
-        ["zzSTDTitle1", "zzSTDTitle2"].include?(node.class_attr)
-      end
-
       # Collect all document-level children (sections, normative refs, annexes,
       # bibliography) sorted by displayorder for correct document order.
+      # Top-level paragraphs in sections (title paragraphs) are excluded —
+      # they are rendered separately by render_doc_title.
       def collect_document_children(doc)
         items = []
 
-        # Main sections children (clauses, terms, etc.)
         if doc.sections
-          items.concat(gather_element_order_children(doc.sections))
-          # Also add typed attributes that may not be in element_order
-          %i[terms definitions].each do |attr|
-            val = safe_attr(doc.sections, attr)
-            next if val.nil?
-            Array(val).each { |v| items << v unless items.include?(v) }
+          section_children = collect_ordered_children(doc.sections)
+          section_children.reject! do |node|
+            node.is_a?(Metanorma::Document::Components::Paragraphs::ParagraphBlock)
           end
+          items.concat(section_children)
         end
 
-        # Normative references from bibliography (may have displayorder)
-        if doc.bibliography && doc.bibliography.references
-          doc.bibliography.references.each { |r| items << r }
-        end
-
-        # Annexes
+        doc.bibliography&.references&.each { |r| items << r }
         doc.annex&.each { |a| items << a }
 
-        # Non-normative bibliography (no displayorder = goes at end)
-        if doc.bibliography && doc.bibliography.references
-          # Already included above; filter normative vs non-normative below
-        end
-
         items.compact!
-        items.sort_by do |node|
-          order = node.displayorder rescue nil
-          order &&= order.to_i
-          order || Float::INFINITY
-        end
-      end
-
-      # Iterate element_order directly, bypassing each_mixed_content which
-      # requires mixed?/ordered? to be true (many section models aren't).
-      def gather_element_order_children(node)
-        children = []
-        return children unless node.is_a?(Lutaml::Model::Serializable)
-        return children unless node.element_order && !node.element_order.empty?
-
-        xml_mapping = node.class.mappings_for(:xml, node.lutaml_register)
-        return children unless xml_mapping
-
-        element_to_attr = {}
-        xml_mapping.mapping_elements_hash.each_value do |rule_or_array|
-          Array(rule_or_array).each do |rule|
-            element_to_attr[rule.name] = rule.to
-            element_to_attr[rule.name.to_s] = rule.to if rule.name.is_a?(Symbol)
-          end
-        end
-
-        indices = Hash.new(0)
-
-        node.element_order.each do |el|
-          if el.text?
-            children << el.text_content if el.text_content
-          elsif el.element?
-            attr_name = element_to_attr[el.name]
-            next unless attr_name
-
-            coll = node.send(attr_name)
-            obj = if coll.is_a?(Array)
-                    idx = indices[attr_name]
-                    indices[attr_name] += 1
-                    coll[idx]
-                  else
-                    coll
-                  end
-            children << obj if obj
-          end
-        end
-
-        children
+        sort_by_displayorder(items)
       end
 
-      def publisher_logos_html(doc)
+      def publisher_logos_html(_doc)
         publishers = flavor_publishers(extract_primary_doc_id)
         logo_map = publisher_logo_map
         return [] if publishers.empty? && logo_map.empty?
@@ -811,8 +679,8 @@ module Metanorma
           next unless svg
 
           # White fill for dark cover background
-          svg = svg.gsub(/fill:#00b1ff/, "fill:white") if pub == "OGC"
-          svg = svg.gsub(/fill:#e3000f/, "fill:white") if pub == "ISO"
+          svg = svg.gsub("fill:#00b1ff", "fill:white") if pub == "OGC"
+          svg = svg.gsub("fill:#e3000f", "fill:white") if pub == "ISO"
           svg
         end
       end

data/lib/metanorma/html/itu_renderer.rb

@@ -4,7 +4,6 @@ module Metanorma
   module Html
     # ITU brand: #0e99d5 blue from logo
     class ItuRenderer < IsoRenderer
-      registers_doc_type Metanorma::ItuDocument::Root
 
       def flavor_publishers(_doc_id)
         ["ITU"]

data/lib/metanorma/html/ogc_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders OgcDocument components to HTML.
     # Extends IsoRenderer with OGC-specific branding (geospatial, OGC cyan-blue #00b1ff).
     class OgcRenderer < IsoRenderer
-      registers_doc_type Metanorma::OgcDocument::Root
 
       def flavor_publishers(_doc_id)
         ["OGC"]
@@ -46,7 +45,7 @@ module Metanorma
           t.example_bg      = "#e8f4fa"
           t.example_color   = "#004d73"
           t.admonition_border = "#e8812e"
-          t.admonition_bg   = "#fff5eb"
+          t.admonition_bg = "#fff5eb"
           t.admonition_color = "#c06a1a"
           t.footer_border_color = "#00b1ff"
           t.cover_separator_color = "rgba(0,177,255,0.25)"
@@ -69,13 +68,13 @@ module Metanorma
         preface_clauses = preface.clause&.reject { |cl| cl.type == "toc" } || []
 
         return if preface_clauses.empty? &&
-                  !preface.foreword && !preface.introduction &&
-                  !preface.abstract && !preface.acknowledgements &&
-                  !preface.executivesummary
+          !preface.foreword && !preface.introduction &&
+          !preface.abstract && !preface.acknowledgements &&
+          !preface.executivesummary
 
         @output << "<div id=\"preface\" class=\"preface-section\">"
         register_toc_entry(id: "preface", level: 1, text: "Preface")
-        @output << "<h1 class=\"ForewordTitle\">Preface</h1>"
+        @output << "<h1 class=\"foreword-title\">Preface</h1>"
 
         preface_clauses.each { |cl| render(cl, level: 2) }
 

data/lib/metanorma/html/oiml_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders OimlDocument (OIML) components to HTML.
     # Extends IsoRenderer with OIML branding.
     class OimlRenderer < IsoRenderer
-      registers_doc_type Metanorma::OimlDocument::Root
 
       def flavor_publishers(_doc_id)
         ["OIML"]

data/lib/metanorma/html/pdfa_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders PDF Association (PDFA) taste documents to HTML.
     # PDFA brand: #cf9c1d gold + #d03544 red + #4992b2 steel blue from logo
     class PdfaRenderer < IsoRenderer
-      registers_doc_type Metanorma::RiboseDocument::Root
 
       def flavor_publishers(_doc_id)
         ["PDF Association"]

data/lib/metanorma/html/ribose_renderer.rb

@@ -5,7 +5,6 @@ module Metanorma
     # Renders RiboseDocument components to HTML.
     # Extends IsoRenderer with Ribose branding.
     class RiboseRenderer < IsoRenderer
-      registers_doc_type Metanorma::RiboseDocument::Root
 
       def flavor_publishers(_doc_id)
         ["Ribose"]