epub_tools 0.6.0 → 0.9.0

data/lib/epub_tools/book_builder.rb

@@ -4,13 +4,14 @@ require 'fileutils'
 require_relative 'loggable'
 require_relative 'xhtml_extractor'
 require_relative 'split_chapters'
+require_relative 'pdf_converter'
 require_relative 'add_chapters'
 require_relative 'pack_ebook'
-require_relative 'compile_workspace'
 require_relative 'chapter_validator'
 
 module EpubTools
-  # Base class for book-building workflows (compile and append).
+  # Base class for book-building workflows (compile and append). Sources can be EPUBs (split into chapters)
+  # and/or chapter PDFs (see {PDFConverter}[rdoc-ref:EpubTools::PDFConverter] for the naming convention).
   # Uses template method pattern — subclasses override hooks to customize behavior.
   class BookBuilder
     include Loggable
@@ -21,7 +22,6 @@ module EpubTools
       @source_dir = options.fetch(:source_dir)
       @build_dir  = options[:build_dir] || File.join(Dir.pwd, '.epub_tools_build')
       @verbose    = options[:verbose] || false
-      @workspace  = CompileWorkspace.new(@build_dir)
     end
 
     # Run the full build workflow
@@ -31,6 +31,7 @@ module EpubTools
       prepare_epub
       extract_xhtmls
       split_xhtmls
+      convert_pdfs
       validate_chapters
       before_add_chapters
       add_chapters
@@ -46,47 +47,48 @@ module EpubTools
     # Hook: called after validation, before adding chapters
     def before_add_chapters; end
 
-    # Subclasses must implement: the book title used when splitting chapters
-    def book_title
-      raise NotImplementedError, "#{self.class} must implement #book_title"
-    end
-
-    # Subclasses must implement: the output file path for pack_epub
-    def output_path
-      raise NotImplementedError, "#{self.class} must implement #output_path"
-    end
+    # Subclasses also define +book_title+ (used when splitting chapters) and +output_path+ (the EPUB to write)
 
     def setup_workspace
-      @workspace.clean
-      @workspace.prepare_directories
+      FileUtils.rm_rf(build_dir)
+      FileUtils.mkdir_p([xhtml_dir, chapters_dir])
       log 'Preparing build directories...'
     end
 
     def extract_xhtmls
       log "Extracting XHTML files from EPUBs in '#{source_dir}'..."
-      XHTMLExtractor.new(source_dir: source_dir, target_dir: @workspace.xhtml_dir, verbose: verbose).run
+      XHTMLExtractor.new(source_dir: source_dir, target_dir: xhtml_dir, verbose: verbose).run
     end
 
     def split_xhtmls
-      Dir.glob(File.join(@workspace.xhtml_dir, '*.xhtml')).each { |f| split_xhtml_file(f) }
+      Dir.glob(File.join(xhtml_dir, '*.xhtml')).each { |f| split_xhtml_file(f) }
     end
 
     def split_xhtml_file(xhtml_file)
       log "Splitting '#{File.basename(xhtml_file, '.xhtml')}'..."
       SplitChapters.new(
         input_file: xhtml_file, book_title: book_title,
-        output_dir: @workspace.chapters_dir, output_prefix: 'chapter', verbose: verbose
+        output_dir: chapters_dir, verbose: verbose
+      ).run
+    end
+
+    def convert_pdfs
+      return if Dir.glob(File.join(source_dir, '*.pdf')).empty?
+
+      log "Converting PDFs in '#{source_dir}'..."
+      PDFConverter.new(
+        source_dir: source_dir, book_title: book_title, output_dir: chapters_dir, verbose: verbose
       ).run
     end
 
     def validate_chapters
-      ChapterValidator.new(chapters_dir: @workspace.chapters_dir, verbose: verbose).validate
+      ChapterValidator.new(chapters_dir: chapters_dir, verbose: verbose).validate
     end
 
     def add_chapters
       log 'Adding chapters to EPUB...'
       AddChapters.new(
-        chapters_dir: @workspace.chapters_dir,
+        chapters_dir: chapters_dir,
         oebps_dir: epub_oebps_dir,
         verbose: verbose
       ).run
@@ -94,15 +96,19 @@ module EpubTools
 
     def pack_epub
       log "Building EPUB '#{output_path}'..."
