metanorma-oiml 0.1.0

data/lib/metanorma/oiml/sts/transformer/table_transformer.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class TableTransformer < Base
+          def transform(source_table)
+            attrs = {}
+            attrs[:id] = source_table.id if source_table.class.method_defined?(:id) && source_table.id
+            label = table_label(source_table)
+            attrs[:label] = label if label
+            caption = table_caption(source_table)
+            attrs[:caption] = caption if caption
+            table = build_table(source_table)
+            attrs[:table] = [table] if table
+            ::Sts::TbxIsoTml::TableWrap.new(attrs)
+          end
+
+          private
+
+          # "Table 2" from the presentation XML autonum attribute.
+          def table_label(source_table)
+            return nil unless source_table.class.method_defined?(:autonum) && source_table.autonum
+
+            "Table #{source_table.autonum}"
+          end
+
+          def table_caption(source_table)
+            return nil unless source_table.class.method_defined?(:name) && source_table.name
+
+            text = RenderedTextExtractor.text_of(source_table.name).strip
+            return nil if text.empty?
+
+            ::Sts::NisoSts::Caption.new(
+              title: ::Sts::NisoSts::Title.new(content: [text])
+            )
+          end
+
+          def build_table(source_table)
+            attrs = {}
+            if source_table.class.method_defined?(:thead) && source_table.thead
+              attrs[:thead] = build_section(source_table.thead, ::Sts::TbxIsoTml::Thead)
+            end
+            if source_table.class.method_defined?(:tbody) && source_table.tbody
+              attrs[:tbody] = build_section(source_table.tbody, ::Sts::TbxIsoTml::Tbody)
+            end
+            ::Sts::TbxIsoTml::Table.new(attrs)
+          end
+
+          def build_section(source_section, klass)
+            trs = Array(source_section.tr).map { |tr| build_tr(tr) }
+            klass.new(tr: trs)
+          end
+
+          def build_tr(tr)
+            th_cells = Array(tr.th).map { |c| build_cell(c, ::Sts::TbxIsoTml::Th) }
+            td_cells = Array(tr.td).map { |c| build_cell(c, ::Sts::TbxIsoTml::Td) }
+            attrs = {}
+            attrs[:th] = th_cells if th_cells.any?
+            attrs[:td] = td_cells if td_cells.any?
+            ::Sts::TbxIsoTml::Tr.new(attrs)
+          end
+
+          def build_cell(cell, klass)
+            entries = cell_entries(cell)
+            fns = cell_footnotes(cell)
+            klass.new do |c|
+              entries.each do |kind, value|
+                case kind
+                when :text then c.content value
+                when :inline_formula then c.inline_formula value
+                when :monospace then c.monospace value
+                when :bold then c.bold value
+                when :italic then c.italic value
+                end
+              end
+              fns.each { |fn| c.fn fn }
+            end
+          end
+
+          # Extracts <fn> footnotes from the cell. MN table cells with
+          # footnote:[...] in AsciiDoc produce an inline <fn> carrying
+          # the footnote body (with paragraphs and math). STS preserves
+          # the footnote as a sibling <fn> element inside the cell so
+          # the renderer can show its content.
+          def cell_footnotes(cell)
+            return [] unless cell.class.method_defined?(:each_mixed_content)
+
+            cell.each_mixed_content.filter_map do |node|
+              next if node.is_a?(String)
+              next unless node.is_a?(Metanorma::Document::Components::Inline::FnElement)
+
+              build_fn(node)
+            end
+          end
+
+          def build_fn(fn_element)
+            paragraphs = Array(fn_element.p).map.with_index { |p, i| build_fn_paragraph(p, fn_element, first: i.zero?) }
+            return nil if paragraphs.empty?
+
+            attrs = { id: fn_element.id, p: paragraphs }
+            label = fn_label(fn_element)
+            attrs[:label] = ::Sts::NisoSts::Label.new(content: [label]) if label
+            ::Sts::TbxIsoTml::Fn.new(attrs)
+          end
+
+          # Fn#p is typed as Sts::NisoSts::Paragraph (uses :text attr).
+          # Our paragraph_transformer produces Sts::NisoSts::Paragraph.
+          # Convert by extracting text — footnote bodies in MN table
+          # cells drop inline math, so we accept text-only. The fn's
+          # reference letter prefixes the first paragraph to match
+          # MN's "<sup>a</sup> body" rendering.
+          def build_fn_paragraph(mn_p, fn_element, first:)
+            iso_p = paragraph_transformer.transform(mn_p)
+            text = extract_paragraph_text(iso_p)
+            label = fn_label(fn_element)
+            text = "#{label} #{text}" if first && label && !text.empty?
+            ::Sts::NisoSts::Paragraph.new(text: [text])
+          end
+
+          def extract_paragraph_text(iso_paragraph)
+            parts = []
+            iso_paragraph.element_order.each do |entry|
+              if entry.node_type == :text
+                parts << entry.text_content.to_s
+              elsif entry.node_type == :element && entry.name == "inline-formula"
+                # Best-effort: extract any mi/mn/mo text from the math
+                parts << extract_formula_text(iso_paragraph)
+              end
+            end
+            parts.join.strip
+          end
+
+          def extract_formula_text(iso_paragraph)
+            Array(iso_paragraph.inline_formula).map do |f|
+              math = f.math
+              next "" unless math
+              extract_math_text(math.to_xml)
+            end.join
+          end
+
+          # Strip comments and MathML/XML tags from a math element's
+          # serialised XML so the parity validator compares only the
+          # visible text. Comment stripping uses String#index (linear,
+          # correct for multi-char terminators); tag stripping uses
+          # simple non-nested character classes.
+          def extract_math_text(math_xml)
+            stripped = strip_xml_comments(math_xml.to_s)
+            stripped
+              .gsub(%r{</?\w+:[^>]*>}, " ")
+              .gsub(/<\/?[^>]*>/, " ")
+              .gsub(/\s+/, " ")
+              .strip
+          end
+
+          # Removes every `<!-- ... -->` comment from +str+. Linear in
+          # the input size; correct for comments containing `>` (which
+          # the previous regex-based stripper would prematurely match).
+          # An unterminated comment runs to end-of-string.
+          def strip_xml_comments(str)
+            result = String.new
+            pos = 0
+            while (open_idx = str.index("<!--", pos))
+              result << str[pos, open_idx - pos]
+              close_idx = str.index("-->", open_idx + 4)
+              break if close_idx.nil?
+              pos = close_idx + 3
+            end
+            result << str[pos..] unless pos.nil? || pos >= str.length
+            result
+          end
+
+          def fn_label(fn_element)
+            ref = fn_element.reference
+            ref.to_s unless ref.nil? || ref.to_s.empty?
+          end
+
+          # Walks the cell's mixed content in document order and produces
+          # an array of [:text, String] | [:inline_formula, InlineFormula] |
+          # [:monospace|:bold|:italic, model] tuples. The builder in
+          # build_cell routes them to the correct typed collection on the
+          # Td/Th model, preserving cross-type ordering via lutaml-model's
+          # mixed_content element_order.
+          def cell_entries(cell)
+            entries = []
+            current_text = nil
+            flush = lambda do
+              return if current_text.nil?
+              entries << [:text, current_text]
+              current_text = nil
+            end
+
+            walk_cell(cell) do |kind, node, text|
+              case kind
+              when :text
+                current_text = (current_text || "") + text
+              when :stem
+                formula = build_inline_formula(node)
+                if formula
+                  flush.call
+                  entries << [:inline_formula, formula]
+                else
+                  mirror_text = cell_mirror_text(node)
+                  current_text = (current_text || "") + mirror_text if mirror_text && !mirror_text.empty?
+                end
+              when :monospace
+                flush.call
+                entries << [:monospace, ::Sts::NisoSts::Monospace.new(content: [text])]
+              when :bold
+                flush.call
+                entries << [:bold, ::Sts::TbxIsoTml::Bold.new(value: [text])]
+              when :italic
+                flush.call
+                entries << [:italic, ::Sts::TbxIsoTml::Italic.new(value: [text])]
+              end
+            end
+            flush.call
+            entries
+          end
+
+          def walk_cell(cell)
+            return unless cell.class.method_defined?(:each_mixed_content)
+
+            @cell_stem_mirrors = build_cell_stem_mirrors(cell)
+
+            cell.each_mixed_content do |node|
+              if node.is_a?(String)
+                yield(:text, node, node)
+                next
+              end
+
+              case node.class.name&.split("::")&.last
+              when "StemInlineElement", "StemBlockElement"
+                yield(:stem, node, nil)
+              when "FmtStemElement"
+                next
+              when "AsciimathElement"
+                next
+              when "TtElement", "MonospaceElement"
+                yield(:monospace, node, RenderedTextExtractor.text_of(node))
+              when "StrongRawElement", "StrongElement"
+                yield(:bold, node, RenderedTextExtractor.text_of(node))
+              when "EmRawElement", "EmElement"
+                yield(:italic, node, RenderedTextExtractor.text_of(node))
+              else
+                text = RenderedTextExtractor.text_of(node)
+                yield(:text, node, text) if text && !text.empty?
+              end
+            end
+          end
+
+          def build_inline_formula(stem_node)
+            mirror = @cell_stem_mirrors && @cell_stem_mirrors[stem_node.id]
+            source = mirror || stem_node
+            ::Metanorma::Oiml::Sts::MathmlBuilder.inline_formula_from_stem(
+              source,
+              klass: ::Sts::NisoSts::InlineFormula
+            )
+          end
+
+          def build_cell_stem_mirrors(cell)
+            map = {}
+            return map unless cell.class.method_defined?(:each_mixed_content)
+
+            cell.each_mixed_content do |node|
+              next unless node.is_a?(Metanorma::Document::Components::Inline::FmtStemElement)
+              Array(node.semx).each do |semx|
+                source = semx.source if semx.is_a?(Metanorma::Document::Components::Inline::SemxElement)
+                map[source] = node if source && !source.empty?
+              end
+            end
+            map
+          end
+
+          def cell_mirror_text(stem_node)
+            mirror = @cell_stem_mirrors && @cell_stem_mirrors[stem_node.id]
+            return nil unless mirror
+
+            Array(mirror.semx).map do |semx|
+              next nil unless semx.is_a?(Metanorma::Document::Components::Inline::SemxElement)
+              semx.text
+            end.compact.join
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/oiml/sts/transformer/term_transformer.rb

