epub_tools 0.6.0 → 0.9.0

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

data/lib/epub_tools/split_chapters.rb

@@ -1,26 +1,27 @@
-#!/usr/bin/env ruby
 # frozen_string_literal: true
 
 require 'nokogiri'
-require 'yaml'
 require 'fileutils'
 require_relative 'loggable'
 require_relative 'style_finder'
 require_relative 'xhtml_cleaner'
-require_relative 'chapter_marker_detector'
 
 module EpubTools
-  # Splits a multi-chapter XHTML file into individual chapter files.
+  # Splits a multi-chapter XHTML file into individual chapter files, named +chapter_N.xhtml+. A chapter starts at
+  # a "Chapter N" marker; "Chapter N (continued)" starts chapter N.5 and "Prologue" starts chapter 0.
   class SplitChapters
     include Loggable
 
+    # Tags that can contain chapter markers
+    MARKER_TAGS = %w[p span h2 h3 h4].freeze
+    # Tags that can contain prologue markers
+    PROLOGUE_TAGS = %w[h3 h4].freeze
+
     def initialize(options = {})
       @input_file    = options.fetch(:input_file)
       @book_title    = options.fetch(:book_title)
       @output_dir    = options[:output_dir] || './chapters'
-      @output_prefix = options[:output_prefix] || 'chapter'
       @verbose       = options[:verbose] || false
-      @detector      = ChapterMarkerDetector.new
     end
 
     # Runs the splitter
@@ -28,8 +29,8 @@ module EpubTools
     def run
       FileUtils.mkdir_p(@output_dir)
       doc = Nokogiri::HTML(read_and_strip_problematic_tags)
-      StyleFinder.new({ file_path: @input_file, verbose: @verbose }).run
-      extract_chapters(doc).map { |number, content| write_chapter_file(number, content) }
+      classes = StyleFinder.new({ file_path: @input_file, verbose: @verbose }).run
+      extract_chapters(doc).map { |number, content| write_chapter_file(number, content, classes) }
     end
 
     private
@@ -52,20 +53,21 @@ module EpubTools
     end
 
     def process_node(node, chapters, current_number, current_fragment)
-      marker = @detector.detect(node)
-      if marker
-        start_chapter(chapters, marker_number(marker, node), current_number, current_fragment)
+      number = marker_number(node)
+      if number
+        start_chapter(chapters, number, current_number, current_fragment)
       else
         current_fragment&.add_child(node.dup)
         [current_number, current_fragment]
       end
     end
 
-    def marker_number(marker, node)
-      case marker
-      when :continued then @detector.extract_chapter_number(node) + 0.5
-      when :chapter then @detector.extract_chapter_number(node)
-      when :prologue then 0
+    # @return [Numeric, nil] The chapter a marker node starts, or nil when the node is not a marker
+    def marker_number(node)
+      if MARKER_TAGS.include?(node.name) && (number = node.text[/Chapter\s+(\d+)/i, 1])
+        node.text.match?(/Chapter\s+\d+\s*\(continued\)/i) ? number.to_i + 0.5 : number.to_i
+      elsif PROLOGUE_TAGS.include?(node.name) && node.text.strip.match?(/\APrologue\z/i)
+        0
       end
     end
 
@@ -74,11 +76,11 @@ module EpubTools
       [number, Nokogiri::HTML::DocumentFragment.parse('')]
     end
 
-    def write_chapter_file(label, content)
+    def write_chapter_file(label, content, classes)
       display = display_label(label)
-      filename = File.join(@output_dir, "#{@output_prefix}_#{file_label(label)}.xhtml")
+      filename = File.join(@output_dir, "chapter_#{file_label(label)}.xhtml")
       File.write(filename, build_xhtml_template(display, content))
-      XHTMLCleaner.new({ filename: filename }).run
+      XHTMLCleaner.new({ filename: filename, classes: classes }).run
       log("Extracted: #{filename}")
       filename
     end
@@ -88,7 +90,7 @@ module EpubTools
         <?xml version="1.0" encoding="UTF-8"?>
         <html xmlns="http://www.w3.org/1999/xhtml" lang="en">
           <head>
-            <title>#{@book_title} - #{display_label}</title>
+            <title>#{@book_title.encode(xml: :text)} - #{display_label}</title>
             <link rel="stylesheet" type="text/css" href="style.css"/>
           </head>
           <body>

data/lib/epub_tools/style_finder.rb

