metanorma 1.3.7 → 1.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16196ab7719ac294eb22120afeb64ebceee75e83469bf0a4ae1abd2221952139
-  data.tar.gz: d1ed0d591efa82eb1e40b09f6598f98f6d7738435c85b6146e2ec7ada41a3413
+  metadata.gz: d8b82f79d4ce3a18564bd84c137faeca4daf763e2284464f390476fb881a0996
+  data.tar.gz: f6a33995af907243fd0ae9ebff3676467455f21cd502089da6599783b4ba4e86
 SHA512:
-  metadata.gz: 4618e5ebe7f688ae9eec5680d0f17aa2795391e1485e749f975052952378742a0c29be722e46aef10c34432a658294bb06c5eac945c56a27c65c8ab7aedc944b
-  data.tar.gz: e0b3b3ac8846b3d6ecd1fb75691d525f3763c126d2c1db3469c1192c93a14f9a168ec75f2a851f92260334c514704072cc9a59c360034d8de578ca37a2bebf24
+  metadata.gz: 484b71a094f6e23f5e512ffcbc8eac5bed0cd6d5b3fc6e952a28ce05e0e9eef3b64bff995692fd43f36b0c7888814b20318559aeeb0d9dee7900baf0847d95b8
+  data.tar.gz: 508757811e5a63b30b91d4353fdc2a983bfe269da85f39b9be50d0c6a904113965ae53c40052cd43fb38ee740c350b9922d114bfd21833383a525782d278f95c

data/lib/metanorma.rb

@@ -5,7 +5,6 @@ require "asciidoctor"
 require "metanorma/util"
 require "metanorma/config"
 require "metanorma/input"
-require "metanorma/output"
 require "metanorma/registry"
 require "metanorma/processor"
 require "metanorma/asciidoctor_extensions"

data/lib/metanorma/collection_fileprocess.rb

@@ -38,28 +38,58 @@ module Metanorma
     def add_section_split(files)
       files.keys.each_with_object({}) do |k, m|
         if files[k][:sectionsplit] == "true" && !files[k]["attachment"]
-          sectionsplit(files[k][:rel_path]).each_with_index do |f1, i|
-            m[k + f1[:title]] =
-              { parentid: k, presentationxml: true, type: "fileref",
-                rel_path: f1[:url], out_path: File.basename(f1[:url]),
-                anchors: read_anchors(Nokogiri::XML(File.read(f1[:url]))),
-                bibdata: files[k][:bibdata], ref: f1[:url] }
-            m[k + f1[:title]][:bare] = true unless i.zero?
+          s, manifest = sectionsplit(files[k][:ref])
+          s.each_with_index do |f1, i|
+            add_section_split_instance(f1, m, k, i, files)
           end
+          m["#{k}:index.html"] = add_section_split_cover(files, manifest, k)
         end
         m[k] = files[k]
       end
     end
 
+    def add_section_split_cover(files, manifest, ident)
+      cover = section_split_cover(manifest, ident)
+      files[ident][:out_path] = cover
+      { attachment: true, index: false, out_path: cover,
+        ref: File.join(File.dirname(manifest.file), cover) }
+    end
+
+    def section_split_cover(col, ident)
+      dir = File.dirname(col.file)
+      @compile.collection_setup(nil, dir)
+      CollectionRenderer.new(col, dir,
+                             output_folder: "#{ident}_collection",
+                             format: %i(html),
+                             coverpage: File.join(dir, "cover.html")).coverpage
+      FileUtils.mv "#{ident}_collection/index.html",
+                   File.join(dir, "#{ident}_index.html")
+      FileUtils.rm_rf "#{ident}_collection"
+      "#{ident}_index.html"
+    end
+
+    def add_section_split_instance(file, manifest, key, idx, files)
+      dir = File.dirname(files[key][:ref])
+      presfile = File.join(dir, File.basename(file[:url]))
+      manifest["#{key} #{file[:title]}"] =
+        { parentid: key, presentationxml: true, type: "fileref",
+          rel_path: file[:url], out_path: File.basename(file[:url]),
+          anchors: read_anchors(Nokogiri::XML(File.read(presfile))),
+          bibdata: files[key][:bibdata], ref: presfile }
+      manifest["#{key} #{file[:title]}"][:bare] = true unless idx.zero?
+    end
+
     def sectionsplit(file)
