epub_tools 0.6.0 → 0.9.0

data/test/add_chapters_test.rb

@@ -191,3 +191,67 @@ class AddChaptersHalfChapterTest < Minitest::Test
     XHTML
   end
 end
+
+class AddChaptersReadingOrderTest < Minitest::Test
+  def setup
+    @tmp = Dir.mktmpdir
+    @chapters_dir = File.join(@tmp, 'chapters')
+    @epub_dir = File.join(@tmp, 'OEBPS')
+    FileUtils.mkdir_p([@chapters_dir, @epub_dir])
+    create_book_with_two_chapters
+    write_chapter('chapter_1b.xhtml', '<h1>Chapter 1b: Later</h1>')
+    write_chapter('chapter_1a.xhtml', '<h1>Chapter 1a: Side</h1>')
+    write_chapter('chapter_3.xhtml', '<p>No heading</p>')
+    write_chapter('chapter_epilogue.xhtml', '<h1>Epilogue: After</h1>')
+  end
+
+  def teardown
+    FileUtils.remove_entry(@tmp)
+  end
+
+  def test_inserts_chapters_in_reading_order_with_their_headings
+    EpubTools::AddChapters.new(chapters_dir: @chapters_dir, oebps_dir: @epub_dir).run
+
+    opf = Nokogiri::XML(File.read(File.join(@epub_dir, 'package.opf')))
+    nav = Nokogiri::XML(File.read(File.join(@epub_dir, 'nav.xhtml'))).remove_namespaces!
+    spine = opf.xpath('//xmlns:itemref').map { |i| i['idref'] }
+
+    assert_equal %w[title chap1 chapter_1a chapter_1b chap2 chap3 chapter_epilogue], spine
+    assert_equal ['Title Page', 'Chapter 1', 'Chapter 1a: Side', 'Chapter 1b: Later', 'Chapter 2', 'Chapter 3',
+                  'Epilogue: After'],
+                 nav.xpath('//nav/ol/li/a').map(&:text)
+  end
+
+  private
+
+  def write_chapter(name, body)
+    File.write(File.join(@chapters_dir, name), "<html xmlns=\"http://www.w3.org/1999/xhtml\"><body>#{body}</body></html>")
+  end
+
+  def create_book_with_two_chapters
+    File.write(File.join(@epub_dir, 'package.opf'), <<~XML)
+      <?xml version="1.0"?>
+      <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/"></metadata>
+        <manifest>
+          <item id="title" href="title.xhtml" media-type="application/xhtml+xml"/>
+          <item id="chap1" href="chapter_1.xhtml" media-type="application/xhtml+xml"/>
+          <item id="chap2" href="chapter_2.xhtml" media-type="application/xhtml+xml"/>
+        </manifest>
+        <spine><itemref idref="title"/><itemref idref="chap1"/><itemref idref="chap2"/></spine>
+      </package>
+    XML
+    File.write(File.join(@epub_dir, 'nav.xhtml'), <<~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">
+        <body>
+          <nav epub:type="toc" id="toc"><ol>
+            <li><a href="title.xhtml">Title Page</a></li>
+            <li><a href="chapter_1.xhtml">Chapter 1</a></li>
+            <li><a href="chapter_2.xhtml">Chapter 2</a></li>
+          </ol></nav>
+        </body>
+      </html>
+    XHTML
+  end
+end

data/test/append_book_test.rb

@@ -45,7 +45,7 @@ class AppendBookTest < Minitest::Test
 
   def test_detect_conflicts_raises_on_overlap
     ab = build_append_book
-    setup_conflict_dirs(ab, new_chapters: [1, 2], existing_chapters: [1])
+    setup_conflict_dirs(new_chapters: [1, 2], existing_chapters: [1])
 
     error = assert_raises(ArgumentError) { ab.send(:detect_conflicts) }
     assert_match(/chapters 1 already exist/, error.message)
@@ -53,11 +53,19 @@ class AppendBookTest < Minitest::Test
 
   def test_detect_conflicts_passes_with_no_overlap
     ab = build_append_book
-    setup_conflict_dirs(ab, new_chapters: [5], existing_chapters: [1, 2])
+    setup_conflict_dirs(new_chapters: [5], existing_chapters: [1, 2])
 
     ab.send(:detect_conflicts)
   end
 
+  def test_detect_conflicts_with_lettered_chapters
+    ab = build_append_book
+    setup_conflict_dirs(new_chapters: %w[3a 4], existing_chapters: %w[3 3a])
+
+    error = assert_raises(ArgumentError) { ab.send(:detect_conflicts) }
+    assert_match(/chapters 3a already exist/, error.message)
+  end
+
   def test_detect_conflicts_with_half_chapters
     ab = build_append_book
     chapters_dir = File.join(@tmp, 'chapters')
@@ -67,10 +75,6 @@ class AppendBookTest < Minitest::Test
     FileUtils.touch(File.join(chapters_dir, 'chapter_3_5.xhtml'))
     FileUtils.touch(File.join(oebps_dir, 'chapter_3_5.xhtml'))
 
-    workspace = ab.instance_variable_get(:@workspace)
-    workspace.instance_variable_set(:@chapters_dir, chapters_dir)
-    workspace.instance_variable_set(:@epub_dir, File.join(@tmp, 'epub'))
-
     error = assert_raises(ArgumentError) { ab.send(:detect_conflicts) }
     assert_match(/3\.5 already exist/, error.message)
   end
@@ -112,16 +116,12 @@ class AppendBookTest < Minitest::Test
     )
   end
 
