epuber 0.3.5

data/lib/epuber/transformer.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require_relative 'checker_transformer_base'
+
+
+module Epuber
+  class Transformer < CheckerTransformerBase
+    require_relative 'transformer/text_transformer'
+
+    # @return [Hash<Symbol, Class>]
+    #
+    def self.map_source_type__class
+      {
+        :result_text_xhtml_string => TextTransformer,
+        :source_text_file         => TextTransformer,
+      }.merge(super)
+    end
+  end
+end

data/lib/epuber/transformer/text_transformer.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require_relative '../transformer'
+
+
+module Epuber
+  class Transformer
+    class TextTransformer < Transformer
+
+      # @return [String]
+      #
+      attr_accessor :text
+
+      # @return [String]
+      #
+      attr_accessor :file_path
+
+
+      # @param [String] file_path  path to transforming file
+      # @param [String] text  text file content
+      # @param [CompilationContext] compilation_context
+      #
+      # @return [String] new transformed text
+      #
+      def call(file_path, text, compilation_context)
+        @file_path = file_path
+        @text = text.dup
+
+        @block.call(self, @text, compilation_context)
+
+        new_text = @text
+
+        @text = nil
+        @file_path = nil
+
+        new_text
+      end
+
+      # Shortcut for performing substitutions in text
+      #
+      # @param [Regexp, String] pattern
+      # @param [String, nil] replacement
+      # @param [Bool] multiple_times  run the replacement multiple times, while there is something to replace
+      # @param [Proc] block  optional block for creating replacements, see String#gsub!
+      #
+      # @return [String, nil] see String#gsub!
+      #
+      def replace_all(pattern, replacement = nil, multiple_times: false, &block)
+        result = if replacement.nil?
+                   @text.gsub!(pattern, &block)
+                 else
+                   @text.gsub!(pattern, replacement, &block)
+                 end
+
+        result = replace_all(pattern, replacement, multiple_times: multiple_times, &block) if multiple_times && !result.nil?
+        result
+      end
+    end
+  end
+end

data/lib/epuber/user_interface.rb

@@ -0,0 +1,186 @@
+
+require 'active_support/core_ext/object/try'
+require 'nokogiri'
+
+require_relative 'ruby_extensions/thread'
+require_relative 'command'
+
+
+module Epuber
+  class UserInterface
+    Location = Struct.new(:path, :lineno)
+
+    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)
+      $stdout.puts unless @last_processing_file_line.nil?
+
+      $stdout.puts(_format_message(:error, message, location: location))
+      _print_backtrace(location.try(:backtrace_locations) || message.try(:backtrace_locations) || caller_locations, location: location) if current_command.verbose?
+    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)
+      if current_command && 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
+    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
+
+    private
+
+    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;   :red
+        when :warning; :yellow
+        when :normal;  :white
+        when :debug;   :blue
+        else
+          raise "Unknown output level #{level}"
+      end
+    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(obj.path, obj.lineno)
+      when ::Nokogiri::XML::Node
+        Location.new(obj.document.file_path, obj.line)
+      when Location
+        obj
+      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
+      comps << "  (in file #{location.path} line #{location.lineno}" unless location.nil?
+
+      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 { |loc| loc.to_s }
+    end
+
+    # @param [Thread::Backtrace::Location] location location of the error
+    #
+    def self._print_backtrace(locations, location: nil)
+      puts(_format_backtrace(locations, location: location)) if current_command.verbose?
+    end
+  end
+
+  # shortcut
+  UI = UserInterface
+end

data/lib/epuber/vendor/globals_context.rb

@@ -0,0 +1,26 @@
+
+module Epuber
+  class GlobalsContext
+    attr_accessor :catch_variables
+
+    def initialize
+      @catch_variables = []
+    end
+
+    def catch
+      before = global_variables
+
+      begin
+        yield
+      ensure
+        @catch_variables += (global_variables - before)
+      end
+    end
+
+    def clear_all
+      @catch_variables.each do |name|
+        eval("#{name} = nil")
+      end
+    end
+  end
+end

data/lib/epuber/vendor/hash_binding.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Epuber
+  class HashBinding
+    # @param [Hash] vars
+    #
+    def initialize(vars = {})
+      @vars = vars
+    end
+
+    # @param [String] name
+    #
+    def method_missing(name)
+      raise NameError, "Not found value for key #{name}" unless @vars.key?(name)
+      @vars[name]
+    end
+
+    # rubocop:disable Style/AccessorMethodName
+
+    def get_binding
+      binding
+    end
+
+    # rubocop:enable Style/AccessorMethodName
+  end
+end

data/lib/epuber/vendor/nokogiri_extensions.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'nokogiri'
+
+
+class Nokogiri::XML::Node
+  # @param [String] name
+  # @param [Hash, String] args
+  #
+  # @return [Nokogiri::XML::Node] new parent node
+  #
+  def surround_with_element(name, *args, &block)
+    new_parent = document.create_element(name, *args, &block)
+    old_parent = parent
+
+    self.parent = new_parent
+
+    if old_parent.is_a?(Nokogiri::XML::Document)
+      old_parent.root = new_parent
+    else
+      old_parent.children = new_parent
+    end
+
+    new_parent
+  end
+
+  # @return [String] path to original file
+  #
+  attr_accessor :file_path
+end

data/lib/epuber/vendor/ruby_templater.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+# rubocop:disable Lint/Eval
+
+require_relative 'hash_binding'
+
+
+module Epuber
+  class RubyTemplater
+    # @return [String]
+    #
+    attr_accessor :source_text
+
+    # @return [String]
+    #
+    attr_accessor :file_path
+
+    # @return [Hash]
+    #
+    attr_accessor :locals
+
+    # @param source [String]
+    #
+    # @return [self]
+    #
+    def self.from_source(source, file_path = nil)
+      inst = new
+      inst.source_text = source
+      inst.file_path = file_path
+      inst
+    end
+
+    # @param file [String, File]
+    #
+    # @return [self]
+    #
+    def self.from_file(file)
+      file_obj = if file.is_a?(String)
+                   File.new(file, 'r')
+                 else
+                   file
+                 end
+
+      from_source(file_obj.read, file_obj.path)
+    end
+
+
+    # ----------------------------------------------------------------------------- #
+    # DSL methods
+
+
+    # @param locals [Hash]
+    #
+    # @return [self]
+    #
+    def with_locals(locals = {})
+      self.locals = locals
+      self
+    end
+
+    # @return [String]
+    #
+    def render
+      hash_binding = HashBinding.new(locals)
+      eval_string = %(%(#{source_text}))
+      eval(eval_string, hash_binding.get_binding)
+    end
+  end
+end
+
+# rubocop:enable Lint/Eval

data/lib/epuber/vendor/size.rb

@@ -0,0 +1,20 @@
+
+module Epuber
+  class Size
+    # @return [Numeric]
+    #
+    attr_reader :width
+
+    # @return [Numeric]
+    #
+    attr_reader :height
+
+    # @param [Numeric] width
+    # @param [Numeric] height
+    #
+    def initialize(width, height)
+      @width = width
+      @height = height
+    end
+  end
+end