epuber 0.7.4 → 0.9.0

data/lib/epuber/compiler/file_finders/imaginary.rb

@@ -11,6 +11,8 @@ module Epuber
           #
           attr_accessor :entries
 
+          # @return [String]
+          #
           attr_reader :name
 
           def initialize(name)
@@ -32,8 +34,12 @@ module Epuber
         end
 
         class FileEntry
+          # @return [String]
+          #
           attr_reader :name
 
+          # @return [String]
+          #
           attr_reader :absolute_path
 
           def initialize(name, absolute_path)
@@ -42,7 +48,7 @@ module Epuber
           end
 
           def ==(other)
-            other.is_a?(FileEntry) ? name == other.name : name == other.to_s
+            name == (other.is_a?(FileEntry) ? other.name : other.to_s)
           end
         end
 
@@ -83,14 +89,11 @@ module Epuber
           make_dir_p(path)[file_name] = FileEntry.new(file_name, file_path)
         end
 
-
         def __core_find_files_from_pattern(pattern)
           parts = self.class.path_parts(pattern)
           found_entries = find_recurser(root, parts).flatten
           file_entries = found_entries.reject { |entry| entry.is_a?(DirEntry) }
-          file_entries.map do |item|
-            item.absolute_path
-          end
+          file_entries.map(&:absolute_path)
         end
 
         def __core_file?(path)
@@ -104,12 +107,14 @@ module Epuber
           current.is_a?(FileEntry)
         end
 
-        private
-
-        def self.path_parts(path)
-          path.split(File::SEPARATOR).reject(&:empty?)
+        class << self
+          def path_parts(path)
+            path.split(File::SEPARATOR).reject(&:empty?)
+          end
         end
 
+        private
+
         def find_recurser(dir, parts)
           return [] unless dir.respond_to? :[]
 
@@ -117,25 +122,25 @@ module Epuber
           return [] if pattern.nil?
 
           matches         = case pattern
-                              when '**'
-                                case parts
-                                  when ['*']
-                                    parts = [] # end recursion
-                                    directories_under(dir).map do |d|
-                                      d.entries.select do |f|
-                                        (f.is_a?(FileEntry) || f.is_a?(DirEntry)) &&
-                                          f.name.match(/\A(?!\.)/)
-                                      end
-                                    end.flatten.uniq
-                                  when []
-                                    parts = [] # end recursion
-                                    dir.entries.values.flatten.uniq
-                                  else
-                                    directories_under(dir)
-                                end
+                            when '**'
+                              case parts
+                              when ['*']
+                                parts = [] # end recursion
+                                directories_under(dir).map do |d|
+                                  d.entries.select do |f|
+                                    (f.is_a?(FileEntry) || f.is_a?(DirEntry)) &&
+                                      f.name.match(/\A(?!\.)/)
+                                  end
+                                end.flatten.uniq
+                              when []
+                                parts = [] # end recursion
+                                dir.entries.values.flatten.uniq
                               else
