epuber 0.7.4 → 0.9.0

data/lib/epuber/server.rb

@@ -23,9 +23,9 @@ require_relative 'third_party/bower'
 
 
 module Epuber
-
   # API:
-  # [LATER]   /file/<path-or-pattern> -- displays pretty file (image, text file) (for example: /file/text/s01.xhtml or /file/text/s01.bade)
+  # [LATER]   /file/<path-or-pattern> -- displays pretty file (image, text file) (for example: /file/text/s01.xhtml or
+  #                                      /file/text/s01.bade)
   #
   class Server < Sinatra::Base
     require_relative 'server/handlers'
@@ -42,11 +42,9 @@ module Epuber
           body = pretty(env, e)
         end
 
-        unless body.is_a?(Array)
-          body = [body]
-        end
+        body = [body] unless body.is_a?(Array)
 
-        [500, { 'Content-Type'   => content_type,
+        [500, { 'Content-Type' => content_type,
                 'Content-Length' => Rack::Utils.bytesize(body.join).to_s },
          body]
       end
@@ -118,7 +116,7 @@ module Epuber
 
       super() do |server|
         $stderr = old_stderr
-        puts "Started development server on #{server.host}:#{server.port}"
+        UI.puts "Started development server on #{server.host}:#{server.port}"
 
         host = if server.host == '0.0.0.0'
                  'localhost'
@@ -134,11 +132,11 @@ module Epuber
       @verbose = verbose
       @default_thin_logger ||= Thin::Logging.logger
 
-      unless verbose
+      if verbose
+        Thin::Logging.logger = @default_thin_logger
+      else
         Thin::Logging.logger = Logger.new(nil)
         Thin::Logging.logger.level = :fatal
-      else
-        Thin::Logging.logger = @default_thin_logger
       end
 
       set :logging, verbose
@@ -152,20 +150,18 @@ module Epuber
     end
 
     def self.start_listening_if_needed
-      return unless self.listener.nil?
+      return unless listener.nil?
 
       self.listener = Listen.to(Config.instance.project_path, debug: true) do |modified, added, removed|
-        begin
-          changes_detected(modified, added, removed)
-        rescue => e
-          # print error, do not send error further, listener will die otherwise
-          $stderr.puts e
-          $stderr.puts e.backtrace
-        end
+        changes_detected(modified, added, removed)
+      rescue StandardError => e
+        # print error, do not send error further, listener will die otherwise
+        warn e
+        warn e.backtrace
       end
 
-      listener.ignore(%r{\.idea})
-      listener.ignore(%r{#{Config.instance.working_path}})
+      listener.ignore(/\.idea/)
+      listener.ignore(/#{Config.instance.working_path}/)
       listener.ignore(%r{#{Config::WORKING_PATH}/})
 
       listener.start
@@ -183,22 +179,21 @@ module Epuber
       self.class.build_path
     end
 
-
-    # @param level [Symbol]
-    # @param message [String]
+    # @param [Symbol] level
+    # @param [String] message
     #
     # @return nil
     #
     def self._log(level, message)
       case level
       when :ui
-        puts message
+        UI.puts message
       when :info
-        puts "INFO: #{message}" if verbose
+        UI.puts "INFO: #{message}" if verbose
       when :get
-        puts " GET: #{message}" if verbose
+        UI.puts " GET: #{message}" if verbose
       when :ws
-        puts "  WS: #{message}" if verbose
+        UI.puts "  WS: #{message}" if verbose
       else
         raise "Unknown log level #{level}"
       end
@@ -213,7 +208,7 @@ module Epuber
 
     # @!group Helpers
 
-    # @param pattern [String]
+    # @param [String] pattern
     #
     # @return [String] path to file
     #
@@ -222,13 +217,13 @@ module Epuber
       finder.find_files(pattern).first
     end
 
-    # @param index [Fixnum]
+    # @param [Fixnum] index
     # @return [Epuber::Book::File, nil]
     #
     def spine_file_at(index)
-      if !file_resolver.nil? && index >= 0 && index < file_resolver.spine_files.count
-        file_resolver.spine_files[index]
-      end
+      return unless !file_resolver.nil? && index >= 0 && index < file_resolver.spine_files.count
+
+      file_resolver.spine_files[index]
     end
 
     # @param [String] path
@@ -238,15 +233,14 @@ module Epuber
     def self.relative_path_to_book_file(path)
       file = file_resolver.file_with_source_path(path)
       return if file.nil?
+
       file.pkg_destination_path
     end
 
     def add_script_file_to_head(html_doc, file_name, *args)
       source = File.read(File.expand_path("server/#{file_name}", File.dirname(__FILE__)))
 
-      if File.extname(file_name) == '.coffee'
-        source = CoffeeScript.compile(source)
-      end
+      source = CoffeeScript.compile(source) if File.extname(file_name) == '.coffee'
 
       args.each do |hash|
         hash.each do |key, value|
@@ -263,8 +257,8 @@ module Epuber
       add_script_to_head(html_doc, source)
     end
 
-    # @param html_doc [Nokogiri::HTML::Document]
-    # @param script_text [String]
+    # @param [Nokogiri::HTML::Document] html_doc
+    # @param [String] script_text
     #
     def add_script_to_head(html_doc, script_text)
       script_node = html_doc.create_element('script', script_text, type: 'text/javascript')
@@ -278,7 +272,7 @@ module Epuber
       head.add_child(script_node)
     end
 
-    # @param html_doc [Nokogiri::HTML::Document]
+    # @param [Nokogiri::HTML::Document] html_doc
     #
     def add_auto_refresh_script(html_doc)
       add_file_to_head(:js, html_doc, 'auto_refresh/reloader.coffee')
@@ -288,7 +282,7 @@ module Epuber
       add_script_to_head(html_doc, 'var auto_refresh = new AutoRefresh(window, console);')
     end
 
-    # @param html_doc [Nokogiri::HTML::Document]
+    # @param [Nokogiri::HTML::Document] html_doc
     #
     def add_keyboard_control_script(html_doc, previous_path, next_path)
       add_script_file_to_head(html_doc, 'keyboard_control.coffee',
@@ -296,27 +290,29 @@ module Epuber
                               '$next_path' => next_path)
     end
 
-    # @param html_doc [Nokogiri::HTML::Document]
+    # @param [Nokogiri::HTML::Document] html_doc
     #
     def add_file_to_head(type, html_doc, file_path)
       head = html_doc.at_css('head')
       node = case type
              when :style
-               html_doc.create_element('link',  href: "/server/raw/#{file_path}" ,rel: 'stylesheet', type: 'text/css')
+               html_doc.create_element('link', href: "/server/raw/#{file_path}", rel: 'stylesheet', type: 'text/css')
              when :js
                html_doc.create_element('script', src: "/server/raw/#{file_path}", type: 'text/javascript')
              else
                raise "Unknown file type `#{type}`"
              end
 
-      return if head.css('script, link').any? { |n| (!n['href'].nil? && n['href'] == node['href']) || (!n['src'].nil? && n['src'] == node['src']) }
+      return if head.css('script, link').any? do |n|
+                  (!n['href'].nil? && n['href'] == node['href']) || (!n['src'].nil? && n['src'] == node['src'])
+                end
 
       head.add_child(node)
     end
 
-    # @param html_doc [Nokogiri::HTML::Document]
-    # @param key [String]
-    # @param value [String]
+    # @param [Nokogiri::HTML::Document] html_doc
+    # @param [String] key
+    # @param [String] value
     #
     def add_meta_to_head(name, content, html_doc, force: false)
       head = html_doc.at_css('head')
@@ -338,24 +334,22 @@ module Epuber
         self.target = new_target
       else
         self.target = book.targets.first
-        _log :ui, "[!] Not found previous target after reloading bookspec file, jumping to first #{self.target.name}"
+        _log :ui, "[!] Not found previous target after reloading bookspec file, jumping to first #{target.name}"
       end
     end
 
     def self._compile_book
-      begin
-        compiler = Epuber::Compiler.new(book, target)
-        compiler.compile(build_path)
-        self.file_resolver = compiler.file_resolver
+      compiler = Epuber::Compiler.new(book, target)
+      compiler.compile(build_path)
+      self.file_resolver = compiler.file_resolver
 
-        true
-      rescue => e
-        self.file_resolver = compiler.file_resolver
+      true
+    rescue StandardError => e
+      self.file_resolver = compiler.file_resolver
 
-        Epuber::UI.error("Compile error: #{e}", location: e)
+      Epuber::UI.error("Compile error: #{e}", location: e)
 
-        false
-      end
+      false
     end
 
     def self.compile_book(&completion)
@@ -366,15 +360,15 @@ module Epuber
 
       @compilation_thread = Thread.new do
         result = _compile_book
-        completion.call(result) unless completion.nil?
+        completion&.call(result)
       end
 
-      if completion.nil?
-        @compilation_thread.join
-      end
+      return unless completion.nil?
+
+      @compilation_thread.join
     end
 
-    # @param message [String]
+    # @param [String] message
     #
     def self.send_to_clients(message)
       _log :info, "sending message to clients #{message.inspect}"
@@ -384,10 +378,11 @@ module Epuber
       end
     end
 
-    # @param type [Symbol]
+    # @param [Symbol] type
     def self.notify_clients(type, data = nil)
       _log :info, "Notifying clients with type #{type.inspect}"
-      raise "Not known type `#{type}`" unless [:styles, :reload, :compile_start, :compile_end].include?(type)
+      raise "Not known type `#{type}`" unless %i[styles reload compile_start compile_end].include?(type)
+
       message = {
         name: type,
       }
@@ -406,17 +401,17 @@ module Epuber
       files_paths.select { |file| file_resolver.file_with_source_path(file) || book.file_path == file }
     end
 
-    # @param _modified [Array<String>]
-    # @param _added [Array<String>]
-    # @param _removed [Array<String>]
+    # @param [Array<String>] modified
+    # @param [Array<String>] added
+    # @param [Array<String>] removed
     #
-    def self.changes_detected(_modified, _added, _removed)
-      all_changed = (_modified + _added + _removed).uniq.map { |path| path.unicode_normalize }
+    def self.changes_detected(modified, added, removed)
+      all_changed = (modified + added + removed).uniq.map(&:unicode_normalize)
 
       reload_bookspec if all_changed.any? { |file| file == book.file_path }
 
       changed = filter_not_project_files(all_changed) || []
-      return if changed.count == 0
+      return if changed.count.zero?
 
       notify_clients(:compile_start)
 
@@ -440,11 +435,15 @@ module Epuber
         # remove nil paths (for example bookspec can't be found so the relative path is nil)
         changed.compact!
 
-        # if changed.size > 0 && changed.all? { |file| file.end_with?(*Epuber::Compiler::FileFinders::GROUP_EXTENSIONS[:style]) }
-          # notify_clients(:styles, changed)
-        # else
+        changed_only_styles = changed.all? do |file|
+          file.end_with?(*Epuber::Compiler::FileFinders::GROUP_EXTENSIONS[:style])
+        end
+
+        if changed.size.positive? && changed_only_styles
+          notify_clients(:styles, changed)
+        else
           notify_clients(:reload, changed)
-        # end
+        end
       end
     end
 
@@ -460,12 +459,12 @@ module Epuber
         ws.onopen do
           sockets << ws
 
-          ws.send({name: :hello}.to_json)
+          ws.send({ name: :hello }.to_json)
 
           thread = Thread.new do
             loop do
               sleep(10)
-              ws.send({name: :heartbeat}.to_json)
+              ws.send({ name: :heartbeat }.to_json)
             end
           end
         end
@@ -490,6 +489,7 @@ module Epuber
       mtime = File.mtime(file_path)
       last_modified(mtime)
       etag(mtime.to_s)
+      cache_control :public, :must_revalidate
 
       case File.extname(file_path)
       when '.styl'
@@ -571,11 +571,11 @@ module Epuber
         full_path = File.expand_path(path, build_path)
 
         case File.extname(full_path)
-          when '.xhtml'
-            content_type :xhtml
-            handle_xhtml_file(full_path)
-          else
-            handle_file(full_path)
+        when '.xhtml'
+          content_type :xhtml
+          handle_xhtml_file(full_path)
+        else
+          handle_file(full_path)
         end
       end
     end
@@ -621,6 +621,7 @@ module Epuber
     get '/raw/*' do
       path = find_file
       next not_found if path.nil?
+
       handle_file(File.expand_path(path, build_path))
     end
 

data/lib/epuber/third_party/bower.rb

@@ -5,12 +5,12 @@ module Epuber
     class Bower
       class << self
         JS_COMPONENTS = {
-          jquery:    'jquery/dist/',
-          cookies:   'cookies-js/dist/',
-          uri:       'uri.js/src/',
-          spin:      'spin.js/',
+          jquery: 'jquery/dist/',
+          cookies: 'cookies-js/dist/',
+          uri: 'uri.js/src/',
+          spin: 'spin.js/',
           keymaster: 'keymaster/',
-        }
+        }.freeze
 
         def path_to_js(component)
           path = JS_COMPONENTS[component]

data/lib/epuber/transformer/book_transformer.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative '../transformer'
+
+module Epuber
+  class Transformer
+    class BookTransformer < Transformer
+      # @return [Book]
+      #
+      attr_accessor :book
+
+      # @return [CompilationContext]
+      #
+      attr_accessor :compilation_context
+
+      # @param [Epuber::Book] book
+      # @param [Epuber::Compiler::CompilationContext] compilation_context
+      #
+      def call(book, compilation_context)
+        @book = book
+        @compilation_context = compilation_context
+
+        @block.call(self, @book, @compilation_context)
+
+        @book = nil
+        @compilation_context = nil
+      end
+
+      # Find file in source or destination paths
+      #
+      # @param [String] pattern
+      # @param [Thread::Backtrace::Location] location
+      #
+      # @return [Epuber::Compiler::FileTypes::AbstractFile, nil]
+      #
+      def find_file(pattern, 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)
+          @compilation_context.file_resolver.file_with_source_path(path)
+        rescue Compiler::FileFinders::FileNotFoundError
+          begin
+            path = @compilation_context.file_resolver.dest_finder.find_file(pattern)
+            @compilation_context.file_resolver.file_with_destination_path(path)
+          rescue Compiler::FileFinders::FileNotFoundError
+            nil
+          end
+        end
+      end
+
+      # Find files destination paths
+      #
+      # @param [String] pattern
+      # @param [Thread::Backtrace::Location] location
+      #
+      # @return [Array<Epuber::Compiler::FileTypes::AbstractFile>]
+      #
+      def find_destination_files(pattern, 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.map { |path| @compilation_context.file_resolver.file_with_destination_path(path) }
+      end
+
+      # Find file and raise exception if not found
+      #
+      # @param [String] pattern
+      # @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
+
+        file
+      end
+
+      # Read file from destination path (raises exception if not found)
+      #
+      # @param [String] pattern
+      # @param [Thread::Backtrace::Location] location
+      #
+      # @return [String]
+      #
+      def read_destination_file(pattern, location: caller_locations.first)
+        file = get_file(pattern, location: location)
+        File.read(file.final_destination_path)
+      end
+
+      # Write file to destination path (raises exception if not found)
+      #
+      # @param [String] pattern
+      # @param [String] content
+      # @param [Thread::Backtrace::Location] location
+      #
+      # @return [void]
+      #
+      def write_destination_file(pattern, content, location: caller_locations.first)
+        file = get_file(pattern, location: location)
+        Compiler::FileTypes::AbstractFile.write_to_file(content, file.final_destination_path)
+      end
+    end
+  end
+end

data/lib/epuber/transformer/text_transformer.rb

@@ -5,7 +5,6 @@ require_relative '../transformer'
 module Epuber
   class Transformer
     class TextTransformer < Transformer
-
       # @return [String]
       #
       attr_accessor :text
@@ -51,7 +50,10 @@ module Epuber
                    @text.gsub!(pattern, replacement, &block)
                  end
 
-        result = replace_all(pattern, replacement, multiple_times: multiple_times, &block) if multiple_times && !result.nil?
+        if multiple_times && !result.nil?
+          result = replace_all(pattern, replacement, multiple_times: multiple_times,
+                               &block)
+        end
         result
       end
     end

data/lib/epuber/transformer.rb

@@ -5,13 +5,15 @@ require_relative 'checker_transformer_base'
 module Epuber
   class Transformer < CheckerTransformerBase
     require_relative 'transformer/text_transformer'
+    require_relative 'transformer/book_transformer'
 
     # @return [Hash<Symbol, Class>]
     #
     def self.map_source_type__class
       {
-        :result_text_xhtml_string => TextTransformer,
-        :source_text_file         => TextTransformer,
+        result_text_xhtml_string: TextTransformer,
+        source_text_file: TextTransformer,
+        after_all_text_files: BookTransformer,
       }.merge(super)
     end
   end