-  def setup_conflict_dirs(append_book, new_chapters:, existing_chapters:)
+  def setup_conflict_dirs(new_chapters:, existing_chapters:)
     chapters_dir = File.join(@tmp, 'chapters')
     oebps_dir = File.join(@tmp, 'epub', 'OEBPS')
     FileUtils.mkdir_p([chapters_dir, oebps_dir])
 
     new_chapters.each { |n| FileUtils.touch(File.join(chapters_dir, "chapter_#{n}.xhtml")) }
     existing_chapters.each { |n| FileUtils.touch(File.join(oebps_dir, "chapter_#{n}.xhtml")) }
-
-    workspace = append_book.instance_variable_get(:@workspace)
-    workspace.instance_variable_set(:@chapters_dir, chapters_dir)
-    workspace.instance_variable_set(:@epub_dir, File.join(@tmp, 'epub'))
   end
 end

data/test/chapter_validator_test.rb

@@ -58,6 +58,18 @@ class ChapterValidatorTest < Minitest::Test
     assert_match(/Missing chapter numbers: 2/, error.message)
   end
 
+  def test_lettered_chapters_are_not_required
+    create_chapter_files(%w[1 1a 1b 2])
+
+    assert_silent { @validator.validate }
+  end
+
+  def test_validates_only_side_chapters
+    create_chapter_files(%w[7a 7b])
+
+    assert_silent { @validator.validate }
+  end
+
   private
 
   def create_chapter_files(numbers)

data/test/cli_test.rb

@@ -1,6 +1,43 @@
 # frozen_string_literal: true
 
 require_relative 'test_helper'
-require_relative 'cli/command_registry_test'
-require_relative 'cli/option_builder_test'
-require_relative 'cli/runner_test'
+require_relative '../lib/epub_tools'
+
+class CLITest < Minitest::Test
+  def test_parse_maps_flags_to_option_keys
+    options = EpubTools::CLI.parse('init', %w[-t Title -a Author -o dir -c cover.jpg])
+
+    assert_equal({ verbose: true, title: 'Title', author: 'Author', destination: 'dir', cover_image: 'cover.jpg' },
+                 options)
+  end
+
+  def test_quiet_turns_off_verbose
+    refute EpubTools::CLI.parse('pack', %w[-i dir -o out.epub -q])[:verbose]
+  end
+
+  def test_commands_without_verbose_output_have_no_quiet_flag
+    assert_equal({ chapters_dir: 'c', oebps_dir: 'e' }, EpubTools::CLI.parse('add', %w[-c c -e e]))
+    assert_output('', /invalid option: -q/) do
+      assert_raises(SystemExit) { EpubTools::CLI.parse('add', %w[-c c -e e -q]) }
+    end
+  end
+
+  def test_missing_required_options_name_their_flags
+    assert_output('', /Missing required options: --output-dir\n/) do
+      assert_raises(SystemExit) { EpubTools::CLI.parse('init', %w[-t Title -a Author]) }
+    end
+  end
+
+  def test_run_builds_and_runs_the_command
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, 'mimetype'), 'application/epub+zip')
+      out = File.join(dir, '..', "#{File.basename(dir)}.epub")
+      command = EpubTools::CLI.run(['pack', '-i', dir, '-o', out, '-q'])
+
+      assert_instance_of EpubTools::PackEbook, command
+      assert_path_exists out
+    ensure
+      FileUtils.rm_f(out)
+    end
+  end
+end