@@ -0,0 +1,236 @@
+# frozen_string: true
+
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class TermTransformer < Base
+          def transform(source_term)
+            content = []
+
+            term_number = extract_term_number(source_term)
+            add_preferred_name(content, source_term)
+            add_definition(content, source_term)
+            add_standalone_paragraphs(content, source_term)
+            add_lists(content, source_term)
+            add_term_notes(content, source_term)
+            add_term_examples(content, source_term)
+            add_sources(content, source_term)
+
+            attrs = {}
+            attrs[:id] = source_term.id if source_term.id
+            # The term number ("3.1") becomes the section's <title>,
+            # which the renderer emits as a TermNum heading matching
+            # MN's "<h3 class='TermNum'>3.5.12</h3>" layout. Previously
+            # it was emitted as a leading <p>, which the parity check
+            # did not see as a heading.
+            attrs[:title] = ::Sts::NisoSts::Title.new(content: [term_number]) if term_number
+            paragraphs, lists, notes = partition_content(content)
+            attrs[:paragraphs] = paragraphs if paragraphs.any?
+            attrs[:list] = lists if lists.any?
+            attrs[:non_normative_note] = notes if notes.any?
+
+            nested = Array(source_term.term).map { |sub| transform(sub) }
+            attrs[:sec] = nested if nested.any?
+
+            ::Sts::NisoSts::Section.new(attrs)
+          end
+
+          def partition_content(content)
+            paragraphs = content.grep(::Sts::NisoSts::Paragraph)
+            lists = content.grep(::Sts::NisoSts::List)
+            notes = content.grep(::Sts::NisoSts::NonNormativeNote)
+            others = content.reject do |c|
+              [::Sts::NisoSts::Paragraph, ::Sts::NisoSts::List,
+               ::Sts::NisoSts::NonNormativeNote].any? { |k| c.is_a?(k) }
+            end
+            [paragraphs + others, lists, notes]
+          end
+
+          private
+
+          # The term number ("3.1") from the term's fmt-name caption label.
+          def extract_term_number(source_term)
+            section_transformer.extract_autonum(source_term)
+          end
+
+          def add_preferred_name(content, source_term)
+            para = preferred_name_paragraph(source_term)
+            content << para if para
+          end
+
+          # Preferred names often contain math (e.g. "maximum capacity
+          # (E_max)"). The typed TermNameElement drops stems, so we prefer
+          # the rendered fmt_preferred tree and route it through the
+          # paragraph transformer so MathML passes through verbatim.
+          # Falls back to text-only paragraph when no rendered tree exists.
+          def preferred_name_paragraph(source_term)
+            fmt = Array(source_term.fmt_preferred).first if source_term.class.method_defined?(:fmt_preferred)
+            if fmt && fmt.class.method_defined?(:p)
+              p = Array(fmt.p).first
+              return paragraph_transformer.transform(p) if p
+            end
+
+            text = preferred_name_text(source_term)
+            return nil if text.nil? || text.empty?
+
+            ::Sts::NisoSts::Paragraph.new(text: [text])
+          end
+
+          def preferred_name_text(source_term)
+            preferred = Array(source_term.preferred).first
+            return nil unless preferred
+
+            expression = preferred.expression
+            return RenderedTextExtractor.text_of(preferred) unless expression
+
+            names = Array(expression.name)
+            return RenderedTextExtractor.text_of(preferred) if names.empty?
+
+            RenderedTextExtractor.text_of(names.first)
+          end
+
+          def add_definition(content, source_term)
+            definition = Array(source_term.definition).first
+            return unless definition
+
+            vd = definition.verbal_definition
+            return unless vd
+
+            Array(vd.p).each { |p| content << paragraph_transformer.transform(p) }
+          end
+
+          def add_standalone_paragraphs(content, source_term)
+            Array(source_term.p).each { |p| content << paragraph_transformer.transform(p) }
+          end
+
+          def add_lists(content, source_term)
+            definition = Array(source_term.definition).first
+            return unless definition
+
+            vd = definition.verbal_definition
+            return unless vd
+
+            Array(vd.ul).each { |ul| content << list_transformer.transform(ul) }
+            Array(vd.ol).each { |ol| content << list_transformer.transform(ol) }
+          end
+
+          def add_list_items(content, list)
+            Array(list.listitem).each do |li|
+              Array(li.paragraphs).each { |p| content << paragraph_transformer.transform(p) }
+            end
+          end
+
+          # Term notes become <non-normative-note> carrying their own
+          # label ("Note 1 to entry:") — plain "Note" notes leave the
+          # kind label to the renderer. Nested <ul>/<ol> inside the
+          # termnote become sibling <list> children of the note so the
+          # renderer emits them after the paragraphs.
+          def add_term_notes(content, source_term)
+            Array(source_term.termnote).each do |tn|
+              paragraphs = Array(tn.p).map { |p| paragraph_transformer.transform(p) }
+              lists = Array(tn.ul).map { |ul| list_transformer.transform(ul) } +
+                      Array(tn.ol).map { |ol| list_transformer.transform(ol) }
+              next if paragraphs.empty? && lists.empty?
+
+              attrs = { p: paragraphs }
+              attrs[:list] = lists if lists.any?
+              label = term_note_label(tn)
+              attrs[:label] = ::Sts::NisoSts::Label.new(content: [label]) if label
+              content << ::Sts::NisoSts::NonNormativeNote.new(attrs)
+            end
+          end
+
+          # MN renders term notes "<span class='term-note-label'>
+          # Term notes become <non-normative-note> with a "Note:" label
+          # — matching MN's "<span class='termnote_label'>Note: </span>"
+          # prefix inside the note paragraph. The entity's autonum
+          # ("Note 1 to entry:") isn't surfaced in MN's term notes, so
+          # we mirror that here.
+          def term_note_label(_note_obj)
+            "Note:"
+          end
+
+          def add_term_examples(content, source_term)
+            Array(source_term.termexample).each { |te| add_typed_note_paragraphs(content, te, "Example", colon: true) }
+          end
+
+          def add_typed_note_paragraphs(content, note_obj, label, colon: false)
+            suffix = colon ? ": " : "  "
+            Array(note_obj.p).each_with_index do |p, i|
+              para = paragraph_transformer.transform(p)
+              if i.zero?
+                existing = para.content.to_a
+                para.content = ["#{label}#{suffix}#{existing.first || ''}"] + existing[1..]
+              end
+              content << para
+            end
+            Array(note_obj.ul).each { |ul| content << list_transformer.transform(ul) }
+            Array(note_obj.ol).each { |ol| content << list_transformer.transform(ol) }
+          end
+
+          def build_list(list, list_type)
+            list_transformer.transform_with_type(list, list_type)
+          end
+
+          def add_sources(content, source_term)
+            Array(source_term.source).each { |s| content << build_source(s) }
+          end
+
+          def build_source(source)
+            origin = source.origin
+            return nil unless origin
+
+            citeas = origin.citeas
+            locality = extract_locality(origin)
+            ordinal = bib_ordinal(origin)
+
+            text = "[SOURCE: #{citeas}"
+            if locality
+              text << ", #{locality}"
+              text << "[#{ordinal}]" if ordinal
+              text << " "
+            end
+            text << "]"
+            ::Sts::NisoSts::Paragraph.new(text: [text])
+          end
+
+          def extract_locality(origin)
+            ls_arr = origin.locality_stack
+            return nil unless ls_arr.is_a?(Array) && ls_arr.any?
+
+            parts = []
+            ls_arr.each do |ls|
+              Array(ls.bib_locality).each do |loc|
+                from = loc.reference_from
+                val = case from
+                      when String then from
+                      when nil then ""
+                      else
+                        cv = from.content rescue nil
+                        cv ? Array(cv).first.to_s : from.to_s
+                      end
+                parts << val if val && !val.empty?
+              end
+            end
+            parts.empty? ? nil : parts.join(", ")
+          end
+
+          def bib_ordinal(origin)
+            bibitemid = origin.bibitemid
+            return nil unless bibitemid
+
+            bib = context.source.typed_root.bibliography
+            return nil unless bib
+
+            items = Array(bib.references).flat_map { |rs| Array(rs.references) }
+            items.each_with_index do |item, i|
+              return (i + 1).to_s if item.id == bibitemid || item.anchor == bibitemid
+            end
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/oiml/sts/transformer.rb

