verku 0.8.0.p

data/lib/verku/adapters/markdown.rb

@@ -0,0 +1,44 @@
+module Kitabu
+  class Markdown
+    # Supported Markdown libraries
+    #
+    MARKDOWN_LIBRARIES = %w[Kramdown]
+
+    # Retrieve preferred Markdown processor.
+    # You'll need one of the following libraries:
+    #
+    # # RDiscount: https://rubygems.org/gems/rdiscount
+    # # Maruku: https://rubygems.org/gems/maruku
+    # # PEGMarkdown: https://rubygems.org/gems/rpeg-markdown
+    # # BlueCloth: https://rubygems.org/gems/bluecloth
+    # # Redcarpet: https://rubygems.org/gems/redcarpet
+    # # Kramdown: http://kramdown.rubyforge.org/
+    #
+    # Note: RDiscount will always be installed as Kitabu's dependency but only used when no
+    # alternative library is available.
+    #
+    def self.engine
+      @engine ||= Object.const_get(MARKDOWN_LIBRARIES.find {|lib| Object.const_defined?(lib)})
+    end
+
+    def self.to_latex(content)
+      case engine.name
+      when "Redcarpet"
+        # render = Redcarpet::Render::HTML.new(:hard_wrap => true, :xhtml => true)
+        # Redcarpet::Markdown.new(render).render(content)
+      else
+        engine.new(content).to_latex
+      end
+    end
+    # Convert Markdown to HTML.
+    def self.to_html(content)
+      case engine.name
+      when "Redcarpet"
+        render = Redcarpet::Render::HTML.new(:hard_wrap => true, :xhtml => true)
+        Redcarpet::Markdown.new(render).render(content)
+      else
+        engine.new(content).to_html
+      end
+    end
+  end
+end

data/lib/verku/cli.rb

@@ -0,0 +1,93 @@
+# -*- encoding: utf-8 -*-
+require 'thor'
+require 'verku/version'
+module Verku
+  class Cli < Thor
+    FORMATS = %w[pdf draft proof html epub mobi txt]
+    check_unknown_options!
+    
+    def self.exit_on_failure?
+      true
+    end
+    def initialize(args = [], options = {}, config = {})
+      if (config[:current_task] || config[:current_command]).name == "new" && args.empty?
+        raise Error, "The e-Book path is required. For details run: verku help new"
+      end
+      super
+    end
+    
+    desc "create", "Start new work"
+    map %w(create new) => :create
+    def create(path)
+      puts "Verku -- A Million Monkeys Writing Your Masterpiece."
+      generator = Generator.new
+      generator.destination_root = path.squish.gsub(' ','-')
+      generator.invoke_all
+    end
+    
+    desc "compile [OPTIONS]", "Export e-book"
+    map %w(compile export build) => :export
+    method_option :only, :type => :string, :desc => "Can be one of: #{FORMATS.join(", ")}"
+    method_option :open, :type => :boolean, :desc => "Automatically open PDF (Preview.app for Mac OS X and xdg-open for Linux)"
+    def export
+      inside_ebook!
+      if options[:only] && !FORMATS.include?(options[:only])
+        raise Error, "The --only option need to be one of: #{FORMATS.join(", ")}"
+      end
+      Verku::Exporter.run(root_dir, options)
+    end
+    
+    desc "pdf", "Export PDF only"
+    def pdf
+      inside_ebook!
+      Verku::Exporter.run(root_dir, {:only => 'pdf'})
+    end
+    
+    desc "version", "Prints the Verku's version information"
+    map %w(-v --version) => :version
+    def version
+      say "Verku version #{Verku::Version::STRING}"
+    end
+    
+    desc "stats", "Display some stats about your e-book"
+    def stats
+      inside_ebook!
+      stats = Verku::Stats.new(root_dir)
+
+      say [
+        # "Chapters: #{stats.chapters}",
+        "Goal:   #{sprintf("%7d", stats.target)}",
+        "Words:  #{sprintf("%7d", stats.words)}",
+        "        -------",
+        "Left:   #{sprintf("%7d", stats.remaining)}",
+        "\nProgress: #{sprintf("%5d", stats.today)}"
+      ].join("\n")
+    end
+
+    desc "move old_id new_id", "Move scene to new sequence."
+    def move(oid,nid)
+      s = Structure.new(root_dir)
+      s.move(oid,nid)
+    end
+    desc "trash [OPTIONS]", "Move scene to trash."
+    def trash(scene_id)
+      s = Structure.new(root_dir)
+      s.trash(scene_id)
+    end
+    private
+      def config
+        YAML.load_file(config_path).with_indifferent_access
+      end
+      def config_path
+        root_dir.join("_verku.yml")
+      end
+      def root_dir
+        @root ||= Pathname.new(Dir.pwd)
+      end
+      def inside_ebook!
+        unless File.exist?(config_path)
+          raise Error, "You have to run this command from inside an e-book directory."
+        end
+      end
+  end
+end

