metanorma-oiml 0.1.0

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

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        # Factory methods for building sts-ruby model instances.
+        # Zero Nokogiri — all models are constructed via lutaml-model.
+        module ModelBuilder
+          module_function
+
+          def standard(lang:, dtd_version: "1.2", front: nil, body: nil, back: nil)
+            ::Sts::NisoSts::Standard.new(
+              lang: lang,
+              dtd_version: dtd_version
+            ).tap do |std|
+              std.front = front if front
+              std.body = body if body
+              std.back = back if back
+            end
+          end
+
+          def front(std_meta: nil)
+            ::Sts::NisoSts::Front.new.tap { |f| f.std_meta = std_meta if std_meta }
+          end
+
+          def body(sec: [])
+            ::Sts::NisoSts::Body.new(sec: Array(sec))
+          end
+
+          def back(app_group: nil, ref_list: [])
+            attrs = {}
+            attrs[:ref_list] = Array(ref_list) if ref_list&.any?
+            ::Sts::NisoSts::Back.new(attrs).tap do |b|
+              b.app_group = app_group if app_group
+            end
+          end
+
+          def app_group(app: [])
+            ::Sts::NisoSts::AppGroup.new(app: Array(app))
+          end
+
+          def sec(id: nil, label: nil, title: nil, content: [], paragraph: [], sec: [],
+                  list: [], table_wrap: [], fig: [], non_normative_note: [],
+                  non_normative_example: [])
+            all_content = Array(content) + Array(paragraph)
+            distributed = distribute_sec_content(all_content)
+
+            attrs = {}
+            attrs[:id] = id if id
+            attrs[:title] = ::Sts::NisoSts::Title.new(content: [title]) if title
+            attrs[:paragraphs] = distributed[:paragraph] if distributed[:paragraph].any?
+            attrs[:sec] = Array(sec) if sec&.any?
+            attrs[:list] = (Array(list) + distributed[:list]) if (list&.any? || distributed[:list].any?)
+            attrs[:table_wrap] = (Array(table_wrap) + distributed[:table_wrap]) if (table_wrap&.any? || distributed[:table_wrap].any?)
+            attrs[:fig] = (Array(fig) + distributed[:fig]) if (fig&.any? || distributed[:fig].any?)
+            attrs[:non_normative_note] = (Array(non_normative_note) + distributed[:note]) if (non_normative_note&.any? || distributed[:note].any?)
+            attrs[:non_normative_example] = (Array(non_normative_example) + distributed[:example]) if (non_normative_example&.any? || distributed[:example].any?)
+            ::Sts::NisoSts::Section.new(attrs)
+          end
+
+          def distribute_sec_content(content)
+            result = Hash.new { |h, k| h[k] = [] }
+            content.each do |item|
+              case item
+              when ::Sts::NisoSts::Paragraph then result[:paragraph] << item
+              when ::Sts::NisoSts::List then result[:list] << item
+              when ::Sts::NisoSts::Figure then result[:fig] << item
+              when ::Sts::TbxIsoTml::TableWrap then result[:table_wrap] << item
+              when ::Sts::NisoSts::NonNormativeNote then result[:note] << item
+              when ::Sts::NisoSts::NonNormativeExample then result[:example] << item
+              when ::Sts::NisoSts::DisplayFormula then result[:formula] << item
+              when ::Sts::NisoSts::DefList then result[:def_list] << item
+              end
+            end
+            result
+          end
+
+          def paragraph(id: nil)
+            ::Sts::NisoSts::Paragraph.new.tap do |p|
+              p.id = id if id
+              yield p if block_given?
+            end
+          end
+
+          def list(list_type: "bullet", list_item: [])
+            ::Sts::NisoSts::List.new(list_type: list_type, list_item: Array(list_item))
+          end
+
+          def def_list(id: nil, def_items: [])
+            items = Array(def_items)
+            ::Sts::NisoSts::DefList.new.tap do |dl|
+              dl.id = id if id
+              dl.def_item = items if items.any?
+            end
+          end
+
+          def def_item(id: nil, term: nil, defn: nil)
+            ::Sts::NisoSts::DefItem.new.tap do |di|
+              di.id = id if id
+              di.term = term if term
+              di.definition = defn if defn
+            end
+          end
+          def term(content: [])
+            ::Sts::NisoSts::Term.new(text: Array(content))
+          end
+
+          def def(paragraph: [])
+            ::Sts::NisoSts::Def.new(paragraph: Array(paragraph))
+          end
+
+          def list_item(paragraph: [])
+            ::Sts::NisoSts::ListItem.new(p: Array(paragraph))
+          end
+
+          def table_wrap(id: nil, caption: nil, table: nil)
+            ::Sts::TbxIsoTml::TableWrap.new.tap do |tw|
+              tw.id = id if id
+              tw.caption = caption if caption
+              tw.table = [table] if table
+            end
+          end
+
+          def table(thead: nil, tbody: nil)
+            ::Sts::TbxIsoTml::Table.new.tap do |t|
+              t.thead = thead if thead
+              t.tbody = tbody if tbody
+            end
+          end
+
+          def thead(tr: [])
+            ::Sts::TbxIsoTml::Thead.new(tr: Array(tr))
+          end
+
+          def tbody(tr: [])
+            ::Sts::TbxIsoTml::Tbody.new(tr: Array(tr))
+          end
+
+          def tr(th: [], td: [])
+            attrs = {}
+            attrs[:th] = Array(th) if th&.any?
+            attrs[:td] = Array(td) if td&.any?
+            ::Sts::TbxIsoTml::Tr.new(attrs)
+          end
+
+          def th(content: nil)
+            ::Sts::TbxIsoTml::Th.new.tap { |c| c.content = Array(content) if content }
+          end
+
+          def td(content: nil)
+            ::Sts::TbxIsoTml::Td.new.tap { |c| c.content = Array(content) if content }
+          end
+
+          def fig(id: nil, label: nil, caption: nil, graphic: nil)
+            ::Sts::NisoSts::Figure.new.tap do |f|
+              f.id = id if id
+              f.label = ::Sts::NisoSts::Label.new(content: [label]) if label
+              f.caption = caption if caption
+              f.graphic = [graphic] if graphic
+            end
+          end
+
+          def graphic(href: nil)
+            ::Sts::NisoSts::Graphic.new(href: xlink_href)
+          end
+
+          def caption(title: nil)
+            ::Sts::NisoSts::Caption.new.tap do |c|
+              c.title = ::Sts::NisoSts::Title.new(content: [title]) if title
+            end
+          end
+
+          def disp_formula(id: nil, label: nil, math: nil)
+            ::Sts::NisoSts::DisplayFormula.new.tap do |f|
+              f.id = id if id
+              f.label = ::Sts::NisoSts::Label.new(content: [label]) if label
+              f.math = math if math
+            end
+          end
+
+          def inline_formula(math: nil)
+            ::Sts::NisoSts::InlineFormula.new(math: math)
+          end
+
+          def non_normative_note(paragraph: [], label: nil)
+            ::Sts::NisoSts::NonNormativeNote.new.tap do |n|
+              n.p = Array(paragraph) if paragraph&.any?
+              n.label = ::Sts::NisoSts::Label.new(content: [label]) if label
+            end
+          end
+
+          def non_normative_example(paragraph: [], label: nil)
+            ::Sts::NisoSts::NonNormativeExample.new.tap do |e|
+              e.p = Array(paragraph) if paragraph&.any?
+              e.label = ::Sts::NisoSts::Label.new(content: [label]) if label
+            end
+          end
+
+          def ref_list(content_type: nil, title: nil, ref: [])
+            ::Sts::NisoSts::ReferenceList.new.tap do |rl|
+              rl.content_type = content_type if content_type
+              rl.title = ::Sts::NisoSts::Title.new(content: [title]) if title
+              rl.ref = Array(ref) if ref&.any?
+            end
+          end
+
+          def ref(label: nil, mixed_citation: nil, std: nil)
+            ::Sts::NisoSts::Reference.new.tap do |r|
+              r.label = ::Sts::NisoSts::Label.new(content: [label]) if label
+              r.mixed_citation = ::Sts::NisoSts::MixedCitation.new(content: [mixed_citation]) if mixed_citation
+              r.std = std if std
+            end
+          end
+
+          # Builds the OIML front-matter metadata block. OIML is not
+          # ISO — the NISO-STS-correct container for an OIML publication
+          # is <std-meta> (the generic catch-all for non-ISO / non-
+          # national / non-regional SDOs). MetadataStd ships the same
+          # attribute set as MetadataIso (title_wrap, std_ident,
+          # permissions, pub_date, custom_meta_group), but several
+          # are collections where MetadataIso's were singular.
+          def std_meta(doc_identifier: nil, title: nil, pub_date: nil,
+                       permissions: nil, custom_meta_group: nil)
+            ::Sts::NisoSts::MetadataStd.new.tap do |m|
+              m.title_wrap = [::Sts::NisoSts::TitleWrap.new(main: title)] if title
+              m.std_ident = std_ident_for(doc_identifier) if doc_identifier
+              m.permissions = [permissions] if permissions
+              m.pub_date = pub_date.to_s if pub_date
+              m.custom_meta_group = [custom_meta_group] if custom_meta_group
+            end
+          end
+
+          # <std-ident> per NISO STS (Z39.102-2022): the OIML identifier
+          # decomposed into originator + doc-type + doc-number
+          # (+ part-number). "OIML B 6-2:2024" → OIML / b / 6 / 2. The
+          # publication year is NOT repeated here — pub-date carries it.
+          # Identifiers that don't match the OIML pattern fall back to a
+          # plain originator string rather than being dropped.
+          OIML_ID_PATTERN = /\A(OIML)\s+([A-Z]+)\s+(\d+)(?:-(\d+))?(?::\d{4})?\z/.freeze
+
+          def std_ident_for(doc_identifier)
+            match = OIML_ID_PATTERN.match(doc_identifier.to_s.strip)
+            return plain_std_ident(doc_identifier) unless match
+
+            attrs = {
+              originator: match[1],
+              doc_type: match[2].downcase,
+              doc_number: match[3],
+            }
+            attrs[:part_number] = match[4] if match[4]
+            ::Sts::NisoSts::StandardIdentification.new(attrs)
+          end
+
+          def plain_std_ident(doc_identifier)
+            ::Sts::NisoSts::StandardIdentification.new(originator: doc_identifier)
+          end
+
+          def permissions(holder: nil, year: nil)
+            attrs = {}
+            attrs[:copyright_statement] = "© #{year} #{holder}" if year && holder
+            attrs[:copyright_year] = year.to_s if year
+            attrs[:copyright_holder] = holder.to_s if holder
+            ::Sts::NisoSts::Permissions.new(attrs)
+          end
+
+          def custom_meta_group(name: nil, value: nil)
+            ::Sts::NisoSts::CustomMetaGroup.new(
+              custom_meta: [::Sts::NisoSts::CustomMeta.new(
+                meta_name: name, meta_value: value
+              )]
+            )
+          end
+
+          def bold(content: [])
+            ::Sts::TbxIsoTml::Bold.new(value: Array(content))
+          end
+
+          def italic(content: [])
+            ::Sts::TbxIsoTml::Italic.new(value: Array(content))
+          end
+
+          def monospace(content: [])
+            ::Sts::NisoSts::Monospace.new(content: Array(content))
+          end
+
+          def sub(content: [])
+            ::Sts::NisoSts::Sub.new(content: Array(content))
+          end
+
+          def sup(content: [])
+            ::Sts::NisoSts::Sup.new(content: Array(content))
+          end
+
+          def ext_link(xlink_href: nil, content: [])
+            ::Sts::NisoSts::ExtLink.new(
+              ext_link_type: "uri",
+              xlink_href: xlink_href,
+              content: Array(content)
+            )
+          end
+
+          def xref(rid: nil, ref_type: "other", value: nil)
+            ::Sts::TbxIsoTml::Xref.new(rid: rid, ref_type: ref_type, value: value)
+          end
+
+          def fn(id: nil, value: nil)
+            ::Sts::TbxIsoTml::Fn.new(id: id, value: value)
+          end
+
+          def title(content: [])
+            ::Sts::NisoSts::Title.new(content: Array(content))
+          end
+
+          def label(content: [])
+            ::Sts::NisoSts::Label.new(content: Array(content))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Metanorma
+  module Oiml
+    module Sts
+      module Transformer
+        # Converts MN <note> / <example> blocks (outside term entries)
+        # to STS <non-normative-note> / <non-normative-example>.
+        # Body notes carry NO label — the renderer prepends the kind
+        # label ("NOTE" / "EXAMPLE") outside the first paragraph, the
+        # way Metanorma marks up body notes ("<span class='note-label'>
+        # NOTE</span>&nbsp;<p>…"). Term entries use "Note N to entry:"
+        # via TermTransformer.
+        class NoteTransformer < Base
+          def transform(source_note)
+            paragraphs = extract_paragraphs(source_note)
+            return nil if paragraphs.empty?
+
+            if example?(source_note)
+              label = example_label(source_note)
+              ModelBuilder.non_normative_example(paragraph: paragraphs, label: label)
+            else
+              ModelBuilder.non_normative_note(paragraph: paragraphs)
+            end
+          end
+
+          # MN renders body examples as "<span class='example-label'>
+          # EXAMPLE N</span>" — "Example" plus the autonum, even when
+          # the source carries no explicit name. The label ends up
+          # inside the first paragraph so parity text comparison sees
+          # it on both sides.
+          def example_label(source_example)
+            return nil unless source_example.is_a?(example_block_class)
+
+            number = source_example.autonum if source_example.class.method_defined?(:autonum)
+            number && !number.to_s.empty? ? "Example #{number}" : nil
+          end
+
+          # SourcecodeBlock stores its text in body.content (the bare
+          # `content` attribute is nil for parsed documents). The body's
+          # content is markup-encoded by the model's roundtrip contract;
+          # decoded_content (metanorma-document >= 0.3.1) unwraps it —
+          # with a local decode as the fallback for older releases.
+          def transform_preformat(source_code)
+            text = preformat_text(source_code)
+            return nil if text.nil? || text.empty?
+
+            ::Sts::NisoSts::Preformat.new(content: [text])
+          end
+
+          private
+
+          def example?(source_note)
+            source_note.is_a?(example_block_class)
+          end
+
+          def extract_paragraphs(source_note)
+            case source_note
+            when example_block_class
+              Array(source_note.paragraphs).map { |p| paragraph_transformer.transform(p) }
+            when note_block_class
+              Array(source_note.content)
+                .select { |p| p.is_a?(paragraph_block_class) }
+                .map { |p| paragraph_transformer.transform(p) }
+            else
+              []
+            end
+          end
+
+          def preformat_text(source_code)
+            return unless source_code.is_a?(sourcecode_block_class)
+
+            body = source_code.body
+            return source_code.text unless body
+
+            content = body.content if body.is_a?(Lutaml::Model::Serializable)
+            return CGI.unescapeHTML(Array(content).join) if content && !content.to_s.empty?
+
+            source_code.text
+          end
+
+          def note_block_class
+            Metanorma::Document::Components::Blocks::NoteBlock
+          end
+
+          def example_block_class
+            Metanorma::Document::Components::AncillaryBlocks::ExampleBlock
+          end
+
+          def sourcecode_block_class
+            Metanorma::Document::Components::AncillaryBlocks::SourcecodeBlock
+          end
+
+          def paragraph_block_class
+            Metanorma::Document::Components::Paragraphs::ParagraphBlock
+          end
+        end
+      end
+    end
+  end
+end