metanorma-document 0.2.12 → 0.4.0

data/lib/metanorma/html/standard_renderer.rb

@@ -160,57 +160,217 @@ module Metanorma
 
       # --- Term rendering ---
 
+      # Unified term entry renderer. Handles both semantic-only term models
+      # (StandardDocument::Terms::Term) and presentation-aware models with
+      # fmt-* attributes (IsoDocument::Terms::IsoTerm): safe_attr returns nil
+      # for attributes a model does not declare, so the fmt-* branches are
+      # skipped automatically on semantic-only models.
       def render_term(term, **_opts)
-        attrs = element_attrs(id: safe_attr(term, :id))
+        attrs = element_attrs(id: safe_attr(term, :id), **term_data_attrs(term))
+        fmt_definition = safe_attr(term, :fmt_definition)
+
         parts = []
-        term.preferred&.each do |d|
-          parts << (render_term_designation(d, "preferred") || "")
+        parts << (render_term_number(term) || "")
+        parts << render_term_designations(term, :fmt_preferred, :preferred,
+                                          "preferred")
+        parts << render_term_designations(term, :fmt_admitted, :admitted,
+                                          "admitted")
+        parts << render_term_designations(term, :fmt_deprecates, :deprecates,
+                                          "deprecated")
+        parts << (render_term_domain(term, fmt_definition) || "")
+        parts << render_term_definitions(term, fmt_definition)
+        parts << render_term_note_parts(term)
+        parts << render_term_example_parts(term)
+        parts << render_term_source_parts(term)
+        safe_attr(term, :admonition)&.each do |admonition|
+          parts << (render_admonition(admonition) || "")
         end
-        term.admitted&.each do |d|
-          parts << (render_term_designation(d, "admitted") || "")
+        safe_attr(term, :term)&.each { |sub| parts << (render_term(sub) || "") }
+        render_liquid("_element.html.liquid", {
+                        "tag" => "div",
+                        "extra_attrs" => attrs,
+                        "content" => parts.join,
+                      })
+      end
+
+      def term_data_attrs(term)
+        term_name = extract_term_name(term)
+        term_definition = extract_term_definition(term)
+        data_attrs = {}
+        if term_name && !term_name.empty?
+          data_attrs["data-term-name"] = term_name
         end
-        term.deprecates&.each do |d|
-          parts << (render_term_designation(d, "deprecated") || "")
+        if term_definition && !term_definition.empty?
+          data_attrs["data-term-definition"] = term_definition
         end
-
-        if term.domain
-          domain_text = if term.domain.is_a?(String)
-                          term.domain
+        data_attrs
+      end
+
+      def render_term_number(term)
+        fmt_name = safe_attr(term, :fmt_name)
+        term_number = safe_attr(term, :term_number)
+        if fmt_name
+          render_liquid("_term_number.html.liquid", {
+                          "content" => render_inline_element(fmt_name),
+                        })
+        elsif term_number
+          number_text = if term_number.is_a?(String)
+                          term_number
                         else
-                          safe_attr(term.domain, :text).to_s
+                          extract_text_value(term_number)
                         end
-          unless domain_text.to_s.empty?
-            parts << render_liquid("_term_domain.html.liquid", {
-                                     "text" => escape_html(domain_text),
-                                   }).to_s
+          render_liquid("_term_number.html.liquid", {
+                          "content" => escape_html(number_text),
+                        })
+        end
+      end
+
+      # Designations (preferred/admitted/deprecated): fmt-* presentation
+      # elements win when present; otherwise render semantic designations.
+      def render_term_designations(term, fmt_attr, semantic_attr, type)
+        fmt = safe_attr(term, fmt_attr)
+        fmt_list = fmt.is_a?(Array) ? fmt : [fmt].compact
+        parts = []
+        if fmt_list.empty?
+          term.public_send(semantic_attr)&.each do |designation|
+            parts << (render_term_designation(designation, type) || "")
+          end
+        else
+          fmt_list.each do |element|
+            element.p&.each { |para| parts << (render_paragraph(para) || "") }
           end
         end
+        parts.join
+      end
+
+      def render_term_domain(term, fmt_definition)
+        return nil if fmt_definition
+
+        domain = term.domain
+        return nil unless domain
+
+        domain_text = domain.is_a?(String) ? domain : safe_attr(domain, :text).to_s
+        return nil if domain_text.empty?
+
+        render_liquid("_term_domain.html.liquid", {
+                        "text" => escape_html(domain_text),
+                      }).to_s
+      end
+
+      def render_term_definitions(term, fmt_definition)
+        return render_ordered_content(fmt_definition) || "" if fmt_definition
+
+        parts = []
+        safe_attr(term, :p)&.each do |para|
+          parts << (render_paragraph(para) || "")
+        end
+        term.definition&.each do |definition|
+          parts << (render_term_definition(definition) || "")
+        end
+        parts.join
+      end
 
