hawkins 0.1.0 → 2.0.0

data/lib/hawkins/cli.rb

@@ -1,190 +0,0 @@
-require 'jekyll'
-require 'guard'
-require 'guard/runner'
-require 'listen'
-
-module Hawkins
-  class Cli < Thor
-    include Thor::Actions
-
-    attr_accessor :jekyll_config
-
-    def self.exit_on_failure?
-      true
-    end
-
-    def initialize(*args)
-      super
-      Jekyll.logger.log_level = :warn
-      @jekyll_config = Jekyll::Configuration[Jekyll::Configuration::DEFAULTS]
-      @jekyll_config.read_config_files(@jekyll_config.config_files({}))
-    end
-
-    desc "post TITLE", "create a post"
-    option :editor, :default => ENV['VISUAL'] || ENV['EDITOR'] || 'vi'
-    option :date, :default => Time.now.to_s
-    def post(title)
-      begin
-        date = Date.parse(options[:date])
-      rescue
-        # If an exception is not descended from the Thor::Error class, Thor
-        # prints the stacktrace.  We don't want a stacktrace in this instance,
-        # so we lie and use one of Thor's error classes in the call to fail().
-        fail(Thor::InvocationError, "ERROR: Could not parse '#{options[:date]}' as a date")
-      end
-      slug = title.to_url
-      dest = path_to(:_posts)
-
-      shell.mute { empty_directory(dest) }
-
-      filename = "#{date.strftime('%Y-%m-%d')}-#{slug}.md"
-      content = <<-CONTENT.gsub(/^\s*/, '')
-        ---
-        title: #{title}
-        ---
-      CONTENT
-
-      create_file(path_to(dest, filename), content)
-
-      case options[:editor]
-      when /g?vim/
-        editor_args = "+"
-      when /x?emacs/
-        editor_args = "+#{content.lines.count}"
-      else
-        editor_args = nil
-      end
-
-      exec(*[options[:editor], editor_args, path_to(dest, filename)].compact)
-    end
-
-    desc "isolate FILE ...", "work on a file or files in isolation (globs are allowed)"
-    long_desc <<-LONGDESC
-      Jekyll's regeneration capability is limited to regenerating the
-      entire site.  This option will ignore all files except the ones you
-      specify in order to speed regeneration.
-
-      Keep in mind that Jekyll's inclusion mechanism is not aware of
-      subdirectories so this command operates on the basename of all files
-      that match the file or glob you provide.
-    LONGDESC
-    option :future, :type => :boolean, :default => false, :desc => "publish future dated posts"
-    option :drafts, :type => :boolean, :default => false, :desc => "publish draft posts"
-    def isolate(*files)
-      SafeYAML::OPTIONS[:default_mode] = :safe
-
-      pages = []
-      pages << Hawkins::DEFAULT_EXTENSIONS.map do |ext|
-        Dir.glob("**/*.#{ext}")
-      end
-      pages.flatten!.reject! { |f| File.fnmatch?('_site/*', f) }
-
-      pages.select! do |p|
-        content = File.read(p)
-        # Jekyll only renders pages with YAML frontmatter.  See Jekyll's
-        # convertible.rb read_yaml method.
-        content =~ /\A(---\s*\n.*?\n?)^(---\s*$\n?)/m
-      end
-
-      isolation_config = {}
-      isolation_config['exclude'] = pages.concat(jekyll_config['exclude'])
-      isolation_config['include'] = Hawkins::DEFAULT_INCLUDES
-
-      files.each do |glob|
-        matches = Dir.glob(glob)
-        matches.map! do |f|
-          ext = File.extname(f)
-          # If we have to add to this list from Rack, then Rack will have no
-          # idea what the original file extension was.  Use a wildcard to
-          # avoid this issue.
-          "#{File.basename(f, ext)}.*"
-        end
-        if matches.empty?
-          raise Thor::Error.new("Could not find any matches for #{glob}.")
-        end
-        isolation_config['include'] += matches
-      end
-
-      isolation_config['include'].uniq!
-
-      # We have to write the isolation config out to a file so that the Guard
-      # can detect when the configuration changes.
-      create_file(Hawkins::ISOLATION_FILE, YAML.dump(isolation_config))
-
-      begin
-        invoke(:serve, [], options)
-      ensure
-        remove_file(Hawkins::ISOLATION_FILE)
-      end
-    end
-
-    desc "serve", "render and serve the site"
-    option :future, :type => :boolean, :default => false, :desc => "publish future dated posts"
-    option :drafts, :type => :boolean, :default => false, :desc => "publish draft posts"
-    def serve
-      config_files = jekyll_config.config_files({}) || []
-      if File.exist?(Hawkins::ISOLATION_FILE)
-        config_files << Hawkins::ISOLATION_FILE
-      end
-
-      # By default Jekyll uses the absolute path and Guard doesn't so we need to fix that.
-      dest = Pathname.new(jekyll_config['destination']).relative_path_from(Pathname.new(Dir.pwd))
-
-      contents = <<-GUARDFILE.gsub(/^\s*/, '')
-        interactor :off
-        notification :off
-        guard 'hawkins',
-          :config => #{config_files},
-          :drafts => #{options[:drafts]},
-          :future => #{options[:future]} do
-          watch %r{.*}
-          ignore %r{^#{dest}}
-        end
-
-        guard 'livereload',
-          :grace_period => 5 do
-          watch %r{.*}
-        end
-      GUARDFILE
-      guard_start(contents)
-    end
-
-    # Methods in the no_tasks block are not exposed to users
-    no_tasks do
-      def guard_start(guardfile_contents)
-        Guard.setup(:guardfile_contents => guardfile_contents)
-        Guard::Runner.new.run(:start)
-        Guard.listener.start
-
-        exitcode = 0
-        begin
-          while Guard.interactor.foreground != :exit
-            Guard.queue.process while Guard.queue.pending?
-          end
-        rescue Interrupt
-        rescue SystemExit => e
-          exitcode = e.status
-        end
-
-        guard_stop
-        exitcode
-      end
-
-      def guard_stop
-        Guard.listener.stop
-        Guard.interactor.background
-        Guard::Runner.new.run(:stop)
-      end
-
-      def self.source_root
-        File.expand_path("..", File.dirname(__FILE__))
-      end
-
-      # Builds a path within the source_root
-      def path_to(*args)
-        args = args.map(&:to_s)
-        File.join(*args)
-      end
-    end
-  end
-end

data/lib/hawkins/guard.rb

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