-      PackEbook.new(input_dir: @workspace.epub_dir, output_file: output_path, verbose: verbose).run
+      # Expanded here: PackEbook puts a relative path next to epub_dir, inside the build dir that gets deleted
+      PackEbook.new(input_dir: epub_dir, output_file: File.expand_path(output_path), verbose: verbose).run
     end
 
     def finalize_and_cleanup
       log "Done. Output EPUB: #{File.expand_path(output_path)}"
-      @workspace.clean
+      FileUtils.rm_rf(build_dir)
       output_path
     end
 
-    def epub_oebps_dir = File.join(@workspace.epub_dir, 'OEBPS')
+    def xhtml_dir = File.join(build_dir, 'xhtml')
+    def chapters_dir = File.join(build_dir, 'chapters')
+    def epub_dir = File.join(build_dir, 'epub')
+    def epub_oebps_dir = File.join(epub_dir, 'OEBPS')
   end
 end

data/lib/epub_tools/chapter_order.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module EpubTools
+  # Reading order of chapter files: chapter_1, chapter_1_5, chapter_1a, chapter_1b, chapter_2, ..., chapter_epilogue
+  module ChapterOrder
+    module_function
+
+    # @param filename [String] A chapter filename, e.g. +chapter_12a.xhtml+
+    # @return [Array] A key that sorts chapter filenames in reading order
+    def sort_key(filename)
+      basename = File.basename(filename, '.xhtml')
+      return [Float::INFINITY, ''] if basename == 'chapter_epilogue'
+
+      if (m = basename.match(/_(\d+)_5\z/))
+        [m[1].to_f + 0.5, '']
+      else
+        [basename[/\d+/].to_f, basename[/\d+([a-z]*)\z/, 1].to_s]
+      end
+    end
+
+    # Inserts +node+ into +parent+ before the first chapter that sorts after +filename+, so a chapter added
+    # later (e.g. 12a after 13 is already in the book) still lands in reading order.
+    # @yield [element] Each existing child element; returns the filename it points to
+    def insert(parent, node, filename)
+      key = sort_key(filename)
+      later = parent.element_children.find do |el|
+        href = yield(el)
+        href&.start_with?('chapter_') && (sort_key(href) <=> key) == 1
+      end
+      later ? later.add_previous_sibling(node) : parent.add_child(node)
+    end
+  end
+end

data/lib/epub_tools/chapter_validator.rb

@@ -13,13 +13,14 @@ module EpubTools
     end
 
     # Validates that integer chapter numbers form a complete sequence with no gaps.
-    # Half-chapters (e.g. chapter_5_5.xhtml) are recognized but not required.
+    # Half-chapters (e.g. chapter_5_5.xhtml) and lettered side chapters (e.g. chapter_5a.xhtml) are
+    # recognized but not required.
     # @raise [RuntimeError] if no chapter files are found or if integer chapters have gaps
     def validate
       log 'Validating chapter sequence...'
       nums = extract_chapter_numbers
       check_sequence_completeness(nums)
-      log "Chapter sequence is complete: #{nums.first} to #{nums.last}."
+      log "Chapter sequence is complete: #{nums.first.floor} to #{nums.last.floor}."
     end
 
     private
@@ -34,7 +35,7 @@ module EpubTools
     end
 
     def extract_chapter_number(basename)
-      if (m = basename.match(/_(\d+)_5\z/))
+      if (m = basename.match(/_(\d+)(?:_5|[a-z]+)\z/))
         m[1].to_i + 0.5
       elsif (m = basename.match(/_(\d+)\z/))
         m[1].to_i
@@ -43,6 +44,8 @@ module EpubTools
 
     def check_sequence_completeness(sorted)
       integers = sorted.select { |n| n == n.to_i }.map(&:to_i)
+      return if integers.empty? # e.g. appending only side chapters
+
       missing = (integers.first..integers.last).to_a - integers
       raise "Missing chapter numbers: #{missing.join(' ')}" if missing.any?
     end

data/lib/epub_tools/cli.rb

@@ -1,33 +1,131 @@
 # frozen_string_literal: true
 
-require_relative 'cli/command_registry'
-require_relative 'cli/option_builder'
-require_relative 'cli/runner'
+require 'optparse'
+require_relative 'version'
+require_relative 'epub_initializer'
+require_relative 'xhtml_extractor'
+require_relative 'split_chapters'
+require_relative 'pdf_converter'
+require_relative 'add_chapters'
+require_relative 'pack_ebook'
+require_relative 'unpack_ebook'
+require_relative 'set_cover'
+require_relative 'compile_book'
+require_relative 'append_book'
 
 module EpubTools
