kitabu 0.4.7 → 1.0.0.rc1

data/README.markdown

@@ -1,60 +0,0 @@
-Kitabu
-======
-
-* <http://fnando.github.com/kitabu.html>
-
-DESCRIPTION:
-------------
-
-A framework for creating e-books from Markdown/Textile text markup using Ruby. 
-Using the Prince PDF generator, you'll be able to get high quality PDFs.
-
-While Prince is too expensive (495USD for a single user license), the 
-free version available at [http://www.princexml.com/download/](http://www.princexml.com/download/) generates
-a PDF with a small logo on the first page, which is removed when sent
-to a printer.
-
-FEATURES:
----------
-
-* Write PDF using Markdown or Textile text markup
-* Book layout support
-* Syntax highlight theme based on Textmate
-* Generate a PDF with a single rake task
-* Table of Contents automatically generated from chapter titles
-
-Check it out <http://fnando.github.com/kitabu.html> for details.
-
-MAINTAINER
-----------
- 
-* Nando Vieira (<http://simplesideias.com.br>)
-
-CONTRIBUTORS
-------------
- 
-* Arthur Zapparoli (<http://arthurgeek.net>)
-
-LICENSE:
---------
-
-(The MIT License)
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/VERSION

@@ -1 +0,0 @@
-0.4.6

data/lib/kitabu/base.rb

@@ -1,271 +0,0 @@
-# encoding: utf-8
-module Kitabu
-  module Base
-    DEFAULT_LAYOUT = "boom"
-    DEFAULT_THEME = "eiffel"
-    DEFAULT_SYNTAX = "plain_text"
-    DEFAULT_MARKDOWN_PROCESSOR = "rdiscount"
-    GEM_ROOT = File.expand_path(File.dirname(__FILE__) + "/../../")
-    
-    extend self
-    
-    def root_path
-      defined?(KITABU_ROOT) ? KITABU_ROOT : ENV["KITABU_ROOT"]
-    end
-    
-    def html_path
-      root_path + "/output/#{app_name}.html"
-    end
-    
-    def pdf_path
-      root_path + "/output/#{app_name}.pdf"
-    end
-    
-    def template_path
-      root_path + "/templates/layout.html"
-    end
-    
-    def config_path
-      root_path + "/config.yml"
-    end
-    
-    def text_dir
-      root_path + "/text"
-    end
-    
-    # Load the configuration file
-    def config
-      @config = YAML::load_file(config_path)
-    end
-    
-    # Check if nokogiri is available
-    def nokogiri?
-      defined?(Nokogiri)
-    end
-    
-    # Check if hpricot is available
-    def hpricot?
-      defined?(Hpricot)
-    end
-    
-    # Parse erb template propagating the configuration file
-    # and adding more variables
-    def parse_layout(contents)
-      template = File.new(template_path).read
-      contents, toc = self.table_of_contents(contents)
-      cfg = config.merge(:contents => contents, :toc => toc)
-      env = OpenStruct.new(cfg)
-
-      ERB.new(template).result env.instance_eval{ binding }
-    end
-    
-    def table_of_contents(contents)
-      return [contents, nil] unless nokogiri? || hpricot?
-      
-      if nokogiri?
-        doc = Nokogiri::HTML.parse(contents)
-      else
-        doc = Hpricot(contents)
-      end
-      
-      counter = {}
-
-      doc.search("h2, h3, h4, h5, h6").each do |node|
-        title = node.inner_text
-        permalink = Kitabu::Base.to_permalink(title)
-        
-        # initialize and increment counter
-        counter[permalink] ||= 0
-        counter[permalink] += 1
-        
-        # set a incremented permalink if more than one occurrence
-        # is found
-        permalink = "#{permalink}-#{counter[permalink]}" if counter[permalink] > 1
-        node.set_attribute("id", permalink)
-      end
-      
-      if nokogiri?
-        contents = doc.to_xhtml
-      else
-        contents = doc.to_html
-      end
-      
-      io = StringIO.new(contents)
-      toc = Toc.new
-      REXML::Document.parse_stream(io, toc) rescue nil
-      
-      # Nokogiri wraps any content in a valid HTML structure;
-      # so we should use only the body content. Additionally,
-      # Nokogiri also converts XHTML to HTML. #nokogirisuckhard
-      if nokogiri?
-        doc.to_xhtml.match(/<body>(.*?)<\/body>/xm)
-        contents = $1
-      end
-      
-      [contents, toc.to_s]
-    end
-    
-    def generate_pdf
-      IO.popen("prince %s -o %s" % [html_path, pdf_path]).close
-    end
-    
-    def generate_html
-      # parsed file holder
-      contents = ""
-      
-      # skip some patterns
-      entries = Dir.entries(text_dir).sort.reject do |entry| 
-        %w(. .. .svn .git).include?(entry) || (File.file?(entry) && entry !~ /\.(markdown|textile)$/)
-      end
-      
-      $stdout << "\nNo markup files found!\n" if entries.empty?
-      
-      # first, get all chapters; then, get all parsed markdown
-      # files from this chapter and group them into a <div class="chapter"> tag
-      entries.each do |entry|
-        # gets all parsed markdown files to wrap in a 
-        # chapter element
-        chapter = ""
-        
-        # entry can be a file outside chapter folder
-        file = "#{text_dir}/#{entry}"
-        
-        if File.file?(file)
-          markup_files = [file]
-        else
-          # merge all markdown and textile files into a single list
-          markup_files =  Dir["#{text_dir}/#{entry}/**/*.markdown"] + 
-                          Dir["#{text_dir}/#{entry}/**/*.textile"]
-        end
-        
-        # no files, so skip it!
-        next if markup_files.empty?
-        
-        markup_files.sort.each do |markup_file|
-          # get the file contents
-          markup_contents = File.read(markup_file)
-          
-          # instantiate a markup object
-          begin
-            if markup_file =~ /\.textile$/
-              markup = BlackCloth.new(markup_contents)
-              markup.no_span_caps = true
-            else
-              markup = markdown_processor_class.new(markup_contents)
-            end
-          rescue Exception => e
-            $stdout << "\nSkipping #{markup_file} (#{e.message})"
-            next
-          end
-          
-          # convert the markup into html
-          parsed_contents = markup.to_html
-          
-          # process syntax highlight
-          parsed_contents = Kitabu::Syntax.process(parsed_contents, markup)
-          
-          # add final content to the chapter buffer
-          chapter << (parsed_contents + "\n\n")
-        end
-        
-        # wrap chapter in div, so i can be styled accordingly
-        contents << %[<div class="chapter">%s</div>] % chapter
-      end
-      
-      # create output directory if is missing
-      FileUtils.mkdir(File.dirname(html_path)) unless File.exists?(File.dirname(html_path))
-      
-      # save html file
-      File.open(html_path, "w+") do |f|
-        f << Kitabu::Base.parse_layout(contents)
-      end
-    end
-    
-    def app_name
-      ENV["KITABU_NAME"] || "kitabu"
-    end
-    
-    # Check if the specified theme is available
-    def theme?(theme_name)
-      themes.include?(theme_name)
-    end
-    
-    # Check if the specified syntax is available
-    def syntax?(syntax_name)
-      syntaxes.include?(syntax_name)
-    end
-    
-    # Check if the specified layout is available
-    def layout?(layout_name)
-      layouts.include?(layout_name)
-    end
-    
-    # Wrap the default theme constant in a method
-    def default_theme
-      DEFAULT_THEME
-    end
-    
-    # Wrap the default syntax constant in a method
-    def default_syntax
-      DEFAULT_SYNTAX
-    end
-    
-    # Wrap the default layout constant in a method
-    def default_layout
-      DEFAULT_LAYOUT
-    end
-    
-    # Wrap the default Markdown constant in a method
-    def default_markdown_processor
-      DEFAULT_MARKDOWN_PROCESSOR
-    end
-    
-    # Return the current Markdown class
-    def markdown_processor
-      config["markdown"] || default_markdown_processor
-    end
-    
-    # Select Markdown processor based on string
-    def markdown_processor_class
-      case markdown_processor
-        when "maruku" then Maruku
-        when "bluecloth" then BlueCloth
-        when "peg_markdown" then PEGMarkdown
-        else RDiscount
-      end
-    end
-    
-    # Return a list will all available syntaxes
-    def syntaxes
-      Uv.syntaxes
-    end
-    
-    # Return a list with all available layouts
-    def layouts
-      @layouts ||= begin
-        dir = File.join(GEM_ROOT, "templates/layouts")
-        Dir.entries(dir).reject{|p| p =~ /^\.+$/ }.sort
-      end
-    end
-    
-    # Return a list with all available themes
-    def themes
-      @themes ||= begin
-        filter = File.join(GEM_ROOT, "templates/themes/*.css")
-        Dir[filter].collect{|path| File.basename(path).gsub(/\.css$/, '') }.sort
-      end
-    end
-    
-    # Normalize string by replacing accented characters
-    # for its equivalent.
-    def to_permalink(str)
-      str = ActiveSupport::Multibyte::Chars.new(str)
-      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
-end

data/lib/kitabu/blackcloth.rb

@@ -1,184 +0,0 @@
-# encoding: utf-8
-class BlackCloth < RedCloth
-  @@syntax_blocks = []
-
-  FN_RE = /
-    (\s+)?    # getting spaces
-    %\{       # opening
-    (.*?)     # footnote
-    \}#       # closing
-  /xm
-
-  # Usage: Writing some text with a footnote %{this is a footnote}
-  def inline_textile_fn(text)
-    text.gsub!( FN_RE )  do |m|
-      %(<span class="footnote">#{$2}</span>)
-    end
-
-    text
-  end
-
-  FN_URL_LINK = /
-    <
-    ((?:https?|ftp):\/\/.*?)
-    >
-  /x
-
-  # Usage: <http://google.com>
-  def inline_textile_url_link(text)
-    text.gsub!( FN_URL_LINK ) do |m|
-      %(<a href="#{$1}">#{$1}</a>)
-    end
-  end
-
-  # Usage:
-  # file. app/models/users.rb
-  #
-  # Remember to set `base_url` in your Kitabu configuration file
-  def textile_file(tag, attrs, cite, content)
-    base_url = Kitabu::Base.config["base_url"]
-
-    if base_url
-      url = File.join(base_url, content)
-    else
-      url = content
-      $stdout << "\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}">#{content}</a></span></p>)
-  end
-
-  # Usage:
-  # syntax(ruby). Some code
-  #
-  # getting from line 100 to 200 of file.rb
-  # syntax(ruby 100,200). file.rb
-  #
-  # getting block 'sample' from file.rb
-  # syntax(ruby#sample). file.rb
-  #
-  # to create a block:
-  # #begin: sample
-  #   some code
-  # #end: sample
-  def textile_syntax(tag, attrs, cite, content)
-    # get syntax
-    m, syntax = *attrs.match(/class="(.*?)([# ].*?)?"/)
-    syntax = 'plain_text' if tag == "pre"
-
-    # set source
-    source_file = content
-
-    # get block name
-    m, block_name = *attrs.match(/id="(.*?)"/ms)
-
-    # get line interval
-    m, from_line, to_line = *attrs.match(/class=".*? ([0-9]+),([0-9]+)"/)
-
-    content = Kitabu::Syntax.content_for({
-      :code => content,
-      :syntax => syntax,
-      :source_file => source_file,
-      :block_name => block_name,
-      :from_line => from_line,
-      :to_line => to_line
-    })
-
-    @@syntax_blocks << [syntax, content]
-    position = @@syntax_blocks.size - 1
-    %(@syntax:#{position})
-  end
-
-  def syntax_blocks
-    @@syntax_blocks
-  end
-
-  # Usage: pre. Some code
-  def textile_pre(*args)
-    # Should I add the default theme as a class?
-    send(:textile_syntax, *args)
-  end
-
-  # Usage: note. Some text
-  def textile_note(tag, attrs, cite, content)
-    %(<p class="note">#{content}</p>)
-  end
-
-  # Usage: attention. Some text
-  def textile_attention(tag, attrs, cite, content)
-    %(<p class="attention">#{content}</p>)
-  end
-
-  # Usage: figure(This is the caption). some_image.jpg
-  def textile_figure(tag, attrs, cite, content)
-    m, title = *attrs.match(/class="(.*?)"/)
-
-    width, height = image_size(content)
-
-    %(<p class="figure"><img style="width: #{width}px; height: #{height}px" src="../images/#{content}" alt="#{title}" /><br/><span class="caption">#{title}</span></p>)
-  end
-
-  def image_size(img)
-    IO.popen("file #{Kitabu::Base.root_path}/images/#{img}") do |io|
-      m, width, height = *io.read.match(/([0-9]+) x ([0-9]+)/)
-      return [width.to_i, height.to_i]
-    end
-  end
-
-  # overriding inline method
-  def inline( text )
-    @rules += [:inline_textile_fn, :inline_textile_url_link]
-    super
-  end
-
-  # overriding to_html method
-  def to_html( *rules )
-      rules = DEFAULT_RULES if rules.empty?
-      # make our working copy
-      text = self.dup
-
-      @urlrefs = {}
-      @shelf = []
-      textile_rules = [:refs_textile, :block_textile_table, :block_textile_lists,
-                       :block_textile_prefix, :inline_textile_image, :inline_textile_link,
-                       :inline_textile_code, :inline_textile_span, :glyphs_textile]
-      markdown_rules = [:refs_markdown, :block_markdown_setext, :block_markdown_atx, :block_markdown_rule,
-                        :block_markdown_bq, :block_markdown_lists,
-                        :inline_markdown_reflink, :inline_markdown_link]
-      @rules = rules.collect do |rule|
-          case rule
-          when :markdown
-              markdown_rules
-          when :textile
-              textile_rules
-          else
-              rule
-          end
-      end.flatten
-
-      # standard clean up
-      incoming_entities text
-      clean_white_space text
-
-      # start processor
-      @pre_list = []
-      rip_offtags text
-      no_textile text
-      hard_break text
-      unless @lite_mode
-          refs text
-          blocks text
-      end
-      inline text
-      smooth_offtags text
-
-      retrieve text
-
-      text.gsub!( /<\/?notextile>/, '' )
-      text.gsub!( /x%x%/sm, '&#38;' )
-      clean_html text if filter_html
-      text.strip!
-      text
-
-  end
-end