epub_tools 0.4.1 → 0.5.0

data/lib/epub_tools/cli/runner.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require_relative 'command_registry'
 require_relative 'option_builder'
+require_relative 'command_options_configurator'
 
 module EpubTools
   module CLI
@@ -12,24 +15,15 @@ module EpubTools
       def initialize(program_name = nil)
         @registry = CommandRegistry.new
         @program_name = program_name || File.basename($PROGRAM_NAME)
+        @options_configurator = CommandOptionsConfigurator.new
       end
 
       # Run the CLI application
       # @param args [Array<String>] Command line arguments
       # @return [Boolean] true if the command was run successfully
       def run(args = ARGV)
-        # Handle global version flag
-        if ['-v', '--version'].include?(args[0])
-          puts EpubTools::VERSION
-          exit 0
-        end
-
-        commands = registry.available_commands
-
-        if args.empty? || !commands.include?(args[0])
-          print_usage(commands)
-          exit 1
-        end
+        handle_version_flag(args)
+        validate_command_args(args)
 
         cmd = args.shift
         handle_command(cmd, args)
@@ -43,6 +37,36 @@ module EpubTools
         command_config = registry.get(cmd)
         return false unless command_config
 
+        builder = build_option_parser(cmd, command_config)
+        execute_command(command_config, builder, args)
+      end
+
+      private
+
+      # Handle version flag and exit if present
+      # @param args [Array<String>] Command line arguments
+      def handle_version_flag(args)
+        return unless ['-v', '--version'].include?(args[0])
+
+        puts EpubTools::VERSION
+        exit 0
+      end
+
+      # Validate command arguments and exit if invalid
+      # @param args [Array<String>] Command line arguments
+      def validate_command_args(args)
+        commands = registry.available_commands
+        return unless args.empty? || !commands.include?(args[0])
+
+        print_usage(commands)
+        exit 1
+      end
+
+      # Build option parser for a command
+      # @param cmd [String] Command name
+      # @param command_config [Hash] Command configuration
+      # @return [OptionBuilder] Configured option builder
+      def build_option_parser(cmd, command_config)
         options = command_config[:default_options].dup
         required_keys = command_config[:required_keys]
 
@@ -50,114 +74,39 @@ module EpubTools
                                .with_banner("Usage: #{program_name} #{cmd} [options]")
                                .with_help_option
 
-        # Configure command-specific options
-        configure_command_options(cmd, builder)
+        @options_configurator.configure(cmd, builder)
+        builder
+      end
 
-        # Parse arguments and run the command
+      # Execute a command with parsed options
+      # @param command_config [Hash] Command configuration
+      # @param builder [OptionBuilder] Option builder instance
+      # @param args [Array<String>] Command line arguments
+      # @return [Object] Command instance
+      def execute_command(command_config, builder, args)
         options = builder.parse(args)
         command_class = command_config[:class]
-        command_class.new(options).run
-        true
+        command_instance = command_class.new(options)
+        command_instance.run
+        command_instance
       end
 
-      private
-
       # Print usage information
       # @param commands [Array<String>] Available commands
       def print_usage(_commands)
-        puts <<~USAGE
-          Usage: #{program_name} COMMAND [options]
-          Commands:
-            init      Initialize a bare-bones EPUB
-            extract   Extract XHTML files from EPUBs
-            split     Split XHTML into separate XHTMLs per chapter
-            add       Add chapter XHTML files into an EPUB
-            pack      Package an EPUB directory into a .epub file
-            unpack    Unpack an EPUB file into a directory
-            compile   Takes EPUBs in a dir and splits, cleans, and compiles into a single EPUB.
-        USAGE
+        puts "Usage: #{program_name} COMMAND [options]"
+        puts 'Commands:'
+        print_command_list
       end
 
