metanorma-iso 3.4.8 → 3.4.9

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::Context
+        attr_reader :source_document, :id_generator, :footnote_collector
+
+        def initialize(source_document)
+          @source_document = source_document
+          @id_generator = Transformer::IdGenerator.new(self)
+          @footnote_collector = Transformer::FootnoteCollector.new
+        end
+
+        def language
+          return nil unless @source_document
+
+          bibdata = @source_document.bibdata
+          return nil unless bibdata
+
+          lang = bibdata.language
+          lang.is_a?(Array) ? lang.first : lang
+        end
+
+        def script
+          return nil unless @source_document
+
+          bibdata = @source_document.bibdata
+          return nil unless bibdata
+
+          scr = bibdata.script
+          scr.is_a?(Array) ? scr.first : scr
+        end
+
+        def doctype
+          bibdata = @source_document.bibdata
+          bibdata&.ext&.doctype
+        end
+
+        def bibitem_lookup
+          @bibitem_lookup ||= build_bibitem_lookup
+        end
+
+        private
+
+        def build_bibitem_lookup
+          lookup = {}
+          bib = @source_document.bibliography
+          return lookup unless bib
+
+          bib.references&.each do |ref_section|
+            ref_section.references&.each do |bibitem|
+              next unless bibitem.id
+
+              lookup[bibitem.id] = bibitem
+            end
+          end
+
+          lookup
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::DefListTransformer < Transformer::Base
+        def transform(source)
+          build_ordered(::Sts::IsoSts::DefList) do |dl|
+            dl.id = source.id if source.id && !source.id.start_with?("_")
+            dl.list_type = source.key if source.key
+
+            source.each_mixed_content do |node|
+              next if node.is_a?(String)
+
+              case node
+              when Metanorma::Document::Components::Lists::DtElement
+                @current_dt = node
+              when Metanorma::Document::Components::Lists::DdElement
+                dl.def_item transform_def_item(@current_dt, node)
+                @current_dt = nil
+              end
+            end
+          end
+        end
+
+        private
+
+        def transform_def_item(dt, dd)
+          build_ordered(::Sts::IsoSts::DefItem) do |item|
+            item.term transform_term(dt) if dt
+            item.def transform_def(dd) if dd
+          end
+        end
+
+        def transform_term(dt)
+          build_ordered(::Sts::IsoSts::Term) do |t|
+            t.id = dt.id if dt.id
+            inline_transformer.apply_inline_content(dt, t)
+          end
+        end
+
+        def transform_def(dd)
+          build_ordered(::Sts::IsoSts::Def) do |d|
+            if dd.p && !dd.p.empty?
+              dd.p.each do |para|
+                d.p paragraph_transformer.transform(para)
+              end
+            end
+
+            dd.ul&.each { |ul| d.p build_list_paragraph(ul) }
+            dd.ol&.each { |ol| d.p build_list_paragraph(ol) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::DocumentTransformer < Transformer::Base
+        def transform(source)
+          build_ordered(::Sts::IsoSts::Standard) do |s|
+            s.lang = @context.language
+            s.front = Transformer::FrontTransformer.new(@context).transform(source)
+            s.body = Transformer::BodyTransformer.new(@context).transform(source)
+            s.back = Transformer::BackTransformer.new(@context).transform(source)
+          end
+        end
+
+        def transform_to_xml(source)
+          standard = transform(source)
+          xml = standard.to_xml
+          apply_nbsp_to_text(xml)
+        end
+
+        private
+
+        def apply_nbsp_to_text(xml)
+          Transformer::NbspProcessor.apply_to_text(xml)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::ExampleTransformer < Transformer::Base
+        def transform(source)
+          build_ordered(::Sts::IsoSts::NonNormativeExample) do |example|
+            example.id = source.id if source.id && !source.id.start_with?("_")
+
+            transform_example_content(source, example)
+          end
+        end
+
+        private
+
+        def transform_example_content(source, example)
+          source.each_mixed_content do |node|
+            next if node.is_a?(String)
+
+            dispatch_block(node, example)
+          end
+        end
+
+        def dispatch_block(node, target)
+          case node
+          when Metanorma::Document::Components::Paragraphs::ParagraphBlock
+            target.p paragraph_transformer.transform(node)
+          when Metanorma::Document::Components::Lists::UnorderedList,
+               Metanorma::Document::Components::Lists::OrderedList
+            target.list list_transformer.transform(node)
+          when Metanorma::Document::Components::Lists::DefinitionList
+            target.def_list def_list_transformer.transform(node)
+          when Metanorma::Document::Components::Blocks::NoteBlock
+            target.non_normative_note note_transformer.transform(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::FigureTransformer < Transformer::Base
+        def transform(figure)
+          build_ordered(::Sts::IsoSts::Fig) do |f|
+            f.id = id_for(figure)
+
+            figure_label = label_for(figure)
+            f.label figure_label if figure_label
+
+            if figure.title
+              caption = build_ordered(::Sts::IsoSts::Caption) do |c|
+                inline_transformer.apply_inline_content(figure.title, c)
+              end
+              f.title caption
+            end
+
+            if figure.image
+              images = figure.image.is_a?(Array) ? figure.image : [figure.image]
+              images.each do |img|
+                next unless img
+
+                graphic = build_ordered(::Sts::IsoSts::Graphic) do |g|
+                  g.xlink_href = img.src if img.src
+                end
+                f.graphic graphic
+              end
+            end
+          end
+        end
+
+        private
+
+        def label_for(figure)
+          autonum = figure.autonum if figure.class.method_defined?(:autonum)
+          autonum && !autonum.to_s.empty? ? ::Sts::IsoSts::Label.new(content: [autonum.to_s]) : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::FootnoteCollector
+        def initialize
+          @footnotes = {}
+          @counter = 0
+        end
+
+        def register(footnote_text, paragraphs: nil)
+          normalized = footnote_text.strip
+          if @footnotes.key?(normalized)
+            @footnotes[normalized]
+          else
+            @counter += 1
+            entry = { id: "fn_#{@counter}", number: @counter,
+                      paragraphs: paragraphs }
+            @footnotes[normalized] = entry
+            entry
+          end
+        end
+
+        def lookup(footnote_text)
+          @footnotes[footnote_text.strip]
+        end
+
+        def empty?
+          @footnotes.empty?
+        end
+
+        def count
+          @footnotes.size
+        end
+
+        def fn_group
+          return nil if @footnotes.empty?
+
+          group = build_ordered_fn_group
+
+          @footnotes.each do |text, entry|
+            fn = build_ordered_fn
+            fn.id = entry[:id]
+
+            fn_label = ::Sts::IsoSts::Label.new
+            fn_label.content = ["<sup>#{entry[:number]})</sup>"]
+            fn.label = fn_label
+
+            paras = entry[:paragraphs]
+            if paras && !paras.empty?
+              paras.each { |para| fn.paragraph para }
+            else
+              fn_para = ::Sts::IsoSts::Paragraph.new
+              fn_para.content = [text]
+              fn.paragraph fn_para
+            end
+
+            group.fn fn
+          end
+
+          group
+        end
+
+        private
+
+        def build_ordered_fn_group
+          inst = ::Sts::IsoSts::FnGroup.new
+          inst.instance_variable_set(:@__order_tracking__, true)
+          inst.content_type = "footnotes"
+          inst
+        end
+
+        def build_ordered_fn
+          inst = ::Sts::IsoSts::Fn.new
+          inst.instance_variable_set(:@__order_tracking__, true)
+          inst
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::FormulaTransformer < Transformer::Base
+        def transform(formula)
+          ::Sts::IsoSts::DispFormula.new do |f|
+            f.id = id_for(formula)
+
+            formula_label = label_for(formula)
+            f.label = formula_label if formula_label
+
+            if formula.stem
+              stem = formula.stem
+              if stem.math
+                math_el = ::Sts::IsoSts::Mathml2::Math.new
+                math_el.content = [stem.math.to_xml]
+                f.math = math_el
+              elsif stem.content
+                tex = ::Sts::NisoSts::TexMath.new
+                tex.content = [stem.content]
+                f.tex_math = tex
+              end
+            end
+          end
+        end
+
+        private
+
+        def label_for(formula)
+          autonum = formula.autonum if formula.class.method_defined?(:autonum)
+          autonum && !autonum.to_s.empty? ? ::Sts::IsoSts::Label.new(content: [autonum.to_s]) : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::FrontTransformer < Transformer::Base
+        def transform(source)
+          build_ordered(::Sts::IsoSts::Front) do |f|
+            f.iso_meta = Transformer::IsoMetaTransformer.new(@context).transform(source.bibdata)
+
+            preface = source.preface
+            if preface
+              transform_preface_sections(preface).each do |sec|
+                f.sec sec
+              end
+            end
+          end
+        end
+
+        private
+
+        def transform_preface_sections(preface)
+          sections = []
+
+          if preface.foreword
+            sections << section_transformer.transform_foreword(preface.foreword)
+          end
+
+          if preface.abstract
+            sections << section_transformer.transform_abstract(preface.abstract)
+          end
+
+          if preface.introduction
+            sections << section_transformer.transform_introduction(preface.introduction)
+          end
+
+          if preface.clause
+            Array(preface.clause).each do |cl|
+              sections << section_transformer.transform(cl)
+            end
+          end
+
+          if preface.acknowledgements
+            sections << section_transformer.transform(preface.acknowledgements)
+          end
+
+          if preface.executivesummary
+            sections << section_transformer.transform(preface.executivesummary)
+          end
+
+          sections
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::IdGenerator
+        def initialize(context)
+          @context = context
+          @id_map = {}
+          @section_counters = {
+            table: 0,
+            figure: 0,
+            formula: 0,
+            biblref: 0,
+            fn: 0,
+            unnumbered_table: 0,
+          }
+        end
+
+        def register(source_id, sts_id)
+          @id_map[source_id] = sts_id
+        end
+
+        def remap(source_id)
+          @id_map[source_id] || source_id
+        end
+
+        def id_for(element)
+          case element
+          when Metanorma::IsoDocument::Sections::IsoForewordSection
+            "sec_foreword"
+          when Metanorma::IsoDocument::Sections::IsoAbstractSection
+            "sec_abstract"
+          when Metanorma::IsoDocument::Sections::IsoClauseSection
+            id_for_clause(element)
+          when Metanorma::IsoDocument::Sections::IsoAnnexSection
+            id_for_annex(element)
+          when Metanorma::IsoDocument::Sections::IsoTermsSection
+            id_for_terms(element)
+          when Metanorma::Document::Components::Tables::TableBlock
+            id_for_table(element)
+          when Metanorma::Document::Components::AncillaryBlocks::FigureBlock
+            id_for_figure(element)
+          when Metanorma::Document::Components::AncillaryBlocks::FormulaBlock
+            id_for_formula(element)
+          when Metanorma::Document::Components::Paragraphs::ParagraphBlock
+            id_for_paragraph(element)
+          when Metanorma::StandardDocument::Sections::StandardReferencesSection
+            id_for_ref_section(element)
+          else
+            id = element.id if element.class.method_defined?(:id)
+            id ? remap(id) : nil
+          end
+        end
+
+        def section_number(element)
+          if element.is_a?(Metanorma::IsoDocument::Sections::IsoClauseSection) ||
+              element.is_a?(Metanorma::IsoDocument::Sections::IsoAnnexSection) ||
+              element.is_a?(Metanorma::IsoDocument::Sections::IsoTermsSection)
+            element.number
+          end
+        end
+
+        private
+
+        def id_for_clause(clause)
+          return remap(clause.id) if clause.id && @id_map.key?(clause.id)
+
+          number = clause.number
+          sts_id = if number && !number.empty?
+                     "sec_#{number}"
+                   elsif clause.type == "intro"
+                     "sec_intro"
+                   elsif clause.type == "scope"
+                     "sec_scope"
+                   else
+                     clause.id ? remap(clause.id) : nil
+                   end
+
+          register(clause.id, sts_id) if clause.id && sts_id
+          sts_id
+        end
+
+        def id_for_annex(annex)
+          return remap(annex.id) if annex.id && @id_map.key?(annex.id)
+
+          number = annex.number
+          sts_id = if number && !number.empty?
+                     "sec_#{number}"
+                   else
+                     "sec_A"
+                   end
+
+          register(annex.id, sts_id) if annex.id
+          sts_id
+        end
+
+        def id_for_terms(terms)
+          return remap(terms.id) if terms.id && @id_map.key?(terms.id)
+
+          number = terms.number
+          sts_id = if number && !number.empty?
+                     "sec_#{number}"
+                   else
+                     "sec_terms"
+                   end
+
+          register(terms.id, sts_id) if terms.id
+          sts_id
+        end
+
+        def id_for_table(table)
+          return remap(table.id) if table.id && @id_map.key?(table.id)
+
+          @section_counters[:table] += 1
+          number = table.autonum if table.class.method_defined?(:autonum)
+          number = nil if number && number.to_s.empty?
+          if number
+            sts_id = "tab_#{number}"
+          else
+            letter = ("a".ord + @section_counters[:unnumbered_table]).chr
+            @section_counters[:unnumbered_table] += 1
+            sts_id = "tab_#{letter}"
+          end
+
+          register(table.id, sts_id) if table.id
+          sts_id
+        end
+
+        def id_for_figure(figure)
+          return remap(figure.id) if figure.id && @id_map.key?(figure.id)
+
+          @section_counters[:figure] += 1
+          number = figure.autonum if figure.class.method_defined?(:autonum)
+          number = nil if number && number.to_s.empty?
+          sts_id = if number
+                     "fig_#{number}"
+                   else
+                     "fig_#{@section_counters[:figure]}"
+                   end
+
+          register(figure.id, sts_id) if figure.id
+          sts_id
+        end
+
+        def id_for_formula(formula)
+          return remap(formula.id) if formula.id && @id_map.key?(formula.id)
+
+          @section_counters[:formula] += 1
+          number = formula.autonum if formula.class.method_defined?(:autonum)
+          number = nil if number && number.to_s.empty?
+          sts_id = if number
+                     num = number.to_s.gsub(/[()]/, "")
+                     "formula_#{num}"
+                   else
+                     "formula_#{@section_counters[:formula]}"
+                   end
+
+          register(formula.id, sts_id) if formula.id
+          sts_id
+        end
+
+        def id_for_paragraph(para)
+          return nil unless para.id && !para.id.start_with?("_")
+
+          remap(para.id)
+        end
+
+        def id_for_ref_section(ref_section)
+          return remap(ref_section.id) if ref_section.id && @id_map.key?(ref_section.id)
+
+          normative = ref_section.normative == "true"
+          sts_id = normative ? "sec_normrefs" : "sec_bibl"
+
+          register(ref_section.id, sts_id) if ref_section.id
+          sts_id
+        end
+      end
+    end
+  end
+end