epuber 0.9.4 → 0.10.0

data/lib/epuber/from_file/from_file_executor.rb

@@ -21,7 +21,7 @@ module Epuber
     end
 
     def run
-      UI.puts "📖 Loading EPUB file #{@filepath}"
+      UI.info "📖 Loading EPUB file #{@filepath}"
 
       Zip::File.open(@filepath) do |zip_file|
         @zip_file = zip_file
@@ -29,22 +29,22 @@ module Epuber
         validate_mimetype
 
         @opf_path = content_opf_path
-        UI.puts "  Parsing OPF file at #{@opf_path}"
+        UI.info "  Parsing OPF file at #{@opf_path}"
         @opf = OpfFile.new(zip_file.read(@opf_path))
 
         if zip_file.find_entry(ENCRYPTION_PATH)
-          UI.puts '  Parsing encryption.xml file'
+          UI.info '  Parsing encryption.xml file'
           @encryption_handler = EncryptionHandler.new(zip_file.read(ENCRYPTION_PATH), @opf)
         end
 
-        UI.puts '  Generating bookspec file'
+        UI.info '  Generating bookspec file'
         basename = File.basename(@filepath, File.extname(@filepath))
         File.write("#{basename}.bookspec", generate_bookspec)
 
         export_files
 
-        UI.puts '' # empty line
-        UI.puts <<~TEXT.rstrip.ansi.green
+        UI.info '' # empty line
+        UI.info <<~TEXT.rstrip.ansi.green
           🎉 Project initialized.
           Please review generated #{basename}.bookspec file and start using Epuber.
 
@@ -112,13 +112,13 @@ module Epuber
         extension = File.extname(item.href).downcase
         if text_file_extensions.include?(extension) &&
            @opf.spine_items.none? { |spine_item| spine_item.idref == item.id }
-          UI.puts "  Skipping #{item.href} (not in spine)"
+          UI.info "  Skipping #{item.href} (not in spine)"
           next
         end
 
         # ignore ncx file
         if item.media_type == 'application/x-dtbncx+xml'
-          UI.puts "  Skipping #{item.href} (ncx file)"
+          UI.info "  Skipping #{item.href} (ncx file)"
           next
         end
 
@@ -127,7 +127,7 @@ module Epuber
                             .join(item.href)
                             .to_s
 
-        UI.puts "  Exporting #{item.href} (from #{full_path})"
+        UI.info "  Exporting #{item.href} (from #{full_path})"
 
         contents = @zip_file.read(full_path)
         contents = @encryption_handler.process_file(full_path, contents) if @encryption_handler

data/lib/epuber/plugin.rb

@@ -12,7 +12,7 @@ module Epuber
       #
       attr_reader :instances
 
-      # @param [String] file_path path to plugin file
+      # @param [String] relative_path path to plugin file (relative to project root)
       #
       def initialize(file_path)
         super(file_path)

data/lib/epuber/server.rb

@@ -116,7 +116,7 @@ module Epuber
 
       super() do |server|
         $stderr = old_stderr
-        UI.puts "Started development server on #{server.host}:#{server.port}"
+        UI.info "Started development server on #{server.host}:#{server.port}"
 
         host = if server.host == '0.0.0.0'
                  'localhost'
@@ -187,13 +187,13 @@ module Epuber
     def self._log(level, message)
       case level
       when :ui
-        UI.puts message
+        UI.info message
       when :info
-        UI.puts "INFO: #{message}" if verbose
+        UI.info "INFO: #{message}" if verbose
       when :get
-        UI.puts " GET: #{message}" if verbose
+        UI.info " GET: #{message}" if verbose
       when :ws
-        UI.puts "  WS: #{message}" if verbose
+        UI.info "  WS: #{message}" if verbose
       else
         raise "Unknown log level #{level}"
       end

data/lib/epuber/transformer/book_transformer.rb

@@ -29,21 +29,27 @@ module Epuber
       # Find file in source or destination paths
       #
       # @param [String] pattern
+      # @param [String] context_path path to directory that is used as context for finding
+      # @param [Array<Symbol>, Symbol] groups
       # @param [Thread::Backtrace::Location] location
       #
       # @return [Epuber::Compiler::FileTypes::AbstractFile, nil]
       #
-      def find_file(pattern, location: caller_locations.first)
+      def find_file(pattern, context_path: nil, groups: nil, location: caller_locations.first)
         return pattern if pattern.is_a?(Compiler::FileTypes::AbstractFile)
 
         UI.error!("Pattern for finding file can't be nil", location: location) if pattern.nil?
 
         begin