-      Compile.new.compile(
+      @compile.compile(
         file, { format: :asciidoc, extension_keys: [:presentation] }
         .merge(@compile_options)
       )
       r = file.sub(/\.xml$/, ".presentation.xml")
-      @isodoc.sectionsplit(
-        Nokogiri::XML(File.read(r)), File.basename(r), File.dirname(r)
-      ).sort_by { |f| f[:order] }
+      xml = Nokogiri::XML(File.read(r))
+      s = @compile.sectionsplit(xml, File.basename(r), File.dirname(r))
+        .sort_by { |f| f[:order] }
+      [s, @compile.collection_manifest(File.basename(r), s, xml, nil,
+                                       File.dirname(r))]
     end
 
     # rel_path is the source file address, determined relative to the YAML.
@@ -74,8 +104,9 @@ module Metanorma
             else
               { type: "id", ref: ref["id"] }
             end
-      ret[:attachment] = ref["attachment"] if ref["attachment"]
-      ret[:sectionsplit] = ref["sectionsplit"] if ref["sectionsplit"]
+      %i(attachment sectionsplit index).each do |s|
+        ret[s] = ref[s.to_s] if ref[s.to_s]
+      end
       ret[:presentationxml] = ref["presentation-xml"] if ref["presentation-xml"]
       ret[:bareafterfirst] = ref["bare-after-first"] if ref["bare-after-first"]
       ret
@@ -131,11 +162,12 @@ module Metanorma
     # compile and output individual file in collection
     # warn "metanorma compile -x html #{f.path}"
     def file_compile(file, filename, identifier)
-      c = Compile.new
-      c.compile file.path, { format: :asciidoc, extension_keys: @format }
+      return if @files[identifier][:sectionsplit] == "true"
+
+      @compile.compile file.path, { format: :asciidoc, extension_keys: @format }
         .merge(compile_options(identifier))
       @files[identifier][:outputs] = {}
-      file_compile_formats(file, filename, identifier, c)
+      file_compile_formats(file, filename, identifier)
     end
 
     def compile_options(identifier)
@@ -150,9 +182,9 @@ module Metanorma
       ret
     end
 
-    def file_compile_formats(file, filename, identifier, compile)
+    def file_compile_formats(file, filename, identifier)
       @format.each do |e|
-        ext = compile.processor.output_formats[e]
+        ext = @compile.processor.output_formats[e]
         fn = File.basename(filename).sub(/(?<=\.)[^.]+$/, ext.to_s)
         if /html$/.match?(ext) && @files[identifier][:sectionsplit]
           # file_sectionsplit_copy(file, fn, identifier, ext, e)
@@ -182,6 +214,7 @@ module Metanorma
     # process each file in the collection
     # files are held in memory, and altered as postprocessing
     def files # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      warn "\n\n\n\n\nInternal Refs: #{DateTime.now.strftime('%H:%M:%S')}"
       internal_refs = locate_internal_refs
       @files.each_with_index do |(identifier, x), i|
         i.positive? && Array(@directives).include?("bare-after-first") and
@@ -189,6 +222,7 @@ module Metanorma
         if x[:attachment] then copy_file_to_dest(x)
         else
           file, filename = targetfile(x, read: true)
+          warn "\n\n\n\n\nProcess #{filename}: #{DateTime.now.strftime('%H:%M:%S')}"
           file = update_xrefs(file, identifier, internal_refs)
           Tempfile.open(["collection", ".xml"], encoding: "utf-8") do |f|
             f.write(file)

data/lib/metanorma/collection_manifest.rb

@@ -47,9 +47,9 @@ module Metanorma
       def parse_docref(mnf)
         mnf.xpath("xmlns:docref").map do |dr|
           h = { "identifier" => dr.at("identifier").children.to_xml }
-          dr[:fileref] and h["fileref"] = dr[:fileref]
-          h["attachment"] = dr[:attachment] if dr[:attachment]
-          h["sectionsplit"] = dr[:sectionsplit] if dr[:sectionsplit]
+          %i(fileref attachment sectionsplit index).each do |s|
+            h[s.to_s] = dr[s] if dr[s]
+          end
           h["presentation-xml"] = dr[:presentationxml] if dr[:presentationxml]
           h
         end
@@ -70,7 +70,7 @@ module Metanorma
 
         m[dr["identifier"]] = Document.parse_file(
           File.join(dir, dr["fileref"]),
-          dr["attachment"], dr["identifier"]
+          dr["attachment"], dr["identifier"], dr["index"]
         )
         m
       end
@@ -118,10 +118,16 @@ module Metanorma
 
     def docref_to_xml_attrs(elem, docref)
       elem[:fileref] = @disambig.source2dest_filename(docref["fileref"])
-      elem[:attachment] = docref["attachment"] if docref["attachment"]
-      elem[:sectionsplit] = docref["sectionsplit"] if docref["sectionsplit"]
+      %i(attachment sectionsplit).each do |i|
+        elem[i] = docref[i.to_s] if docref[i.to_s]
+      end
+      elem[:index] = docref.has_key?("index") ? docref["index"] : "true"
       elem[:presentationxml] = "true" if docref["presentation-xml"] &&
-        docref["presentation-xml"] == "true" || docref["presentation-xml"] == true
+        [true, "true"].include?(docref["presentation-xml"])
+      docref_to_xml_attrs_id(elem, docref)
+    end
+
+    def docref_to_xml_attrs_id(elem, docref)
       if collection.directives.include?("documents-inline")
         id = collection.documents.find_index do |k, _|
           k == docref["identifier"]

data/lib/metanorma/collection_renderer.rb

@@ -37,10 +37,12 @@ module Metanorma
       @coverpage = options[:coverpage]
       @format = Util.sort_extensions_execution(options[:format])
       @compile_options = options[:compile] || {}
+      @compile_options[:no_install_fonts] = true if options[:no_install_fonts]
       @log = options[:log]
       @documents = collection.documents
       @directives = collection.directives
       @disambig = Util::DisambigFiles.new
+      @compile = Compile.new
 
       # list of files in the collection
       @files = read_files folder
@@ -52,14 +54,20 @@ module Metanorma
     # @param col [Metanorma::Collection] XML collection
     # @param options [Hash]
     # @option options [String] :coverpage cover page HTML (Liquid template)
-    # @option options [Array<Synbol>] :format list of formats
+    # @option options [Array<Symbol>] :format list of formats
     # @option options [Strong] :ourput_folder output directory
     def self.render(col, options = {})
       folder = File.dirname col.file
+      # require "byebug"; byebug
+      warn "\n\n\n\n\nRender Init: #{DateTime.now.strftime('%H:%M:%S')}"
       cr = new(col, folder, options)
+      warn "\n\n\n\n\nRender Files: #{DateTime.now.strftime('%H:%M:%S')}"
       cr.files
+      warn "\n\n\n\n\nConcatenate: #{DateTime.now.strftime('%H:%M:%S')}"
       cr.concatenate(col, options)
+      warn "\n\n\n\n\nCoverpage: #{DateTime.now.strftime('%H:%M:%S')}"
       cr.coverpage if options[:format]&.include?(:html)
+      warn "\n\n\n\n\nDone: #{DateTime.now.strftime('%H:%M:%S')}"
     end
 
     def concatenate(col, options)
@@ -71,7 +79,7 @@ module Metanorma
         out = col.clone
         out.directives << "documents-inline"
         out.documents.each_key do |id|
-          next if @files[id][:attachment]
+          next if @files[id][:attachment] || @files[id][:outputs].nil?
 
           filename = @files[id][:outputs][e]
           out.documents[id] = Metanorma::Document.raw_file(filename)
@@ -171,7 +179,7 @@ module Metanorma
     # @param elm [Nokogiri::XML::Element]
     # @param builder [Nokogiri::XML::Builder]
     def indexfile_docref(elm, builder)
-      return "" unless elm.at(ns("./docref"))
+      return "" unless elm.at(ns("./docref[@index = 'true']"))
 
       builder.ul { |b| docrefs(elm, b) }
     end
@@ -179,7 +187,7 @@ module Metanorma
     # @param elm [Nokogiri::XML::Element]
     # @param builder [Nokogiri::XML::Builder]
     def docrefs(elm, builder)
-      elm.xpath(ns("./docref")).each do |d|
+      elm.xpath(ns("./docref[@index = 'true']")).each do |d|
         ident = d.at(ns("./identifier")).children.to_xml
         builder.li do |li|
           li.a **{ href: index_link(d, ident) } do |a|

data/lib/metanorma/compile.rb

@@ -7,6 +7,7 @@ require "fontist/manifest/install"
 require_relative "compile_validate"
 require_relative "fontist_utils"
 require_relative "util"
+require_relative "sectionsplit"
 
 module Metanorma
   class Compile
@@ -16,6 +17,8 @@ module Metanorma
     def initialize
       @registry = Metanorma::Registry.instance
       @errors = []
+      @isodoc = IsoDoc::Convert.new({})
+      @fontist_installed = false
     end
 
     def compile(filename, options = {})
@@ -27,7 +30,8 @@ module Metanorma
       (file, isodoc = process_input(filename, options)) or return nil
       relaton_export(isodoc, options)
       extract(isodoc, options[:extract], options[:extract_type])
-      FontistUtils.install_fonts(@processor, options)
+      FontistUtils.install_fonts(@processor, options) unless @fontist_installed
+      @fontist_installed = true
       process_extensions(extensions, file, isodoc, options)
     end
 
@@ -54,7 +58,7 @@ module Metanorma
       dir = filename.sub(%r(/[^/]+$), "/")
       options[:relaton] ||= "#{dir}/#{o[:relaton]}" if o[:relaton]
       options[:sourcecode] ||= "#{dir}/#{o[:sourcecode]}" if o[:sourcecode]
-      options[:extension_keys] ||= o[:extensions]&.split(/,[ ]*/)&.map(&:to_sym)
+      options[:extension_keys] ||= o[:extensions]&.split(/, */)&.map(&:to_sym)
       options[:extension_keys] = nil if options[:extension_keys] == [:all]
       options[:format] ||= :asciidoc
       options[:filename] = filename
@@ -62,12 +66,10 @@ module Metanorma
     end
 
     def get_extensions(options)
-      options[:extension_keys] ||= @processor.output_formats.reduce([]) do |memo, (k, _)|
-        memo << k
-      end
+      options[:extension_keys] ||=
+        @processor.output_formats.reduce([]) { |memo, (k, _)| memo << k }
       extensions = options[:extension_keys].reduce([]) do |memo, e|
-        if @processor.output_formats[e]
-          memo << e
+        if @processor.output_formats[e] then memo << e
         else
           message = "[metanorma] Error: #{e} format is not supported for this standard."
           @errors << message
@@ -85,26 +87,33 @@ module Metanorma
 
     def process_input(filename, options)
       case extname = File.extname(filename)
-      when ".adoc"
-        Util.log("[metanorma] Processing: AsciiDoc input.", :info)
-        file = read_file(filename)
-        options[:asciimath] and
-          file.sub!(/^(=[^\n]+\n)/, "\\1:mn-keep-asciimath:\n")
-        dir = File.dirname(filename)
-        dir != "." and
-          file.gsub!(/^include::/, "include::#{dir}/")
-        [file, @processor.input_to_isodoc(file, filename, options)]
-      when ".xml"
-        Util.log("[metanorma] Processing: Metanorma XML input.", :info)
-        # TODO NN: this is a hack -- we should provide/bridge the
-        # document attributes in Metanorma XML
-        ["", read_file(filename)]
+      when ".adoc" then process_input_adoc(filename, options)
+      when ".xml" then process_input_xml(filename, options)
       else
-        Util.log("[metanorma] Error: file extension #{extname} is not supported.", :error)
+        Util.log("[metanorma] Error: file extension #{extname} "\
+                 "is not supported.", :error)
         nil
       end
     end
 
+    def process_input_adoc(filename, options)
+      Util.log("[metanorma] Processing: AsciiDoc input.", :info)
+      file = read_file(filename)
+      options[:asciimath] and
+        file.sub!(/^(=[^\n]+\n)/, "\\1:mn-keep-asciimath:\n")
+      dir = File.dirname(filename)
+      dir != "." and
+        file.gsub!(/^include::/, "include::#{dir}/")
+      [file, @processor.input_to_isodoc(file, filename, options)]
+    end
+
+    def process_input_xml(filename, _options)
+      Util.log("[metanorma] Processing: Metanorma XML input.", :info)
+      # TODO NN: this is a hack -- we should provide/bridge the
+      # document attributes in Metanorma XML
+      ["", read_file(filename)]
+    end
+
     def read_file(filename)
       File.read(filename, encoding: "utf-8").gsub("\r\n", "\n")
     end
@@ -132,7 +141,7 @@ module Metanorma
       return unless dirname
 
       if extract_types.nil? || extract_types.empty?
-        extract_types = [:sourcecode, :image, :requirement]
+        extract_types = %i[sourcecode image requirement]
       end
       FileUtils.rm_rf dirname
       FileUtils.mkdir_p dirname
@@ -157,7 +166,7 @@ module Metanorma
       xml.at("//image | //xmlns:image") or return
       FileUtils.mkdir_p "#{dirname}/image"
       xml.xpath("//image | //xmlns:image").each_with_index do |s, i|
-        next unless /^data:image/.match s["src"]
+        next unless /^data:image/.match? s["src"]
 
         %r{^data:image/(?<imgtype>[^;]+);base64,(?<imgdata>.+)$} =~ s["src"]
         filename = s["filename"] || sprintf("image-%04d.%s", i, imgtype)
@@ -201,15 +210,18 @@ module Metanorma
         outfilename = f.sub(/\.[^.]+$/, ".#{file_extension}")
         isodoc_options = get_isodoc_options(file, options, ext)
         if ext == :rxl
-          options[:relaton] = outfilename
-          relaton_export(isodoc, options)
+          relaton_export(isodoc, options.merge(relaton: outfilename))
         elsif options[:passthrough_presentation_xml] && ext == :presentation
           FileUtils.cp f, presentationxml_name
+        elsif ext == :html && options[:sectionsplit]
+          sectionsplit_convert(xml_name, isodoc, outfilename, isodoc_options)
         else
           begin
-            @processor.use_presentation_xml(ext) ?
-              @processor.output(nil, presentationxml_name, outfilename, ext, isodoc_options) :
+            if @processor.use_presentation_xml(ext)
+              @processor.output(nil, presentationxml_name, outfilename, ext, isodoc_options)
+            else
               @processor.output(isodoc, xml_name, outfilename, ext, isodoc_options)
+            end
           rescue StandardError => e
             isodoc_error_process(e)
           end
@@ -233,8 +245,9 @@ module Metanorma
       isodoc_options = @processor.extract_options(file)
       isodoc_options[:datauriimage] = true if options[:datauriimage]
       isodoc_options[:sourcefilename] = options[:filename]
-      isodoc_options[:bare] ||= options[:bare]
-      isodoc_options[:sectionsplit] ||= options[:sectionsplit]
+      %i(bare sectionsplit no_install_fonts).each do |x|
+        isodoc_options[x] ||= options[x]
+      end
       if ext == :pdf
         floc = FontistUtils.fontist_font_locations(@processor, options) and
           isodoc_options[:mn2pdf] = { font_manifest_file: floc.path }

data/lib/metanorma/document.rb

@@ -1,13 +1,15 @@
 module Metanorma
   class Document
     # @return [Strin]
-    attr_reader :file, :attachment, :bibitem
+    attr_reader :file, :attachment, :bibitem, :index
 
     # @param bibitem [RelatonBib::BibliographicItem]
     def initialize(bibitem, file, options = {})
       @bibitem = bibitem
       @file = file
       @attachment = options[:attachment]
+      @index = options[:index]
+      @index = true if @index.nil?
       @raw = options[:raw]
     end
 
@@ -16,10 +18,11 @@ module Metanorma
       # @param attachment [Bool] is an attachment
       # @param identifier [String] is the identifier assigned the file
       # in the collection file
+      # @param index [Bool] is indication on whether to index this file in coverpage
       # @return [Metanorma::Document]
-      def parse_file(file, attachment, identifier = nil)
+      def parse_file(file, attachment, identifier = nil, index = true)
         new(bibitem(file, attachment, identifier), file,
-            { attachment: attachment })
+            { attachment: attachment, index: index })
       end
 
       # #param xml [Nokogiri::XML::Document, Nokogiri::XML::Element]

