metanorma 1.7.6 → 2.0.0

data/lib/metanorma/sectionsplit_links.rb

@@ -1,189 +0,0 @@
-module Metanorma
-  class Sectionsplit
-    def xref_preprocess(xml, _fileslookup, _identifier)
-      key = (0...8).map { rand(65..90).chr }.join # random string
-      xml.root["type"] = key # to force recognition of internal refs
-      # bookmarks etc as new id elements introduced in Presentation XML:
-      # add doc suffix
-      Metanorma::Utils::anchor_attributes.each do |(tag_name, attribute_name)|
-        Util::add_suffix_to_attributes(xml, xml.root["document_suffix"],
-                                       tag_name, attribute_name, @isodoc)
-      end
-      key
-    end
-
-    def xref_process(section, xml, key)
-      svg_preprocess(section, Metanorma::Utils::to_ncname(@ident))
-      refs = eref_to_internal_eref(section, xml, key)
-      refs += xref_to_internal_eref(section, xml, key)
-      ins = new_hidden_ref(section)
-      copied_refs = copy_repo_items_biblio(ins, section, xml)
-      insert_indirect_biblio(ins, refs - copied_refs, key, xml)
-    end
-
-    def svg_preprocess(xml, doc_suffix)
-      suffix = doc_suffix.nil? || doc_suffix.blank? ? "" : "_#{doc_suffix}"
-      xml.xpath("//m:svg", "m" => "http://www.w3.org/2000/svg").each do |s|
-        m = svgmap_wrap(s)
-        svg_xrefs(s, m, suffix)
-      end
-      xml
-    end
-
-    def svgmap_wrap(svg)
-      ret = svg.at("./ancestor::xmlns:svgmap") and return ret
-      ret = svg.at("./ancestor::xmlns:figure")
-      ret.wrap("<svgmap/>")
-      svg.at("./ancestor::xmlns:svgmap")
-    end
-
-    def svg_xrefs(svg, svgmap, suffix)
-      svg.xpath(".//m:a", "m" => "http://www.w3.org/2000/svg").each do |a|
-        /^#/.match? a["href"] or next
-        a["href"] = a["href"].sub(/^#/, "")
-        svgmap << "<target href='#{a['href']}'>" \
-                  "<xref target='#{a['href']}#{suffix}'/></target>"
-      end
-    end
-
-    def make_anchor(anchor)
-      "<localityStack><locality type='anchor'><referenceFrom>" \
-        "#{anchor}</referenceFrom></locality></localityStack>"
-    end
-
-    def xref_to_internal_eref(section, xml, key)
-      bibitems, indirect = xref_to_internal_eref_prep(section, xml)
-      section.xpath(ns("//xref")).each_with_object({}) do |x, m|
-        xref_prefix_key(x, key, indirect)
-        x["bibitemid"] = x["target"]
-        m[x["bibitemid"]] = true
-        xref_to_internal_eref_anchor(x, key, bibitems, xml.root["document_suffix"])
-      end.keys
-    end
-
-    def xref_to_internal_eref_prep(section, xml)
-      bibitems = Util::gather_bibitems(section)
-      indirect_bibitems = Util::gather_bibitems(xml)
-        .select { |_, v| indirect_bib?(v) }
-      [bibitems, indirect_bibitems]
-    end
-
-    def xref_to_internal_eref_anchor(xref, key, bibitems, document_suffix)
-      t = xref["target"]
-      if d = bibitems[t]&.at(ns("./docidentifier[@type = 'repository']"))
-        m = %r{^([^/]+)}.match(d.text) and
-          t.sub!(%r(#{m[0]}_), "")
-      end
-      t.sub!(%r{^#{key}_}, "")
-      xref << make_anchor(t.sub(%r(_#{document_suffix}$), ""))
-      xref.delete("target")
-      xref.name = "eref"
-    end
-
-    def xref_prefix_key(xref, key, indirect)
-      if b = indirect[xref["target"]]
-        t = b.at(ns("./docidentifier[@type = 'repository']"))
-        xref["type"] = t.text.sub(%r{/.*$}, "")
-      else
-        xref["target"] = "#{key}_#{xref['target']}"
-        xref["type"] = key
-      end
-    end
-
-    def eref_to_internal_eref(section, xml, key)
-      bibitems, bibitemids = eref_to_internal_eref_prep(section, xml)
-      eref_to_internal_eref_select(section, xml, bibitems)
-        .each_with_object([]) do |x, m|
-          url = bibitems[x]&.at(ns("./uri[@type = 'citation']"))
-          bibitemids[x]&.each do |e|
-            id = eref_to_internal_eref1(e, key, url) and m << id
-          end
-        end
-    end
-
-    def eref_to_internal_eref_prep(section, xml)
-      bibitems = Util::gather_bibitems(xml)
-        .delete_if { |_, v| internal_bib?(v) }
-      bibitemids = Util::gather_bibitemids(section)
-      [bibitems, bibitemids]
-    end
-
-    def eref_to_internal_eref1(elem, key, url)
-      if url
-        elem.name = "link"
-        elem["target"] = url
-        nil
-      else
-        elem["bibitemid"] = "#{key}_#{elem['bibitemid']}"
-        elem << make_anchor(elem["bibitemid"])
-        elem["type"] = key
-        elem["bibitemid"]
-      end
-    end
-
-    def eref_to_internal_eref_select(section, _xml, bibitems)
-      refs = Util::gather_bibitemids(section).keys
-      refs.uniq.reject do |x|
-        b = bibitems[x] and ( indirect_bib?(b) || internal_bib?(b) )
-      end
-    end
-
-    def internal_bib?(bibitem)
-      bibitem["type"] == "internal" ||
-        bibitem.at(ns("./docidentifier[@type = 'repository']"))
-    end
-
-    def indirect_bib?(bibitem)
-      a = bibitem.at(ns("./docidentifier[@type = 'repository']")) or
-        return false
-      %r{^current-metanorma-collection/}.match?(a.text) and return false
-      a.text.include?("/")
-    end
-
-    # from standoc
-    def new_hidden_ref(xmldoc)
-      ins = xmldoc.at("bibliography") or
-        xmldoc.root << "<bibliography/>" and ins = xmldoc.at("bibliography")
-      ins.add_child("<references hidden='true' normative='false'/>").first
-    end
-
-    def copy_repo_items_biblio(ins, section, xml)
-      bibitems = Util::gather_bibitems(section)
-      xml.xpath(ns("//references/bibitem[docidentifier/@type = 'repository']"))
-        .each_with_object([]) do |b, m|
-          bibitems[b["id"]] or next
-          # section.at("//*[@bibitemid = '#{b['id']}']") or next
-          ins << b.dup
-          m << b["id"]
-        end
-    end
-
-    def insert_indirect_biblio(ins, refs, key, xml)
-      refs.empty? and return
-      internal_bibitems, external_bibitems = insert_indirect_biblio_prep(xml)
-      refs.compact.reject do |x|
-        #external_bibitems[x.sub(/^#{key}_/, "")]
-      end.each do |x|
-        ins << if b = internal_bibitems[x.sub(/^#{key}_/, "")]
-                 b.dup.tap { |m| m["id"] = x }
-               else new_indirect_bibitem(x, key)
-               end
-      end
-    end
-
-    def insert_indirect_biblio_prep(xml)
-      bibitems = Util::gather_bibitems(xml)
-      internal_bibitems = bibitems.select { |_, v| internal_bib?(v) }
-      external_bibitems = bibitems.reject { |_, v| internal_bib?(v) }
-      [internal_bibitems, external_bibitems]
-    end
-
-    def new_indirect_bibitem(ident, prefix)
-      <<~BIBENTRY
-        <bibitem id="#{ident}" type="internal">
-        <docidentifier type="repository">#{ident.sub(/^#{prefix}_/, "#{prefix}/")}</docidentifier>
-        </bibitem>
-      BIBENTRY
-    end
-  end
-end

data/lib/metanorma/util.rb

@@ -1,127 +0,0 @@
-module Metanorma
-  module Util
-    def self.log(message, type = :info)
-      log_types = Metanorma.configuration.logs.map(&:to_s) || []
-
-      if log_types.include?(type.to_s)
-        puts(message)
-      end
-
-      if type == :fatal
-        exit(1)
-      end
-    end
-
-    # dependency ordering
-    def self.sort_extensions_execution_ord(ext)
-      case ext
-      when :xml then 0
-      when :rxl then 1
-      when :presentation then 2
-      else
-        99
-      end
-    end
-
-    def self.sort_extensions_execution(ext)
-      ext.sort do |a, b|
-        sort_extensions_execution_ord(a) <=> sort_extensions_execution_ord(b)
-      end
-    end
-
-    def self.recursive_string_keys(hash)
-      case hash
-      when Hash then hash.map { |k, v| [k.to_s, recursive_string_keys(v)] }.to_h
-      when Enumerable then hash.map { |v| recursive_string_keys(v) }
-      else
-        hash
-      end
-    end
-
-    def self.gather_bibitems(xml)
-      xml.xpath("//xmlns:bibitem[@id]").each_with_object({}) do |b, m|
-        if m[b["id"]]
-          b.remove
-          next # we can't update duplicate bibitem, processing updates wrong one
-        else
-          m[b["id"]] = b
-        end
-      end
-    end
-
-    def self.gather_bibitemids(xml)
-      xml.xpath("//*[@bibitemid]").each_with_object({}) do |e, m|
-        /^semantic__/.match?(e.name) and next
-        m[e["bibitemid"]] ||= []
-        m[e["bibitemid"]] << e
-      end
-    end
-
-    def self.gather_citeases(xml)
-      xml.xpath("//*[@citeas]").each_with_object({}) do |e, m|
-        /^semantic__/.match?(e.name) and next
-        m[e["citeas"]] ||= []
-        m[e["citeas"]] << e
-      end
-    end
-
-    def self.add_suffix_to_attributes(doc, suffix, tag_name, attr_name, isodoc)
-      (suffix.nil? || suffix.empty?) and return
-      doc.xpath(isodoc.ns("//#{tag_name}[@#{attr_name}]")).each do |elem|
-        a = elem.attributes[attr_name].value
-        /_#{suffix}$/.match?(a) or
-          elem.attributes[attr_name].value = "#{a}_#{suffix}"
-      end
-    end
-
-    def self.hash_key_detect(directives, key, variable)
-      c = directives.detect { |x| x.is_a?(Hash) && x.has_key?(key) } or
-        return variable
-      c[key]
-    end
-
-    def self.rel_path_resolve(dir, path)
-      path.nil? and return path
-      path.empty? and return path
-      p = Pathname.new(path)
-      p.absolute? ? path : File.join(dir, path)
-    end
-
-    def self.key(ident)
-      @c ||= HTMLEntities.new
-      @c.decode(ident).gsub(/(\p{Zs})+/, " ")
-    end
-
-    class DisambigFiles
-      def initialize
-        @seen_filenames = []
-      end
-
-      def strip_root(name)
-        name.sub(%r{^(\./)?(\.\./)+}, "")
-      end
-
-      def source2dest_filename(name, disambig = true)
-        n = strip_root(name)
-        dir = File.dirname(n)
-        base = File.basename(n)
-        if disambig && @seen_filenames.include?(base)
-          base = disambiguate_filename(base)
-        end
-        @seen_filenames << base
-        dir == "." ? base : File.join(dir, base)
-      end
-
-      def disambiguate_filename(base)
-        m = /^(?<start>.+\.)(?!0)(?<num>\d+)\.(?<suff>[^.]*)$/.match(base) ||
-          /^(?<start>.+\.)(?<suff>[^.]*)/.match(base) ||
-          /^(?<start>.+)$/.match(base)
-        i = m.names.include?("num") ? m["num"].to_i + 1 : 1
-        while @seen_filenames.include? base = "#{m['start']}#{i}.#{m['suff']}"
-          i += 1
-        end
-        base
-      end
-    end
-  end
-end

data/lib/metanorma/worker_pool.rb

@@ -1,29 +0,0 @@
-module Metanorma
-  class WorkersPool
-    def initialize(workers)
-      @workers = workers
-      @queue = SizedQueue.new(@workers)
-      @threads = Array.new(@workers) do
-        Thread.new do
-          catch(:exit) do
-            loop do
-              job, args = @queue.pop
-              job.call *args
-            end
-          end
-        end
-      end
-    end
-
-    def schedule(*args, &block)
-      @queue << [block, args]
-    end
-
-    def shutdown
-      @workers.times do
-        schedule { throw :exit }
-      end
-      @threads.map(&:join)
-    end
-  end
-end