epub_tools 0.3.1 → 0.4.1

data/lib/epub_tools/pack_ebook.rb

@@ -1,21 +1,27 @@
 require 'zip'
 require 'fileutils'
 require 'pathname'
+require_relative 'loggable'
 
 module EpubTools
   # Packages an EPUB directory into a .epub file
   class PackEbook
-    # [input_dir] Path to the EPUB directory (containing mimetype, META-INF, OEBPS)
-    # [output_file] Path to resulting .epub file; if +nil+, defaults to <tt><input_dir>.epub</tt>
-    def initialize(input_dir, output_file = nil, verbose: false)
-      @input_dir = File.expand_path(input_dir)
+    include Loggable
+    # Initializes the class
+    # @param options [Hash] Configuration options
+    # @option options [String] :input_dir Path to the EPUB directory (containing mimetype, META-INF, OEBPS) (required)
+    # @option options [String] :output_file Path to resulting .epub file (default: <input_dir>.epub)
+    # @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
-      @verbose = verbose
+      @verbose = options[:verbose] || false
     end
 
     # Runs the packaging process and returns the resulting file path
@@ -33,24 +39,24 @@ module EpubTools
           Dir.glob('**/*', File::FNM_DOTMATCH).sort.each do |entry|
             next if ['.', '..', 'mimetype'].include?(entry)
             next if File.directory?(entry)
+
             zip.add(entry, entry)
           end
         end
       end
-      puts "EPUB created: #{@output_file}" if @verbose
+      log "EPUB created: #{@output_file}"
       @output_file
     end
 
     private
 
     def validate_input!
-      unless Dir.exist?(@input_dir)
-        raise ArgumentError, "Directory '#{@input_dir}' does not exist."
-      end
+      raise ArgumentError, "Directory '#{@input_dir}' does not exist." unless Dir.exist?(@input_dir)
+
       mimetype = File.join(@input_dir, 'mimetype')
-      unless File.file?(mimetype)
-        raise ArgumentError, "Error: 'mimetype' file missing in #{@input_dir}"
-      end
+      return if File.file?(mimetype)
+
+      raise ArgumentError, "Error: 'mimetype' file missing in #{@input_dir}"
     end
 
     def add_mimetype(zip)

data/lib/epub_tools/split_chapters.rb

@@ -1,42 +1,48 @@
 #!/usr/bin/env ruby
 require 'nokogiri'
 require 'yaml'
-require_relative 'text_style_class_finder'
+require 'fileutils'
+require_relative 'loggable'
+require_relative 'style_finder'
 require_relative 'xhtml_cleaner'
 
 module EpubTools
   # Takes a Google Docs generated, already extracted from their EPUB, XHTML files with multiple
   # chapters and it:
-  # - Extracts classes using {TextStyleClassFinder}[rdoc-ref:EpubTools::TextStyleClassFinder]
+  # - Extracts classes using {StyleFinder}[rdoc-ref:EpubTools::StyleFinder]
   # - Looks for tags that say something like Chapter XX or Prologue and splits the text there
   # - Creates new chapter_XX.xhtml files that are cleaned using
   #   {XHTMLCleaner}[rdoc-ref:EpubTools::XHTMLCleaner]
   # - Saves those files to +output_dir+
   class SplitChapters
-    # [input_file] path to the source XHTML
-    # [book_title] title to use in HTML <title> tags
-    # [output_dir] where to write chapter files
-    # [output_prefix] filename prefix. Defaults to 'chapter' and you should never need to change it
-    # [verbose] whether to print progress to STDOUT.
-    def initialize(input_file, book_title, output_dir = './chapters', output_prefix = 'chapter', verbose = false)
-      @input_file    = input_file
-      @book_title    = book_title
-      @output_dir    = output_dir
-      @output_prefix = output_prefix
-      @verbose       = verbose
+    include Loggable
+    # Initializes the class
+    # @param options [Hash] Configuration options
+    # @option options [String] :input_file Path to the source XHTML (required)
+    # @option options [String] :book_title Title to use in HTML <title> tags (required)
+    # @option options [String] :output_dir Where to write chapter files (default: './chapters')
+    # @option options [String] :output_prefix Filename prefix for chapter files (default: 'chapter')
+    # @option options [Boolean] :verbose Whether to print progress to STDOUT (default: false)
+    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
     end
 
     # Runs the splitter
+    # @return [Array<String>] List of generated chapter file paths
     def run
       # Prepare output dir
-      Dir.mkdir(@output_dir) unless Dir.exist?(@output_dir)
+      FileUtils.mkdir_p(@output_dir)
 
       # Read the doc
       raw_content = read_and_strip_problematic_tags
       doc = Nokogiri::HTML(raw_content)
 
       # Find Style Classes