-        if term.definition
-          Array(term.definition).each do |defn|
-            parts << (render_term_definition(defn) || "")
+      def render_term_note_parts(term)
+        notes = safe_attr(term, :termnote) || Array(safe_attr(term, :note))
+        parts = []
+        notes.each_with_index do |note, i|
+          parts << (render_term_note_item(note, i) || "")
+        end
+        parts.join
+      end
+
+      # A term note can be a raw String (rendered with a "Note N to entry"
+      # label), a termnote element (labelled wrapper), or a plain block
+      # (rendered as a generic note).
+      def render_term_note_item(note, index)
+        if note.is_a?(String)
+          render_liquid("_term_text_note.html.liquid", {
+                          "label" => "Note #{index + 1} to entry: ",
+                          "content" => escape_html(note),
+                        }).to_s
+        elsif term_scoped_block?(note)
+          render_term_note(note)
+        else
+          render_note(note)
+        end
+      end
+
+      def render_term_example_parts(term)
+        examples = safe_attr(term, :termexample) ||
+          Array(safe_attr(term, :example))
+        examples.map do |example|
+          render_term_example_item(example) || ""
+        end.join
+      end
+
+      # A term example can be a termexample element (labelled wrapper), a
+      # raw String, or a plain paragraph block (both rendered as paragraphs).
+      # render_paragraph cannot take a bare String (render_mixed_inline
+      # expects a model), so Strings go through the paragraph template
+      # directly — same markup render_paragraph would emit.
+      def render_term_example_item(example)
+        if example.is_a?(String)
+          return render_liquid("_paragraph.html.liquid", {
+                                 "attrs" => "",
+                                 "content" => escape_html(example),
+                               })
+        end
+        return render_term_example(example) if term_scoped_block?(example)
+
+        render_paragraph(example)
+      end
+
+      # Termnote/termexample elements wrap block children (`p`, lists);
+      # plain paragraph blocks and Strings do not declare a `p` attribute.
+      def term_scoped_block?(node)
+        node.is_a?(Lutaml::Model::Serializable) &&
+          node.class.attributes.key?(:p)
+      end
+
+      def render_term_source_parts(term)
+        fmt_termsource = safe_attr(term, :fmt_termsource)
+        parts = []
+        if fmt_termsource && !fmt_termsource.empty?
+          fmt_termsource.each do |source|
+            parts << render_liquid("_paragraph.html.liquid", {
+                                     "attrs" => " class=\"term-source\"",
+                                     "content" => render_mixed_inline(source),
+                                   })
+          end
+        else
+          term.source&.each { |src| parts << (render_term_source(src) || "") }
+          safe_attr(term, :termsource)&.each do |source|
+            parts << (render_term_source_element(source) || "")
           end
         end
+        parts.join
+      end
 
-        term.note&.each_with_index do |note, i|
-          if note.is_a?(String)
-            label = "Note #{i + 1} to entry: "
-            parts << render_liquid("_term_text_note.html.liquid", {
-                                     "label" => label,
-                                     "content" => escape_html(note),
-                                   }).to_s
-          else
-            parts << (render_note(note) || "")
+      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
 
-        term.example&.each { |ex| parts << (render_paragraph(ex) || "") }
-        term.source&.each { |src| parts << (render_term_source(src) || "") }
-        render_liquid("_element.html.liquid", {
-                        "tag" => "div",
-                        "extra_attrs" => attrs,
-                        "content" => parts.join,
-                      })
+        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)
@@ -454,11 +614,13 @@ module Metanorma
         [prefix_text, rest.empty? ? nil : rest]
       end
 
+      PREFERRED_LINK_TYPES = %w[src citation].freeze
+
       def bibitem_url(item)
         links = Array(item.link)
         return nil if links.empty?
 
-        preferred = links.find { |l| ["src", "citation"].include?(l.type) }
+        preferred = links.find { |l| PREFERRED_LINK_TYPES.include?(l.type) }
         return preferred.content.to_s if preferred && !preferred.content.to_s.empty?
 
         non_rss = links.find do |l|

data/lib/metanorma/html.rb

@@ -11,61 +11,13 @@ module Metanorma
       Liquid::Environment.default.file_system = Liquid::LocalFileSystem.new(
         TEMPLATES_ROOT, "_%s.html.liquid"
       )
