bookshelf 1.0.0

data/lib/bookshelf/dependency.rb

@@ -0,0 +1,15 @@
+module Bookshelf
+  class Dependency
+    def self.kindlegen?
+      @kindlegen ||= `which kindlegen` && $?.success?
+    end
+
+    def self.prince?
+      @prince ||= `which prince` && $?.success?
+    end
+
+    def self.html2text?
+      @html2text ||= `which html2text` && $?.success?
+    end
+  end
+end

data/lib/bookshelf/errors.rb

@@ -0,0 +1,3 @@
+module Bookshelf
+  class DirectoryAlreadyCreatedError < StandardError; end
+end

data/lib/bookshelf/exporter.rb

@@ -0,0 +1,56 @@
+module Bookshelf
+  class Exporter
+    def self.run(book_dir, options)
+      exporter = new(book_dir, options)
+      exporter.export!
+    end
+
+    attr_accessor :book_dir
+    attr_accessor :options
+
+    def initialize(book_dir, options)
+      @book_dir = book_dir
+      @options = options
+    end
+
+    def ui
+      @ui ||= Thor::Base.shell.new
+    end
+
+    def export!
+      helper = Bookshelf.root_dir.join("config/helper.rb")
+      load(helper) if helper.exist?
+
+      export_pdf = [nil, "pdf"].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::HTML.parse(book_dir)
+      exported << Parser::PDF.parse(book_dir) if export_pdf && Dependency.prince?
+      exported << Parser::Epub.parse(book_dir) if export_epub
+      exported << Parser::Mobi.parse(book_dir) if export_mobi && Dependency.kindlegen?
+      exported << Parser::Txt.parse(book_dir) if export_txt && Dependency.html2text?
+
+      if exported.all?
+        color = :green
+        message = options[:auto] ? "exported!" : "** e-book has been exported"
+        Notifier.notify(
+          :image   => Bookshelf::ROOT.join("templates/ebook.png"),
+          :title   => "Bookshelf",
+          :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
+      Bookshelf.config(book_dir)
+    end
+  end
+end

data/lib/bookshelf/extensions/redcloth.rb

@@ -0,0 +1,69 @@
+module RedCloth
+  INLINE_FORMATTERS = [:textile, :footnote, :link]
+
+  def self.convert(text)
+    new(text).to_html(*INLINE_FORMATTERS)
+  end
+
+  module Inline
+    FN_RE = /
+      (\s+)?     # getting spaces
+      (\\)?%\{   # opening
+      (.*?)      # footnote
+      \}#        # closing
+    /xm
+
+    def footnote(text)
+      text.gsub!(FN_RE) do |m|
+        if $2
+          %[#{$1}%{#{$3}}]
+        else
+          %(<span class="footnote">#{$3}</span>)
+        end
+      end
+    end
+
+    LINK_RE = /
+      <
+      ((?:https?|ftp):\/\/.*?)
+      >
+    /xm
+
+    def link(text)
+      text.gsub!(LINK_RE) do |m|
+        %(<a href="#{$1}">#{$1}</a>)
+      end
+    end
+  end
+
+  module Formatters
+    module HTML
+      def figure(options = {})
+        %[<p class="figure"><img src="../images/#{options[:text]}" alt="#{options[:class]}" /><br/><span class="caption">#{options[:class]}</span></p>]
+      end
+
+      def note(options = {})
+        %[<p class="note">#{options[:text]}</p>]
+      end
+
+      def attention(options = {})
+        %[<p class="attention">#{options[:text]}</p>]
+      end
+
+      def file(options = {})
+        base_url = Bookshelf.config[:base_url]
+
+        if base_url
+          url = File.join(base_url, options[:text])
+        else
+          url = content
+          $stderr << "\nYou're using `file. #{content}` but didn't set base_url in your configuration file.\n"
+        end
+
+        %[<p class="file"><span><strong>Download</strong> <a href="#{url}">#{options[:text]}</a></span></p>]
+      end
+    end
+  end
+end
+
+RedCloth.send(:include, RedCloth::Inline)

data/lib/bookshelf/extensions/string.rb

@@ -0,0 +1,11 @@
+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
+end

data/lib/bookshelf/generator.rb

@@ -0,0 +1,75 @@
+module Bookshelf
+  # The Bookshelf::Generator class will create a new book structure.
+  #
+  #   ebook = Bookshelf::Generator.new
+  #   ebook.destination_root = "/some/path/book-name"
+  #   ebook.invoke_all
+  #
+  class Generator < Thor::Group
+    include Thor::Actions
+
+    desc "Generate a new e-Book structure"
+
+    def self.source_root
+      File.dirname(__FILE__) + "/../../templates"
+    end
+
+    def copy_html_templates
+      copy_file "layout.erb"  , "templates/html/layout.erb"
+      copy_file "layout.css"  , "templates/html/layout.css"
+      copy_file "user.css"    , "templates/html/user.css"
+      copy_file "syntax.css"  , "templates/html/syntax.css"
+    end
+
+    def copy_epub_templates
+      copy_file "cover.erb"   , "templates/epub/cover.erb"
+      copy_file "epub.css"    , "templates/epub/user.css"
+      copy_file "epub.erb"    , "templates/epub/page.erb"
+      copy_file "cover.png"   , "templates/epub/cover.png"
+    end
+
+    def copy_sample_page
+      copy_file "sample.md"   , "text/01_Welcome.md"
+    end
+
+    def copy_config_file
+      @name = full_name
+      @uid = Digest::MD5.hexdigest("#{Time.now}--#{rand}")
+      @year = Date.today.year
+      template "config.erb", "config/bookshelf.yml"
+    end
+
+    def copy_helper_file
+      copy_file "helper.rb", "config/helper.rb"
+    end
+
+    def create_directories
+      empty_directory "output"
+      empty_directory "images"
+      empty_directory "code"
+    end
+
+    def create_git_files
+      create_file ".gitignore" do
+        "output/*.{html,epub,pdf}\noutput/tmp"
+      end
+
+      create_file "output/.gitkeep"
+      create_file "images/.gitkeep"
+      create_file "code/.gitkeep"
+    end
+
+    def copy_guardfile
+      copy_file "Guardfile", "Guardfile"
+    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.present? ? name.squish : "John Doe"
+    end
+  end
+end

data/lib/bookshelf/parser.rb

@@ -0,0 +1,54 @@
+require 'open3'
+
+module Bookshelf
+  module Parser
+    autoload :HTML  , "bookshelf/parser/html"
+    autoload :PDF   , "bookshelf/parser/pdf"
+    autoload :Epub  , "bookshelf/parser/epub"
+    autoload :Mobi  , "bookshelf/parser/mobi"
+    autoload :Txt   , "bookshelf/parser/txt"
+
+    class Base
+      # The e-book directory.
+      #
+      attr_accessor :book_dir
+      
+      def self.parse(book_dir)
+        new(book_dir).parse
+      end
+
+      def initialize(book_dir)
+        @book_dir = Pathname.new(book_dir)
+      end
+
+      # Return directory's basename.
+      #
+      def name
+        File.basename(book_dir)
+      end
+
+      # Return the configuration file.
+      #
+      def config
+        Bookshelf.config(book_dir)
+      end
+
+      # Render a eRb template using +locals+ as data seed.
+      #
+      def render_template(file, locals = {})
+        ERB.new(File.read(file)).result OpenStruct.new(locals).instance_eval{ binding }
+      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/bookshelf/parser/epub.rb

@@ -0,0 +1,146 @@
+module Bookshelf
+  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::Maker.new
+      end
+
+      def html
+        @html ||= Nokogiri::HTML(html_path.read)
+      end
+
+      def parse
+        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]
+        epub.cover_page   cover_image if cover_image && File.exist?(cover_image)
+
+        write_sections!
+        write_toc!
+
+        epub.files    sections.map(&:filepath) + assets
+        epub.nav      navigation
+        epub.toc_page toc_path
+
+        epub.save(epub_path)
+
+        true
+      rescue Exception
+        p $!, $@
+        false
+      end
+
+      def write_toc!
+        toc = TOC::Epub.new(navigation)
+
+        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)
+
+          # Save file to disk.
+          #
+          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[Bookshelf.root_dir.join("templates/epub/*.css")]
+          assets += Dir[Bookshelf.root_dir.join("assets/images/**/*.{jpg,png,gif}")]
+          assets
+        end
+      end
+
+      def cover_image
+        path = Dir[book_dir.join("cover.{jpg,png,gif}").to_s].first
+        return 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
+        Bookshelf.root_dir.join("templates/epub/page.erb")
+      end
+
+      def html_path
+        Bookshelf.root_dir.join("output/#{name}.html")
+      end
+
+      def epub_path
+        Bookshelf.root_dir.join("output/#{name}.epub")
+      end
+
+      def tmp_dir
+        Bookshelf.root_dir.join("output/tmp")
+      end
+
+      def toc_path
+        tmp_dir.join("toc.html")
+      end
+    end
+  end
+end

data/lib/bookshelf/parser/html.rb

@@ -0,0 +1,177 @@
+module Bookshelf
+  module Parser
+    class HTML < Base
+      # List of directories that should be skipped.
+      #
+      IGNORE_DIR = %w[. .. .svn]
+
+      # Files that should be skipped.
+      #
+      IGNORE_FILES = /^(TOC)\..*?$/
+
+      # List of recognized extensions.
+      #
+      EXTENSIONS = %w[md mkdn markdown textile html]
+
+      class << self
+        # The footnote index control. We have to manipulate footnotes
+        # because each chapter starts from 1, so we have duplicated references.
+        #
+        attr_accessor :footnote_index
+      end
+
+      # Parse all files and save the parsed content
+      # to <tt>output/book_name.html</tt>.
+      #
+      def parse
+        reset_footnote_index!
+
+        File.open(Bookshelf.root_dir.join("output/#{name}.html"), "w") do |file|
+          file << parse_layout(content)
+        end
+        true
+      # rescue Exception
+      #   false
+      end
+
+      def reset_footnote_index!
+        self.class.footnote_index = 1
+      end
+
+      # Return all chapters wrapped in a <tt>div.chapter</tt> tag.
+      #
+      def content
+        String.new.tap do |chapters|
+          entries.each do |entry|
+            files = chapter_files(entry)
+
+            # no markup files, so skip to the next one!
+            next if files.empty?
+
+            chapters << %[<div class="chapter">#{render_chapter(files)}</div>]
+          end
+        end
+      end
+
+      # Return a list of all recognized files.
+      #
+      def entries
+        Dir.entries(book_dir).sort.inject([]) do |buffer, entry|
+          buffer << book_dir.join(entry) if valid_entry?(entry)
+          buffer
+        end
+      end
+
+      private
+      def chapter_files(entry)
+        # Chapters can be files outside a directory.
+        if File.file?(entry)
+          [entry]
+        else
+          Dir.glob("#{entry}/**/*.{#{EXTENSIONS.join(",")}}").sort
+        end
+      end
+
+      # Check if path is a valid entry.
+      # Files/directories that start with a dot or underscore will be skipped.
+      #
+      def valid_entry?(entry)
+        entry !~ /^(\.|_)/ && (valid_directory?(entry) || valid_file?(entry))
+      end
+
+      # Check if path is a valid directory.
+      #
+      def valid_directory?(entry)
+        File.directory?(book_dir.join(entry)) && !IGNORE_DIR.include?(File.basename(entry))
+      end
+
+      # Check if path is a valid file.
+      #
+      def valid_file?(entry)
+        ext = File.extname(entry).gsub(/\./, "").downcase
+        File.file?(book_dir.join(entry)) && EXTENSIONS.include?(ext) && entry !~ IGNORE_FILES
+      end
+
+      # Render +file+ considering its extension.
+      #
+      def render_file(file, plain_syntax = false)
+        file_format = format(file)
+        content = Bookshelf::Syntax.render(book_dir, file_format, File.read(file), plain_syntax)
+        content = case file_format
+        when :markdown
+          Markdown.to_html(content)
+        when :textile
+          RedCloth.convert(content)
+        else
+          content
+        end
+
+        render_footnotes(content, plain_syntax)
+      end
+
+      def render_footnotes(content, plain_syntax = false)
+        html = Nokogiri::HTML(content)
+        footnotes = html.css("p[id^='fn']")
+
+        return content if footnotes.empty?
+
+        reset_footnote_index! unless self.class.footnote_index
+
+        footnotes.each do |fn|
+          index = self.class.footnote_index
+          actual_index = fn["id"].gsub(/[^\d]/, "")
+
+          fn.set_attribute("id", "_fn#{index}")
+
+          html.css("a[href='#fn#{actual_index}']").each do |link|
+            link.set_attribute("href", "#_fn#{index}")
+          end
+
+          html.css("a[href='#fnr#{actual_index}']").each do |link|
+            link.set_attribute("href", "#_fnr#{index}")
+          end
+
+          html.css("[id=fnr#{actual_index}]").each do |tag|
+            tag.set_attribute("id", "_fnr#{index}")
+          end
+
+          self.class.footnote_index += 1
+        end
+
+        html.css("body").inner_html
+      end
+
+      def format(file)
+        case File.extname(file).downcase
+        when ".markdown", ".mkdn", ".md"
+          :markdown
+        when ".textile"
+          :textile
+        else
+          :html
+        end
+      end
+
+      # Parse layout file, making available all configuration entries.
+      #
+      def parse_layout(html)
+        toc = TOC::HTML.generate(html)
+        locals = config.merge({
+          :content   => toc.content,
+          :toc       => toc.to_html
+        })
+        render_template(Bookshelf.root_dir.join("templates/html/layout.erb"), locals)
+      end
+
+      # Render all +files+ from a given chapter.
+      #
+      def render_chapter(files, plain_syntax = false)
+        String.new.tap do |chapter|
+          files.each do |file|
+            chapter << render_file(file, plain_syntax) << "\n\n"
+          end
+        end
+      end
+    end
+  end
+end