epuber 0.3.5

data/lib/epuber/command/server.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require_relative '../command'
+require 'os'
+
+
+module Epuber
+  class Command
+    class Server < Command
+      self.summary = 'Starts web server to display and debug e-book pages.'
+      self.arguments = [
+        CLAide::Argument.new('TARGET', false, false),
+      ]
+
+      def self.options
+        [
+          ['--open',   'Opens the web page in default web browser, working only on OS X'],
+        ].concat(super)
+      end
+
+      # @param args [CLAide::ARGV]
+      #
+      def initialize(args)
+        super
+        @selected_target_name = args.shift_argument
+        @open_web_browser = args.flag?('open', false)
+      end
+
+      def validate!
+        super
+        verify_one_bookspec_exists!
+      end
+
+      def run
+        super
+
+        require_relative '../server'
+
+        target = if @selected_target_name.nil?
+                   book.targets.first
+                 else
+                   book.target_named(@selected_target_name)
+                 end
+
+        help!('Not existing target') if target.nil?
+
+        Epuber::Server.run!(book, target, verbose: verbose?) do |uri|
+          if OS.osx?
+            if @open_web_browser
+              system "open #{uri}"
+            else
+              puts 'Web browser can be automatically opened by adding --open flag, see --help'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/epuber/compiler.rb

