RubyGems - kitabu - Versions diffs - 0.4.5 - Mend

kitabu 0.4.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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