data/lib/verku/dependency.rb

@@ -0,0 +1,19 @@
+module Verku
+  class Dependency
+    def self.kindlegen?
+      @kindlegen ||= `which kindlegen` && $?.success?
+    end
+
+    def self.xelatex?
+      @xelatex ||= `which xelatex` && $?.success?
+    end
+
+    def self.html2text?
+      @html2text ||= `which html2text` && $?.success?
+    end
+
+    def self.pygments_rb?
+      @pygments_rb ||= defined?(Pygments)
+    end
+  end
+end

data/lib/verku/exporter.rb

@@ -0,0 +1,77 @@
+module Verku
+  class Exporter
+    def self.run(root_dir, options)
+      exporter = new(root_dir, options)
+      exporter.export!
+    end
+
+    attr_accessor :root_dir
+    attr_accessor :options
+
+    def initialize(root_dir, options)
+      @root_dir = root_dir
+      @options = options
+    end
+
+    def ui
+      @ui ||= Thor::Base.shell.new
+    end
+
+    def export!
+      helper = root_dir.join("config/helper.rb")
+      load(helper) if helper.exist?
+
+      raise "Missing Templates directory (_templates)" unless File.exist?("_templates")
+      raise "Missing Images directory (_images)" unless File.exist?("_images")
+      raise "Missing Output directory (builds)" unless File.exist?("builds")
+
+      puts "Missing Kindlegen" unless Dependency.kindlegen?
+      puts "Missing XeLatex" unless Dependency.xelatex?
+      # puts "Missing Html2Text" unless Dependency.html2text?
+
+      export_pdf  = [nil, "pdf"].include?(options[:only])
+      export_html = [nil, "html", "mobi", "epub"].include?(options[:only])
+      export_epub = [nil, "mobi", "epub"].include?(options[:only])
+      export_mobi = [nil, "mobi"].include?(options[:only])
+      export_txt  = [nil, "txt"].include?(options[:only])
+
+      exported = []
+      exported << Parser::PDF.parse(root_dir) if export_pdf && Dependency.xelatex?# && Dependency.prince?
+      exported << Parser::HTML.parse(root_dir) if export_html 
+      epub_done = Parser::Epub.parse(root_dir) if export_epub
+      exported << epub_done
+      exported << Parser::Mobi.parse(root_dir) if export_mobi && epub_done && Dependency.kindlegen?
+      # exported << Parser::Txt.parse(root_dir) if export_txt && Dependency.html2text?
+
+      if exported.all?
+        color = :green
+        message = options[:auto] ? "exported!" : "** e-book has been exported"
+
+        if options[:open] && export_pdf
+          filepath = root_dir.join("output/#{File.basename(root_dir)}.pdf")
+
+          if RUBY_PLATFORM =~ /darwin/
+            IO.popen("open -a Preview.app '#{filepath}'").close
+          elsif RUBY_PLATFORM =~ /linux/
+            Process.detach(Process.spawn("xdg-open '#{filepath}'", :out => "/dev/null"))
+          end
+        end
+
+        Notifier.notify(
+          :image   => Verku::ROOT.join("_templates/ebook.png"),
+          :title   => "Verku",
+          :message => "Your \"#{config[:title]}\" e-book has been exported!"
+        )
+      else
+        color = :red
+        message = options[:auto] ? "could not be exported!" : "** e-book couldn't be exported"
+      end
+
+      ui.say message, color
+    end
+
+    def config
+      Verku.config(root_dir)
+    end
+  end
+end