data/test/compile_book_test.rb

@@ -113,4 +113,18 @@ class CompileBookTest < Minitest::Test
 
     assert_equal 'test.epub', result
   end
+
+  def test_relative_output_is_written_to_working_directory
+    book = File.join(@tmp, 'part')
+    FileUtils.mkdir_p(File.join(book, 'OEBPS'))
+    File.write(File.join(book, 'mimetype'), 'application/epub+zip')
+    File.write(File.join(book, 'OEBPS', 'text.xhtml'), '<html><body><p>Chapter 1</p><p>Text</p></body></html>')
+    EpubTools::PackEbook.new(input_dir: book, output_file: File.join(@source, 'part.epub')).run
+
+    Dir.chdir(@tmp) do
+      EpubTools::CompileBook.new(title: @title, author: @author, source_dir: @source, output_file: 'out.epub').run
+    end
+
+    assert_path_exists File.join(@tmp, 'out.epub')
+  end
 end

data/test/epub_initializer_test.rb

@@ -24,6 +24,22 @@ class EpubInitializerTest < Minitest::Test
     verify_file_contents
   end
 
+  def test_style_comes_from_the_gem_not_the_working_directory
+    Dir.chdir(@tmp) { EpubTools::EpubInitializer.new(title: @title, author: @author, destination: @dest).run }
+
+    assert_equal File.read(File.expand_path('../style.css', __dir__)), File.read(File.join(@dest, 'OEBPS', 'style.css'))
+  end
+
+  def test_title_and_author_are_escaped
+    EpubTools::EpubInitializer.new(title: 'Tom & Jerry', author: 'A <B>', destination: @dest).run
+    opf = strict_xml('package.opf')
+    dc = { 'dc' => 'http://purl.org/dc/elements/1.1/' }
+
+    assert_equal 'Tom & Jerry', opf.at_xpath('//dc:title', dc).text
+    assert_equal 'A <B>', opf.at_xpath('//dc:creator', dc).text
+    assert_equal 'by A <B>', strict_xml('title.xhtml').at_xpath('//xmlns:p[@class="author"]').text
+  end
+
   def test_run_with_cover_image
     # create dummy image
     cover = File.join(@tmp, 'cover.png')
@@ -117,6 +133,8 @@ class EpubInitializerTest < Minitest::Test
 
   private
 
+  def strict_xml(name) = Nokogiri::XML(File.read(File.join(@dest, 'OEBPS', name)), &:strict)
+
   def verify_directory_structure
     assert Dir.exist?(@dest)
     assert File.directory?(File.join(@dest, 'META-INF'))