-      # Configure command-specific options
-      # @param cmd [String] Command name
-      # @param builder [OptionBuilder] Option builder instance
-      def configure_command_options(cmd, builder)
-        case cmd
-        when 'add'
-          builder.with_custom_options do |opts, options|
-            opts.on('-c DIR', '--chapters-dir DIR', 'Chapters directory (required)') { |v| options[:chapters_dir] = v }
-            opts.on('-e DIR', '--oebps-dir DIR', 'EPUB OEBPS directory (required)') do |v|
-              options[:oebps_dir] = v
-            end
-          end
-
-        when 'extract'
-          builder.with_custom_options do |opts, options|
-            opts.on('-s DIR', '--source-dir DIR', 'Directory with EPUBs to extract XHTMLs from (required)') do |v|
-              options[:source_dir] = v
-            end
-            opts.on('-t DIR', '--target-dir DIR',
-                    'Directory where the XHTML files will be extracted to (required)') do |v|
-              options[:target_dir] = v
-            end
-          end
-          .with_verbose_option
-
-        when 'split'
-          builder.with_custom_options do |opts, options|
-            opts.on('-i FILE', '--input FILE', 'Source XHTML file (required)') { |v| options[:input_file] = v }
-            opts.on('-t TITLE', '--title TITLE', 'Book title for HTML <title> tags (required)') do |v|
-              options[:book_title] = v
-            end
-            opts.on('-o DIR', '--output-dir DIR',
-                    "Output directory for chapter files (default: #{options[:output_dir]})") do |v|
-              options[:output_dir] = v
-            end
-            opts.on('-p PREFIX', '--prefix PREFIX',
-                    "Filename prefix for chapters (default: #{options[:prefix]})") do |v|
-              options[:prefix] = v
-            end
-          end
-          .with_verbose_option
-
-        when 'init'
-          builder.with_title_option
-                 .with_author_option
-                 .with_custom_options do |opts, options|
-            opts.on('-o DIR', '--output-dir DIR', 'Destination EPUB directory (required)') do |v|
-              options[:destination] = v
-            end
-          end
-            .with_cover_option
-
-        when 'pack'
-          builder.with_input_dir('EPUB directory to package')
-                 .with_output_file('Output EPUB file path')
-                 .with_verbose_option
-
-        when 'unpack'
-          builder.with_custom_options do |opts, options|
-            opts.on('-i FILE', '--input-file FILE', 'EPUB file to unpack (required)') { |v| options[:epub_file] = v }
-            opts.on('-o DIR', '--output-dir DIR', 'Output directory to extract into (default: basename of epub)') do |v|
-              options[:output_dir] = v
-            end
-          end
-          .with_verbose_option
-
-        when 'compile'
-          builder.with_title_option
-                 .with_author_option
-                 .with_custom_options do |opts, options|
-            opts.on('-s DIR', '--source-dir DIR', 'Directory with EPUBs to extract XHTMLs from (required)') do |v|
-              options[:source_dir] = v
-            end
-            opts.on('-o FILE', '--output FILE', 'EPUB to create (default: book title in source dir)') do |v|
-              options[:output_file] = v
-            end
-          end
-            .with_cover_option
-            .with_verbose_option
-        end
+      def print_command_list
+        puts '  init      Initialize a bare-bones EPUB'
+        puts '  extract   Extract XHTML files from EPUBs'
+        puts '  split     Split XHTML into separate XHTMLs per chapter'
+        puts '  add       Add chapter XHTML files into an EPUB'
+        puts '  pack      Package an EPUB directory into a .epub file'
+        puts '  unpack    Unpack an EPUB file into a directory'
+        puts '  compile   Takes EPUBs in a dir and splits, cleans, and compiles into a single EPUB.'
       end
     end
   end

data/lib/epub_tools/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'cli/command_registry'
 require_relative 'cli/option_builder'
 require_relative 'cli/runner'
@@ -10,36 +12,21 @@ module EpubTools
     # @return [CLI::Runner] A configured runner instance
     def self.create_runner(program_name = nil)
       runner = Runner.new(program_name)
-
-      # Register all commands
-      runner.registry.register('add', EpubTools::AddChapters,
-                               %i[chapters_dir oebps_dir])
-
-      runner.registry.register('extract', EpubTools::XHTMLExtractor,
-                               %i[source_dir target_dir],
-                               { verbose: true })
-
-      runner.registry.register('split', EpubTools::SplitChapters,
-                               %i[input_file book_title],
-                               { output_dir: './chapters', prefix: 'chapter', verbose: true })
-
-      runner.registry.register('init', EpubTools::EpubInitializer,
-                               %i[title author destination],
-                               { verbose: true })
-
-      runner.registry.register('pack', EpubTools::PackEbook,
-                               %i[input_dir output_file],
-                               { verbose: true })
-
-      runner.registry.register('unpack', EpubTools::UnpackEbook,
-                               [:epub_file],
-                               { verbose: true })
-
-      runner.registry.register('compile', EpubTools::CompileBook,
-                               %i[title author source_dir],
-                               { verbose: true })
-
+      register_all_commands(runner.registry)
       runner
     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 })
