metanorma-iso 3.4.8 → 3.4.9

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::ListTransformer < Transformer::Base
+        OL_TYPE_MAP = {
+          "arabic" => "order",
+          "loweralpha" => "alpha-lower",
+          "upperalpha" => "alpha-upper",
+          "lowerroman" => "roman-lower",
+          "upperroman" => "roman-upper",
+        }.freeze
+
+        def transform(source)
+          build_ordered(::Sts::IsoSts::List) do |list|
+            list.id = source.id if source.id && !source.id.start_with?("_")
+            list.list_type = list_type_for(source)
+
+            source.listitem&.each do |li|
+              list.list_item transform_list_item(li)
+            end
+          end
+        end
+
+        private
+
+        def list_type_for(source)
+          case source
+          when Metanorma::Document::Components::Lists::UnorderedList
+            "bullet"
+          when Metanorma::Document::Components::Lists::OrderedList
+            OL_TYPE_MAP[source.type] || "order"
+          end
+        end
+
+        def transform_list_item(li)
+          build_ordered(::Sts::IsoSts::ListItem) do |item|
+            item.id = li.id if li.id && !li.id.start_with?("_")
+
+            if li.content_text && !li.content_text.empty?
+              item.p paragraph_transformer.transform(
+                build_text_paragraph(li.content_text),
+              )
+            elsif li.paragraphs && !li.paragraphs.empty?
+              li.paragraphs.each do |para|
+                item.p paragraph_transformer.transform(para)
+              end
+            end
+
+            li.unordered_lists&.each { |ul| item.list transform(ul) }
+            li.ordered_lists&.each { |ol| item.list transform(ol) }
+          end
+        end
+
+        def build_text_paragraph(text_array)
+          text = text_array.is_a?(Array) ? text_array.join : text_array.to_s
+          para = Metanorma::Document::Components::Paragraphs::ParagraphBlock.new
+          para.text = [text]
+          para
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::NbspProcessor
+        NBSP = " "
+
+        RULES = [
+          [/(Part) (\d)/i, "\\1#{NBSP}\\2"],
+          [/(\d) (%)/, "\\1#{NBSP}\\2"],
+          [/(ISO[\/&]?(?:TC|IEC)?) (\d)/i, "\\1#{NBSP}\\2"],
+          [/(NOTE) (\d)/i, "\\1#{NBSP}\\2"],
+          [/(Note)\s(\d)\s(to entry)/i, "\\1#{NBSP}\\2#{NBSP}\\3"],
+          [/(Table|Figure|Clause|Volume) (([A-Za-z]\.)?\d)/i,
+           "\\1#{NBSP}\\2"],
+          [/(Formula) (\()/i, "\\1#{NBSP}\\2"],
+          [/(Annex) ([A-Za-z])/i, "\\1#{NBSP}\\2"],
+          [/ (— [A-Z])/, "#{NBSP}\\1"],
+        ].freeze
+
+        def self.process(text)
+          return text unless text.is_a?(String)
+
+          RULES.reduce(text) do |t, (pattern, replacement)|
+            t.gsub(pattern, replacement)
+          end
+        end
+
+        # Apply the NBSP rules to every text node of a serialised XML string
+        # (walks each +>text<+ run). Used as the metanorma-core
+        # +document_transformers+ +:post_process+ hook, replacing the
+        # previously-private DocumentTransformer#apply_nbsp_to_text.
+        #
+        # @param xml [String] serialised STS XML.
+        # @return [String] XML with NBSP rules applied to text content.
+        def self.apply_to_text(xml)
+          xml.gsub(/>([^<]+)</) { ">#{process(Regexp.last_match(1))}<" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::NoteTransformer < Transformer::Base
+        def transform(source)
+          build_ordered(::Sts::IsoSts::NonNormativeNote) do |note|
+            note.id = source.id if source.id && !source.id.start_with?("_")
+
+            transform_note_content(source, note)
+          end
+        end
+
+        private
+
+        def transform_note_content(source, note)
+          source.each_mixed_content do |node|
+            next if node.is_a?(String)
+
+            dispatch_block(node, note)
+          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)
+          when Metanorma::Document::Components::AncillaryBlocks::ExampleBlock
+            target.non_normative_example example_transformer.transform(node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::ParagraphTransformer < Transformer::Base
+        def transform(source)
+          ::Sts::IsoSts::Paragraph.new do |p|
+            p.id = paragraph_id(source)
+            p.content_type = source.type_attr if source.type_attr
+            p.content_type = source.class_attr if source.class_attr && !p.content_type
+
+            inline_transformer.apply_inline_content(source, p)
+          end
+        end
+
+        private
+
+        def paragraph_id(source)
+          id = source.id
+          return nil unless id && !id.start_with?("_")
+
+          remap_id(id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::QuoteTransformer < Transformer::Base
+        def transform(quote)
+          build_ordered(::Sts::NisoSts::DispQuote) do |dq|
+            quote.paragraphs&.each do |para|
+              dq.p paragraph_transformer.transform(para)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::ReferenceTransformer < Transformer::Base
+        def transform_list(ref_section)
+          normative = ref_section.normative == "true"
+
+          build_ordered(::Sts::IsoSts::RefList) do |rl|
+            rl.id = id_for(ref_section)
+            rl.content_type = normative ? "norm-refs" : "bibl"
+
+            if ref_section.title
+              rl.title transform_title(ref_section.title)
+            end
+
+            if ref_section.p && !ref_section.p.empty?
+              ref_section.p.each do |para|
+                rl.p paragraph_transformer.transform(para)
+              end
+            end
+
+            if ref_section.references && !ref_section.references.empty?
+              ref_section.references.each_with_index do |bibitem, idx|
+                rl.ref transform_bibitem(bibitem, idx + 1)
+              end
+            end
+          end
+        end
+
+        def transform_bibitem(bibitem, index)
+          build_ordered(::Sts::IsoSts::Ref) do |ref|
+            ref.id = "biblref_#{index}"
+
+            lbl = ::Sts::IsoSts::Label.new(content: ["[#{index}]"])
+            ref.label lbl
+
+            mc = build_mixed_citation(bibitem)
+            ref.mixed_citation mc if mc
+
+            std = build_std_for(bibitem)
+            ref.std std if std
+          end
+        end
+
+        private
+
+        def build_mixed_citation(bibitem)
+          mc = ::Sts::IsoSts::MixedCitation.new
+
+          doc_id = primary_docidentifier(bibitem)
+          title_text = reference_title(bibitem)
+
+          if doc_id
+            mc.content doc_id
+            if title_text
+              mc.content ", "
+              italic = ::Sts::IsoSts::Italic.new
+              italic.content title_text
+              mc.italic italic
+            end
+          elsif title_text
+            mc.content title_text
+          else
+            return nil
+          end
+
+          mc
+        end
+
+        def build_std_for(bibitem)
+          doc_id = primary_docidentifier(bibitem)
+          return nil unless doc_id
+
+          std = ::Sts::IsoSts::Std.new
+          std.type = "dated"
+
+          dated_ref = ::Sts::IsoSts::StdRef.new
+          dated_ref.type = "dated"
+          dated_ref.content = [doc_id]
+          std.std_ref dated_ref
+
+          undated = undated_identifier(doc_id)
+          if undated && undated != doc_id
+            undated_ref = ::Sts::IsoSts::StdRef.new
+            undated_ref.type = "undated"
+            undated_ref.content = [undated]
+            std.std_ref undated_ref
+          end
+
+          std
+        end
+
+        def primary_docidentifier(bibitem)
+          return nil unless bibitem.docidentifier
+
+          ids = Array(bibitem.docidentifier)
+
+          primary = ids.find { |d| d.primary == true }
+          return primary.id.to_s if primary&.id
+
+          iso_id = ids.find { |d| d.type == "ISO" }
+          return iso_id.id.to_s if iso_id&.id
+
+          ids.first&.id&.to_s
+        end
+
+        def reference_title(bibitem)
+          return nil unless bibitem.title
+
+          titles = Array(bibitem.title)
+
+          main_title = titles.find { |t| t.type == "title-main" }
+          return extract_title_text(main_title) if main_title
+
+          extract_title_text(titles.first) if titles.first
+        end
+
+        def extract_title_text(title)
+          return nil unless title
+
+          if title.content && !title.content.empty?
+            Array(title.content).join
+          elsif title.element_order && !title.element_order.empty?
+            inline_transformer.extract_text(title)
+          end
+        end
+
+        def undated_identifier(doc_id)
+          doc_id.sub(/:\d{4}$/, "")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::SectionTransformer < Transformer::Base
+        SEC_TYPE_MAP = {
+          "intro" => "intro",
+          "scope" => "scope",
+          "overview" => "scope",
+        }.freeze
+
+        def transform(clause)
+          build_ordered(::Sts::IsoSts::Sec) do |sec|
+            sec.id = id_for(clause)
+            sec.sec_type = sec_type_for(clause)
+
+            label_text = label_for(clause)
+            sec.label = ::Sts::IsoSts::Label.new(content: [label_text]) if label_text
+
+            if title_for(clause)
+              sec.title transform_title(title_for(clause))
+            end
+
+            dispatch_content(clause, sec)
+          end
+        end
+
+        def transform_foreword(foreword)
+          build_ordered(::Sts::IsoSts::Sec) do |sec|
+            sec.id = "sec_foreword"
+            sec.sec_type = "foreword"
+            sec.title transform_title(foreword.title) if foreword.title
+
+            dispatch_content(foreword, sec, skip_title: true)
+          end
+        end
+
+        def transform_abstract(abstract)
+          build_ordered(::Sts::IsoSts::Sec) do |sec|
+            sec.id = "sec_abstract"
+            sec.sec_type = "abstract"
+            sec.title transform_title(abstract.title) if abstract.title
+
+            dispatch_content(abstract, sec)
+          end
+        end
+
+        def transform_introduction(intro)
+          build_ordered(::Sts::IsoSts::Sec) do |sec|
+            sec.id = "sec_intro"
+            sec.sec_type = "intro"
+            sec.title transform_title(intro.title) if intro.title
+
+            dispatch_content(intro, sec, skip_title: true)
+          end
+        end
+
+        def transform_annex(annex)
+          build_ordered(::Sts::IsoSts::Sec) do |sec|
+            sec.id = id_for(annex)
+
+            if annex.number && !annex.number.empty?
+              sec.label = ::Sts::IsoSts::Label.new(content: ["Annex #{annex.number}"])
+            end
+
+            sec.title transform_title(annex.title) if annex.title
+
+            dispatch_content(annex, sec, skip_title: true)
+          end
+        end
+
+        private
+
+        def dispatch_content(source, target, skip_title: false)
+          dispatcher = block_dispatcher
+          title_node = skip_title ? source.title : nil
+
+          source.each_mixed_content do |node|
+            next if node.is_a?(String)
+            next if node == title_node
+            next if skip_node?(node)
+
+            dispatcher.dispatch(node, target)
+          end
+        end
+
+        def sec_type_for(clause)
+          SEC_TYPE_MAP[clause.type]
+        end
+
+        def label_for(clause)
+          clause.number if clause.number && !clause.number.empty?
+        end
+
+        def title_for(clause)
+          clause.title
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::SourcecodeTransformer < Transformer::Base
+        def transform(source)
+          ::Sts::IsoSts::Preformat.new do |pre|
+            pre.id = source.id if source.id && !source.id.start_with?("_")
+            pre.preformat_type = source.lang if source.lang
+
+            inline_transformer.apply_inline_content(source, pre)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      module Transformer
+        # Adapter conforming the STS transformer to the metanorma-core
+        # +document_transformers+ contract: +.new(model, options)+ plus
+        # +#transform+ returning a target (+::Sts::IsoSts::Standard+) that
+        # responds to +#to_xml+. It hides the +Context+ construction behind
+        # the (model, options) signature, so the metanorma-core driver treats
+        # STS exactly like any other document-model transformer.
+        class Standard
+          # @param model [Object] a metanorma-document model
+          #   (+Metanorma::IsoDocument::Root+), as returned by the reader's
+          #   +.from_xml+.
+          # @param options [Hash] processor options (accepted for interface
+          #   conformance; not yet consumed).
+          def initialize(model, options = {})
+            @model = model
+            @options = options
+          end
+
+          # @return [::Sts::IsoSts::Standard] the STS output model, which
+          #   responds to +#to_xml+.
+          def transform
+            Transformer.transform(@model)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Metanorma
+  module Iso
+    module Sts
+      class Transformer::TableTransformer < Transformer::Base
+        def transform_wrap(table)
+          build_ordered(::Sts::TbxIsoTml::TableWrap) do |tw|
+            tw.id = id_for(table)
+
+            table_label = label_for(table)
+            tw.label table_label if table_label
+
+            if table.name
+              caption = build_ordered(::Sts::NisoSts::Caption) do |c|
+                inline_transformer.apply_inline_content(table.name, c)
+              end
+              tw.caption caption
+            end
+
+            tw.table transform(table)
+
+            if table.note && !table.note.empty?
+              table.note.each do |n|
+                tw.non_normative_note note_transformer.transform(n)
+              end
+            end
+          end
+        end
+
+        def transform(table)
+          build_ordered(::Sts::TbxIsoTml::Table) do |t|
+            t.width = table.width if table.width
+            t.summary = table.summary if table.summary
+
+            if table.colgroup
+              cg = build_ordered(::Sts::TbxIsoTml::Colgroup) do |colgroup|
+                Array(table.colgroup.col).each do |col|
+                  c = ::Sts::TbxIsoTml::Col.new
+                  c.width = col.width if col.width
+                  colgroup.col c
+                end
+              end
+              t.colgroup cg
+            end
+
+            if table.thead
+              t.thead transform_section(table.thead,
+                                        ::Sts::TbxIsoTml::Thead)
+            end
+            if table.tbody
+              t.tbody transform_section(table.tbody,
+                                        ::Sts::TbxIsoTml::Tbody)
+            end
+            if table.tfoot
+              t.tfoot transform_section(table.tfoot,
+                                        ::Sts::TbxIsoTml::Tfoot)
+            end
+          end
+        end
+
+        private
+
+        def transform_section(section, klass)
+          inst = klass.new
+          Array(section.tr).each do |tr|
+            row = build_ordered(::Sts::TbxIsoTml::Tr) do |r|
+              Array(tr.th).each { |th| r.th transform_cell(th, ::Sts::TbxIsoTml::Th) }
+              Array(tr.td).each { |td| r.td transform_cell(td, ::Sts::TbxIsoTml::Td) }
+            end
+            inst.tr row
+          end
+          inst
+        end
+
+        def transform_cell(cell, klass)
+          c = klass.new
+          c.id = cell.id if cell.id && !cell.id.start_with?("_")
+          c.colspan = cell.colspan.to_s if cell.colspan
+          c.rowspan = cell.rowspan.to_s if cell.rowspan
+          c.align = cell.align if cell.align
+          c.valign = cell.valign if cell.valign
+
+          if cell.element_order && !cell.element_order.empty?
+            inline_transformer.apply_inline_content(cell, c)
+          elsif cell.text && !cell.text.empty?
+            c.content Array(cell.text).join
+          end
+          c
+        end
+
+        def label_for(table)
+          autonum = table.autonum if table.class.method_defined?(:autonum)
+          autonum && !autonum.to_s.empty? ? ::Sts::IsoSts::Label.new(content: [autonum.to_s]) : nil
+        end
+      end
+    end
+  end
+end