metanorma-document 0.3.0 → 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
+
+      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
 
-        if term.definition
-          Array(term.definition).each do |defn|
-            parts << (render_term_definition(defn) || "")
+      # 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)

data/lib/metanorma/html.rb

@@ -11,57 +11,6 @@ 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"
@@ -77,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

@@ -5,19 +5,14 @@ module Metanorma
     module Handlers
       module Inline
         # Shared declarative table of inline marks whose HTML rendering is
-        # a fixed tag with optional static attrs. Two adapters consume it:
+        # 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.
         #
-        # - RichHtmlRenderer: renders Metanorma XML elements to HTML
-        #   directly (the fallback / attribute-value path).
-        # - Output::HtmlRenderers::MarkRenderers: renders mirror Model marks
-        #   to HTML (the primary SSR path).
-        #
-        # Both adapters must produce visually equivalent HTML for the same
-        # mark type — the table is the single source of truth for the
-        # mark-name to tag-and-attrs mapping. Marks whose attrs vary per
-        # instance (link, xref, eref, span) carry data in mark.attrs and
-        # are not in this table; each adapter keeps custom handlers for
-        # those.
+        # 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 },

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

@@ -12,9 +12,8 @@ module Metanorma
         # Nokogiri::HTML5::Builder to guarantee well-formed, escaped output.
         #
         # Simple-wrap elements (em, strong, sub, sup, code, u, s, smallcap,
-        # bcp14, concept) share their tag-and-attrs mapping with the Model-side
-        # renderer via Inline::Catalog, so the XML→HTML and Model→HTML paths
-        # produce visually equivalent output for the same mark type.
+        # bcp14, concept) take their tag-and-attrs mapping from the shared
+        # Inline::Catalog table.
         module RichHtmlRenderer
           # Complex element handlers — these have per-instance attrs or
           # multi-step rendering and bypass the shared Catalog.

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

data/lib/metanorma/mirror/output/formats/inline_format.rb

@@ -8,12 +8,42 @@ module Metanorma
     module Output
       module Formats
         class InlineFormat < BaseFormat
+          # Classic content styles inlined for the no-JS SSR body: reset +
+          # typography + block/inline component styles from the classic
+          # asset pipeline. Page chrome (layout, print, transitions, dark,
+          # cover, header, footer, toc, search, progress, shortcuts,
+          # glossary panel, flavor modules) is owned by the SPA and
+          # excluded.
+          CONTENT_CSS_MODULES = %w[
+            base/_reset
+            base/_typography
+            components/section
+            components/note
+            components/example
+            components/sourcecode
+            components/formula
+            components/admonition
+            components/table
+            components/footnote
+            components/figure
+            components/term
+            components/bibliography
+            components/inline
+            components/index
+          ].freeze
+
+          class << self
+            attr_accessor :missing_bundle_warned
+          end
+
           def write(output_path, guide, title: "Metanorma")
             FileUtils.mkdir_p(File.dirname(output_path))
 
-            data_script = "window.METANORMA_DATA = #{safe_json(guide)};"
-            ssr_body = HtmlRenderer.new(guide).render
-            head_parts = []
+            warn_missing_bundle unless iife_bundle_exists?
+
+            data_script = "window.METANORMA_DATA = #{safe_json(guide.to_h)};"
+            ssr_body = render_ssr_body(guide)
+            head_parts = [build_style(classic_content_css)]
             css_inline = read_css_inline
             if css_inline && !css_inline.empty?
               head_parts << build_style(css_inline)
@@ -42,6 +72,37 @@ module Metanorma
 
           private
 