-
-      Moxml::Adapter::Nokogiri.class_eval do
-        class << self
-          alias_method :_original_children_patched, :children
-          remove_method :children
-        end
-
-        def self.children(node)
-          node.children.to_a
-        end
-      end
-    end
-
-    # Patch missing Moxml module method used by lutaml-model XML serializer
-    ::Moxml.class_eval do
-      def self.preprocess_entities(text)
-        if block_given?
-          yield text
-        else
-          text
-        end
-      end
-    end
-
-    module Html
-      Lutaml::Xml::XmlElement.class_eval do
-        remove_method :order
-
-        def order
-          return @order_cache if @order_cache
-
-          @order_cache = children.filter_map do |child|
-            if child.text?
-              Lutaml::Xml::Element.new("Text", "text",
-                                       text_content: child.text,
-                                       node_type: :text)
-            elsif child.cdata?
-              Lutaml::Xml::Element.new("Text", "#cdata-section",
-                                       text_content: child.text,
-                                       node_type: :cdata)
-            elsif child.comment?
-              nil
-            else
-              Lutaml::Xml::Element.new("Element", child.unprefixed_name,
-                                       node_type: :element,
-                                       namespace_uri: child.namespace_uri,
-                                       namespace_prefix: child.namespace_prefix)
-            end
-          end
-        end
-      end
     end
 
     autoload :BaseRenderer, "metanorma/html/base_renderer"
+    autoload :Flavor, "metanorma/html/flavor"
+    autoload :FlavorRegistry, "metanorma/html/flavor_registry"
     autoload :Generator, "metanorma/html/generator"
+    autoload :RendererDelegation, "metanorma/html/renderer_delegation"
     autoload :Theme, "metanorma/html/theme"
     autoload :AssetPipeline, "metanorma/html/asset_pipeline"
     autoload :Component, "metanorma/html/component"
@@ -74,6 +26,7 @@ module Metanorma
     autoload :IsoRenderer, "metanorma/html/iso_renderer"
     autoload :BipmRenderer, "metanorma/html/bipm_renderer"
     autoload :CcRenderer, "metanorma/html/cc_renderer"
+    autoload :CsaRenderer, "metanorma/html/csa_renderer"
     autoload :IccRenderer, "metanorma/html/icc_renderer"
     autoload :PdfaRenderer, "metanorma/html/pdfa_renderer"
     autoload :IecRenderer, "metanorma/html/iec_renderer"

data/lib/metanorma/iso_document/sections/iso_preface.rb

@@ -4,30 +4,44 @@ module Metanorma
   module IsoDocument
     module Sections
       # Prefatory clauses in an ISO/IEC document.
-      # Extends StandardDocument::Preface with ISO-specific section types:
-      #   abstract → IsoAbstractSection
-      #   foreword → IsoForewordSection
-      #   introduction → IsoClauseSection
-      # ISO preface mandates foreword; isodoc preface is permissive.
-      class IsoPreface < Metanorma::StandardDocument::Sections::Preface
-        # Override: ISO uses specific section types
+      # Corresponds to isostandard.rng:
+      #   preface = element preface { abstract?, foreword, introduction? }
+      #
+      # This class deliberately does NOT inherit StandardDocument::Preface:
+      # lutaml-model deep-duplicates a parent's XML mappings into subclasses,
+      # so inheriting would keep the isodoc-level acknowledgements and
+      # executivesummary mappings that the ISO grammar forbids. Attributes
+      # are composed directly instead.
+      #
+      # The `clause` mapping is a documented extension required by real ISO
+      # presentation output, which emits front-matter clauses such as
+      # `<clause type="toc">` ahead of the foreword. `content` mirrors
+      # `clause` for the generic preface-content consumers (e.g. the mirror
+      # renderer), matching the runtime behavior of the previous inherited
+      # dual mapping.
+      class IsoPreface < Lutaml::Model::Serializable
         attribute :abstract, IsoAbstractSection
         attribute :foreword, IsoForewordSection
         attribute :introduction, IsoClauseSection
 
-        # Generic clauses in preface use IsoClauseSection
+        # Presentation front-matter clauses (e.g. table of contents placeholder)
         attribute :clause, IsoClauseSection, collection: true
+        attribute :content, Metanorma::StandardDocument::Sections::ContentSection,
+                  collection: true
 
-        # Acknowledgements and executivesummary use IsoClauseSection
-        attribute :acknowledgements, IsoClauseSection
-        attribute :executivesummary, IsoClauseSection
+        # Presentation-specific attributes
+        attribute :semx_id, :string
+        attribute :displayorder, :integer
 
         xml do
           element "preface"
           ordered
 