data/lib/metanorma/processor.rb

@@ -3,10 +3,7 @@
 
 module Metanorma
   class Processor
-
-    attr_reader :short
-    attr_reader :input_format
-    attr_reader :asciidoctor_backend
+    attr_reader :short, :input_format, :asciidoctor_backend
 
     def initialize
       raise "This is an abstract class!"
@@ -16,7 +13,7 @@ module Metanorma
       {
         xml: "xml",
         presentation: "presentation.xml",
-        rxl: "rxl"
+        rxl: "rxl",
       }
     end
 
@@ -36,7 +33,7 @@ module Metanorma
       end
     end
 
-    def output(isodoc_node, inname, outname, format, options={})
+    def output(isodoc_node, _inname, outname, _format, _options = {})
       File.open(outname, "w:UTF-8") { |f| f.write(isodoc_node) }
     end
 

data/lib/metanorma/sectionsplit.rb

@@ -0,0 +1,270 @@
+require "yaml"
+
+module Metanorma
+  class Compile
+    # assume we pass in Presentation XML, but we want to recover Semantic XML
+    def sectionsplit_convert(input_filename, file, output_filename = nil,
+                             opts = {})
+      @isodoc = IsoDoc::Convert.new({})
+      input_filename += ".xml" unless input_filename.match?(/\.xml$/)
+      File.exist?(input_filename) or
+        File.open(input_filename, "w:UTF-8") { |f| f.write(file) }
+      presxml = File.read(input_filename, encoding: "utf-8")
+      @openmathdelim, @closemathdelim = @isodoc.extract_delims(presxml)
+      xml, filename, dir = @isodoc.convert_init(presxml, input_filename, false)
+      build_collection(xml, presxml, output_filename || filename, dir, opts)
+    end
+
+    def ns(xpath)
+      @isodoc.ns(xpath)
+    end
+
+    def build_collection(xml, presxml, filename, dir, opts = {})
+      base = File.basename(filename)
+      collection_setup(base, dir)
+      files = sectionsplit(xml, base, dir)
+      collection_manifest(base, files, xml, presxml, dir).render(
+        { format: %i(html), output_folder: "#{filename}_collection",
+          coverpage: File.join(dir, "cover.html") }.merge(opts),
+      )
+    end
+
+    def collection_manifest(filename, files, origxml, _presxml, dir)
+      File.open(File.join(dir, "#{filename}.html.yaml"), "w:UTF-8") do |f|
+        f.write(collectionyaml(files, origxml))
+      end
+      Metanorma::Collection.parse File.join(dir, "#{filename}.html.yaml")
+    end
+
+    def collection_setup(filename, dir)
+      FileUtils.mkdir_p "#{filename}_collection" if filename
+      FileUtils.mkdir_p dir
+      File.open(File.join(dir, "cover.html"), "w:UTF-8") do |f|
+        f.write(coll_cover)
+      end
+    end
+
+    def coll_cover
+      <<~COVER
+        <html>
+          <head/>
+            <body>
+              <h1>{{ doctitle }}</h1>
+              <h2>{{ docnumber }}</h2>
+              <nav>{{ labels["navigation"] }}</nav>
+            </body>
+        </html>
+      COVER
+    end
+
+    SPLITSECTIONS =
+      [["//preface/*", "preface"], ["//sections/*", "sections"],
+       ["//annex", nil],
+       ["//bibliography/*[not(@hidden = 'true')]", "bibliography"],
+       ["//indexsect", nil]].freeze
+
+    def sectionsplit(xml, filename, dir)
+      @key = xref_preprocess(xml)
+      @splitdir = dir
+      out = emptydoc(xml)
+      SPLITSECTIONS.each_with_object([]) do |n, ret|
+        xml.xpath(ns(n[0])).each do |s|
+          ret << sectionfile(xml, out, "#{filename}.#{ret.size}", s, n[1])
+        end
+      end
+    end
+
+    def emptydoc(xml)
+      out = xml.dup
+      out.xpath(
+        ns("//preface | //sections | //annex | //bibliography/clause | "\
+           "//bibliography/references[not(@hidden = 'true')] | //indexsect"),
+      ).each(&:remove)
+      out
+    end
+
+    def sectionfile(fulldoc, xml, file, chunk, parentnode)
+      fname = create_sectionfile(fulldoc, xml.dup, file, chunk, parentnode)
+      { order: chunk["displayorder"].to_i, url: fname,
+        title: titlerender(chunk) }
+    end
+
+    def create_sectionfile(xml, out, file, chunk, parentnode)
+      ins = out.at(ns("//misccontainer")) || out.at(ns("//bibdata"))
+      if parentnode
+        ins.next = "<#{parentnode}/>"
+        ins.next.add_child(chunk.dup)
+      else ins.next = chunk.dup
+      end
+      xref_process(out, xml, @key)
+      outname = "#{file}.xml"
+      File.open(File.join(@splitdir, outname), "w:UTF-8") { |f| f.write(out) }
+      outname
+    end
+
+    #     def xref_preprocess(xml)
+    #       svg_preprocess(xml)
+    #       key = (0...8).map { rand(65..90).chr }.join # random string
+    #       xml.root["type"] = key # to force recognition of internal refs
+    #       refs = eref_to_internal_eref(xml, key)
+    #       refs += xref_to_internal_eref(xml, key)
+    #       ins = new_hidden_ref(xml)
+    #       copy_repo_items_biblio(ins, xml)
+    #       insert_indirect_biblio(ins, refs, key)
+    #     end
+
+    def xref_preprocess(xml)
+      svg_preprocess(xml)
+      key = (0...8).map { rand(65..90).chr }.join # random string
+      xml.root["type"] = key # to force recognition of internal refs
+      key
+    end
+
+    def xref_process(section, xml, key)
+      refs = eref_to_internal_eref(section, xml, key)
+      refs += xref_to_internal_eref(section, key)
+      ins = new_hidden_ref(section)
+      copied_refs = copy_repo_items_biblio(ins, section, xml)
+      insert_indirect_biblio(ins, refs - copied_refs, key)
+    end
+
+    def svg_preprocess(xml)
+      xml.xpath("//m:svg", "m" => "http://www.w3.org/2000/svg").each do |s|
+        m = svgmap_wrap(s)
+        s.xpath(".//m:a", "m" => "http://www.w3.org/2000/svg").each do |a|
+          next unless /^#/.match? a["href"]
+
+          a["href"] = a["href"].sub(/^#/, "")
+          m << "<target href='#{a['href']}'>"\
+            "<xref target='#{a['href']}'/></target>"
+        end
+      end
+    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 make_anchor(anchor)
+      "<localityStack><locality type='anchor'><referenceFrom>"\
+        "#{anchor}</referenceFrom></locality></localityStack>"
+    end
+
+    def xref_to_internal_eref(xml, key)
+      xml.xpath(ns("//xref")).each_with_object({}) do |x, m|
+        x["bibitemid"] = "#{key}_#{x['target']}"
+        x << make_anchor(x["target"])
+        m[x["bibitemid"]] = true
+        x.delete("target")
+        x["type"] = key
+        x.name = "eref"
+      end.keys
+    end
+
+    def eref_to_internal_eref(section, xml, key)
+      eref_to_internal_eref_select(section, xml).each_with_object([]) do |x, m|
+        url = xml.at(ns("//bibitem[@id = '#{x}']/url[@type = 'citation']"))
+        section.xpath(("//*[@bibitemid = '#{x}']")).each do |e|
+          id = eref_to_internal_eref1(e, key, url)
+          id and m << id
+        end
+      end
+    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)
+      refs = section.xpath(("//*/@bibitemid")).map { |x| x.text } # rubocop:disable Style/SymbolProc
+      refs.uniq.reject do |x|
+        xml.at(ns("//bibitem[@id = '#{x}'][@type = 'internal']")) ||
+          xml.at(ns("//bibitem[@id = '#{x}']"\
+                    "[docidentifier/@type = 'repository']"))
+      end
+    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)
+      xml.xpath(ns("//references/bibitem[docidentifier/@type = 'repository']"))
+        .each_with_object([]) do |b, m|
+        section.at("//*[@bibitemid = '#{b['id']}']") or next
+        ins << b.dup
+        m << b["id"]
+      end
+    end
+
+    def insert_indirect_biblio(ins, refs, prefix)
+      refs.each do |x|
+        ins << <<~BIBENTRY
+          <bibitem id="#{x}" type="internal">
+          <docidentifier type="repository">#{x.sub(/^#{prefix}_/, "#{prefix}/")}</docidentifier>
+          </bibitem>
+        BIBENTRY
+      end
+    end
+
+    def recursive_string_keys(hash)
+      case hash
+      when Hash then Hash[
+        hash.map { |k, v| [k.to_s, recursive_string_keys(v)] }
+      ]
+      when Enumerable then hash.map { |v| recursive_string_keys(v) }
+      else
+        hash
+      end
+    end
+
+    def titlerender(section)
+      title = section.at(ns("./title")) or return "[Untitled]"
+      t = title.dup
+      t.xpath(ns(".//tab | .//br")).each { |x| x.replace(" ") }
+      t.xpath(ns(".//strong")).each { |x| x.replace(x.children) }
+      t.children.to_xml
+    end
+
+    def collectionyaml(files, xml)
+      ret = {
+        directives: ["presentation-xml", "bare-after-first"],
+        bibdata: {
+          title: {
+            type: "title-main",
+            language: @lang,
+            content: xml.at(ns("//bibdata/title")).text,
+          },
+          type: "collection",
+          docid: {
+            type: xml.at(ns("//bibdata/docidentifier/@type")).text,
+            id: xml.at(ns("//bibdata/docidentifier")).text,
+          },
+        },
+        manifest: {
+          level: "collection",
+          title: "Collection",
+          docref: files.sort_by { |f| f[:order] }.each.map do |f|
+            { fileref: f[:url], identifier: f[:title] }
+          end,
+        },
+      }
+      recursive_string_keys(ret).to_yaml
+    end
+  end
+end

