metanorma-iso 3.4.8 → 3.4.9

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

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::InlineTransformer < Transformer::Base
+        include Transformer::ContentText
+
+        def transform_inline(node)
+          case node
+          when String
+            [:content, node]
+          when Metanorma::Document::Components::Inline::EmRawElement
+            [:italic, transform_italic(node)]
+          when Metanorma::Document::Components::Inline::StrongRawElement
+            [:bold, transform_bold(node)]
+          when Metanorma::Document::Components::Inline::SubElement
+            [:sub, transform_sub(node)]
+          when Metanorma::Document::Components::Inline::SupElement
+            [:sup, transform_sup(node)]
+          when Metanorma::Document::Components::Inline::TtElement
+            [:monospace, transform_monospace(node)]
+          when Metanorma::Document::Components::Inline::SmallCapElement
+            [:sc, transform_smallcap(node)]
+          when Metanorma::Document::Components::Inline::XrefElement
+            [:xref, transform_xref(node)]
+          when Metanorma::Document::Components::Inline::ErefElement
+            [:std, transform_eref(node)]
+          when Metanorma::Document::Components::Inline::FnElement
+            [:xref, transform_fn(node)]
+          when Metanorma::Document::Components::Inline::LinkElement
+            [:ext_link, transform_link(node)]
+          when Metanorma::Document::Components::Inline::BrElement
+            [:break, transform_br(node)]
+          when Metanorma::Document::Components::Inline::StemInlineElement
+            [:inline_formula, transform_stem(node)]
+          when Metanorma::Document::Components::Inline::ConceptElement
+            nil
+          when Metanorma::Document::Components::Inline::SpanElement
+            [:styled_content, transform_span(node)]
+          when Metanorma::Document::Components::Inline::Bcp14Element
+            [:bold, transform_bcp14(node)]
+          end
+        end
+
+        def apply_inline_content(source, target)
+          source.each_mixed_content do |node|
+            result = transform_inline(node)
+            next unless result
+
+            type, value = result
+            if type == :content
+              target.content value
+            else
+              target.send(type, value)
+            end
+          end
+          target
+        end
+
+        def apply_term_inline_content(source, target)
+          text = extract_text(source)
+          target.content = [text] if text && !text.empty?
+          target
+        end
+
+        def apply_tbx_content(source, target, text_attr: :value)
+          source.each_mixed_content do |node|
+            result = transform_tbx_inline(node)
+            next unless result
+
+            type, value = result
+            if type == :content
+              target.send(text_attr, value)
+            else
+              target.send(type, value)
+            end
+          end
+          target
+        end
+
+        def transform_tbx_inline(node)
+          case node
+          when String
+            [:content, node]
+          when Metanorma::Document::Components::Inline::EmRawElement
+            [:italic, build_tbx_italic(node)]
+          when Metanorma::Document::Components::Inline::StrongRawElement
+            [:bold, build_tbx_bold(node)]
+          when Metanorma::Document::Components::Inline::SubElement
+            [:sub, transform_sub(node)]
+          when Metanorma::Document::Components::Inline::SupElement
+            [:sup, transform_sup(node)]
+          when Metanorma::Document::Components::Inline::XrefElement
+            [:xref, transform_xref(node)]
+          when Metanorma::Document::Components::Inline::ErefElement
+            [:std, transform_eref(node)]
+          when Metanorma::Document::Components::Inline::FnElement
+            [:xref, transform_fn(node)]
+          when Metanorma::Document::Components::Inline::LinkElement
+            [:ext_link, transform_link(node)]
+          when Metanorma::Document::Components::Inline::StemInlineElement
+            [:inline_formula, transform_stem(node)]
+          when Metanorma::Document::Components::Inline::TtElement
+            [:monospace, transform_monospace(node)]
+          end
+        end
+
+        def build_tbx_italic(node)
+          ::Sts::TbxIsoTml::Italic.new do |i|
+            apply_inline_content(node, i)
+          end
+        end
+
+        def build_tbx_bold(node)
+          ::Sts::TbxIsoTml::Bold.new do |b|
+            apply_inline_content(node, b)
+          end
+        end
+
+        private
+
+        def transform_bold(node)
+          ::Sts::IsoSts::Bold.new do |b|
+            apply_inline_content(node, b)
+          end
+        end
+
+        def transform_italic(node)
+          ::Sts::IsoSts::Italic.new do |i|
+            apply_inline_content(node, i)
+          end
+        end
+
+        def transform_sub(node)
+          ::Sts::NisoSts::Sub.new do |s|
+            s.content node.content if node.content
+          end
+        end
+
+        def transform_sup(node)
+          ::Sts::NisoSts::Sup.new do |s|
+            apply_inline_content(node, s)
+          end
+        end
+
+        def transform_monospace(node)
+          content = node.content || extract_text(node)
+          ::Sts::NisoSts::Monospace.new do |m|
+            m.content content if content
+          end
+        end
+
+        def transform_smallcap(node)
+          content = node.content || extract_text(node)
+          ::Sts::NisoSts::Sc.new do |s|
+            s.content content if content
+          end
+        end
+
+        def transform_xref(node)
+          rid = remap_id(node.target)
+          xref = ::Sts::TbxIsoTml::Xref.new
+          xref.rid = rid
+          xref.ref_type = ref_type_for(node.target)
+          text = extract_text(node)
+          xref.value = text if text && !text.empty?
+          xref
+        end
+
+        def transform_eref(node)
+          node.bibitemid
+          citeas = node.citeas
+
+          std = ::Sts::IsoSts::Std.new
+          std.std_id = citeas
+          std.type = "dated"
+
+          std_ref = ::Sts::IsoSts::StdRef.new
+          ref_text = citeas.to_s
+          if node.locality_stack && !node.locality_stack.empty?
+            localities = node.locality_stack.map do |ls|
+              Array(ls.bib_locality).map do |loc|
+                if loc.reference_from
+                  "#{loc.type} #{loc.reference_from}"
+                else
+                  loc.type.to_s
+                end
+              end
+            end.flatten.join(", ")
+            ref_text = "#{ref_text}, #{localities}" unless localities.empty?
+          end
+          std_ref.content = [ref_text]
+          std.std_ref std_ref
+          std
+        end
+
+        def transform_fn(node)
+          text = extract_fn_text(node)
+          fn_paragraphs = build_fn_paragraphs(node)
+          entry = @context.footnote_collector.register(text,
+                                                       paragraphs: fn_paragraphs)
+
+          xref = ::Sts::TbxIsoTml::Xref.new
+          xref.rid = entry[:id]
+          xref.ref_type = "fn"
+          xref.value = "<sup>#{entry[:number]})</sup>"
+          xref
+        end
+
+        def build_fn_paragraphs(node)
+          paras = []
+          return paras unless node.p && !node.p.empty?
+
+          node.p.each do |para|
+            fn_para = ::Sts::IsoSts::Paragraph.new
+            apply_inline_content(para, fn_para)
+            paras << fn_para
+          end
+          paras
+        end
+
+        def extract_fn_text(node)
+          parts = []
+          if node.p && !node.p.empty?
+            node.p.each do |para|
+              text = extract_text(para)
+              parts << text if text && !text.empty?
+            end
+          end
+          parts.join(" ")
+        end
+
+        def transform_link(node)
+          link = ::Sts::NisoSts::ExtLink.new
+          link.xlink_href = node.target if node.target
+          text = extract_text(node)
+          link.content = [text] if text && !text.empty?
+          link
+        end
+
+        def transform_br(_node)
+          ::Sts::IsoSts::Break.new
+        end
+
+        def transform_stem(node)
+          formula = ::Sts::IsoSts::InlineFormula.new
+          if node.content
+            formula.content = [node.content]
+          end
+          formula
+        end
+
+        def transform_span(node)
+          styled = ::Sts::IsoSts::StyledContent.new
+          styled.style_type = node.style if node.style
+          apply_inline_content(node, styled)
+          styled
+        end
+
+        def transform_bcp14(node)
+          content = extract_text(node)
+          ::Sts::IsoSts::Bold.new do |b|
+            b.content content if content
+          end
+        end
+
+        def ref_type_for(target)
+          return "sec" unless target
+
+          case target
+          when /^term_/
+            "term-sec"
+          when /^tab_/
+            "table"
+          when /^fig_/
+            "fig"
+          when /^formula_/
+            "disp-formula"
+          when /^fn_/
+            "fn"
+          when /^biblref_/, /^sec_bibl/
+            "bibr"
+          when /^app_/, /^sec_[A-Z]/
+            "app"
+          else
+            "sec"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/iso/sts/transformer/iso_meta_transformer.rb