@@ -1,69 +1,40 @@
-#!/usr/bin/env ruby
 # frozen_string_literal: true
 
 require 'nokogiri'
-require 'yaml'
 require_relative 'loggable'
 
 module EpubTools
   # Finds css classes for bold and italic texts in Google Docs-generated EPUBs. Used by
-  # {XHTMLCleaner}[rdoc-ref:EpubTools::XHTMLCleaner] and
-  # {SplitChapters}[rdoc-ref:EpubTools::SplitChapters].
+  # {SplitChapters}[rdoc-ref:EpubTools::SplitChapters] to tell {XHTMLCleaner}[rdoc-ref:EpubTools::XHTMLCleaner]
+  # which spans are bold or italic.
   class StyleFinder
     include Loggable
 
     # Initializes the class
     # @param options [Hash] Configuration options
     # @option options [String] :file_path XHTML file to be analyzed (required)
-    # @option options [String] :output_path Path to write the YAML file (default: 'text_style_classes.yaml')
     # @option options [Boolean] :verbose Whether to print progress to STDOUT (default: false)
     def initialize(options = {})
       @file_path = options.fetch(:file_path)
-      @output_path = options[:output_path] || 'text_style_classes.yaml'
       @verbose = options[:verbose] || false
       raise ArgumentError, "File does not exist: #{@file_path}" unless File.exist?(@file_path)
     end
 
     # Runs the finder
-    # @return [Hash] Data containing the extracted style classes (italics and bolds)
+    # @return [Hash{Symbol => Array<String>}] The +:italics+ and +:bolds+ class names
     def run
-      style_blocks = extract_style_blocks
-      italics, bolds = extract_style_classes(style_blocks)
-      generate_output(italics, bolds)
-    end
-
-    def extract_style_blocks
-      doc = Nokogiri::HTML(File.read(@file_path))
-      doc.xpath('//style').map(&:text).join("\n")
-    end
-
-    def extract_style_classes(style_blocks)
-      italics = extract_classes(style_blocks, /font-style\s*:\s*italic/)
-      bolds = extract_classes(style_blocks, /font-weight\s*:\s*700/)
-      [italics, bolds]
-    end
-
-    def generate_output(italics, bolds)
-      print_summary(italics, bolds) if @verbose
-
-      data = { 'italics' => italics, 'bolds' => bolds }
-      File.write(@output_path, data.to_yaml)
-      data
+      styles = Nokogiri::HTML(File.read(@file_path)).xpath('//style').map(&:text).join("\n")
+      italics = classes_with(styles, /font-style\s*:\s*italic/)
+      bolds = classes_with(styles, /font-weight\s*:\s*700/)
+      log "Classes with font-style: italic: #{italics.join(', ')}" unless italics.empty?
+      log "Classes with font-weight: 700: #{bolds.join(', ')}" unless bolds.empty?
+      { italics: italics, bolds: bolds }
     end
 
     private
 