data/lib/metanorma/version.rb

@@ -1,3 +1,3 @@
 module Metanorma
-  VERSION = "1.3.7".freeze
+  VERSION = "1.3.8".freeze
 end

data/metanorma.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.5.0"
 
   spec.add_runtime_dependency "asciidoctor"
-  spec.add_runtime_dependency "fontist", "~> 1.9"
+  spec.add_runtime_dependency "fontist", "~> 1.9.0"
   spec.add_runtime_dependency "htmlentities"
   spec.add_runtime_dependency "metanorma-utils", "~> 1.2.0"
   spec.add_runtime_dependency "mn2pdf", "~> 1"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma
 version: !ruby/object:Gem::Version
-  version: 1.3.7
+  version: 1.3.8
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-19 00:00:00.000000000 Z
+date: 2021-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: 1.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: 1.9.0
 - !ruby/object:Gem::Dependency
   name: htmlentities
   requirement: !ruby/object:Gem::Requirement
@@ -278,13 +278,9 @@ files:
 - lib/metanorma/input.rb
 - lib/metanorma/input/asciidoc.rb
 - lib/metanorma/input/base.rb
-- lib/metanorma/output.rb
-- lib/metanorma/output/base.rb
-- lib/metanorma/output/pdf.rb
-- lib/metanorma/output/utils.rb
-- lib/metanorma/output/xslfo.rb
 - lib/metanorma/processor.rb
 - lib/metanorma/registry.rb