@@ -0,0 +1,374 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::IsoMetaTransformer < Transformer::Base
+        include Transformer::ContentText
+
+        DOC_TYPE_MAP = {
+          "international-standard" => "IS",
+          "technical-specification" => "TS",
+          "technical-report" => "TR",
+          "publicly-available-specification" => "PAS",
+          "international-workshop-agreement" => "IWA",
+          "guide" => "GUIDE",
+          "amendment" => "Amd",
+          "technical-corrigendum" => "TCor",
+          "committee-document" => "CD",
+          "recommendation" => "R",
+        }.freeze
+
+        def transform(bibdata)
+          build_ordered(::Sts::IsoSts::IsoMeta) do |m|
+            title_wraps_for(bibdata).each { |tw| m.title_wrap tw }
+            m.doc_ident doc_ident_for(bibdata)
+            m.std_ident std_ident_for(bibdata)
+            std_refs_for(bibdata).each { |sr| m.std_ref sr }
+            m.doc_ref doc_ref_for(bibdata)
+            release_dates_for(bibdata).each { |rd| m.release_date rd }
+            m.comm_ref comm_ref_for(bibdata)
+            if (sec = secretariat_for(bibdata))
+              m.secretariat sec
+            end
+            ics_codes_for(bibdata).each { |i| m.ics i }
+            permissions_for(bibdata).each { |p| m.permissions p }
+          end
+        end
+
+        private
+
+        def title_wraps_for(bibdata)
+          wraps = []
+
+          languages_for(bibdata).each do |lang|
+            title = title_for_language(bibdata, lang)
+            next unless title
+
+            tw = build_ordered(::Sts::IsoSts::TitleWrap)
+            tw.xml_lang = lang
+
+            intro_text = title_intro_text(title)
+            tw.intro = ::Sts::IsoSts::TitleIntro.new(content: [intro_text]) if intro_text
+
+            main_text = title_main_text(title)
+            tw.main = ::Sts::IsoSts::TitleMain.new(content: [main_text]) if main_text
+
+            compl_text = title_compl_text(title)
+            tw.compl = ::Sts::IsoSts::TitleCompl.new(content: [compl_text]) if compl_text
+
+            full_text = [intro_text, main_text, compl_text].compact.join(" — ")
+            tw.full = ::Sts::IsoSts::TitleFull.new(content: [full_text]) if full_text
+
+            wraps << tw
+          end
+
+          wraps
+        end
+
+        def title_for_language(bibdata, lang)
+          titles = bibdata.titles
+          titles = titles.items if titles.is_a?(Lutaml::Model::Collection)
+          Array(titles).find do |t|
+            t_lang = t.language || t.lang
+            t_lang == lang
+          end
+        end
+
+        def title_intro_text(title)
+          ti = title.title_intro
+          extract_text_value(ti) if ti
+        end
+
+        def title_main_text(title)
+          tm = title.title_main
+          if tm
+            extract_text_value(tm)
+          elsif title.content
+            extract_text_value(title)
+          end
+        end
+
+        def title_compl_text(title)
+          tp = title.title_part
+          extract_text_value(tp) if tp
+        end
+
+        def doc_ident_for(bibdata)
+          di = ::Sts::IsoSts::DocumentIdentification.new
+          di.sdo = ::Sts::NisoSts::Sdo.new(content: [publisher_for(bibdata)])
+
+          ext = bibdata.ext
+          if ext&.structuredidentifier
+            si = ext.structuredidentifier
+            proj_num = extract_text_value(si.project_number || si)
+            di.proj_id = ::Sts::NisoSts::ProjId.new(content: [proj_num]) if proj_num && !proj_num.empty?
+          end
+
+          lang = primary_language(bibdata)
+          di.language = ::Sts::IsoSts::Language.new(content: [lang]) if lang
+
+          release_ver = release_version_for(bibdata)
+          di.release_version = ::Sts::NisoSts::ReleaseVersion.new(content: [release_ver]) if release_ver
+
+          di
+        end
+
+        def std_ident_for(bibdata)
+          si = ::Sts::IsoSts::StandardIdentification.new
+          si.originator = ::Sts::NisoSts::Originator.new(content: [publisher_for(bibdata)])
+
+          doctype_abbrev = doctype_abbreviation(bibdata)
+          si.doc_type = ::Sts::NisoSts::DocType.new(content: [doctype_abbrev]) if doctype_abbrev
+
+          if bibdata.docnumber
+            si.doc_number = ::Sts::NisoSts::DocNumber.new(content: [bibdata.docnumber])
+          end
+
+          ext = bibdata.ext
+          if ext&.structuredidentifier
+            si_struct = ext.structuredidentifier
+            if si_struct.partnumber
+              si.part_number = ::Sts::NisoSts::PartNumber.new(content: [si_struct.partnumber.to_s])
+            end
+          end
+
+          if bibdata.edition && !bibdata.edition.empty?
+            edition_val = bibdata.edition.is_a?(Array) ? bibdata.edition.first : bibdata.edition
+            edition_text = extract_text_value(edition_val) || edition_val.to_s
+            si.edition = ::Sts::IsoSts::Edition.new(content: [edition_text]) if edition_text && !edition_text.empty?
+          end
+
+          if bibdata.version
+            ver = bibdata.version
+            ver_text = ver.revision_date || "1"
+            si.version = ::Sts::NisoSts::Version.new(content: [ver_text.to_s])
+          end
+
+          si
+        end
+
+        def std_refs_for(bibdata)
+          refs = []
+
+          identifiers = doc_identifiers(bibdata)
+          primary_id = identifiers.first
+          return refs unless primary_id
+
+          ref_text = extract_text_value(primary_id) || primary_id.to_s
+          if ref_text && !ref_text.empty?
+            sr = ::Sts::IsoSts::StdRef.new
+            sr.type = "dated"
+            sr.content = [ref_text]
+            refs << sr
+
+            undated = undated_ref(ref_text)
+            if undated != ref_text
+              sr2 = ::Sts::IsoSts::StdRef.new
+              sr2.type = "undated"
+              sr2.content = [undated]
+              refs << sr2
+            end
+          end
+
+          refs
+        end
+
+        def doc_ref_for(bibdata)
+          pub = publisher_for(bibdata)
+          num = bibdata.docnumber
+          return nil unless pub && num
+
+          lang = primary_language(bibdata)
+          ref_text = "#{pub} #{num}"
+          ref_text += " (#{lang})" if lang && lang != "en"
+
+          ::Sts::IsoSts::DocRef.new(content: [ref_text])
+        end
+
+        def release_dates_for(bibdata)
+          dates = []
+          return dates unless bibdata.date
+
+          Array(bibdata.date).each do |d|
+            next unless d.type == "released"
+
+            date_val = d.on&.content || extract_text_value(d)
+            if date_val
+              rd = ::Sts::IsoSts::ReleaseDate.new
+              rd.content = [date_val.to_s]
+              dates << rd
+            end
+          end
+
+          dates
+        end
+
+        def comm_ref_for(bibdata)
+          eg = bibdata.ext&.editorial_group
+          return nil unless eg
+
+          parts = []
+          tc = eg.technical_committee
+          if tc
+            if tc.is_a?(Hash)
+              parts << "ISO/#{tc['type']} #{tc['number']}"
+            elsif tc.number
+              parts << extract_text_value(tc)
+            end
+          end
+
+          return nil if parts.empty?
+
+          ::Sts::IsoSts::CommRef.new(content: [parts.join("/")])
+        end
+
+        def secretariat_for(bibdata)
+          eg = bibdata.ext&.editorial_group
+          return nil unless eg
+
+          sec = eg.secretariat
+          return nil unless sec
+
+          ::Sts::IsoSts::Secretariat.new(content: [sec.to_s])
+        end
+
+        def ics_codes_for(bibdata)
+          ics_list = bibdata.ext&.ics
+          return [] unless ics_list
+
+          Array(ics_list).filter_map do |ics|
+            code = ics.code
+            next unless code
+
+            i = ::Sts::NisoSts::Ics.new
+            i.ics_code = ::Sts::NisoSts::IcsCode.new(content: [code.to_s])
+            i
+          end
+        end
+
+        def permissions_for(bibdata)
+          perms = []
+          return perms unless bibdata.copyright
+
+          Array(bibdata.copyright).each do |cr|
+            perm = build_ordered(::Sts::IsoSts::Permissions) do |p|
+              p.copyright_statement = ::Sts::IsoSts::CopyrightStatement.new(
+                content: ["All rights reserved"],
+              )
+
+              if cr.from
+                p.copyright_year = ::Sts::IsoSts::CopyrightYear.new(
+                  content: [cr.from.to_s],
+                )
+              end
+
+              if cr.owner
+                owners = cr.owner.is_a?(Array) ? cr.owner : [cr.owner]
+                owners.each do |owner|
+                  name = owner.organization || owner
+                  name_text = if name.name
+                                extract_text_value(name.name) || name.name.to_s
+                              elsif name.abbreviation
+                                extract_text_value(name.abbreviation) || name.abbreviation.to_s
+                              else
+                                name.to_s
+                              end
+                  next if name_text.empty?
+
+                  p.copyright_holder = ::Sts::IsoSts::CopyrightHolder.new(
+                    content: [name_text],
+                  )
+                end
+              end
+            end
+
+            perms << perm
+          end
+
+          perms
+        end
+
+        def publisher_for(bibdata)
+          return "ISO" unless bibdata.contributor
+
+          publisher = Array(bibdata.contributor).find do |c|
+            roles = c.role
+            roles = [roles] unless roles.is_a?(Array)
+            roles&.any? do |r|
+              rtype = r.type || r
+              rtype.to_s.include?("publisher")
+            end
+          end
+
+          return "ISO" unless publisher
+
+          org = publisher.organization || publisher
+          abbr = org.abbreviation
+          abbr_text = extract_text_value(abbr) || abbr.to_s
+          abbr_text.empty? ? "ISO" : abbr_text
+        end
+
+        def doctype_abbreviation(bibdata)
+          dt = bibdata.ext&.doctype
+          return nil unless dt
+
+          dt = Array(dt).first if dt.is_a?(Array)
+
+          value = dt.is_a?(String) ? dt : (dt.value || dt.abbreviation || dt.to_s)
+
+          DOC_TYPE_MAP[value] || value
+        end
+
+        def release_version_for(bibdata)
+          status = bibdata.status
+          return nil unless status
+
+          stage = status.stage
+          return nil unless stage
+
+          stage_val = extract_text_value(stage) || stage.to_s
+
+          stage_abbrev = status.stage_abbreviation
+          abbrev = extract_text_value(stage_abbrev) if stage_abbrev
+
+          case stage_val
+          when "60" then "IS"
+          when "50" then "FDIS"
+          when "40" then "DIS"
+          when "30" then "CD"
+          when "20" then "WD"
+          else abbrev || nil
+          end
+        end
+
+        def languages_for(bibdata)
+          langs = []
+          if bibdata.language
+            Array(bibdata.language).each do |l|
+              langs << (l.is_a?(String) ? l : (l.value || l.to_s))
+            end
+          end
+          langs.empty? ? ["en"] : langs
+        end
+
+        def primary_language(bibdata)
+          languages_for(bibdata).first
+        end
+
+        def doc_identifiers(bibdata)
+          return [] unless bibdata.doc_identifier
+
+          Array(bibdata.doc_identifier).select do |di|
+            type = di.type
+            !type || type == "ISO" || type == "std" || type == "URN"
+          end
+        end
+
+        def undated_ref(ref)
+          ref.sub(/:\d{4}$/, "")
+        end
+      end
+    end
+  end
+end