hawkins 0.1.0

data/lib/hawkins/guard.rb

@@ -0,0 +1,268 @@
+# encoding: UTF-8
+
+require 'benchmark'
+require 'guard/plugin'
+require 'hawkins'
+require 'jekyll'
+require 'thin'
+
+# Most of this is courtesy of the guard-jekyll-plus gem at
+# https://github.com/imathis/guard-jekyll-plus
+
+module Guard
+  class Hawkins < Plugin
+    def initialize(options={})
+      super
+
+      default_extensions = ::Hawkins::DEFAULT_EXTENSIONS
+
+      @options = {
+        :extensions     => [],
+        :config         => Jekyll::Configuration.new.config_files({}),
+        :drafts         => false,
+        :future         => false,
+        :config_hash    => nil,
+        :silent         => false,
+        :msg_prefix     => 'Jekyll'
+      }.merge(options)
+
+      @config = load_config(@options)
+      @source = local_path(@config['source'])
+      @destination = local_path(@config['destination'])
+      @msg_prefix = @options[:msg_prefix]
+      @app_prefix = 'Hawkins'
+
+      # Convert array of extensions into a regex for matching file extensions
+      # E.g. /\.md$|\.markdown$|\.html$/i
+      extensions  = @options[:extensions].concat(default_extensions).flatten.uniq
+      @extensions = Regexp.new(
+        extensions.map { |e| (e << '$').gsub('\.', '\\.') }.join('|'),
+        true
+      )
+
+      # set Jekyll server thread to nil
+      @server_thread = nil
+
+      # Create a Jekyll site
+      @site = Jekyll::Site.new(@config)
+    end
+
+    def load_config(options)
+      config = jekyll_config(options)
+
+      # Override configuration with option values
+      config['show_drafts'] ||= options[:drafts]
+      config['future']      ||= options[:future]
+      config
+    end
+
+    def reload_config!
+      UI.info "Reloading Jekyll configuration!"
+      @config = load_config(@options)
+    end
+
+    def start
+      build
+      start_server
+      return if @config[:silent]
+      msg = "#{@app_prefix} "
+      msg += "watching and serving at #{@config['host']}:#{@config['port']}#{@config['baseurl']}"
+      UI.info(msg)
+    end
+
+    def reload
+      stop if !@server_thread.nil? && @server_thread.alive?
+      reload_config!
+      start
+    end
+
+    def reload_server
+      stop_server
+      start_server
+    end
+
+    def stop
+      stop_server
+    end
+
+    def run_on_modifications(paths)
+      # At this point we know @options[:config] is going to be an Array
+      # thanks to the call to jekyll_config earlier.
+      reload_config! if @options[:config].map { |f| paths.include?(f) }.any?
+      matched = jekyll_matches paths
+      unmatched = non_jekyll_matches paths
+
+      if matched.size > 0
+        build(matched, "Files changed: ", "  ~ ".yellow)
+      elsif unmatched.size > 0
+        copy(unmatched)
+      end
+    end
+
+    def run_on_additions(paths)
+      matched = jekyll_matches paths
+      unmatched = non_jekyll_matches paths
+
+      if matched.size > 0
+        build(matched, "Files added: ", "  + ".green)
+      elsif unmatched.size > 0
+        copy(unmatched)
+      end
+    end
+
+    def run_on_removals(paths)
+      matched = jekyll_matches paths
+      unmatched = non_jekyll_matches paths
+
+      if matched.size > 0
+        build(matched, "Files removed: ", "  x ".red)
+      elsif unmatched.size > 0
+        remove(unmatched)
+      end
+    end
+
+    private
+
+    def build(files=nil, message='', mark=nil)
+      UI.info "#{@msg_prefix} #{message}" + "building...".yellow unless @config[:silent]
+      if files
+        puts '| '
+        files.each { |file| puts '|' + mark + file }
+        puts '| '
+      end
+      elapsed = Benchmark.realtime { Jekyll::Site.new(@config).process }
+      unless @config[:silent]
+        msg = "#{@msg_prefix} " + "build completed in #{elapsed.round(2)}s ".green
+        msg += "#{@source} → #{@destination}"
+        UI.info(msg)
+      end
+      rescue
+        UI.error("#{@msg_prefix} build has failed") unless @config[:silent]
+        stop_server
+        throw :task_has_failed
+    end
+
+    # Copy static files to destination directory
+    #
+    def copy(files=[])
+      files = ignore_stitch_sources files
+      return false unless files.size > 0
+      begin
+        message = 'copied file'
+        message += 's' if files.size > 1
+        UI.info "#{@msg_prefix} #{message.green}" unless @config[:silent]
+        puts '| '
+        files.each do |file|
+          path = destination_path file
+          FileUtils.mkdir_p(File.dirname(path))
+          FileUtils.cp(file, path)
+          puts '|' + "  → ".green + path
+        end
+        puts '| '
+
+      rescue
+        UI.error "#{@msg_prefix} copy has failed" unless @config[:silent]
+        UI.error e
+        stop_server
+        throw :task_has_failed
+      end
+      true
+    end
+
+    # Remove deleted source file/directories from destination
+    def remove(files=[])
+      # Ensure at least one file still exists (other scripts may clean up too)
+      return false unless files.select { |f| File.exist? f }.size > 0
+      begin
+        message = 'removed file'
+        message += 's' if files.size > 1
+        UI.info "#{@msg_prefix} #{message.red}" unless @config[:silent]
+        puts '| '
+
+        files.each do |file|
+          path = destination_path file
+          if File.exist?(path)
+            FileUtils.rm(path)
+            puts '|' + "  x ".red + path
+          end
+
+          dir = File.dirname(path)
+          next unless Dir[File.join(dir, '*')].empty?
+          FileUtils.rm_r(dir)
+          puts '|' + "  x ".red + dir
+        end
+        puts '| '
+
+      rescue
+        UI.error "#{@msg_prefix} remove has failed" unless @config[:silent]
+        UI.error e
+        stop_server
+        throw :task_has_failed
+      end
+      true
+    end
+
+    def jekyll_matches(paths)
+      paths.select { |file| file =~ @extensions }
+    end
+
+    def non_jekyll_matches(paths)
+      paths.select { |file| !file.match(/^_/) && !file.match(@extensions) }
+    end
+
+    def jekyll_config(options)
+      if options[:config_hash]
+        config = options[:config_hash]
+      elsif options[:config]
+        options[:config] = [options[:config]] unless options[:config].is_a? Array
+        config = options
+      end
+      Jekyll.configuration(config)
+    end
+
+    # TODO Use Pathname.relative_path_from or similar here
+    def local_path(path)
+      Dir.chdir('.')
+      current = Dir.pwd
+      path = path.sub current, ''
+      if path == ''
+        './'
+      else
+        path.sub(/^\//, '')
+      end
+    end
+
+    def destination_path(file)
+      if @source =~ /^\./
+        File.join(@destination, file)
+      else
+        file.sub(/^#{@source}/, "#{@destination}")
+      end
+    end
+
+    def start_server
+      if @server_thread.nil?
+        @server_thread = Thread.new do
+          Thin::Server.start(@config['host'], @config['port'], :signals => false) do
+            require 'rack/livereload'
+            require 'hawkins/isolation'
+            use Rack::LiveReload,
+                :min_delay => 500,
+                :max_delay => 2000,
+                :no_swf => true,
+                :source => :vendored
+            run ::Hawkins::IsolationInjector.new
+          end
+        end
+        UI.info "#{@app_prefix} running Rack" unless @config[:silent]
+      else
+        UI.warning "#{@app_prefix} using an old server thread!"
+      end
+    end
+
+    def stop_server
+      @server_thread.kill unless @server_thread.nil?
+      @server_thread = nil
+    end
+  end
+end

data/lib/hawkins/isolation.rb

@@ -0,0 +1,116 @@
+require 'pathname'
+require 'rack'
+require 'safe_yaml/load'
+require 'set'
+
+module Hawkins
+  class IsolationInjector
+    attr_reader :site_root
+    attr_reader :isolation_file
+
+    def initialize(options={})
+      @options = options
+      @site_root = @options[:site_root] || Jekyll.configuration({})['destination']
+      @isolation_file = @options[:isolation_file] || Hawkins::ISOLATION_FILE
+      SafeYAML::OPTIONS[:default_mode] = :safe
+    end
+
+    def call(env)
+      req = Rack::Request.new(env)
+      path = Pathname.new(req.path_info).relative_path_from(Pathname.new('/'))
+      path = File.join(site_root, path.to_s)
+
+      path = File.join(path, "index.html") if File.directory?(path)
+      path = Pathname.new(path).cleanpath.to_s
+
+      files = Dir[File.join(site_root, "**/*")]
+      if files.include?(path)
+        mime = mime(path)
+        file = file_info(path)
+        body = file[:body]
+        time = file[:time]
+        hdrs = {'Last-Modified' => time}
+
+        if time == req.env['HTTP_IF_MODIFIED_SINCE']
+          [304, hdrs, []]
+        else
+          hdrs.update(
+            'Content-length' => body.bytesize.to_s,
+            'Content-Type' => mime
+          )
+          [200, hdrs, [body]]
+        end
+      else
+        handle_404(req, path)
+      end
+    end
+
+    def handle_404(req, true_path)
+      if File.exist?(isolation_file)
+        file = true_path
+        # Use a wildcard since the origin file could be anything
+        file = "#{File.basename(file, File.extname(file))}.*".force_encoding('utf-8')
+
+        config = SafeYAML.load_file(isolation_file)
+
+        file_set = Set.new(config['include'])
+
+        # Prevent loops.  If it's already in 'include'
+        # then we've gone through here before.
+        return static_error if file_set.include?(file)
+
+        config['include'] = file_set.add(file).to_a
+
+        File.open(isolation_file, 'w') do |f|
+          YAML.dump(config, f)
+        end
+
+        response = <<-PAGE.gsub(/^\s*/, '')
+          <!DOCTYPE HTML>
+          <html lang="en-US">
+          <head>
+            <meta charset="UTF-8">
+            <title>Rendering #{req.path_info}</title>
+          </head>
+          <body>
+            <h1>Hold on while I render that page for you!</h1>
+          </body>
+        PAGE
+
+        headers = {}
+        headers['Content-Length'] = response.bytesize.to_s
+        headers['Content-Type'] = 'text/html'
+        headers['Connection'] = 'keep-alive'
+        [200, headers, [response]]
+      else
+        static_error
+      end
+    end
+
+    def static_error
+      error_page = File.join(site_root, "404.html")
+      if File.exist?(error_page)
+        body = file_info(error_page)[:body]
+        mime = mime(error_page)
+      else
+        body = "Not found"
+        mime = "text/plain"
+      end
+      [404, {"Content-Type" => mime, "Content-length" => body.bytesize.to_s}, [body]]
+    end
+
+    def mime(path_info)
+      Rack::Mime.mime_type(File.extname(path_info))
+    end
+
+    def file_info(path)
+      File.open(path, 'r') do |f|
+        {
+          :body => f.read,
+          :time => f.mtime.httpdate,
+          :expand_path => path
+        }
+      end
+    end
+  end
+end

data/lib/hawkins/version.rb

@@ -0,0 +1,3 @@
+module Hawkins
+  VERSION = "0.1.0"
+end

data/test/resources/test_site/_config.yml

@@ -0,0 +1,21 @@
+# Do not use tabs in this file!
+# Required for running on Ruby 1.9
+encoding: utf-8
+
+# Change this if we ever need the site to reside in a sub-directory
+baseurl: ''
+
+permalink: /:year/:title.html
+paginate: 8
+paginate_path: /news/page:num
+
+markdown: kramdown
+kramdown:
+  # Use GitHub flavor markdown
+  input: GFM
+  hard_wrap: false
+
+# See http://jekyllrb.com/docs/configuration/#frontmatter-defaults
+defaults:
+  - scope: { type: "posts" }
+    values: { layout: "default" }

data/test/resources/test_site/_includes/footer.html

@@ -0,0 +1,5 @@
+<footer>
+  <div>
+    Some footer content
+  </div>
+</footer>

data/test/resources/test_site/_includes/header.html

@@ -0,0 +1,8 @@
+<header>
+<nav role="navigation">
+  <ul>
+    <li>Nav Item 1</li>
+    <li>Nav Item 2</li>
+  </ul>
+</nav>
+</header>

data/test/resources/test_site/_includes/top.html

@@ -0,0 +1,6 @@
+<!DOCTYPE HTML>
+<html lang="en-US">
+<head>
+  <meta charset="UTF-8">
+  <title>Hawkins Test - {{ page.title }}</title>
+  <link rel="stylesheet" href="{{ site.baseurl }}/assets/hawkins.css" />

data/test/resources/test_site/_layouts/default.html

@@ -0,0 +1,10 @@
+{% include top.html %}
+</head>
+<body>
+  {% include header.html %}
+  <div id="page-content">
+    {{ content }}
+  </div>
+  {% include footer.html %}
+</body>
+</html>