metanorma 2.2.9 → 2.3.1

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Metanorma
+  class Collection
+    class Renderer
+      def file_compile_formats(filename, identifier, opts)
+        f = @files.get(identifier, :outputs)
+        format = opts[:extension_keys]
+        concatenate_presentation?({ format: }) and format << :presentation
+        format.each do |e|
+          e == :pdf and output_filename = opts[:pdffile]
+          file_compile_format(filename, identifier, e, f, output_filename)
+        end
+        @files.set(identifier, :outputs, f)
+      end
+
+      # Generate output filename with correct extension
+      def output_filename_with_extension(fname, format)
+        ext = @compile.processor.output_formats[format]
+        fname_base = File.basename(fname)
+        # ONLY replace .xml or .html extensions, NEVER remove section numbers
+        if /\.(xml|html)$/.match?(fname_base)
+          fname_base.sub(/\.(xml|html)$/, ".#{ext}")
+        else
+          "#{fname_base}.#{ext}"
+        end
+      end
+
+      # Move file to new output filename if specified
+      def handle_new_output_filename(output_fname, new_output_fname)
+        return output_fname unless new_output_fname
+
+        FileUtils.mv(File.join(@outdir, output_fname),
+                     File.join(@outdir, new_output_fname))
+        new_output_fname
+      end
+
+      # Apply custom filename pattern with substitutions
+      def apply_custom_filename_pattern(ident, custom_fname, output_fname,
+format)
+        idx = @files.get(ident, :idx)
+        original_file = @files.get(ident, :ref)
+        basename = File.basename(original_file, ".*")
+        basename_legacy = File.basename(original_file)
+        custom_fname = @files.substitute_filename_pattern(
+          custom_fname, document_num: idx,
+                        basename: basename, basename_legacy: basename_legacy
+        )
+        if File.dirname(custom_fname) == "."
+          output_fname
+        else
+          preserve_output_dir_structure(custom_fname, output_fname,
+                                        format, explicit_custom: true)
+        end
+      end
+
+      # Apply directory preservation for files with directory structure
+      def apply_directory_preservation(fname, output_fname, format)
+        fname_dir = File.dirname(fname)
+        output_fname = File.join(fname_dir, output_fname)
+        preserve_output_dir_structure(fname, output_fname, format)
+      end
+
+      # Compile single format for a file and update outputs hash
+      def file_compile_format(fname, ident, format, outputs, new_output_fname)
+        ext = @compile.processor.output_formats[format]
+        output_fname = output_filename_with_extension(fname, format)
+        output_fname = handle_new_output_filename(output_fname,
+                                                  new_output_fname)
+        if !new_output_fname && (custom = @files.preserve_directory_structure?(ident))
+          output_fname = apply_custom_filename_pattern(ident, custom,
+                                                       output_fname, format)
+        elsif !new_output_fname && File.dirname(fname) != "."
+          output_fname = apply_directory_preservation(fname, output_fname,
+                                                      format)
+        end
+        should_skip = /html$/.match?(ext) && @files.get(ident, :sectionsplit)
+        should_skip or outputs[format] = File.join(@outdir, output_fname)
+      end
+
+      # Determine if file should be moved to subdirectory
+      def should_move_to_subdirectory?(ext, output_basename, explicit_custom)
+        if explicit_custom
+          # For explicit output-filename: move html, doc, pdf, presentation.xml
+          ext.end_with?("html") || ext == "doc" || ext == "pdf" ||
+            output_basename.end_with?(".presentation.xml")
+        else
+          # Default: only HTML and presentation files
+          ext.end_with?("html") ||
+            output_basename.end_with?(".html", ".presentation.xml")
+        end
+      end
+
+      # Move file from root to subdirectory
+      def move_file_to_subdirectory(fname_dir, output_basename)
+        output_with_dir = File.join(fname_dir, output_basename)
+        output_dest = File.join(@outdir, output_with_dir)
+        output_src = File.join(@outdir, output_basename)
+        return nil unless File.exist?(output_src) && output_src != output_dest
+
+        FileUtils.mkdir_p(File.dirname(output_dest))
+        FileUtils.mv(output_src, output_dest)
+        output_with_dir
+      end
+
+      # Handle case where destination already exists
+      def handle_existing_destination(output_with_dir, output_src)
+        output_dest = File.join(@outdir, output_with_dir)
+        return nil unless File.exist?(output_dest)
+        return output_with_dir unless File.exist?(output_src)
+
+        FileUtils.rm_f(output_src)
+        err_src = output_src.sub(/\.html$/, ".err.html")
+        FileUtils.rm_f(err_src) if File.exist?(err_src)
+        output_with_dir
+      end
+
+      # Generate custom basename with extension
+      def custom_basename_with_extension(fname, output_basename)
+        custom_basename = File.basename(fname, ".*")
+        ext = File.extname(output_basename)
+        "#{custom_basename}#{ext}"
+      end
+
+      # Preserve directory structure from input filename in output
+      def preserve_output_dir_structure(fname, output_fname, format = nil,
+explicit_custom: false)
+        fname_dir = File.dirname(fname)
+        return output_fname if fname_dir == "."
+
+        output_basename = File.basename(output_fname)
+        ext = format ? @compile.processor.output_formats[format].to_s : ""
+        should_move = should_move_to_subdirectory?(ext, output_basename,
+                                                   explicit_custom)
+        if should_move
+          result = move_file_to_subdirectory(fname_dir, output_basename)
+          return result if result
+
+          handle_existing_destination(File.join(fname_dir, output_basename),
+                                      File.join(@outdir,
+                                                output_basename)) || output_fname
+        elsif explicit_custom
+          custom_basename_with_extension(fname, output_basename)
+        else
+          output_basename
+        end
+      end
+
+      def copy_file_to_dest(identifier)
+        out = Pathname.new(@files.get(identifier, :out_path)).cleanpath
+        out.absolute? and
+          out = out.relative_path_from(File.expand_path(FileUtils.pwd))
+        dest = File.join(@outdir,
+                         @disambig.source2dest_filename(out.to_s,
+                                                        preserve_dirs: true))
+        FileUtils.mkdir_p(File.dirname(dest))
+        source = @files.get(identifier, :ref)
+        source != dest and FileUtils.cp_r source, dest, remove_destination: true
+      end
+    end
+  end
+end

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