+    end
   end
 end

data/lib/epub_tools/compile_book.rb

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 require 'fileutils'
 require_relative 'loggable'
 require_relative 'xhtml_extractor'
@@ -6,11 +8,14 @@ require_relative 'split_chapters'
 require_relative 'epub_initializer'
 require_relative 'add_chapters'
 require_relative 'pack_ebook'
+require_relative 'compile_workspace'
+require_relative 'chapter_validator'
 
 module EpubTools
   # Orchestrates extraction, splitting, validation, and packaging of book EPUBs
   class CompileBook
     include Loggable
+
     # Book title
     attr_reader :title
     # Book author
@@ -43,114 +48,92 @@ module EpubTools
       @output_file = options[:output_file] || default_output_file
       @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 compile workflow
     def run
-      clean_build_dir
-      prepare_dirs
+      setup_workspace
       extract_xhtmls
       split_xhtmls
-      validate_sequence
+      validate_chapters
       initialize_epub
       add_chapters
       pack_epub
-      log "Done. Output EPUB: #{File.expand_path(output_file)}"
-      clean_build_dir
+      finalize_and_cleanup
     end
 
     private
 
-    def default_output_file
-      "#{title.gsub(' ', '_')}.epub"
-    end
-
-    def clean_build_dir
-      log "Cleaning build directory #{build_dir}..."
-      FileUtils.rm_rf(build_dir)
-    end
-
-    def prepare_dirs
+    def setup_workspace
+      @workspace.clean
+      log "Cleaning build directory #{@build_dir}..."
+      @workspace.prepare_directories
       log 'Preparing build directories...'
-      FileUtils.mkdir_p(xhtml_dir)
-      FileUtils.mkdir_p(chapters_dir)
     end
 
-    def xhtml_dir
-      @xhtml_dir ||= File.join(build_dir, 'xhtml')
-    end
-
-    def chapters_dir
-      @chapters_dir ||= File.join(build_dir, 'chapters')
+    def finalize_and_cleanup
+      log "Done. Output EPUB: #{File.expand_path(output_file)}"
+      @workspace.clean
+      output_file
     end
 
-    def epub_dir
-      @epub_dir ||= File.join(build_dir, 'epub')
+    def default_output_file
+      "#{title.gsub(' ', '_')}.epub"
     end
 
     def extract_xhtmls
       log "Extracting XHTML files from epubs in '#{source_dir}'..."
       XHTMLExtractor.new({
                            source_dir: source_dir,
-                           target_dir: xhtml_dir,
+                           target_dir: @workspace.xhtml_dir,
                            verbose: verbose
                          }).run
     end
 
     def split_xhtmls
       log 'Splitting XHTML files into chapters...'
-      Dir.glob(File.join(xhtml_dir, '*.xhtml')).each do |xhtml_file|
-        base = File.basename(xhtml_file, '.xhtml')
-        log "Splitting '#{base}'..."
-        SplitChapters.new({
-                            input_file: xhtml_file,
-                            book_title: title,
-                            output_dir: chapters_dir,
-                            output_prefix: 'chapter',
-                            verbose: verbose
-                          }).run
+      Dir.glob(File.join(@workspace.xhtml_dir, '*.xhtml')).each do |xhtml_file|
+        split_xhtml_file(xhtml_file)
       end
     end
 
-    def validate_sequence
-      log 'Validating chapter sequence...'
-      nums = Dir.glob(File.join(chapters_dir, '*.xhtml')).map do |file|
-        if (m = File.basename(file, '.xhtml').match(/_(\d+)\z/))
-          m[1].to_i
-        end
-      end.compact
-      raise "No chapter files found in #{chapters_dir}" if nums.empty?
+    def split_xhtml_file(xhtml_file)
+      base = File.basename(xhtml_file, '.xhtml')
+      log "Splitting '#{base}'..."
+      SplitChapters.new(build_split_options(xhtml_file)).run
+    end
 