+          # SSR body is the classic renderer's document body: identical to
+          # the static HTML output, embedded as the no-JS / first-paint
+          # placeholder the SPA replaces on mount.
+          def render_ssr_body(guide)
+            document = guide.document
+            unless document
+              raise ArgumentError,
+                    "InlineFormat requires a Guide carrying its source document"
+            end
+
+            renderer = Metanorma::Html::Generator.renderer_for(document).new
+            renderer.generate_body(document)
+          end
+
+          def classic_content_css
+            css_dir = Metanorma::Html::AssetPipeline::CSS_DIR
+            CONTENT_CSS_MODULES.filter_map do |mod|
+              path = File.join(css_dir, "#{mod}.css")
+              File.read(path) if File.exist?(path)
+            end.join("\n")
+          end
+
+          def warn_missing_bundle
+            return if self.class.missing_bundle_warned
+
+            warn "metanorma-document: #{iife_bundle_path} not found — " \
+                 "writing static HTML without the interactive SPA. " \
+                 "Run `rake build_frontend` to build it."
+            self.class.missing_bundle_warned = true
+          end
+
           def build_style(css)
             Nokogiri::HTML5::Builder.new do |doc|
               doc.style { doc.text css }

data/lib/metanorma/mirror/output/pipeline.rb

@@ -23,6 +23,7 @@ id_strategy: nil)
             content: @context.content,
             meta: @context.meta,
             title: @context.title,
+            document: @context.parsed,
           )
         end
 

data/lib/metanorma/mirror/output.rb

@@ -6,8 +6,6 @@ module Metanorma
       autoload :Pipeline, "#{__dir__}/output/pipeline"
       autoload :PipelineContext, "#{__dir__}/output/pipeline_context"
       autoload :Builder, "#{__dir__}/output/builder"
-      autoload :HtmlRenderers, "#{__dir__}/output/html_renderers"
-      autoload :HtmlRenderer, "#{__dir__}/output/html_renderer"
       autoload :Formats, "#{__dir__}/output/formats"
     end
   end

data/lib/metanorma/mirror/rewriter.rb

@@ -6,7 +6,9 @@ module Metanorma
     # per-type customization. Despite living in the reverse-conversion
     # namespace, this class produces a Model graph (not Metanorma XML) —
     # the output is a fully model-driven representation that can be
-    # serialized via Model#to_h or rendered via Output::HtmlRenderer.
+    # serialized via Model#to_h or embedded into HTML output by
+    # Output::Formats::InlineFormat (which renders the source document
+    # through the classic Metanorma::Html renderer).
     #
     # Instance API:
     #   Rewriter.new(skip: Set.new(%w[review footnotes]))

data/lib/metanorma/registers/setup.rb

@@ -44,6 +44,12 @@ module Metanorma
           Lutaml::Model::GlobalRegister.register(reg)
         end
 
+        def setup_csa_register
+          reg = Lutaml::Model::Register.new(:csa_document,
+                                            fallback: [:iso_document])
+          Lutaml::Model::GlobalRegister.register(reg)
+        end
+
         def setup_bsi_register
           iso = Metanorma::IsoDocument
           reg = Lutaml::Model::Register.new(:bsi_document,
@@ -155,6 +161,10 @@ module Metanorma
             from_type: sd::Sections::Preface,
             to_type: Metanorma::UnDocument::Sections::UnPreface,
           )
+          reg.register_global_type_substitution(
+            from_type: Metanorma::Document::Components::MultiParagraph::AdmonitionBlock,
+            to_type: Metanorma::UnDocument::Blocks::UnAdmonitionBlock,
+          )
         end
       end
     end

data/lib/metanorma/standard_document/annotation_container.rb

@@ -10,6 +10,7 @@ module Metanorma
         attribute :to, :string
         attribute :type, :string
         attribute :date, :string
+        attribute :semx_id, :string
         attribute :paragraphs,
                   Metanorma::Document::Components::Paragraphs::ParagraphBlock,
                   collection: true
@@ -22,6 +23,7 @@ module Metanorma
           map_attribute "to", to: :to
           map_attribute "type", to: :type
           map_attribute "date", to: :date
+          map_attribute "semx-id", to: :semx_id
           map_element "p", to: :paragraphs
         end
       end