epub_tools 0.5.0 → 0.9.0

data/lib/epub_tools/epub_file_writer.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-
-module EpubTools
-  # Handles writing files for EPUB structure
-  class EpubFileWriter
-    def initialize(destination)
-      @destination = destination
-    end
-
-    # Creates the basic EPUB directory structure
-    def create_structure
-      FileUtils.mkdir_p("#{@destination}/META-INF")
-      FileUtils.mkdir_p("#{@destination}/OEBPS")
-    end
-
-    # Writes the mimetype file
-    def write_mimetype
-      File.write("#{@destination}/mimetype", 'application/epub+zip')
-    end
-
-    # Writes the container.xml file
-    def write_container
-      content = <<~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
-      File.write("#{@destination}/META-INF/container.xml", content)
-    end
-
-    # Writes XHTML content to a file
-    def write_xhtml(filename, content)
-      File.write(File.join(@destination, 'OEBPS', filename), content)
-    end
-
-    # Writes the package.opf file
-    def write_package_opf(content)
-      File.write(File.join(@destination, 'OEBPS', 'package.opf'), content)
-    end
-
-    # Copies the project style.css to EPUB structure
-    def write_style
-      src = File.join(Dir.pwd, 'style.css')
-      dest = File.join(@destination, 'OEBPS', 'style.css')
-      unless File.exist?(src)
-        warn "Warning: style.css not found in project root (#{src}), skipping copy."
-        return
-      end
-      FileUtils.cp(src, dest)
-    end
-  end
-end