-          path = @compilation_context.file_resolver.source_finder.find_file(pattern)
+          path = @compilation_context.file_resolver.source_finder.find_file(pattern, context_path: context_path,
+                                                                                     groups: groups)
+          path = File.join(context_path, path) if context_path
           @compilation_context.file_resolver.file_with_source_path(path)
         rescue Compiler::FileFinders::FileNotFoundError
           begin
-            path = @compilation_context.file_resolver.dest_finder.find_file(pattern)
+            path = @compilation_context.file_resolver.dest_finder.find_file(pattern, context_path: context_path,
+                                                                                     groups: groups)
+            path = File.join(context_path, path) if context_path
             @compilation_context.file_resolver.file_with_destination_path(path)
           rescue Compiler::FileFinders::FileNotFoundError
             nil
@@ -54,27 +60,35 @@ module Epuber
       # Find files destination paths
       #
       # @param [String] pattern
+      # @param [String] context_path path to directory that is used as context for finding
+      # @param [Array<Symbol>, Symbol] groups
       # @param [Thread::Backtrace::Location] location
       #
       # @return [Array<Epuber::Compiler::FileTypes::AbstractFile>]
       #
-      def find_destination_files(pattern, location: caller_locations.first)
+      def find_destination_files(pattern, context_path: nil, groups: nil, location: caller_locations.first)
         UI.error!("Pattern for finding file can't be nil", location: location) if pattern.nil?
 
-        paths = @compilation_context.file_resolver.dest_finder.find_files(pattern)
+        paths = @compilation_context.file_resolver.dest_finder.find_files(pattern, context_path: context_path,
+                                                                                   groups: groups)
         paths.map { |path| @compilation_context.file_resolver.file_with_destination_path(path) }
       end
 
       # Find file and raise exception if not found
       #
       # @param [String] pattern
+      # @param [String] context_path path to directory that is used as context for finding
+      # @param [Array<Symbol>, Symbol] groups
       # @param [Thread::Backtrace::Location] location
       #
       # @return [Epuber::Compiler::FileTypes::AbstractFile]
       #
-      def get_file(pattern, location: caller_locations.first)
-        file = find_file(pattern, location: location)
-        UI.error!("File with pattern #{pattern} not found", location: location) unless file
+      def get_file(pattern, context_path: nil, groups: nil, location: caller_locations.first)
+        file = find_file(pattern, context_path: context_path, groups: groups, location: location)
+        unless file
+          UI.error!("File with pattern #{pattern} not found (context path: #{context_path || 'nil'})",
+                    location: location)
+        end
 
         file
       end
@@ -82,12 +96,14 @@ module Epuber
       # Read file from destination path (raises exception if not found)
       #
       # @param [String] pattern
+      # @param [String] context_path path to directory that is used as context for finding
+      # @param [Array<Symbol>, Symbol] groups
       # @param [Thread::Backtrace::Location] location
       #
       # @return [String]
       #
-      def read_destination_file(pattern, location: caller_locations.first)
-        file = get_file(pattern, location: location)
+      def read_destination_file(pattern, context_path: nil, groups: nil, location: caller_locations.first)
+        file = get_file(pattern, context_path: context_path, groups: groups, location: location)
         File.read(file.final_destination_path)
       end
 
@@ -95,12 +111,14 @@ module Epuber
       #
       # @param [String] pattern
       # @param [String] content
+      # @param [String] context_path path to directory that is used as context for finding
+      # @param [Array<Symbol>, Symbol] groups
       # @param [Thread::Backtrace::Location] location
       #
       # @return [void]
       #
-      def write_destination_file(pattern, content, location: caller_locations.first)
-        file = get_file(pattern, location: location)
+      def write_destination_file(pattern, content, context_path: nil, groups: nil, location: caller_locations.first)
+        file = get_file(pattern, context_path: context_path, groups: groups, location: location)
         Compiler::FileTypes::AbstractFile.write_to_file(content, file.final_destination_path)
       end
     end

data/lib/epuber/user_interface.rb

@@ -1,235 +1,30 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/object/try'
-require 'nokogiri'
+require 'delegate'
 
-require_relative 'ruby_extensions/thread'
-require_relative 'command'
+require_relative 'utils/logger/console_logger'
 
 module Epuber