@@ -22,7 +22,8 @@ module Metanorma
         @ncnames = {}
         @nested or update_indirect_refs_to_docs(xml, docid, internal_refs, sso)
         @files.add_document_suffix(docid, xml)
-        @nested or update_sectionsplit_refs_to_docs(xml, internal_refs, sso)
+        @nested or update_sectionsplit_refs_to_docs(xml, docid, internal_refs,
+                                                    sso)
         update_direct_refs_to_docs(xml, docid, sso)
         ::Metanorma::Collection::Util::hide_refs(xml)
         sso and eref2link(xml, sso)
@@ -38,7 +39,8 @@ module Metanorma
         [docxml, sso]
       end
 
-      def update_sectionsplit_refs_to_docs(docxml, internal_refs, presxml)
+      def update_sectionsplit_refs_to_docs(docxml, docid, internal_refs,
+presxml)
         Util::gather_citeases(docxml, presxml).each do |k, v|
           (@files.get(k) && @files.get(k, :sectionsplit)) or next
           opts = { key: @files.get(k, :indirect_key),
@@ -47,7 +49,7 @@ module Metanorma
           refs = v.each_with_object({}) do |eref, m|
             update_sectionsplit_eref_to_doc(eref, internal_refs, m, opts)
           end
-          add_hidden_bibliography(docxml, refs)
+          add_hidden_bibliography(docxml, refs, docid)
         end
       end
 
@@ -65,7 +67,7 @@ module Metanorma
 
       BIBITEM_NOT_REPO_XPATH = <<~XPATH.strip
         //bibitem[not(ancestor::bibitem)][not(ancestor::bibdata)][not(./docidentifier[@type = 'repository'])]
-        XPATH
+      XPATH
 
       def supply_repo_ids(doc)
         doc.xpath(ns(BIBITEM_NOT_REPO_XPATH)).each do |b|
@@ -106,7 +108,8 @@ module Metanorma
         erefs.each do |k, v|
           v.each do |e|
             if loc = e.at(".//#{ANCHOR_XPATH}") then anchors[k] << loc
-            else no_anchor[k] << e end
+            else no_anchor[k] << e
+            end
           end
         end
         [erefs, no_anchor, anchors, Util::gather_bibitemids(docxml, presxml)]
@@ -229,7 +232,7 @@ module Metanorma
         type = "clause" if type == "annex"
         ref = ins.at(ns("./locality/referenceFrom"))&.text
         a = @files.get(docid, :anchors).dig(type, ref) or return
-        ins << "<locality type='anchor'><referenceFrom>#{a.sub(/^_/, '')}" \
+        ins << "<locality type='anchor'><referenceFrom>#{a}" \
           "</referenceFrom></locality>"
       end
     end

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

@@ -3,6 +3,7 @@
 require "isodoc"
 require "metanorma-utils"
 require_relative "fileparse"
+require_relative "filelocation"
 
 module Metanorma
   class Collection
@@ -10,18 +11,28 @@ module Metanorma
       # compile and output individual file in collection
       # warn "metanorma compile -x html #{f.path}"
       def file_compile(file, filename, identifier)
-        @files.get(identifier, :sectionsplit) and return
-        opts = {
-          format: :asciidoc,
-          extension_keys: @files.get(identifier, :format),
-          output_dir: @outdir,
-          type: @flavor,
-        }.merge(compile_options_update(identifier))
+        sectionsplit_val = @files.get(identifier, :sectionsplit)
+        sectionsplit_val and return
+        opts = compile_options_base(identifier)
+          .merge(compile_options_update(identifier))
+
         @compile.compile file, opts
         @files.set(identifier, :outputs, {})
         file_compile_formats(filename, identifier, opts)
       end
 
+      def compile_options_base(identifier)
+        e = @files.get(identifier, :extract_opts)
+        {
+          format: :asciidoc,
+          extension_keys: @files.get(identifier, :format),
+          fonts: e&.dig(:fonts),
+          output_dir: @outdir,
+          pdffile: @files.get(identifier, :pdffile),
+          type: Util::taste2flavor(@flavor),
+        }
+      end
+
       def compile_options_update(identifier)
         ret = @compile_options.dup
         @directives.detect { |d| d.key == "presentation-xml" } ||
@@ -43,33 +54,6 @@ module Metanorma
       #         ret
       #       end
 
-      def file_compile_formats(filename, identifier, opts)
-        f = @files.get(identifier, :outputs)
-        format = opts[:extension_keys]
-        concatenate_presentation?({ format: format }) and format << :presentation
-        format.each do |e|
-          file_compile_format(filename, identifier, e, f)
-        end
-        @files.set(identifier, :outputs, f)
-      end
-
-      def file_compile_format(filename, identifier, format, output_formats)
-        ext = @compile.processor.output_formats[format]
-        fn = File.basename(filename).sub(/(?<=\.)[^.]+$/, ext.to_s)
-        (/html$/.match?(ext) && @files.get(identifier, :sectionsplit)) or
-          output_formats[format] = File.join(@outdir, fn)
-      end
-
-      def copy_file_to_dest(identifier)
-        out = Pathname.new(@files.get(identifier, :out_path)).cleanpath
-        out.absolute? and
-          out = out.relative_path_from(File.expand_path(FileUtils.pwd))
-        dest = File.join(@outdir, @disambig.source2dest_filename(out.to_s))
-        FileUtils.mkdir_p(File.dirname(dest))
-        source = @files.get(identifier, :ref)
-        source != dest and FileUtils.cp_r source, dest, remove_destination: true
-      end
-
       # process each file in the collection
       # files are held in memory, and altered as postprocessing
       def files # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
@@ -85,7 +69,11 @@ module Metanorma
             file, fname = @files.targetfile_id(ident, read: true)
             warn "\n\n\n\n\nProcess #{fname}: #{DateTime.now.strftime('%H:%M:%S')}"
             collection_xml = update_xrefs(file, ident, internal_refs)
-            collection_filename = File.basename(fname, File.extname(fname))
+            # Strip .xml or .html extension, but NOT section numbers like .0
+            fname_base = File.basename(fname)
+            collection_filename = fname_base
+            /\.(xml|html)$/.match?(fname_base) and
+              collection_filename = fname_base.sub(/\.(xml|html)$/, "")
             collection_xml_path = File.join(Dir.tmpdir,
                                             "#{collection_filename}.xml")
             File.write collection_xml_path, collection_xml, encoding: "UTF-8"
@@ -168,23 +156,49 @@ module Metanorma
       def locate_internal_refs1_prep(file)
         xml = Nokogiri::XML(file, &:huge)
         r = xml.root["document_suffix"]
-        xml.xpath("//*[@id]").each_with_object({}) do |i, x|
-          /^semantic_/.match?(i.name) and next
+        ret = xml.xpath("//*[@id]").each_with_object({}) do |i, x|
           x[i["id"]] = i
           r and x[i["id"].sub(/_#{r}$/, "")] = i
         end
+        xml.xpath("//*[@anchor]").each do |i|
+          ret[i["anchor"]] = i
+          r and ret[i["anchor"].sub(/_#{r}$/, "")] = i
+        end
+        ret
       end
 
       def update_bibitem(bib, identifier)
-        docid = get_bibitem_docid(bib, identifier) or return
-        newbib = dup_bibitem(docid, bib)
-        url = @files.url(docid, relative: true,
-                                doc: !@files.get(docid, :attachment))
-        dest = newbib.at("./docidentifier") || newbib.at(ns("./docidentifier"))
+        newbib, url = update_bibitem_prep(bib, identifier)
+        newbib or return
+        dest = begin
+          newbib.at("./docidentifier") || newbib.at(ns("./docidentifier"))
+        rescue StandardError
+          nil
+        end
         dest or dest = newbib.elements[-1]
         dest.previous = "<uri type='citation'>#{url}</uri>"
         bib.replace(newbib)
       end
+
+      def update_bibitem_prep(bib, identifier)
+        docid = get_bibitem_docid(bib, identifier) or return [nil, nil]
+        newbib = dup_bibitem(docid, bib)
+        url = @files.url(docid, relative: true,
+                                doc: !@files.get(docid, :attachment))
+        # Use :outputs[:html] if available (after compilation),
+        # otherwise convert :out_path to HTML (before compilation)
+        current_html = @files.get(identifier, :outputs)&.dig(:html)
+        if !current_html && (out_path = @files.get(identifier, :out_path))
+          # Convert .xml to .html, following same logic as ref_file_xml2html
+          current_html = if out_path.end_with?(".xml")
+                           out_path.sub(/\.xml$/, ".html")
+                         else
+                           "#{out_path}.html"
+                         end
+        end
+        url = make_relative_path(current_html, url) if current_html
+        [newbib, url]
+      end
     end
   end
 end

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

@@ -39,9 +39,23 @@ module Metanorma
         @c.decode(@isodoc.docid_prefix(nil, ident))
       end
 
+      # Check if file has a recognized MIME type (other than XML)
+      # If so, don't append .html (e.g., .svg, .png, .jpg, etc.)
       def index_link(docref, ident)
         if docref.file
-          @files.get(ident, :out_path).sub(/\.xml$/, ".html")
+          out_path = @files.get(ident, :out_path)
+          # Ensure the path ends with .html for documents, but not for recognized file types
+          if Util::mime_file_recognised?(out_path) && !out_path.end_with?(".xml")
+            # File has a recognized extension (like .svg, .png), keep it as is
+            out_path
+          elsif out_path.end_with?(".xml")
+            out_path.sub(/\.xml$/, ".html")
+          elsif out_path.end_with?(".html")
+            out_path
+          else
+            "#{out_path}.html"
+          end
+
         else "#{docref.id}.html"
         end
       end

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

@@ -1,11 +1,13 @@
 module Metanorma
   class Collection
     class Renderer
-      def docconv
+      def docconv(added_options = {})
         @tempfile_cache ||= []
-        flavor = @flavor.to_sym
+        flavor = Util::taste2flavor(@flavor).to_sym
+        opts = Util::taste2isodoc_attrs(@flavor, :doc)
         x = Asciidoctor.load nil, backend: flavor
-        x.converter.doc_converter(DocOptionsNode.new(@directives, @dirname))
+        x.converter.doc_converter(DocOptionsNode.new(@directives, @dirname,
+                                                     added_options.merge(opts)))
       end
 
       def concat_extract_files(filename)
@@ -112,7 +114,7 @@ module Metanorma
       end
 
       class DocOptionsNode
-        def initialize(directives, dir)
+        def initialize(directives, dir, options)
           @dir = dir
           @wordcoverpage =
             Util::hash_key_detect(directives, "document-word-coverpage",
@@ -120,12 +122,14 @@ module Metanorma
           @wordintropage =
             Util::hash_key_detect(directives, "document-word-intropage",
                                   @wordintropage)
+          @options = options
         end
 
         def attr(key)
           case key
           when "wordcoverpage" then Util::rel_path_resolve(@dir, @wordcoverpage)
           when "wordintropage" then Util::rel_path_resolve(@dir, @wordintropage)
+          else @options[key.to_sym]
           end
         end
       end

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

@@ -1,5 +1,6 @@
 require "isodoc"
 require "htmlentities"
+require "mime/types"
 require_relative "fileprocess"
 require_relative "../../util/fontist_helper"
 require_relative "../../util/util"
@@ -14,7 +15,7 @@ require_relative "../log"
 module Metanorma
   class Collection
     class Renderer
-      FORMATS = %i[html xml doc pdf].freeze
+      FORMATS = %i[html xml doc pdf pdf-portfolio].freeze
 
       attr_accessor :isodoc, :isodoc_presxml, :nested
       attr_reader :xml, :compile, :compile_options, :documents, :outdir,
@@ -45,11 +46,12 @@ module Metanorma
         @compile.load_flavor(@flavor)
 
         # output processor for flavour
-        @isodoc = Util::isodoc_create(@flavor, @lang, @script, @xml)
-        @isodoc_presxml = Util::isodoc_create(@flavor, @lang, @script, @xml,
+        @isodoc = Util::isodoc_create(Util::taste2flavor(@flavor), @lang,
+                                      @script, @xml)
+        @isodoc_presxml = Util::isodoc_create(Util::taste2flavor(@flavor),
+                                              @lang, @script, @xml,
                                               presxml: true)
         @outdir = dir_name_cleanse(options[:output_folder])
-        @coverpage = options[:coverpage] || collection.coverpage
         @format = ::Metanorma::Util.sort_extensions_execution(options[:format])
         @compile_options = options[:compile] || {}
         @compile_options[:install_fonts] = true if options[:install_fonts]
@@ -71,6 +73,11 @@ module Metanorma
         # if true, then this is not the last time Renderer will be run
         # (e.g. this is sectionsplit)
 
+        @coverpage = options[:coverpage] || collection.coverpage
+        @coverpage_pdf_portflio = options[:coverpage_pdf_portfolio] ||
+          collection.coverpage_pdf_portfolio || Util::taste2coverpage_pdf_portfolio(@flavor)
+        collection.directives = directives_normalise(collection.directives)
+        @directives = collection.directives
         # list of files in the collection
         @files = Metanorma::Collection::FileLookup.new(folder, self)
         @files.add_section_split
@@ -78,6 +85,50 @@ module Metanorma
         create_non_existing_directory(@outdir)
       end
 
+      def directives_normalise(directives)
+        @coverpage_pdf_portflio and
+          directives = directives_normalise_coverpage_pdf_portfolio(directives)
+        directives_normalise_keystore_pdf_portfolio(directives)
+      end
+
+      # KILL
+      def directives_normalise_coverpage_pdf_portfolio(directives)
+        directives.reject! { |d| d.key == "coverpage-pdf-portfolio" }
+        absolute_coverpage_pdf_portflio = @coverpage_pdf_portflio &&
+          Pathname.new(@coverpage_pdf_portflio).absolute?
+        @coverpage_pdf_portflio =
+          Util::rel_path_resolve(@dirname, @coverpage_pdf_portflio)
+        absolute_coverpage_pdf_portflio or
+          @coverpage_pdf_portflio = Pathname.new(@coverpage_pdf_portflio)
+            .relative_path_from(Pathname.new(@outdir)).to_s
+        directives << ::Metanorma::Collection::Config::Directive
+          .new(key: "coverpage-pdf-portfolio", value: @coverpage_pdf_portflio)
+        directives
+      end
+
+      def directives_normalise_coverpage_pdf_portfolio(directives)
+        directives_resolve_filepath(directives, "coverpage-pdf-portfolio",
+                                    @coverpage_pdf_portflio)
+      end
+
+      def directives_normalise_keystore_pdf_portfolio(directives)
+        f = directives.find { |d| d.key == "keystore-pdf-portfolio" }
+        f.nil? || f.value.nil? and return directives
+        directives_resolve_filepath(directives, "keystore-pdf-portfolio",
+                                    f.value)
+      end
+
+      def directives_resolve_filepath(directives, name, val)
+        abs = Pathname.new(val).absolute?
+        directives.reject! { |d| d.key == name }
+        val = Util::rel_path_resolve(@dirname, val)
+        abs or
+          val = Pathname.new(val).relative_path_from(Pathname.new(@outdir)).to_s
+        directives << ::Metanorma::Collection::Config::Directive
+          .new(key: name, value: val)
+        directives
+      end
+
       def flush_files
         warn "\n\n\n\n\nDone: #{DateTime.now.strftime('%H:%M:%S')}"
         warn "\nFiles to delete:\n"
@@ -148,14 +199,59 @@ module Metanorma
       end
 
       def concatenate_outputs(options)
-        pres = File.join(@outdir, "collection.presentation.xml")
-        options[:format].include?(:pdf) and pdfconv.convert(pres)
+        pres, compile_opts = concatenate_outputs_prep(options)
+        warn pp compile_opts
+        options[:format].include?(:pdf) and pdfconv(compile_opts).convert(pres)
+        options[:format].include?(:"pdf-portfolio") and
+          pdfconv(pdf_portfolio_mn2pdf_options)
+            .convert(pres, nil, nil,
+                     File.join(@outdir, "collection.portfolio.pdf"))
         options[:format].include?(:doc) and docconv_convert(pres)
+        bilingual_output(options, pres)
+      end
+
+      def concatenate_outputs_prep(_options)
+        pres = File.join(@outdir, "collection.presentation.xml")
+        fonts = extract_added_fonts(pres)
+        if fonts
+          # Install fonts before trying to locate them
+          font_options = @compile_options.merge({ fonts: fonts })
+          ::Metanorma::Util::FontistHelper.install_fonts(@compile.processor,
+                                                         font_options)
+
+          mn2pdf = {
+            font_manifest: ::Metanorma::Util::FontistHelper
+              .location_manifest(@compile.processor, { fonts: fonts }),
+          }
+        end
+        [pres, { fonts: fonts, mn2pdf: mn2pdf }.compact]
+      end
+
+      def extract_added_fonts(pres)
+        File.exist?(pres) or return
+        xml = Nokogiri::XML(File.read(pres, encoding: "UTF-8"), &:huge)
+        x = xml.xpath("//*[local-name() = 'presentation-metadata']/" \
+          "*[local-name() = 'fonts']")
+        x.empty? and return
+        x.map(&:text).join(";")
+      end
+
+      def pdf_portfolio_mn2pdf_options
+        f1 = @directives.find { |d| d.key == "keystore-pdf-portfolio" }&.value
+        f2 = @directives.find do |d|
+          d.key == "keystore-password-pdf-portfolio"
+        end&.value
+        {  "pdf-portfolio": "true", pdfkeystore: f1,
+           pdfkeystorepassword: f2 }.compact
+      end
+
+      def bilingual_output(options, pres)
         @directives.detect { |d| d.key == "bilingual" } &&
           options[:format].include?(:html) and
           Metanorma::Collection::Multilingual.new(
-            { flavor: flavor.to_sym,
-              converter_options: PdfOptionsNode.new(flavor, @compile_options),
+            { flavor: Util::taste2flavor(flavor).to_sym,
+              converter_options: PdfOptionsNode.new(Util::taste2flavor(flavor),
+                                                    @compile_options),
               outdir: @outdir },
           ).to_html(pres)
       end
@@ -183,10 +279,8 @@ module Metanorma
       # collection manifest
       def coverpage
         @coverpage or return
-
         @coverpage_path = Util::rel_path_resolve(@dirname, @coverpage)
         warn "\n\n\n\n\nCoverpage: #{DateTime.now.strftime('%H:%M:%S')}"
-
         File.open(File.join(@outdir, "index.html"), "w:UTF-8") do |f|
           f.write @isodoc.populate_template(File.read(@coverpage_path))
         end