@@ -0,0 +1,255 @@
+# encoding: utf-8
+
+require 'English'
+
+require 'pathname'
+require 'fileutils'
+
+require 'zip'
+
+require_relative 'vendor/nokogiri_extensions'
+require_relative 'vendor/globals_context'
+
+require_relative 'plugin'
+
+
+module Epuber
+  class Compiler
+    require_relative 'compiler/compilation_context'
+
+    require_relative 'compiler/opf_generator'
+    require_relative 'compiler/nav_generator'
+    require_relative 'compiler/meta_inf_generator'
+
+    require_relative 'compiler/file_resolver'
+    require_relative 'compiler/file_finders/normal'
+
+
+    EPUB_CONTENT_FOLDER = 'OEBPS'
+
+    # @return [Epuber::GlobalsContext]
+    #
+    def self.globals_catcher
+      @globals_catcher ||= Epuber::GlobalsContext.new
+    end
+
+    # @return [Epuber::Compiler::FileResolver]
+    #
+    attr_reader :file_resolver
+
+    # @return [CompilationContext]
+    #
+    attr_reader :compilation_context
+
+    # @param book [Epuber::Book::Book]
+    # @param target [Epuber::Book::Target]
+    #
+    def initialize(book, target)
+      @book = book
+      @target = target
+      @compilation_context = CompilationContext.new(book, target)
+    end
+
+    # Compile target to build folder
+    #
+    # @param build_folder [String] path to folder, where will be stored all compiled files
+    # @param [Bool] check should run non-release checkers
+    # @param [Bool] write should perform transformations of source files and write them back
+    # @param [Bool] release this is release build
+    #
+    # @return [void]
+    #
+    def compile(build_folder, check: false, write: false, release: false, verbose: false)
+      @file_resolver = FileResolver.new(Config.instance.project_path, build_folder)
+      compilation_context.file_resolver = @file_resolver
+      compilation_context.should_check = check
+      compilation_context.should_write = write
+      compilation_context.release_build = release
+      compilation_context.verbose = verbose
+
+      self.class.globals_catcher.catch do
+        @build_folder = build_folder
+
+        FileUtils.mkdir_p(build_folder)
+
+        puts "  handling target #{@target.name.inspect} in build dir `#{Config.instance.pretty_path_from_project(build_folder)}`"
+
+        parse_toc_item(@target.root_toc)
+        parse_target_file_requests
+
+        process_all_target_files
+        generate_other_files
+
+        # build folder cleanup
+        remove_unnecessary_files
+        remove_empty_folders
+      end
+    ensure
+      self.class.globals_catcher.clear_all
+    end
+
+    # Archives current target files to epub
+    #
+    # @param path [String] path to created archive
+    #
+    # @return [String] path
+    #
+    def archive(path = nil, configuration_suffix: nil)
+      path ||= epub_name(configuration_suffix)
+
+      epub_path = File.expand_path(path)
+
+      Dir.chdir(@file_resolver.destination_path) do
+        new_paths = @file_resolver.package_files.map(&:pkg_destination_path)
+
+        if ::File.exists?(epub_path)
+          Zip::File.open(epub_path, true) do |zip_file|
+            old_paths = zip_file.instance_eval { @entry_set.entries.map(&:name) }
+            diff = old_paths - new_paths
+            diff.each do |file_to_remove|
+              puts "DEBUG: removing file from result EPUB: #{file_to_remove}" if compilation_context.verbose?
+              zip_file.remove(file_to_remove)
+            end
+          end
+        end
+
+        run_command(%(zip -q0X "#{epub_path}" mimetype))
+        run_command(%(zip -qXr9D "#{epub_path}" "#{new_paths.join('" "')}" --exclude \\*.DS_Store))
+      end
+
+      path
+    end
+
+    # Creates name of epub file for current book and current target
+    #
+    # @return [String] name of result epub file
+    #
+    def epub_name(configuration_suffix = nil)
+      epub_name = if !@book.output_base_name.nil?
+                    @book.output_base_name
+                  elsif @book.from_file?
+                    ::File.basename(@book.file_path, ::File.extname(@book.file_path))
+                  else
+                    @book.title
+                  end
+
+      epub_name += @book.build_version.to_s unless @book.build_version.nil?
+      epub_name += "-#{@target.name}" if @target != @book.default_target
+      epub_name += "-#{configuration_suffix}" unless configuration_suffix.nil?
+      epub_name + '.epub'
+    end
+
+
+    private
+
+    # @return nil
+    #
+    def remove_empty_folders
+      Dir.chdir(@file_resolver.destination_path) do
+        Dir.glob('**/*')
+          .select { |d| File.directory?(d) }
+          .select { |d| (Dir.entries(d) - %w(. ..)).empty? }
+          .each do |d|
+          puts "DEBUG: removing empty folder `#{d}`" if compilation_context.verbose?
+          Dir.rmdir(d)
+        end
+      end
+    end
+
+    # @return nil
+    #
+    def remove_unnecessary_files
+      unnecessary_paths = @file_resolver.unneeded_files_in_destination.map { |path| File.join(@file_resolver.destination_path, path) }
+      unnecessary_paths.each do |path|
+        puts "DEBUG: removing unnecessary file: `#{Config.instance.pretty_path_from_project(path)}`" if compilation_context.verbose?
+
+        File.delete(path)
+      end
+    end
+
+    # @return nil
+    #
+    def generate_other_files
+      # generate nav file (nav.xhtml or nav.ncx)
+      nav_file = FileTypes::NavFile.new(@target.epub_version)
+      @file_resolver.add_file(nav_file)
+      process_file(nav_file)
+
+      # generate .opf file
+      opf_file = FileTypes::OPFFile.new
+      @file_resolver.add_file(opf_file)
+      process_file(opf_file)
+
+      # generate mimetype file
+      mimetype_file = FileTypes::MimeTypeFile.new
+      @file_resolver.add_file(mimetype_file)
+      process_file(mimetype_file)
+
+      # generate META-INF files
+      container_xml = FileTypes::ContainerXMLFile.new
+      @file_resolver.add_file(container_xml)
+      process_file(container_xml)
+
+      if @target.epub_version >= 2.0 && @target.epub_version < 3.0
+        ibooks_options = FileTypes::IBooksDisplayOptionsFile.new
+        @file_resolver.add_file(ibooks_options)
+        process_file(ibooks_options)
+      end
+    end
+
+    # @return nil
+    #
+    def parse_target_file_requests
+      @target.files.each do |file_request|
+        @file_resolver.add_file_from_request(file_request)
+      end
+    end
+
+    # @param [FileTypes::AbstractFile] file
+    #
+    def process_file(file)
+      file.process(compilation_context)
+    end
+
+    # @return nil
+    #
+    def process_all_target_files
+      @file_resolver.manifest_files.each_with_index do |file, idx|
+        UI.print_processing_file(file, idx, @file_resolver.manifest_files.count)
+        process_file(file)
+      end
+
+      UI.processing_files_done
+    end
+
+    # @param toc_item [Epuber::Book::TocItem]
+    #
+    def parse_toc_item(toc_item)
+      unless toc_item.file_request.nil?
+        file = @file_resolver.add_file_from_request(toc_item.file_request, :spine)
+        file.toc_item = toc_item if file.toc_item.nil?
+      end
+
+      # process recursively other files
+      toc_item.sub_items.each do |child|
+        parse_toc_item(child)
+      end
+    end
+
+    # @param cmd [String]
+    #
+    # @return [void]
+    #
+    # @raise if the return value is not 0
+    #
+    def run_command(cmd)
+      system(cmd)
+
+      $stdout.flush
+      $stderr.flush
+
+      code = $CHILD_STATUS
+      raise 'wrong return value' if code != 0
+    end
+  end
+end