-      TextStyleClassFinder.new(@input_file, verbose: @verbose).call
+      StyleFinder.new({ file_path: @input_file, verbose: @verbose }).run
 
       chapters = extract_chapters(doc)
       write_chapter_files(chapters)
@@ -45,7 +51,7 @@ module EpubTools
     private
 
     def read_and_strip_problematic_tags
-      File.read(@input_file).gsub(/<hr\b[^>]*\/?>/i, '').gsub(/<br\b[^>]*\/?>/i, '')
+      File.read(@input_file).gsub(%r{<hr\b[^>]*/?>}i, '').gsub(%r{<br\b[^>]*/?>}i, '')
     end
 
     def extract_chapters(doc)
@@ -74,9 +80,12 @@ module EpubTools
     end
 
     def write_chapter_files(chapters)
+      chapter_files = []
       chapters.each do |number, content|
-        write_chapter_file(number, content)
+        filename = write_chapter_file(number, content)
+        chapter_files << filename
       end
+      chapter_files
     end
 
     def write_chapter_file(label, content)
@@ -95,20 +104,21 @@ module EpubTools
           </body>
         </html>
       HTML
-      XHTMLCleaner.new(filename).call
-      puts "Extracted: #{filename}" if @verbose
+      XHTMLCleaner.new({ filename: filename }).run
+      log("Extracted: #{filename}")
+      filename
     end
 
     def display_label(label)
-      label > 0 ? "Chapter #{label}" : "Prologue"
+      label.positive? ? "Chapter #{label}" : 'Prologue'
     end
 
     # Detect a bolded Prologue marker
     def prologue_marker?(node)
       return false unless %w[h3 h4].include?(node.name)
       return false unless node.text.strip =~ /\APrologue\z/i
+
       true
     end
-
   end
 end

data/lib/epub_tools/{text_style_class_finder.rb → style_finder.rb}

@@ -1,24 +1,29 @@
 #!/usr/bin/env ruby
 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].
-  class TextStyleClassFinder
-    # [file_path] XHTML file to be analyzed.
-    # [output_path] Defaults to +text_style_classes.yaml+. You should never need to change this.
-    # [verbose] Whether to print progress or not
-    def initialize(file_path, output_path = 'text_style_classes.yaml', verbose: false)
-      @file_path = file_path
-      @output_path = output_path
-      @verbose = verbose
+  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
-    def call
+    # @return [Hash] Data containing the extracted style classes (italics and bolds)
+    def run
       doc = Nokogiri::HTML(File.read(@file_path))
       style_blocks = doc.xpath('//style').map(&:text).join("\n")
 
@@ -28,10 +33,11 @@ module EpubTools
       print_summary(italics, bolds) if @verbose
 
       data = {
-        "italics" => italics,
-        "bolds"   => bolds
+        'italics' => italics,
+        'bolds' => bolds
       }
       File.write(@output_path, data.to_yaml)
+      data
     end
 
     private
@@ -42,13 +48,11 @@ module EpubTools
     end
 
     def print_summary(italics, bolds)
-      unless italics.empty?
-        puts "Classes with font-style: italic: #{italics.join(", ")}"
-      end
+      log "Classes with font-style: italic: #{italics.join(', ')}" unless italics.empty?
 
-      unless bolds.empty?
-        puts "Classes with font-weight: 700: #{bolds.join(", ")}"
-      end
+      return if bolds.empty?
+
+      log "Classes with font-weight: 700: #{bolds.join(', ')}"
     end
   end
 end

data/lib/epub_tools/unpack_ebook.rb

@@ -1,16 +1,21 @@
 require 'zip'
 require 'fileutils'
+require_relative 'loggable'
 
 module EpubTools
   # Unpacks an EPUB (.epub file) into a directory
   class UnpackEbook
-    # [epub_file] path to the .epub file
-    # [output_dir] Directory to extract into; defaults to basename of epub_file without .epub
-    # [verbose] Whether to log things to $stdout while the class runs or not
-    def initialize(epub_file, output_dir = nil, verbose: false)
-      @epub_file = File.expand_path(epub_file)
-      @output_dir = (output_dir.nil? || output_dir.empty?) ? default_dir: output_dir
-      @verbose = verbose
+    include Loggable
+    # Initializes the class
+    # @param options [Hash] Configuration options
+    # @option options [String] :epub_file Path to the .epub file to unpack (required)
+    # @option options [String] :output_dir Directory to extract into (default: basename of epub_file without .epub)
+    # @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
+      @verbose = options[:verbose] || false
     end
 
     # Extracts all entries from the EPUB into the output directory. Returns the output
