metanorma-standoc 1.11.2 → 2.0.1

data/lib/metanorma/standoc/render.rb

@@ -0,0 +1,115 @@
+module Metanorma
+  module Standoc
+    module Base
+      def html_extract_attributes(node)
+        {
+          script: node.attr("script"),
+          bodyfont: node.attr("body-font"),
+          headerfont: node.attr("header-font"),
+          monospacefont: node.attr("monospace-font"),
+          i18nyaml: node.attr("i18nyaml"),
+          scope: node.attr("scope"),
+          htmlstylesheet: node.attr("htmlstylesheet"),
+          htmlstylesheet_override: node.attr("htmlstylesheet-override"),
+          htmlcoverpage: node.attr("htmlcoverpage"),
+          htmlintropage: node.attr("htmlintropage"),
+          scripts: node.attr("scripts"),
+          scripts_override: node.attr("scripts-override"),
+          scripts_pdf: node.attr("scripts-pdf"),
+          datauriimage: node.attr("data-uri-image") != "false",
+          htmltoclevels: node.attr("htmltoclevels") || node.attr("toclevels"),
+          doctoclevels: node.attr("doctoclevels") || node.attr("toclevels"),
+          break_up_urls_in_tables: node.attr("break-up-urls-in-tables"),
+          suppressasciimathdup: node.attr("suppress-asciimath-dup"),
+          bare: node.attr("bare"),
+          sectionsplit: node.attr("sectionsplit"),
+          baseassetpath: node.attr("base-asset-path"),
+          aligncrosselements: node.attr("align-cross-elements"),
+        }
+      end
+
+      def html_converter(node)
+        IsoDoc::HtmlConvert.new(html_extract_attributes(node))
+      end
+
+      def pdf_converter(node)
+        return nil if node.attr("no-pdf")
+
+        IsoDoc::Standoc::PdfConvert.new(pdf_extract_attributes(node))
+      end
+
+      def doc_extract_attributes(node)
+        attrs = {
+          script: node.attr("script"),
+          bodyfont: node.attr("body-font"),
+          headerfont: node.attr("header-font"),
+          monospacefont: node.attr("monospace-font"),
+          i18nyaml: node.attr("i18nyaml"),
+          scope: node.attr("scope"),
+          wordstylesheet: node.attr("wordstylesheet"),
+          wordstylesheet_override: node.attr("wordstylesheet-override"),
+          standardstylesheet: node.attr("standardstylesheet"),
+          header: node.attr("header"),
+          wordcoverpage: node.attr("wordcoverpage"),
+          wordintropage: node.attr("wordintropage"),
+          ulstyle: node.attr("ulstyle"),
+          olstyle: node.attr("olstyle"),
+          htmltoclevels: node.attr("htmltoclevels") || node.attr("toclevels"),
+          doctoclevels: node.attr("doctoclevels") || node.attr("toclevels"),
+          break_up_urls_in_tables: node.attr("break-up-urls-in-tables"),
+          suppressasciimathdup: node.attr("suppress-asciimath-dup"),
+          bare: node.attr("bare"),
+          baseassetpath: node.attr("base-asset-path"),
+          aligncrosselements: node.attr("align-cross-elements"),
+        }
+
+        if fonts_manifest = node.attr(FONTS_MANIFEST)
+          attrs[IsoDoc::XslfoPdfConvert::MN2PDF_OPTIONS] = {
+            IsoDoc::XslfoPdfConvert::MN2PDF_FONT_MANIFEST => fonts_manifest,
+          }
+        end
+
+        attrs
+      end
+
+      def pdf_extract_attributes(node)
+        %w(pdf-encrypt pdf-encryption-length pdf-user-password
+           pdf-owner-password pdf-allow-copy-content pdf-allow-edit-content
+           pdf-allow-assemble-document pdf-allow-edit-annotations
+           pdf-allow-print pdf-allow-print-hq pdf-allow-fill-in-forms
+           pdf-allow-access-content pdf-encrypt-metadata)
+          .each_with_object({}) do |x, m|
+          m[x.gsub(/-/, "").to_i] = node.attr(x)
+        end
+      end
+
+      def doc_converter(node)
+        IsoDoc::WordConvert.new(doc_extract_attributes(node))
+      end
+
+      def presentation_xml_converter(node)
+        IsoDoc::PresentationXMLConvert.new(html_extract_attributes(node))
+      end
+
+      def default_fonts(node)
+        b = node.attr("body-font") ||
+          (node.attr("script") == "Hans" ? '"Source Han Sans",serif' : '"Cambria",serif')
+        h = node.attr("header-font") ||
+          (node.attr("script") == "Hans" ? '"Source Han Sans",sans-serif' : '"Cambria",serif')
+        m = node.attr("monospace-font") || '"Courier New",monospace'
+        "$bodyfont: #{b};\n$headerfont: #{h};\n$monospacefont: #{m};\n"
+      end
+
+      def outputs(node, ret)
+        File.open("#{@filename}.xml", "w:UTF-8") { |f| f.write(ret) }
+        presentation_xml_converter(node).convert("#{@filename}.xml")
+        html_converter(node).convert("#{@filename}.presentation.xml",
+                                     nil, false, "#{@filename}.html")
+        doc_converter(node).convert("#{@filename}.presentation.xml",
+                                    nil, false, "#{@filename}.doc")
+        pdf_converter(node)&.convert("#{@filename}.presentation.xml",
+                                     nil, false, "#{@filename}.pdf")
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/reqt.rb

