guard-jekyll-plus 2.0.0 → 2.0.1

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

@@ -0,0 +1,113 @@
+require 'guard/jekyll_plus/builder/modifier'
+
+module Guard
+  RSpec.describe JekyllPlus::Builder::Modifier 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 change' 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
+
+      context 'when excluded file changes' do
+        before do
+          allow(config).to receive(:destination).and_return('bar/')
+          allow(config).to receive(:excluded?).with('foo.jpg').and_return(true)
+        end
+
+        it 'does not copy anything' do
+          expect(FileUtils).to_not receive(:cp)
+          subject.update(%w(foo.jpg))
+        end
+
+        it 'shows which files were excluded' do
+          expect($stdout).to receive(:puts)
+            .with(/Ignoring excluded file: 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')
+
+          allow(config).to receive(:error)
+        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
+          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('update 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

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

@@ -0,0 +1,76 @@
+require 'guard/jekyll_plus/builder/rebuilder'
+
+module Guard
+  RSpec.describe JekyllPlus::Builder::Rebuilder do
+    let(:site) { instance_double(Jekyll::Site) }
+    let(:config) { instance_double(JekyllPlus::Config) }
+    subject { described_class.new(config, site) }
+
+    describe '#update' do
+      before do
+        allow(site).to receive(:process)
+        allow($stdout).to receive(:puts)
+        allow(config).to receive(:info)
+        allow(config).to receive(:source)
+        allow(config).to receive(:destination)
+      end
+
+      it 'processes all the files' do
+        expect(site).to receive(:process)
+        subject.update
+      end
+
+      it 'shows header' do
+        expect(config).to receive(:info).with(/building\.\.\./)
+        subject.update
+      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(config).to receive(:error)
+          allow(site).to receive(:process)
+            .and_raise(NoMethodError, 'something in Haml template failed')
+        end
+
+        it 'shows an error' do
+          expect(config).to receive(:error).with('build has failed')
+          expect(config).to receive(:error).with(/something in Haml template/)
+          catch(:task_has_failed) do
+            subject.update
+          end
+        end
+
+        it 'throws task_has_failed symbol' do
+          expect do
+            subject.update
+          end.to throw_symbol(:task_has_failed)
+        end
+      end
+
+      context 'when a system error happens' do
+        before do
+          allow(config).to receive(:error)
+          allow(site).to receive(:process).and_raise(RuntimeError, 'big error')
+        end
+
+        it 'shows an error' do
+          expect(config).to receive(:error).with('build has failed')
+          expect(config).to receive(:error).with(/big error/)
+          catch(:task_has_failed) do
+            subject.update
+          end
+        end
+
+        it 'throws task_has_failed symbol' do
+          expect do
+            subject.update
+          end.to throw_symbol(:task_has_failed)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+require 'guard/jekyll_plus/builder/remover'
+
+module Guard
+  RSpec.describe JekyllPlus::Builder::Remover 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
+        allow(config).to receive(:extensions).and_return(extensions)
+
+        # for build
+        allow(config).to receive(:info)
+        allow(config).to receive(:source)
+        allow(config).to receive(:destination)
+
+        allow($stdout).to receive(:puts)
+      end
+
+      context 'when asset files are deleted' do
+        before do
+          allow(config).to receive(:destination).and_return('bar/')
+
+          # non existing src file
+          allow(File).to receive(:exist?).with('foo.jpg').and_return(false)
+
+          # Make one file exist so removing dst files can happen.
+          # I'm not sure why this is necessary
+          allow(File).to receive(:exist?).with('logo.png').and_return(true)
+
+          # existing destination file
+          allow(File).to receive(:exist?).with('bar/foo.jpg').and_return(true)
+
+          # the removing of the file
+          allow(FileUtils).to receive(:rm).with('bar/foo.jpg')
+          allow(FileUtils).to receive(:rm).with('bar/logo.png')
+
+          # checking for empty dirs to clear
+          allow(Dir).to receive(:[]).with('bar/*').and_return(%w(logo.png))
+          allow(File).to receive(:exist?).with('bar/logo.png').and_return(true)
+        end
+
+        it 'removes delete files from destination' do
+          expect(FileUtils).to receive(:rm).with('bar/foo.jpg')
+          subject.update(%w(foo.jpg logo.png))
+        end
+      end
+
+      context 'when sources files are removed' do
+        it 'builds' do
+          expect(site).to receive(:process)
+          subject.update(%w(foo.haml))
+        end
+      end
+
+      context 'when an error happens' do
+        before do
+          allow(config).to receive(:destination).and_return('bar/')
+          allow(config).to receive(:error)
+          allow(File).to receive(:exist?).with('foo').and_return(false)
+
+          # just so the removing is triggered (don't know why)
+          allow(File).to receive(:exist?).with('baz').and_return(true)
+
+          # file to be deleted
+          allow(File).to receive(:exist?).with('bar/foo').and_return(true)
+
+          # file we don't care about
+          allow(File).to receive(:exist?).with('bar/baz').and_return(false)
+
+          allow(Dir).to receive(:[]).with('bar/*').and_return(%w(logo.png))
+
+          # simulate failure
+          allow(FileUtils).to receive(:rm).with('bar/foo')
+            .and_raise(Errno::ENOENT, 'foo')
+        end
+
+        it 'shows an error' do
+          expect(config).to receive(:error).with('remove has failed')
+          expect(config).to receive(:error).with(/No such file.* - foo/)
+          catch(:task_has_failed) do
+            subject.update(%w(foo baz))
+          end
+        end
+
+        it 'throws task_has_failed symbol' do
+          expect do
+            subject.update(%w(foo baz))
+          end.to throw_symbol(:task_has_failed)
+        end
+      end
+    end
+  end
+end

data/spec/lib/guard/jekyll-plus/builder_spec.rb

@@ -0,0 +1,57 @@
+require 'guard/compat/test/helper'
+
+require 'guard/jekyll_plus/builder'
+
+module Guard
+  RSpec.describe JekyllPlus::Builder do
+    let(:config) { instance_double(JekyllPlus::Config) }
+    let(:site) { instance_double(Jekyll::Site) }
+    let(:rebuilder) { instance_double(JekyllPlus::Builder::Rebuilder) }
+    let(:modifier) { instance_double(JekyllPlus::Builder::Modifier) }
+    let(:adder) { instance_double(JekyllPlus::Builder::Adder) }
+    let(:remover) { instance_double(JekyllPlus::Builder::Remover) }
+
+    subject { described_class.new(config) }
+
+    before do
+      allow(Jekyll::Site).to receive(:new).and_return(site)
+
+      allow(JekyllPlus::Config).to receive(:new).and_return(config)
+      allow(config).to receive(:jekyll_config)
+
+      allow(JekyllPlus::Builder::Adder).to receive(:new).and_return(adder)
+      allow(JekyllPlus::Builder::Remover).to receive(:new).and_return(remover)
+      allow(JekyllPlus::Builder::Modifier).to receive(:new).and_return(modifier)
+      allow(JekyllPlus::Builder::Rebuilder).to receive(:new)
+        .and_return(rebuilder)
+    end
+
+    describe '#build' do
+      it 'rebuilds the site' do
+        expect(rebuilder).to receive(:update)
+        subject.build
+      end
+    end
+
+    describe '#added' do
+      it 'builds if needed' do
+        expect(adder).to receive(:update)
+        subject.added(%w(foo))
+      end
+    end
+
+    describe '#modified' do
+      it 'builds if needed' do
+        expect(modifier).to receive(:update)
+        subject.modified(%w(foo))
+      end
+    end
+
+    describe '#removed' do
+      it 'builds if needed' do
+        expect(remover).to receive(:update)
+        subject.removed(%w(foo))
+      end
+    end
+  end
+end

data/spec/lib/guard/jekyll-plus/config_spec.rb

@@ -0,0 +1,138 @@
+require 'guard/compat/test/helper'
+
+require 'guard/jekyll_plus/config'
+
+RSpec.describe Guard::JekyllPlus::Config do
+  let(:options) { {} }
+  subject { described_class.new(options) }
+
+  let(:valid_jekyll_options) do
+    {
+      'source' => 'foo',
+      'destination' => 'bar'
+    }
+  end
+
+  let(:jekyll_config) { valid_jekyll_options }
+
+  before do
+    allow(Jekyll).to receive(:configuration).and_return(jekyll_config)
+  end
+
+  describe '#source' do
+    context 'with a relative path' do
+      let(:jekyll_config) { valid_jekyll_options.merge('source' => 'foo') }
+
+      it 'returns source from Jekyll config' do
+        expect(subject.source).to eq('foo')
+      end
+    end
+  end
+
+  describe '#serve?' do
+    context 'when option is not configured' do
+      let(:options) { {} }
+      it { is_expected.to_not be_serve }
+    end
+
+    context 'when configured as false' do
+      let(:options) { { serve: false } }
+      it { is_expected.to_not be_serve }
+    end
+
+    context 'when configuerd as true' do
+      let(:options) { { serve:  true } }
+      it { is_expected.to be_serve }
+    end
+  end
+
+  %w(host baseurl port).each do |option|
+    describe "#{option}" do
+      let(:value) { double('value') }
+      let(:jekyll_config) { valid_jekyll_options.merge(option.to_s => value) }
+
+      it 'returns value from Jekyll config' do
+        expect(subject.send(option)).to be(value)
+      end
+    end
+  end
+
+  describe '#jekyll_serve_options' do
+    it 'returns all jekyll options'do
+      expect(subject.jekyll_serve_options).to be(jekyll_config)
+    end
+  end
+
+  describe '#server_root' do
+    let(:path) { File.join(Dir.pwd, 'foo') }
+    let(:jekyll_config) { valid_jekyll_options.merge('destination' => path) }
+
+    it 'returns destination dir'do
+      expect(subject.server_root).to eq('foo')
+    end
+  end
+
+  describe '#rack_config' do
+    context 'when option is not configured' do
+      let(:options) { {} }
+      it 'returns nil' do
+        expect(subject.rack_config).to be_nil
+      end
+    end
+
+    context 'when configured' do
+      let(:rack_options) { double('rack options') }
+      let(:options) { { rack_config: rack_options } }
+
+      it 'returns value from options' do
+        expect(subject.rack_config).to be(rack_options)
+      end
+    end
+  end
+
+  describe '#extensions' do
+    let(:options) { { extensions: %w(foo) } }
+    let(:exts) do
+      'foo|md|mkd|mkdn|markdown|textile|html|haml|slim|xml|yml|sass|scss'
+    end
+
+    it 'returns configured extensions' do
+      expect(subject.extensions).to eq(/\.(?:#{exts})$/i)
+    end
+
+    it 'matches .slim files' do
+      expect(subject.extensions).to match('foo.slim')
+    end
+  end
+
+  # We need this basically to turn off logging
+  describe '#rack_environment' do
+    context 'when silent is true' do
+      let(:options) { { silent: true } }
+      it 'uses nil to prevent loading Rack default middleware' do
+        expect(subject.rack_environment).to eq(nil)
+      end
+    end
+
+    context 'when silent is false' do
+      let(:options) { { silent:  false } }
+      it 'uses development for full Rack default middleware' do
+        expect(subject.rack_environment).to eq('development')
+      end
+    end
+  end
+
+  describe '#excluded?' do
+    context 'with excludes in Jekyll' do
+      let(:jekyll_config) do
+        valid_jekyll_options.merge('exclude' => ['f*', 'b*z'])
+      end
+
+      it 'matches files excluded in Jekyll' do
+        expect(subject.excluded?('foo')).to be_truthy
+        expect(subject.excluded?('bar')).to be_falsey
+        expect(subject.excluded?('baz')).to be_truthy
+      end
+    end
+  end
+end