guard-jekyll-plus 2.0.0 → 2.0.1

data/lib/guard/jekyll_plus/builder/adder.rb

@@ -0,0 +1,23 @@
+require 'guard/jekyll_plus/builder/action'
+
+module Guard
+  class JekyllPlus < Plugin
+    class Builder
+      class Adder < Action
+        def initialize(*args)
+          @msg = 'Files added: '
+          @mark = '  + '.green
+          @name = 'copy'
+          @activity = 'copying'
+          @color = :green
+          super
+        end
+
+        def do_update(files)
+          header(files)
+          files.each { |file| copy(file, destination_path(file)) }
+        end
+      end
+    end
+  end
+end

data/lib/guard/jekyll_plus/builder/modifier.rb

@@ -0,0 +1,23 @@
+require 'guard/jekyll_plus/builder/action'
+
+module Guard
+  class JekyllPlus < Plugin
+    class Builder
+      class Modifier < Action
+        def initialize(*args)
+          @msg = 'Files changed: '
+          @mark = '  ~ '.yellow
+          @name = 'update'
+          @activity = 'updating'
+          @color = :green
+          super
+        end
+
+        def do_update(files)
+          header(files)
+          files.each { |file| copy(file, destination_path(file)) }
+        end
+      end
+    end
+  end
+end

data/lib/guard/jekyll_plus/builder/rebuilder.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'guard/jekyll_plus/builder/action'
+
+module Guard
+  class JekyllPlus < Plugin
+    class Builder
+      class Rebuilder < Action
+        def initialize(*args)
+          @name = 'build'
+          @activity = 'building...'
+          @color = :yellow
+          super
+        end
+
+        def update
+          header(nil)
+          benchmark { @site.process }
+
+        # rescue almost everything because Jekyll::Convertible forwards
+        # every plugin-specific exception it encounters
+        rescue StandardError => e
+          @config.error "#{@name} has failed"
+          @config.error e.to_s
+          throw :task_has_failed
+        end
+
+        def benchmark
+          elapsed = Benchmark.realtime { yield }.round(2)
+          change = format('%s → %s', @config.source, @config.destination)
+          msg = format('build completed in %ss '.green + change, elapsed)
+          @config.info msg
+        end
+      end
+    end
+  end
+end

data/lib/guard/jekyll_plus/builder/remover.rb

@@ -0,0 +1,24 @@
+require 'guard/jekyll_plus/builder/action'
+
+module Guard
+  class JekyllPlus < Plugin
+    class Builder
+      class Remover < Action
+        def initialize(*args)
+          @msg = 'Files removed: '
+          @mark = '  x '.red
+          @name = 'remove'
+          @activity = 'removing'
+          @color = :red
+          super
+        end
+
+        def do_update(files)
+          return if files.none? { |f| File.exist?(f) }
+          header(files)
+          files.each { |file| remove(destination_path(file)) }
+        end
+      end
+    end
+  end
+end

data/lib/guard/jekyll_plus/config.rb

