epub_tools 0.5.0 → 0.9.0

data/lib/epub_tools/epub_initializer.rb

@@ -1,12 +1,10 @@
-#!/usr/bin/env ruby
 # frozen_string_literal: true
 
 require 'fileutils'
+require 'securerandom'
+require 'time'
 require_relative 'loggable'
-require_relative 'xhtml_generator'
-require_relative 'epub_metadata_builder'
-require_relative 'epub_file_writer'
-require_relative 'epub_configuration'
+require_relative 'set_cover'
 
 module EpubTools
   # Sets up a basic empty EPUB directory structure with the basic files created:
@@ -15,126 +13,122 @@ module EpubTools
   # - +title.xhtml+ as a title page
   # - +package.opf+
   # - +nav.xhtml+ as a table of contents
-  # - +style.css+ a basic style inherited from the repo
+  # - +style.css+ the basic stylesheet that ships with the gem
   # - cover image (optionally)
   class EpubInitializer
     include Loggable
 
+    STYLE = File.expand_path('../../style.css', __dir__)
+
+    CONTAINER = <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <container version="1.0" xmlns="urn:oasis:names:tc:opendocument:xmlns:container">
+        <rootfiles>
+          <rootfile full-path="OEBPS/package.opf" media-type="application/oebps-package+xml"/>
+        </rootfiles>
+      </container>
+    XML
+
+    NAV = <<~XHTML
+      <?xml version="1.0" encoding="utf-8"?>
+      <html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" lang="en">
+        <head>
+          <title>Table of Contents</title>
+        </head>
+        <body>
+          <nav epub:type="toc" id="toc">
+            <h1>Table of Contents</h1>
+            <ol>
+              <li><a href="title.xhtml">Title Page</a></li>
+            </ol>
+          </nav>
+        </body>
+      </html>
+    XHTML
+
     # Initializes the class
     # @param options [Hash] Configuration options
     # @option options [String] :title Book title (required)
     # @option options [String] :author Book author (required)
     # @option options [String] :destination Target directory for the EPUB files (required)
-    # @option options [String] :cover_image Optional path to the cover image
+    # @option options [String] :cover_image Optional path to the cover image, added with {SetCover}[rdoc-ref:EpubTools::SetCover]
     # @option options [Boolean] :verbose Whether to print progress to STDOUT (default: false)
     def initialize(options = {})
-      @config = EpubConfiguration.new(options)
-      @verbose = @config.verbose
-      @xhtml_generator = create_xhtml_generator
-      @metadata_builder = create_metadata_builder
-      @file_writer = create_file_writer
-    end
-
-    private
-
-    def create_xhtml_generator
-      XhtmlGenerator.new(title: @config.title, author: @config.author)
-    end
-
-    def create_metadata_builder
-      EpubMetadataBuilder.new(@config)
+      # Escaped once here, since they are only used inside the XML templates
+      @title = options.fetch(:title).encode(xml: :text)
+      @author = options.fetch(:author).encode(xml: :text)
+      @destination = File.expand_path(options.fetch(:destination))
+      @cover_image = options[:cover_image]
+      @verbose = options[:verbose] || false
     end
 
-    def create_file_writer
-      EpubFileWriter.new(@config.destination)
-    end
-
-    public
-
     # Creates the empty ebook and returns the directory
     def run
-      @file_writer.create_structure
-      @file_writer.write_mimetype
-      write_title_page
-      @file_writer.write_container
-      write_cover if @config.cover_image_path
-      write_package_opf
-      write_nav
-      @file_writer.write_style
-      log "Created empty ebook structure at: #{@config.destination}"
-      @config.destination
+      FileUtils.mkdir_p([File.join(@destination, 'META-INF'), oebps_dir])
+      files.each { |path, content| File.write(File.join(@destination, path), content) }
+      write_cover if @cover_image
+      log "Created empty ebook structure at: #{@destination}"
+      @destination
     end
 
     private
 
-    def write_title_page
-      content = @xhtml_generator.build_title_page
-      @file_writer.write_xhtml('title.xhtml', content)
-    end
-
-    # Copies the cover image into the EPUB structure and creates a cover.xhtml page
-    def write_cover
-      return unless cover_image_exists?
+    def oebps_dir = File.join(@destination, 'OEBPS')
 