data/lib/verku/extensions/string.rb

@@ -0,0 +1,19 @@
+class String
+  def to_permalink
+    str = ActiveSupport::Multibyte::Chars.new(self.dup)
+    str = str.normalize(:kd).gsub(/[^\x00-\x7F]/,'').to_s
+    str.gsub!(/[^-\w\d]+/xim, "-")
+    str.gsub!(/-+/xm, "-")
+    str.gsub!(/^-?(.*?)-?$/, '\1')
+    str.downcase!
+    str
+  end
+  def to_latex
+  	require 'kramdown'
+  	Kramdown::Document.new(self.dup).to_latex
+  end
+  def to_html
+  	require 'kramdown'
+  	Kramdown::Document.new(self.dup).to_html
+  end
+end

data/lib/verku/generator.rb

@@ -0,0 +1,55 @@
+module Verku
+  class Generator < Thor::Group
+    include Thor::Actions
+    def self.source_root
+      File.dirname(__FILE__) + "/../../templates"
+    end
+    def build_config_file
+      # require "uuidtools"
+      @title = File.basename(destination_root).gsub('-', ' ')
+      @name = full_name
+      @uuid = SecureRandom.uuid
+      @year = Date.today.year
+      template "config.erb", "_verku.yml"
+      template "readme.erb", "README.md"
+    end
+    def copy_templates
+      copy_file "pdf/layout.erb",         "_templates/pdf/layout.erb"
+      copy_file "merovex-logo.png",       "_images/logo.png"
+      
+      copy_file "html/layout.erb",        "_templates/html/layout.erb"
+      copy_file "html/thanks.erb",        "_templates/html/thanks.erb"
+      copy_file "html/copyright.erb",     "_templates/html/copyright.erb"
+      copy_file "html/user.css",          "_templates/html/user.css"
+      copy_file "html/layout.css",        "_templates/html/layout.css"
+      copy_file "html/syntax.css",        "_templates/html/syntax.css"
+
+      copy_file "epub/back.erb",          "_templates/epub/back.html"
+      copy_file "epub/copyright.erb",     "_templates/epub/copyright.erb"
+      copy_file "epub/cover.erb",         "_templates/epub/cover.erb"
+      copy_file "epub/cover.html",        "_templates/epub/cover.html"
+      copy_file "epub/page.erb",          "_templates/epub/page.erb"
+      copy_file "epub/user.css",          "_templates/epub/user.css"
+
+      copy_file "cover.jpg",              "_images/cover.jpg"
+      copy_file "rakefile.rb",            "Rakefile"
+      copy_file "extras.tex",             "_extras/dedications.tex"
+    end
+    def copy_sample_text
+      directory "text", "text"
+    end
+    def create_directories
+      empty_directory "builds"
+      empty_directory "docs"
+      empty_directory "_images"
+    end
+    private
+      # Retrieve user's name using finger.
+      # Defaults to <tt>John Doe</tt>.
+      #
+      def full_name
+        name = `finger $USER 2> /dev/null | grep Login | colrm 1 46`.chomp
+        name.empty? ? "John Doe" : name.squish
+      end
+  end
+end

data/lib/verku/parser.rb

