metanorma-standoc 1.11.1 → 2.0.0

data/lib/asciidoctor/standoc/section.rb

@@ -1,191 +1,3 @@
-require "uri"
-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),
-                preface: (
-                           node.role == "preface" || node.attr("style") == "preface" ? true : nil) }
-        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
-    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

data/lib/asciidoctor/standoc/terms.rb

@@ -1,154 +1,3 @@
-module Asciidoctor
-  module Standoc
-    module Section
-      def in_terms?
-        @term_def
-      end
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/terms"
 
-      def nonterm_symbols_parse(attrs, xml, node)
-        defs = @definitions
-        @definitions = false
-        clause_parse(attrs, xml, node)
-        @definitions = defs
-      end
-
-      def symbols_attrs(node, attr)
-        case sectiontype1(node)
-        when "symbols" then attr.merge(type: "symbols")
-        when "abbreviated terms", "abbreviations"
-          attr.merge(type: "abbreviated_terms")
-        else
-          attr
-        end
-      end
-
-      def symbols_parse(attr, xml, node)
-        node.role == "nonterm" and return nonterm_symbols_parse(attr, xml, node)
-        xml.definitions **attr_code(attr) do |xml_section|
-          xml_section.title { |t| t << node.title }
-          defs = @definitions
-          termdefs = @term_def
-          @definitions = true
-          @term_def = false
-          xml_section << node.content
-          @definitions = defs
-          @term_def = termdefs
-        end
-      end
-
-      def nonterm_term_def_subclause_parse(attrs, xml, node)
-        defs = @term_def
-        @term_def = false
-        clause_parse(attrs, xml, node)
-        @term_def = defs
-      end
-
-      def terms_boilerplate_parse(attrs, xml, node)
-        defs = @term_def
-        @term_def = false
-        clause_parse(attrs.merge(type: "boilerplate"), xml, node)
-        @term_def = defs
-      end
-
-      # subclause contains subclauses
-      def term_def_subclause_parse(attrs, xml, node)
-        node.role == "nonterm" and
-          return nonterm_term_def_subclause_parse(attrs, xml, node)
-        node.role == "boilerplate" and
-          return terms_boilerplate_parse(attrs, xml, node)
-        st = sectiontype(node, false)
-        return symbols_parse(attrs, xml, node) if @definitions
-
-        sub = node.find_by(context: :section) { |s| s.level == node.level + 1 }
-        sub.empty? || (return term_def_parse(attrs, xml, node, false))
-        st == "symbols and abbreviated terms" and
-          return symbols_parse(attrs, xml, node)
-        st == "terms and definitions" and return clause_parse(attrs, xml, node)
-        term_def_subclause_parse1(attrs, xml, node)
-      end
-
-      def term_def_subclause_parse1(attrs, xml, node)
-        xml.term **attr_code(attrs) do |xml_section|
-          term_designation(xml_section, node, "preferred", node.title)
-          xml_section << node.content
-        end
-      end
-
-      def term_def_parse(attrs, xml, node, _toplevel)
-        xml.terms **attr_code(attrs) do |section|
-          section.title { |t| t << node.title }
-          (s = node.attr("source")) && s.split(",").each do |s1|
-            section.termdocsource(nil, **attr_code(bibitemid: s1))
-          end
-          section << node.content
-        end
-      end
-
-      def term_designation(xml, _node, tag, text)
-        xml.send tag do |p|
-          p.expression do |e|
-            e.name { |name| name << text }
-          end
-        end
-      end
-
-      def term_source_attrs(_node, seen_xref)
-        { case: seen_xref.children[0]["case"],
-          droploc: seen_xref.children[0]["droploc"],
-          bibitemid: seen_xref.children[0]["target"],
-          format: seen_xref.children[0]["format"], type: "inline" }
-      end
-
-      def add_term_source(node, xml_t, seen_xref, match)
-        if seen_xref.children[0].name == "concept"
-          xml_t.origin { |o| o << seen_xref.children[0].to_xml }
-        else
-          attrs = term_source_attrs(node, seen_xref)
-          attrs.delete(:text)
-          xml_t.origin seen_xref.children[0].content, **attr_code(attrs)
-        end
-        match[:text] && xml_t.modification do |mod|
-          mod.p { |p| p << match[:text].sub(/^\s+/, "") }
-        end
-      end
-
-      TERM_REFERENCE_RE_STR = <<~REGEXP.freeze
-        ^(?<xref><(xref|concept)[^>]+>(.*?</(xref|concept)>)?)
-               (,\s(?<text>.*))?
-        $
-      REGEXP
-      TERM_REFERENCE_RE =
-        Regexp.new(TERM_REFERENCE_RE_STR.gsub(/\s/, "").gsub(/_/, "\\s"),
-                   Regexp::IGNORECASE | Regexp::MULTILINE)
-
-      def extract_termsource_refs(text, node)
-        matched = TERM_REFERENCE_RE.match text
-        matched.nil? and @log.add("AsciiDoc Input", node,
-                                  "term reference not in expected format:"\
-                                  "#{text}")
-        matched
-      end
-
-      def termsource(node)
-        matched = extract_termsource_refs(node.content, node) || return
-        noko do |xml|
-          status = node.attr("status") ||
-            (matched[:text] ? "modified" : "identical")
-          attrs = { status: status, type: node.attr("type") || "authoritative" }
-          xml.termsource **attrs do |xml_t|
-            seen_xref = Nokogiri::XML.fragment(matched[:xref])
-            add_term_source(node, xml_t, seen_xref, matched)
-          end
-        end.join("\n")
-      end
-
-      def termdefinition(node)
-        noko do |xml|
-          xml.definition do |d|
-            d << node.content
-          end
-        end.join("\n")
-      end
-    end
-  end
-end