epuber 0.3.5

data/lib/epuber/checker.rb

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

data/lib/epuber/checker/text_checker.rb

@@ -0,0 +1,129 @@
+# encoding: utf-8
+
+require 'active_support/core_ext/string/access'
+
+require_relative '../ruby_extensions/match_data'
+require_relative '../checker'
+
+
+module Epuber
+  class Checker
+    class TextChecker < Checker
+      class MatchProblem
+        # @param message [String]
+        # @param file_path [String]
+        # @param match [MatchData]
+        #
+        def initialize(match, message, file_path)
+          @match = match
+          @message = message
+          @file_path = file_path
+        end
+
+        # Formats caret symbol with space indent
+        #
+        # @param [Fixnum] indent
+        #
+        # @return [String]
+        #
+        def caret_symbol(indent)
+          ' ' * indent + '^'
+        end
+
+        # Formats caret symbols for indent and length
+        #
+        # @param [Fixnum] length
+        # @param [Fixnum] indent
+        #
+        # @return [String]
+        #
+        def caret_symbols(indent, length)
+          start_sign = caret_symbol(indent)
+          end_sign = if length > 1
+                       caret_symbol(length-2)
+                     else
+                       ''
+                     end
+
+          "#{start_sign}#{end_sign}"
+        end
+
+        def formatted_match_line
+          match_line = @match.matched_string
+          pre_line = @match.pre_match_lines.last || ''
+
+          pre = match_pre_line = pre_line
+          if remove_tabs(match_pre_line).length > 100
+            pre = "#{match_pre_line.first(20)}...#{match_pre_line.last(30)}"
+          end
+
+          pre = remove_tabs(pre)
+
+          post_line = @match.post_match_lines.first || ''
+
+          post = if post_line.length > 50
+                   "#{post_line.first(50)}..."
+                 else
+                   post_line
+                 end
+
+          [pre, match_line, post]
+        end
+
+        def remove_tabs(text)
+          text.gsub("\t", ' ' * 4)
+        end
+
+        def to_s
+          pre_original = @match.pre_match_lines.last || ''
+          pre, match_text, post = formatted_match_line
+
+          pointers = caret_symbols(pre.length, match_text.length)
+
+          %{#{@file_path}:#{@match.line_number} column: #{pre_original.length} --- #{@message}
+  #{pre + match_text.ansi.red + post}
+  #{pointers}}
+        end
+      end
+
+      # @return [String]
+      #
+      attr_accessor :text
+
+      # @return [String]
+      #
+      attr_accessor :file_path
+
+
+
+      # @param file_path [String]
+      # @param text [String]
+      # @param [CompilationContext] compilation_context
+      #
+      # @return nil
+      #
+      def call(file_path, text, compilation_context)
+        @file_path = file_path
+        @text = text
+
+        @block.call(self, text, compilation_context)
+
+        @text = nil
+        @file_path = nil
+      end
+
+      # @param regexp [Regexp]
+      # @param [String] message  message to display, when the regexp found something
+      #
+      def should_not_contain(regexp, message)
+        # find all matches
+        # taken from http://stackoverflow.com/questions/6804557/how-do-i-get-the-match-data-for-all-occurrences-of-a-ruby-regular-expression-in
+        matches = text.to_enum(:scan, regexp).map { Regexp.last_match }
+        matches.each do |match|
+          # @type match [MatchData]
+          UI.print_processing_problem MatchProblem.new(match, message, Config.instance.pretty_path_from_project(file_path))
+        end
+      end
+    end
+  end
+end

data/lib/epuber/checker_transformer_base.rb

@@ -0,0 +1,71 @@
+
+module Epuber
+  class CheckerTransformerBase
+
+    # Type of source value for this checker, valid values are:
+    #    :result_text_xhtml_string     just before writing result xhtml to build folder
+    #
+    # @return [Symbol]
+    #
+    attr_reader :source_type
+
+    # List of options/flags passed in from plugin instance
+    #
+    # @return [Array<Symbol>]
+    #
+    attr_reader :options
+
+    # @return [Proc]
+    #
+    attr_reader :block
+
+
+    # @param [Symbol] type type of checker, see #type
+    # @param [Array<Symbol>] options list of other arguments, usually flags
+    #
+    def initialize(type, *options, &block)
+      @source_type = type
+      @block = block
+
+      valid_options_inst = valid_options
+      options.each do |opt|
+        raise "Unknown option #{opt.inspect}" unless valid_options_inst.include?(opt)
+      end
+      @options = options
+    end
+
+    # @return [Array<Symbol>]
+    #
+    def valid_options
+      [:run_only_before_release]
+    end
+
+
+
+    def call(*args)
+      raise NotImplementedError, 'You should override this method'
+    end
+
+
+
+    # ------------------------------------------------------------------ #
+    # @group Registration
+
+    # @return [Hash<Symbol, Class>]
+    #
+    def self.map_source_type__class
+      {}
+    end
+
+
+    # @param type [Symbol]
+    #
+    # @return [Class]
+    #
+    def self.class_for_source_type(type)
+      checker_class = self.map_source_type__class[type]
+      raise "#{self} class not found for type: #{type.inspect}" if checker_class.nil?
+      checker_class
+    end
+  end
+end

data/lib/epuber/command.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'claide'
+
+module Epuber
+  class PlainInformative < StandardError
+    include CLAide::InformativeError
+
+    def message
+      "[!] #{super}".ansi.red
+    end
+  end
+
+  class Command < CLAide::Command
+    require_relative 'command/compile'
+    require_relative 'command/init'
+    require_relative 'command/server'
+
+    self.abstract_command = true
+    self.command = 'epuber'
+    self.version = VERSION
+    self.description = 'Epuber, easy creating and maintaining e-book.'
+    self.plugin_prefixes = plugin_prefixes + %w(epuber)
+
+    def self.run(argv = [])
+      begin
+        UI.current_command = self
+        super
+        UI.current_command = nil
+
+      rescue => e
+        UI.error!(e)
+
+        UI.current_command = nil
+      end
+    end
+
+    def validate!
+      super
+      UI.current_command = self
+    end
+
+    def run
+      UI.current_command = self
+    end
+
+    protected
+
+    # @return [Epuber::Book::Book]
+    #
+    def book
+      Config.instance.bookspec
+    end
+
+    # @return [void]
+    #
+    # @raise PlainInformative if no .bookspec file don't exists or there are too many
+    #
+    def verify_one_bookspec_exists!
+      bookspec_files = Config.instance.find_all_bookspecs
+      raise PlainInformative, "No `.bookspec' found in the project directory." if bookspec_files.empty?
+      raise PlainInformative, "Multiple `.bookspec' found in current directory" if bookspec_files.count > 1
+    end
+  end
+end

data/lib/epuber/command/compile.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+require 'fileutils'
+require 'os'
+
+require_relative '../command'
+
+
+module Epuber
+  class Command
+    class Compile < Command
+      self.summary = 'Compile targets into multiple EPUB files.'
+      self.arguments = [
+        CLAide::Argument.new('TARGETS', false, true),
+      ]
+
+      def self.options
+        [
+          ['--check',   'Performs additional validation on sources + checks result epub with epubcheck.'],
+          ['--write',   'Performs additional transformations which writes to source files.'],
+          ['--release', 'Create release version of the book, no caching, everything creates from scratch.'],
+        ].concat(super)
+      end
+
+      # @param argv [CLAide::ARGV]
+      #
+      def initialize(argv)
+        @targets_names = argv.arguments!
+        @should_check = argv.flag?('check', false)
+        @should_write = argv.flag?('write', false)
+        @release_version = argv.flag?('release', false)
+
+        super(argv)
+      end
+
+      def validate!
+        super
+        verify_one_bookspec_exists!
+        verify_all_targets_exists!
+      end
+
+      def run
+        super
+
+        puts "compiling book `#{Config.instance.pretty_path_from_project(book.file_path)}`"
+
+        if @release_version
+          # Remove all previous versions of compiled files
+          targets.each do |target|
+            build_path = Epuber::Config.instance.release_build_path(target)
+
+            if ::File.directory?(build_path)
+              FileUtils.remove_dir(build_path, true)
+            end
+          end
+
+          # Build all targets to always clean directory
+          targets.each do |target|
+            compiler = Epuber::Compiler.new(book, target)
+            compiler.compile(Epuber::Config.instance.release_build_path(target), check: true, write: @should_write, release: true, verbose: verbose?)
+
+            archive_name = compiler.epub_name
+
+            if ::File.exists?(archive_name)
+              FileUtils.remove_file(archive_name)
+            end
+
+            archive_path = compiler.archive(archive_name)
+
+            system(%(epubcheck "#{archive_path}"))
+
+            convert_epub_to_mobi(archive_path, ::File.basename(archive_path, '.epub') + '.mobi') if target.create_mobi
+          end
+        else
+          targets.each do |target|
+            compiler = Epuber::Compiler.new(book, target)
+            compiler.compile(Epuber::Config.instance.build_path(target), check: @should_check, write: @should_write, verbose: verbose?)
+            archive_path = compiler.archive(configuration_suffix: 'debug')
+
+            system(%(epubcheck "#{archive_path}")) if @should_check
+
+            convert_epub_to_mobi(archive_path, ::File.basename(archive_path, '.epub') + '.mobi') if target.create_mobi
+          end
+        end
+      end
+
+      private
+
+      # @return [Array<Epuber::Book::Target>]
+      #
+      def targets
+        @targets ||= (
+          targets = @targets_names
+
+          # when the list of targets is nil pick all available targets
+          if targets.empty?
+            book.targets
+          else
+            targets.map { |target_name| book.target_named(target_name) }
+          end
+        )
+      end
+
+      def verify_all_targets_exists!
+        index = targets.index(&:nil?)
+        help! "Not found target `#{@targets_names[index]}' in bookspec `#{book.file_path}'" unless index.nil?
+      end
+
+      def validate_dir(path)
+        if ::File.directory?(path)
+          path
+        end
+      end
+
+      def find_calibre_app
+        locations = `mdfind "kMDItemCFBundleIdentifier == net.kovidgoyal.calibre"`.split("\n")
+        UI.error!("Can't find location of calibre.app to convert EPUB to MOBI.") if locations.empty?
+
+        selected = locations.first
+        UI.warn("Using calibre.app at location #{selected}") if locations.count > 1
+
+        selected
+      end
+
+      def find_calibre_convert_file
+        if OS.osx?
+          ::File.join(find_calibre_app, 'Contents/MacOS/ebook-convert')
+        elsif OS.linux?
+          script_path = '/usr/bin/ebook-convert'
+          UI.error!("Can't find ebook-convert in folder /usr/bin to convert EPUB to MOBI.") unless ::File.executable?(script_path)
+          script_path
+        else
+          UI.error!('Unsupported OS to convert EPUB to MOBI.')
+        end
+      end
+
+      def convert_epub_to_mobi(epub_path, mobi_path)
+        system(find_calibre_convert_file, epub_path, mobi_path)
+      end
+    end
+  end
+end

data/lib/epuber/command/init.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+
+require 'fileutils'
+
+require_relative '../command'
+require_relative '../vendor/ruby_templater'
+
+
+module Epuber
+  class Command
+    class Init < Command
+      self.summary = 'Initialize current folder to use it as Epuber project'
+      self.arguments = [
+        CLAide::Argument.new('PROJECT_NAME', false, true),
+      ]
+
+      # @param argv [CLAide::ARGV]
+      #
+      def initialize(argv)
+        @book_name = argv.arguments!.first
+
+        super(argv)
+      end
+
+      def validate!
+        help! 'You must specify identifier-like name of the book as first argument' if @book_name.nil?
+
+        existing = Dir.glob('*.bookspec')
+        help! "Can't reinit this folder, #{existing.first} already exists." unless existing.empty?
+      end
+
+      def run
+        super
+
+        write_gitignore
+        write_bookspec(@book_name)
+        write_sublime_project(@book_name)
+
+        FileUtils.mkdir_p('images')
+        FileUtils.mkdir_p('fonts')
+        FileUtils.mkdir_p('styles')
+        write_default_style(@book_name)
+
+        FileUtils.mkdir_p('text')
+
+        print_good_bye(@book_name)
+      end
+
+
+      private
+
+      def print_good_bye(book_id)
+        puts <<-END.ansi.green
+Project initialized, please review #{book_id}.bookspec file, remove comments.
+END
+      end
+
+      # Creates <book-id>.bookspec file from template
+      #
+      # @param book_id [String]
+      #
+      # @return [void]
+      #
+      def write_bookspec(book_id)
+        template_path = File.expand_path(File.join('..', 'templates', 'template.bookspec'), File.dirname(__FILE__))
+        rendered = Epuber::RubyTemplater.from_file(template_path)
+                                        .with_locals(book_id: book_id)
+                                        .render
+
+        write("#{book_id}.bookspec", rendered)
+      end
+
+      # Creates <book-id>.sublime-project
+      #
+      # @param book_id [String]
+      #
+      # @return [void]
+      #
+      def write_sublime_project(book_id)
+        text = '{
+  "folders": [
+    {
+      "follow_symlinks": true,
+      "path": ".",
+      "folder_exclude_patterns": [".epuber"],
+      "file_exclude_patterns": ["*.epub"]
+    }
+  ]
+}'
+
+        write("#{book_id}.sublime-project", text)
+      end
+
+      # Creates .gitignore file
+      #
+      # @return [void]
+      #
+      def write_gitignore
+        write('.gitignore', <<-END
+# This is generated with `epuber init`
+*.epub
+*.mobi
+!.epuber/
+.epuber/build
+.epuber/release_build
+
+        END
+        )
+      end
+
+      def write_default_style(book_id)
+        write("styles/#{book_id}.styl", <<-END
+// This is generated with `epuber init` script.
+        END
+        )
+      end
+
+      # @param string [String] text to file
+      # @param file_path [String] path to file
+      #
+      # @return [void]
+      #
+      def write(file_path, string)
+        File.write(file_path, string)
+      end
+
+      # @param text [String]
+      #
+      # @return [String] returned text without new line
+      #
+      def ask(text)
+        print text
+        result = $stdin.gets.chomp
+
+        while result.empty?
+          puts 'Value cannot be empty, please fill it!'.ansi.red
+          print text
+          result = $stdin.gets.chomp
+        end
+
+        result
+      end
+    end
+  end
+end