data/lib/epuber/compiler/compilation_context.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+
+module Epuber
+  class Compiler
+    class CompilationContext
+      # @return [Epuber::Book]
+      #
+      attr_reader :book
+
+      # @return [Epuber::Book::Target]
+      #
+      attr_reader :target
+
+      # @return [Epuber::Compiler::FileResolver]
+      #
+      attr_accessor :file_resolver
+
+      # @return [Array<Epuber::Plugin>]
+      #
+      def plugins
+        @plugins ||= @target.plugins.map do |path|
+          begin
+            plugin = Plugin.new(File.expand_path(path, Config.instance.project_path))
+            plugin.files.each do |file|
+              file_resolver.add_file(file)
+            end
+            plugin
+          rescue LoadError
+            UI.error "Can't find plugin at path #{path}"
+          end
+        end.compact
+      end
+
+      # @param [Class] klass class of thing you want to perform (Checker or Transformer)
+      # @param [Symbol] source_type source type of that thing (Checker or Transformer)
+      #
+      # @yield
+      # @yieldparam [Epuber::CheckerTransformerBase] instance of checker or transformer
+      #
+      # @return nil
+      #
+      def perform_plugin_things(klass, source_type)
+        plugins.each do |plugin|
+          plugin.instances(klass).each do |instance|
+            # @type [Epuber::CheckerTransformerBase] instance
+
+            next if instance.source_type != source_type
+            next if instance.options.include?(:run_only_before_release) && !release_build
+
+            yield instance
+          end
+        end
+      end
+
+
+      #########
+
+      # @return [Bool]
+      #
+      attr_accessor :should_check
+
+      # @return [Bool]
+      #
+      attr_accessor :should_write
+
+      # @return [Bool]
+      #
+      attr_accessor :release_build
+
+      # @return [Bool]
+      #
+      attr_accessor :verbose
+
+      def verbose?
+        verbose
+      end
+
+
+      def initialize(book, target)
+        @book = book
+        @target = target
+      end
+    end
+  end
+end

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