-  class UserInterface
-    Location = Struct.new(:path, :lineno, :column, keyword_init: true)
-
-    class << self
-      # @return [Epuber::Command]
-      #
-      attr_accessor :current_command
-    end
-
-    # Fatal error, prints message and exit with return code 1
-    #
-    # @param [Exception, String] message message of the error
-    # @param [Thread::Backtrace::Location] location location of the error
-    #
-    def self.error!(message, location: nil)
-      error(message, location: location)
-      exit(1)
-    end
-
-    # Fatal error, prints message and exit with return code 1
-    #
-    # @param [String] message message of the error
-    # @param [Thread::Backtrace::Location] location location of the error
-    # @param [Bool] backtrace  output backtrace locations, nil == automatic, true == always and false == never
-    #
-    def self.error(message, location: nil)
-      _clear_processing_line_for_new_output do
-        $stdout.puts(_format_message(:error, message, location: location))
-        if current_command&.verbose?
-          _print_backtrace(location.try(:backtrace_locations) || message.try(:backtrace_locations) || caller_locations,
-                           location: location)
-        end
-      end
-    end
-
-    # @param [String] message message of the error
-    # @param [Thread::Backtrace::Location] location location of the error
-    #
-    def self.warning(message, location: nil)
-      _clear_processing_line_for_new_output do
-        $stdout.puts(_format_message(:warning, message, location: location))
-      end
-    end
-
-    # @param [#to_s] problem some problem, object just have to know to convert self into string with method #to_s
-    #
-    def self.print_processing_problem(problem)
-      _clear_processing_line_for_new_output do
-        $stdout.puts(problem.to_s.ansi.send(_color_from_level(:warning)))
-      end
-    end
-
-    # @param [String] info_text
-    #
-    def self.print_processing_debug_info(info_text)
-      return unless current_command&.verbose?
-
-      _clear_processing_line_for_new_output do
-        message = if @current_file.nil?
-                    "▸ #{info_text}"
-                  else
-                    "▸ #{@current_file.source_path}: #{info_text}"
-                  end
-
-        $stdout.puts(message.ansi.send(_color_from_level(:debug)))
-      end
-    end
-
-    # @param [Compiler::FileTypes::AbstractFile] file
-    #
-    # @return nil
-    #
-    def self.print_processing_file(file, index, count)
-      remove_processing_file_line
-
-      @current_file = file
-
-      @last_processing_file_line = "▸ Processing #{file.source_path} (#{index + 1} of #{count})"
-      $stdout.print(@last_processing_file_line)
-    end
-
-    def self.remove_processing_file_line
-      last_line = @last_processing_file_line
-
-      unless @last_processing_file_line.nil?
-        $stdout.print("\033[2K") # remove line, but without moving cursor
-        $stdout.print("\r") # go to beginning of line
-        @last_processing_file_line = nil
-      end
-
-      last_line
-    end
-
-    def self.processing_files_done
-      remove_processing_file_line
-
-      @current_file = nil
-    end
-
-    def self.puts(message)
-      _clear_processing_line_for_new_output do
-        $stdout.puts(message)
-      end
-    end
-
-    # @param [Compiler::FileTypes::AbstractFile] file
-    # @param [String] step_name
-    # @param [Fixnum] time
+  class UserInterface < Delegator
+    # @return [Logger::AbstractLogger]
     #
-    def self.print_step_processing_time(step_name, time = nil)
-      return yield if !current_command || !current_command.debug_steps_times
-
-      remove_processing_file_line
+    attr_reader :logger
 
-      if block_given?
-        start = Time.now
-        returned_value = yield
+    def initialize
+      super(nil)
 
-        time = Time.now - start
-      end
-
-      info_text = "Step #{step_name} took #{time * 1000} ms"
-      message = if @current_file.nil?
-                  "▸ #{info_text}"
-                else
-                  "▸ #{@current_file.source_path}: #{info_text}"
-                end
-
-      $stdout.puts(_format_message(:debug, message))
-
-      returned_value
+      @logger = Logger::ConsoleLogger.new
     end
 
-    def self._clear_processing_line_for_new_output
-      last_line = remove_processing_file_line
-
-      yield
-
-      @last_processing_file_line = last_line
-      $stdout.print(last_line)
-    end
-
-    # @param [Symbol] level color of the output
-    #
-    # @return [Symbol] color
-    #
-    def self._color_from_level(level)
-      case level
-      when :error then   :red
-      when :warning then :yellow
-      when :normal then  :white
-      when :debug then   :blue
-      else
-        raise "Unknown output level #{level}"
-      end
+    def __getobj__
+      @logger
     end
 
