RubyGems - kitabu - Versions diffs - 0.4.5 - Mend

kitabu 0.4.5

Files changed (454) hide show

data/lib/kitabu.rb ADDED Viewed

@@ -0,0 +1,50 @@
+# encoding: utf-8
+require "rubygems"
+require "yaml"
+require "erb"
+require "ostruct"
+require "rexml/streamlistener"
+require "rexml/document"
+require "activesupport"
+$:.unshift File.dirname(__FILE__)
+require "kitabu/base"
+require "kitabu/toc"
+require "kitabu/syntax"
+require "kitabu/templates"
+vendor = File.dirname(__FILE__) + "/kitabu/vendor/"
+dir = RUBY_VERSION =~ /^1.9/ ? "ruby1.9" : "ruby1.8"
+$:.unshift File.join(vendor, dir, "plist")
+$:.unshift File.join(vendor, dir, "textpow")
+$:.unshift File.join(vendor, dir, "uv")
+$:.unshift File.join(vendor, "colorize")
+begin
+  require "nokogiri"
+rescue LoadError
+  nil
+end
+begin
+  require "hpricot"
+rescue LoadError
+  nil
+end unless defined?(Nokogiri)
+require "colorize"
+begin
+  require "plist"
+  require "textpow"
+  require "uv"
+rescue LoadError => e
+  NO_SYNTAX_HIGHLIGHT = true
+end
+module Kitabu
+  VERSION = "0.4.5"
+end

data/lib/kitabu/base.rb ADDED Viewed

@@ -0,0 +1,271 @@
+# 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 ADDED Viewed

@@ -0,0 +1,179 @@
+# 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: 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