-  # CLI module - houses the object-oriented command line interface components
+  # Command line interface: parses a command's flags and runs the class that implements it
   module CLI
-    # Create a new Runner instance configured with all available commands
-    # @param program_name [String] Name of the program
-    # @return [CLI::Runner] A configured runner instance
-    def self.create_runner(program_name = nil)
-      runner = Runner.new(program_name)
-      register_all_commands(runner.registry)
-      runner
+    TITLE = ['-t TITLE', '--title TITLE', 'Book title', :title, :required].freeze
+    AUTHOR = ['-a AUTHOR', '--author AUTHOR', 'Author name', :author, :required].freeze
+    COVER = ['-c PATH', '--cover PATH', 'Cover image file path (optional)', :cover_image].freeze
+    BOOK_TITLE = ['-t TITLE', '--title TITLE', 'Book title for HTML <title> tags', :book_title, :required].freeze
+    CHAPTERS_OUT = ['-o DIR', '--output-dir DIR', 'Output directory for chapter files (default: ./chapters)',
+                    :output_dir].freeze
+
+    # Each command's class, usage summary and flags as [short, long, description, option key, :required].
+    # Commands log progress unless run with -q, except those marked <tt>verbose: false</tt>.
+    COMMANDS = {
+      'init' => { class: EpubInitializer, summary: 'Initialize a bare-bones EPUB',
+                  flags: [TITLE, AUTHOR, ['-o DIR', '--output-dir DIR', 'Destination EPUB directory',
+                                          :destination, :required], COVER] },
+      'extract' => { class: XHTMLExtractor, summary: 'Extract XHTML files from EPUBs',
+                     flags: [['-s DIR', '--source-dir DIR', 'Directory with EPUBs to extract XHTMLs from',
+                              :source_dir, :required],
+                             ['-t DIR', '--target-dir DIR',
+                              'Directory where the XHTML files will be extracted to', :target_dir, :required]] },
+      'split' => { class: SplitChapters, summary: 'Split XHTML into separate XHTMLs per chapter',
+                   flags: [['-i FILE', '--input FILE', 'Source XHTML file', :input_file, :required], BOOK_TITLE,
+                           CHAPTERS_OUT] },
+      'pdf' => { class: PDFConverter, summary: 'Convert chapter PDFs into chapter XHTMLs',
+                 flags: [['-s DIR', '--source-dir DIR', "Dir of PDFs named '12a Title.pdf'", :source_dir, :required],
+                         BOOK_TITLE, CHAPTERS_OUT] },
+      'add' => { class: AddChapters, summary: 'Add chapter XHTML files into an EPUB', verbose: false,
+                 flags: [['-c DIR', '--chapters-dir DIR', 'Chapters directory', :chapters_dir, :required],
+                         ['-e DIR', '--oebps-dir DIR', 'EPUB OEBPS directory', :oebps_dir, :required]] },
+      'pack' => { class: PackEbook, summary: 'Package an EPUB directory into a .epub file',
+                  flags: [['-i DIR', '--input-dir DIR', 'EPUB directory to package', :input_dir, :required],
+                          ['-o FILE', '--output-file FILE', 'Output EPUB file path', :output_file, :required]] },
+      'unpack' => { class: UnpackEbook, summary: 'Unpack an EPUB file into a directory',
+                    flags: [['-i FILE', '--input-file FILE', 'EPUB file to unpack', :epub_file, :required],
+                            ['-o DIR', '--output-dir DIR',
+                             'Output directory to extract into (default: basename of epub)', :output_dir]] },
+      'cover' => { class: SetCover, summary: 'Add or replace the cover of an EPUB',
+                   flags: [['-i FILE', '--input-file FILE', 'EPUB to add the cover to', :epub_file, :required],
+                           ['-c PATH', '--cover PATH', 'Cover image: jpg, png, gif or svg', :cover_image, :required]] },
+      'compile' => { class: CompileBook,
+                     summary: 'Takes EPUBs and/or chapter PDFs in a dir and compiles them into a single EPUB.',
+                     flags: [TITLE, AUTHOR,
+                             ['-s DIR', '--source-dir DIR', 'Directory with EPUBs and/or chapter PDFs',
+                              :source_dir, :required],
+                             ['-o FILE', '--output FILE', 'EPUB to create (default: <Book_Title>.epub)',
+                              :output_file], COVER] },
+      'append' => { class: AppendBook,
+                    summary: 'Takes EPUBs and/or chapter PDFs in a dir and appends them to an existing EPUB.',
+                    flags: [['-s DIR', '--source-dir DIR',
+                             'Directory with EPUBs and/or chapter PDFs to append', :source_dir, :required],
+                            ['-t FILE', '--target-epub FILE', 'Existing EPUB file to append to',
+                             :target_epub, :required]] }
+    }.freeze
+
+    module_function
+
+    # Runs the command named by the first argument, or prints the version or usage
+    # @param args [Array<String>] Command line arguments
+    # @return [Object] The command instance that ran
+    def run(args)
+      if ['-v', '--version'].include?(args[0])
+        puts VERSION
+        exit
+      end
+      usage unless COMMANDS.key?(args[0])
+
+      name, *rest = args
+      COMMANDS[name][:class].new(parse(name, rest)).tap(&:run)
+    end
+
+    # @param name [String] Command name
+    # @param args [Array<String>] The command's arguments
+    # @return [Hash] Options for the command's class; exits with the help text if they are invalid
+    def parse(name, args)
+      command = COMMANDS.fetch(name)
+      options = verbose?(command) ? { verbose: true } : {}
+      parser = parser_for(name, command, options)
+      parser.parse(args)
+      missing = missing_flags(command, options)
+      abort "Missing required options: #{missing.join(', ')}\n#{parser}" if missing.any?
+
+      options
+    rescue OptionParser::ParseError => e
+      abort "#{e.message}\n#{parser}"
     end
 