@@ -29,20 +34,20 @@ module EpubTools
           end
         end
       end
-      puts "Unpacked #{File.basename(@epub_file)} to #{@output_dir}" if @verbose
+      log "Unpacked #{File.basename(@epub_file)} to #{@output_dir}"
       @output_dir
     end
 
     private
 
     def default_dir
-      [File.dirname(@epub_file), File.basename(@epub_file, '.epub')].join("/")
+      [File.dirname(@epub_file), File.basename(@epub_file, '.epub')].join('/')
     end
 
     def validate!
-      unless File.file?(@epub_file)
-        raise ArgumentError, "EPUB file '#{@epub_file}' does not exist"
-      end
+      return if File.file?(@epub_file)
+
+      raise ArgumentError, "EPUB file '#{@epub_file}' does not exist"
     end
   end
 end

data/lib/epub_tools/version.rb

@@ -1,4 +1,4 @@
 module EpubTools
   # Ruby Gem version number
-  VERSION = '0.3.1'
+  VERSION = '0.4.1'.freeze
 end

data/lib/epub_tools/xhtml_cleaner.rb

@@ -16,17 +16,20 @@ module EpubTools
   # - Unwraps any <tt><span></tt> tags that have no classes assigned.
   # - Outputs everything to a cleanly formatted +.xhtml+
   class XHTMLCleaner
-    # [filename] The path to the xhtml to clean
-    # [class_config] A YAML containing the bold and italic classes to check. It defaults to
-    #                +text_style_classes.yaml+ since that's the one that
-    #                {TextStyleClassFinder}[rdoc-ref:EpubTools::TextStyleClassFinder] uses.
-    def initialize(filename, class_config = 'text_style_classes.yaml')
-      @filename = filename
+    # 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')
+    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)
     end
 
-    # Calls the service class
-    def call
+    # Runs the cleaner
+    # @return [String] Path to the cleaned file
+    def run
       raw_content = read_and_strip_problematic_hr
       doc = parse_xml(raw_content)
       remove_empty_paragraphs(doc)
@@ -34,24 +37,25 @@ module EpubTools
       replace_italic_spans(doc)
       unwrap_remaining_spans(doc)
       write_pretty_output(doc)
+      @filename
     end
 
     private
 
     def read_and_strip_problematic_hr
-      File.read(@filename).gsub(/<hr\b[^>]*\/?>/i, '').gsub(/<br\b[^>]*\/?>/i, '')
+      File.read(@filename).gsub(%r{<hr\b[^>]*/?>}i, '').gsub(%r{<br\b[^>]*/?>}i, '')
     end
 
     def parse_xml(content)
       Nokogiri::XML(content) { |config| config.default_xml.noblanks }
-    rescue => e
+    rescue StandardError => e
       abort "Error parsing XML: #{e.message}"
     end
 
     def remove_empty_paragraphs(doc)
       doc.css('p').each do |p|
         content = p.inner_html.strip
-        if content.empty? || content =~ /\A(<span[^>]*>\s*<\/span>\s*)+\z/
+        if content.empty? || content =~ %r{\A(<span[^>]*>\s*</span>\s*)+\z}
           p.remove
         else
           p.remove_attribute('class')
@@ -70,14 +74,14 @@ module EpubTools
     def replace_italic_spans(doc)
       @classes[:italics].each do |class_name|
         doc.css("span.#{class_name}").each do |node|
-          node.name = "i"
+          node.name = 'i'
           node.remove_attribute('class')
         end
       end
     end
 
     def unwrap_remaining_spans(doc)
-      doc.css("span").each do |span|
+      doc.css('span').each do |span|
         span.add_next_sibling(span.dup.content)
         span.remove
       end

data/lib/epub_tools/xhtml_extractor.rb

@@ -1,24 +1,32 @@
 require 'zip'
 require 'fileutils'
+require_relative 'loggable'
 
 module EpubTools
   # Extracts text .xhtml files from EPUB archives, excluding nav.xhtml
   class XHTMLExtractor