-    # @param [Thread::Backtrace::Location, Nokogiri::XML::Node] obj
-    #
-    # @return [Location]
-    #
-    def self._location_from_obj(obj)
-      case obj
-      when ::Thread::Backtrace::Location
-        Location.new(path: obj.path, lineno: obj.lineno)
-      when ::Nokogiri::XML::Node
-        Location.new(path: obj.document.file_path, lineno: obj.line)
-      when Location
-        obj
-      when Epuber::Compiler::FileTypes::AbstractFile
-        Location.new(path: obj.source_path)
-      end
-    end
-
-    # @param [Symbol] level color of the output
-    # @param [String] message message of the error
-    # @param [Thread::Backtrace::Location] location location of the error
-    #
-    # @return [String] formatted message
-    #
-    def self._format_message(level, message, location: nil)
-      location = _location_from_obj(location)
-
-      comps = []
-      comps << message.to_s
-      message_already_formatted =
-        message.is_a?(Epuber::Compiler::Problem) || message.is_a?(Epuber::Checker::TextChecker::MatchProblem)
-
-      if !location.nil? && !message_already_formatted
-        path = location.path
-
-        # calculate relative path when path is absolute and in project
-        path = path[Config.instance.project_path.size + 1..-1] if path.start_with?(Config.instance.project_path)
-
-        line_parts = [
-          "  (in file #{path}",
-        ]
-        line_parts << "line #{location.lineno}" if location.lineno
-        line_parts << "column #{location.column}" if location.column
-
-        comps << "#{line_parts.join(' ')})"
-      end
-
-      comps.join("\n").ansi.send(_color_from_level(level))
-    end
-
-    # @param [Array<Thread::Backtrace::Location>] locations locations of the error (only for verbose output)
-    # @param [Thread::Backtrace::Location] location location of the error
-    #
-    # @return [String] formatted message
-    #
-    def self._format_backtrace(locations, location: nil)
-      index = locations.index(location) || 0
-      locations[index, locations.size].map(&:to_s)
-    end
-
-    # @param [Thread::Backtrace::Location] location location of the error
-    #
-    def self._print_backtrace(locations, location: nil)
-      $stdout.puts(_format_backtrace(locations, location: location)) if current_command.verbose?
+    def __setobj__(obj)
+      @logger = obj
     end
   end
 
   # shortcut
-  UI = UserInterface
+  UI = UserInterface.new
 end

data/lib/epuber/utils/location.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Epuber
+  Location = Struct.new(:path, :lineno, :column, keyword_init: true) do
+    # !@attribute [r] path
+    #   @return [String] path to file
+
+    # !@attribute [r] lineno
+    #   @return [Integer, nil] line number
+
+    # !@attribute [r] column
+    #   @return [Integer, nil] column number
+  end
+end

