epub_tools 0.3.0 → 0.4.0

data/lib/epub_tools/loggable.rb

@@ -0,0 +1,11 @@
+module EpubTools
+  # Provides logging capability to classes that include it
+  module Loggable
+    # Logs a message if verbose mode is enabled
+    # @param message [String] The message to log
+    # @return [nil]
+    def log(message)
+      puts message if @verbose
+    end
+  end
+end

data/lib/epub_tools/pack_ebook.rb

@@ -1,24 +1,30 @@
 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 <input_dir>.epub
-    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
 
-    # Run the packaging process
+    # Runs the packaging process and returns the resulting file path
     def run
       validate_input!
       Dir.chdir(@input_dir) do
@@ -33,23 +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,33 +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 {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 (e.g. "chapter")
-    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_hr
+      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)
@@ -35,8 +50,8 @@ module EpubTools
 
     private
 
-    def read_and_strip_problematic_hr
-      File.read(@input_file).gsub(/<hr\b[^>]*\/?>/i, '').gsub(/<br\b[^>]*\/?>/i, '')
+    def read_and_strip_problematic_tags
+      File.read(@input_file).gsub(%r{<hr\b[^>]*/?>}i, '').gsub(%r{<br\b[^>]*/?>}i, '')
     end
 
     def extract_chapters(doc)
@@ -65,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)
@@ -86,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/style_finder.rb

@@ -0,0 +1,58 @@
+#!/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 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)
+    def run
+      doc = Nokogiri::HTML(File.read(@file_path))
+      style_blocks = doc.xpath('//style').map(&:text).join("\n")
+
+      italics = extract_classes(style_blocks, /font-style\s*:\s*italic/)
+      bolds   = extract_classes(style_blocks, /font-weight\s*:\s*700/)
+
+      print_summary(italics, bolds) if @verbose
+
+      data = {
+        'italics' => italics,
+        'bolds' => bolds
+      }
+      File.write(@output_path, data.to_yaml)
+      data
+    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(', ')}"
+    end
+  end
+end

data/lib/epub_tools/unpack_ebook.rb

@@ -1,23 +1,25 @@
 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
-    def initialize(epub_file, output_dir = nil, verbose: false)
-      @epub_file = File.expand_path(epub_file)
-      default_dir = [File.dirname(@epub_file), File.basename(@epub_file, '.epub')].join("/")
-      @output_dir = if output_dir.nil? || output_dir.empty?
-                      default_dir
-                    else
-                      output_dir
-                    end
-      @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
+    # Extracts all entries from the EPUB into the output directory. Returns the output
+    # directory.
     def run
       validate!
       FileUtils.mkdir_p(@output_dir)
@@ -32,15 +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('/')
+    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,3 +1,4 @@
 module EpubTools
-  VERSION = '0.3.0'
+  # Ruby Gem version number
+  VERSION = '0.4.0'.freeze
 end

data/lib/epub_tools/xhtml_cleaner.rb

@@ -4,13 +4,32 @@ require 'nokogiri'
 require 'yaml'
 
 module EpubTools
+  # Cleans Google Docs XHTMLs
+
+  # Google Docs makes a mess out of EPUBs and creates html without proper tag names and just uses
+  # classes for _everything_. This class does the following to clean invalid xhtml:
+  #
+  # - 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
+  #   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+
   class XHTMLCleaner
-    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
 
-    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)
@@ -18,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')
@@ -54,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,20 +1,32 @@
 require 'zip'
 require 'fileutils'
+require_relative 'loggable'
 
 module EpubTools
-  # Extracts .xhtml files from EPUB archives, excluding nav.xhtml
+  # Extracts text .xhtml files from EPUB archives, excluding nav.xhtml
   class XHTMLExtractor
-    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
 
-    def extract_all
+    # Runs the extraction process
+    # @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
@@ -25,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
@@ -43,4 +56,4 @@ module EpubTools
       warn "⚠️ Failed to process #{epub_path}: #{e.message}"
     end
   end
-end
+end

data/lib/epub_tools.rb

@@ -1,6 +1,6 @@
 require_relative 'epub_tools/version'
-require_relative 'epub_tools/add_chapters_to_epub'
-require_relative 'epub_tools/cli_helper'
+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/xhtml_cleaner'
@@ -8,6 +8,8 @@ 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
 end

data/test/{add_chapters_to_epub_test.rb → add_chapters_test.rb}

@@ -1,8 +1,8 @@
 require_relative 'test_helper'
-require_relative '../lib/epub_tools/add_chapters_to_epub'
+require_relative '../lib/epub_tools/add_chapters'
 require 'nokogiri'
 
-class AddChaptersToEpubTest < Minitest::Test
+class AddChaptersTest < Minitest::Test
   def setup
     @tmp = Dir.mktmpdir
     # Directories for chapters and EPUB OEBPS
@@ -54,12 +54,18 @@ class AddChaptersToEpubTest < Minitest::Test
 
   def test_run_moves_files_and_updates_opf_and_nav
     # Run the add chapters task
-    EpubTools::AddChaptersToEpub.new(@chapters_dir, @epub_dir).run
+    result = EpubTools::AddChapters.new(chapters_dir: @chapters_dir, epub_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 AddChaptersToEpubTest < 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