+- lib/metanorma/sectionsplit.rb
 - lib/metanorma/util.rb
 - lib/metanorma/version.rb
 - metanorma.gemspec

data/lib/metanorma/output.rb

@@ -1,8 +0,0 @@
-require_relative "./output/base"
-require_relative "./output/pdf"
-require_relative "./output/xslfo"
-
-module Metanorma
-  module Output
-  end
-end

data/lib/metanorma/output/base.rb

@@ -1,13 +0,0 @@
-
-module Metanorma
-  module Output
-
-    class Base
-
-      def convert(in_path, out_path)
-        raise "This is an abstract class"
-      end
-
-    end
-  end
-end

data/lib/metanorma/output/pdf.rb

@@ -1,32 +0,0 @@
-require "open3"
-require_relative "./utils.rb"
-require "pathname"
-require "shellwords"
-
-module Metanorma
-  module Output
-    class Pdf < Base
-
-      def convert(url_path, output_path)
-        file_url = Utils::file_path(url_path)
-        pdfjs = File.join(File.dirname(__FILE__), "../../../bin/metanorma-pdf.js")
-
-        node_path = ENV["NODE_PATH"] || `npm root --quiet -g`.strip
-        node_cmd = ["node", pdfjs, file_url, output_path].map { |arg| shellescape(arg) }.join(" ")
-
-        _, error_str, status = Open3.capture3({ "NODE_PATH" => node_path }, node_cmd)
-        raise error_str unless status.success?
-      end
-
-      def shellescape(str)
-        if Gem.win_platform?()
-          # https://bugs.ruby-lang.org/issues/16741
-          str.match(" ") ? "\"#{str}\"" : str
-        else
-          Shellwords.shellescape(str)
-        end
-      end
-    end
-  end
-end
-

data/lib/metanorma/output/utils.rb

@@ -1,17 +0,0 @@
-require "pathname"
-
-module Metanorma
-  module Output
-    module Utils
-      class << self
-        def file_path(url_path)
-          file_url = url_path
-          file_url = "file://#{url_path}" if Pathname.new(file_url).absolute?
-          %r{^file://}.match?(file_url) or
-            file_url = "file://#{Dir.pwd}/#{url_path}"
-          file_url
-        end
-      end
-    end
-  end
-end

data/lib/metanorma/output/xslfo.rb

@@ -1,21 +0,0 @@
-require 'mn2pdf'
-require_relative "./utils.rb"
-
-module Metanorma
-  module Output
-    class XslfoPdf < Base
-      def convert(url_path, output_path, xsl_stylesheet, options = "")
-        return if url_path.nil? || output_path.nil? || xsl_stylesheet.nil?
-
-        Mn2pdf.convert(quote(url_path), quote(output_path), quote(xsl_stylesheet), options)
-      end
-
-      def quote(x)
-        return x if /^'.*'$/.match(x)
-        return x if /^".*"$/.match(x)
-        %("#{x}")
-      end
-    end
-  end
-end
-