data/test/pdf_converter_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+require_relative '../lib/epub_tools/pdf_converter'
+
+class PDFConverterTest < Minitest::Test
+  XML = <<~XML
+    <pdf2xml><page number="1">
+      <fontspec id="0" size="42"/><fontspec id="1" size="18"/>
+      <text top="105" left="231" width="400" font="0">Heading typed in the PDF</text>
+      <text top="198" left="135" width="400" font="1">Tom &amp; Jerry’s text.</text>
+      <text top="235" left="135" width="400" font="1">More text.</text>
+    </page></pdf2xml>
+  XML
+
+  def setup
+    @tmp = Dir.mktmpdir
+    @source = File.join(@tmp, 'pdfs')
+    @output = File.join(@tmp, 'chapters')
+    FileUtils.mkdir_p(@source)
+  end
+
+  def teardown
+    FileUtils.rm_rf(@tmp)
+  end
+
+  def test_names_chapters_after_their_pdfs
+    ['0 Cast List.pdf', "12a Don't Stop.pdf"].each { |name| FileUtils.touch(File.join(@source, name)) }
+
+    paths = converter.run
+
+    assert_equal %w[chapter_0.xhtml chapter_12a.xhtml], paths.map { |path| File.basename(path) }.sort
+    assert_equal 'Cast List', heading('chapter_0.xhtml')
+    assert_equal 'Chapter 12a: Don’t Stop', heading('chapter_12a.xhtml')
+    assert_includes File.read(File.join(@output, 'chapter_12a.xhtml')), '<p>Tom &amp; Jerry’s text.</p>'
+  end
+
+  def test_names_the_epilogue
+    FileUtils.touch(File.join(@source, 'Epilogue One Month.pdf'))
+
+    assert_equal(['chapter_epilogue.xhtml'], converter.run.map { |path| File.basename(path) })
+    assert_equal 'Epilogue: One Month', heading('chapter_epilogue.xhtml')
+  end
+
+  def test_rejects_pdfs_without_a_chapter_number
+    FileUtils.touch(File.join(@source, 'Afterword.pdf'))
+
+    error = assert_raises(ArgumentError) { converter.run }
+    assert_match(/Afterword\.pdf/, error.message)
+  end
+
+  def test_does_nothing_without_pdfs
+    assert_empty converter.run
+    refute_path_exists @output
+  end
+
+  private
+
+  def converter
+    xml = XML
+    EpubTools::PDFConverter.new(source_dir: @source, output_dir: @output, book_title: 'Book').tap do |converter|
+      converter.define_singleton_method(:pdftohtml) { |_pdf| Nokogiri::XML(xml) }
+    end
+  end
+
+  def heading(file)
+    Nokogiri::XML(File.read(File.join(@output, file))).at_xpath('//xmlns:h1').text
+  end
+end

data/test/pdf_layout_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+require_relative '../lib/epub_tools/pdf_layout'
+
+class PDFLayoutTest < Minitest::Test
+  # Shaped like `pdftohtml -xml` output: body text at left=108, first-line indents at 135, lines 25px apart
+  # and paragraphs 37px apart, with full lines ending at 800.
+  XML = <<~XML
+    <pdf2xml>
+    <page number="1">
+      <fontspec id="0" size="42"/><fontspec id="1" size="18"/>
+      <text top="105" left="231" width="400" font="0">Chapter 1: Title in the PDF</text>
+      <text top="198" left="135" width="200" font="1"><i><b>Monday, 9:00 am</b></i></text>
+      <text top="231" left="135" width="600" font="1">The first paragraph has <i>italic words that </i></text>
+      <text top="256" left="108" width="692" font="1"><i>continue</i> on this line and ends with a half-</text>
+      <text top="281" left="108" width="692" font="1">dressed word and no trailing space</text>
+      <text top="306" left="108" width="600" font="1">before this line, which is full </text>
+      <text top="306" left="708" width="92" font="1">width </text>
+    </page>
+    <page number="2">
+      <text top="107" left="108" width="300" font="1">so it continues after the page break.</text>
+      <text top="144" left="108" width="400" font="1">A block paragraph after a gap.</text>
+      <text top="181" left="460" width="28" font="1">*** </text>
+      <text top="218" left="135" width="665" font="1">After the break, a paragraph whose writer hit</text>
+      <text top="255" left="135" width="200" font="1">enter by mistake.</text>
+      <text top="292" left="135" width="100" font="1">Short end.</text>
+    </page>
+    <page number="3">
+      <text top="107" left="108" width="400" font="1">A new paragraph, as the last page ended short.</text>
+      <text top="144" left="126" width="300" font="1">• A bullet that wraps</text>
+      <text top="164" left="138" width="200" font="1">onto a second line</text>
+      <text top="184" left="126" width="200" font="1">• Second bullet</text>
+    </page>
+    </pdf2xml>
+  XML
+
+  def test_rebuilds_paragraphs
+    html = EpubTools::PDFLayout.new(Nokogiri::XML(XML)).to_html
+
+    assert_equal [
+      '<p><i><b>Monday, 9:00 am</b></i></p>',
+      '<p>The first paragraph has <i>italic words that continue</i> on this line and ends with a half-dressed ' \
+      'word and no trailing space before this line, which is full width so it continues after the page break.</p>',
+      '<p>A block paragraph after a gap.</p>',
+      '<hr/>',
+      '<p>After the break, a paragraph whose writer hit enter by mistake.</p>',
+      '<p>Short end.</p>',
+      '<p>A new paragraph, as the last page ended short.</p>',
+      '<ul><li>A bullet that wraps onto a second line</li><li>Second bullet</li></ul>'
+    ], html.split("\n    ")
+  end
+
+  def test_empty_without_body_text
+    assert_predicate EpubTools::PDFLayout.new(Nokogiri::XML('<pdf2xml><page number="1"/></pdf2xml>')), :empty?
+  end
+end

