metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/metanorma-standoc-1.5.0/lib/asciidoctor/standoc/cleanup_ref.rb

@@ -0,0 +1,247 @@
+require "set"
+require "relaton_bib"
+
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def biblio_reorder(xmldoc)
+        xmldoc.xpath("//references[@normative = 'false']").each do |r|
+          biblio_reorder1(r)
+        end
+      end
+
+      def biblio_reorder1(refs)
+        fold_notes_into_biblio(refs)
+        bib = sort_biblio(refs.xpath("./bibitem"))
+        insert = refs&.at("./bibitem")&.previous_element
+        refs.xpath("./bibitem").each { |b| b.remove }
+        bib.reverse.each do |b|
+          insert and insert.next = b.to_xml or
+            refs.children.first.add_previous_sibling b.to_xml
+        end
+        extract_notes_from_biblio(refs)
+        refs.xpath("./references").each { |r| biblio_reorder1(r) }
+      end
+
+      def fold_notes_into_biblio(refs)
+        refs.xpath("./bibitem").each do |r|
+          while r&.next_element&.name == "note" do
+            r.next_element["appended"] = true
+            r << r.next_element.remove
+          end
+        end
+      end
+
+      def extract_notes_from_biblio(refs)
+        refs.xpath("./bibitem").each do |r|
+          r.xpath("./note[@appended]").reverse.each do |n|
+            n.delete("appended")
+            r.next = n
+          end
+        end
+      end
+
+      def sort_biblio(bib)
+        bib
+      end
+
+      # default presuppose that all citations in biblio numbered
+      # consecutively, but that standards codes are preserved as is:
+      # only numeric references are renumbered
+      def biblio_renumber(xmldoc)
+        r = xmldoc.at("//references[@normative = 'false'] | "\
+                      "//clause[.//references[@normative = 'false']] | "\
+                      "//annex[.//references[@normative = 'false']]") or return
+        r.xpath(".//bibitem[not(ancestor::bibitem)]").each_with_index do |b, i|
+          next unless docid = b.at("./docidentifier[@type = 'metanorma']")
+          next unless  /^\[\d+\]$/.match(docid.text)
+          docid.children = "[#{i + 1}]"
+        end
+      end
+
+      # move ref before p
+      def ref_cleanup(xmldoc)
+        xmldoc.xpath("//p/ref").each do |r|
+          parent = r.parent
+          parent.previous = r.remove
+        end
+      end
+
+      def normref_cleanup(xmldoc)
+        r = xmldoc.at(self.class::NORM_REF) || return
+        preface = r.xpath("./title/following-sibling::*") & # intersection
+          r.xpath("./bibitem[1]/preceding-sibling::*")
+        preface.each { |n| n.remove }
+      end
+
+      def biblio_cleanup(xmldoc)
+        biblio_reorder(xmldoc)
+        biblio_nested(xmldoc)
+        biblio_renumber(xmldoc)
+      end
+
+      def biblio_nested(xmldoc)
+        xmldoc.xpath("//references[references]").each do |t|
+          t.name = "clause"
+          t.xpath("./references").each { |r| r["normative"] = t["normative"] }
+          t.delete("normative")
+        end
+      end
+
+      def docid_prefix(prefix, docid)
+        docid = "#{prefix} #{docid}" unless omit_docid_prefix(prefix)
+        docid
+      end
+
+      def omit_docid_prefix(prefix)
+        return true if prefix.nil? || prefix.empty?
+        %(ISO IEC IEV ITU metanorma).include? prefix
+      end
+
+      def format_ref(ref, type, isopub)
+        return docid_prefix(type, ref) if isopub
+        return "[#{ref}]" if /^\d+$/.match(ref) && !/^\[.*\]$/.match(ref)
+        ref
+      end
+
+      ISO_PUBLISHER_XPATH =
+        "./contributor[role/@type = 'publisher']/"\
+        "organization[abbreviation = 'ISO' or abbreviation = 'IEC' or "\
+        "name = 'International Organization for Standardization' or "\
+        "name = 'International Electrotechnical Commission']".freeze
+
+      def reference_names(xmldoc)
+        xmldoc.xpath("//bibitem[not(ancestor::bibitem)]").each do |ref|
+          isopub = ref.at(ISO_PUBLISHER_XPATH)
+          docid = ref.at("./docidentifier[@type = 'metanorma']") ||
+            ref.at("./docidentifier[not(@type = 'DOI')]") or next
+          reference = format_ref(docid.text, docid["type"], isopub)
+          @anchors[ref["id"]] = { xref: reference }
+        end
+      end
+
+      def ref_dl_cleanup(xmldoc)
+        xmldoc.xpath("//clause[@bibitem = 'true']").each do |c|
+          bib = dl_bib_extract(c) or next
+          validate_ref_dl(bib, c)
+          bibitemxml = RelatonBib::BibliographicItem.new(
+            RelatonBib::HashConverter::hash_to_bib(bib)).to_xml or next
+          bibitem = Nokogiri::XML(bibitemxml)
+          bibitem["id"] = c["id"] if c["id"]
+          c.replace(bibitem.root)
+        end
+      end
+
+      def validate_ref_dl(bib, c)
+        unless bib["id"]
+          @log.add("Anchors", c, "The following reference is missing "\
+                   "an anchor:\n" + c.to_xml)
+          return
+        end
+        bib["title"] or @log.add("Bibliography", c, "Reference #{bib['id']} "\
+                                 "is missing a title")
+        bib["docid"] or @log.add("Bibliography", c, "Reference #{bib['id']} "\
+                                 "is missing a document identifier (docid)")
+      end
+
+      def extract_from_p(tag, bib, key)
+        return unless bib[tag]
+        "<#{key}>#{bib[tag].at('p').children}</#{key}>"
+      end
+
+      # if the content is a single paragraph, replace it with its children
+      # single links replaced with uri
+      def p_unwrap(p)
+        elems = p.elements
+        if elems.size == 1 && elems[0].name == "p"
+          link_unwrap(elems[0]).children.to_xml.strip
+        else
+          p.to_xml.strip
+        end
+      end
+
+      def link_unwrap(p)
+        elems = p.elements
+        if elems.size == 1 && elems[0].name == "link"
+          p.at("./link").replace(elems[0]["target"].strip)
+        end
+        p
+      end
+
+      def dd_bib_extract(dtd)
+        return nil if dtd.children.empty?
+        dtd.at("./dl") and return dl_bib_extract(dtd)
+        elems = dtd.remove.elements
+        return p_unwrap(dtd) unless elems.size == 1 &&
+          %w(ol ul).include?(elems[0].name)
+        ret = []
+        elems[0].xpath("./li").each do |li|
+          ret << p_unwrap(li)
+        end
+        ret
+      end
+
+      def add_to_hash(bib, key, val)
+        Utils::set_nested_value(bib, key.split(/\./), val)
+      end
+
+      # definition list, with at most one level of unordered lists
+      def dl_bib_extract(c, nested = false)
+        dl = c.at("./dl") or return
+        bib = {}
+        key = ""
+        dl.xpath("./dt | ./dd").each do |dtd|
+          dtd.name == "dt" and key = dtd.text.sub(/:+$/, "") or
+            add_to_hash(bib, key, dd_bib_extract(dtd))
+        end
+        c.xpath("./clause").each do |c1|
+          key = c1&.at("./title")&.text&.downcase&.strip
+          next unless %w(contributor relation series).include? key
+          add_to_hash(bib, key, dl_bib_extract(c1, true))
+        end
+        if !nested and c.at("./title")
+          title = c.at("./title").remove.children.to_xml
+          bib["title"] = bib["title"] ? Array(bib["title"]) : []
+          bib["title"] << title if !title.empty?
+        end
+        bib
+      end
+
+      def fetch_termbase(termbase, id)
+        ""
+      end
+
+      def read_local_bibitem(uri)
+        return nil if %r{^http[s]?://}.match(uri)
+        file = @localdir + uri + ".rxl"
+        File.file?(file) or file = @localdir + uri + ".xml"
+        File.file?(file) or return nil
+        xml = Nokogiri::XML(File.read(file, encoding: "utf-8"))
+        ret = xml.at("//*[local-name() = 'bibdata']") or return nil
+        ret = Nokogiri::XML(ret.to_xml.sub(
+          %r{(<bibdata[^>]*?) xmlns=("[^"]+"|'[^']+')}, "\\1")).root
+        ret.name = "bibitem"
+        ins = ret.at("./*[local-name() = 'docidentifier']") or return nil
+        ins.previous = %{<uri type="citation">#{uri}</uri>}
+        ret&.at("./*[local-name() = 'ext']")&.remove
+        ret
+      end
+
+      # if citation uri points to local file, get bibitem from it
+      def fetch_local_bibitem(xmldoc)
+        xmldoc.xpath("//bibitem[formattedref]"\
+                     "[uri[@type = 'citation']]").each do |b|
+          uri = b&.at("./uri[@type = 'citation']")&.text
+          bibitem = read_local_bibitem(uri) or next
+          bibitem["id"] = b["id"]
+          b.replace(bibitem)
+        end
+      end
+
+      def bibitem_cleanup(xmldoc)
+        ref_dl_cleanup(xmldoc)
+        fetch_local_bibitem(xmldoc)
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-standoc-1.5.0/lib/asciidoctor/standoc/cleanup_section.rb

@@ -0,0 +1,221 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "json"
+require "pathname"
+require "open-uri"
+require "mathml2asciimath"
+
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def make_preface(x, s)
+        if x.at("//foreword | //introduction | //acknowledgements | "\
+            "//*[@preface]")
+          preface = s.add_previous_sibling("<preface/>").first
+          f = x.at("//foreword") and preface.add_child f.remove
+          f = x.at("//introduction") and preface.add_child f.remove
+          move_clauses_into_preface(x, preface)
+          f = x.at("//acknowledgements") and preface.add_child f.remove
+        end
+        make_abstract(x, s)
+      end
+
+      def move_clauses_into_preface(x, preface)
+        x.xpath("//*[@preface]").each do |c|
+          c.delete("preface")
+          preface.add_child c.remove
+        end
+      end
+
+      def make_abstract(x, s)
+        if x.at("//abstract[not(ancestor::bibitem)]")
+          preface = s.at("//preface") ||
+            s.add_previous_sibling("<preface/>").first
+          abstract = x.at("//abstract[not(ancestor::bibitem)]").remove
+          preface.prepend_child abstract.remove
+          bibabstract = bibabstract_location(x)
+          dupabstract = abstract.dup
+          dupabstract.traverse { |n| n.remove_attribute("id") }
+          dupabstract.remove_attribute("language")
+          dupabstract.remove_attribute("script")
+          dupabstract&.at("./title")&.remove
+          bibabstract.next = dupabstract
+        end
+      end
+
+      def bibabstract_location(x)
+        bibabstract = x.at("//bibdata/script") || x.at("//bibdata/language") ||
+          x.at("//bibdata/contributor[not(following-sibling::contributor)]") ||
+          x.at("//bibdata/date[not(following-sibling::date)]") ||
+          x.at("//docnumber") ||
+          x.at("//bibdata/docidentifier"\
+               "[not(following-sibling::docidentifier)]") ||
+        x.at("//bibdata/uri[not(following-sibling::uri)]") ||
+        x.at("//bibdata/title[not(following-sibling::title)]")
+      end
+
+      def make_bibliography(x, s)
+        if x.at("//sections/references")
+          biblio = s.add_next_sibling("<bibliography/>").first
+          x.xpath("//sections/references").each do |r|
+            biblio.add_child r.remove
+          end
+        end
+      end
+
+      def sections_order_cleanup(x)
+        s = x.at("//sections")
+        make_preface(x, s)
+        make_annexes(x)
+        make_bibliography(x, s)
+        x.xpath("//sections/annex").reverse_each { |r| s.next = r.remove }
+      end
+      
+      def make_annexes(x)
+        x.xpath("//*[@annex]").each do |y|
+          y.delete("annex")
+          next if y.name == "annex" || !y.ancestors("annex").empty?
+          y.wrap("<annex/>")
+          y.parent["id"] = "_#{UUIDTools::UUID.random_create}"
+          y.parent["obligation"] = y["obligation"]
+          y.parent["language"] = y["language"]
+          y.parent["script"] = y["script"]
+        end
+      end
+
+      def maxlevel(x)
+        max = 5
+        x.xpath("//clause[@level]").each do |c|
+          max = c["level"].to_i if max < c["level"].to_i
+        end
+        max
+      end
+
+      def sections_level_cleanup(x)
+        m = maxlevel(x)
+        return if m < 6
+        m.downto(6).each do |l|
+          x.xpath("//clause[@level = '#{l}']").each do |c|
+            c.delete("level")
+            c.previous_element << c.remove
+          end
+        end
+      end
+
+      def sections_cleanup(x)
+        sections_order_cleanup(x)
+        sections_level_cleanup(x)
+        sections_names_cleanup(x)
+      end
+
+      def obligations_cleanup(x)
+        obligations_cleanup_info(x)
+        obligations_cleanup_norm(x)
+        obligations_cleanup_inherit(x)
+      end
+
+      def obligations_cleanup_info(x)
+        (s = x.at("//foreword")) && s["obligation"] = "informative"
+        (s = x.at("//introduction")) && s["obligation"] = "informative"
+        (s = x.at("//acknowledgements")) && s["obligation"] = "informative"
+        x.xpath("//references").each { |r| r["obligation"] = "informative" }
+        x.xpath("//preface//clause").each do |r|
+          r["obligation"] = "informative"
+        end
+      end
+
+      def obligations_cleanup_norm(x)
+        (s = x.at("//clause[@type = 'scope']")) && s["obligation"] = "normative"
+        x.xpath("//terms").each { |r| r["obligation"] = "normative" }
+        x.xpath("//definitions").each { |r| r["obligation"] = "normative" }
+      end
+
+      def obligations_cleanup_inherit(x)
+        x.xpath("//annex | //clause[not(ancestor::boilerplate)]").each do |r|
+          r["obligation"] = "normative" unless r["obligation"]
+        end
+        x.xpath(Utils::SUBCLAUSE_XPATH).each do |r|
+          o = r&.at("./ancestor::*/@obligation")&.text and r["obligation"] = o
+        end
+      end
+
+      def clausebefore_cleanup(xmldoc)
+        return unless xmldoc.at("//sections")
+        unless ins = xmldoc.at("//sections").children.first
+          xmldoc.at("//sections") << " "
+          ins = xmldoc.at("//sections").children.first
+        end
+        xmldoc.xpath("//*[@beforeclauses = 'true']").each do |x|
+          x.delete("beforeclauses")
+          ins.previous = x.remove
+        end
+      end
+
+      def get_or_make_title(node)
+          unless node.at("./title")
+            if node.children.empty?
+              node << "<title/>"
+            else
+              node.children.first.previous = "<title/>"
+            end
+          end
+          node.at("./title")
+      end
+
+      def replace_title(doc, xpath, text, first = false)
+        return unless text
+        doc.xpath(xpath).each_with_index do |node, i|
+          next if first && !i.zero?
+          title = get_or_make_title(node)
+          fn = title.xpath("./fn")
+          fn.each { |n| n.remove }
+          title.content = text
+          fn.each { |n| title << n }
+        end
+      end
+
+      def sections_names_cleanup(x)
+        replace_title(x, "//clause[@type = 'scope']", @i18n&.scope)
+        replace_title(x, "//preface//abstract", @i18n&.abstract)
+        replace_title(x, "//foreword", @i18n&.foreword)
+        replace_title(x, "//introduction", @i18n&.introduction)
+        replace_title(x, "//acknowledgements", @i18n&.acknowledgements)
+        section_names_refs_cleanup(x)
+        section_names_terms_cleanup(x)
+      end
+
+      def section_names_refs_cleanup(x)
+        replace_title(x, "//references[@normative = 'true']",
+                      @i18n&.normref, true)
+        replace_title(x, "//references[@normative = 'false']",
+                      @i18n&.bibliography, true)
+      end
+
+      NO_SYMABBR = "[.//definitions[not(@type)]]"
+      SYMABBR = "[.//definitions[@type = 'symbols']"\
+        "[@type = 'abbreviated_terms']]".freeze
+      SYMnoABBR = "[.//definitions[@type = 'symbols']"\
+        "[not(@type = 'abbreviated_terms')]]".freeze
+      ABBRnoSYM = "[.//definitions[not(@type = 'symbols')]"\
+        "[@type = 'abbreviated_terms']]".freeze
+
+      def section_names_terms_cleanup(x)
+        replace_title(x, "//definitions[@type = 'symbols']", @i18n&.symbols)
+        replace_title(x, "//definitions[@type = 'abbreviated_terms']", @i18n&.abbrev)
+        replace_title(x, "//definitions[not(@type)]", @i18n&.symbolsabbrev)
+        replace_title(x, "//terms#{SYMnoABBR} | //clause[.//terms]#{SYMnoABBR}",
+                      @i18n&.termsdefsymbols, true)
+        replace_title(x, "//terms#{ABBRnoSYM} | //clause[.//terms]#{ABBRnoSYM}",
+                      @i18n&.termsdefabbrev, true)
+        replace_title(x, "//terms#{SYMABBR} | //clause[.//terms]#{SYMABBR}",
+                      @i18n&.termsdefsymbolsabbrev, true)
+        replace_title(x, "//terms#{NO_SYMABBR} | //clause[.//terms]#{NO_SYMABBR}",
+                      @i18n&.termsdefsymbolsabbrev, true)
+        replace_title(
+          x, "//terms[not(.//definitions)] | //clause[.//terms][not(.//definitions)]",
+          @i18n&.termsdef, true)
+      end
+    end
+  end
+end