-      sorted = nums.sort.uniq
-      missing = (sorted.first..sorted.last).to_a - sorted
-      raise "Missing chapter numbers: #{missing.join(' ')}" if missing.any?
+    def build_split_options(xhtml_file)
+      {
+        input_file: xhtml_file,
+        book_title: title,
+        output_dir: @workspace.chapters_dir,
+        output_prefix: 'chapter',
+        verbose: verbose
+      }
+    end
 
-      log "Chapter sequence is complete: #{sorted.first} to #{sorted.last}."
+    def validate_chapters
+      ChapterValidator.new(chapters_dir: @workspace.chapters_dir, verbose: verbose).validate
     end
 
     def initialize_epub
       log 'Initializing new EPUB...'
-      if cover_image
-        EpubInitializer.new({
-                              title: title,
-                              author: author,
-                              destination: epub_dir,
-                              cover_image: cover_image
-                            }).run
-      else
-        EpubInitializer.new({
-                              title: title,
-                              author: author,
-                              destination: epub_dir
-                            }).run
-      end
+      EpubInitializer.new(build_epub_options).run
+    end
+
+    def build_epub_options
+      options = { title: title, author: author, destination: @workspace.epub_dir }
+      options[:cover_image] = cover_image if cover_image
+      options
     end
 
     def add_chapters
       log 'Adding chapters to EPUB...'
       AddChapters.new({
-                        chapters_dir: chapters_dir,
-                        epub_dir: File.join(epub_dir, 'OEBPS'),
+                        chapters_dir: @workspace.chapters_dir,
+                        epub_dir: File.join(@workspace.epub_dir, 'OEBPS'),
                         verbose: verbose
                       }).run
     end
@@ -158,7 +141,7 @@ module EpubTools
     def pack_epub
       log "Building final EPUB '#{output_file}'..."
       PackEbook.new({
-                      input_dir: epub_dir,
+                      input_dir: @workspace.epub_dir,
                       output_file: output_file,
                       verbose: verbose
                     }).run

data/lib/epub_tools/compile_workspace.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module EpubTools
+  # Manages the build workspace for book compilation
+  class CompileWorkspace
+    attr_reader :build_dir
+
+    def initialize(build_dir)
+      @build_dir = build_dir
+    end
+
+    # Cleans the build directory
+    def clean
+      FileUtils.rm_rf(@build_dir)
+    end
+
+    # Prepares all necessary directories
+    def prepare_directories
+      FileUtils.mkdir_p(xhtml_dir)
+      FileUtils.mkdir_p(chapters_dir)
+    end
+
+    # Gets the XHTML extraction directory
+    def xhtml_dir
+      @xhtml_dir ||= File.join(@build_dir, 'xhtml')
+    end
+
+    # Gets the chapters directory
+    def chapters_dir
+      @chapters_dir ||= File.join(@build_dir, 'chapters')
+    end
+
+    # Gets the EPUB build directory
+    def epub_dir
+      @epub_dir ||= File.join(@build_dir, 'epub')
+    end
+  end
+end

data/lib/epub_tools/epub_configuration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'time'
+
+module EpubTools
+  # Handles configuration parsing and setup for EPUB initialization
+  class EpubConfiguration
+    attr_reader :title, :author, :destination, :uuid, :modified,
+                :cover_image_path, :cover_image_fname, :cover_image_media_type, :verbose
+
+    def initialize(options = {})
+      @title = options.fetch(:title)
+      @author = options.fetch(:author)
+      @destination = File.expand_path(options.fetch(:destination))
+      @uuid = "urn:uuid:#{SecureRandom.uuid}"
+      @modified = Time.now.utc.iso8601
+      @cover_image_path = options[:cover_image]
+      @cover_image_fname = nil
+      @cover_image_media_type = nil
+      @verbose = options[:verbose] || false
+    end
+
+    def cover_image?
+      !@cover_image_path.nil?
+    end
+
+    def update_cover_info(fname, media_type)
+      @cover_image_fname = fname
+      @cover_image_media_type = media_type
+    end
+  end
+end

data/lib/epub_tools/epub_file_writer.rb

@@ -0,0 +1,57 @@
+# 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