-          Metanorma::StandardDocument::SectionXmlMapping.apply_preface_elements(self)
-          map_element "clause", to: :clause
+          map_element "abstract",     to: :abstract
+          map_element "foreword",     to: :foreword
+          map_element "introduction", to: :introduction
+          map_element "clause",       to: :clause
+          map_element "clause",       to: :content
 
           Metanorma::StandardDocument::SectionXmlMapping.apply_preface_attributes(self)
         end

data/lib/metanorma/mirror/default_registry.rb

@@ -153,6 +153,27 @@ module Metanorma
             Handlers::Structural,
             method_name: :preface,
           )
+          # IsoPreface and UnPreface deliberately do not inherit
+          # StandardDocument::Preface (grammar-strict classes compose from
+          # mixins), so they need explicit registrations — the registry
+          # resolves handlers through class ancestry.
+          registry.register(
+            Metanorma::IsoDocument::Sections::IsoPreface,
+            Handlers::Structural,
+            method_name: :preface,
+          )
+          registry.register(
+            Metanorma::UnDocument::Sections::UnPreface,
+            Handlers::Structural,
+            method_name: :preface,
+          )
+          # UnAbstractSection likewise composes instead of inheriting
+          # ContentSection.
+          registry.register(
+            Metanorma::UnDocument::Sections::UnAbstractSection,
+            Handlers::Section,
+            method_name: :content_section,
+          )
           registry.register(
             Metanorma::StandardDocument::Sections::Sections,
             Handlers::Structural,

data/lib/metanorma/mirror/handlers/inline/catalog.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Mirror
+    module Handlers
+      module Inline
+        # Shared declarative table of inline marks whose HTML rendering is
+        # a fixed tag with optional static attrs. It is consumed by
+        # RichHtmlRenderer, which renders Metanorma XML elements to HTML
+        # directly (the fallback / attribute-value path) during the
+        # forward transform into the mirror IR.
+        #
+        # Marks whose attrs vary per instance (link, xref, eref, span)
+        # carry data in mark.attrs and are not in this table; each
+        # consumer keeps custom handlers for those.
+        module Catalog
+          SIMPLE_WRAPS = {
+            "emphasis" => { tag: :em },
+            "strong" => { tag: :strong },
+            "subscript" => { tag: :sub },
+            "superscript" => { tag: :sup },
+            "code" => { tag: :code },
+            "underline" => { tag: :u },
+            "strike" => { tag: :s },
+            "smallcap" => { tag: :span, style: "font-variant: small-caps" },
+            "concept" => { tag: :span, class: "concept" },
+            "bcp14" => { tag: :span, class: "bcp14" },
+            "footnote" => { tag: :sup, class: "footnote-inline" },
+            "stem" => { tag: :span, class: "stem" },
+          }.freeze
+
+          # XML element classes that render via SIMPLE_WRAPS without
+          # per-instance attrs. Maps element class → mark type (catalog
+          # key). RichHtmlRenderer uses this to dispatch simple elements
+          # through the shared table.
+          SIMPLE_ELEMENTS = {
+            Metanorma::Document::Components::Inline::EmRawElement => "emphasis",
+            Metanorma::Document::Components::Inline::StrongRawElement => "strong",
+            Metanorma::Document::Components::Inline::SubElement => "subscript",
+            Metanorma::Document::Components::Inline::SupElement => "superscript",
+            Metanorma::Document::Components::Inline::TtElement => "code",
+            Metanorma::Document::Components::TextElements::UnderlineElement => "underline",
+            Metanorma::Document::Components::TextElements::StrikeElement => "strike",
+            Metanorma::Document::Components::Inline::SmallCapElement => "smallcap",
+            Metanorma::Document::Components::Inline::Bcp14Element => "bcp14",
+            Metanorma::Document::Components::Inline::ConceptElement => "concept",
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/mirror/handlers/inline/rich_html_renderer.rb

@@ -10,35 +10,14 @@ module Metanorma
         # representation of inline content is required (e.g., attribute values,
         # fallback rendering). All HTML construction goes through
         # Nokogiri::HTML5::Builder to guarantee well-formed, escaped output.
+        #
+        # Simple-wrap elements (em, strong, sub, sup, code, u, s, smallcap,
+        # bcp14, concept) take their tag-and-attrs mapping from the shared
+        # Inline::Catalog table.
         module RichHtmlRenderer
-          RENDERERS = {
-            Metanorma::Document::Components::Inline::EmRawElement => ->(el) {
-              wrap { |d| d.em { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::Inline::StrongRawElement => ->(el) {
-              wrap { |d| d.strong { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::Inline::SubElement => ->(el) {
-              wrap { |d| d.sub { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::Inline::SupElement => ->(el) {
-              wrap { |d| d.sup { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::Inline::TtElement => ->(el) {
-              wrap { |d| d.code { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::TextElements::UnderlineElement => ->(el) {
-              wrap { |d| d.u { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::TextElements::StrikeElement => ->(el) {
-              wrap { |d| d.s { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::Inline::SmallCapElement => ->(el) {
-              wrap { |d| d.span { d << raw(extract(el)) } }
-            },
-            Metanorma::Document::Components::Inline::Bcp14Element => ->(el) {
-              wrap { |d| d.span { d << raw(extract(el)) } }
-            },
+          # Complex element handlers — these have per-instance attrs or
+          # multi-step rendering and bypass the shared Catalog.
+          COMPLEX_RENDERERS = {
             Metanorma::Document::Components::Inline::StemInlineElement => ->(el) {
               for_stem(el)
             },
@@ -57,9 +36,6 @@ module Metanorma
             Metanorma::Document::Components::Inline::FnElement => ->(el) {
               for_fn(el)
             },
-            Metanorma::Document::Components::Inline::ConceptElement => ->(el) {
-              wrap { |d| d.span(class: "concept") { d << raw(extract(el)) } }
-            },
             Metanorma::Document::Components::Inline::SpanElement => ->(el) {
               for_span(el)
             },
@@ -93,8 +69,25 @@ module Metanorma
           end
 
           def self.render_element(element)
-            renderer = RENDERERS[element.class]
-            renderer ? renderer.call(element) : extract(element)
+            complex = COMPLEX_RENDERERS[element.class]
+            return complex.call(element) if complex
+
+            mark_type = Catalog::SIMPLE_ELEMENTS[element.class]
+            return render_simple(mark_type, element) if mark_type
+
+            extract(element)
+          end
+
+          def self.render_simple(mark_type, element)
+            spec = Catalog::SIMPLE_WRAPS[mark_type]
+            attrs = spec.except(:tag)
+            wrap do |d|
+              if attrs.empty?
+                d.public_send(spec[:tag]) { d << raw(extract(element)) }
+              else
+                d.public_send(spec[:tag], attrs) { d << raw(extract(element)) }
+              end
+            end
           end
 
           def self.for_stem(element)
@@ -105,7 +98,10 @@ module Metanorma
               .sub(/\s*xmlns(:\w+)?="[^"]*"\s*/, " ")
               .gsub(/\s+/, " ")
               .strip
-            wrap { |d| d.span(class: "inline-math") { d << raw(mathml) } }
+            spec = Catalog::SIMPLE_WRAPS["stem"]
+            wrap do |d|
+              d.public_send(spec[:tag], spec.except(:tag)) { d << raw(mathml) }
+            end
           end
 
           def self.for_xref(element)
@@ -130,7 +126,10 @@ module Metanorma
 
           def self.for_fn(element)
             reference = SafeAttr.read(element, :reference) || ""
-            wrap { |d| d.sup(class: "footnote-inline") { d.text reference } }
+            spec = Catalog::SIMPLE_WRAPS["footnote"]
+            wrap do |d|
+              d.public_send(spec[:tag], spec.except(:tag)) { d.text reference }
+            end
           end
 
           def self.for_span(element)

data/lib/metanorma/mirror/handlers/inline.rb

@@ -6,6 +6,7 @@ module Metanorma
       module Inline
         autoload :TextExtractor, "#{__dir__}/inline/text_extractor"
         autoload :RichHtmlRenderer, "#{__dir__}/inline/rich_html_renderer"
+        autoload :Catalog, "#{__dir__}/inline/catalog"
 
         MARK_BUILDERS = {
           Metanorma::Document::Components::Inline::EmRawElement => ->(_el) {

data/lib/metanorma/mirror/handlers/sourcecode.rb

@@ -11,7 +11,7 @@ module Metanorma
 
           body = SafeAttr.read(element, :body)
           text = if body
-                   Array(body.content).join
+                   body.decoded_content
                  elsif SafeAttr.read(element, :content).is_a?(String)
                    SafeAttr.read(element, :content)
                  else

data/lib/metanorma/mirror/model/guide.rb

@@ -4,12 +4,13 @@ module Metanorma
   module Mirror
     module Model
       class Guide
-        attr_reader :content, :meta, :title
+        attr_reader :content, :meta, :title, :document
 
-        def initialize(content:, meta: {}, title: nil)
+        def initialize(content:, meta: {}, title: nil, document: nil)
           @content = content
           @meta = meta
           @title = title
+          @document = document
         end
 
         def to_h