metanorma-standoc 1.11.4 → 2.0.0

data/lib/asciidoctor/standoc/render.rb

@@ -1,115 +1,3 @@
-module Asciidoctor
-  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
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/render"
 
-      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/asciidoctor/standoc/reqt.rb

@@ -1,90 +1,3 @@
-require "htmlentities"
-require "uri" if /^2\./.match?(RUBY_VERSION)
-require "mime/types"
-require "base64"
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/reqt"
 
-module Asciidoctor
-  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/asciidoctor/standoc/section.rb

@@ -1,208 +1,3 @@
-require "uri" if /^2\./.match?(RUBY_VERSION)
-require_relative "ref_sect"
-require_relative "terms"
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/section"
 
-module Asciidoctor
-  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"),
-                                      type: "floating-title"))
-      end
-
-      def floating_title(node)
-        noko do |xml|
-          xml.p **floating_title_attrs(node) do |xml_t|
-            xml_t << node.title
-          end
-        end.join("\n")
-      end
-    end
-  end
-end

data/lib/asciidoctor/standoc/table.rb

@@ -1,85 +1,3 @@
-module Asciidoctor
-  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
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/table"
 
-      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/asciidoctor/standoc/term_lookup_cleanup.rb

@@ -1,179 +1,3 @@
-# frozen_string_literal: true.
-require "asciidoctor/standoc/utils"
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/term_lookup_cleanup"
 
-
-module Asciidoctor
-  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