RubyGems - kitabu - Versions diffs - 0.4.7 → 1.0.0.rc1 - Mend

kitabu 0.4.7 → 1.0.0.rc1

Files changed (544) hide show

@@ -0,0 +1,131 @@
+module Kitabu
+  module Parser
+    class Epub < Html
+      module Toc
+        HEAD = <<-HEAD
+<?xml version='1.0' encoding='utf-8' ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xml:lang='en' xmlns='http://www.w3.org/1999/xhtml'>
+  <head>
+    <meta content='application/xhtml+xml; charset=utf-8' http-equiv='Content-Type' />
+    <title>Table of Contents</title>
+  </head>
+  <body>
+    <div id='toc'>
+      <ul>
+HEAD
+TAIL = <<-TAIL
+      </ul>
+    </div>
+  </body>
+</html>
+TAIL
+        def generate_html(nav)
+          HEAD +
+          nav.map { |element|
+            "<li><a href='#{element[:content]}'>#{element[:label]}</a></li>"
+          }.join +
+          TAIL
+        end
+        def generate_file(*args)
+          filename = "tmp/toc.html"
+          File.open(filename, 'w') { |file| file.write generate_html(*args) }
+          filename
+        end
+        module_function :generate_file, :generate_html
+      end
+      attr_accessor :epub
+      def initialize(*args)
+        super
+        FileUtils.mkdir_p('tmp')
+        @epub = EeePub::Maker.new
+      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
+        assets            = collect_assets
+        sections          = collect_sections
+        filenames         = collect_filenames(sections)
+        epub.files        filenames + assets
+        epub.nav          collect_nav(sections, filenames)
+        epub.toc_page     Toc.generate_file collect_nav(sections, filenames)
+        epub.save(epub_path)
+        true
+      rescue Exception
+        p $!, $@
+        false
+      end
+      def collect_assets
+        [cover_image, File.join(root_dir, "templates", "epub", "style.css")].compact
+      end
+      def cover_image
+        path = root_dir.join('images/cover-epub.jpg')
+        return path if File.exist?(path)
+      end
+      def chapter(entry)
+        files = chapter_files(entry)
+        content = replace_paths(render_chapter(files, true))
+        html = Nokogiri(content)
+        title = html.css("h2").first.text
+        [
+          title,
+          render_template(
+            root_dir.join("templates/epub/page.erb"),
+            {:chapter_title => title, :content => content, :language => config[:language]}
+          )
+        ]
+      end
+      def collect_sections
+        entries.map { |entry| chapter(entry) }
+      end
+      def collect_filenames(sections)
+        index = 0
+        sections.map do |section|
+          index += 1
+          filename = "tmp/section_#{index}.html"
+          File.open(filename, 'w') { |file| file.write section[1] }
+          filename
+        end
+      end
+      def collect_nav(sections, filenames)
+        [sections, filenames].transpose.map do |section, filename|
+          {:label => section[0], :content => File.basename(filename)}
+        end
+      end
+      def replace_paths(text)
+        text.gsub(%r[src="(.*?)"]) {|m| %[src="#{File.basename($1)}"]}
+      end
+      def epub_path
+        root_dir.join("output/#{name}.epub")
+      end
+    end
+  end
+end

data/lib/kitabu/parser/html.rb ADDED