@@ -0,0 +1,47 @@
+# frozen_string: true
+
+# OIML Metanorma presentation XML → OIML NISO STS XML transformer.
+#
+# Architecture:
+# - {SourceDocument}: parses input via Metanorma::Oiml::Document::Root
+#   (typed model, on the metanorma-document framework). Zero Nokogiri.
+# - {Context}: shared state during one conversion run.
+# - {ModelBuilder}: factory methods for sts-ruby model instances.
+# - {DocumentTransformer}: orchestrator. Produces a Sts::NisoSts::Standard
+#   root via sts-ruby models and serializes via lutaml-model.
+# - Per-element transformers walk typed-model source objects and emit
+#   sts-ruby model instances. Zero Nokogiri.
+# - {RenderedTextExtractor}: unified text extraction from typed models.
+# - {BlockDispatcher}: Open/Closed dispatch by typed model class name.
+module Metanorma::Oiml::Sts::Transformer
+  autoload :SourceDocument, "metanorma/oiml/sts/transformer/source_document"
+  autoload :Standard, "metanorma/oiml/sts/transformer/standard"
+  autoload :Context, "metanorma/oiml/sts/transformer/context"
+  autoload :ModelBuilder, "metanorma/oiml/sts/transformer/model_builder"
+  autoload :IdGenerator, "metanorma/oiml/sts/transformer/id_generator"
+  autoload :FootnoteCollector, "metanorma/oiml/sts/transformer/footnote_collector"
+  autoload :Base, "metanorma/oiml/sts/transformer/base"
+  autoload :DocumentTransformer, "metanorma/oiml/sts/transformer/document_transformer"
+  autoload :FrontTransformer, "metanorma/oiml/sts/transformer/front_transformer"
+  autoload :BodyTransformer, "metanorma/oiml/sts/transformer/body_transformer"
+  autoload :BackTransformer, "metanorma/oiml/sts/transformer/back_transformer"
+  autoload :SectionTransformer, "metanorma/oiml/sts/transformer/section_transformer"
+  autoload :ParagraphTransformer, "metanorma/oiml/sts/transformer/paragraph_transformer"
+  autoload :InlineTransformer, "metanorma/oiml/sts/transformer/inline_transformer"
+  autoload :ListTransformer, "metanorma/oiml/sts/transformer/list_transformer"
+  autoload :TableTransformer, "metanorma/oiml/sts/transformer/table_transformer"
+  autoload :FigureTransformer, "metanorma/oiml/sts/transformer/figure_transformer"
+  autoload :FormulaTransformer, "metanorma/oiml/sts/transformer/formula_transformer"
+  autoload :NoteTransformer, "metanorma/oiml/sts/transformer/note_transformer"
+  autoload :ReferenceTransformer, "metanorma/oiml/sts/transformer/reference_transformer"
+  autoload :TermTransformer, "metanorma/oiml/sts/transformer/term_transformer"
+  autoload :DlTransformer, "metanorma/oiml/sts/transformer/dl_transformer"
+  autoload :BlockDispatcher, "metanorma/oiml/sts/transformer/block_dispatcher"
+  autoload :RenderedTextExtractor, "metanorma/oiml/sts/transformer/rendered_text_extractor"
+
+  def self.convert(input)
+    source = SourceDocument.parse(input)
+    context = Context.new(source)
+    DocumentTransformer.new(context).transform_to_xml(source)
+  end
+end

data/lib/metanorma/oiml/sts/validation_report.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Metanorma
+  module Oiml
+    module Sts
+      # Immutable value object holding the result of validating an OIML STS
+      # XML document. `errors` is an array of {Finding} structs.
+      class ValidationReport
+        Finding = Struct.new(:rule_id, :message, :xpath, keyword_init: true)
+
+        attr_reader :errors
+
+        def initialize(errors: [])
+          @errors = errors
+        end
+
+        def valid?
+          errors.empty?
+        end
+
+        def add(rule_id:, message:, xpath: nil)
+          @errors << Finding.new(rule_id: rule_id, message: message, xpath: xpath)
+        end
+
+        def freeze
+          @errors.freeze
+          super
+        end
+
+        def to_s
+          if valid?
+            "OIML STS validation passed (0 errors)"
+          else
+            "OIML STS validation FAILED (#{errors.size} errors):\n" \
+              "#{errors.map { |e| "  [#{e.rule_id}] #{e.message}#{' at ' + e.xpath if e.xpath}" }.join("\n")}"
+          end
+        end
+      end
+    end
+  end
+end