data/test/set_cover_test.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'test_helper'
+require_relative '../lib/epub_tools/set_cover'
+require_relative '../lib/epub_tools/epub_initializer'
+require 'zip'
+
+class SetCoverTest < Minitest::Test
+  DC = { 'dc' => 'http://purl.org/dc/elements/1.1/' }.freeze
+
+  def setup
+    @tmp = Dir.mktmpdir
+    @epub = File.join(@tmp, 'book.epub')
+    book = EpubTools::EpubInitializer.new(title: 'Book', author: 'Me', destination: File.join(@tmp, 'book')).run
+    EpubTools::PackEbook.new(input_dir: book, output_file: @epub).run
+  end
+
+  def teardown
+    FileUtils.rm_rf(@tmp)
+  end
+
+  def test_adds_then_replaces_the_cover_keeping_the_book_identity
+    identifier = book_identifier
+    apply_cover('art.png')
+    apply_cover('art.jpg')
+
+    assert_cover_entries('cover.jpg', 'image/jpeg')
+    assert_cover_files('cover.jpg', replaced: 'cover.png')
+    assert_equal identifier, book_identifier
+    assert_path_exists "#{@epub}.bak"
+  end
+
+  def test_rejects_unsupported_image_types
+    bmp = File.join(@tmp, 'art.bmp')
+    File.write(bmp, 'BMP')
+
+    error = assert_raises(ArgumentError) { EpubTools::SetCover.new(epub_file: @epub, cover_image: bmp) }
+    assert_match(/unsupported cover image type/, error.message)
+  end
+
+  private
+
+  def apply_cover(name)
+    path = File.join(@tmp, name)
+    File.write(path, 'IMAGE')
+    EpubTools::SetCover.new(epub_file: @epub, cover_image: path).run
+  end
+
+  def assert_cover_entries(href, media_type)
+    covers = opf.xpath('//xmlns:item[@properties="cover-image"]').map { |item| [item['href'], item['media-type']] }
+    spine = opf.xpath('//xmlns:itemref').map { |ref| ref['idref'] }
+
+    assert_equal [[href, media_type]], covers
+    assert_equal %w[cover-page title], spine
+    assert_equal 1, opf.xpath('//xmlns:meta[@name="cover"]').size
+  end
+
+  def assert_cover_files(image, replaced:)
+    assert_includes zip_entry('OEBPS/cover.xhtml'), %(src="#{image}")
+    refute_includes Zip::File.open(@epub) { |zip| zip.map(&:name) }, "OEBPS/#{replaced}"
+  end
+
+  def book_identifier = opf.at_xpath('//dc:identifier', DC).text
+
+  def opf = Nokogiri::XML(zip_entry('OEBPS/package.opf'))
+
+  def zip_entry(name) = Zip::File.open(@epub) { |zip| zip.read(name) }
+end

