epuber 0.3.12 → 0.4.0

data/lib/epuber/compiler/file_types/abstract_file.rb

@@ -37,6 +37,9 @@ module Epuber
         #
         attr_accessor :path_type
 
+        # @return [Epuber::Compiler::CompilationContext] non-nil value only during #process() method
+        #
+        attr_accessor :compilation_context
 
         def ==(other)
           self.class == other.class && final_destination_path == other.final_destination_path
@@ -45,43 +48,6 @@ module Epuber
 
         ################################################################################################################
 
-        # @param [String] source_path  path to source file
-        # @param [String] dest_path  path to destination file
-        # @param [Bool] identical whether the content of existing files should be compared or not (expensive operation)
-        #
-        # @return [Bool]
-        #
-        def self.file_uptodate?(source_path, dest_path, identical: true)
-          return false unless File.exist?(dest_path)
-          return false unless FileUtils.uptodate?(dest_path, [source_path])
-
-          if identical
-            return false unless FileUtils.identical?(dest_path, source_path)
-          end
-
-          true
-        end
-
-        # @param [String] source_path
-        # @param [String] dest_path
-        #
-        # @return [Bool]
-        #
-        def self.file_copy?(source_path, dest_path)
-          !file_uptodate?(source_path, dest_path)
-        end
-
-        # @param [String] source_path
-        # @param [String] dest_path
-        #
-        # @return nil
-        #
-        def self.file_copy(source_path, dest_path)
-          return unless file_copy?(source_path, dest_path)
-
-          file_copy!(source_path, dest_path)
-        end
-
         # @param [String] source_path
         # @param [String] dest_path
         #

data/lib/epuber/compiler/file_types/bade_file.rb

@@ -9,6 +9,8 @@ module Epuber
       require_relative 'xhtml_file'
 
       class BadeFile < XHTMLFile
+        PRECOMPILED_CACHE_NAME = 'bade_precompiled'
+
         # @param [Epuber::Compiler::CompilationContext] compilation_context
         #
         def process(compilation_context)
@@ -16,7 +18,8 @@ module Epuber
           book = compilation_context.book
           file_resolver = compilation_context.file_resolver
 
-          bade_content = load_source(compilation_context)
+          up_to_date = source_file_up_to_date?
+          precompiled_exists = File.exist?(precompiled_path)
 
           variables = {
             __book: book,
@@ -27,11 +30,67 @@ module Epuber
             __const: Hash.new { |_hash, key| UI.warning("Undefined constant with key `#{key}`", location: caller_locations[0]) }.merge!(target.constants),
           }
 
-          xhtml_content = Bade::Renderer.from_source(bade_content, source_path)
-                                        .with_locals(variables)
-                                        .render(new_line: '', indent: '')
+          should_load_from_precompiled = up_to_date && precompiled_exists && compilation_context.incremental_build?
+
+          precompiled = if should_load_from_precompiled
+                          begin
+                            Bade::Precompiled.from_yaml_file(precompiled_path)
+                          rescue LoadError
+                            UI.warning("Empty precompiled file at path #{pretty_precompiled_path}", location: self)
+                            nil
+                          end
+                        end
+
+          if !precompiled.nil?
+            xhtml_content = UI.print_step_processing_time('rendering precompiled Bade') do
+              renderer = Bade::Renderer.from_precompiled(precompiled)
+                                       .with_locals(variables)
+
+              renderer.render(new_line: '', indent: '')
+            end
+          else
+            UI.print_processing_debug_info('Parsing new version of source file') if compilation_context.incremental_build?
+
+            bade_content = load_source(compilation_context)
+
+            xhtml_content = UI.print_step_processing_time('rendering changed Bade') do
+              renderer = Bade::Renderer.from_source(bade_content, source_path)
+                                       .with_locals(variables)
+
+              # turn on optimizations when can
+              if renderer.respond_to?(:optimize=)
+                renderer.optimize = true
+              end
+
+              FileUtils.mkdir_p(File.dirname(precompiled_path))
+              renderer.precompiled.write_yaml_to_file(precompiled_path)
+
+              renderer.render(new_line: '', indent: '')
+            end
+          end
 
           write_compiled(common_process(xhtml_content, compilation_context))