@@ -0,0 +1,90 @@
+require "htmlentities"
+require "uri" if /^2\./.match?(RUBY_VERSION)
+require "mime/types"
+require "base64"
+
+module Metanorma
+  module Standoc
+    module Blocks
+      def reqt_subpart(name)
+        %w(specification measurement-target verification import label title
+           description component subject inherit classification).include? name
+      end
+
+      def reqt_subpart_attrs(node, name)
+        klass = node.attr("class") || "component"
+        attr_code(keep_attrs(node)
+          .merge(exclude: node.option?("exclude"),
+                 type: node.attr("type"),
+                 class: name == "component" ? klass : nil))
+      end
+
+      def requirement_subpart(node)
+        name = node.role || node.attr("style")
+        noko do |xml|
+          xml.send name, **reqt_subpart_attrs(node, name) do |o|
+            o << node.content
+          end
+        end
+      end
+
+      def req_classif_parse(classif)
+        ret = []
+        HTMLEntities.new.decode(classif).split(/;\s*/).each do |c|
+          c1 = c.split(/:\s*/)
+          next unless c1.size == 2
+
+          c1[1].split(/,\s*/).each { |v| ret << [c1[0], v] }
+        end
+        ret
+      end
+
+      def requirement_classification(classif, out)
+        req_classif_parse(classif).each do |r|
+          out.classification do |c|
+            c.tag { |t| t << r[0] }
+            c.value { |v| v << r[1] }
+          end
+        end
+      end
+
+      def reqt_attrs(node)
+        attr_code(keep_attrs(node).merge(id_unnum_attrs(node)).merge(
+                    id: Metanorma::Utils::anchor_or_uuid(node),
+                    unnumbered: node.option?("unnumbered") ? "true" : nil,
+                    number: node.attr("number"),
+                    subsequence: node.attr("subsequence"),
+                    obligation: node.attr("obligation"),
+                    filename: node.attr("filename"),
+                    type: node.attr("type"),
+                    model: node.attr("model"),
+                  ))
+      end
+
+      def requirement_elems(node, out)
+        node.title and out.title { |t| t << node.title }
+        a = node.attr("label") and out.label do |l|
+          l << a
+        end
+        a = node.attr("subject") and csv_split(a)&.each do |subj|
+          out.subject { |s| s << subj }
+        end
+        a = HTMLEntities.new.decode(node.attr("inherit")) and
+          csv_split(a)&.each do |i|
+            out.inherit { |inh| inh << i }
+          end
+        classif = node.attr("classification") and
+          requirement_classification(classif, out)
+      end
+
+      def requirement(node, obligation)
+        noko do |xml|
+          xml.send obligation, **reqt_attrs(node) do |ex|
+            requirement_elems(node, ex)
+            wrap_in_para(node, ex)
+          end
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/section.rb