@@ -0,0 +1,85 @@
+require 'open3'
+
+module Verku
+  module Parser
+    autoload :HTML  , "verku/parser/html"
+    autoload :PDF   , "verku/parser/pdf"
+    autoload :Epub  , "verku/parser/epub"
+    autoload :Mobi  , "verku/parser/mobi"
+#    autoload :Txt   , "verku/parser/txt"
+
+    class Base
+      # The e-book directory.
+      #
+      attr_accessor :root_dir
+
+      # Where the text files are stored.
+      #
+      attr_accessor :source
+
+      def self.parse(root_dir)
+        new(root_dir).parse
+      end
+
+      def initialize(root_dir)
+        @root_dir = Pathname.new(root_dir)
+        @source = root_dir.join("text")
+      end
+
+      # Return directory's basename.
+      #
+      def name
+        File.basename(root_dir)
+      end
+
+      # Return the configuration file.
+      #
+      def config
+        Verku.config(root_dir)
+      end
+      def entries
+        return @entries unless @entries.nil?
+        files = Dir["text/**/*.tex"]
+        @entries = {}
+        files.each do |f|
+          k = File.dirname(f)
+          k.gsub!('text/','')
+          @entries[k] = [] if @entries[k].nil?
+          @entries[k] << f
+        end
+        return @entries
+      end
+      def render_template(file, locals = {})
+        ERB.new(File.read(file)).result OpenStruct.new(locals).instance_eval{ binding }
+      end
+      def read_content(file)
+        content = File.read(file)
+        data = {}
+        begin
+# YAML_FRONT_MATTER_REGEXP = /\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)/m
+          if    content   =~ /\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)/m
+            # content = "\n#{$'}\n"
+            content = $POSTMATCH
+            data = SafeYAML.load($1)
+            # data = YAML.load($1)
+          end
+          return [content, data]
+        rescue SyntaxError => e
+          puts "YAML Exception reading #{path}: #{e.message}"
+        rescue Exception => e
+          puts "Error reading file #{path}: #{e.message}"
+        end
+      end
+      def spawn_command(cmd)
+        begin
+          stdout_and_stderr, status = Open3.capture2e(*cmd)
+        rescue Errno::ENOENT => e
+          puts e.message
+        else
+          puts stdout_and_stderr unless status.success?
+          status.success?
+        end
+      end
+    end
+  end
+end

data/lib/verku/parser/epub.rb