-      ext = File.extname(@config.cover_image_path).downcase
-      media_type = determine_media_type(ext)
-      return unless media_type
-
-      fname = "cover#{ext}"
-      @config.update_cover_info(fname, media_type)
-      @xhtml_generator.cover_image_fname = fname
-      update_metadata_builder_with_cover_info
-
-      copy_cover_image(ext)
-      write_cover_page
-    end
-
-    def cover_image_exists?
-      return true if File.exist?(@config.cover_image_path)
-
-      warn "Warning: cover image '#{@config.cover_image_path}' not found; skipping cover support."
-      false
-    end
-
-    def determine_media_type(ext)
-      case ext
-      when '.jpg', '.jpeg' then 'image/jpeg'
-      when '.png' then 'image/png'
-      when '.gif' then 'image/gif'
-      when '.svg' then 'image/svg+xml'
-      else
-        warn "Warning: unsupported cover image type '#{ext}'; skipping cover support."
-        nil
-      end
-    end
-
-    def update_metadata_builder_with_cover_info
-      @metadata_builder = EpubMetadataBuilder.new(@config)
+    def files
+      { 'mimetype' => 'application/epub+zip', 'META-INF/container.xml' => CONTAINER,
+        'OEBPS/title.xhtml' => title_page, 'OEBPS/package.opf' => package_opf, 'OEBPS/nav.xhtml' => NAV,
+        'OEBPS/style.css' => File.read(STYLE) }
     end
 
-    def copy_cover_image(_ext)
-      dest = File.join(@config.destination, 'OEBPS', @config.cover_image_fname)
-      FileUtils.cp(@config.cover_image_path, dest)
-    end
-
-    # Generates a cover.xhtml file displaying the cover image
-    def write_cover_page
-      content = @xhtml_generator.build_cover_page
-      @file_writer.write_xhtml('cover.xhtml', content)
+    def write_cover
+      SetCover.new(cover_image: @cover_image).apply_to(oebps_dir)
+    rescue ArgumentError => e
+      warn "Warning: #{e.message}; skipping cover support."
     end
 
-    # Generates the package.opf with optional cover image entries
-    def write_package_opf
-      manifest_items, spine_items = @metadata_builder.build_manifest_and_spine
-      metadata = @metadata_builder.build_metadata
-      content = @metadata_builder.build_opf_xml(metadata, manifest_items, spine_items)
-      @file_writer.write_package_opf(content)
+    def title_page
+      <<~XHTML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <html xmlns="http://www.w3.org/1999/xhtml" lang="en">
+          <head>
+            <meta charset="UTF-8" />
+            <title>#{@title}</title>
+            <link rel="stylesheet" type="text/css" href="style.css"/>
+          </head>
+          <body>
+            <h1 class="title">#{@title}</h1>
+            <p class="author">by #{@author}</p>
+          </body>
+        </html>
+      XHTML
     end
 
-    # Generates the initial navigation document (Table of Contents)
-    def write_nav
-      content = @xhtml_generator.build_nav_page
-      @file_writer.write_xhtml('nav.xhtml', content)
+    def package_opf
+      <<~XML
+        <?xml version="1.0" encoding="utf-8"?>
+        <package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="pub-id" xml:lang="en">
+          <metadata xmlns:dc="http://purl.org/dc/elements/1.1/">
+            <dc:identifier id="pub-id">urn:uuid:#{SecureRandom.uuid}</dc:identifier>
+            <dc:title>#{@title}</dc:title>
+            <dc:creator>#{@author}</dc:creator>
+            <dc:language>en</dc:language>
+            <meta property="dcterms:modified">#{Time.now.utc.iso8601}</meta>
+            <meta property="schema:accessMode">textual</meta>
+            <meta property="schema:accessibilityFeature">unknown</meta>
+            <meta property="schema:accessibilityHazard">none</meta>
+            <meta property="schema:accessModeSufficient">textual</meta>
+          </metadata>
+          <manifest>
+            <item id="style" href="style.css" media-type="text/css"/>
+            <item id="nav" href="nav.xhtml" media-type="application/xhtml+xml" properties="nav"/>
+            <item id="title" href="title.xhtml" media-type="application/xhtml+xml"/>
+          </manifest>
+          <spine>
+            <itemref idref="title"/>
+          </spine>
+        </package>
+      XML
     end
   end
 end

data/lib/epub_tools/pack_ebook.rb