data/test/split_chapters_test.rb

@@ -29,8 +29,7 @@ class SplitChaptersTest < Minitest::Test
   end
 
   def test_run_generates_chapter_files
-    result = EpubTools::SplitChapters.new(input_file: @input, book_title: 'BookTitle', output_dir: @out,
-                                          output_prefix: 'chap').run
+    result = EpubTools::SplitChapters.new(input_file: @input, book_title: 'BookTitle', output_dir: @out).run
 
     verify_return_value(result)
     verify_generated_files_exist(result)
@@ -46,9 +45,9 @@ class SplitChaptersTest < Minitest::Test
 
   def verify_generated_files_exist(result)
     expected_paths = [
-      File.join(@out, 'chap_0.xhtml'),
-      File.join(@out, 'chap_1.xhtml'),
-      File.join(@out, 'chap_2.xhtml')
+      File.join(@out, 'chapter_0.xhtml'),
+      File.join(@out, 'chapter_1.xhtml'),
+      File.join(@out, 'chapter_2.xhtml')
     ]
 
     expected_paths.each do |path|
@@ -58,7 +57,7 @@ class SplitChaptersTest < Minitest::Test
 
     files = Dir.children(@out)
 
-    ['chap_0.xhtml', 'chap_1.xhtml', 'chap_2.xhtml'].each do |file|
+    ['chapter_0.xhtml', 'chapter_1.xhtml', 'chapter_2.xhtml'].each do |file|
       assert_includes files, file
     end
   end
@@ -70,7 +69,7 @@ class SplitChaptersTest < Minitest::Test
   end
 
   def verify_prologue_content
-    prologue = File.read(File.join(@out, 'chap_0.xhtml'))
+    prologue = File.read(File.join(@out, 'chapter_0.xhtml'))
 
     assert_includes prologue, '<h1>Prologue</h1>'
     assert_includes prologue, 'Intro text'
@@ -78,7 +77,7 @@ class SplitChaptersTest < Minitest::Test
   end
 
   def verify_chapter_one_content
-    ch1 = File.read(File.join(@out, 'chap_1.xhtml'))
+    ch1 = File.read(File.join(@out, 'chapter_1.xhtml'))
 
     assert_includes ch1, '<h1>Chapter 1</h1>'
     assert_includes ch1, 'First paragraph'
@@ -86,7 +85,7 @@ class SplitChaptersTest < Minitest::Test
   end
 
   def verify_chapter_two_content
-    ch2 = File.read(File.join(@out, 'chap_2.xhtml'))
+    ch2 = File.read(File.join(@out, 'chapter_2.xhtml'))
 
     assert_includes ch2, '<h1>Chapter 2</h1>'
     assert_includes ch2, 'Second paragraph'
@@ -120,7 +119,7 @@ class SplitChaptersContinuedTest < Minitest::Test
 
   def test_splits_continued_chapters
     result = EpubTools::SplitChapters.new(
-      input_file: @input, book_title: 'Test', output_dir: @out, output_prefix: 'chapter'
+      input_file: @input, book_title: 'Test', output_dir: @out
     ).run
 
     assert_equal 3, result.size
@@ -131,7 +130,7 @@ class SplitChaptersContinuedTest < Minitest::Test
 
   def test_continued_chapter_content
     EpubTools::SplitChapters.new(
-      input_file: @input, book_title: 'Test', output_dir: @out, output_prefix: 'chapter'
+      input_file: @input, book_title: 'Test', output_dir: @out
     ).run
 
     continued = File.read(File.join(@out, 'chapter_1_5.xhtml'))
@@ -140,6 +139,13 @@ class SplitChaptersContinuedTest < Minitest::Test
     assert_includes continued, 'Continued text'
   end
 
+  def test_book_title_is_escaped
+    EpubTools::SplitChapters.new(input_file: @input, book_title: 'Tom & Jerry', output_dir: @out).run
+    chapter = Nokogiri::XML(File.read(File.join(@out, 'chapter_1.xhtml')), &:strict)
+
+    assert_equal 'Tom & Jerry - Chapter 1', chapter.at_xpath('//xmlns:title').text
+  end
+
   def test_continued_marker_case_insensitive
     content = <<~HTML
       <?xml version="1.0"?>