-                                regex_body = pattern_to_regex(pattern)
-                                dir.entries.reject { |k, _v| /\A#{regex_body}\Z/ !~ k }.values
+                                directories_under(dir)
+                              end
+                            else
+                              regex_body = pattern_to_regex(pattern)
+                              dir.entries.select { |k, _v| /\A#{regex_body}\Z/ =~ k }.values
                             end
 
           if parts.empty? # we're done recursing
@@ -156,14 +161,14 @@ module Epuber
 
         def pattern_to_regex(pattern)
           pattern.gsub('.', '\.')
-            .gsub('?', '.')
-            .gsub('*', '.*')
-            .gsub('(', '\(')
-            .gsub(')', '\)')
-            .gsub(/\{(.*?)\}/) do
-              "(#{Regexp.last_match[1].gsub(',', '|')})"
-            end
-            .gsub(/\A\./, '(?!\.).')
+                 .gsub('?', '.')
+                 .gsub('*', '.*')
+                 .gsub('(', '\(')
+                 .gsub(')', '\)')
+                 .gsub(/\{(.*?)\}/) do
+                   "(#{Regexp.last_match[1].gsub(',', '|')})"
+                 end
+                 .gsub(/\A\./, '(?!\.).')
         end
       end
     end

data/lib/epuber/compiler/file_resolver.rb

@@ -20,12 +20,12 @@ module Epuber
     require_relative 'file_types/container_xml_file'
     require_relative 'file_types/ibooks_display_options_file'
     require_relative 'file_types/coffee_script_file'
-
+    require_relative 'file_types/css_file'
 
     class FileResolver
       class ResolveError < StandardError; end
 
-      PATH_TYPES = [:spine, :manifest, :package, nil]
+      PATH_TYPES = [:spine, :manifest, :package, nil].freeze
 
       # @return [String] path where should look for source files
       #
@@ -125,24 +125,16 @@ module Epuber
         existing_file = @final_destination_path_to_file[file.final_destination_path]
 
         # save mapping from file_request to file, file_request can be different, but result file could be the same ...
-        unless file.try(:file_request).nil?
-          @request_to_files[file.file_request] << (existing_file || file)
-        end
+        @request_to_files[file.file_request] << (existing_file || file) unless file.try(:file_request).nil?
 
         # return existing file if already exists, new file will be thrown away
         return existing_file unless existing_file.nil?
 
-        if [:spine].include?(type)
-          @spine_files << file
-        end
+        @spine_files << file if [:spine].include?(type)
 
-        if [:spine, :manifest].include?(type)
-          @manifest_files << file
-        end
+        @manifest_files << file if %i[spine manifest].include?(type)
 
-        if [:spine, :manifest, :package].include?(type)
-          @package_files << file
-        end
+        @package_files << file if %i[spine manifest package].include?(type)
 
         @files << file
 
@@ -151,13 +143,11 @@ module Epuber
 
         @final_destination_path_to_file[file.final_destination_path] = file
 
-        if file.respond_to?(:source_path) && !file.source_path.nil?
-          @source_path_to_file[file.source_path] = file
-        end
+        @source_path_to_file[file.source_path] = file if file.respond_to?(:source_path) && !file.source_path.nil?
 
-        if file.respond_to?(:abs_source_path) && !file.abs_source_path.nil?
-          @abs_source_path_to_file[file.abs_source_path] = file
-        end
+        return unless file.respond_to?(:abs_source_path) && !file.abs_source_path.nil?
+
+        @abs_source_path_to_file[file.abs_source_path] = file
       end
 
       # Get instance of file from request instance
@@ -184,7 +174,7 @@ module Epuber
         end
 
         if file_request.only_one
-          files.first  # @request_to_files always returns array, see #initialize method
+          files.first # @request_to_files always returns array, see #initialize method
         else
           files
         end
@@ -219,99 +209,99 @@ module Epuber
       # @return [Array<String>] list of files that should be deleted in destination directory
       #
       def unneeded_files_in_destination
-        requested_paths = files.map do |file|
-          file.pkg_destination_path
-        end
+        requested_paths = files.map(&:pkg_destination_path)
 
         existing_paths = FileFinders::Normal.new(destination_path).find_all('*')
 
         unnecessary_paths = existing_paths - requested_paths
 
-        unnecessary_paths.select! do |path|
-          !::File.directory?(File.join(destination_path, path))
+        unnecessary_paths.reject! do |path|
+          ::File.directory?(File.join(destination_path, path))
         end
 
         unnecessary_paths
       end
 
-
       ##################################################################################################################
 
-      private
-
-      # @param [String] path  path to some file
-      #
-      # @return [String] path with changed extension
-      #
-      def self.renamed_file_with_path(path)
-        extname     = File.extname(path)
-        new_extname = FileFinders::EXTENSIONS_RENAME[extname]
-
-        if new_extname.nil?
-          path
-        else
-          path.sub(/#{Regexp.escape(extname)}$/, new_extname)
-        end
-      end
-
-      # @param file [Epuber::Compiler::AbstractFile]
-      #
-      # @return [nil]
-      #
-      def resolve_destination_path(file)
-        if file.final_destination_path.nil?
-          dest_path = if file.respond_to?(:source_path) && !file.source_path.nil?
-                        file.abs_source_path = File.expand_path(file.source_path, source_path)
-                        self.class.renamed_file_with_path(file.source_path)
-                      elsif !file.destination_path.nil?
-                        file.destination_path
-                      else
-                        raise ResolveError, "What should I do with file that doesn't have source path or destination path? file: #{file.inspect}"
-                      end
-
-          file.destination_path = dest_path
-          file.pkg_destination_path = File.join(*self.class.path_comps_for(file.path_type), dest_path)
-          file.final_destination_path = File.join(destination_path, file.pkg_destination_path)
+      class << self
+        # @param [String] path  path to some file
+        #
+        # @return [String] path with changed extension
+        #
+        def renamed_file_with_path(path)
+          extname     = File.extname(path)
+          new_extname = FileFinders::EXTENSIONS_RENAME[extname]
+
+          if new_extname.nil?
+            path
+          else
+            path.sub(/#{Regexp.escape(extname)}$/, new_extname)
+          end
         end
-      end
 
-      # @param [String] extname  extension of file
-      #
-      # @return [Class]
-      #
-      def self.file_class_for(extname)
-        mapping = {
-          '.styl'  => FileTypes::StylusFile,
+        # @param [String] extname  extension of file
+        #
+        # @return [Class]
+        #
+        def file_class_for(extname)
+          mapping = {
+            '.styl' => FileTypes::StylusFile,
+            '.css' => FileTypes::CSSFile,
 
-          '.coffee' => FileTypes::CoffeeScriptFile,
+            '.coffee' => FileTypes::CoffeeScriptFile,
 
-          '.bade'  => FileTypes::BadeFile,
-          '.xhtml' => FileTypes::XHTMLFile,
-          '.html'  => FileTypes::XHTMLFile,
+            '.bade' => FileTypes::BadeFile,
+            '.xhtml' => FileTypes::XHTMLFile,
+            '.html' => FileTypes::XHTMLFile,
 
-          '.jpg'   => FileTypes::ImageFile,
-          '.jpeg'  => FileTypes::ImageFile,
-          '.png'   => FileTypes::ImageFile,
-        }
+            '.jpg' => FileTypes::ImageFile,
+            '.jpeg' => FileTypes::ImageFile,
+            '.png' => FileTypes::ImageFile,
+          }
 
-        mapping[extname] || FileTypes::StaticFile
-      end
+          mapping[extname] || FileTypes::StaticFile
+        end
 
-      # @param [String] root_path  path to root of the package
-      # @param [Symbol] path_type  path type of file
-      #
-      # @return [Array<String>] path components
-      #
-      def self.path_comps_for(root_path = nil, path_type)
-        case path_type
+        # @param [String] root_path  path to root of the package
+        # @param [Symbol] path_type  path type of file
+        #
+        # @return [Array<String>] path components
+        #
+        def path_comps_for(root_path, path_type)
+          case path_type
           when :spine, :manifest
             Array(root_path) + [Compiler::EPUB_CONTENT_FOLDER]
           when :package
             Array(root_path)
-          else
-            nil
+          end
         end
       end
+
+      private
+
+      # @param [Epuber::Compiler::AbstractFile] file
+      #
+      # @return [nil]
+      #
+      def resolve_destination_path(file)
+        return unless file.final_destination_path.nil?
+
+        dest_path = if file.respond_to?(:source_path) && !file.source_path.nil?
+                      file.abs_source_path = File.expand_path(file.source_path, source_path)
+                      self.class.renamed_file_with_path(file.source_path)
+                    elsif !file.destination_path.nil?
+                      file.destination_path
+                    else
+                      raise ResolveError, <<~ERROR
+                        What should I do with file that doesn't have source path or destination path? file: #{file.inspect}
+                      ERROR
+                    end
+
+        file.destination_path = dest_path
+        file.pkg_destination_path = File.join(*self.class.path_comps_for(nil, file.path_type), dest_path)
+        file.final_destination_path = File.join(destination_path, file.pkg_destination_path)
+      end
     end
   end
 end

data/lib/epuber/compiler/file_stat.rb

@@ -36,7 +36,7 @@ module Epuber
             @mtime = stat.mtime
             @ctime = stat.ctime
             @size = stat.size
-          rescue
+          rescue StandardError
             # noop
           end
         end
@@ -66,9 +66,9 @@ module Epuber
         raise AttributeError, "other must be class of #{self.class}" unless other.is_a?(FileStat)
 
         file_path == other.file_path &&
-             size == other.size &&
-            mtime == other.mtime &&
-            ctime == other.ctime
+          size == other.size &&
+          mtime == other.mtime &&
+          ctime == other.ctime
       end
     end
   end

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

@@ -4,18 +4,18 @@ module Epuber
   class Compiler
     module FileTypes
       class AbstractFile
-
         # @return [String] relative destination path
         #
         attr_accessor :destination_path
 
-        # @return [Symbol] group of this file (:text, :image, :font, ...), see Epuber::Compiler::FileFinder::GROUP_EXTENSIONS
+        # @return [Symbol] group of this file (:text, :image, :font, ...), see
+        #                  Epuber::Compiler::FileFinder::GROUP_EXTENSIONS
         #
         attr_accessor :group
 
         # @return [Set<Symbol>] list of properties
         #
-        attr_accessor :properties
+        attr_writer :properties
 
         # @return [Set<Symbol>] list of properties
         #
@@ -23,7 +23,6 @@ module Epuber
           @properties ||= Set.new
         end
 
-
         # @return [String] final relative destination path from root of the package calculated by FileResolver
         #
         attr_accessor :pkg_destination_path
@@ -88,9 +87,7 @@ module Epuber
         def self.write_to_file!(content, to_path)
           FileUtils.mkdir_p(File.dirname(to_path))
 
-          File.open(to_path, 'w') do |file_handle|
-            file_handle.write(content)
-          end
+          File.write(to_path, content)
         end
       end
     end

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

@@ -26,10 +26,15 @@ module Epuber
             __file_resolver: file_resolver,
             __file: self,
             __toc_item: toc_item,
-            __const: Hash.new { |_hash, key| UI.warning("Undefined constant with key `#{key}`", location: caller_locations[0]) }.merge!(target.constants),
+            __const: Hash.new do |_hash, key|
+                       UI.warning("Undefined constant with key `#{key}`", location: caller_locations[0])
+                     end.merge!(target.constants),
           }
 
-          should_load_from_precompiled = up_to_date && precompiled_exists && compilation_context.incremental_build? && (!compilation_context.should_write)
+          should_load_from_precompiled = up_to_date &&
+                                         precompiled_exists &&
+                                         compilation_context.incremental_build? &&
+                                         !compilation_context.should_write
 
           precompiled = if should_load_from_precompiled
                           begin
@@ -40,16 +45,10 @@ module Epuber
                           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.file_path = source_path
-
-              renderer.render(new_line: '', indent: '')
+          if precompiled.nil?
+            if compilation_context.incremental_build?
+              UI.print_processing_debug_info('Parsing new version of source file')
             end
-          else
-            UI.print_processing_debug_info('Parsing new version of source file') if compilation_context.incremental_build?
 
             bade_content = load_source(compilation_context)
 
@@ -58,13 +57,19 @@ module Epuber
                                        .with_locals(variables)
 
               # turn on optimizations when can
-              if renderer.respond_to?(:optimize=)
-                renderer.optimize = true
-              end
+              renderer.optimize = true if renderer.respond_to?(:optimize=)
 
               FileUtils.mkdir_p(File.dirname(precompiled_path))
               renderer.precompiled.write_yaml_to_file(precompiled_path)
 
+              renderer.render(new_line: '', indent: '')
+            end
+          else
+            xhtml_content = UI.print_step_processing_time('rendering precompiled Bade') do
+              renderer = Bade::Renderer.from_precompiled(precompiled)
+                                       .with_locals(variables)
+              renderer.file_path = source_path
+
               renderer.render(new_line: '', indent: '')
             end
           end
@@ -82,7 +87,7 @@ module Epuber
         # @return [String]
         #
         def precompiled_path
-          File.join(Config.instance.build_cache_path(PRECOMPILED_CACHE_NAME), source_path + '.precompiled.yml')
+          File.join(Config.instance.build_cache_path(PRECOMPILED_CACHE_NAME), "#{source_path}.precompiled.yml")
         end
 
         def pretty_precompiled_path

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

@@ -10,7 +10,7 @@ module Epuber
       class CoffeeScriptFile < SourceFile
         # @param [Compiler::CompilationContext] compilation_context
         #
-        def process(compilation_context)
+        def process(_compilation_context)
           return if destination_file_up_to_date?
 
           write_compiled(CoffeeScript.compile(File.new(abs_source_path)))

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'css_parser'
+
+module Epuber
+  class Compiler
+    module FileTypes
+      require_relative 'source_file'
+
+      class CSSFile < SourceFile
+        DECLARATION_TO_FILE_GROUP_MAP = {
+          'background' => :image,
+          'background-image' => :image,
+          'list-style' => :image,
+          'list-style-image' => :image,
+          'content' => :image,
+          'cursor' => :image,
+          'border-image' => :image,
+          'border-image-source' => :image,
+          'mask-image' => :image,
+          'mask-box-image' => :image,
+          'src' => :font,
+        }.freeze
+
+        URL_REGEXP = /url\((.+)\)/.freeze
+
+        # @param [Compiler::CompilationContext] compilation_context
+        #
+        def process(compilation_context)
+          return if destination_file_up_to_date?
+
+          write_processed(process_css(File.read(abs_source_path), compilation_context))
+        end
+
+        # Processes CSS file, resolves all linked files and adds them to file resolver
+        #
+        # @param [String] content
+        # @param [Compiler::CompilationContext] compilation_context
+        #
+        # @return [String]
+        #
+        def process_css(content, compilation_context)
+          file_resolver = compilation_context.file_resolver
+
+          parser = UI.print_step_processing_time('css parsing') do
+            parser = CssParser::Parser.new
+            parser.load_string!(content)
+            parser
+          end
+
+          # resolve links to files, add other linked resources and compute correct path
+          UI.print_step_processing_time('resolving url()') do
+            parser.each_rule_set do |rule_set, _media_types|
+              declarations = rule_set.instance_eval { @declarations }
+              declarations.each do |property, decl_value|
+                value = decl_value.to_s
+                next unless value =~ URL_REGEXP
+
+                path = Regexp.last_match(1)
+                if path.start_with?('"') && path.end_with?('"')
+                  path = path[1..-2]
+                  quote = '"'
+                end
+                if path.start_with?("'") && path.end_with?("'")
+                  path = path[1..-2]
+                  quote = "'"
+                end
+
+                next if path.start_with?('data:') || path.start_with?('http://') || path.start_with?('https://')
+
+                resource_group = DECLARATION_TO_FILE_GROUP_MAP[property]
+                dirname = File.dirname(destination_path)
+
+                begin
+                  new_path = file_resolver.dest_finder.find_file(path, groups: resource_group, context_path: dirname)
+                rescue FileFinders::FileNotFoundError, FileFinders::MultipleFilesFoundError
+                  new_path = XHTMLProcessor.resolved_link_to_file(path,
+                                                                  resource_group,
+                                                                  dirname,
+                                                                  file_resolver.source_finder).to_s
+                  pkg_abs_path = File.expand_path(new_path, dirname).unicode_normalize
+                  pkg_new_path = Pathname.new(pkg_abs_path)
+                                         .relative_path_from(Pathname.new(file_resolver.source_path))
+                                         .to_s
+
+                  file_class = FileResolver.file_class_for(File.extname(new_path))
+                  file = file_class.new(pkg_new_path)
+                  file.path_type = :manifest
+                  file_resolver.add_file(file)
+                end
+
+                new_url = FileResolver.renamed_file_with_path(new_path)
+                content = content.gsub(value, "url(#{quote}#{new_url}#{quote})")
+              end
+            end
+          end
+
+          content
+        end
+      end
+    end
+  end
+end

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

@@ -12,7 +12,7 @@ module Epuber
 
         # @param [Compiler::CompilationContext] compilation_context
         #
-        def process(compilation_context)
+        def process(_compilation_context)
           write_generate(content.to_s)
         end
 

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

@@ -16,14 +16,16 @@ module Epuber
           dest = final_destination_path
           source = abs_source_path
 
-          img = Magick::Image::read(source).first
+          img = Magick::Image.read(source).first
 
           resolution = img.columns * img.rows
           max_resolution = 3_000_000
 
           if resolution > max_resolution
             img = img.change_geometry("#{max_resolution}@>") do |width, height, b_img|
-              UI.print_processing_debug_info("downscaling from resolution #{b_img.columns}x#{b_img.rows} to #{width}x#{height}")
+              UI.print_processing_debug_info(<<~MSG)
+                downscaling from resolution #{b_img.columns}x#{b_img.rows} to #{width}x#{height}
+              MSG
               b_img.resize!(width, height)
             end
 

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

@@ -6,7 +6,6 @@ module Epuber
       require_relative 'generated_file'
 
       class NavFile < GeneratedFile
-
         # @return [Epuber::Version]
         #
         attr_reader :epub_version

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

@@ -6,7 +6,6 @@ module Epuber
       require_relative 'generated_file'
 
       class OPFFile < GeneratedFile
-
         def initialize
           super