+          update_metadata!
+        end
+
+        # return [Array<String>]
+        #
+        def find_dependencies
+          (super + self.class.find_imports(File.read(abs_source_path))).uniq
+        end
+
+        # @return [String]
+        #
+        def precompiled_path
+          File.join(Config.instance.build_cache_path(PRECOMPILED_CACHE_NAME), source_path + '.precompiled.yml')
+        end
+
+        def pretty_precompiled_path
+          Config.instance.pretty_path_from_project(precompiled_path)
+        end
+
+        def self.find_imports(content)
+          content.to_enum(:scan, /^\s*import ("|')([^'"]*)("|')/).map { Regexp.last_match[2] }
         end
       end
     end

data/lib/epuber/compiler/file_types/coffee_script_file.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'coffee-script'
+
+
+module Epuber
+  class Compiler
+    module FileTypes
+      require_relative 'source_file'
+
+      class CoffeeScriptFile < SourceFile
+        # @param [Compiler::CompilationContext] compilation_context
+        #
+        def process(compilation_context)
+          return if destination_file_up_to_date?
+
+          write_compiled(CoffeeScript.compile(File.new(abs_source_path)))
+
+          update_metadata!
+        end
+      end
+    end
+  end
+end

data/lib/epuber/compiler/file_types/generated_file.rb

@@ -19,8 +19,10 @@ module Epuber
 
         def write_generate(content)
           if self.class.write_to_file?(content, final_destination_path)
-            UI.print_processing_debug_info("Writing generated content to #{pkg_destination_path}")
+            UI.print_processing_debug_info("#{pkg_destination_path}: Writing generated content")
             self.class.write_to_file!(content, final_destination_path)
+          else
+            UI.print_processing_debug_info("#{pkg_destination_path}: Not writing to disk ... generated content is same")
           end
         end
       end

data/lib/epuber/compiler/file_types/image_file.rb

@@ -9,14 +9,14 @@ module Epuber
       require_relative 'source_file'
 
       class ImageFile < SourceFile
-        # @param [Compiler::CompilationContext] compilation_context
+        # @param [Compiler::CompilationContext] _compilation_context
         #
-        def process(compilation_context)
+        def process(_compilation_context)
+          return if destination_file_up_to_date?
+
           dest = final_destination_path
           source = abs_source_path
 
-          return if self.class.file_uptodate?(source, dest)
-
           img = Magick::Image::read(source).first
 
           resolution = img.columns * img.rows
@@ -35,6 +35,8 @@ module Epuber
             # file is already old
             self.class.file_copy!(source, dest)
           end
+
+          update_metadata!
         end
       end
     end

data/lib/epuber/compiler/file_types/source_file.rb

@@ -26,17 +26,77 @@ module Epuber
           @source_path = source_path
         end
 
+        # return [Array<String>]
+        #
+        def find_dependencies
+          []
+        end
+
+        def process(_compilation_context)
+          # do nothing
+        end
+
+        # Source file does not change from last build
+        # @warning Using only this method can cause not updating files that are different for targets
+        #
+        # @return [Bool]
+        #
+        def source_file_up_to_date?
+          return false unless compilation_context.incremental_build?
+
+          source_db = compilation_context.source_file_database
+          source_db.up_to_date?(source_path)
+        end
+
+        # Source file does not change from last build of this target
+        #
+        # @return [Bool]
+        #
+        def destination_file_up_to_date?
+          return false unless compilation_context.incremental_build?
+
+          source_db = compilation_context.source_file_database
+          target_db = compilation_context.target_file_database
+
+          destination_file_exist? && # destination file must exist
+            target_db.up_to_date?(source_path) && # source file must be up-to-date from last build of this target
+            source_db.file_stat_for(source_path) == target_db.file_stat_for(source_path)
+        end
+
+        # Final destination path exist
+        #
+        # @return [Bool]
+        #
+        def destination_file_exist?
+          File.exist?(final_destination_path)
+        end
+
+        # Updates information about source file in file databases
+        #
+        # @return [nil]
+        #
+        def update_metadata!
+          compilation_context.source_file_database.update_metadata(source_path)
+          compilation_context.target_file_database.update_metadata(source_path)
+        end
+
         def default_file_copy
-          if self.class.file_copy?(abs_source_path, final_destination_path)
+          if destination_file_up_to_date?
+            UI.print_processing_debug_info("Destination path #{pkg_destination_path} is up-to-date")
+          else
             UI.print_processing_debug_info("Copying to #{pkg_destination_path}")
             self.class.file_copy!(abs_source_path, final_destination_path)
           end
+
+          update_metadata!
         end
 
         def write_compiled(content)
           if self.class.write_to_file?(content, final_destination_path)
             UI.print_processing_debug_info("Writing compiled version to #{pkg_destination_path}")
             self.class.write_to_file!(content, final_destination_path)
+          else
+            UI.print_processing_debug_info("Not writing to disk ... compiled version at #{pkg_destination_path} is same")
           end
         end
 
@@ -44,6 +104,8 @@ module Epuber
           if self.class.write_to_file?(content, final_destination_path)
             UI.print_processing_debug_info("Writing processed version to #{pkg_destination_path}")
             self.class.write_to_file!(content, final_destination_path)
+          else
+            UI.print_processing_debug_info("Not writing to disk ... processed version at #{pkg_destination_path} is same")
           end
         end
       end

data/lib/epuber/compiler/file_types/static_file.rb

@@ -7,9 +7,9 @@ module Epuber
       require_relative 'source_file'
 
       class StaticFile < SourceFile
-        # @param [Compiler::CompilationContext] compilation_context
+        # @param [Compiler::CompilationContext] _compilation_context
         #
-        def process(compilation_context)
+        def process(_compilation_context)
           default_file_copy
         end
       end

data/lib/epuber/compiler/file_types/stylus_file.rb

@@ -12,12 +12,27 @@ module Epuber
         # @param [Compiler::CompilationContext] compilation_context
         #
         def process(compilation_context)
+          return if destination_file_up_to_date?
+
           Stylus.define('__is_debug', !compilation_context.release_build)
           Stylus.define('__is_verbose_mode', compilation_context.verbose?)
           Stylus.define('__target_name', compilation_context.target.name)
           Stylus.define('__book_title', compilation_context.book.title)
+          Stylus.define('__const', compilation_context.target.constants)
 
           write_compiled(Stylus.compile(File.new(abs_source_path)))
+
+          update_metadata!
+        end
+
+        def find_dependencies
+          self.class.find_imports(File.read(abs_source_path))
+        end
+
+        # @return [Array<String>]
+        #
+        def self.find_imports(content)
+          content.to_enum(:scan, /^\s*@import ("|')([^'"]*)("|')/).map { Regexp.last_match[2] }
         end
       end
     end

data/lib/epuber/compiler/file_types/xhtml_file.rb

@@ -29,6 +29,21 @@ module Epuber
           end
         end
 
+        # @param [Book::Target] target
+        # @param [FileResolver] file_resolver
+        #
+        # @return [Array<String>] list of paths to styles relative to this file
+        #
+        def default_scripts(target, file_resolver)
+          default_scripts = target.default_scripts.map do |default_style_request|
+            Array(file_resolver.file_from_request(default_style_request))
+          end.flatten
+
+          default_scripts.map do |style|
+            Pathname.new(style.final_destination_path).relative_path_from(Pathname.new(File.dirname(final_destination_path))).to_s
+          end
+        end
+
         # @param [Compiler::CompilationContext] compilation_context
         #
         def load_source(compilation_context)
@@ -53,6 +68,14 @@ module Epuber
           xhtml_content
         end
 
+        # @param [Array] errors
+        #
+        def process_nokogiri_errors(errors)
+          errors.each do |e|
+            UI.warning(e)
+          end
+        end
+
         # @param [String] content xhtml in string
         # @param [Compiler::CompilationContext] compilation_context
         #
@@ -63,29 +86,64 @@ module Epuber
           book = compilation_context.book
           file_resolver = compilation_context.file_resolver
 
-          xhtml_doc = XHTMLProcessor.xml_document_from_string(content, source_path)
-          XHTMLProcessor.add_missing_root_elements(xhtml_doc, book.title, target.epub_version)
+          xhtml_doc = UI.print_step_processing_time('parsing XHTML file') do
+            XHTMLProcessor.xml_document_from_string(content, source_path)
+          end
 
-          XHTMLProcessor.add_styles(xhtml_doc, default_styles(target, file_resolver))
+          if compilation_context.release_build && xhtml_doc.errors.count > 0
+            process_nokogiri_errors(xhtml_doc.errors)
+          end
 
-          XHTMLProcessor.add_viewport(xhtml_doc, target.default_viewport) unless target.default_viewport.nil?
-          self.properties << :scripted if XHTMLProcessor.using_javascript?(xhtml_doc)
-          self.properties << :remote_resources if XHTMLProcessor.using_remote_resources?(xhtml_doc)
+          UI.print_step_processing_time('adding missing elements') do
+            XHTMLProcessor.add_missing_root_elements(xhtml_doc, book.title, target.epub_version)
+          end
 
-          XHTMLProcessor.resolve_links(xhtml_doc, destination_path, file_resolver.dest_finder)
-          XHTMLProcessor.resolve_images(xhtml_doc, destination_path, file_resolver)
+          UI.print_step_processing_time('adding default things') do
+            XHTMLProcessor.add_styles(xhtml_doc, default_styles(target, file_resolver))
+            XHTMLProcessor.add_scripts(xhtml_doc, default_scripts(target, file_resolver))
 
-          xhtml_string = xhtml_doc.to_s
+            XHTMLProcessor.add_viewport(xhtml_doc, target.default_viewport) unless target.default_viewport.nil?
+          end
+
+          # resolve links to files, add other linked resources and compute correct path
+          UI.print_step_processing_time('resolving links') do
+            XHTMLProcessor.resolve_links(xhtml_doc, destination_path, file_resolver.dest_finder)
+          end
+          UI.print_step_processing_time('resolving image resources') do
+            XHTMLProcessor.resolve_images(xhtml_doc, destination_path, file_resolver)
+          end
+          UI.print_step_processing_time('resolving scripts') do
+            XHTMLProcessor.resolve_scripts(xhtml_doc, destination_path, file_resolver)
+          end
+          UI.print_step_processing_time('resolving stylesheets') do
+            XHTMLProcessor.resolve_stylesheets(xhtml_doc, destination_path, file_resolver)
+          end
+
+          XHTMLProcessor.resolve_mathml_namespace(xhtml_doc)
+
+          UI.print_step_processing_time('investigating properties') do
+            self.properties << :remote_resources if XHTMLProcessor.using_remote_resources?(xhtml_doc)
+            self.properties << :scripted if XHTMLProcessor.using_javascript?(xhtml_doc)
+            self.properties << :mathml if XHTMLProcessor.using_mathml?(xhtml_doc)
+          end
+
+          xhtml_string = UI.print_step_processing_time('converting to XHTML') do
+             xhtml_doc.to_s
+          end
 
           # perform transformations
-          compilation_context.perform_plugin_things(Transformer, :result_text_xhtml_string) do |transformer|
-            xhtml_string = transformer.call(final_destination_path, xhtml_string, compilation_context)
+          UI.print_step_processing_time('performing final transformations') do
+            compilation_context.perform_plugin_things(Transformer, :result_text_xhtml_string) do |transformer|
+              xhtml_string = transformer.call(final_destination_path, xhtml_string, compilation_context)
+            end
           end
 
           # perform custom validation
           if compilation_context.should_check
-            compilation_context.perform_plugin_things(Checker, :result_text_xhtml_string) do |checker|
-              checker.call(final_destination_path, xhtml_string, compilation_context)
+            UI.print_step_processing_time('performing final validations') do
+              compilation_context.perform_plugin_things(Checker, :result_text_xhtml_string) do |checker|
+                checker.call(final_destination_path, xhtml_string, compilation_context)
+              end
             end
           end