kitabu 0.4.7 → 1.0.0.rc1

data/lib/kitabu/tasks.rb

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

@@ -1,54 +0,0 @@
-# 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/vendor/colorize/colorize.rb

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

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

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

@@ -1,224 +0,0 @@
-#--###########################################################
-# Copyright 2006, Ben Bleything <ben@bleything.net> and      #
-# Patrick May <patrick@hexane.org>                           #
-#                                                            #
-# Distributed under the MIT license.                         #
-##############################################################
-#++
-# See Plist::Emit.
-module Plist
-  # === Create a plist
-  # You can dump an object to a plist in one of two ways:
-  #
-  # * <tt>Plist::Emit.dump(obj)</tt>
-  # * <tt>obj.to_plist</tt>
-  #   * This requires that you mixin the <tt>Plist::Emit</tt> module, which is already done for +Array+ and +Hash+.
-  #
-  # The following Ruby classes are converted into native plist types:
-  #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time, true, false
-  # * +Array+ and +Hash+ are both recursive; their elements will be converted into plist nodes inside the <array> and <dict> containers (respectively).
-  # * +IO+ (and its descendants) and +StringIO+ objects are read from and their contents placed in a <data> element.
-  # * User classes may implement +to_plist_node+ to dictate how they should be serialized; otherwise the object will be passed to <tt>Marshal.dump</tt> and the result placed in a <data> element.
-  #
-  # For detailed usage instructions, refer to USAGE[link:files/docs/USAGE.html] and the methods documented below.
-  module Emit
-    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.dump</tt> with +self+.
-    def to_plist(envelope = true)
-      return Plist::Emit.dump(self, envelope)
-    end
-
-    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.save_plist</tt> with +self+.
-    def save_plist(filename)
-      Plist::Emit.save_plist(self, filename)
-    end
-
-    # The following Ruby classes are converted into native plist types:
-    #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time
-    #
-    # Write us (via RubyForge) if you think another class can be coerced safely into one of the expected plist classes.
-    #
-    # +IO+ and +StringIO+ objects are encoded and placed in <data> elements; other objects are <tt>Marshal.dump</tt>'ed unless they implement +to_plist_node+.
-    #
-    # The +envelope+ parameters dictates whether or not the resultant plist fragment is wrapped in the normal XML/plist header and footer.  Set it to false if you only want the fragment.
-    def self.dump(obj, envelope = true)
-      output = plist_node(obj)
-
-      output = wrap(output) if envelope
-
-      return output
-    end
-
-    # Writes the serialized object's plist to the specified filename.
-    def self.save_plist(obj, filename)
-      File.open(filename, 'wb') do |f|
-        f.write(obj.to_plist)
-      end
-    end
-
-    private
-    def self.plist_node(element)
-      output = ''
-
-      if element.respond_to? :to_plist_node
-        output << element.to_plist_node
-      else
-        case element
-        when Array
-          if element.empty?
-            output << "<array/>\n"
-          else
-            output << tag('array') {
-              element.collect {|e| plist_node(e)}
-            }
-          end
-        when Hash
-          if element.empty?
-            output << "<dict/>\n"
-          else
-            inner_tags = []
-
-            element.keys.sort.each do |k|
-              v = element[k]
-              inner_tags << tag('key', CGI::escapeHTML(k.to_s))
-              inner_tags << plist_node(v)
-            end
-
-            output << tag('dict') {
-              inner_tags
-            }
-          end
-        when true, false
-          output << "<#{element}/>\n"
-        when Time
-          output << tag('date', element.utc.strftime('%Y-%m-%dT%H:%M:%SZ'))
-        when Date # also catches DateTime
-          output << tag('date', element.strftime('%Y-%m-%dT%H:%M:%SZ'))
-        when String, Symbol, Fixnum, Bignum, Integer, Float
-          output << tag(element_type(element), CGI::escapeHTML(element.to_s))
-        when IO, StringIO
-          element.rewind
-          contents = element.read
-          # note that apple plists are wrapped at a different length then
-          # what ruby's base64 wraps by default.
-          # I used #encode64 instead of #b64encode (which allows a length arg)
-          # because b64encode is b0rked and ignores the length arg.
-          data = "\n"
-          Base64::encode64(contents).gsub(/\s+/, '').scan(/.{1,68}/o) { data << $& << "\n" }
-          output << tag('data', data)
-        else
-          output << comment( 'The <data> element below contains a Ruby object which has been serialized with Marshal.dump.' )
-          data = "\n"
-          Base64::encode64(Marshal.dump(element)).gsub(/\s+/, '').scan(/.{1,68}/o) { data << $& << "\n" }
-          output << tag('data', data )
-        end
-      end
-
-      return output
-    end
-
-    def self.comment(content)
-      return "<!-- #{content} -->\n"
-    end
-
-    def self.tag(type, contents = '', &block)
-      out = nil
-
-      if block_given?
-        out = IndentedString.new
-        out << "<#{type}>"
-        out.raise_indent
-
-        out << block.call
-
-        out.lower_indent
-        out << "</#{type}>"
-      else
-        out = "<#{type}>#{contents.to_s}</#{type}>\n"
-      end
-
-      return out.to_s
-    end
-
-    def self.wrap(contents)
-      output = ''
-
-      output << '<?xml version="1.0" encoding="UTF-8"?>' + "\n"
-      output << '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">' + "\n"
-      output << '<plist version="1.0">' + "\n"
-
-      output << contents
-
-      output << '</plist>' + "\n"
-
-      return output
-    end
-
-    def self.element_type(item)
-      return case item
-        when String, Symbol:          'string'
-        when Fixnum, Bignum, Integer: 'integer'
-        when Float:                   'real'
-        else
-          raise "Don't know about this data type... something must be wrong!"
-      end
-    end
-    private
-    class IndentedString #:nodoc:
-      attr_accessor :indent_string
-
-      @@indent_level = 0
-
-      def initialize(str = "\t")
-        @indent_string = str
-        @contents = ''
-      end
-
-      def to_s
-        return @contents
-      end
-
-      def raise_indent
-        @@indent_level += 1
-      end
-
-      def lower_indent
-        @@indent_level -= 1 if @@indent_level > 0
-      end
-
-      def <<(val)
-        if val.is_a? Array
-          val.each do |f|
-            self << f
-          end
-        else
-          # if it's already indented, don't bother indenting further
-          unless val =~ /\A#{@indent_string}/
-            indent = @indent_string * @@indent_level
-
-            @contents << val.gsub(/^/, indent)
-          else
-            @contents << val
-          end
-
-          # it already has a newline, don't add another
-          @contents << "\n" unless val =~ /\n$/
-        end
-      end
-    end
-  end
-end
-
-# we need to add this so sorting hash keys works properly
-class Symbol #:nodoc:
-  def <=> (other)
-    self.to_s <=> other.to_s
-  end
-end
-
-class Array #:nodoc:
-  include Plist::Emit
-end
-
-class Hash #:nodoc:
-  include Plist::Emit
-end