-    def extract_classes(style_text, pattern)
-      regex = /\.([\w-]+)\s*{[^}]*#{pattern.source}[^}]*}/i
-      style_text.scan(regex).flatten.uniq
-    end
-
-    def print_summary(italics, bolds)
-      log "Classes with font-style: italic: #{italics.join(', ')}" unless italics.empty?
-
-      return if bolds.empty?
-
-      log "Classes with font-weight: 700: #{bolds.join(', ')}"
+    def classes_with(styles, pattern)
+      styles.scan(/\.([\w-]+)\s*{[^}]*#{pattern.source}[^}]*}/i).flatten.uniq
     end
   end
 end

data/lib/epub_tools/unpack_ebook.rb

@@ -16,8 +16,7 @@ module EpubTools
     # @option options [Boolean] :verbose Whether to print progress to STDOUT (default: false)
     def initialize(options = {})
       @epub_file = File.expand_path(options.fetch(:epub_file))
-      output_dir = options[:output_dir]
-      @output_dir = output_dir.nil? || output_dir.empty? ? default_dir : output_dir
+      @output_dir = options[:output_dir].to_s.empty? ? default_dir : options[:output_dir]
       @verbose = options[:verbose] || false
     end
 
@@ -26,30 +25,13 @@ module EpubTools
     def run
       validate!
       FileUtils.mkdir_p(@output_dir)
-      extract_entries
+      Zip::File.extract_all(@epub_file, @output_dir) { true }
       log "Unpacked #{File.basename(@epub_file)} to #{@output_dir}"
       @output_dir
     end
 
     private
 
-    def extract_entries
-      Zip::File.open(@epub_file) do |zip|
-        zip.each do |entry|
-          extract_entry(entry)
-        end
-      end
-    end
-
-    def extract_entry(entry)
-      if entry.directory?
-        FileUtils.mkdir_p(File.join(@output_dir, entry.name))
-      else
-        FileUtils.mkdir_p(File.join(@output_dir, File.dirname(entry.name)))
-        entry.extract(destination_directory: @output_dir) { true }
-      end
-    end
-
     def default_dir
       [File.dirname(@epub_file), File.basename(@epub_file, '.epub')].join('/')
     end

data/lib/epub_tools/version.rb

@@ -2,5 +2,5 @@
 
 module EpubTools
   # Ruby Gem version number
-  VERSION = '0.6.0'
+  VERSION = '0.9.0'
 end

data/lib/epub_tools/xhtml_cleaner.rb

@@ -1,8 +1,6 @@
-#!/usr/bin/env ruby
 # frozen_string_literal: true
 
 require 'nokogiri'
-require 'yaml'
 
 module EpubTools
   # Cleans Google Docs XHTMLs
@@ -12,7 +10,7 @@ module EpubTools
   #
   # - Removes any <tt><br /></tt> or <tt><hr /></tt> tags.
   # - Removes empty <tt><p></tt> tags.
-  # - Using the +class_config+, it removes <tt><span></tt> tags that are used for bold or italics and
+  # - Using the +classes+, it removes <tt><span></tt> tags that are used for bold or italics and
   #   replaces them with <tt><b></tt> or <tt><i></tt> tags.
   # - Unwraps any <tt><span></tt> tags that have no classes assigned.
   # - Outputs everything to a cleanly formatted +.xhtml+
@@ -20,12 +18,11 @@ module EpubTools
     # Initializes the class
     # @param options [Hash] Configuration options
     # @option options [String] :filename The path to the xhtml to clean (required)
-    # @option options [String] :class_config Path to a YAML file containing the bold and italic classes to check
-    #                          (default: 'text_style_classes.yaml')
+    # @option options [Hash{Symbol => Array<String>}] :classes The +:italics+ and +:bolds+ class names, as found by
+    #                          {StyleFinder}[rdoc-ref:EpubTools::StyleFinder] (required)
     def initialize(options = {})
       @filename = options.fetch(:filename)
-      class_config = options[:class_config] || 'text_style_classes.yaml'
-      @classes = YAML.load_file(class_config).transform_keys(&:to_sym)
+      @classes = options.fetch(:classes)
     end
 
     # Runs the cleaner

data/lib/epub_tools/xhtml_extractor.rb

@@ -24,12 +24,7 @@ module EpubTools
     # Runs the extraction process
     # @return [Array<String>] Paths to all extracted XHTML files
     def run
-      all_extracted_files = []
-      epub_files.each do |epub_path|
-        extracted = extract_xhtmls_from(epub_path)
-        all_extracted_files.concat(extracted) if extracted
-      end
-      all_extracted_files
+      epub_files.flat_map { |epub_path| extract_xhtmls_from(epub_path) || [] }
     end
 
     private
@@ -56,7 +51,6 @@ module EpubTools
 
       renamed = "#{epub_name}_#{File.basename(entry.name)}"
       output_path = File.join(@target_dir, renamed)
-      FileUtils.mkdir_p(File.dirname(output_path))
       entry.extract(renamed, destination_directory: @target_dir) { true }
       log output_path
       extracted_files << output_path

data/lib/epub_tools.rb

@@ -5,14 +5,15 @@ require_relative 'epub_tools/loggable'
 require_relative 'epub_tools/add_chapters'
 require_relative 'epub_tools/epub_initializer'
 require_relative 'epub_tools/split_chapters'
-require_relative 'epub_tools/chapter_marker_detector'
 require_relative 'epub_tools/xhtml_cleaner'
 require_relative 'epub_tools/xhtml_extractor'
+require_relative 'epub_tools/pdf_converter'
 require_relative 'epub_tools/pack_ebook'
 require_relative 'epub_tools/unpack_ebook'
 require_relative 'epub_tools/book_builder'
 require_relative 'epub_tools/compile_book'
 require_relative 'epub_tools/append_book'
+require_relative 'epub_tools/set_cover'
 require_relative 'epub_tools/cli'
 
 # Wrapper for all the other classes