metanorma-standoc 1.11.4 → 2.0.0

data/lib/asciidoctor/standoc/terms.rb

@@ -1,160 +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 **attr_code(attrs) do |o|
-            o << seen_xref.children[0].children.to_xml
-          end
-        end
-        add_term_source_mod(xml_t, match)
-      end
-
-      def add_term_source_mod(xml_t, match)
-        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

data/lib/asciidoctor/standoc/utils.rb

@@ -1,101 +1,3 @@
-require "date"
-require "nokogiri"
-require "htmlentities"
-require "json"
-require "pathname"
-require "uuidtools"
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/utils"
 
-module Asciidoctor
-  module Standoc
-    module Utils
-      def convert(node, transform = nil, opts = {})
-        transform ||= node.node_name
-        opts.empty? ? (send transform, node) : (send transform, node, opts)
-      end
-
-      def document_ns_attributes(_doc)
-        nil
-      end
-
-      NOKOHEAD = <<~HERE.freeze
-        <!DOCTYPE html SYSTEM
-        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-        <html xmlns="http://www.w3.org/1999/xhtml">
-        <head> <title></title> <meta charset="UTF-8" /> </head>
-        <body> </body> </html>
-      HERE
-
-      # block for processing XML document fragments as XHTML,
-      # to allow for HTMLentities
-      # Unescape special chars used in Asciidoctor substitution processing
-      def noko(&block)
-        doc = ::Nokogiri::XML.parse(NOKOHEAD)
-        fragment = doc.fragment("")
-        ::Nokogiri::XML::Builder.with fragment, &block
-        fragment.to_xml(encoding: "US-ASCII", indent: 0).lines.map do |l|
-          l.gsub(/>\n$/, ">").gsub(/\s*\n$/m, " ").gsub("&#150;", "\u0096")
-            .gsub("&#151;", "\u0097").gsub("&#x96;", "\u0096")
-            .gsub("&#x97;", "\u0097")
-        end
-      end
-
-      def attr_code(attributes)
-        attributes.compact.transform_values do |v|
-          v.is_a?(String) ? HTMLEntities.new.decode(v) : v
-        end
-      end
-
-      # if the contents of node are blocks, output them to out;
-      # else, wrap them in <p>
-      def wrap_in_para(node, out)
-        if node.blocks? then out << node.content
-        else
-          out.p { |p| p << node.content }
-        end
-      end
-
-      SUBCLAUSE_XPATH = "//clause[not(parent::sections)]"\
-                        "[not(ancestor::boilerplate)]".freeze
-
-      def isodoc(lang, script, i18nyaml = nil)
-        conv = html_converter(EmptyAttr.new)
-        i18n = conv.i18n_init(lang, script, i18nyaml)
-        conv.metadata_init(lang, script, i18n)
-        conv
-      end
-
-      def dl_to_attrs(elem, dlist, name)
-        e = dlist.at("./dt[text()='#{name}']") or return
-        val = e.at("./following::dd/p") || e.at("./following::dd") or return
-        elem[name] = val.text
-      end
-
-      def dl_to_elems(ins, elem, dlist, name)
-        a = elem.at("./#{name}[last()]")
-        ins = a if a
-        dlist.xpath("./dt[text()='#{name}']").each do |e|
-          v = e.at("./following::dd")
-          e = v.elements and e.size == 1 && e.first.name == "p" and v = e.first
-          v.name = name
-          ins.next = v
-          ins = ins.next
-        end
-        ins
-      end
-
-      def term_expr(elem)
-        "<expression><name>#{elem}</name></expression>"
-      end
-
-      class EmptyAttr
-        def attr(_any_attribute)
-          nil
-        end
-
-        def attributes
-          {}
-        end
-      end
-    end
-  end
-end

data/lib/asciidoctor/standoc/validate.rb

@@ -1,158 +1,3 @@
-require "asciidoctor/standoc/utils"
-require_relative "./validate_section"
-require "nokogiri"
-require "jing"
-require "iev"
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/validate"
 
