metanorma-oiml 0.1.0

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class BlockDispatcher < Base
+          HANDLERS = {
+            "IsoClauseSection"             => :dispatch_via_section,
+            "ClauseSection"                => :dispatch_via_section,
+            "IsoForewordSection"           => :dispatch_via_section,
+            "IsoIntroductionSection"       => :dispatch_via_section,
+            "IsoTermsSection"              => :dispatch_via_section,
+            "DefinitionSection"            => :dispatch_via_section,
+            "IsoAnnexSection"              => :dispatch_via_section,
+            "ParagraphBlock"               => :dispatch_via_paragraph,
+            "ParagraphWithFootnote"        => :dispatch_via_paragraph,
+            "UnorderedList"                => :dispatch_via_list,
+            "OrderedList"                  => :dispatch_via_list,
+            "DefinitionList"               => :dispatch_via_dl,
+            "TableBlock"                   => :dispatch_via_table,
+            "FigureBlock"                  => :dispatch_via_figure,
+            "FormulaBlock"                 => :dispatch_via_formula,
+            "NoteBlock"                    => :dispatch_via_note,
+            "ExampleBlock"                 => :dispatch_via_note,
+            "AdmonitionBlock"              => :dispatch_via_note,
+            "QuoteBlock"                   => :dispatch_via_note,
+            "SourcecodeBlock"              => :dispatch_via_sourcecode,
+            "StandardReferencesSection"    => :dispatch_via_references,
+            "BibliographySection"          => :dispatch_via_references
+          }.freeze
+
+          PRESENTATION_CLASSES = %w[
+            FmtTitleElement FmtXrefLabelElement FmtNameElement FmtStemElement
+            FmtFnLabelElement FmtConceptElement SemxElement LocalizedString
+            LocalizedStrings FmtVal AsciiMath BrElement TabElement Bookmark
+            SpanElement
+          ].freeze
+
+          def dispatch(source_obj)
+            return nil if source_obj.nil? || source_obj.is_a?(String)
+            class_name = source_obj.class.name&.split("::")&.last
+            return nil if PRESENTATION_CLASSES.include?(class_name)
+
+            handler = HANDLERS[class_name]
+            return nil unless handler
+
+            send(handler, source_obj)
+          end
+
+          SECTION_CLASS_NAMES = %w[
+            IsoClauseSection ClauseSection IsoForewordSection
+            IsoIntroductionSection IsoTermsSection DefinitionSection
+            IsoAnnexSection AnnexSection
+          ].freeze
+
+          # Typed attribute → handler method mapping for ContentSection.
+          # These are NOT yielded by each_mixed_content; we iterate them
+          # explicitly to dispatch tables, lists, notes, etc.
+          TYPED_ATTR_DISPATCH = {
+            paragraphs: :dispatch_via_paragraph,
+            unordered_lists: :dispatch_via_list,
+            ordered_lists: :dispatch_via_list,
+            tables: :dispatch_via_table,
+            figures: :dispatch_via_figure,
+            formulas: :dispatch_via_formula,
+            notes: :dispatch_via_note,
+            examples: :dispatch_via_note,
+            admonitions: :dispatch_via_note,
+            sourcecode_blocks: :dispatch_via_sourcecode,
+            quote_blocks: :dispatch_via_note,
+            definition_lists: :dispatch_via_dl,
+            definitions: :dispatch_via_section,
+          }.freeze
+
+          def dispatch_section_blocks(section)
+            results = []
+
+            # Walk typed collection attributes for all content types.
+            # each_mixed_content is NOT used because it overlaps with
+            # typed attributes (causing duplication) and misses some
+            # content types (tables, lists, notes).
+            TYPED_ATTR_DISPATCH.each do |attr, handler|
+              next unless section.class.method_defined?(attr)
+              collection = section.public_send(attr)
+              Array(collection).each do |item|
+                result = send(handler, item)
+                results << result if result
+                dispatch_paragraph_siblings(item, results)
+              end
+            end
+
+            results
+          end
+
+          # MN's typed model attaches "block siblings" as attributes on
+          # the preceding block (ParagraphBlock.note holds notes that
+          # semantically follow the paragraph; TableBlock.note holds
+          # table notes, which render right after the table). Walk those
+          # sibling collections and dispatch each, preserving document
+          # order. Restricted to ParagraphBlock and TableBlock to avoid
+          # firing for lists/etc. that have their own note sub-collections
+          # with different semantics.
+          def dispatch_paragraph_siblings(item, results)
+            return unless paragraph_block?(item) || table_block?(item)
+
+            SIBLING_ATTRS.each do |attr, handler|
+              next unless item.class.method_defined?(attr)
+              Array(item.public_send(attr)).each do |sibling|
+                result = send(handler, sibling)
+                results << result if result
+              end
+            end
+          end
+
+          def paragraph_block?(item)
+            item.is_a?(Metanorma::Document::Components::Paragraphs::ParagraphBlock)
+          end
+
+          def table_block?(item)
+            item.is_a?(Metanorma::Document::Components::Tables::TableBlock)
+          end
+
+          SIBLING_ATTRS = {
+            note: :dispatch_via_note,
+            example: :dispatch_via_note,
+          }.freeze
+
+          private
+
+          def dispatch_via_section(obj);   section_transformer.transform(obj);   end
+          def dispatch_via_paragraph(obj); paragraph_transformer.transform(obj); end
+          def dispatch_via_list(obj);     list_transformer.transform(obj);     end
+          def dispatch_via_dl(obj);       dl_transformer.transform(obj);       end
+          def dispatch_via_table(obj);    table_transformer.transform(obj);    end
+          def dispatch_via_figure(obj);   figure_transformer.transform(obj);   end
+          def dispatch_via_formula(obj);  formula_transformer.transform(obj);  end
+          def dispatch_via_note(obj);     note_transformer.transform(obj);     end
+          def dispatch_via_sourcecode(obj); note_transformer.transform_preformat(obj); end
+          def dispatch_via_references(obj); reference_transformer.transform_section(obj); end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class BodyTransformer < Base
+          def transform(source)
+            sections = []
+
+            sections += front_transformer.preface_sections(source) if source.front?
+
+            source.sections.each do |clause|
+              sec = dispatcher.dispatch(clause)
+              sections << sec if sec
+            end
+
+            ModelBuilder.body(sec: sections)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class Context
+          attr_reader :source, :id_generator, :footnote_collector
+
+          def initialize(source)
+            @source = source
+            @id_generator = IdGenerator.new
+            @footnote_collector = FootnoteCollector.new
+          end
+
+          def language
+            source.language || "en"
+          end
+
+          def docidentifier
+            source.docidentifier
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        # Converts MN `<dl>`/`<dt>`/`<dd>` to STS `<def-list>`/`<def-item>`.
+        # Follows mnconvert's pattern (mn2xml.xsl lines 5327-5528): each
+        # dt/dd pair becomes a def-item with term + def children. Notes
+        # inside dl are extracted as siblings after the def-list.
+        class DlTransformer < Base
+          def transform(source_dl)
+            def_items = pair_dt_dd(source_dl)
+            ModelBuilder.def_list(id: source_dl.id, def_items: def_items)
+          end
+
+          private
+
+          def pair_dt_dd(source_dl)
+            dts = Array(source_dl.dt)
+            dds = Array(source_dl.dd)
+            dts.each_with_index.map do |dt, i|
+              build_def_item(dt, dds[i])
+            end
+          end
+
+          def build_def_item(dt, dd)
+            attrs = {}
+            attrs[:id] = dt.id if dt.class.method_defined?(:id) && dt.id
+
+            term_text = RenderedTextExtractor.text_of(dt)
+            term = term_text.nil? || term_text.empty? ? nil : ModelBuilder.term(content: [term_text])
+
+            defn = dd ? build_def(dd) : nil
+
+            attrs[:term] = term if term
+            attrs[:defn] = defn if defn
+            ModelBuilder.def_item(**attrs)
+          end
+
+          def build_def(dd)
+            paragraphs = Array(dd.p).map { |p| paragraph_transformer.transform(p) }
+            ModelBuilder.def(paragraph: paragraphs)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class DocumentTransformer < Base
+          def transform(source)
+            front_model = build_front(source)
+            body_model = build_body(source)
+            back_model = build_back(source)
+
+            std = ModelBuilder.standard(
+              lang: context.language,
+              dtd_version: "1.2",
+              front: front_model,
+              body: body_model,
+              back: back_model
+            )
+            std
+          end
+
+          def transform_to_xml(source)
+            std = transform(source)
+            xml = std.to_xml
+            inject_namespaces(xml)
+              .then { |x| inject_processing_meta(x) }
+              .then { |x| fix_lang_attribute(x) }
+          end
+
+          private
+
+          def build_front(source)
+            return nil unless source.has_metadata?
+            front_transformer.transform(source)
+          end
+
+          def build_body(source)
+            BodyTransformer.new(context).transform(source)
+          end
+
+          def build_back(source)
+            return nil unless source.has_back?
+            BackTransformer.new(context).transform(source)
+          end
+
+          def inject_namespaces(xml)
+            return xml if xml.include?("xmlns:xlink")
+            xml.sub("<standard", '<standard xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:mml="http://www.w3.org/1998/Math/MathML"')
+          end
+
+          def inject_processing_meta(xml)
+            return xml if xml.include?("<processing-meta")
+            meta = '<processing-meta tagset-family="sts" base-tagset="interchange" table-model="xhtml" mathml="MathML 3.0" terminology-model="tbx"/>'
+            xml.sub(/(<standard[^>]*>)/, "\\1\n  #{meta}")
+          end
+
+          def fix_lang_attribute(xml)
+            xml.gsub(/\slang="([a-z-]+)"/, ' xml:lang="\\1"')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class FigureTransformer < Base
+          def transform(source_fig)
+            attrs = {}
+            attrs[:id] = source_fig.id if source_fig.class.method_defined?(:id) && source_fig.id
+
+            label_text = extract_label(source_fig)
+            caption_text = extract_title(source_fig)
+            graphic = extract_graphic(source_fig)
+
+            ModelBuilder.fig(id: attrs[:id], label: label_text, caption: ModelBuilder.caption(title: caption_text), graphic: graphic)
+          end
+
+          private
+
+          # "Figure 1" from the presentation XML autonum attribute —
+          # same pattern as TableTransformer's label.
+          def extract_label(source_fig)
+            return nil unless source_fig.class.method_defined?(:autonum) && source_fig.autonum
+
+            "Figure #{source_fig.autonum}"
+          end
+
+          def extract_title(source_fig)
+            return nil unless source_fig.class.method_defined?(:name) && source_fig.name
+
+            text = RenderedTextExtractor.text_of(source_fig.name).strip
+            text.empty? ? nil : text
+          end
+
+          def extract_graphic(source_fig)
+            return nil unless source_fig.class.method_defined?(:image)
+            images = Array(source_fig.image)
+            return nil if images.empty?
+            img = images.first
+            href = img.src if img.class.method_defined?(:src)
+            href ||= img.href if img.class.method_defined?(:href)
+            return nil unless href
+            ModelBuilder.graphic(xlink_href: href)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        # Collects footnotes during conversion so they can be flushed to the
+        # right location in the STS output.
+        class FootnoteCollector
+          def initialize
+            @seen = {}
+            @counter = 0
+          end
+
+          def register(source_id)
+            return @seen[source_id] if @seen.key?(source_id)
+
+            @counter += 1
+            @seen[source_id] = "fn_#{@counter}"
+          end
+
+          def known?(source_id)
+            @seen.key?(source_id)
+          end
+
+          def size
+            @seen.size
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class FormulaTransformer < Base
+          def transform(source_formula)
+            id = source_formula.id if source_formula.class.method_defined?(:id) && source_formula.id
+            label = extract_label(source_formula)
+            math = extract_math(source_formula)
+            ModelBuilder.disp_formula(id: id, label: label, math: math)
+          end
+
+          private
+
+          def extract_label(source_formula)
+            return nil unless source_formula.class.method_defined?(:fmt_name)
+            fmt_name = Array(source_formula.fmt_name).first
+            return nil unless fmt_name
+            RenderedTextExtractor.text_of(fmt_name)
+          end
+
+          # MathML passthrough: extract <math> from the formula's stem and
+          # parse into Mml::V3::Math. Delegates to MathmlBuilder so the
+          # math extraction logic lives in one place. Zero Nokogiri.
+          def extract_math(source_formula)
+            stem = first_stem(source_formula)
+            return nil unless stem
+
+            ::Metanorma::Oiml::Sts::MathmlBuilder.math_from_stem(stem)
+          end
+
+          def first_stem(source_formula)
+            if source_formula.class.method_defined?(:stem)
+              Array(source_formula.stem).first
+            elsif source_formula.class.method_defined?(:formula)
+              formula_el = Array(source_formula.formula).first
+              Array(formula_el.stem).first if formula_el
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class FrontTransformer < Base
+          def transform(source)
+            std_meta = build_std_meta(source)
+            ModelBuilder.front(std_meta: std_meta)
+          end
+
+          def preface_sections(source)
+            sections = []
+            sections += build_boilerplate(source)
+            sections += build_foreword(source) if source.foreword
+            sections += build_introduction(source) if source.introduction
+            sections
+          end
+
+          private
+
+          def build_std_meta(source)
+            title = source.formatted_title || source.title(type: "main") || source.title
+            ModelBuilder.std_meta(
+              doc_identifier: source.docidentifier,
+              title: title,
+              pub_date: source.pub_date,
+              permissions: ModelBuilder.permissions(
+                holder: source.copyright_holder || source.publisher || "OIML",
+                year: source.copyright_year || source.pub_date
+              ),
+              custom_meta_group: build_custom_meta(source)
+            )
+          end
+
+          def build_custom_meta(source)
+            series = source.docidentifier.to_s.match(/OIML\s+([A-Z])\s/) { |m| m[1] }
+            return nil unless series
+            ModelBuilder.custom_meta_group(name: "oiml-doc-series", value: series)
+          end
+
+          def build_boilerplate(source)
+            typed = source.typed_root
+            bp = typed.boilerplate
+            return [] unless bp
+
+            sections = []
+            Array(bp.copyright_statement).each do |cs|
+              paragraphs = []
+              cs.each_mixed_content do |inner|
+                next if inner.is_a?(String)
+                next unless inner.class.method_defined?(:paragraphs)
+                Array(inner.paragraphs).each { |p| paragraphs << paragraph_transformer.transform(p) }
+              end
+              next if paragraphs.empty?
+              sections << ModelBuilder.sec(title: "Copyright", paragraph: paragraphs)
+            end
+            Array(bp.feedback_statement).each do |fs|
+              paragraphs = []
+              fs.each_mixed_content do |inner|
+                next if inner.is_a?(String)
+                next unless inner.class.method_defined?(:paragraphs)
+                Array(inner.paragraphs).each { |p| paragraphs << paragraph_transformer.transform(p) }
+              end
+              next if paragraphs.empty?
+              sections << ModelBuilder.sec(title: "Feedback", paragraph: paragraphs)
+            end
+            sections
+          end
+
+          def build_foreword(source)
+            content = dispatcher.dispatch_section_blocks(source.foreword)
+            [ModelBuilder.sec(title: "Foreword", paragraph: content)]
+          end
+
+          def build_introduction(source)
+            content = dispatcher.dispatch_section_blocks(source.introduction)
+            [ModelBuilder.sec(title: "Introduction", paragraph: content)]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class IdGenerator
+          def initialize
+            @registry = {}
+            @counter = 0
+          end
+
+          def register(source_id, sts_id)
+            @registry[source_id] = sts_id
+          end
+
+          def remap(source_id)
+            @registry[source_id]
+          end
+
+          def id_for(obj, prefix: "sec")
+            return nil unless obj
+            source_id = obj.id if obj.is_a?(Lutaml::Model::Serializable) && obj.class.method_defined?(:id)
+            source_id ||= nil
+
+            if source_id && !source_id.empty?
+              return @registry[source_id] if @registry.key?(source_id)
+              register(source_id, source_id)
+              return source_id
+            end
+
+            @counter += 1
+            "#{prefix}_#{@counter}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class InlineTransformer < Base
+          def transform(source_node)
+            paragraph_transformer.transform(source_node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        class ListTransformer < Base
+          def transform(source_list)
+            list_type = source_list.is_a?(Metanorma::Document::Components::Lists::OrderedList) ? "order" : "bullet"
+            items = Array(source_list.listitem).map { |li| build_list_item(li) }
+            ModelBuilder.list(list_type: list_type, list_item: items)
+          end
+
+          def transform_def_list(source_dl)
+            items = Array(source_dl.dt).zip(Array(source_dl.dd)).map do |dt, dd|
+              build_def_item(dt, dd)
+            end.compact
+            ::Sts::NisoSts::DefList.new(def_item: items)
+          end
+
+          private
+
+          def build_list_item(li)
+            nested_lists = build_nested_lists(li)
+
+            ::Sts::NisoSts::ListItem.new do |item|
+              label = item_label(li)
+              item.label ::Sts::NisoSts::Label.new(content: [label]) if label
+              Array(li.paragraphs).each { |p| item.p paragraph_transformer.transform(p) }
+              nested_lists.each { |l| item.list l }
+            end
+          end
+
+          # The item's marker from the presentation XML (its fmt-name /
+          # autonum, e.g. "—" or "1."), nil when absent.
+          def item_label(li)
+            return nil unless li.class.method_defined?(:fmt_name) && li.fmt_name
+
+            text = RenderedTextExtractor.text_of(li.fmt_name).strip
+            text.empty? ? nil : text
+          end
+
+          # Recurses into nested <ul>/<ol> children of a list item.
+          # MN stores them as typed collection attrs on ListItem.
+          def build_nested_lists(li)
+            results = []
+            [:unordered_lists, :ordered_lists].each do |attr|
+              next unless li.class.method_defined?(attr)
+              Array(li.public_send(attr)).each do |nested|
+                results << transform(nested)
+              end
+            end
+            results
+          end
+
+          def build_def_item(dt, dd)
+            term_text = RenderedTextExtractor.text_of(dt)
+            desc_text = extract_dd_text(dd)
+            return nil unless term_text || desc_text
+
+            attrs = {}
+            attrs[:term] = ::Sts::NisoSts::Term.new(text: [term_text]) if term_text && !term_text.empty?
+            if desc_text && !desc_text.empty?
+              attrs[:def] = ::Sts::NisoSts::Def.new(
+                paragraph: [::Sts::NisoSts::Paragraph.new(content: [desc_text])]
+              )
+            end
+            ::Sts::NisoSts::DefItem.new(attrs)
+          end
+
+          def extract_dd_text(dd)
+            return nil unless dd
+            ps = dd.p if dd.is_a?(Lutaml::Model::Serializable) && dd.class.method_defined?(:p)
+            ps = Array(ps)
+            return RenderedTextExtractor.text_of(dd) if ps.empty?
+            texts = ps.map { |p| RenderedTextExtractor.text_of(p) }.reject(&:empty?)
+            texts.empty? ? nil : texts.join(" ")
+          end
+        end
+      end
+    end
+  end
+end