metanorma 2.0.0 → 2.5.5

data/lib/metanorma/collection/renderer/utils.rb

@@ -1,25 +1,31 @@
+require "marcel"
+
 module Metanorma
   class Collection
     class Renderer
       def dir_name_cleanse(name)
         path = Pathname.new(name)
-        clean_regex = /[<>:"|?*]/
+        clean_regex = /[<>:"|?*\p{Zs}]/
         fallback_sym = "_"
-        return name.gsub(clean_regex, fallback_sym) unless path.absolute?
-
+        path.absolute? or return name.gsub(clean_regex, fallback_sym)
         File.join(path.dirname,
                   path.basename.to_s.gsub(clean_regex, fallback_sym))
       end
 
       def dup_bibitem(docid, bib)
-        newbib = @files.get(docid, :bibdata).dup
+        newbib = deep_detached_clone(@files.get(docid, :bibdata))
         newbib.name = "bibitem"
         newbib["hidden"] = "true"
         newbib&.at("./*[local-name() = 'ext']")&.remove
         newbib["id"] = bib["id"]
+        bib["anchor"] and newbib["anchor"] = bib["anchor"]
         newbib
       end
 
+      def deep_detached_clone(node)
+        Nokogiri::XML(node.to_xml).root
+      end
+
       def get_bibitem_docid(bib, identifier)
         docid =
           bib.at(ns("./docidentifier[@type = 'metanorma-collection']")) ||
@@ -33,11 +39,11 @@ module Metanorma
         end
       end
 
-      def hide_refs(docxml)
-        docxml.xpath(ns("//references[bibitem][not(./bibitem[not(@hidden) or " \
-                        "@hidden = 'false'])]")).each do |f|
-          f["hidden"] = "true"
-        end
+      def new_hidden_ref(xml)
+        ins = xml.at(ns("bibliography")) or
+          xml.root << "<bibliography/>" and ins = xml.at(ns("bibliography"))
+        ins.at(ns("./references[@hidden = 'true']")) or
+          ins.add_child("<references hidden='true' normative='false'/>").first
       end
 
       def strip_eref(eref)
@@ -48,11 +54,12 @@ module Metanorma
       def docid_to_citeas(bib)
         docid = bib.at(ns("./docidentifier[@primary = 'true']")) ||
           bib.at(ns("./docidentifier")) or return
-        docid_prefix(docid)
+        ::Metanorma::Collection::Util::key(docid_prefix(docid))
       end
 
-      def collect_erefs(docxml)
-        docxml.xpath(ns("//eref"))
+      def collect_erefs(docxml, presxml)
+        tag = presxml ? "fmt-eref" : "eref"
+        docxml.xpath(ns("//#{tag}"))
           .each_with_object({ citeas: {}, bibitemid: {} }) do |i, m|
           m[:citeas][i["citeas"]] = true
           m[:bibitemid][i["bibitemid"]] = true
@@ -64,16 +71,35 @@ module Metanorma
           "#{val}</docidentifier>"
       end
 
-      def add_hidden_bibliography(xmldoc, refs)
-        ins = new_hidden_ref(xmldoc)
+      def add_hidden_bibliography(xml, refs, current_id = nil)
+        ins = new_hidden_ref(xml)
+        current_html = if current_id
+                         @files.get(current_id,
+                                    :outputs)&.dig(:html)
+                       else
+                         nil
+                       end
         refs.each do |k, v|
           url = @files.url(v, {})
+          url = make_relative_path(current_html, url) if current_html
           ins << <<~XML
-            <bibitem id="#{k}">#{docid_xml(v)}<uri type='citation'>#{url}</uri></bibitem>
+            <bibitem id="#{k}" anchor="#{k}">#{docid_xml(v)}<uri type='citation'>#{url}</uri></bibitem>
           XML
         end
       end
 
+      def make_relative_path(from_file, to_file)
+        return to_file if to_file.nil? || to_file.to_s.empty?
+        return to_file if to_file.start_with?("http://", "https://", "#")
+
+        from_dir = File.dirname(from_file)
+        return to_file if from_dir == "."
+
+        from_path = Pathname.new(from_dir)
+        to_path = Pathname.new(to_file)
+        to_path.relative_path_from(from_path).to_s
+      end
+
       private
 
       def docid_prefix(docid)
@@ -100,65 +126,96 @@ module Metanorma
       # @raise [ArgumentError]
       def check_options(options)
         (options[:format].is_a?(Array) && (FORMATS & options[:format]).any?) or
-          raise ArgumentError, "Need to specify formats (xml,html,pdf,doc)"
+          raise ArgumentError,
+                "Need to specify formats (xml,html,pdf,pdf-portfolio,doc)"
       end
 
-      def pdfconv
-        doctype = @doctype.to_sym
-        x = Asciidoctor.load nil, backend: doctype
-        x.converter.pdf_converter(PdfOptionsNode.new(doctype,
-                                                     @compile_options))
+      def pdfconv(added_options)
+        flavor, taste_opts, x = pdfconv_prep
+        fonts = [taste_opts[:fonts], added_options[:fonts]].compact.flatten
+          .join(";")
+        opts = @compile_options.merge(added_options.merge(taste_opts))
+        opts[:fonts] = fonts
+        x.converter.pdf_converter(PdfOptionsNode.new(flavor, opts))
+      end
+
+      def pdfconv_prep
+        flavor = Util::taste2flavor(@flavor).to_sym
+        taste_opts = Util::taste2isodoc_attrs(@flavor, :pdf)
+        x = Asciidoctor.load nil, backend: flavor
+        [flavor, taste_opts, x]
       end
 
       def fail_update_bibitem(docid, identifier)
         error = "[metanorma] Cannot find crossreference to document #{docid} " \
                 "in document #{identifier}."
-        @log&.add("Cross-References", nil, error)
+        @log&.add("METANORMA_2", nil, params: [docid, identifier])
         ::Metanorma::Util.log(error, :warning)
       end
 
       def datauri_encode(docxml, directory)
         docxml.xpath(ns("//image")).each do |i|
+          read_in_if_svg(i, directory.sub(%r{(?<!=/)$}, "/"))
+        end
+        docxml.xpath(ns("//image")).each do |i| # rubocop:disable Style/CombinableLoops
+          (i["src"] && !i["src"].empty?) or next
           i["src"] = Vectory::Utils::datauri(i["src"], directory)
         end
         docxml
       end
 
+      def read_in_if_svg(img, localdir)
+        img["src"] or return
+        if img.elements.map(&:name).include?("svg")
+          img["src"] = nil
+          return
+        end
+        path = Vectory::Utils.svgmap_rewrite0_path(img["src"], localdir)
+        svg = svg_in_path?(path) or return
+        img.children = (Nokogiri::XML(svg).root)
+        img["src"] = nil
+        true
+      end
+
+      def svg_in_path?(path)
+        File.file?(path) or return false
+        type = Marcel::MimeType.for(name: path) or return false
+        type == "image/svg+xml" or return false
+        svg = File.read(path, encoding: "utf-8") or return false
+        svg
+      end
+
       class PdfOptionsNode
-        def initialize(doctype, options)
-          p = Metanorma::Registry.instance.find_processor(doctype)
+        def initialize(flavor, options)
+          p = Metanorma::Registry.instance.find_processor(Util::taste2flavor(flavor))
           if ::Metanorma::Util::FontistHelper.has_custom_fonts?(p, options, {})
             @fonts_manifest =
               ::Metanorma::Util::FontistHelper.location_manifest(p, options)
           end
+          @options = options
         end
 
         def attr(key)
           if key == "fonts-manifest" && @fonts_manifest
             @fonts_manifest
+          else @options[key.to_sym]
           end
         end
       end
 
-      def isodoc_create
-        isodoc = Util::load_isodoc(@doctype)
-        isodoc.i18n_init(@lang, @script, @locale) # read in internationalisation
-        isodoc.metadata_init(@lang, @script, @locale, isodoc.i18n)
-        isodoc.info(@xml, nil)
-        isodoc
-      end
-
       # create the @meta class of isodoc, for populating Liquid,
       # with "navigation" set to the index bar.
       # extracted from the manifest
       def isodoc_populate
         @isodoc.info(@xml, nil)
         { navigation: indexfile(@manifest), nav_object: index_object(@manifest),
+          bibdata: YAML.safe_load(@bibdata.to_yaml,
+                                  permitted_classes: [Date, Symbol]),
           docrefs: liquid_docrefs(@manifest),
-          "prefatory-content": isodoc_builder(@xml.at("//prefatory-content")),
-          "final-content": isodoc_builder(@xml.at("//final-content")),
-          doctitle: @bibdata.title.first.title.content,
-          docnumber: @bibdata.docidentifier.first.id }.each do |k, v|
+          "prefatory-content": isodoc_builder(@xml.at("//xmlns:prefatory-content")),
+          "final-content": isodoc_builder(@xml.at("//xmlns:final-content")),
+          doctitle: Array(@bibdata.title).first&.content,
+          docnumber: Array(@bibdata.docidentifier).first&.content }.each do |k, v|
           v and @isodoc.meta.set(k, v)
         end
       end
@@ -166,15 +223,29 @@ module Metanorma
       def isodoc_builder(node)
         node or return
 
-        # Kludging namespace back in because of Shale brain damage
-        doc = Nokogiri::XML(node.to_xml.sub(">", " xmlns='http://www.metanorma.org'>"))
         Nokogiri::HTML::Builder.new(encoding: "UTF-8") do |b|
           b.div do |div|
-            doc.root.children&.each { |n| @isodoc.parse(n, div) }
+            node.children.each { |n| @isodoc.parse(n, div) }
           end
         end.doc.root.to_html
       end
 
+      def eref2link(docxml, _presxml)
+        isodoc = IsoDoc::PresentationXMLConvert.new({})
+        isodoc.bibitem_lookup(docxml)
+        isodoc.eref2link(docxml)
+      end
+
+      def error_anchor(erefs, docid)
+        erefs.each do |e|
+          msg = "<strong>** Unresolved reference to document #{docid} " \
+                "from eref</strong>"
+          e << msg
+          strip_eref(e)
+          @log&.add("METANORMA_3", e, params: [docid])
+        end
+      end
+
       def ns(xpath)
         @isodoc.ns(xpath)
       end

data/lib/metanorma/collection/sectionsplit/collection.rb

@@ -0,0 +1,110 @@
+module Metanorma
+  class Collection
+    class Sectionsplit
+      def build_collection
+        collection_setup(@base, @dir)
+        files = sectionsplit
+        input_xml = Nokogiri::XML(File.read(@input_filename,
+                                            encoding: "UTF-8"), &:huge)
+        collection_manifest(@base, files, input_xml, @xml, @dir).render(
+          { format: %i(html), output_folder: "#{@output_filename}_collection",
+            coverpage: File.join(@dir, "cover.html") }.merge(@compile_opts),
+        )
+        section_split_attachments(out: "#{@output_filename}_collection")
+      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><meta charset="UTF-8"/></head><body>
+                <h1>{{ doctitle }}</h1>
+                <h2>{{ docnumber }}</h2>
+                <nav>{{ navigation }}</nav>
+              </body></html>
+        COVER
+      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 collectionyaml(files, xml)
+        ret = {
+          directives: ["presentation-xml", "bare-after-first"],
+          bibdata: {
+            title: {
+              type: "title-main", language: @lang,
+              content: xml.at(ns("//bibdata/title"))&.text || "[TITLE]"
+            },
+            type: "collection",
+            docid: {
+              type: xml.at(ns("//bibdata/docidentifier/@type"))&.text || "[FLAVOR]",
+              id: xml.at(ns("//bibdata/docidentifier"))&.text || "[DOCID]",
+            },
+          },
+          manifest: {
+            level: "collection", title: "Collection",
+            docref: files.sort_by { |f| f[:order] }.each.map do |f|
+              # XML files are always stored flat, so fileref is always the basename
+              # f[:url] may include directory for HTML output, but XML is basename only
+              fileref = File.basename(f[:url])
+              entry = { fileref: fileref, identifier: f[:title] }
+              # Include sectionsplit_filename and sectionsplit-output when there's a directory structure
+              # This tells the renderer to preserve directory structure in HTML output
+              if @sectionsplit_filename && File.dirname(@sectionsplit_filename) != "."
+                entry[:"sectionsplit-filename"] = @sectionsplit_filename
+                entry[:"sectionsplit-output"] = true
+              end
+              entry
+            end
+          },
+        }
+        ::Metanorma::Util::recursive_string_keys(ret).to_yaml
+      end
+
+      def att_dir(file)
+        "_#{File.basename(file, '.*')}_attachments"
+      end
+
+      def section_split_attachments(out: nil)
+        attachments = att_dir(@tmp_filename)
+        File.directory?(attachments) or return
+        dir = out || File.dirname(@input_filename)
+        ret = File.join(dir, att_dir(@output_filename))
+        FileUtils.rm_rf ret
+        FileUtils.mv attachments, ret
+        File.basename(ret)
+      end
+
+      def section_split_cover(col, ident, one_doc_coll)
+        dir = File.dirname(col.file)
+        collection_setup(nil, dir)
+        r = ::Metanorma::Collection::Renderer
+          .new(col, dir, output_folder: "#{ident}_collection",
+                         format: %i(html),
+                         coverpage: File.join(dir, "cover.html"))
+        r.coverpage
+        section_split_cover1(ident, r, dir, one_doc_coll)
+      end
+
+      def section_split_cover1(ident, renderer, dir, _one_doc_coll)
+        filename = File.basename("#{ident}_index.html")
+        # ident can be a directory with YAML indirection
+        dest = File.join(dir, filename)
+        FileUtils.mv File.join(renderer.outdir, "index.html"), dest
+        FileUtils.rm_rf renderer.outdir
+        filename
+      end
+    end
+  end
+end