metanorma 1.7.7 → 2.0.1

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

@@ -0,0 +1,254 @@
+module Metanorma
+  class Collection
+    class Renderer
+      # Resolves references to other files in the collection. Three routines:
+      # 1. Eref to a document that has been split into multiple documents
+      # (sectionsplit) are resolved to direct eref to the split document
+      # 2. Indirect erefs to a file anchor in an unknwon file in the collection
+      # (bibitem[@type = 'internal'] ) are resolved to direct eref to the
+      # containing document
+      # 3. Direct erefs to other files in collection
+      # (repo(current-metanorma-collection/x) are resolved to hyperlinks
+      # @param file [String] XML content
+      # @param identifier [String] docid
+      # @param internal_refs [Hash{String=>Hash{String=>String}] schema name to
+      #   anchor to filename
+      # @return [String] XML content
+      def update_xrefs(file, docid, internal_refs)
+        xml, sso = update_xrefs_prep(file, docid)
+        @nested || sso or
+          Metanorma::Collection::XrefProcess::xref_process(xml, xml, nil, docid,
+                                                           @isodoc)
+        @nested or update_indirect_refs_to_docs(xml, docid, internal_refs)
+        @files.add_document_suffix(docid, xml)
+        @nested or update_sectionsplit_refs_to_docs(xml, internal_refs)
+        update_direct_refs_to_docs(xml, docid)
+        hide_refs(xml)
+        sso and eref2link(xml)
+        @nested or svgmap_resolve(xml, docid)
+        xml.to_xml
+      end
+
+      def update_xrefs_prep(file, docid)
+        docxml = file.is_a?(String) ? Nokogiri::XML(file, &:huge) : file
+        supply_repo_ids(docxml)
+        sso = @files.get(docid, :sectionsplit_output)
+        [docxml, sso]
+      end
+
+      def update_sectionsplit_refs_to_docs(docxml, internal_refs)
+        Util::gather_citeases(docxml).each do |k, v|
+          (@files.get(k) && @files.get(k, :sectionsplit)) or next
+          opts = { key: @files.get(k, :indirect_key),
+                   source_suffix: docxml.root["document_suffix"],
+                   target_suffix: @files.get(k, :document_suffix) }
+          refs = v.each_with_object({}) do |eref, m|
+            update_sectionsplit_eref_to_doc(eref, internal_refs, m, opts)
+          end
+          add_hidden_bibliography(docxml, refs)
+        end
+      end
+
+      def update_sectionsplit_eref_to_doc(eref, internal_refs, doclist, opts)
+        a = eref.at(ns("./localityStack/locality[@type = 'anchor']/" \
+                       "referenceFrom")) or return
+        doc = internal_refs[opts[:key]]["#{a.text}_#{opts[:target_suffix]}"]
+        bibitemid = Metanorma::Utils::to_ncname("#{doc}_#{opts[:source_suffix]}")
+        eref["bibitemid"] = bibitemid
+        doclist[bibitemid] ||= doc
+        doclist
+      end
+
+      def eref2link(docxml)
+        isodoc = IsoDoc::PresentationXMLConvert.new({})
+        isodoc.bibitem_lookup(docxml)
+        isodoc.eref2link(docxml)
+      end
+
+      BIBITEM_NOT_REPO_XPATH = "//bibitem[not(ancestor::bibitem)]" \
+        "[not(./docidentifier[@type = 'repository'])]".freeze
+
+      def supply_repo_ids(doc)
+        doc.xpath(ns(BIBITEM_NOT_REPO_XPATH)).each do |b|
+          b.xpath(ns("./docidentifier")).each do |docid|
+            id = @isodoc.docid_prefix(docid["type"], docid.children.to_xml)
+            @files.get(id) or next
+            @files.get(id, :indirect_key) and next # will resolve as indirect key
+            docid.next = docid_xml(id)
+          end
+        end
+      end
+
+      def svg_datauri(docxml, docid)
+        rel = @files.get(docid, :rel_path)
+        parent = @files.get(docid, :parentid) and
+          rel = @files.get(parent, :rel_path)
+        # if sectionsplit, use orig file dir
+        dir = File.join(@dirname, File.dirname(rel))
+        datauri_encode(docxml, dir)
+      end
+
+      def svgmap_resolve(docxml, docid)
+        ids = @files.get(docid, :ids)
+        docxml = svg_unnest(svg_datauri(docxml, docid))
+        isodoc = IsoDoc::PresentationXMLConvert.new({})
+        isodoc.bibitem_lookup(docxml)
+        docxml.xpath(ns("//svgmap//eref")).each do |e|
+          svgmap_resolve_eref(e, isodoc, docxml, ids)
+        end
+        Vectory::SvgMapping.new(docxml, "").call
+        docxml.xpath(ns("//svgmap")).each { |s| isodoc.svgmap_extract(s) }
+      end
+
+      def svg_unnest(docxml)
+        docxml.xpath(ns("//svgmap//image[.//*[name() = 'image']]")).each do |i|
+          s = i.elements.detect { |e| e.name == "svg" } and
+            i.replace(s)
+        end
+        docxml
+      end
+
+      def svgmap_resolve_eref(eref, isodoc, _docxml, ids)
+        href = isodoc.eref_target(eref) or return
+        href == "##{eref['bibitemid']}" ||
+          (href =~ /^#/ && !ids[href.sub(/^#/, "")]) and return
+        eref["target"] = href.strip
+        eref.name = "link"
+        eref.elements&.remove
+      end
+
+      # repo(current-metanorma-collection/ISO 17301-1:2016)
+      # replaced by bibdata of "ISO 17301-1:2016" in situ as bibitem.
+      # Any erefs to that bibitem id are replaced with relative URL
+      # Preferably with anchor, and is a job to realise dynamic lookup
+      # of localities.
+      def update_direct_refs_to_docs(docxml, identifier)
+        erefs, erefs1 = update_direct_refs_to_docs_prep(docxml)
+        docxml.xpath(ns("//bibitem")).each do |b|
+          docid = b.at(ns("./docidentifier[@type = 'repository']")) or next
+          strip_unresolved_repo_erefs(identifier, docid, erefs1, b) or next
+          update_bibitem(b, identifier)
+          docid = docid_to_citeas(b) or next
+          erefs[docid] and update_anchors(b, docid, erefs[docid])
+        end
+      end
+
+      def update_direct_refs_to_docs_prep(docxml)
+        @ncnames = {}
+        [Util::gather_citeases(docxml), Util::gather_bibitemids(docxml)]
+      end
+
+      # strip erefs if they are repository erefs, but do not point to a document
+      # within the current collection. This can happen if a collection consists
+      # of many documents, but not all are included in the current collection.
+      # Do not do this if this is a sectionsplit collection or a nested manifest.
+      # Return false if bibitem is not to be further processed
+      def strip_unresolved_repo_erefs(_document_id, bib_docid, erefs, bibitem)
+        %r{^current-metanorma-collection/(?!Missing:)}.match?(bib_docid.text) and
+          return true
+        @nested and return false
+        erefs[bibitem["id"]]&.each { |x| x.parent and strip_eref(x) }
+        false
+      end
+
+      # Resolve erefs to a container of ids in another doc,
+      # to an anchor eref (direct link)
+      def update_indirect_refs_to_docs(docxml, _docidentifier, internal_refs)
+        bibitems, erefs = update_indirect_refs_to_docs_prep(docxml)
+        internal_refs.each do |schema, ids|
+          ids.each do |id, file|
+            k = indirect_ref_key(schema, id, docxml)
+            update_indirect_refs_to_docs1(docxml, k, file, bibitems, erefs)
+          end
+        end
+      end
+
+      def update_indirect_refs_to_docs_prep(docxml)
+        @updated_anchors = {}
+        [Util::gather_bibitems(docxml), Util::gather_bibitemids(docxml)]
+      end
+
+      def indirect_ref_key(schema, id, docxml)
+        /^#{schema}_/.match?(id) and return id
+        ret = "#{schema}_#{id}"
+        suffix = docxml.root["document_suffix"]
+        (k = docxml.root["type"]) && k != schema && suffix and
+          ret = "#{ret}_#{suffix}"
+        ret
+      end
+
+      def update_indirect_refs_to_docs1(_docxml, key, file, bibitems, erefs)
+        erefs[key]&.each do |e|
+          e["citeas"] = file
+          update_indirect_refs_to_docs_anchor(e, file)
+        end
+        update_indirect_refs_to_docs_docid(bibitems[key], file)
+      end
+
+      def update_indirect_refs_to_docs_anchor(eref, file)
+        a = eref.at(ns(".//locality[@type = 'anchor']/referenceFrom")) or return
+        suffix = file
+        @files.get(file) && p = @files.get(file, :parentid) and
+          suffix = "#{p}_#{suffix}"
+        existing = a.text
+        anchor = existing
+        @files.url?(file) or
+          anchor = Metanorma::Utils::to_ncname("#{anchor}_#{suffix}")
+        @updated_anchors[existing] or a.children = anchor
+        @updated_anchors[anchor] = true
+      end
+
+      def update_indirect_refs_to_docs_docid(bib, file)
+        docid = bib&.at(ns("./docidentifier[@type = 'repository']")) or return
+        docid.children = "current-metanorma-collection/#{file}"
+        docid.previous =
+          "<docidentifier type='metanorma-collection'>#{file}</docidentifier>"
+      end
+
+      # update crossrefences to other documents, to include
+      # disambiguating document suffix on id
+      def update_anchors(bib, docid, erefs)
+        erefs.each do |e|
+          if @files.get(docid) then update_anchor_loc(bib, e, docid)
+          else
+            msg = "<strong>** Unresolved reference to document #{docid} " \
+                  "from eref</strong>"
+            e << msg
+            strip_eref(e)
+            @log&.add("Cross-References", e, msg)
+          end
+        end
+      end
+
+      def update_anchor_loc(bib, eref, docid)
+        loc = eref.at(".//xmlns:locality[@type = 'anchor']") or
+          return update_anchor_create_loc(bib, eref, docid)
+        ref = loc.at("./xmlns:referenceFrom") or return
+        anchor = suffix_anchor(ref, docid)
+        a = @files.get(docid, :anchors) or return
+        a.inject([]) { |m, (_, x)| m + x.values }
+          .include?(anchor) or return
+        ref.content = anchor
+      end
+
+      def suffix_anchor(ref, docid)
+        @ncnames[docid] ||= Metanorma::Utils::to_ncname(docid)
+        anchor = ref.text
+        @files.url?(docid) or anchor = "#{@ncnames[docid]}_#{anchor}"
+        anchor
+      end
+
+      # if there is a crossref to another document, with no anchor, retrieve the
+      # anchor given the locality, and insert it into the crossref
+      def update_anchor_create_loc(_bib, eref, docid)
+        ins = eref.at(ns("./localityStack")) or return
+        type = ins.at(ns("./locality/@type"))&.text
+        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(/^_/, '')}" \
+               "</referenceFrom></locality>"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "isodoc"
+require "metanorma-utils"
+require_relative "fileparse"
+
+module Metanorma
+  class Collection
+    class Renderer
+      # 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: @format,
+          output_dir: @outdir,
+        }.merge(compile_options_update(identifier))
+        @compile.compile file, opts
+        @files.set(identifier, :outputs, {})
+        file_compile_formats(filename, identifier)
+      end
+
+      def compile_options_update(identifier)
+        ret = @compile_options.dup
+        @directives.detect { |d| d.key == "presentation-xml" } ||
+          @files.get(identifier, :presentationxml) and
+          ret.merge!(passthrough_presentation_xml: true)
+        @files.get(identifier, :sectionsplit) == true and
+          ret.merge!(sectionsplit: true)
+        @files.get(identifier, :bare) == true and
+          ret.merge!(bare: true)
+        ret
+      end
+
+      def file_compile_formats(filename, identifier)
+        f = @files.get(identifier, :outputs)
+        @format << :presentation if @format.include?(:pdf)
+        @format.each do |e|
+          ext = @compile.processor.output_formats[e]
+          fn = File.basename(filename).sub(/(?<=\.)[^.]+$/, ext.to_s)
+          (/html$/.match?(ext) && @files.get(identifier, :sectionsplit)) or
+            f[e] = File.join(@outdir, fn)
+        end
+        @files.set(identifier, :outputs, f)
+      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 source, dest
+      end
+
+      # 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\nRender Files: #{DateTime.now.strftime('%H:%M:%S')}"
+        internal_refs = locate_internal_refs
+        @files.keys.each_with_index do |ident, i|
+          i.positive? && @directives.detect do |d|
+            d.key == "bare-after-first"
+          end and
+            @compile_options.merge!(bare: true)
+          if @files.get(ident, :attachment) then copy_file_to_dest(ident)
+          else
+            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))
+            collection_xml_path = File.join(Dir.tmpdir,
+                                            "#{collection_filename}.xml")
+            File.write collection_xml_path, collection_xml, encoding: "UTF-8"
+            file_compile(collection_xml_path, fname, ident)
+            FileUtils.rm(collection_xml_path)
+          end
+        end
+      end
+
+      # gather internal bibitem references
+      def gather_internal_refs
+        @files.keys.each_with_object({}) do |i, refs|
+          @files.get(i, :attachment) and next
+          file, = @files.targetfile_id(i, read: true)
+          gather_internal_refs1(file, i, refs)
+        end
+      end
+
+      def gather_internal_refs1(file, ident, refs)
+        f = Nokogiri::XML(file, &:huge)
+        !@files.get(ident, :sectionsplit) and
+          gather_internal_refs_indirect(f, refs)
+        key = @files.get(ident, :indirect_key) and
+          gather_internal_refs_sectionsplit(f, ident, key, refs)
+      end
+
+      def gather_internal_refs_indirect(doc, refs)
+        doc.xpath(ns("//bibitem[@type = 'internal']/" \
+                     "docidentifier[@type = 'repository']")).each do |d|
+                       a = d.text.split(%r{/}, 2)
+                       a.size > 1 or next
+                       refs[a[0]] ||= {}
+                       refs[a[0]][a[1]] = false
+                     end
+      end
+
+      def gather_internal_refs_sectionsplit(_doc, ident, key, refs)
+        refs[key] ||= {}
+        @files.get(ident, :ids).each_key do |k|
+          refs[key][k] = false
+        end
+      end
+
+      def populate_internal_refs(refs)
+        @files.keys.reject do |k|
+          @files.get(k, :attachment) || @files.get(k, :sectionsplit)
+        end.each do |ident|
+          locate_internal_refs1(refs, ident,
+                                @isodoc.docid_prefix("", ident.dup))
+        end
+        refs
+      end
+
+      # resolve file location for the target of each internal reference
+      def locate_internal_refs
+        warn "\n\n\n\n\nInternal Refs: #{DateTime.now.strftime('%H:%M:%S')}"
+        refs = populate_internal_refs(gather_internal_refs)
+        refs.each do |schema, ids|
+          ids.each do |id, key|
+            key and next
+            refs[schema][id] = "Missing:#{schema}:#{id}"
+            @log&.add("Cross-References", nil, refs[schema][id])
+          end
+        end
+        refs
+      end
+
+      def locate_internal_refs1(refs, identifier, ident)
+        file, = @files.targetfile_id(ident, read: true)
+        t = locate_internal_refs1_prep(file)
+        refs.each do |schema, ids|
+          ids.keys.select { |id| t[id] }.each do |id|
+            t[id].at("./ancestor-or-self::*[@type = '#{schema}']") and
+              refs[schema][id] = identifier
+          end
+        end
+      end
+
+      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
+          x[i["id"]] = i
+          r and x[i["id"].sub(/_#{r}$/, "")] = i
+        end
+      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"))
+        dest or dest = newbib.elements[-1]
+        dest.previous = "<uri type='citation'>#{url}</uri>"
+        bib.replace(newbib)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+module Metanorma
+  class Collection
+    class Renderer
+      # @param elm [Nokogiri::XML::Element]
+      # @return [String]
+      def indexfile_title(entry)
+        if entry.bibdata &&
+            x = entry.bibdata.title.detect { |t| t.type == "main" } ||
+                entry.bibdata.title.first
+          x.title.content
+        else
+          entry.title
+        end
+      end
+
+      # uses the identifier to label documents; other attributes (title) can be
+      # looked up in @files[id][:bibdata]
+      #
+      # @param mnf [Collection::Manifest]
+      # @param builder [Nokogiri::XML::Builder]
+      def indexfile_docref(mnf, builder)
+        Array(mnf.entry).detect(&:index) or return ""
+        builder.ul { |b| docrefs(mnf, b) }
+      end
+
+      def docrefs(mnf, builder)
+        ident = docref_ident(mnf)
+        builder.li do |li|
+          li.a href: index_link(mnf, ident) do |a|
+            a << ident.split(/([<>&])/).map do |x|
+              /[<>&]/.match?(x) ? x : @c.encode(x, :hexadecimal)
+            end.join
+          end
+        end
+      end
+
+      def docref_ident(docref)
+        ident = docref.identifier.dup
+        @c.decode(@isodoc.docid_prefix(nil, ident))
+      end
+
+      def index_link(docref, ident)
+        if docref.file
+          @files.get(ident, :out_path).sub(/\.xml$/, ".html")
+        else "#{docref.id}.html"
+        end
+      end
+
+      # single level navigation list, with hierarchical nesting
+      def indexfile(mnf)
+        mnfs = Array(mnf)
+        mnfs.empty? and return ""
+        mnfs.map { |m| "<ul>#{indexfile1(m)}</ul>" }.join("\n")
+      end
+
+      def index?(mnf)
+        mnf.index and return true
+        mnf.entry.detect { |e| index?(e) }
+      end
+
+      def indexfile1(mnf)
+        index?(mnf) or return ""
+        cleanup_indexfile1(build_indexfile1(mnf))
+      end
+
+      def build_indexfile1(mnf)
+        Nokogiri::HTML::Builder.new do |b|
+          if mnf.file then docrefs(mnf, b)
+          else
+            b.li do |l|
+              l << indexfile_title(mnf)
+              l.ul do |u|
+                Array(mnf.entry).each { |e| u << indexfile1(e) }
+              end
+            end
+          end
+        end
+      end
+
+      def cleanup_indexfile1(ret)
+        ret = ret.doc.root
+        ret.xpath("/ul").each do |u|
+          if u.at("./li/ul") && !u.at("./li[text()]")
+            u.replace(u.xpath("./li/ul"))
+          end
+        end
+        ret.to_html
+      end
+
+      # object to construct navigation out of in Liquid
+      def index_object(mnf)
+        mnf = Array(mnf).first
+        ret = { title: indexfile_title(mnf), level: mnf.type,
+                docrefs: index_object_docrefs(mnf),
+                children: index_object_children(mnf) }.compact
+        ret.keys == [:children] and ret = ret[:children]
+        ret
+      end
+
+      def index_object_children(mnf)
+        nonfiles = Array(mnf.entry).reject(&:file)
+        c = nonfiles.each_with_object([]) do |d, b|
+          b << index_object(d)
+        end.flatten
+        c.empty? and c = nil
+        c
+      end
+
+      def index_object_docrefs(mnf)
+        files = Array(mnf.entry).select(&:file)
+        files.empty? and return nil
+        r = Nokogiri::HTML::Builder.new do |b|
+          b.ul do |u|
+            files.each { |f| docrefs(f, u) }
+          end
+        end
+        r.doc.root&.to_html&.gsub("\n", " ")
+      end
+
+      def liquid_docrefs(mnfs)
+        Array(mnfs).select(&:index).each_with_object([]) do |d, m|
+          if d.file
+            ident = @c.decode(@isodoc.docid_prefix(nil, d.identifier.dup))
+            m << { "identifier" => ident, "file" => index_link(d, ident),
+                   "title" => indexfile_title(d), "level" => d.type }
+          else
+            liquid_docrefs(d.entry).each { |m1| m << m1 }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+module Metanorma
+  class Collection
+    class Renderer
+      def docconv
+        @tempfile_cache ||= []
+        doctype = @doctype.to_sym
+        x = Asciidoctor.load nil, backend: doctype
+        x.converter.doc_converter(DocOptionsNode.new(@directives, @dirname))
+      end
+
+      def concat_extract_files(filename)
+        xml = Nokogiri::XML(File.read(filename, encoding: "UTF-8"), &:huge)
+        docs = xml.xpath(ns("//doc-container")).each_with_object([]) do |x, m|
+          n = Nokogiri::XML::Document.new
+          n.add_child(x.elements.first.remove)
+          m << n
+        end
+        [wrapping_doc(docs.first.dup, xml), docs]
+      end
+
+      def wrapping_doc(doc, xml)
+        doc.at(ns("//bibdata")).replace(xml.at(ns("//bibdata")).to_xml)
+        sections = wrapping_doc_body(doc)
+        wrapping_doc_intro_outro(xml, sections)
+        set_displayorder_wrapping_doc(doc)
+      end
+
+      def wrapping_doc_intro_outro(xml, sections)
+        p = xml.at(ns("//prefatory-content")) and
+          sections.previous = "<preface>#{p.children.to_xml}</preface>"
+        p = xml.at(ns("//final-content")) and
+          sections.next = "<annex>#{p.children.to_xml}</annex>"
+      end
+
+      def wrapping_doc_body(doc)
+        doc.xpath(ns("//annex | //preface | //bibliography")).each(&:remove)
+        s = doc.at(ns("//sections"))
+        repl = <<~BODY
+          <sections><clause id='_collection_placeholder'><p>PLACEHOLDER</p></clause></sections>
+        BODY
+        s.replace(repl)
+        doc.at(ns("//sections"))
+      end
+
+      def set_displayorder_wrapping_doc(doc)
+        doc.xpath(ns("//preface/* | //sections/* | //annex"))
+          .each_with_index do |x, i|
+          x["displayorder"] = i + 1
+        end
+        doc
+      end
+
+      SECTION_BREAK = '<p class="MsoNormal"><br clear="all" class="section"/></p>'
+        .freeze
+      DIV1 = '<div class="WordSection1">&#xa0;</div>'.freeze
+      DIV2 = '<div class="WordSection2">&#xa0;</div>'.freeze
+
+      def docconv_convert1(docs)
+        docs.each_with_index.with_object([]) do |(d, i), m|
+          conv = docconv
+          conv.convert_init(d.to_xml(encoding: "UTF-8"), "xxxx", false)
+          html = conv.postprocess_cleanup(conv.convert1(d, "xxx", "."))
+          @tempfile_cache += conv.tempfile_cache # hold on to the temp img files
+          b = Nokogiri::XML(html).at("//body")
+          i == docs.size - 1 or
+            b << '<p class="MsoNormal"><br clear="all" class="section"/></p>'
+          m << b.children
+        end
+      end
+
+      def collection_coverpages(conv, docs)
+        conv.wordintropage and [DIV2, SECTION_BREAK].reverse.each do |s|
+          docs.unshift(Nokogiri::XML(s).root)
+        end
+        conv.wordcoverpage and [DIV1, SECTION_BREAK].reverse.each do |s|
+          docs.unshift(Nokogiri::XML(s).root)
+        end
+        docs
+      end
+
+      def docconv_convert(filename)
+        pref_file, docs = concat_extract_files(filename)
+        body = docconv_convert1(docs)
+        collection_conv = overall_docconv_converter(body)
+        collection_coverpages(collection_conv, body)
+        collection_conv.convert(filename, pref_file.to_xml, false)
+      end
+
+      def overall_docconv_cover(collection_conv)
+        p = Util::hash_key_detect(@directives, "collection-word-coverpage", nil)
+        collection_conv.wordcoverpage =
+          Util::rel_path_resolve(@dirname, p)
+        p = Util::hash_key_detect(@directives, "collection-word-intropage", nil)
+        collection_conv.wordintropage =
+          Util::rel_path_resolve(@dirname, p)
+      end
+
+      def overall_docconv_converter(body)
+        collection_conv = docconv
+        collection_conv.options[:collection_doc] = body.map(&:to_xml).join
+        overall_docconv_cover(collection_conv)
+
+        def collection_conv.postprocess_cleanup(result)
+          ret = to_xhtml(super)
+          b = ret.at("//div[@id = '_collection_placeholder']")
+          b.replace(@options[:collection_doc])
+          from_xhtml(ret)
+        end
+
+        collection_conv
+      end
+
+      class DocOptionsNode
+        def initialize(directives, dir)
+          @dir = dir
+          @wordcoverpage =
+            Util::hash_key_detect(directives, "document-word-coverpage",
+                                  @wordcoverpage)
+          @wordintropage =
+            Util::hash_key_detect(directives, "document-word-intropage",
+                                  @wordintropage)
+        end
+
+        def attr(key)
+          case key
+          when "wordcoverpage" then Util::rel_path_resolve(@dir, @wordcoverpage)
+          when "wordintropage" then Util::rel_path_resolve(@dir, @wordintropage)
+          end
+        end
+      end
+    end
+  end
+end