-    # Register all available commands with their configurations
-    # @param registry [CommandRegistry] The command registry to populate
-    def self.register_all_commands(registry)
-      registry.register('add', EpubTools::AddChapters, %i[chapters_dir oebps_dir])
-      registry.register('extract', EpubTools::XHTMLExtractor, %i[source_dir target_dir], { verbose: true })
-      registry.register('split', EpubTools::SplitChapters, %i[input_file book_title],
-                        { output_dir: './chapters', prefix: 'chapter', verbose: true })
-      registry.register('init', EpubTools::EpubInitializer, %i[title author destination], { verbose: true })
-      registry.register('pack', EpubTools::PackEbook, %i[input_dir output_file], { verbose: true })
-      registry.register('unpack', EpubTools::UnpackEbook, [:epub_file], { verbose: true })
-      registry.register('compile', EpubTools::CompileBook, %i[title author source_dir], { verbose: true })
-      registry.register('append', EpubTools::AppendBook, %i[source_dir target_epub], { verbose: true })
+    # @return [Array<String>] The long names of required flags that were not given, e.g. +--title+
+    def missing_flags(command, options)
+      command[:flags].filter_map { |_, long, _, key, required| long.split.first if required && options[key].nil? }
     end
+
+    def parser_for(name, command, options)
+      OptionParser.new("Usage: #{program_name} #{name} [options]") do |parser|
+        command[:flags].each do |short, long, desc, key, required|
+          parser.on(short, long, required ? "#{desc} (required)" : desc) { |v| options[key] = v }
+        end
+        parser.on('-q', '--quiet', 'Run quietly (default: verbose)') { options[:verbose] = false } if verbose?(command)
+        parser.on('-h', '--help', 'Print this help') do
+          puts parser
+          exit
+        end
+      end
+    end
+
+    def usage
+      puts "Usage: #{program_name} COMMAND [options]", 'Commands:'
+      COMMANDS.each { |name, command| puts "  #{name.ljust(9)} #{command[:summary]}" }
+      exit 1
+    end
+
+    def verbose?(command) = command.fetch(:verbose, true)
+
+    def program_name = File.basename($PROGRAM_NAME)
   end
 end

data/lib/epub_tools/compile_book.rb

@@ -24,7 +24,7 @@ module EpubTools
 
     def before_add_chapters
       log 'Initializing new EPUB...'
-      options = { title: title, author: author, destination: @workspace.epub_dir }
+      options = { title: title, author: author, destination: epub_dir }
       options[:cover_image] = cover_image if cover_image
       EpubInitializer.new(options).run
     end

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