@@ -0,0 +1,270 @@
+# encoding: utf-8
+
+require 'unicode_normalize'
+
+
+module Epuber
+  class Compiler
+    module FileFinders
+      class FileNotFoundError < ::StandardError
+        # @return [String]
+        #
+        attr_reader :pattern
+
+        # @return [String]
+        #
+        attr_reader :context_path
+
+        # @param [String] pattern
+        # @param [String] context_path
+        #
+        def initialize(pattern, context_path)
+          @pattern = pattern
+          @context_path = context_path
+        end
+
+        def to_s
+          "Not found file matching pattern `#{pattern}` from context path #{context_path}."
+        end
+      end
+
+      class MultipleFilesFoundError < ::StandardError
+        # @return [Array<String>]
+        #
+        attr_reader :files_paths
+
+        # @return [Array<Symbol>]
+        #
+        attr_reader :groups
+
+        # @return [String]
+        #
+        attr_reader :pattern
+
+        # @return [String]
+        #
+        attr_reader :context_path
+
+        # @param [String] pattern  original pattern for searching
+        # @param [Symbol] groups  list of groups
+        # @param [String] context_path  context path of current searching
+        # @param [Array<String>] files_paths  list of founded files
+        #
+        def initialize(pattern, groups, context_path, files_paths)
+          @pattern = pattern
+          @groups = groups
+          @context_path = context_path
+          @files_paths = files_paths
+        end
+
+        def to_s
+          str = "Found too many files for pattern `#{pattern}` from context path #{context_path}"
+          str += ", file groups #{groups.map(:inspect)}" unless groups.nil?
+          str + ", founded files #{files_paths}"
+        end
+      end
+
+      BINARY_EXTENSIONS = %w(.png .jpeg .jpg .otf .ttf)
+      STATIC_EXTENSIONS = BINARY_EXTENSIONS + %w(.css .js)
+
+      GROUP_EXTENSIONS = {
+        text:   %w(.xhtml .html .bade),
+        image:  %w(.png .jpg .jpeg),
+        font:   %w(.otf .ttf),
+        style:  %w(.css .styl),
+        script: %w(.js),
+      }
+
+      EXTENSIONS_RENAME = {
+        '.styl' => '.css',
+
+        '.bade' => '.xhtml',
+      }
+
+      class Abstract
+
+        # @return [String] path where should look for source files
+        #
+        attr_reader :source_path
+
+        # @return [Array<String>]
+        #
+        attr_accessor :ignored_patterns
+
+
+        # @param [String] source_path
+        #
+        def initialize(source_path)
+          @source_path = source_path.unicode_normalize.freeze
+          @source_path_abs = ::File.expand_path(@source_path).unicode_normalize.freeze
+          @ignored_patterns = []
+        end
+
+
+        def assert_one_file(files, pattern: nil, groups: nil, context_path: nil)
+          raise FileNotFoundError.new(pattern, context_path) if files.empty?
+          raise MultipleFilesFoundError.new(pattern, groups, context_path, files) if files.count >= 2
+        end
+
+        # Method for finding file from context_path, if there is not matching file, it will continue to search from
+        # #source_path and after that it tries to search recursively from #source_path.
+        #
+        # When it founds too many (more than two) it will raise MultipleFilesFoundError
+        #
+        # @param [String] pattern  pattern of the desired files
+        # @param [Symbol] groups  list of group names, nil or empty array for all groups, for valid values see GROUP_EXTENSIONS
+        # @param [String] context_path  path for root of searching, it is also defines start folder of relative path
+        #
+        # @return [Array<String>] list of founded files
+        #
+        def find_file(pattern, groups: nil, context_path: nil, search_everywhere: true)
+          files = find_files(pattern, groups: groups, context_path: context_path, search_everywhere: search_everywhere)
+          assert_one_file(files, pattern: pattern, groups: groups, context_path: context_path)
+          files.first
+        end
+
+        # Method for finding files from context_path, if there is not matching file, it will continue to search from
+        # #source_path and after that it tries to search recursively from #source_path.
+        #
+        # @param [String] pattern  pattern of the desired files
+        # @param [Array<Symbol>] groups  list of group names, nil or empty array for all groups, for valid values see GROUP_EXTENSIONS
+        # @param [String] context_path  path for root of searching, it is also defines start folder of relative path
+        #
+        # @return [Array<String>] list of founded files
+        #
+        def find_files(pattern, groups: nil, context_path: nil, search_everywhere: true)
+          files = []
+          searching_path = context_path
+
+          unless searching_path.nil?
+            searching_path = ::File.expand_path(context_path, @source_path_abs)
+
+            unless searching_path.start_with?(@source_path_abs)
+              raise "You can't search from folder (#{searching_path}) that is not sub folder of the source_path (#{source_path}) expanded to (#{@source_path_abs})."
+            end
+
+            files = __find_files(pattern, groups, searching_path)
+          end
+
+          if files.empty? && context_path != source_path
+            files = __find_files(pattern, groups, @source_path_abs, searching_path || @source_path_abs)
+          end
+
+          if files.empty? && search_everywhere && !pattern.start_with?('**')
+            files = __find_files('**/' + pattern, groups, @source_path_abs, searching_path || @source_path_abs)
+          end
+
+          files
+        end
+
+        # Looks for all files from #source_path recursively
+        #
+        # @param [String] pattern  pattern of the desired files
+        # @param [Array<Symbol>] groups  list of group names, nil or empty array for all groups, for valid values see GROUP_EXTENSIONS
+        # @param [String] context_path  path for root of searching, it is also defines start folder of relative path
+        #
+        # @return [Array<String>] list of founded files
+        #
+        def find_all(pattern, groups: nil, context_path: @source_path_abs)
+          __find_files('**/' + pattern, groups, context_path)
+        end
+
+        # @param [Array<String>] paths  list of file paths
+        # @param [Array<Symbol>] groups  list of groups to filter file paths
+        #
+        # @return [Array<String>] filtered list of file paths
+        #
+        def self.group_filter_paths(paths, groups)
+          # filter depend on group
+          groups = Array(groups)
+
+          if groups.empty?
+            paths
+          else
+            valid_extensions = groups.map do |group|
+              GROUP_EXTENSIONS.fetch(group) { raise ::StandardError, "Unknown file group #{group.inspect}" }
+            end.flatten
+
+            paths.select do |file_path|
+              valid_extensions.include?(::File.extname(file_path))
+            end
+          end
+        end
+
+        # @param [Array<String>] paths  list of file paths
+        # @param [String] context_path
+        #
+        # @return [Array<String>] mapped list of file paths
+        #
+        def self.relative_paths_from(paths, context_path)
+          context_pathname = Pathname.new(context_path)
+          paths.map do |path|
+            Pathname(path.unicode_normalize).relative_path_from(context_pathname).to_s
+          end
+        end
+
+        private
+
+        # Looks for files at given context path, if there is no file, it will try again with pattern for any extension
+        #
+        # @param [String] pattern  pattern of the desired files
+        # @param [Array<Symbol>] groups  list of group names, nil or empty array for all groups, for valid values see GROUP_EXTENSIONS
+        # @param [String] context_path  path for root of searching, it is also defines start folder of relative path
+        # @param [String] orig_context_path  original context path, wo it will work nicely with iterative searching
+        #
+        # @return [Array<String>] list of founded files
+        #
+        def __find_files(pattern, groups, context_path, orig_context_path = context_path)
+          # remove fragment from pattern
+          pattern = pattern.sub(/#.*$/, '') if pattern.include?('#')
+
+          files = __core_find_files(pattern, groups, context_path, orig_context_path)
+
+          # try to find files with any extension
+          files = __core_find_files(pattern + '.*', groups, context_path, orig_context_path) if files.empty?
+
+          files
+        end
+
+        # Core method for finding files, it only search for files, filter by input groups and map the final paths to pretty relative paths from context_path
+        #
+        # @param [String] pattern  pattern of the desired files
+        # @param [Array<Symbol>] groups  list of group names, nil or empty array for all groups, for valid values see GROUP_EXTENSIONS
+        # @param [String] context_path  path for root of searching, it is also defines start folder of relative path
+        # @param [String] orig_context_path  original context path, wo it will work nicely with iterative searching
+        #
+        # @return [Array<String>] list of founded files
+        #
+        def __core_find_files(pattern, groups, context_path, orig_context_path = context_path)
+          context_path = __core_file?(context_path) ? File.dirname(context_path) : context_path
+          orig_context_path = __core_file?(orig_context_path) ? File.dirname(orig_context_path) : orig_context_path
+
+          full_pattern = File.expand_path(pattern, context_path)
+          file_paths = __core_find_files_from_pattern(full_pattern).map(&:unicode_normalize)
+
+          file_paths.reject! do |path|
+            File.directory?(path)
+          end
+
+          # remove any files that should be ignored
+          file_paths.reject! do |path|
+            ignored_patterns.any? { |exclude_pattern| File.fnmatch(exclude_pattern, path) }
+          end
+
+          file_paths = self.class.group_filter_paths(file_paths, groups)
+
+          # create relative path to context path
+          self.class.relative_paths_from(file_paths, orig_context_path)
+        end
+
+        def __core_find_files_from_pattern(pattern)
+          raise 'Implement this in subclass'
+        end
+
+        def __core_file?(path)
+          raise 'Implement this in subclass'
+        end
+      end
+    end
+  end
+end