@@ -0,0 +1,174 @@
+module Kitabu
+  module Parser
+    class Html < Base
+      # Supported Markdown libraries
+      #
+      MARKDOWN_LIBRARIES = %w[Maruku BlueCloth PEGMarkdown Redcarpet RDiscount]
+      # List of directories that should be skipped.
+      #
+      IGNORE_DIR = %w[. .. .svn]
+      # Files that should be skipped.
+      #
+      IGNORE_FILES = /^(CHANGELOG|TOC)\..*?$/
+      # List of recognized extensions.
+      #
+      EXTENSIONS = %w[md mkdn markdown textile html]
+      # Parse all files and save the parsed content
+      # to <tt>output/book_name.html</tt>.
+      #
+      def parse
+        File.open(root_dir.join("output/#{name}.html"), "w+") do |file|
+          file << parse_layout(content)
+        end
+        true
+      rescue Exception
+        false
+      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 the configuration file.
+      #
+      def config
+        Kitabu.config(root_dir)
+      end
+      # Return a list of all recognized files.
+      #
+      def entries
+        Dir.entries(source).sort.inject([]) do |buffer, entry|
+          buffer << source.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?(source.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?(source.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 = Kitabu::Syntax.render(root_dir, file_format, File.read(file), plain_syntax)
+        case file_format
+        when :markdown
+          markdown.new(content).to_html
+        when :textile
+          RedCloth.convert(content)
+        else
+          content
+        end
+      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.generate(html)
+        locals = config.merge({
+          :content   => toc.content,
+          :toc       => toc.to_html,
+          :changelog => render_changelog
+        })
+        render_template(root_dir.join("templates/html/layout.erb"), locals)
+      end
+      # Render changelog file.
+      # This file can be used to inform any book change.
+      #
+      def render_changelog
+        changelog = Dir[root_dir.join("text/CHANGELOG.*")].first
+        return render_file(changelog) if changelog
+        nil
+      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
+      # 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
+      # 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
+      #
+      # Note: RDiscount will always be installed as Kitabu's dependency but only used when no
+      # alternative library is available.
+      #
+      def markdown
+        @markdown ||= Object.const_get(MARKDOWN_LIBRARIES.find {|lib| Object.const_defined?(lib)})
+      end
+    end
+  end
+end

data/lib/kitabu/parser/mobi.rb ADDED

@@ -0,0 +1,17 @@
+module Kitabu
+  module Parser
+    class Mobi < Base
+      def parse
+        command = ["kindlegen", epub_file.to_s,]
+        puts command
+        Process.wait Process.spawn(*command)
+        true
+      end
+      def epub_file
+        root_dir.join("output/#{name}.epub")
+      end
+    end
+  end
+end

data/lib/kitabu/parser/pdf.rb ADDED

@@ -0,0 +1,41 @@
+module Kitabu
+  module Parser
+    class Pdf < Base
+      def parse
+        content = File.read(html_file)
+        prince_friendly_footnotes = transform_footnotes(content)
+        transformed_html_file = File.new('output/prince_friendly_footnote_file.html', 'w')
+        transformed_html_file.write prince_friendly_footnotes
+        command = ["prince", transformed_html_file.path, "-o", pdf_file.to_s]
+        Process.wait Process.spawn(*command)
+        transformed_html_file.close
+        File.unlink(transformed_html_file)
+        true
+      end
+      def transform_footnotes(content)
+        doc = Nokogiri::HTML(content)
+        doc.css('a').each do |node|
+          prince_friendly_footnote = <<-FN
+            #{node.text}<span class='fn'><a href='#{node['href']}'>#{node['href']}</a></span>
+          FN
+          node.replace(prince_friendly_footnote)
+        end
+        doc.to_xhtml
+      end
+      def html_file
+        root_dir.join("output/#{name}.html")
+      end
+      def pdf_file
+        root_dir.join("output/#{name}.pdf")
+      end
+    end
+  end
+end

data/lib/kitabu/parser/txt.rb ADDED

@@ -0,0 +1,22 @@
+module Kitabu
+  module Parser
+    class Txt < Base
+      def parse
+        command = ["html2text", "-style", "pretty", "-o", txt_file.to_s, html_file.to_s]
+        puts command.join(' ')
+        Process.wait Process.spawn(*command)
+        true
+      end
+      def html_file
+        root_dir.join("output/#{name}.html")
+      end
+      def txt_file
+        root_dir.join("output/#{name}.txt")
+      end
+    end
+  end
+end

data/lib/kitabu/stream.rb ADDED

@@ -0,0 +1,27 @@
+module Kitabu
+  class Stream
+    attr_accessor :listener, :content
+    attr_reader :html
+    def initialize(content, listener)
+      @content  = content
+      @listener = listener
+      @html = Nokogiri::HTML.parse(content)
+    end
+    def parse
+      traverse(html)
+    end
+    def traverse(node)
+      node.children.each do |child|
+        emit(child)
+        traverse(child)
+      end
+    end
+    def emit(node)
+      listener.send(:tag, node) if node.name =~ /h[2-6]/
+    end
+  end
+end

data/lib/kitabu/syntax.rb CHANGED

@@ -1,126 +1,128 @@
-# encoding: utf-8
 module Kitabu
-  module Syntax
-    extend self
-    def content_for(options)
-      # retrieve the file source
-      source_file = File.join(Kitabu::Base.root_path, "code", options[:source_file].to_s)
-      # shortcut to the code
-      code = options[:code]
-      if options[:source_file] && File.exists?(source_file)
-        # Here's the thing: if the source file has been specified and the
-        # correspondent file exists, process it!
-        file = File.open(source_file, "r")
-        if options[:from_line] && options[:to_line]
-          # Check if there's a line range and if so, set the code to
-          # the chosen lines
-          from_line = options[:from_line].to_i - 1
-          to_line = options[:to_line].to_i
-          offset = to_line - from_line
-          code = file.readlines.slice(from_line, offset).join
-        elsif block_name = options[:block_name]
-          # Check if there's a block name and retrieve it
-          re = %r(# ?begin: ?\b#{block_name}\b ?(?:[^\r\n]+)?\r?\n(.*?)\r?\n([^\r\n]+)?# ?end: \b#{block_name}\b)sim
-          file.read.gsub(re) { |block| code = $1 }
-        else
-          # As last resource, just read the whole file
-          code = file.read
-          code = code.gsub(/&lt;/, '<').gsub(/&gt;/, '>').gsub(/&amp;/, '&')
-        end
-      end
-      # no code? set to default
-      code ||= options[:code]
-      # normalize indentation
-      line = StringIO.new(code).readlines[0]
-      if line =~ /^(\t+)/
-        char = "\t"
-        size = $1.length
-      elsif line =~ /^( +)/
-        char = " "
-        size = $1.length
+  class Syntax
+    attr_reader :io
+    attr_reader :lines
+    attr_reader :root_dir
+    attr_reader :format
+    # Render syntax blocks from specified source code.
+    #
+    #   dir = Pathname.new(File.dirname(__FILE__))
+    #   text = File.read(dir.join("text/some_file.textile"))
+    #   Kitabu::Syntax.render(dir, :textile, text)
+    #
+    def self.render(root_dir, format, source_code, raw = false)
+      source_code.gsub(/@@@(.*?)@@@/m) do |match|
+        new(root_dir, format, $1, raw).process
       end
+    end
-      code.gsub! %r(^#{char}{#{size}}), "" if size.to_i > 0
-      # remove all line stubs
-      code.gsub! %r(^[\t ]*__$), ""
-      code
+    # Process each syntax block individually.
+    #
+    def initialize(root_dir, format, code, raw = false)
+      @format = format
+      @root_dir = root_dir
+      @io = StringIO.new(code)
+      @lines = io.readlines.collect(&:chomp)
+      @language = 'text' if raw
     end
-    def apply(code, syntax, processor)
-      # get chosen theme or default
-      theme = Kitabu::Base.config["theme"]
-      theme = Kitabu::Base.default_theme unless Kitabu::Base.theme?(theme)
-      # get default syntax if no syntax has been set yet
-      syntax = Kitabu::Base.default_syntax if syntax.to_s =~ /^\s*$/ || !Kitabu::Base.syntax?(syntax)
-      # replace ampersand for textile; this is added
-      # by RedCloth
-      code.gsub!(/x%x%/sm, "&") if processor == :textile
-      # do replace PRE tags using the syntax and added classes
-      silence_warnings do
-        code = Uv.parse(code, "xhtml", syntax, false, theme)
-      end
-      code.gsub!(/<pre class="(.*?)"/sim, %(<pre class="\\1 #{syntax}"))
-      code.gsub!(/<pre>/sim, %(<pre class="#{syntax} #{theme}"))
-      code
+    # Return unprocessed line codes.
+    #
+    def raw
+      lines[1..-1].join("\n")
     end
-    def process(content, markup)
-      return content if ENV["NO_SYNTAX_HIGHLIGHT"] || defined?(NO_SYNTAX_HIGHLIGHT)
-      if markup.respond_to?(:syntax_blocks)
-        # textile
-        content = content.gsub(/@syntax:([0-9]+)/m) do |m|
-          syntax, code = markup.syntax_blocks[$1.to_i]
-          Kitabu::Syntax.apply(code, syntax, :textile)
+    # Return meta data from syntax annotation.
+    #
+    def meta
+      @meta ||= begin
+        line = lines.first.squish
+        _, language, file, modifier, reference = *line.match(/^([^ ]+)(?: ([^:#]+)(?:(:|#)(.*?))?)?$/)
+        if modifier == "#"
+          type = :block
+        elsif modifier == ":"
+          type = :range
+        elsif file
+          type = :file
+        else
+          type = :inline
         end
-      else
-        # markdown
-        content = content.gsub /<pre><code>(.*?)<\/code><\/pre>/m do |block|
-          code = $1.gsub(/&lt;/, '<').gsub(/&gt;/, '>').gsub(/&amp;/, '&')
-          code_lines = StringIO.new(code).readlines
-          syntax_settings = code_lines.first
-          syntax = "plain_text"
+        {
+          :language  => language,
+          :file      => file,
+          :type      => type,
+          :reference => reference
+        }
+      end
+    end
-          if syntax_settings =~ /syntax\(.*?\)\./
-            code = code_lines.slice(1, code_lines.size).join
+    # Process syntax block, returning a +pre+ HTML tag.
+    #
+    def process
+      code = raw.to_s.strip_heredoc
+      code = process_file.gsub(/\n^.*?@(begin|end):.*?$/, "") if meta[:file]
-            # syntax
-            m, syntax = *syntax_settings.match(/syntax\(([^ #]+).*?\)./)
+      code = Pygments.highlight(code, :lexer => language)
-            # file name
-            m, source_file = *syntax_settings.match(/syntax\(.*?\)\. +(.*?)$/)
+      # escape for textile
+      code = %[<notextile>#{code}</notextile>] if format == :textile
+      code
+    end
-            # get line interval
-            m, from_line, to_line = *syntax_settings.match(/syntax\(.*? ([0-9]+),([0-9]+)\)/)
+    private
+    # Process line range as in <tt>@@@ ruby some_file.rb:15,20 @@@</tt>.
+    #
+    def process_range(code)
+      starts, ends = meta[:reference].split(",").collect(&:to_i)
+      code = StringIO.new(code).readlines[starts-1..ends-1].join("\n").strip_heredoc.chomp
+    end
-            # get block name
-            m, block_name = *syntax_settings.match(/syntax\(.*?#([0-9a-z_]+)\)/)
+    # Process block name as in <tt>@@@ ruby some_file.rb#some_block @@@</tt>.
+    #
+    def process_block(code)
+      code.gsub!(/\r\n/, "\n")
+      re = %r[@begin: *\b(#{meta[:reference]})\b *[^\n]*\n(.*?)\n[^\n]*@end: \1]im
-            code = Kitabu::Syntax.content_for({
-              :code => code,
-              :from_line => from_line,
-              :to_line => to_line,
-              :block_name => block_name,
-              :source_file => source_file
-            })
-          end
+      if code.match(re)
+        $2.strip_heredoc
+      else
+        "[missing '#{meta[:reference]}' block name]"
+      end
+    end
-          Kitabu::Syntax.apply(code, syntax, :markdown)
+    # Process file and its relatives.
+    #
+    def process_file
+      file_path = root_dir.join("code/#{meta[:file]}")
+      if File.exist?(file_path)
+        code = File.read(file_path)
+        if meta[:type] == :range
+          process_range(code)
+        elsif meta[:type] == :block
+          process_block(code)
+        else
+          code
         end
+      else
+        "[missing 'code/#{meta[:file]}' file]"
       end
     end
+    # Return e-book's configuration.
+    #
+    def config
+      Kitabu.config(root_dir)
+    end
+    # Return the language used for this syntax block. Overrideable
+    # for epub generation.
+    def language
+      @language || meta[:language]
+    end
   end
 end