data/lib/epuber/utils/logger/abstract_logger.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/try'
+require 'nokogiri'
+
+require_relative '../location'
+
+module Epuber
+  module Logger
+    class AbstractLogger
+      LEVELS = %i[
+        error
+        warning
+        info
+        debug
+      ].freeze
+
+      # @return [Boolean]
+      #
+      attr_accessor :verbose
+
+      # @return [Boolean]
+      #
+      attr_accessor :debug_steps_times
+
+      # @param [Hash] opts
+      # @option opts [Boolean] :verbose (false)
+      # @option opts [Boolean] :debug_steps_times (false)
+      #
+      def initialize(opts = {})
+        @verbose = opts.fetch(:verbose, false)
+        @debug_steps_times = opts.fetch(:debug_steps_times, false)
+
+        @current_file = nil
+        @sticky_message = nil
+        @error_was_logged = false
+      end
+
+      # Report error message
+      #
+      # @param [String, #to_s] message
+      # @param [Thread::Backtrace::Location, Epuber::Location, Nokogiri::XML::Node, nil] location
+      # @param [Boolean] stick if true, the error message will be sticked to the previous one
+      #
+      def error!(message, location: nil, backtrace: caller_locations)
+        _common_log(:error, message, location: location, backtrace: backtrace)
+        exit(1)
+      end
+
+      # Report error message
+      #
+      # @param [String, #to_s] message
+      # @param [Thread::Backtrace::Location, Epuber::Location, Nokogiri::XML::Node, nil] location
+      # @param [Boolean] stick if true, the error message will be sticked to the previous one
+      #
+      def error(message, sticky: false, location: nil, backtrace: caller_locations)
+        _common_log(:error, message, sticky: sticky, location: location, backtrace: backtrace)
+      end
+
+      # Report warning message
+      #
+      # @param [String, #to_s] message
+      # @param [Thread::Backtrace::Location, Epuber::Location, Nokogiri::XML::Node, nil] location
+      #
+      def warning(message, sticky: false, location: nil, backtrace: caller_locations)
+        _common_log(:warning, message, sticky: sticky, location: location, backtrace: backtrace)
+      end
+
+      # Report info message
+      #
+      # @param [String, #to_s] message
+      # @param [Thread::Backtrace::Location, Epuber::Location, Nokogiri::XML::Node, nil] location
+      #
+      def info(message, sticky: false, location: nil, backtrace: caller_locations)
+        _common_log(:info, message, sticky: sticky, location: location, backtrace: backtrace)
+      end
+
+      # Report debug message
+      #
+      # @param [String, #to_s] message
+      # @param [Thread::Backtrace::Location, Epuber::Location, Nokogiri::XML::Node, nil] location
+      #
+      def debug(message, sticky: false, location: nil, backtrace: caller_locations)
+        return unless @verbose
+
+        _common_log(:debug, message, sticky: sticky, location: location, backtrace: backtrace)
+      end
+
+      # @param [Epuber::Compiler::FileTypes::AbstractFile] file
+      # @param [Fixnum] index
+      # @param [Fixnum] count
+      #
+      def start_processing_file(file, index, count)
+        @current_file = file
+
+        _common_log(:debug, "▸ Processing #{file.source_path} (#{index + 1} of #{count})", sticky: true)
+      end
+
+      def end_processing
+        _remove_sticky_message
+        @current_file = nil
+      end
+
+      # @param [String] info_text
+      #
+      def print_processing_debug_info(info_text)
+        return unless @verbose
+
+        message = if @current_file.nil?
+                    "▸ #{info_text}"
+                  else
+                    "▸ #{@current_file.source_path}: #{info_text}"
+                  end
+        _log(:debug, message)
+      end
+
+      # @param [String] step_name
+      # @param [Fixnum] time
+      #
+      def print_step_processing_time(step_name, time = nil)
+        return yield unless @debug_steps_times
+
+        if block_given?
+          start = Time.now
+          returned_value = yield
+
+          time = Time.now - start
+        end
+
+        info_text = "Step #{step_name} took #{(time * 1000).round(2)} ms"
+        message = if @current_file.nil?
+                    "▸ #{info_text}"
+                  else
+                    "▸ #{@current_file.source_path}: #{info_text}"
+                  end
+
+        _log(:debug, message)
+
+        returned_value
+      end
+
+      # Return true if there was any error logged
+      #
+      # @return [Boolean]
+      def error?
+        @error_was_logged
+      end
+
+      protected
+
+      # Point of implementation for concrete logger
+      #
+      # @param [Symbol] level
+      # @param [String] message
+      # @param [Epuber::Location, nil] location
+      # @param [Array<Thread::Backtrace::Location>, nil] backtrace
+      # @param [Boolean] sticky if true, the message will be sticky (will be always as the last message)
+      #
+      def _log(level, message, location: nil, backtrace: nil, remove_last: false) # rubocop:disable Lint/UnusedMethodArgument
+        raise 'Not implemented, this is abstract class'
+      end
+
+      # Remove last line of the output (if it was sticky)
+      #
+      # @return [String, nil] last line
+      #
+      def _remove_sticky_message; end
+
+      private
+
+      # Core logging method
+      #
+      # @param level [Symbol]
+      # @param message [String]
+      # @param location [Thread::Backtrace::Location, Epuber::Location, Nokogiri::XML::Node,
+      #                  Epuber::Compiler::FileTypes::AbstractFile, nil]
+      # @param sticky [Boolean] if true, the message will be sticky (will be always as the last message)
+      #
+      def _common_log(level, message, sticky: false, location: nil, backtrace: nil)
+        raise ArgumentError, "Unknown log level #{level}" unless LEVELS.include?(level)
+
+        @error_was_logged = true if level == :error
+
+        location = _location_from_obj(location)
+
+        if @verbose && level == :error
+          backtrace = location.try(:backtrace_locations) ||
+                      message.try(:backtrace_locations) ||
+                      backtrace ||
+                      caller_locations
+        end
+
+        _log(level, message, location: location, backtrace: backtrace, sticky: sticky)
+      end
+
+      # @param [Thread::Backtrace::Location, Nokogiri::XML::Node] obj
+      #
+      # @return [Location]
+      #
+      def _location_from_obj(obj)
+        case obj
+        when ::Thread::Backtrace::Location
+          Location.new(path: obj.path, lineno: obj.lineno)
+        when ::Nokogiri::XML::Node
+          Location.new(path: obj.document.file_path, lineno: obj.line)
+        when Location
+          obj
+        when Epuber::Compiler::FileTypes::AbstractFile
+          Location.new(path: obj.source_path)
+        end
+      end
+    end
+  end
+end