@@ -0,0 +1,209 @@
+require "uri" if /^2\./.match?(RUBY_VERSION)
+require_relative "ref_sect"
+require_relative "terms"
+
+module Metanorma
+  module Standoc
+    module Section
+      @biblio = false
+      @term_def = false
+      @norm_ref = false
+
+      def sectiontype1(node)
+        node&.attr("heading")&.downcase ||
+          node.title.gsub(%r{<index>.*?</index>}m, "").gsub(/<[^>]+>/, "")
+            .strip.downcase
+      end
+
+      def sectiontype(node, level = true)
+        ret = sectiontype1(node)
+        ret1 = sectiontype_streamline(ret)
+        return ret1 if ret1 == "symbols and abbreviated terms"
+        return nil unless !level || node.level == 1
+        return nil if @seen_headers.include? ret
+
+        @seen_headers << ret
+        ret1
+      end
+
+      def sectiontype_streamline(ret)
+        case ret
+        when "terms and definitions",
+          "terms, definitions, symbols and abbreviated terms",
+          "terms, definitions, symbols and abbreviations",
+          "terms, definitions and symbols",
+          "terms, definitions and abbreviations",
+          "terms, definitions and abbreviated terms"
+          "terms and definitions"
+        when "symbols and abbreviated terms",
+          "symbols", "abbreviated terms", "abbreviations"
+          "symbols and abbreviated terms"
+        else
+          ret
+        end
+      end
+
+      def section_attributes(node)
+        ret = { id: Metanorma::Utils::anchor_or_uuid(node),
+                language: node.attributes["language"],
+                script: node.attributes["script"],
+                number: node.attributes["number"],
+                type: node.attributes["type"],
+                annex: (if (node.attr("style") == "appendix" ||
+                            node.role == "appendix") &&
+                          node.level == 1
+                          true
+                        end),
+                tag: node&.attr("tag"),
+                "multilingual-rendering": node&.attr("multilingual-rendering"),
+                preface: (if node.role == "preface" ||
+                          node.attr("style") == "preface"
+                            true
+                          end) }
+        return ret unless node.attributes["change"]
+
+        ret.merge(change: node.attributes["change"],
+                  path: node.attributes["path"],
+                  path_end: node.attributes["path_end"],
+                  title: node.attributes["title"])
+      end
+
+      def section(node)
+        a = section_attributes(node)
+        noko do |xml|
+          case sectiontype(node)
+          when "introduction" then introduction_parse(a, xml, node)
+          when "foreword" then foreword_parse(a, xml, node)
+          when "scope" then scope_parse(a, xml, node)
+          when "normative references" then norm_ref_parse(a, xml, node)
+          when "terms and definitions"
+            @term_def = true
+            term_def_parse(a, xml, node, true)
+            @term_def = false
+          when "symbols and abbreviated terms"
+            symbols_parse(symbols_attrs(node, a), xml, node)
+          when "acknowledgements"
+            acknowledgements_parse(a, xml, node)
+          when "bibliography"
+            bibliography_parse(a, xml, node)
+          else
+            if @term_def then term_def_subclause_parse(a, xml, node)
+            elsif @definitions then symbols_parse(a, xml, node)
+            elsif @norm_ref ||
+                (node.attr("style") == "bibliography" &&
+                 sectiontype(node, false) == "normative references")
+              norm_ref_parse(a, xml, node)
+            elsif @biblio || node.attr("style") == "bibliography"
+              bibliography_parse(a, xml, node)
+            elsif node.attr("style") == "abstract"
+              abstract_parse(a, xml, node)
+            elsif node.attr("style") == "index"
+              indexsect_parse(a, xml, node)
+            elsif node.attr("style") == "appendix" && node.level == 1
+              annex_parse(a, xml, node)
+            else
+              clause_parse(a, xml, node)
+            end
+          end
+        end.join("\n")
+      end
+
+      def set_obligation(attrs, node)
+        attrs[:obligation] = if node.attributes.has_key?("obligation")
+                               node.attr("obligation")
+                             elsif node.parent.attributes.has_key?("obligation")
+                               node.parent.attr("obligation")
+                             else
+                               "normative"
+                             end
+      end
+
+      def preamble(node)
+        noko do |xml|
+          xml.foreword **attr_code(section_attributes(node)) do |xml_abstract|
+            xml_abstract.title do |t|
+              t << (node.blocks[0].title || @i18n.foreword)
+            end
+            content = node.content
+            xml_abstract << content
+          end
+        end.join("\n")
+      end
+
+      def indexsect_parse(attrs, xml, node)
+        xml.indexsect **attr_code(attrs) do |xml_section|
+          xml_section.title { |name| name << node.title }
+          xml_section << node.content
+        end
+      end
+
+      def abstract_parse(attrs, xml, node)
+        xml.abstract **attr_code(attrs) do |xml_section|
+          xml_section << node.content
+        end
+      end
+
+      def scope_parse(attrs, xml, node)
+        clause_parse(attrs.merge(type: "scope"), xml, node)
+      end
+
+      def clause_parse(attrs, xml, node)
+        attrs[:"inline-header"] = node.option? "inline-header"
+        attrs[:bibitem] = true if node.option? "bibitem"
+        attrs[:level] = node.attr("level")
+        set_obligation(attrs, node)
+        xml.send "clause", **attr_code(attrs) do |xml_section|
+          xml_section.title { |n| n << node.title } unless node.title.nil?
+          xml_section << node.content
+        end
+      end
+
+      def annex_parse(attrs, xml, node)
+        attrs[:"inline-header"] = node.option? "inline-header"
+        set_obligation(attrs, node)
+        xml.annex **attr_code(attrs) do |xml_section|
+          xml_section.title { |name| name << node.title }
+          xml_section << node.content
+        end
+      end
+
+      def introduction_parse(attrs, xml, node)
+        xml.introduction **attr_code(attrs) do |xml_section|
+          xml_section.title { |t| t << @i18n.introduction }
+          content = node.content
+          xml_section << content
+        end
+      end
+
+      def foreword_parse(attrs, xml, node)
+        xml.foreword **attr_code(attrs) do |xml_section|
+          xml_section.title { |t| t << node.title }
+          content = node.content
+          xml_section << content
+        end
+      end
+
+      def acknowledgements_parse(attrs, xml, node)
+        xml.acknowledgements **attr_code(attrs) do |xml_section|
+          xml_section.title { |t| (t << node.title) || @i18n.acknowledgements }
+          content = node.content
+          xml_section << content
+        end
+      end
+
+      def floating_title_attrs(node)
+        attr_code(id_attr(node).merge(align: node.attr("align"),
+                                      depth: node.level,
+                                      type: "floating-title"))
+      end
+
+      def floating_title(node)
+        noko do |xml|
+          xml.floating_title **floating_title_attrs(node) do |xml_t|
+            xml_t << node.title
+          end
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/table.rb