@@ -0,0 +1,131 @@
+require 'jekyll'
+
+module Guard
+  class JekyllPlus < Plugin
+    class Config
+      EXTS = %w(md mkd mkdn markdown textile html haml slim xml yml sass scss)
+
+      def initialize(options)
+        @options = {
+          extensions: [],
+          config: ['_config.yml'],
+          serve: false,
+          rack_config: nil,
+          drafts: false,
+          future: false,
+          config_hash: nil,
+          silent: false,
+          msg_prefix: 'Jekyll '
+        }.merge(options)
+
+        @jekyll_config = load_config(@options)
+
+        @source = local_path(@jekyll_config['source'])
+        @destination = local_path(@jekyll_config['destination'])
+        @msg_prefix = @options[:msg_prefix]
+
+        # Convert array of extensions into a regex for matching file extensions
+        # eg, /\.md$|\.markdown$|\.html$/i
+        #
+        extensions  = @options[:extensions].concat(EXTS).flatten.uniq
+        extensions.map! { |e| Regexp.quote(e.sub(/^\./, '')) }
+        @extensions = /\.(?:#{extensions.join('|')})$/i
+      end
+
+      attr_reader :extensions
+      attr_reader :destination
+      attr_reader :jekyll_config
+
+      def server_options
+        jekyll_config
+      end
+
+      def config_file?(file)
+        @options[:config].include?(file)
+      end
+
+      def reload
+        @jekyll_config = load_config(@options)
+      end
+
+      def info(msg)
+        Compat::UI.info(@msg_prefix + msg) unless silent?
+      end
+
+      def error(msg)
+        Compat::UI.error(@msg_prefix + msg)
+      end
+
+      def source
+        @jekyll_config['source']
+      end
+
+      def serve?
+        @options[:serve]
+      end
+
+      def host
+        @jekyll_config['host']
+      end
+
+      def baseurl
+        @jekyll_config['baseurl']
+      end
+
+      def port
+        @jekyll_config['port']
+      end
+
+      def rack_config
+        @options[:rack_config]
+      end
+
+      def rack_environment
+        silent? ? nil : 'development'
+      end
+
+      alias_method :server_root, :destination
+      alias_method :jekyll_serve_options, :jekyll_config
+
+      def excluded?(path)
+        @jekyll_config['exclude'].any? { |glob| File.fnmatch?(glob, path) }
+      end
+
+      private
+
+      def silent?
+        @options[:silent] || @options['silent']
+      end
+
+      def load_config(options)
+        config = ::Jekyll.configuration(jekyllize_options(options))
+
+        # Override configuration with guard option values
+        config['show_drafts'] = options[:drafts]
+        config['future']      = options[:future]
+        config
+      end
+
+      def jekyllize_options(options)
+        opts = options.dup
+        return opts[:config_hash] if opts[:config_hash]
+        return opts unless opts[:config]
+        opts[:config] = [opts[:config]] unless opts[:config].is_a? Array
+        opts
+      end
+
+      def local_path(path)
+        # TODO: what is this for?
+        Dir.chdir('.')
+
+        current = Dir.pwd
+        path = path.sub current, ''
+        if path == ''
+          './'
+        else
+          path.sub(/^\//, '')
+        end
+      end
+    end
+  end
+end

data/lib/guard/jekyll_plus/server.rb

@@ -0,0 +1,111 @@
+require 'jekyll'
+
+require 'guard/compat/plugin'
+
+require 'guard/jekyll_plus/config'
+
+module Guard
+  class JekyllPlus < Plugin
+    class Server
+      def initialize(config)
+        @thread = nil
+        @config = config
+        @pid = nil
+      end
+
+      def start
+        @rack = rack_available?
+        @rack ? start_rack : start_jekyll
+
+        msg = 'watching and serving using %s at %s:%s%s'
+        type = @rack ? 'rack' : 'jekyll'
+        msg = format(msg, type, @config.host, @config.port, @config.baseurl)
+        @config.info msg
+      end
+
+      def stop
+        @rack ? stop_rack : stop_jekyll
+      end
+
+      private
+
+      def rack_available?
+        @use_rack ||= begin
+                         Kernel.require 'rack'
+                         true
+                       rescue LoadError
+                         false
+                       end
+      end
+
+      def local_config
+        File.exist?('config.ru') ? 'config.ru' : nil
+      end
+
+      def default_config
+        (Pathname(__FILE__).expand_path.dirname + '../../rack/config.ru').to_s
+      end
+
+      def config_file
+        (@config.rack_config || local_config || default_config)
+      end
+
+      def start_jekyll
+        # NOTE: must use process for Jekyll, because:
+        #
+        # 1) webrat has a shutdown that needs to be called. Since Jekyll
+        # doesn't expose the server instance, the only way to call it is to
+        # send "INT" to the process - but that also causes Pygments to crash
+        # (because it's opening a pipe with Mentos)
+        #
+        # 2) you can't use the 'detach' option of Jekyll, because you don't
+        # have access to the pid, because it's only logged and never returned
+        #
+        # You'll likely get a "Couldn't cleanly terminate all actors" error,
+        # because Celluloid doesn't gracefully handle forking.
+        #
+        fail "Server already running at: #{@pid.inspect}" unless @pid.nil?
+        @pid = Process.fork do
+          ::Jekyll::Commands::Serve.process(@config.jekyll_serve_options)
+        end
+      end
+
+      def start_rack
+        fail 'already running!' unless @pid.nil?
+        # Run rack in a process, because the only way to shut down Webrick
+        # cleanly is through calling shutdown(), and Rack sets up and INT
+        # handler specifically to do this - so we need to call INT.
+        #
+        # Webrick needs to shutdown
+        # explicitly - and that's handled by Rack (it traps INT),
+        ENV['RACK_ROOT'] = @config.server_root
+        s = ::Rack::Server.new(config: config_file,
+                               Port: @config.port,
+                               Host: @config.host,
+                               environment: @config.rack_environment)
+
+        @config.info "Using: #{s.server} as server"
+
+        thin = s.server == Rack::Handler::Thin
+        Thin::Logging.silent = @config.rack_environment.nil? if thin
+
+        @pid = Process.fork { s.start }
+      end
+
+      def stop_rack
+        stop_pid
+      end
+
+      def stop_jekyll
+        stop_pid
+      end
+
+      def stop_pid
+        return if @pid.nil?
+        Process.kill('INT', @pid)
+        Process.wait(@pid)
+        @pid = nil
+      end
+    end
+  end
+end

data/lib/guard/jekyll_plus/templates/Guardfile

@@ -0,0 +1,4 @@
+guard 'jekyll_plus' do
+  watch(/.*/)
+  ignore(/^_site/)
+end

data/lib/guard/{jekyll-plus → jekyll_plus}/version.rb

@@ -1,5 +1,5 @@
 module Guard
   class JekyllPlusVersion
-    VERSION = "2.0.0"
+    VERSION = '2.0.1'
   end
 end

data/spec/lib/guard/jekyll-plus/builder/adder_spec.rb

@@ -0,0 +1,94 @@
+require 'guard/jekyll_plus/builder/adder'
+
+module Guard
+  RSpec.describe JekyllPlus::Builder::Adder do
+    let(:site) { instance_double(Jekyll::Site) }
+    let(:config) { instance_double(JekyllPlus::Config) }
+    subject { described_class.new(config, site) }
+
+    describe '#update' do
+      let(:extensions) { /\.haml$/i }
+
+      before do
+        # for build
+        allow(config).to receive(:info)
+        allow(config).to receive(:source)
+        allow(config).to receive(:destination)
+
+        allow(config).to receive(:extensions).and_return(extensions)
+        allow(FileUtils).to receive(:mkdir_p)
+        allow(FileUtils).to receive(:cp)
+        allow($stdout).to receive(:puts)
+      end
+
+      context 'when source files are added' do
+        it 'builds' do
+          expect(site).to receive(:process)
+          subject.update(%w(foo.haml))
+        end
+      end
+
+      context 'when assets change' do
+        before do
+          allow(config).to receive(:destination).and_return('bar/')
+          allow(config).to receive(:excluded?).with('foo.jpg').and_return(false)
+        end
+
+        it 'copies files' do
+          expect(FileUtils).to receive(:cp).with('foo.jpg', 'bar/foo.jpg')
+          subject.update(%w(foo.jpg))
+        end
+      end
+
+      # NOTE: Jekyll just shows a message and passes the plugin,
+      # so it can fail with almost any possible exception.
+      #
+      # We catch StandardError to at least be somewhat reasonable
+      context 'when an Jekyll conversion error happens' do
+        before do
+          allow(site).to receive(:process)
+            .and_raise(NoMethodError, 'error evaluating Haml file')
+        end
+
+        it 'shows an error' do
+          expect(config).to receive(:error).with('build has failed')
+          expect(config).to receive(:error).with(/error evaluating Haml file/)
+
+          catch(:task_has_failed) do
+            subject.update(%w(foo.haml))
+          end
+        end
+
+        it 'throws task_has_failed symbol' do
+          allow(config).to receive(:error)
+          expect do
+            subject.update(%w(foo.haml))
+          end.to throw_symbol(:task_has_failed)
+        end
+      end
+
+      context 'when an error happens' do
+        before do
+          allow(config).to receive(:destination).and_return('bar/')
+          allow(FileUtils).to receive(:cp).and_raise(Errno::ENOENT, 'foo')
+          allow(config).to receive(:error)
+          allow(config).to receive(:excluded?).with('foo').and_return(false)
+        end
+
+        it 'shows an error' do
+          expect(config).to receive(:error).with('copy has failed')
+          expect(config).to receive(:error).with(/No such file.* - foo/)
+          catch(:task_has_failed) do
+            subject.update(%w(foo))
+          end
+        end
+
+        it 'throws task_has_failed symbol' do
+          expect do
+            subject.update(%w(foo))
+          end.to throw_symbol(:task_has_failed)
+        end
+      end
+    end
+  end
+end