-module Asciidoctor
-  module Standoc
-    module Validate
-      SOURCELOCALITY = "./origin//locality[@type = 'clause']/"\
-                       "referenceFrom".freeze
-
-      def init_iev
-        return nil if @no_isobib
-        return @iev if @iev
-
-        @iev = Iev::Db.new(@iev_globalname, @iev_localname) unless @no_isobib
-        @iev
-      end
-
-      def iev_validate(xmldoc)
-        @iev = init_iev or return
-        xmldoc.xpath("//term").each do |t|
-          t.xpath(".//termsource").each do |src|
-            (/^IEC 60050-/.match(src&.at("./origin/@citeas")&.text) &&
-          loc = src.xpath(SOURCELOCALITY)&.text) or next
-            iev_validate1(t, loc, xmldoc)
-          end
-        end
-      end
-
-      def iev_validate1(term, loc, xmldoc)
-        iev = @iev.fetch(loc,
-                         xmldoc&.at("//language")&.text || "en") or return
-        pref = term.xpath("./preferred//name").inject([]) do |m, x|
-          m << x&.text&.downcase
-        end
-        pref.include?(iev.downcase) or
-          @log.add("Bibliography", term, %(Term "#{pref[0]}" does not match ) +
-                   %(IEV #{loc} "#{iev}"))
-      end
-
-      def content_validate(doc)
-        @fatalerror = []
-        xref_validate(doc)
-        section_validate(doc)
-        norm_ref_validate(doc)
-        repeat_id_validate(doc.root)
-        iev_validate(doc.root)
-        concept_validate(doc, "concept", "refterm")
-        concept_validate(doc, "related", "preferred//name")
-        @fatalerror.empty? or clean_abort(@fatalerror.join("\n"), doc.to_xml)
-      end
-
-      def norm_ref_validate(doc)
-        found = false
-        doc.xpath("//references[@normative = 'true']/bibitem").each do |b|
-          next unless docid = b.at("./docidentifier[@type = 'metanorma']")
-          next unless /^\[\d+\]$/.match?(docid.text)
-
-          @log.add("Bibliography", b,
-                   "Numeric reference in normative references")
-          found = true
-        end
-        found and @fatalerror << "Numeric reference in normative references"
-      end
-
-      def concept_validate(doc, tag, refterm)
-        found = false
-        doc.xpath("//#{tag}/xref").each do |x|
-          next if doc.at("//term[@id = '#{x['target']}']")
-          next if doc.at("//definitions//dt[@id = '#{x['target']}']")
-
-          ref = x&.at("../#{refterm}")&.text
-          @log.add("Anchors", x,
-                   "#{tag.capitalize} #{ref} is pointing to "\
-                   "#{x['target']}, which is not a term or symbol")
-          found = true
-        end
-        found and
-          @fatalerror << "#{tag.capitalize} not cross-referencing term or symbol"
-      end
-
-      def repeat_id_validate1(ids, elem)
-        if ids[elem["id"]]
-          @log.add("Anchors", elem, "Anchor #{elem['id']} has already been "\
-                                    "used at line #{ids[elem['id']]}")
-          @fatalerror << "Multiple instances of same ID: #{elem['id']}"
-        else
-          ids[elem["id"]] = elem.line
-        end
-        ids
-      end
-
-      def repeat_id_validate(doc)
-        ids = {}
-        doc.xpath("//*[@id]").each do |x|
-          ids = repeat_id_validate1(ids, x)
-        end
-      end
-
-      def schema_validate(doc, schema)
-        Tempfile.open(["tmp", ".xml"], encoding: "UTF-8") do |f|
-          schema_validate1(f, doc, schema)
-        rescue Jing::Error => e
-          clean_abort("Jing failed with error: #{e}", doc.to_xml)
-        ensure
-          f.close!
-        end
-      end
-
-      def schema_validate1(file, doc, schema)
-        file.write(doc.to_xml)
-        file.close
-        errors = Jing.new(schema, encoding: "UTF-8").validate(file.path)
-        warn "Syntax Valid!" if errors.none?
-        errors.each do |e|
-          @log.add("Metanorma XML Syntax",
-                   "XML Line #{'%06d' % e[:line]}:#{e[:column]}", e[:message])
-        end
-      end
-
-      # RelaxNG cannot cope well with wildcard attributes. So we strip
-      # any attributes from FormattedString instances (which can contain
-      # xs:any markup, and are signalled with @format) before validation.
-      def formattedstr_strip(doc)
-        doc.xpath("//*[@format] | //stem | //bibdata//description | "\
-                  "//formattedref | //bibdata//note | //bibdata/abstract | "\
-                  "//bibitem/abstract | //bibitem/note | //misc-container")
-          .each do |n|
-          n.elements.each do |e|
-            e.traverse do |e1|
-              e1.element? and e1.each { |k, _v| e1.delete(k) }
-            end
-          end
-        end
-        doc
-      end
-
-      # manually check for xref/@target, xref/@to integrity
-      def xref_validate(doc)
-        ids = doc.xpath("//*/@id").each_with_object({}) { |x, m| m[x.text] = 1 }
-        doc.xpath("//xref/@target | //xref/@to").each do |x|
-          next if ids[x.text]
-
-          @log.add("Anchors", x.parent,
-                   "Crossreference target #{x.text} is undefined")
-        end
-      end
-
-      def validate(doc)
-        content_validate(doc)
-        schema_validate(formattedstr_strip(doc.dup),
-                        File.join(File.dirname(__FILE__), "isodoc.rng"))
-      end
-    end
-  end
-end

data/lib/asciidoctor/standoc/validate_section.rb

@@ -1,55 +1,3 @@
-require "nokogiri"
+require "asciidoctor/standoc/deprecated"
+require "metanorma/standoc/validate_section"
 
-module Asciidoctor
-  module Standoc
-    module Validate
-      def section_validate(doc)
-        sourcecode_style(doc.root)
-        hanging_para_style(doc.root)
-        asset_style(doc.root)
-      end
-
-      def sourcecode_style(root)
-        root.xpath("//sourcecode").each do |x|
-          callouts = x.elements.select { |e| e.name == "callout" }
-          annotations = x.elements.select { |e| e.name == "annotation" }
-          if callouts.size != annotations.size
-            @log.add("AsciiDoc Input", x,
-                     "mismatch of callouts and annotations")
-          end
-        end
-      end
-
-      def style_warning(node, msg, text = nil)
-        w = msg
-        w += ": #{text}" if text
-        @log.add("Metanorma XML Style Warning", node, w)
-      end
-
-      def asset_title_style(root)
-        root.xpath("//figure[image][not(name)]").each do |node|
-          style_warning(node, "Figure should have title", nil)
-        end
-        root.xpath("//table[not(name)]").each do |node|
-          style_warning(node, "Table should have title", nil)
-        end
-      end
-
-      def asset_style(root)
-        asset_title_style(root)
-      end
-
-      def hanging_para_style(root)
-        root.xpath("//clause | //annex | //foreword | //introduction | "\
-                   "//acknowledgements").each do |c|
-          next unless c.at("./clause")
-          next if c.elements.reject do |n|
-                    %w(clause title).include? n.name
-                  end.empty?
-
-          style_warning(c, "Hanging paragraph in clause")
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/standoc/base.rb

@@ -0,0 +1,149 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "json"
+require "pathname"
+require "isodoc"
+require "relaton"
+require "fileutils"
+require "metanorma-utils"
+require "isodoc/xslfo_convert"
+require_relative "render"
+
+module Metanorma
+  module Standoc
+    module Base
+      XML_ROOT_TAG = "standard-document".freeze
+      XML_NAMESPACE = "https://www.metanorma.org/ns/standoc".freeze
+      FONTS_MANIFEST = "fonts-manifest".freeze
+
+      def xml_root_tag
+        self.class::XML_ROOT_TAG
+      end
+
+      def xml_namespace
+        self.class::XML_NAMESPACE
+      end
+
+      def init(node)
+        @fn_number ||= 0
+        @draft = false
+        @refids = Set.new
+        @anchors = {}
+        @internal_eref_namespaces = []
+        @draft = node.attributes.has_key?("draft")
+        @novalid = node.attr("novalid")
+        @smartquotes = node.attr("smartquotes") != "false"
+        @keepasciimath = node.attr("mn-keep-asciimath") &&
+          node.attr("mn-keep-asciimath") != "false"
+        @fontheader = default_fonts(node)
+        @files_to_delete = []
+        @filename = if node.attr("docfile")
+                      File.basename(node.attr("docfile"))&.gsub(/\.adoc$/, "")
+                    else ""
+                    end
+        @localdir = Metanorma::Utils::localdir(node)
+        @output_dir = outputdir node
+        @no_isobib_cache = node.attr("no-isobib-cache")
+        @no_isobib = node.attr("no-isobib")
+        @index_terms = node.attr("index-terms")
+        @sourcecode_markup_start = node.attr("sourcecode-markup-start") || "{{{"
+        @sourcecode_markup_end = node.attr("sourcecode-markup-end") || "}}}"
+        @bibdb = nil
+        @seen_headers = []
+        @datauriimage = node.attr("data-uri-image") != "false"
+        @boilerplateauthority = node.attr("boilerplate-authority")
+        @sourcecode_markup_start = node.attr("sourcecode-markup-start") || "{{{"
+        @sourcecode_markup_end = node.attr("sourcecode-markup-end") || "}}}"
+        @log = Metanorma::Utils::Log.new
+        init_bib_caches(node)
+        init_iev_caches(node)
+        @lang = (node.attr("language") || "en")
+        @script = (node.attr("script") ||
+                   Metanorma::Utils.default_script(node.attr("language")))
+        @isodoc = isodoc(@lang, @script, node.attr("i18nyaml"))
+        @i18n = @isodoc.i18n
+        @htmltoclevels = node.attr("htmltoclevels")
+        @doctoclevels = node.attr("doctoclevels")
+        @toclevels = node.attr("toclevels")
+      end
+
+      def document(node)
+        init(node)
+        ret = makexml(node).to_xml(encoding: "US-ASCII", indent: 2)
+        outputs(node, ret) unless node.attr("nodoc") || !node.attr("docfile")
+        clean_exit
+        ret
+      rescue StandardError => e
+        @log.add("Fatal Error", nil, e.message)
+        clean_exit
+        raise e
+      end
+
+      def version
+        flavour = self.class.name.sub(/::Converter$/, "").sub(/^.+::/, "")
+        Metanorma.versioned(Metanorma, flavour)[-1]::VERSION
+      end
+
+      def clean_exit
+        @log.write("#{@output_dir}#{@filename}.err") unless @novalid
+
+        @files_to_delete.each { |f| FileUtils.rm f }
+      end
+
+      def clean_abort(msg, file = nil)
+        file and
+          File.open("#{@filename}.xml.abort", "w:UTF-8") { |f| f.write(file) }
+        clean_exit
+        abort(msg)
+      end
+
+      def makexml1(node)
+        result = ["<?xml version='1.0' encoding='UTF-8'?>",
+                  "<#{xml_root_tag} type='semantic' version='#{version}'>"]
+        result << noko { |ixml| front node, ixml }
+        result << noko { |ixml| middle node, ixml }
+        result << "</#{xml_root_tag}>"
+        textcleanup(result)
+      end
+
+      def makexml(node)
+        result = makexml1(node)
+        ret1 = cleanup(Nokogiri::XML(result))
+        ret1.root.add_namespace(nil, xml_namespace)
+        validate(ret1) unless @novalid
+        ret1
+      end
+
+      def draft?
+        @draft
+      end
+
+      def doctype(node)
+        node.attr("doctype")&.gsub(/\s+/, "-")&.downcase
+      end
+
+      def front(node, xml)
+        xml.bibdata **attr_code(type: "standard") do |b|
+          metadata node, b
+        end
+      end
+
+      def middle(node, xml)
+        xml.sections do |s|
+          s << node.content if node.blocks?
+        end
+      end
+
+      private
+
+      def outputdir(node)
+        if node.attr("output_dir").nil_or_empty?
+          Metanorma::Utils::localdir(node)
+        else
+          File.join(node.attr("output_dir"), "")
+        end
+      end
+    end
+  end
+end