@@ -0,0 +1,187 @@
+require 'fileutils'
+module Verku
+  module Parser
+    class Epub < Base
+      def sections
+        @sections ||= html.css("div.chapter").each_with_index.map do |chapter, index|
+          OpenStruct.new({
+            :index    => index,
+            :filename => "section_#{index}.html",
+            :filepath => tmp_dir.join("section_#{index}.html").to_s,
+            :html     => Nokogiri::HTML(chapter.inner_html)
+          })
+        end
+      end
+      def epub; @epub ||= EeePub.make ;end
+      def html; @html ||= Nokogiri::HTML(html_path.read); end
+      def parse
+        puts "-- Exporting EPUB"
+        epub.title        config["title"]
+        epub.language     config["language"]
+        epub.creator      config["authors"].to_sentence
+        epub.publisher    config["publisher"]
+        epub.date         config["published_at"]
+        epub.uid          config["uid"]
+        epub.identifier   config["identifier"]["id"], :scheme => config["identifier"]["type"]
+        if cover_image.nil?
+          puts "   - Consider adding a cover images in /images."
+        else
+          epub.cover      cover_image
+        end
+        write_coverpage!
+        write_thankspage!
+        write_copyright!
+        write_sections!
+        write_backpage!
+        write_toc!
+        epub.files    cover_page + thanks_page + sections.map(&:filepath) + back_page + copyright_page + assets
+        epub.nav      navigation
+
+        epub.save(epub_path)
+        true
+      rescue Exception
+        p $!, $@
+        false
+      end
+      def back_page
+        return Dir[back_path] if File.exist?(back_path)
+        []
+      end
+      def cover_page
+        Dir[cover_path]
+      end
+      def copyright_page
+        Dir[copyright_path]
+      end
+      def thanks_page
+        Dir[thanks_path]
+      end
+      def write_backpage!
+        contents = render_template(root_dir.join("_templates/epub/back.html"), config)
+        File.open(back_path,"w") do |file|
+          file << contents
+        end
+      end
+      def write_coverpage!
+        contents = render_template(root_dir.join("_templates/epub/cover.html"), config)
+        puts "Writing cover page. #{cover_path}"
+        # 
+        # raise File.dirname(cover_path).inspect
+        FileUtils.mkdir_p(File.dirname(cover_path))
+        File.open(cover_path,"w") do |file|
+          file << contents
+        end
+      end
+      def write_copyright!
+        contents = render_template(root_dir.join("_templates/html/copyright.erb"), config)
+        # File.open('help.html','w').write(contents)
+        FileUtils.mkdir_p(File.dirname(copyright_path))
+        File.open(copyright_path,"w") do |file|
+          file << contents
+        end
+      end
+      def write_thankspage!
+        contents = render_template(root_dir.join("_templates/html/thanks.erb"), config)
+        # File.open('help.html','w').write(contents)
+        FileUtils.mkdir_p(File.dirname(thanks_path))
+        File.open(thanks_path,"w") do |file|
+          file << contents
+        end
+      end
+      def write_toc!
+        toc = TOC::Epub.new(navigation)
+        FileUtils.mkdir_p(File.dirname(toc_path))
+        File.open(toc_path, "w") do |file|
+          file << toc.to_html
+        end
+      end
+
+      def write_sections!
+        # First we need to get all ids, which are used as
+        # the anchor target.
+        links = sections.inject({}) do |buffer, section|
+          section.html.css("[id]").each do |element|
+            anchor = "##{element["id"]}"
+            buffer[anchor] = "#{section.filename}#{anchor}"
+          end
+
+          buffer
+        end
+
+        # Then we can normalize all links and
+        # manipulate other paths.
+        #
+        sections.each do |section|
+          section.html.css("a[href^='#']").each do |link|
+            href = link["href"]
+            link.set_attribute("href", links.fetch(href, href))
+          end
+
+          # Replace all srcs.
+          #
+          section.html.css("[src]").each do |element|
+            src = File.basename(element["src"]).gsub(/\.svg$/, ".png")
+            element.set_attribute("src", src)
+            element.set_attribute("alt", "")
+            element.node_name = "img"
+          end
+
+          FileUtils.mkdir_p(tmp_dir)
+          File.open(section.filepath, "w") do |file|
+            body = section.html.css("body").to_xhtml.gsub(%r[<body>(.*?)</body>]m, "\\1")
+            file << render_chapter(body)
+          end
+        end
+      end
+      def render_chapter(content)
+        locals = config.merge(:content => content)
+        render_template(template_path, locals)
+      end
+      def assets
+        @assets ||= begin
+          assets = Dir[root_dir.join("_templates/epub/*.css")]
+          assets += Dir[root_dir.join("images/**/*.{jpg,png,gif}")]
+          assets
+        end
+      end
+      def cover_image
+        path = Dir[root_dir.join("images/cover-#{name}.{jpg,png,gif}").to_s.downcase].first
+        return File.basename(path) if path && File.exist?(path)
+      end
+      def navigation
+        sections.map do |section| {
+            :label => section.html.css("h2:first-of-type").text,
+            :content => section.filename
+          }
+        end
+      end
+      def template_path
+        root_dir.join("_templates/epub/page.erb")
+      end
+      def html_path
+        root_dir.join("builds/#{name}.html")
+      end
+      def epub_path
+        root_dir.join("builds/#{name}.epub")
+      end
+      def tmp_dir
+        root_dir.join("builds/tmp")
+      end
+      def cover_path
+        tmp_dir.join("cover.html")
+      end
+      def thanks_path
+        tmp_dir.join("thanks.html")
+      end
+      def back_path
+        tmp_dir.join("back.html")
+      end
+      def copyright_path
+        tmp_dir.join("copyright.html")
+      end
+      def toc_path
+        tmp_dir.join("toc.html")
+      end
+    end
+  end
+end