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_block.rb

@@ -0,0 +1,183 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "json"
+require "pathname"
+require "open-uri"
+
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def para_cleanup(xmldoc)
+        ["//p[not(ancestor::bibdata)]", "//ol[not(ancestor::bibdata)]",
+         "//ul[not(ancestor::bibdata)]",
+         "//note[not(ancestor::bibitem or ancestor::table or ancestor::bibdata)]"
+        ].each { |w| inject_id(xmldoc, w) }
+      end
+
+      def inject_id(xmldoc, path)
+        xmldoc.xpath(path).each do |x|
+          x["id"] ||= Utils::anchor_or_uuid
+        end
+      end
+
+      # move Key dl after table footer
+      def dl_table_cleanup(xmldoc)
+        q = "//table/following-sibling::*[1][self::p]"
+        xmldoc.xpath(q).each do |s|
+          if s.text =~ /^\s*key[^a-z]*$/i && !s.next_element.nil? &&
+              s.next_element.name == "dl"
+            s.previous_element << s.next_element.remove
+            s.remove
+          end
+        end
+      end
+
+      def insert_thead(s)
+        thead = s.at("./thead")
+        return thead unless thead.nil?
+        if tname = s.at("./name")
+          thead = tname.add_next_sibling("<thead/>").first
+          return thead
+        end
+        s.children.first.add_previous_sibling("<thead/>").first
+      end
+
+      def header_rows_cleanup(xmldoc)
+        xmldoc.xpath("//table[@headerrows]").each do |s|
+          thead = insert_thead(s)
+          (thead.xpath("./tr").size...s["headerrows"].to_i).each do
+            row = s.at("./tbody/tr")
+            row.parent = thead
+          end
+          thead.xpath(".//td").each { |n| n.name = "th" }
+          s.delete("headerrows")
+        end
+      end
+
+      def table_cleanup(xmldoc)
+        dl_table_cleanup(xmldoc)
+        notes_table_cleanup(xmldoc)
+        header_rows_cleanup(xmldoc)
+      end
+
+      # move notes into table
+      def notes_table_cleanup(xmldoc)
+        nomatches = false
+        until nomatches
+          q = "//table/following-sibling::*[1][self::note]"
+          nomatches = true
+          xmldoc.xpath(q).each do |n|
+            n.previous_element << n.remove
+            nomatches = false
+          end
+        end
+      end
+
+      # include where definition list inside stem block
+      def formula_cleanup(x)
+        q = "//formula/following-sibling::*[1][self::p]"
+        x.xpath(q).each do |s|
+          if s.text =~ /^\s*where[^a-z]*$/i && !s.next_element.nil? &&
+              s.next_element.name == "dl"
+            s.previous_element << s.next_element.remove
+            s.remove
+          end
+        end
+      end
+
+      # include key definition list inside figure
+      def figure_dl_cleanup(xmldoc)
+        q = "//figure/following-sibling::*[self::p]"
+        xmldoc.xpath(q).each do |s|
+          if s.text =~ /^\s*key[^a-z]*$/i && !s.next_element.nil? &&
+              s.next_element.name == "dl"
+            s.previous_element << s.next_element.remove
+            s.remove
+          end
+        end
+      end
+
+      # examples containing only figures become subfigures of figures
+      def subfigure_cleanup(xmldoc)
+        nodes = xmldoc.xpath("//example/figure")
+        while !nodes.empty?
+          nodes[0].parent.name = "figure"
+          nodes = xmldoc.xpath("//example/figure")
+        end
+      end
+
+      def subfigure_cleanup(xmldoc)
+        xmldoc.xpath("//example[figure]").each do |e|
+          next unless e.elements.map { |m| m.name }.
+            reject { |m| %w(name figure).include? m }.empty?
+          e.name = "figure"
+        end
+      end
+
+      def figure_cleanup(xmldoc)
+        figure_footnote_cleanup(xmldoc)
+        figure_dl_cleanup(xmldoc)
+        subfigure_cleanup(xmldoc)
+      end
+
+      ELEMS_ALLOW_NOTES =
+        %w[p formula ul ol dl figure].freeze
+
+      # if a note is at the end of a section, it is left alone
+      # if a note is followed by a non-note block,
+      # it is moved inside its preceding block if it is not delimited
+      # (so there was no way of making that block include the note)
+      def note_cleanup(xmldoc)
+        q = "//note[following-sibling::*[not(local-name() = 'note')]]"
+        xmldoc.xpath(q).each do |n|
+          next if n["keep-separate"] == "true"
+          next unless n.ancestors("table").empty?
+          prev = n.previous_element || next
+          n.parent = prev if ELEMS_ALLOW_NOTES.include? prev.name
+        end
+        xmldoc.xpath("//note[@keep-separate]").each { |n| n.delete("keep-separate") }
+        xmldoc.xpath("//termnote[@keep-separate]").each { |n| n.delete("keep-separate") }
+      end
+
+      def requirement_cleanup(x)
+        requirement_descriptions(x)
+        requirement_inherit(x)
+      end
+
+      def requirement_inherit(x)
+        x.xpath("//requirement | //recommendation | //permission").each do |r|
+          ins = r.at("./classification") ||
+            r.at("./description | ./measurementtarget | ./specification | "\
+                 "./verification | ./import | ./description | ./requirement | "\
+                 "./recommendation | ./permission")
+          r.xpath("./*//inherit").each { |i| ins.previous = i }
+        end
+      end
+
+      def requirement_descriptions(x)
+        x.xpath("//requirement | //recommendation | //permission").each do |r|
+          r.children.each do |e|
+            unless e.element? && (Utils::reqt_subpart(e.name) ||
+                %w(requirement recommendation permission).include?(e.name))
+              t = Nokogiri::XML::Element.new("description", x)
+              e.before(t)
+              t.children = e.remove
+            end
+          end
+          requirement_cleanup1(r)
+        end
+      end
+
+      def requirement_cleanup1(r)
+        while d = r.at("./description[following-sibling::*[1][self::description]]")
+          n = d.next.remove
+          d << n.children
+        end
+        r.xpath("./description[normalize-space(.)='']").each do |d|
+          d.replace("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def external_terms_boilerplate(sources)
+        @i18n.l10n(
+          @i18n.external_terms_boilerplate.gsub(/%/, sources || "???"),
+          @lang, @script)
+      end
+
+      def internal_external_terms_boilerplate(sources)
+        @i18n.l10n(
+          @i18n.internal_external_terms_boilerplate.gsub(/%/, sources || "??"),
+          @lang, @script)
+      end
+
+      def term_defs_boilerplate(div, source, term, preface, isodoc)
+        a = @i18n.term_def_boilerplate and div.next = a
+        source.each do |s|
+          @anchors[s["bibitemid"]] or
+            @log.add("Crossreferences", nil, "term source #{s['bibitemid']} not referenced")
+        end
+        if source.empty? && term.nil?
+          div.next = @i18n.no_terms_boilerplate
+        else
+          div.next = term_defs_boilerplate_cont(source, term, isodoc)
+        end
+      end
+
+      def term_defs_boilerplate_cont(src, term, isodoc)
+        sources = isodoc.sentence_join(src.map do |s|
+          %{<eref bibitemid="#{s['bibitemid']}"/>}
+        end)
+        if src.empty? then @i18n.internal_terms_boilerplate
+        elsif term.nil? then external_terms_boilerplate(sources)
+        else
+          internal_external_terms_boilerplate(sources)
+        end
+      end
+
+      def norm_ref_preface(f)
+      refs = f.elements.select do |e|
+        ["reference", "bibitem"].include? e.name
+      end
+      f.at("./title").next =
+        "<p>#{(refs.empty? ? @i18n.norm_empty_pref : @i18n.norm_with_refs_pref)}</p>"
+    end
+
+      TERM_CLAUSE = "//sections/terms | "\
+        "//sections/clause[descendant::terms]".freeze
+
+      NORM_REF = "//bibliography/references[@normative = 'true']".freeze
+
+      def boilerplate_isodoc(xmldoc)
+        x = xmldoc.dup
+        x.root.add_namespace(nil, self.class::XML_NAMESPACE)
+        xml = Nokogiri::XML(x.to_xml)
+        @isodoc ||= isodoc(@lang, @script)
+        @isodoc.info(xml, nil)
+        @isodoc
+      end
+
+      def boilerplate_cleanup(xmldoc)
+        isodoc = boilerplate_isodoc(xmldoc)
+        xmldoc.xpath(self.class::TERM_CLAUSE).each do |f|
+          term_defs_boilerplate(f.at("./title"),
+                                xmldoc.xpath(".//termdocsource"),
+                                f.at(".//term"), f.at(".//p"), isodoc)
+        end
+        f = xmldoc.at(self.class::NORM_REF) and
+          norm_ref_preface(f)
+        initial_boilerplate(xmldoc, isodoc)
+      end
+
+      def initial_boilerplate(x, isodoc)
+        return if x.at("//boilerplate")
+        preface = x.at("//preface") || x.at("//sections") || x.at("//annex") ||
+          x.at("//references") || return
+        b = boilerplate(x, isodoc) or return
+        preface.previous = b
+      end
+
+      def boilerplate_file(xmldoc)
+        File.join(@libdir, "boilerplate.xml")
+      end
+
+      def boilerplate(xml, conv)
+        file = boilerplate_file(xml)
+        file = File.join(@localdir, @boilerplateauthority) if @boilerplateauthority
+        !file.nil? and File.exists?(file) or return
+        conv.populate_template((File.read(file, encoding: "UTF-8")), nil)
+      end
+
+      def bibdata_cleanup(xmldoc)
+        xmldoc.xpath("//bibdata//bibitem | //bibdata//note").each do |b|
+          b.delete("id")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "json"
+require "pathname"
+require "open-uri"
+require "pp"
+
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def footnote_content(fn)
+        c = fn.children.respond_to?(:to_xml) ? fn.children.to_xml : fn.children
+        c.gsub(/ id="[^"]+"/, "")
+      end
+
+      # include footnotes inside figure if they are the only content 
+      # of the paras following
+      def figure_footnote_cleanup(xmldoc)
+        nomatches = false
+        until nomatches
+          q = "//figure/following-sibling::*[1][self::p and *[1][self::fn]]"
+          nomatches = true
+          xmldoc.xpath(q).each do |s|
+            next if s.children.map { |c| c.text? && /[[:alpha:]]/.match(c.text) }.any?
+            s.previous_element << s.first_element_child.remove
+            s.remove
+            nomatches = false
+          end
+        end
+      end
+
+      def table_footnote_renumber1(fn, i, seen)
+        content = footnote_content(fn)
+        if seen[content] then outnum = seen[content]
+        else
+          i += 1
+          outnum = i
+          seen[content] = outnum
+        end
+        fn["reference"] = (outnum - 1 + "a".ord).chr
+        fn["table"] = true
+        [i, seen]
+      end
+
+      def table_footnote_renumber(xmldoc)
+        xmldoc.xpath("//table | //figure").each do |t|
+          seen = {}
+          i = 0
+          t.xpath(".//fn[not(ancestor::name)]").each do |fn|
+            i, seen = table_footnote_renumber1(fn, i, seen)
+          end
+        end
+      end
+
+      def other_footnote_renumber1(fn, i, seen)
+        unless fn["table"]
+          content = footnote_content(fn)
+          if seen[content] then outnum = seen[content]
+          else
+            i += 1
+            outnum = i
+            seen[content] = outnum
+          end
+          fn["reference"] = outnum.to_s
+        end
+        [i, seen]
+      end
+
+      def other_footnote_renumber(xmldoc)
+        seen = {}
+        i = 0
+        xmldoc.xpath("//fn").each do |fn|
+          i, seen = other_footnote_renumber1(fn, i, seen)
+        end
+      end
+
+      def footnote_cleanup(xmldoc)
+        table_footnote_renumber(xmldoc)
+        other_footnote_renumber(xmldoc)
+        xmldoc.xpath("//fn").each do |fn|
+          fn.delete("table")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def empty_text_before_first_element(x)
+        x.children.each do |c|
+          return false if c.text? and /\S/.match(c.text)
+          return true if c.element?
+        end
+        true
+      end
+
+      def strip_initial_space(x)
+        if x.children[0].text?
+          if !/\S/.match(x.children[0].text)
+            x.children[0].remove
+          else
+            x.children[0].content = x.children[0].text.gsub(/^ /, "")
+          end
+        end
+      end
+
+      def bookmark_cleanup(xmldoc)
+        xmldoc.xpath("//li[descendant::bookmark]").each do |x|
+          if x&.elements&.first&.name == "p" &&
+              x&.elements&.first&.elements&.first&.name == "bookmark"
+            if empty_text_before_first_element(x.elements[0])
+              x["id"] = x.elements[0].elements[0].remove["id"]
+              strip_initial_space(x.elements[0])
+            end
+          end
+        end
+      end
+
+      # extending localities to cover ISO referencing
+      LOCALITY_REGEX_STR = <<~REGEXP.freeze
+        ^((?<locality>section|clause|part|paragraph|chapter|page|
+                      table|annex|figure|example|note|formula|list|time|anchor|
+                      locality:[^ \\t\\n\\r:,;=]+)(\\s+|=)
+               (?<ref>[^"][^ \\t\\n,:-]*|"[^"]+")
+                 (-(?<to>[^"][^ \\t\\n,:-]*|"[^"]"))?|
+          (?<locality2>whole|locality:[^ \\t\\n\\r:,;=]+))(?<punct>[,:;]?)\\s*
+         (?<text>.*)$
+      REGEXP
+      LOCALITY_RE = Regexp.new(LOCALITY_REGEX_STR.gsub(/\s/, ""),
+                               Regexp::IGNORECASE | Regexp::MULTILINE)
+
+      def tq(x)
+        x.sub(/^"/, "").sub(/"$/, "")
+      end
+
+      def extract_localities(x)
+        text = x&.children&.first&.remove&.text
+        b = x.add_child("<localityStack/>").first if LOCALITY_RE.match text
+        while (m = LOCALITY_RE.match text)
+          ref = m[:ref] ? "<referenceFrom>#{tq m[:ref]}</referenceFrom>" : ""
+          refto = m[:to] ? "<referenceTo>#{tq m[:to]}</referenceTo>" : ""
+          loc = m[:locality]&.downcase || m[:locality2]&.downcase
+          b.add_child("<locality type='#{loc}'>#{ref}#{refto}</locality>")
+          text = m[:text]
+          b = x.add_child("<localityStack/>").first if m[:punct] == ";"
+        end
+        x.add_child(text) if text
+      end
+
+      def xref_to_eref(x)
+        x["bibitemid"] = x["target"]
+        x["citeas"] = @anchors&.dig(x["target"], :xref) ||
+          @log.add("Crossreferences", x,
+                   "#{x['target']} does not have a corresponding anchor ID "\
+                   "in the bibliography!")
+        x.delete("target")
+        extract_localities(x) unless x.children.empty?
+      end
+
+      def xref_cleanup(xmldoc)
+        xmldoc.xpath("//xref").each do |x|
+          if refid? x["target"]
+            x.name = "eref"
+            xref_to_eref(x)
+          else
+            x.delete("type")
+          end
+        end
+      end
+
+      def quotesource_cleanup(xmldoc)
+        xmldoc.xpath("//quote/source | //terms/source").each do |x|
+          xref_to_eref(x)
+        end
+      end
+
+      def origin_cleanup(xmldoc)
+        xmldoc.xpath("//origin/concept[termref]").each do |x|
+          x.replace(x.children)
+        end
+        xmldoc.xpath("//origin").each do |x|
+          x["citeas"] = @anchors&.dig(x["bibitemid"], :xref) ||
+            @log.add("Crossreferences", x,
+                     "#{x['bibitemid']} does not have a corresponding anchor "\
+                     "ID in the bibliography!")
+          extract_localities(x) unless x.children.empty?
+        end
+      end
+
+      def concept_cleanup(xmldoc)
+        xmldoc.xpath("//concept").each do |x|
+          x.delete("term") if x["term"].empty?
+          if /:/.match(x["key"]) then concept_termbase_cleanup(x)
+          elsif refid? x["key"] then concept_eref_cleanup(x)
+          else
+            concept_xref_cleanup(x)
+          end
+          x.delete("key")
+        end
+      end
+
+      def concept_termbase_cleanup(x)
+        text = x&.children&.first&.remove&.text
+        termbase, key = x["key"].split(/:/, 2)
+        x.add_child(%(<termref base="#{termbase}" target="#{key}">#{text}</termref>))
+      end
+
+      def concept_xref_cleanup(x)
+        text = x&.children&.first&.remove&.text
+        x.add_child(%(<xref target="#{x['key']}">#{text}</xref>))
+      end
+
+      def concept_eref_cleanup(x)
+        x.children = "<eref>#{x.children.to_xml}</eref>"
+        extract_localities(x.first_element_child)
+      end
+    end
+  end
+end