jekyll/bin/jekyll

#!/usr/bin/env ruby

$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])

help = <<HELP
Jekyll is a blog-aware, static site generator.

Basic Command Line Usage:
  jekyll                                                   # . -> ./_site
  jekyll <path to write generated site>                    # . -> <path>
  jekyll <path to source> <path to write generated site>   # <path> -> <path>

  Configuration is read from '<source>/_config.yml' but can be overriden
  using the following options:

HELP

require 'optparse'
require 'jekyll'

exec = {}
options = {}
opts = OptionParser.new do |opts|
  opts.banner = help

  opts.on("--auto", "Auto-regenerate") do
    options['auto'] = true
  end

  opts.on("--no-auto", "No auto-regenerate") do
    options['auto'] = false
  end

  opts.on("--server [PORT]", "Start web server (default port 4000)") do |port|
    options['server'] = true
    options['server_port'] = port unless port.nil?
  end

  opts.on("--lsi", "Use LSI for better related posts") do
    options['lsi'] = true
  end

  opts.on("--pygments", "Use pygments to highlight code") do
    options['pygments'] = true
  end

  opts.on("--rdiscount", "Use rdiscount gem for Markdown") do
    options['markdown'] = 'rdiscount'
  end

  opts.on("--time [TIME]", "Time to generate the site for") do |time|
    options['time'] = Time.parse(time)
  end

  opts.on("--future", "Render future dated posts") do
    options['future'] = true
  end

  opts.on("--no-future", "Do not render future dated posts") do
    options['future'] = false
  end

  opts.on("--permalink [TYPE]", "Use 'date' (default) for YYYY/MM/DD") do |style|
    options['permalink'] = style unless style.nil?
  end
  
  opts.on("--paginate [POSTS_PER_PAGE]", "Paginate a blog's posts") do |per_page|
    begin
      options['paginate'] = per_page.to_i
      raise ArgumentError if options['paginate'] == 0
    rescue
      puts 'you must specify a number of posts by page bigger than 0'
      exit 0
    end
  end

  opts.on("--version", "Display current version") do
    puts "Jekyll " + Jekyll.version
    exit 0
  end
end

# Read command line options into `options` hash
opts.parse!

# Get source and destintation from command line
case ARGV.size
  when 0
  when 1
    options['destination'] = ARGV[0]
  when 2
    options['source']      = ARGV[0]
    options['destination'] = ARGV[1]
  else
    puts "Invalid options. Run `jekyll --help` for assistance."
    exit(1)
end

options = Jekyll.configuration(options)

# Get source and destination directories (possibly set by config file)
source      = options['source']
destination = options['destination']

# Files to watch
def globs(source)
  Dir.chdir(source) do
    dirs = Dir['*'].select { |x| File.directory?(x) }
    dirs -= ['_site']
    dirs = dirs.map { |x| "#{x}/**/*" }
    dirs += ['*']
  end
end

# Create the Site
site = Jekyll::Site.new(options)

# Run the directory watcher for auto-generation, if required
if options['auto']
  require 'directory_watcher'

  puts "Auto-regenerating enabled: #{source} -> #{destination}"

  dw = DirectoryWatcher.new(source)
  dw.interval = 1
  dw.glob = globs(source)

  dw.add_observer do |*args|
    t = Time.now.strftime("%Y-%m-%d %H:%M:%S")
    puts "[#{t}] regeneration: #{args.size} files changed"
    site.process
  end

  dw.start

  unless options['server']
    loop { sleep 1000 }
  end
else
  puts "Building site: #{source} -> #{destination}"
  site.process
  puts "Successfully generated site: #{source} -> #{destination}"
end

# Run the server on the specified port, if required
if options['server']
  require 'webrick'
  include WEBrick

  FileUtils.mkdir_p(destination)

  mime_types = WEBrick::HTTPUtils::DefaultMimeTypes
  mime_types.store 'js', 'application/javascript'

  s = HTTPServer.new(
    :Port            => options['server_port'],
    :DocumentRoot    => destination,
    :MimeTypes       => mime_types
  )
  t = Thread.new {
    s.start
  }

  trap("INT") { s.shutdown }
  t.join()
end