metanorma-document 0.3.0 → 0.5.0

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,
@@ -592,9 +530,11 @@ module Metanorma
           end
         end
 
-        def render_mixed_content_in_order(node)
+        def render_mixed_content_in_order(node, skip_classes: nil)
           parts = []
           node.each_mixed_content do |child|
+            next if skip_classes&.any? { |klass| child.is_a?(klass) }
+
             parts << case child
                      when String
                        escape_html(child)

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/templates/_list_item.html.liquid

@@ -1 +1 @@
-<li{{ attrs }}>{{ content }}</li>
+<li{{ attrs }}>{% if label %}<span class="li-label">{{ label }}</span>{% endif %}{{ content }}</li>

data/lib/metanorma/html/theme.rb

@@ -120,26 +120,53 @@ module Metanorma
       # --- Non-YAML state (set programmatically) ---
       attr_accessor :theme_dir
 
+      # Additional theme directories registered by flavor gems (e.g.
+      # metanorma-oiml). Searched before the built-in THEMES_DIR so a
+      # flavor can ship its own `themes/<flavor>/theme.yaml` (directory
+      # form, with assets/templates/custom.css alongside) outside this gem.
+      @extra_themes_dirs = []
+
+      class << self
+        attr_reader :extra_themes_dirs
+
+        def register_themes_dir(dir)
+          @extra_themes_dirs.unshift(File.expand_path(dir))
+        end
+
+        def themes_dirs
+          @extra_themes_dirs + [THEMES_DIR]
+        end
+      end
+
       def self.load(flavor)
-        dir_theme = File.join(THEMES_DIR, flavor.to_s, "theme.yaml")
-        flat_theme = File.join(THEMES_DIR, "#{flavor}.yaml")
-
-        if File.exist?(dir_theme)
-          from_directory(dir_theme, flavor)
-        elsif File.exist?(flat_theme)
-          from_file(flat_theme)
-        else
-          new
+        themes_dirs.each do |themes_dir|
+          dir_theme = File.join(themes_dir, flavor.to_s, "theme.yaml")
+          flat_theme = File.join(themes_dir, "#{flavor}.yaml")
+
+          return from_directory(dir_theme, flavor, themes_dir) if File.exist?(dir_theme)
+          return from_file(flat_theme) if File.exist?(flat_theme)
         end
+
+        new
       end
 
       def self.from_file(path)
         from_yaml(File.read(path))
       end
 
-      def self.from_directory(path, flavor)
+      def self.from_directory(path, flavor, themes_dir = THEMES_DIR)
         theme = from_yaml(File.read(path))
-        theme.theme_dir = File.join(THEMES_DIR, flavor.to_s)
+        theme.theme_dir = File.join(themes_dir, flavor.to_s)
+        theme
+      end
+
+      # Load a theme from an external theme directory: `dir/theme.yaml`
+      # with optional `assets/`, `templates/` and `custom.css` resolved
+      # relative to `dir`. This is the entry point for organization-local
+      # themes living outside any gem.
+      def self.from_theme_dir(dir)
+        theme = from_yaml(File.read(File.join(dir, "theme.yaml")))
+        theme.theme_dir = dir
         theme
       end
 

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"
@@ -85,7 +35,6 @@ module Metanorma
     autoload :IhoRenderer, "metanorma/html/iho_renderer"
     autoload :ItuRenderer, "metanorma/html/itu_renderer"
     autoload :OgcRenderer, "metanorma/html/ogc_renderer"
-    autoload :OimlRenderer, "metanorma/html/oiml_renderer"
     autoload :RiboseRenderer, "metanorma/html/ribose_renderer"
   end
 end

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