-    # [source_dir] Directory that has source .epub files
-    # [target_dir] Directory where the extracted .xhtml files will be copied to
-    # [verbose] Whether to print progress to +STDOUT+ or not
-    def initialize(source_dir:, target_dir:, verbose: false)
-      @source_dir = File.expand_path(source_dir)
-      @target_dir = File.expand_path(target_dir)
-      @verbose = verbose
+    include Loggable
+    # Initializes the class
+    # @param options [Hash] Configuration options
+    # @option options [String] :source_dir Directory containing source .epub files (required)
+    # @option options [String] :target_dir Directory where .xhtml files will be extracted (required)
+    # @option options [Boolean] :verbose Whether to print progress to STDOUT (default: false)
+    def initialize(options = {})
+      @source_dir = File.expand_path(options.fetch(:source_dir))
+      @target_dir = File.expand_path(options.fetch(:target_dir))
+      @verbose = options[:verbose] || false
       FileUtils.mkdir_p(@target_dir)
     end
 
     # Runs the extraction process
-    def extract_all
+    # @return [Array<String>] Paths to all extracted XHTML files
+    def run
+      all_extracted_files = []
       epub_files.each do |epub_path|
-        extract_xhtmls_from(epub_path)
+        extracted = extract_xhtmls_from(epub_path)
+        all_extracted_files.concat(extracted) if extracted
       end
+      all_extracted_files
     end
 
     private
@@ -29,16 +37,17 @@ module EpubTools
 
     def extract_xhtmls_from(epub_path)
       epub_name = File.basename(epub_path, '.epub')
-      puts "Extracting from #{epub_name}.epub" if @verbose
+      log "Extracting from #{epub_name}.epub"
       extracted_files = []
       Zip::File.open(epub_path) do |zip_file|
         zip_file.each do |entry|
           next unless entry.name.downcase.end_with?('.xhtml')
           next if File.basename(entry.name).downcase == 'nav.xhtml'
+
           output_path = File.join(@target_dir, "#{epub_name}_#{File.basename(entry.name)}")
           FileUtils.mkdir_p(File.dirname(output_path))
           entry.extract(output_path) { true }
-          puts output_path if @verbose
+          log output_path
           extracted_files << output_path
         end
       end

data/lib/epub_tools.rb

@@ -1,6 +1,6 @@
 require_relative 'epub_tools/version'
+require_relative 'epub_tools/loggable'
 require_relative 'epub_tools/add_chapters'
-require_relative 'epub_tools/cli_helper'
 require_relative 'epub_tools/epub_initializer'
 require_relative 'epub_tools/split_chapters'
 require_relative 'epub_tools/xhtml_cleaner'
@@ -8,6 +8,7 @@ require_relative 'epub_tools/xhtml_extractor'
 require_relative 'epub_tools/pack_ebook'
 require_relative 'epub_tools/unpack_ebook'
 require_relative 'epub_tools/compile_book'
+require_relative 'epub_tools/cli'
 
 # Wrapper for all the other classes
 module EpubTools

data/test/add_chapters_test.rb

@@ -54,12 +54,18 @@ class AddChaptersTest < Minitest::Test
 
   def test_run_moves_files_and_updates_opf_and_nav
     # Run the add chapters task
-    EpubTools::AddChapters.new(@chapters_dir, @epub_dir).run
+    result = EpubTools::AddChapters.new(chapters_dir: @chapters_dir, oebps_dir: @epub_dir).run
+
+    # Check return value is an array of moved file basenames
+    assert_instance_of Array, result
+    assert_equal 2, result.size
+    assert_includes result, 'chapter_0.xhtml'
+    assert_includes result, 'chapter_1.xhtml'
 
     # Original chapter files should be moved
     assert_empty Dir.glob(File.join(@chapters_dir, '*.xhtml'))
-    assert File.exist?(File.join(@epub_dir, 'chapter_0.xhtml'))
-    assert File.exist?(File.join(@epub_dir, 'chapter_1.xhtml'))
+    assert_path_exists File.join(@epub_dir, 'chapter_0.xhtml')
+    assert_path_exists File.join(@epub_dir, 'chapter_1.xhtml')
 
     # package.opf should include manifest items and spine refs
     doc = Nokogiri::XML(File.read(@opf_file)) { |cfg| cfg.default_xml.noblanks }
@@ -81,12 +87,13 @@ class AddChaptersTest < Minitest::Test
     # strip namespaces for easy querying
     nav_doc.remove_namespaces!
     links = nav_doc.xpath('//nav/ol/li/a')
+
     assert_equal 2, links.size
     # First is Prologue (chapter_0)
     assert_equal 'chapter_0.xhtml', links[0]['href']
-    assert_equal 'Prologue',          links[0].text
+    assert_equal 'Prologue', links[0].text
     # Second is Chapter 1
     assert_equal 'chapter_1.xhtml', links[1]['href']
-    assert_equal 'Chapter 1',         links[1].text
+    assert_equal 'Chapter 1', links[1].text
   end
 end

data/test/cli/command_registry_test.rb

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