kitabu 0.4.5

data/lib/kitabu/syntax.rb

@@ -0,0 +1,126 @@
+# 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
+      end
+
+      code.gsub! %r(^#{char}{#{size}}), "" if size.to_i > 0
+      
+      # remove all line stubs
+      code.gsub! %r(^[\t ]*__$), ""
+      code
+    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
+    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)
+        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"
+
+          if syntax_settings =~ /syntax\(.*?\)\./
+            code = code_lines.slice(1, code_lines.size).join
+
+            # syntax
+            m, syntax = *syntax_settings.match(/syntax\(([^ #]+).*?\)./)
+
+            # file name
+            m, source_file = *syntax_settings.match(/syntax\(.*?\)\. +(.*?)$/)
+
+            # get line interval
+            m, from_line, to_line = *syntax_settings.match(/syntax\(.*? ([0-9]+),([0-9]+)\)/)
+
+            # get block name
+            m, block_name = *syntax_settings.match(/syntax\(.*?#([0-9a-z_]+)\)/)
+
+            code = Kitabu::Syntax.content_for({
+              :code => code,
+              :from_line => from_line,
+              :to_line => to_line,
+              :block_name => block_name,
+              :source_file => source_file
+            })
+          end
+
+          Kitabu::Syntax.apply(code, syntax, :markdown)
+        end
+      end
+    end
+  end
+end

data/lib/kitabu/tasks.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+require "kitabu"
+
+begin
+  require Kitabu::Base.markdown_processor.downcase
+rescue LoadError => e
+  puts  "\n#{Kitabu::Base.markdown_processor} gem not found. NO MARKDOWN for you.\n" +
+        "Install using `sudo gem install #{Kitabu::Base.markdown_processor}`.\n"
+end
+
+require File.dirname(__FILE__) + "/redcloth"
+require File.dirname(__FILE__) + "/blackcloth"
+
+if !ENV["NO_SYNTAX_HIGHLIGHT"] && defined?(NO_SYNTAX_HIGHLIGHT)
+  puts  "\nCannot load syntax highlight libraries.",
+        "Check it out the documentation to know how to proceed.",
+        "You can skip this warning by running `export NO_SYNTAX_HIGHLIGHT=1`\n\n"
+end
+
+# extend BlackCloth if module Helpers is defined
+BlackCloth.__send__(:include, ::Helpers) if defined?(::Helpers)
+
+task :default => "auto"
+
+desc "Generate PDF from markup files"
+task :pdf => :html do
+  Kitabu::Base.generate_pdf
+  puts "Your PDF has been generated. Check it out the output directory!"
+  sleep(1) && system("open #{Kitabu::Base.pdf_path}") if RUBY_PLATFORM =~ /darwin/ && ENV["AUTO_OPEN"] == "1"
+end
+
+desc "Generate HTML from markup files"
+task :html do
+  Kitabu::Base.generate_html
+end
+
+desc "List all available syntaxes"
+task :syntaxes do
+  puts Kitabu::Base.syntaxes.sort.join("\n")
+end
+
+desc "List all available themes"
+task :themes do
+  puts Kitabu::Base.themes.sort.join("\n")
+end
+
+desc "List all titles and its permalinks"
+task :titles => :html do
+  contents = File.new(Kitabu::Base.html_path).read
+  output = ""
+  
+  contents.scan(/<h([1-6])(.*?)>(.*?)<\/h[1-6]>/sim) do
+    level = $1.to_i - 1
+    output << "-" * level
+    output << " " if level > 0
+    
+    if level == 0
+      output << Colorize.yellow($3.upcase, :style => :underscore)
+    else
+      output << $3
+    end
+    
+    output << Colorize.green($2.to_s.gsub(/^.*?id=['"](.*?)['"].*?$/, ' #\1'))
+    output << "\n"
+  end
+  
+  puts output
+end
+
+task :watch => :auto
+
+desc "Watch changes and automatically generate html & pdf"
+task :auto do
+  thread = Thread.new do
+    latest_mtime = 0
+
+    trap 'INT' do
+      puts
+      thread.exit
+    end
+
+    loop do
+      files = Dir["./**/*"].reject {|p| p =~ /\.\/output/ }
+      changes = []
+      
+      mtime = files.collect do |file| 
+        mt = File.mtime(file).to_i
+        changes << file if latest_mtime > 0 && mt > latest_mtime
+        mt
+      end.max
+
+      if latest_mtime < mtime
+        if changes.size > 0
+          puts Colorize.yellow("\n\n#{changes.size} file(s) changed") + " - #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
+          changes.each do |file| 
+            puts "  - #{Colorize.blue(file, :options => :highlight)}"
+          end unless latest_mtime == 0
+        end
+        latest_mtime = mtime
+        
+        Kitabu::Base.generate_html
+        Kitabu::Base.generate_pdf
+        puts Colorize.green("== PDF exported!")
+        
+        puts
+      end
+
+      sleep ENV["WAIT"] || 1
+    end
+  end
+
+  thread.join
+end

data/lib/kitabu/templates.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+module Kitabu
+  module Templates
+    TEMPLATES_ROOT = File.join(Kitabu::Base::GEM_ROOT, 'templates')
+    DIRECTORIES = %w(text templates output)
+    
+    extend self
+    
+    def process!(options)
+      options[:layout] ||= Kitabu::Base.default_layout
+      
+      directories!(options)
+      bundle_css!(options)
+      files!(options)
+      config!(options)
+    end
+    
+    def directories!(options)
+      FileUtils.mkdir(options[:path])
+      
+      DIRECTORIES.each do |d|
+        FileUtils.mkdir File.join(options[:path], d)
+      end
+    end
+    
+    def files!(options)
+      copy_file "Rakefile", "#{options[:path]}/Rakefile"
+      copy_file "layouts/#{options[:layout]}/layout.css", "#{options[:path]}/templates/layout.css"
+      copy_file "layouts/#{options[:layout]}/layout.html", "#{options[:path]}/templates/layout.html"
+      copy_file "user.css", "#{options[:path]}/templates/user.css"
+    end
+    
+    def config!(options)
+      template = File.new(File.join(TEMPLATES_ROOT, 'config.yml')).read
+      env = OpenStruct.new(options)
+      contents = ERB.new(template).result env.instance_eval{binding}
+
+      File.open(File.join(options[:path], 'config.yml'), 'w+') << contents
+    end
+    
+    def bundle_css!(options)
+      contents = Dir["#{TEMPLATES_ROOT}/themes/*.css"].collect do |file|
+        File.read(file)
+      end
+
+      File.open("#{options[:path]}/templates/syntax.css", "w+") << contents.join("\n\n")
+    end
+    
+    private
+      def copy_file(from, to)
+        FileUtils.cp File.join(TEMPLATES_ROOT, from), to
+      end
+  end
+end

data/lib/kitabu/toc.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+module Kitabu
+  class Toc
+    include REXML::StreamListener
+
+    def initialize
+      @toc = ""
+      @previous_level = 0
+      @tag = nil
+      @stack = []
+    end
+
+    def header?(tag=nil)
+      tag ||= @tag_name
+      return false unless tag.to_s =~ /h[2-6]/
+      @tag_name = tag
+      return true
+    end
+
+    def in_header?
+      @in_header
+    end
+
+    def tag_start(name, attrs)
+      @tag_name = name
+      return unless header?(name)
+      @in_header = true
+      @current_level = name.gsub!(/[^2-6]/, '').to_i
+      @stack << @current_level
+      @id = attrs["id"]
+    end
+
+    def tag_end(name)
+      return unless header?(name)
+      @in_header = false
+      @previous_level = @current_level
+    end
+
+    def text(str)
+      return unless in_header?
+      @toc << %(<div class="level#{@current_level} #{@id}"><a href="##{@id}"><span>#{str}</span></a></div>)
+    end
+
+    def method_missing(*args)
+    end
+
+    def to_s
+      @toc
+    end
+  end
+end

data/lib/kitabu/vendor/colorize/colorize.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+module Colorize
+  extend self
+  
+  VERSION = "0.0.1"
+  
+  COLORS = {
+    :black   => "30",
+    :blue    => "34",
+    :cyan    => "36",
+    :gray    => "30",
+    :green   => "32",
+    :purple  => "35",
+    :red     => "31",
+    :white   => "37",
+    :yellow  => "33"
+  }
+  
+  BGCOLORS = {
+    :black   => "40",
+    :blue    => "44",
+    :cyan    => "46",
+    :gray    => "47",
+    :green   => "42",
+    :purple  => "45",
+    :red     => "41",
+    :white   => "47",
+    :yellow  => "43"
+  }
+  
+  STYLES = {
+    :highlight => "1",
+    :blink => "5",
+    :underscore => "4"
+  }
+  
+  def puts(string, options={})
+    Kernel.puts apply(string, options)
+  end
+  
+  def apply(string, options={})
+    options = {
+      :style => []
+    }.merge(options)
+    
+    options[:style] = [options[:style]].flatten
+    
+    colors = []
+    
+    options[:color] = options[:color].to_sym if options[:color]
+    options[:bgcolor] = options[:bgcolor].to_sym if options[:bgcolor]
+    
+    colors << COLORS[options[:color]] if options[:color]
+    colors << BGCOLORS[options[:bgcolor]] if options[:bgcolor]
+    
+    options[:style] << :highlight if [options[:color], options[:bgcolor]].include?(:white)
+    
+    options[:style].each do |option|
+      colors << STYLES[option.to_sym]
+    end
+    
+    colors.uniq!
+    colors.compact!
+    
+    if ENV["COLORIZE"] == "0"
+      string
+    else
+      %(\e[#{colors.join(";")}m#{string}\e[0m)
+    end
+  end
+  
+  def method_missing(color_name, *args)
+    if COLORS.keys.include?(color_name.to_sym)
+      string = args.shift
+      options = args.pop || {}
+      apply string, {:color => color_name}.merge(options)
+    else
+      super
+    end
+  end
+end

data/lib/kitabu/vendor/ruby1.8/plist/plist.rb

@@ -0,0 +1,22 @@
+#--
+##############################################################
+# Copyright 2006, Ben Bleything <ben@bleything.net> and      #
+# Patrick May <patrick@hexane.org>                           #
+#                                                            #
+# Distributed under the MIT license.                         #
+##############################################################
+#++
+# = Plist
+#
+# This is the main file for plist.  Everything interesting happens in Plist and Plist::Emit.
+
+require 'base64'
+require 'cgi'
+require 'stringio'
+
+require 'plist/generator'
+require 'plist/parser'
+
+module Plist
+  VERSION = '3.0.0'
+end