@@ -17,13 +17,7 @@ module EpubTools
     # @option options [Boolean] :verbose Whether to print progress to STDOUT (default: false)
     def initialize(options = {})
       @input_dir = File.expand_path(options.fetch(:input_dir))
-      default_name = "#{File.basename(@input_dir)}.epub"
-      output_file = options[:output_file]
-      @output_file = if output_file.nil? || output_file.empty?
-                       default_name
-                     else
-                       output_file
-                     end
+      @output_file = options[:output_file].to_s.empty? ? "#{File.basename(@input_dir)}.epub" : options[:output_file]
       @verbose = options[:verbose] || false
     end
 
@@ -48,8 +42,7 @@ module EpubTools
 
     def create_zip_file(target)
       Zip::File.open(target, create: true) do |zip|
-        # Add mimetype first and uncompressed
-        add_mimetype(zip)
+        zip.add_stored('mimetype', 'mimetype') # EPUB readers need it first and uncompressed
         add_content_files(zip)
       end
     end
@@ -72,10 +65,5 @@ module EpubTools
 
       raise ArgumentError, "Error: 'mimetype' file missing in #{@input_dir}"
     end
-
-    def add_mimetype(zip)
-      # Add mimetype first and uncompressed (Stored)
-      zip.add_stored('mimetype', 'mimetype')
-    end
   end
 end

data/lib/epub_tools/pdf_converter.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'open3'
+require 'fileutils'
+require_relative 'loggable'
+require_relative 'pdf_layout'
+
+module EpubTools
+  # Converts chapter PDFs into chapter XHTML files that {AddChapters}[rdoc-ref:EpubTools::AddChapters] can add
+  # to an EPUB. Text is read with poppler's +pdftohtml+, which keeps italics and line positions; see
+  # {PDFLayout}[rdoc-ref:EpubTools::PDFLayout] for how paragraphs are rebuilt.
+  #
+  # PDFs must be named <tt>"<number><optional letters> <Title>.pdf"</tt>: <tt>13a I Hear You.pdf</tt> becomes
+  # +chapter_13a.xhtml+, headed "Chapter 13a: I Hear You". Chapter 0 is front matter, headed with just its title.
+  # <tt>Epilogue One Month.pdf</tt> becomes +chapter_epilogue.xhtml+, headed "Epilogue: One Month".
+  class PDFConverter
+    include Loggable
+
+    FILENAME = /\A(?:(?<number>\d+)(?<suffix>[a-z]*)|(?<epilogue>Epilogue)) +(?<title>.+)\z/
+
+    # Initializes the class
+    # @param options [Hash] Configuration options
+    # @option options [String] :source_dir Directory containing the chapter PDFs (required)
+    # @option options [String] :book_title Book title for the XHTML <tt><title></tt> tags (required)
+    # @option options [String] :output_dir Where to write the chapter files (default: './chapters')
+    # @option options [Boolean] :verbose Whether to log progress to STDOUT (default: false)
+    def initialize(options = {})
+      @source_dir = File.expand_path(options.fetch(:source_dir))
+      @book_title = options.fetch(:book_title)
+      @output_dir = File.expand_path(options[:output_dir] || './chapters')
+      @verbose = options[:verbose] || false
+    end
+
+    # Runs the converter
+    # @return [Array<String>] Paths of the generated chapter files (empty when there are no PDFs)
+    def run
+      pdfs = Dir.glob(File.join(@source_dir, '*.pdf'))
+      validate_names!(pdfs)
+      FileUtils.mkdir_p(@output_dir) unless pdfs.empty?
+      pdfs.map { |pdf| convert(pdf) }
+    end
+
+    private
+
+    def parse_name(pdf) = File.basename(pdf, '.pdf').unicode_normalize(:nfc).match(FILENAME)
+
+    def validate_names!(pdfs)
+      bad = pdfs.reject { |pdf| parse_name(pdf) }.map { |pdf| File.basename(pdf) }
+      return if bad.empty?
+
+      raise ArgumentError, "PDF names must look like '12a Chapter Title.pdf': #{bad.join(', ')}"
+    end
+
+    def convert(pdf)
+      number, title = chapter_name(pdf)
+      label = case number
+              when '0' then title
+              when 'epilogue' then "Epilogue: #{title}"
+              else "Chapter #{number}: #{title}"
+              end
+      path = File.join(@output_dir, "chapter_#{number}.xhtml")
+      File.write(path, well_formed(build_xhtml(label.encode(xml: :text), chapter_body(pdf))))
+      log "Converted: #{File.basename(pdf)} -> #{File.basename(path)}"
+      path
+    end
+
+    # @return [Array(String, String)] The chapter number without leading zeros (e.g. "13a", or "epilogue") and its
+    #   title
+    def chapter_name(pdf)
+      name = parse_name(pdf)
+      number = name[:epilogue] ? 'epilogue' : "#{name[:number].to_i}#{name[:suffix]}"
+      [number, name[:title].tr("'", '’')]
+    end
+
+    def chapter_body(pdf)
+      layout = PDFLayout.new(pdftohtml(pdf))
+      raise "No text found in '#{pdf}' (is it a scanned image?)" if layout.empty?
+
+      layout.to_html
+    end
+
+    def pdftohtml(pdf)
+      xml, status = Open3.capture2('pdftohtml', '-xml', '-i', '-q', '-stdout', pdf)
+      raise "pdftohtml failed to read '#{pdf}'" unless status.success?
+
+      Nokogiri::XML(xml)
+    rescue Errno::ENOENT
+      raise 'pdftohtml not found; install poppler (e.g. `brew install poppler`) to convert PDFs'
+    end
+
+    def well_formed(xhtml)
+      Nokogiri::XML(xhtml, &:strict)
+      xhtml
+    end
+
+    def build_xhtml(label, body)
+      <<~HTML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <html xmlns="http://www.w3.org/1999/xhtml" lang="en">
+          <head>
+            <title>#{@book_title.encode(xml: :text)} - #{label}</title>
+            <link rel="stylesheet" type="text/css" href="style.css"/>
+          </head>
+          <body>
+            <h1>#{label}</h1>
+            #{body}
+          </body>
+        </html>
+      HTML
+    end
+  end
+end