@@ -0,0 +1,85 @@
+module Metanorma
+  module Standoc
+    module Table
+      def table_attrs(node)
+        keep_attrs(node)
+          .merge(id: Metanorma::Utils::anchor_or_uuid(node),
+                 headerrows: node.attr("headerrows"),
+                 unnumbered: node.option?("unnumbered") ? "true" : nil,
+                 number: node.attr("number"),
+                 subsequence: node.attr("subsequence"),
+                 alt: node.attr("alt"),
+                 summary: node.attr("summary"),
+                 width: node.attr("width"))
+      end
+
+      def table(node)
+        @table_fn_number = "a"
+        noko do |xml|
+          xml.table **attr_code(table_attrs(node)) do |xml_table|
+            colgroup(node, xml_table)
+            table_name(node, xml_table)
+            %i(head body foot).reject do |tblsec|
+              node.rows[tblsec].empty?
+            end
+            table_head_body_and_foot node, xml_table
+          end
+        end
+      end
+
+      private
+
+      def colgroup(node, xml_table)
+        return if node.option? "autowidth"
+
+        cols = node&.attr("cols")&.split(/,/) or return
+        return unless (cols.size > 1) && cols.all? { |c| /\d/.match(c) }
+
+        xml_table.colgroup do |cg|
+          node.columns.each do |col|
+            cg.col **{ width: "#{col.attr 'colpcwidth'}%" }
+          end
+        end
+      end
+
+      def table_name(node, xml_table)
+        if node.title?
+          xml_table.name do |n|
+            n << node.title
+          end
+        end
+      end
+
+      def table_cell1(cell, thd)
+        thd << if cell.style == :asciidoc
+                 cell.content
+               else
+                 cell.text
+               end
+      end
+
+      def table_cell(node, xml_tr, tblsec)
+        cell_attributes =
+          { id: node.id, colspan: node.colspan, valign: node.attr("valign"),
+            rowspan: node.rowspan, align: node.attr("halign") }
+        cell_tag = "td"
+        cell_tag = "th" if tblsec == :head || node.style == :header
+        xml_tr.send cell_tag, **attr_code(cell_attributes) do |thd|
+          table_cell1(node, thd)
+        end
+      end
+
+      def table_head_body_and_foot(node, xml)
+        %i(head body foot).reject { |s| node.rows[s].empty? }.each do |s|
+          xml.send "t#{s}" do |xml_tblsec|
+            node.rows[s].each do |row|
+              xml_tblsec.tr do |xml_tr|
+                row.each { |cell| table_cell(cell, xml_tr, s) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/term_lookup_cleanup.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true.
+require "metanorma/standoc/utils"
+
+
+module Metanorma
+  module Standoc
+    # Intelligent term lookup xml modifier
+    class TermLookupCleanup
+      AUTOMATIC_GENERATED_ID_REGEXP = /\A_/.freeze
+      EXISTING_TERM_REGEXP = /\Aterm-/.freeze
+      EXISTING_SYMBOL_REGEXP = /\Asymbol-/.freeze
+
+      attr_reader :xmldoc, :termlookup, :log
+
+      def initialize(xmldoc, log)
+        @xmldoc = xmldoc
+        @log = log
+        @termlookup = { term: {}, symbol: {}, secondary2primary: {} }
+        @idhash = {}
+      end
+
+      def call
+        @idhash = populate_idhash
+        @termlookup = replace_automatic_generated_ids_terms
+        set_termxref_tags_target
+        concept_cleanup
+        related_cleanup
+      end
+
+      private
+
+      def concept_cleanup
+        xmldoc.xpath("//concept").each do |n|
+          n.delete("type")
+          refterm = n.at("./refterm") or next
+          p = @termlookup[:secondary2primary][refterm.text] and
+            refterm.children = p
+        end
+      end
+
+      def related_cleanup
+        xmldoc.xpath("//related").each do |n|
+          refterm = n.at("./refterm") or next
+          p = @termlookup[:secondary2primary][refterm.text] and
+            refterm.children = p
+          refterm.replace("<preferred><expression><name>#{refterm.children.to_xml}"\
+                          "</name></expression></preferred>")
+        end
+      end
+
+      def populate_idhash
+        xmldoc.xpath("//*[@id]").each_with_object({}) do |n, mem|
+          next unless /^(term|symbol)-/.match?(n["id"])
+
+          mem[n["id"]] = true
+        end
+      end
+
+      def set_termxref_tags_target
+        xmldoc.xpath("//termxref").each do |node|
+          target = normalize_ref_id(node.text)
+          if termlookup[:term][target].nil? && termlookup[:symbol][target].nil?
+            remove_missing_ref(node, target)
+            next
+          end
+          x = node.at("../xrefrender") and modify_ref_node(x, target)
+          node.name = "refterm"
+        end
+      end
+
+      def remove_missing_ref(node, target)
+        if node.at("../concept[@type = 'symbol']")
+          remove_missing_ref_symbol(node, target)
+        else
+          remove_missing_ref_term(node, target)
+        end
+      end
+
+      def remove_missing_ref_term(node, target)
+        log.add("AsciiDoc Input", node,
+                %(Error: Term reference in `term[#{target}]` missing: \
+                "#{target}" is not defined in document))
+        node.name = "strong"
+        node&.at("../xrefrender")&.remove
+        display = node&.at("../renderterm")&.remove&.children
+        display = [] if display.nil? || display&.to_xml == node.text
+        d = display.empty? ? "" : ", display <tt>#{display.to_xml}</tt>"
+        node.children = "term <tt>#{node.text}</tt>#{d} "\
+                        "not resolved via ID <tt>#{target}</tt>"
+      end
+
+      def remove_missing_ref_symbol(node, target)
+        log.add("AsciiDoc Input", node,
+                %(Error: Symbol reference in `symbol[#{target}]` missing: \
+                "#{target}" is not defined in document))
+        node.name = "strong"
+        node&.at("../xrefrender")&.remove
+        display = node&.at("../renderterm")&.remove&.children
+        display = [] if display.nil? || display&.to_xml == node.text
+        d = display.empty? ? "" : ", display <tt>#{display.to_xml}</tt>"
+        node.children = "symbol <tt>#{node.text}</tt>#{d} "\
+                        "not resolved via ID <tt>#{target}</tt>"
+      end
+
+      def modify_ref_node(node, target)
+        node.name = "xref"
+        s = termlookup[:symbol][target]
+        t = termlookup[:term][target]
+        type = node.parent["type"]
+        if type == "term" || ((!type || node.parent.name == "related") && t)
+          node["target"] = t
+        elsif type == "symbol" ||
+          ((!type || node.parent.name == "related") && s)
+          node["target"] = s
+        end
+      end
+
+      def replace_automatic_generated_ids_terms
+        r = xmldoc.xpath("//term").each.with_object({}) do |n, res|
+          normalize_id_and_memorize(n, res, "./preferred//name",
+                                    "term")
+        end
+        s = xmldoc.xpath("//definitions//dt").each.with_object({}) do |n, res|
+          normalize_id_and_memorize(n, res, ".", "symbol")
+        end
+        { term: r, symbol: s, secondary2primary: pref_secondary2primary }
+      end
+
+      def pref_secondary2primary
+        xmldoc.xpath("//term").each.with_object({}) do |n, res|
+          n.xpath("./preferred//name").each_with_index do |p, i|
+            i.zero? and term = p.text
+            i.positive? and res[p.text] = term
+          end
+        end
+      end
+
+      def normalize_id_and_memorize(node, res_table, text_selector, prefix)
+        normalize_id_and_memorize_init(node, res_table, text_selector, prefix)
+        memorize_other_pref_terms(node, res_table, text_selector)
+      end
+
+      def normalize_id_and_memorize_init(node, res_table, text_selector, prefix)
+        term_text = normalize_ref_id(node.at(text_selector).text)
+        unless AUTOMATIC_GENERATED_ID_REGEXP.match(node["id"]).nil? &&
+            !node["id"].nil?
+          id = unique_text_id(term_text, prefix)
+          node["id"] = id
+          @idhash[id] = true
+        end
+        res_table[term_text] = node["id"]
+      end
+
+      def memorize_other_pref_terms(node, res_table, text_selector)
+        node.xpath(text_selector).each_with_index do |p, i|
+          next unless i.positive?
+
+          res_table[normalize_ref_id(p.text)] = node["id"]
+        end
+      end
+
+      def normalize_ref_id(text)
+        Metanorma::Utils::to_ncname(text.downcase.gsub(/[[:space:]]/, "-"))
+      end
+
+      def unique_text_id(text, prefix)
+        unless @idhash["#{prefix}-#{text}"]
+          return "#{prefix}-#{text}"
+        end
+
+        (1..Float::INFINITY).lazy.each do |index|
+          unless @idhash["#{prefix}-#{text}-#{index}"]
+            break("#{prefix}-#{text}-#{index}")
+          end
+        end
+      end
+    end
+  end
+end