data/lib/epub_tools/epub_metadata_builder.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module EpubTools
-  # Builds metadata content for EPUB package.opf files
-  class EpubMetadataBuilder
-    def initialize(config)
-      @config = config
-    end
-
-    # Builds complete metadata array
-    def build_metadata
-      metadata = []
-      add_dublin_core_metadata(metadata)
-      add_schema_metadata(metadata)
-      add_cover_metadata(metadata) if @config.cover_image_fname
-      metadata
-    end
-
-    # Builds manifest and spine items
-    def build_manifest_and_spine
-      manifest_items = []
-      spine_items = []
-
-      add_base_manifest_items(manifest_items)
-      add_cover_items(manifest_items, spine_items) if @config.cover_image_fname
-      add_title_items(manifest_items, spine_items)
-
-      [manifest_items, spine_items]
-    end
-
-    # Builds complete OPF XML content
-    def build_opf_xml(metadata, manifest_items, spine_items)
-      <<~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/">
-        #{metadata.map { |line| "    #{line}" }.join("\n")}
-          </metadata>
-          <manifest>
-        #{manifest_items.map { |line| "    #{line}" }.join("\n")}
-          </manifest>
-          <spine>
-        #{spine_items.map { |line| "    #{line}" }.join("\n")}
-          </spine>
-        </package>
-      XML
-    end
-
-    private
-
-    def add_dublin_core_metadata(metadata)
-      metadata << %(<dc:identifier id="pub-id">#{@config.uuid}</dc:identifier>)
-      metadata << %(<dc:title>#{@config.title}</dc:title>)
-      metadata << %(<dc:creator>#{@config.author}</dc:creator>)
-      metadata << '<dc:language>en</dc:language>'
-      metadata << %(<meta property="dcterms:modified">#{@config.modified}</meta>)
-    end
-
-    def add_schema_metadata(metadata)
-      metadata << %(<meta property="schema:accessMode">textual</meta>)
-      metadata << %(<meta property="schema:accessibilityFeature">unknown</meta>)
-      metadata << %(<meta property="schema:accessibilityHazard">none</meta>)
-      metadata << %(<meta property="schema:accessModeSufficient">textual</meta>)
-    end
-
-    def add_cover_metadata(metadata)
-      metadata << %(<meta name="cover" content="cover-image"/>)
-    end
-
-    def add_base_manifest_items(manifest_items)
-      manifest_items << mitem('style', 'style.css', 'text/css')
-      manifest_items << mitem('nav', 'nav.xhtml', 'application/xhtml+xml', 'nav')
-    end
-
-    def add_cover_items(manifest_items, spine_items)
-      manifest_items << mitem('cover-image', @config.cover_image_fname, @config.cover_image_media_type, 'cover-image')
-      manifest_items << mitem('cover-page', 'cover.xhtml', 'application/xhtml+xml')
-      spine_items << '<itemref idref="cover-page"/>'
-    end
-
-    def add_title_items(manifest_items, spine_items)
-      manifest_items << mitem('title', 'title.xhtml', 'application/xhtml+xml')
-      spine_items << '<itemref idref="title"/>'
-    end
-
-    def mitem(id, href, type, properties = nil)
-      xml = "<item id=\"#{id}\" href=\"#{href}\" media-type=\"#{type}\""
-      xml += " properties=\"#{properties}\"" if properties
-      "#{xml}/>"
-    end
-  end
-end

data/lib/epub_tools/xhtml_generator.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module EpubTools
-  # Generates XHTML content for EPUB files
-  class XhtmlGenerator
-    attr_accessor :cover_image_fname
-
-    def initialize(title:, author:)
-      @title = title
-      @author = author
-      @cover_image_fname = nil
-    end
-
-    # Generates title page XHTML content
-    def build_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 cover page XHTML content
-    def build_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="#{@cover_image_fname}" alt="Cover"/>
-            </div>
-          </body>
-        </html>
-      XHTML
-    end
-
-    # Generates navigation XHTML content
-    def build_nav_page
-      <<~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
-    end
-  end
-end

data/test/cli/command_registry_test.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../test_helper'
-require_relative '../../lib/epub_tools'
-
-class CommandRegistryTest < Minitest::Test
-  class DummyCommand
-    attr_reader :options
-
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      true
-    end
-  end
-
-  def setup
-    @registry = EpubTools::CLI::CommandRegistry.new
-  end
-
-  def test_registry_initializes_empty
-    assert_empty @registry.commands
-    assert_empty @registry.available_commands
-  end
-
-  def test_register_command
-    @registry.register('test', DummyCommand, [:required_option], { default: 'value' })
-
-    assert_equal 1, @registry.commands.size
-    assert_includes @registry.available_commands, 'test'
-
-    command = @registry.get('test')
-
-    assert_equal DummyCommand, command[:class]
-    assert_equal [:required_option], command[:required_keys]
-    assert_equal({ default: 'value' }, command[:default_options])
-  end
-
-  def test_register_multiple_commands
-    @registry.register('test1', DummyCommand)
-    @registry.register('test2', DummyCommand)
-
-    assert_equal 2, @registry.commands.size
-    assert_includes @registry.available_commands, 'test1'
-    assert_includes @registry.available_commands, 'test2'
-  end
-
-  def test_get_nonexistent_command
-    assert_nil @registry.get('nonexistent')
-  end
-
-  def test_command_exists
-    @registry.register('test', DummyCommand)
-
-    assert @registry.command_exists?('test')
-    refute @registry.command_exists?('nonexistent')
-  end
-
-  def test_chained_registration
-    result = @registry.register('test1', DummyCommand)
-                      .register('test2', DummyCommand)
-
-    assert_equal @registry, result
-    assert_equal 2, @registry.commands.size
-  end
-end

data/test/cli/option_builder_test.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../test_helper'
-require_relative '../../lib/epub_tools'
-require 'stringio'
-
-class OptionBuilderTest < Minitest::Test
-  def setup
-    @builder = EpubTools::CLI::OptionBuilder.new
-  end
-
-  def test_initialize_with_defaults
-    builder = EpubTools::CLI::OptionBuilder.new({ default: 'value' }, [:required])
-
-    assert_equal({ default: 'value' }, builder.options)
-    assert_equal [:required], builder.required_keys
-  end
-
-  def test_with_banner
-    @builder.with_banner('Test Banner')
-
-    assert_equal 'Test Banner', @builder.parser.banner
-  end
-
-  def test_with_help_option
-    # This test is tricky as --help would exit, so we'll test indirectly
-    @builder.with_help_option
-
-    assert_includes @builder.parser.to_s, '-h, --help'
-  end
-
-  def test_with_verbose_option
-    @builder.with_verbose_option
-
-    assert @builder.options[:verbose]
-
-    # Parse args with --quiet to change verbose to false
-    @builder.parse(['--quiet'])
-
-    refute @builder.options[:verbose]
-  end
-
-  def test_with_input_file
-    @builder.with_input_file('Test input')
-
-    verify_parser_option_format('-i, --input-file FILE', 'Test input (required)')
-
-    builder2 = EpubTools::CLI::OptionBuilder.new
-    builder2.with_input_file('Test input', required: false)
-
-    verify_optional_parser_format(builder2, 'Test input')
-
-    @builder.parse(['-i', 'file.txt'])
-
-    assert_equal 'file.txt', @builder.options[:input_file]
-  end
-
-  def test_with_input_dir
-    @builder.with_input_dir('Test input dir')
-
-    assert_includes @builder.parser.to_s, '-i, --input-dir DIR'
-    assert_includes @builder.parser.to_s, 'Test input dir (required)'
-
-    @builder.parse(['-i', 'dir/path'])
-
-    assert_equal 'dir/path', @builder.options[:input_dir]
-  end
-
-  def test_with_output_dir
-    @builder.with_output_dir('Test output dir', 'default/path')
-
-    verify_parser_option_format('-o, --output-dir DIR', 'Test output dir (default: default/path)')
-
-    assert_equal 'default/path', @builder.options[:output_dir]
-
-    builder2 = EpubTools::CLI::OptionBuilder.new
-    builder2.with_output_dir('Test output dir')
-    verify_required_parser_format(builder2, 'Test output dir (required)')
-
-    @builder.parse(['-o', 'new/path'])
-
-    assert_equal 'new/path', @builder.options[:output_dir]
-  end
-
-  def test_with_output_file
-    @builder.with_output_file('Test output file')
-
-    assert_includes @builder.parser.to_s, '-o, --output-file FILE'
-    assert_includes @builder.parser.to_s, 'Test output file (required)'
-
-    @builder.parse(['-o', 'output.txt'])
-
-    assert_equal 'output.txt', @builder.options[:output_file]
-  end
-
-  def test_with_title_option
-    @builder.with_title_option
-
-    assert_includes @builder.parser.to_s, '-t, --title TITLE'
-    assert_includes @builder.parser.to_s, 'Book title (required)'
-
-    @builder.parse(['-t', 'Book Title'])
-
-    assert_equal 'Book Title', @builder.options[:title]
-  end
-
-  def test_with_author_option
-    @builder.with_author_option
-
-    assert_includes @builder.parser.to_s, '-a, --author AUTHOR'
-    assert_includes @builder.parser.to_s, 'Author name (required)'
-
-    @builder.parse(['-a', 'Author Name'])
-
-    assert_equal 'Author Name', @builder.options[:author]
-  end
-
-  def test_with_cover_option
-    @builder.with_cover_option
-
-    assert_includes @builder.parser.to_s, '-c, --cover PATH'
-    assert_includes @builder.parser.to_s, 'Cover image file path (optional)'
-
-    @builder.parse(['-c', 'cover.jpg'])
-
-    assert_equal 'cover.jpg', @builder.options[:cover_image]
-  end
-
-  def test_with_option
-    @builder.with_option('-x', '--extra VALUE', 'Extra option', :extra_option)
-
-    assert_includes @builder.parser.to_s, '-x, --extra VALUE'
-    assert_includes @builder.parser.to_s, 'Extra option'
-
-    @builder.parse(['-x', 'extra-value'])
-
-    assert_equal 'extra-value', @builder.options[:extra_option]
-  end
-
-  def test_with_custom_options
-    @builder.with_custom_options do |opts, options|
-      opts.on('-c', '--custom VALUE', 'Custom option') { |v| options[:custom] = v }
-    end
-
-    assert_includes @builder.parser.to_s, '-c, --custom VALUE'
-    assert_includes @builder.parser.to_s, 'Custom option'
-
-    @builder.parse(['-c', 'custom-value'])
-
-    assert_equal 'custom-value', @builder.options[:custom]
-  end
-
-  def test_parse_validates_required_keys
-    builder = EpubTools::CLI::OptionBuilder.new({}, [:required_option])
-    assert_output('', /Missing required options/) do
-      assert_raises(SystemExit) { builder.parse([]) }
-    end
-  end
-
-  def test_method_chaining
-    result = @builder.with_banner('Test')
-                     .with_verbose_option
-                     .with_title_option
-
-    assert_equal @builder, result
-  end
-
-  private
-
-  def verify_parser_option_format(option_format, description)
-    assert_includes @builder.parser.to_s, option_format
-    assert_includes @builder.parser.to_s, description
-  end
-
-  def verify_optional_parser_format(builder, description)
-    assert_includes builder.parser.to_s, description
-    refute_includes builder.parser.to_s, "#{description} (required)"
-  end
-
-  def verify_required_parser_format(builder, description)
-    assert_includes builder.parser.to_s, description
-  end
-end

data/test/cli/runner_test.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../test_helper'
-require_relative '../../lib/epub_tools'
-require 'stringio'
-
-class RunnerTest < Minitest::Test
-  class TestCommand
-    attr_reader :options, :run_called
-
-    def initialize(options)
-      @options = options
-      @run_called = false
-    end
-
-    def run
-      @run_called = true
-      puts 'Called!'
-      true
-    end
-  end
-
-  def setup
-    @runner = EpubTools::CLI::Runner.new('test-program')
-
-    # Register a test command
-    @runner.registry.register('test-cmd', TestCommand,
-                              [:required_option],
-                              { default_option: 'default' })
-  end
-
-  def test_initialize
-    assert_equal 'test-program', @runner.program_name
-    assert_kind_of EpubTools::CLI::CommandRegistry, @runner.registry
-  end
-
-  def test_handle_command
-    @runner.registry.register('add', TestCommand)
-
-    assert_output(/Usage: test-program add/) do
-      assert_raises(SystemExit) { @runner.handle_command('add', ['-h']) }
-    end
-  end
-
-  def test_handle_command_with_required_args
-    runner = EpubTools::CLI::Runner.new('test-program')
-    runner.registry.register('add', TestCommand)
-
-    assert_output("Called!\n") { assert runner.handle_command('add') }
-  end
-
-  def test_handle_nonexistent_command
-    result = @runner.handle_command('nonexistent')
-
-    refute result # Should return false for nonexistent command
-  end
-
-  def test_run_with_version_flag
-    assert_output(/^\d+\.\d+\.\d+$/) do
-      assert_raises(SystemExit) { @runner.run(['-v']) }
-    end
-  end
-
-  def test_run_with_no_args_shows_usage
-    assert_output(/Usage: test-program COMMAND \[options\]/) do
-      assert_raises(SystemExit) { @runner.run([]) }
-    end
-  end
-
-  def test_program_name_defaults_to_current_program
-    default_runner = EpubTools::CLI::Runner.new
-
-    assert_equal File.basename($PROGRAM_NAME), default_runner.program_name
-  end
-
-  def test_configure_command_options
-    # Test command configuration through public interface
-    @runner.registry.register('add', TestCommand)
-
-    # Should show help without errors
-    assert_output(/Usage: test-program add/) do
-      assert_raises(SystemExit) { @runner.handle_command('add', ['-h']) }
-    end
-  end
-
-  def test_run_with_unknown_command
-    assert_output(/Usage: test-program COMMAND \[options\]/) do
-      assert_raises(SystemExit) { @runner.run(['unknown-command']) }
-    end
-  end
-end

data/test/compile_workspace_test.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test_helper'
-require_relative '../lib/epub_tools/compile_workspace'
-
-class CompileWorkspaceTest < Minitest::Test
-  def setup
-    @tmp = Dir.mktmpdir
-    @workspace = EpubTools::CompileWorkspace.new(@tmp)
-  end
-
-  def teardown
-    FileUtils.rm_rf(@tmp)
-  end
-
-  def test_initialize_sets_build_dir
-    assert_equal @tmp, @workspace.build_dir
-  end
-
-  def test_prepare_directories_creates_required_dirs
-    @workspace.prepare_directories
-
-    assert Dir.exist?(@workspace.xhtml_dir)
-    assert Dir.exist?(@workspace.chapters_dir)
-  end
-
-  def test_directory_paths_are_correct
-    assert_equal File.join(@tmp, 'xhtml'), @workspace.xhtml_dir
-    assert_equal File.join(@tmp, 'chapters'), @workspace.chapters_dir
-    assert_equal File.join(@tmp, 'epub'), @workspace.epub_dir
-  end
-
-  def test_directory_paths_are_memoized
-    # First call creates the path
-    path1 = @workspace.xhtml_dir
-    # Second call should return the same object
-    path2 = @workspace.xhtml_dir
-
-    assert_equal path1, path2
-  end
-
-  def test_clean_removes_build_directory
-    # Create the directory and some content
-    FileUtils.mkdir_p(@tmp)
-    test_file = File.join(@tmp, 'test.txt')
-    File.write(test_file, 'test content')
-
-    assert Dir.exist?(@tmp)
-    assert_path_exists test_file
-
-    @workspace.clean
-
-    refute Dir.exist?(@tmp)
-  end
-end