data/lib/epub_tools/pdf_layout.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module EpubTools
+  # Rebuilds a chapter's paragraphs from +pdftohtml -xml+ output as XHTML body markup. Used by
+  # {PDFConverter}[rdoc-ref:EpubTools::PDFConverter].
+  #
+  # - The PDF's own title (lines larger than body text at the top of page 1) is dropped.
+  # - Paragraphs are rebuilt from first-line indents and vertical gaps, including across page breaks.
+  # - Lines made only of symbols (<tt>***</tt>, <tt>____</tt>) become scene breaks (<tt><hr/></tt>).
+  # - Lines starting with a bullet become list items.
+  # - Italics and bold are kept; ligatures (<tt>fi</tt>, <tt>fl</tt>) become plain letters.
+  class PDFLayout
+    SCENE_BREAK = /\A[*_#~=\s]+\z/
+    BULLET = '•'
+    RAW_XML = Nokogiri::XML::Node::SaveOptions::AS_XML
+    # One line of text: the pdftohtml <text> chunks sharing a +top+ (it splits lines wherever the font changes)
+    Line = Struct.new(:page, :chunks, :font_size) do
+      def top = chunks.first['top'].to_i
+      def left = chunks.first['left'].to_i
+      def right = chunks.last['left'].to_i + chunks.last['width'].to_i
+      def text = chunks.map(&:text).join
+      def html = chunks.map { |chunk| chunk.children.to_xml(save_with: RAW_XML, encoding: 'UTF-8') }.join
+    end
+
+    # @param doc [Nokogiri::XML::Document] Output of <tt>pdftohtml -xml</tt>
+    def initialize(doc)
+      @lines = without_title(parse_lines(doc))
+      @margin = @lines.map(&:left).min
+      @text_edge = @lines.map(&:right).sort[@lines.size * 9 / 10]
+    end
+
+    # @return [Boolean] Whether the PDF has no body text
+    def empty? = @lines.empty?
+
+    # @return [String] XHTML for the chapter body
+    def to_html
+      paragraphs.chunk_while { |a, b| bullet?(a) && bullet?(b) }.map { |group| render(group) }.join("\n    ")
+    end
+
+    private
+
+    def parse_lines(doc)
+      sizes = doc.css('fontspec').to_h { |font| [font['id'], font['size'].to_i] }
+      doc.css('page').flat_map { |page| page_lines(page, sizes) }
+    end
+
+    def page_lines(page, sizes)
+      page.css('text').group_by { |chunk| chunk['top'].to_i }.sort.filter_map do |_top, chunks|
+        chunks = visible_in_order(chunks)
+        Line.new(page['number'].to_i, chunks, chunks.map { |chunk| sizes[chunk['font']] }.max) unless chunks.empty?
+      end
+    end
+
+    # A line's chunks left to right, minus leading whitespace-only ones
+    def visible_in_order(chunks)
+      chunks.sort_by { |chunk| chunk['left'].to_i }.drop_while { |chunk| chunk.text.strip.empty? }
+    end
+
+    def without_title(lines)
+      body_size = lines.map(&:font_size).tally.max_by(&:last)&.first
+      lines.drop_while { |line| line.page == 1 && line.font_size > body_size * 1.4 }
+    end
+
+    # @return [Array<Array<Line>, :break>] Lines grouped into paragraphs, with scene breaks as +:break+
+    def paragraphs
+      @lines.each_with_object([]) do |line, paras|
+        if line.text.match?(SCENE_BREAK)
+          paras << :break
+        elsif paras.last.is_a?(Array) && continues?(paras.last, line)
+          paras.last << line
+        else
+          paras << [line]
+        end
+      end
+    end
+
+    # Distances are relative to font size: lines are ~1.2-1.45x the size apart, paragraphs ~1.9x or more.
+    def continues?(para, line)
+      return false if line.text.start_with?(BULLET)
+      return line.left > para.first.left if bullet?(para) # wrapped bullet lines hang past the bullet
+      return true if line.text.match?(/\A\p{Ll}/) # a stray paragraph break mid-sentence
+      return false if line.left > @margin + 5 # first-line indent
+
+      flows_on?(para.last, line)
+    end
+
+    # Across a page break, only a full previous line means the paragraph carries on (text is ragged-right).
+    # ponytail: misses paragraph ends whose last line is nearly full width, unless the next one is indented
+    def flows_on?(prev, line)
+      return prev.right > @text_edge - (prev.font_size * 6) if line.page != prev.page
+
+      line.top - prev.top < prev.font_size * 1.7
+    end
+
+    def bullet?(para) = para.is_a?(Array) && para.first.text.start_with?(BULLET)
+
+    def render(group)
+      return '<hr/>' if group.first == :break
+      return "<p>#{inline_html(group.first)}</p>" unless bullet?(group.first)
+
+      "<ul>#{group.map { |item| "<li>#{inline_html(item).delete_prefix(BULLET).lstrip}</li>" }.join}</ul>"
+    end
+
+    # Joins a paragraph's lines. Wrapped lines usually keep their trailing space; add one when they don't,
+    # unless the line ends in a hyphen or dash ("half-" + "dressed").
+    def inline_html(para)
+      html = para.first.html.dup
+      para.each_cons(2) { |prev, line| html << (prev.text.match?(/[\s\-–—]\z/) ? '' : ' ') << line.html }
+      html.gsub(/[ff-st]/) { |ligature| ligature.unicode_normalize(:nfkc) }
+          .gsub(%r{</b></i>(\s*)<i><b>}, '\1').gsub(%r{</(i|b)>(\s*)<\1>}, '\2') # italics split across lines
+          .gsub(/ {2,}/, ' ').strip
+    end
+  end
+end

data/lib/epub_tools/set_cover.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'fileutils'
+require 'tmpdir'
+require_relative 'loggable'
+require_relative 'unpack_ebook'
+require_relative 'pack_ebook'
+
+module EpubTools
+  # Adds a cover image to an EPUB, replacing any cover it already has: the image, a +cover.xhtml+ page first in
+  # the reading order, and the manifest and metadata entries marking it as the cover.
+  #
+  # {#run} updates a packed +.epub+ in place (backing it up to <tt><epub>.bak</tt> first). The book keeps its
+  # identifier, so reading apps still treat it as the same book. {#apply_to} updates an unpacked EPUB instead;
+  # {EpubInitializer}[rdoc-ref:EpubTools::EpubInitializer] uses it for new books.
+  class SetCover
+    include Loggable
+
+    # Media types of the supported cover image extensions
+    MEDIA_TYPES = {
+      '.jpg' => 'image/jpeg', '.jpeg' => 'image/jpeg', '.png' => 'image/png', '.gif' => 'image/gif',
+      '.svg' => 'image/svg+xml'
+    }.freeze
+
+    # Initializes the class
+    # @param options [Hash] Configuration options
+    # @option options [String] :cover_image Path to the cover image: jpg, png, gif or svg (required)
+    # @option options [String] :epub_file The EPUB to add the cover to (required for {#run})
+    # @option options [Boolean] :verbose Whether to log progress to STDOUT (default: false)
+    # @raise [ArgumentError] if a file is missing or the image type is unsupported
+    def initialize(options = {})
+      @cover_image = File.expand_path(options.fetch(:cover_image))
+      @extension = File.extname(@cover_image).downcase
+      @epub_file = options[:epub_file] && File.expand_path(options[:epub_file])
+      @verbose = options[:verbose] || false
+      validate!
+    end
+
+    # Adds the cover to +epub_file+
+    # @return [String] Path to the updated EPUB
+    def run
+      raise ArgumentError, 'An :epub_file is required to run' unless @epub_file
+
+      FileUtils.cp(@epub_file, "#{@epub_file}.bak")
+      Dir.mktmpdir do |dir|
+        UnpackEbook.new(epub_file: @epub_file, output_dir: dir).run
+        apply_to(File.join(dir, 'OEBPS'))
+        PackEbook.new(input_dir: dir, output_file: @epub_file).run
+      end
+      log "Set the cover of #{@epub_file} to #{File.basename(@cover_image)} (backup: #{@epub_file}.bak)"
+      @epub_file
+    end
+
+    # Adds the cover to an unpacked EPUB
+    # @param oebps_dir [String] Directory containing the EPUB's +package.opf+
+    def apply_to(oebps_dir)
+      opf_path = File.join(oebps_dir, 'package.opf')
+      opf = Nokogiri::XML(File.read(opf_path)) { |config| config.default_xml.noblanks }
+      remove_old_cover(opf, oebps_dir)
+      FileUtils.cp(@cover_image, File.join(oebps_dir, image_name))
+      File.write(File.join(oebps_dir, 'cover.xhtml'), cover_page)
+      add_cover(opf)
+      File.write(opf_path, opf.to_xml(indent: 2))
+    end
+
+    private
+
+    def validate!
+      raise ArgumentError, "EPUB '#{@epub_file}' not found" if @epub_file && !File.file?(@epub_file)
+      raise ArgumentError, "cover image '#{@cover_image}' not found" unless File.file?(@cover_image)
+      return if MEDIA_TYPES.key?(@extension)
+
+      raise ArgumentError, "unsupported cover image type '#{@extension}' (use jpg, png, gif or svg)"
+    end
+
+    def image_name = "cover#{@extension}"
+
+    def cover_page
+      <<~XHTML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <html xmlns="http://www.w3.org/1999/xhtml" lang="en">
+          <head>
+            <meta charset="UTF-8" />
+            <title>Cover</title>
+            <link rel="stylesheet" type="text/css" href="style.css"/>
+          </head>
+          <body>
+            <div class="cover-image">
+              <img src="#{image_name}" alt="Cover"/>
+            </div>
+          </body>
+        </html>
+      XHTML
+    end
+
+    def remove_old_cover(opf, oebps_dir)
+      opf.xpath('//xmlns:item[@id="cover-image" or contains(@properties, "cover-image")]').each do |item|
+        FileUtils.rm_f(File.join(oebps_dir, item['href']))
+        item.remove
+      end
+      opf.xpath('//xmlns:meta[@name="cover"] | //xmlns:item[@id="cover-page"] | //xmlns:itemref[@idref="cover-page"]')
+         .each(&:remove)
+    end
+
+    def add_cover(opf)
+      opf.at_xpath('//xmlns:metadata').add_child(opf.create_element('meta', name: 'cover', content: 'cover-image'))
+      manifest = opf.at_xpath('//xmlns:manifest')
+      manifest.add_child(opf.create_element('item', id: 'cover-image', href: image_name,
+                                                    'media-type': MEDIA_TYPES[@extension], properties: 'cover-image'))
+      manifest.add_child(opf.create_element('item', id: 'cover-page', href: 'cover.xhtml',
+                                                    'media-type': 'application/xhtml+xml'))
+      opf.at_xpath('//xmlns:spine').prepend_child(opf.create_element('itemref', idref: 'cover-page'))
+    end
+  end
+end