@@ -155,7 +161,7 @@ class SplitChaptersContinuedTest < Minitest::Test
     File.write(@input, content)
 
     result = EpubTools::SplitChapters.new(
-      input_file: @input, book_title: 'Test', output_dir: @out, output_prefix: 'chapter'
+      input_file: @input, book_title: 'Test', output_dir: @out
     ).run
 
     assert_includes result, File.join(@out, 'chapter_5_5.xhtml')

data/test/style_finder_test.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
-require 'yaml'
 require_relative 'test_helper'
 require_relative '../lib/epub_tools/style_finder'
 
-class StyleFinder < Minitest::Test
+class StyleFinderTest < Minitest::Test
   def setup
     @tmp = Dir.mktmpdir
     @xhtml = File.join(@tmp, 'doc.xhtml')
@@ -16,7 +15,6 @@ class StyleFinder < Minitest::Test
       </style></head><body></body></html>
     HTML
     File.write(@xhtml, content)
-    @yaml = File.join(@tmp, 'classes.yaml')
   end
 
   def teardown
@@ -24,11 +22,7 @@ class StyleFinder < Minitest::Test
   end
 
   def test_finds_italic_and_bold_classes
-    EpubTools::StyleFinder.new(file_path: @xhtml, output_path: @yaml).run
-    data = YAML.load_file(@yaml)
-
-    assert_equal ['c1'], data['italics']
-    assert_equal ['c2'], data['bolds']
+    assert_equal({ italics: ['c1'], bolds: ['c2'] }, EpubTools::StyleFinder.new(file_path: @xhtml).run)
   end
 
   def test_verbose_mode
@@ -37,7 +31,7 @@ class StyleFinder < Minitest::Test
       Classes with font-weight: 700: c2
     OUTPUT
     assert_output(text) do
-      EpubTools::StyleFinder.new(file_path: @xhtml, output_path: @yaml, verbose: true).run
+      EpubTools::StyleFinder.new(file_path: @xhtml, verbose: true).run
     end
   end
 end

data/test/test_helper.rb

@@ -2,7 +2,7 @@
 
 require 'simplecov'
 SimpleCov.start do
-  add_filter '/test/'
+  skip '/test/'
 end
 
 require 'minitest/autorun'

data/test/unpack_ebook_test.rb

@@ -43,7 +43,7 @@ class UnpackEbookTest < Minitest::Test
   end
 
   def add_remaining_files_to_zip(zip)
-    Dir.glob(File.join(@build_dir, '**', '*'), File::FNM_DOTMATCH).sort.each do |src_path|
+    Dir.glob(File.join(@build_dir, '**', '*')).each do |src_path|
       add_file_or_directory_to_zip(zip, src_path)
     end
   end

data/test/xhtml_cleaner_test.rb

@@ -1,14 +1,11 @@
 # frozen_string_literal: true
 
-require 'yaml'
 require_relative 'test_helper'
 require_relative '../lib/epub_tools/xhtml_cleaner'
 
 class XHTMLCleanerTest < Minitest::Test
   def setup
     @tmp = Dir.mktmpdir
-    @config = File.join(@tmp, 'config.yaml')
-    File.write(@config, { 'italics' => ['itclass'], 'bolds' => ['boldclass'] }.to_yaml)
     @file = File.join(@tmp, 'test.xhtml')
     content = <<~HTML
       <?xml version="1.0" encoding="UTF-8"?>
@@ -30,7 +27,7 @@ class XHTMLCleanerTest < Minitest::Test
   end
 
   def test_cleaner_removes_and_transforms_tags
-    result = EpubTools::XHTMLCleaner.new(filename: @file, class_config: @config).run
+    result = EpubTools::XHTMLCleaner.new(filename: @file, classes: { italics: ['itclass'], bolds: ['boldclass'] }).run
 
     # Check return value is the filename that was cleaned
     assert_equal @file, result