nanoc 4.4.5 → 4.4.6

data/spec/nanoc/data_sources/filesystem_spec.rb

@@ -0,0 +1,56 @@
+describe Nanoc::DataSources::Filesystem do
+  let(:data_source) { Nanoc::DataSources::Filesystem.new(site.config, nil, nil, params) }
+  let(:params) { {} }
+  let(:site) { Nanoc::Int::SiteLoader.new.new_empty }
+
+  before { Timecop.freeze(now) }
+  after { Timecop.return }
+
+  let(:now) { Time.local(2008, 1, 2, 14, 5, 0) }
+
+  describe '#load_objects' do
+    subject { data_source.send(:load_objects, 'foo', klass) }
+
+    let(:klass) { raise 'override me' }
+
+    context 'items' do
+      let(:klass) { Nanoc::Int::Item }
+
+      context 'no files' do
+        it 'loads nothing' do
+          expect(subject).to be_empty
+        end
+      end
+
+      context 'one regular file' do
+        before do
+          FileUtils.mkdir_p('foo')
+          File.write('foo/bar.html', "---\nnum: 1\n---\ntest 1")
+          FileUtils.touch('foo/bar.html', mtime: now)
+        end
+
+        let(:expected_attributes) do
+          {
+            content_filename: 'foo/bar.html',
+            extension: 'html',
+            filename: 'foo/bar.html',
+            meta_filename: nil,
+            mtime: now,
+            num: 1,
+          }
+        end
+
+        it 'loads that file' do
+          expect(subject.size).to eq(1)
+
+          expect(subject[0].content.string).to eq('test 1')
+          expect(subject[0].attributes).to eq(expected_attributes)
+          expect(subject[0].identifier).to eq(Nanoc::Identifier.new('/bar/'))
+          expect(subject[0].checksum_data).to be_nil
+          expect(subject[0].content_checksum_data).to eq('test 1')
+          expect(subject[0].attributes_checksum_data).to eq("num: 1\n")
+        end
+      end
+    end
+  end
+end

data/spec/nanoc/deploying/fog_spec.rb

@@ -0,0 +1,193 @@
+describe Nanoc::Deploying::Deployers::Fog, stdio: true do
+  let(:deployer) do
+    Nanoc::Deploying::Deployers::Fog.new(
+      'output/',
+      config,
+      dry_run: is_dry_run,
+    )
+  end
+
+  let(:is_dry_run) { false }
+
+  let(:config) do
+    {
+      bucket: 'bucky',
+      provider: 'local',
+      local_root: 'remote',
+    }
+  end
+
+  before do
+    # create output
+    FileUtils.mkdir_p('output')
+    FileUtils.mkdir_p('output/etc')
+    File.open('output/woof', 'w') { |io| io.write 'I am a dog!' }
+    File.open('output/etc/meow', 'w') { |io| io.write 'I am a cat!' }
+
+    # create local cloud
+    FileUtils.mkdir_p('remote')
+  end
+
+  subject { deployer.run }
+
+  shared_examples 'no effective deploy' do
+    it 'does not modify remote' do
+      expect { subject }.not_to change { Dir['remote/**/*'].sort }
+    end
+  end
+
+  shared_examples 'effective deploy' do
+    it 'modifies remote' do
+      expect { subject }.to change { Dir['remote/**/*'].sort }
+        .to([
+          'remote/bucky',
+          'remote/bucky/etc',
+          'remote/bucky/etc/meow',
+          'remote/bucky/woof',
+        ])
+    end
+  end
+
+  context 'dry run' do
+    let(:is_dry_run) { true }
+
+    before do
+      FileUtils.mkdir_p('remote/bucky')
+      FileUtils.mkdir_p('remote/bucky/tiny')
+      File.write('remote/bucky/pig', 'oink?')
+      File.write('remote/bucky/tiny/piglet', 'little oink?')
+    end
+
+    include_examples 'no effective deploy'
+
+    context 'with CDN ID' do
+      let(:config) { super().merge(cdn_id: 'donkey-cdn') }
+
+      let(:cdn) { Object.new }
+      let(:distribution) { Object.new }
+
+      it 'does not actually invalidate' do
+        expect(::Fog::CDN).to receive(:new).with(provider: 'local', local_root: 'remote').and_return(cdn)
+        expect(cdn).to receive(:get_distribution).with('donkey-cdn').and_return(distribution)
+
+        subject
+      end
+    end
+  end
+
+  context 'effective run' do
+    include_examples 'effective deploy'
+
+    context 'custom path' do
+      context 'custom path ends with /' do
+        let(:config) do
+          super().merge(path: 'foo/')
+        end
+
+        it 'raises' do
+          expect { subject }.to raise_error('The path `foo/` is not supposed to have a trailing slash')
+        end
+      end
+
+      context 'custom path does not end with /' do
+        let(:config) do
+          super().merge(path: 'foo')
+        end
+
+        it 'modifies remote' do
+          expect { subject }.to change { Dir['remote/**/*'].sort }
+            .to([
+              'remote/bucky',
+              'remote/bucky/foo',
+              'remote/bucky/foo/etc',
+              'remote/bucky/foo/etc/meow',
+              'remote/bucky/foo/woof',
+            ])
+        end
+      end
+    end
+
+    context 'bucket already exists' do
+      before do
+        FileUtils.mkdir_p('remote/bucky')
+      end
+
+      include_examples 'effective deploy'
+    end
+
+    context 'remote contains stale file at root' do
+      before do
+        FileUtils.mkdir_p('remote/bucky')
+        File.write('remote/bucky/pig', 'oink?')
+      end
+
+      include_examples 'effective deploy'
+
+      it 'does not contain stale files' do
+        subject
+        expect(Dir['remote/**/*'].sort).not_to include('remote/bucky/pig')
+      end
+    end
+
+    context 'remote contains stale file in subdirectory' do
+      before do
+        FileUtils.mkdir_p('remote/bucky/secret')
+        File.write('remote/bucky/secret/pig', 'oink?')
+      end
+
+      include_examples 'effective deploy'
+
+      it 'does not contain stale files' do
+        subject
+        expect(Dir['remote/**/*'].sort).not_to include('remote/bucky/secret/pig')
+      end
+    end
+
+    context 'with CDN ID' do
+      let(:config) { super().merge(cdn_id: 'donkey-cdn') }
+
+      let(:cdn) { Object.new }
+      let(:distribution) { Object.new }
+
+      it 'invalidates' do
+        expect(::Fog::CDN).to receive(:new).with(provider: 'local', local_root: 'remote').and_return(cdn)
+        expect(cdn).to receive(:get_distribution).with('donkey-cdn').and_return(distribution)
+        expect(cdn).to receive(:post_invalidation).with(distribution, contain_exactly('etc/meow', 'woof'))
+
+        subject
+      end
+    end
+
+    context 'remote list consists of truncated sets' do
+      before do
+        expect(::Fog::Storage).to receive(:new).and_return(fog_storage)
+        expect(fog_storage).to receive(:directories).and_return(directories)
+        expect(directories).to receive(:get).and_return(directory)
+        allow(directory).to receive(:files).and_return(files)
+        expect(files).to receive(:get).with('stray').and_return(file_stray).ordered
+        expect(files).to receive(:each)
+          .and_yield(double(:woof, key: 'woof'))
+          .and_yield(double(:meow, key: 'etc/meow'))
+          .and_yield(double(:stray, key: 'stray'))
+        expect(file_stray).to receive(:destroy)
+
+        expect(files).to receive(:create).with(key: 'woof', body: anything, public: true) do
+          FileUtils.mkdir_p('remote/bucky')
+          File.write('remote/bucky/woof', 'hi')
+        end
+        expect(files).to receive(:create).with(key: 'etc/meow', body: anything, public: true) do
+          FileUtils.mkdir_p('remote/bucky/etc')
+          File.write('remote/bucky/etc/meow', 'hi')
+        end
+      end
+
+      let(:fog_storage) { double(:fog_storage) }
+      let(:directories) { double(:directories) }
+      let(:directory) { double(:directory) }
+      let(:files) { double(:files) }
+      let(:file_stray) { double(:file_stray) }
+
+      include_examples 'effective deploy'
+    end
+  end
+end

data/spec/nanoc/extra/parallel_collection_spec.rb

@@ -0,0 +1,108 @@
+describe Nanoc::Extra::ParallelCollection do
+  subject(:col) { described_class.new(wrapped, parallelism: parallelism) }
+  let(:wrapped) { [1, 2, 3, 4, 5] }
+  let(:parallelism) { 5 }
+
+  describe '#each' do
+    subject do
+      col.each do |e|
+        sleep 0.1
+        out << e
+      end
+    end
+    let!(:out) { [] }
+
+    it 'is fast' do
+      expect { subject }.to finish_in_under(0.2).seconds
+    end
+
+    it 'is correct' do
+      expect { subject }.to change { out.sort }.from([]).to([1, 2, 3, 4, 5])
+    end
+
+    it 'does not leave threads lingering' do
+      expect { subject }.not_to change { Thread.list.size }
+    end
+
+    context 'errors' do
+      subject do
+        col.each do |e|
+          if e == 1
+            sleep 0.02
+            raise 'ugh'
+          else
+            sleep 0.1
+            out << e
+          end
+        end
+      end
+
+      let(:parallelism) { 3 }
+
+      it 'raises' do
+        expect { subject }.to raise_error(RuntimeError, 'ugh')
+      end
+
+      it 'aborts early' do
+        expect { subject rescue nil }.to change { out.sort }.from([]).to([2, 3])
+      end
+    end
+
+    context 'low parallelism' do
+      let(:parallelism) { 1 }
+
+      it 'is not fast' do
+        expect { subject }.not_to finish_in_under(0.5).seconds
+      end
+    end
+  end
+
+  describe '#map' do
+    subject do
+      col.map do |e|
+        sleep 0.1
+        e * 10
+      end
+    end
+
+    it 'is fast' do
+      expect { subject }.to finish_in_under(0.2).seconds
+    end
+
+    it 'does not leave threads lingering' do
+      expect { subject }.not_to change { Thread.list.size }
+    end
+
+    it 'is correct' do
+      expect(subject.sort).to eq([10, 20, 30, 40, 50])
+    end
+
+    context 'errors' do
+      subject do
+        col.each do |e|
+          if e == 1
+            sleep 0.02
+            raise 'ugh'
+          else
+            sleep 0.1
+            e * 10
+          end
+        end
+      end
+
+      let(:parallelism) { 3 }
+
+      it 'raises' do
+        expect { subject }.to raise_error(RuntimeError, 'ugh')
+      end
+    end
+
+    context 'low parallelism' do
+      let(:parallelism) { 1 }
+
+      it 'is not fast' do
+        expect { subject }.not_to finish_in_under(0.5).seconds
+      end
+    end
+  end
+end

data/spec/nanoc/filters/colorize_syntax/rouge_spec.rb

@@ -0,0 +1,195 @@
+require 'rouge'
+
+describe Nanoc::Filters::ColorizeSyntax, filter: true, rouge: true do
+  subject { filter.setup_and_run(input, default_colorizer: :rouge, rouge: params) }
+  let(:filter) { ::Nanoc::Filters::ColorizeSyntax.new }
+  let(:params) { {} }
+  let(:wrap) { false }
+  let(:css_class) { 'highlight' }
+  let(:input) do
+    <<-EOS.freeze
+before
+<pre><code class="language-ruby">
+  def foo
+  end
+</code></pre>
+after
+    EOS
+  end
+  let(:output) do
+    <<-EOS
+before
+<pre><code class=\"language-ruby#{wrap ? " #{css_class}" : ''}\">  <span class=\"k\">def</span> <span class=\"nf\">foo</span>
+  <span class=\"k\">end</span></code></pre>
+after
+    EOS
+  end
+
+  context 'with Rouge' do
+    context 'with 1.x', if: Rouge.version < '2' do
+      context 'with default options' do
+        it { is_expected.to eql output }
+      end
+
+      context 'with pygments wrapper' do
+        let(:wrap) { true }
+        let(:params) { super().merge(wrap: wrap) }
+
+        it { is_expected.to eql output }
+
+        context 'with css_class' do
+          let(:css_class) { 'nanoc' }
+          let(:params) { super().merge(css_class: css_class) }
+
+          it { is_expected.to eql output }
+        end
+      end
+
+      context 'with line number' do
+        let(:line_numbers) { true }
+        let(:params) { super().merge(line_numbers: line_numbers) }
+        let(:output) do
+          <<-EOS
+before
+<pre><code class="language-ruby"><table style="border-spacing: 0"><tbody><tr>
+<td class="gutter gl" style="text-align: right"><pre class="lineno">1
+2</pre></td>
+<td class="code"><pre>  <span class="k">def</span> <span class="nf">foo</span>
+  <span class="k">end</span><span class="w">
+</span></pre></td>
+</tr></tbody></table></code></pre>
+after
+          EOS
+        end
+
+        it { is_expected.to eql output }
+      end
+    end
+
+    context 'with 2.x', if: Rouge.version >= '2' do
+      context 'with default options' do
+        it { is_expected.to eql output }
+      end
+
+      context 'with legacy' do
+        let(:legacy) { true }
+        let(:params) { super().merge(legacy: legacy) }
+
+        it { is_expected.to eql output }
+
+        context 'with pygments wrapper' do
+          let(:wrap) { true }
+          let(:params) { super().merge(wrap: wrap) }
+
+          it { is_expected.to eql output }
+
+          context 'with css_class' do
+            let(:css_class) { 'nanoc' }
+            let(:params) { super().merge(css_class: css_class) }
+
+            it { is_expected.to eql output }
+          end
+        end
+
+        context 'with line number' do
+          let(:line_numbers) { true }
+          let(:params) { super().merge(line_numbers: line_numbers) }
+          let(:output) do
+            <<-EOS
+before
+<pre><code class="language-ruby"><table class="rouge-table"><tbody><tr>
+<td class="rouge-gutter gl"><pre class="lineno">1
+2
+</pre></td>
+<td class="rouge-code"><pre>  <span class="k">def</span> <span class="nf">foo</span>
+  <span class="k">end</span></pre></td>
+</tr></tbody></table></code></pre>
+after
+            EOS
+          end
+
+          it { is_expected.to eql output }
+        end
+      end
+
+      context 'with formater' do
+        let(:params) { super().merge(formatter: formatter) }
+
+        context 'with inline' do
+          let(:formatter) { Rouge::Formatters::HTMLInline.new(theme) }
+
+          context 'with github theme' do
+            let(:theme) { Rouge::Themes::Github.new }
+            let(:output) do
+              <<-EOS
+before
+<pre><code class="language-ruby">  <span style="color: #000000;font-weight: bold">def</span> <span style="color: #990000;font-weight: bold">foo</span>
+  <span style="color: #000000;font-weight: bold">end</span></code></pre>
+after
+              EOS
+            end
+
+            it { is_expected.to eql output }
+          end
+
+          context 'with colorful theme' do
+            let(:theme) { Rouge::Themes::Colorful.new }
+            let(:output) do
+              <<-EOS
+before
+<pre><code class="language-ruby">  <span style="color: #080;font-weight: bold">def</span> <span style="color: #06B;font-weight: bold">foo</span>
+  <span style="color: #080;font-weight: bold">end</span></code></pre>
+after
+              EOS
+            end
+
+            it { is_expected.to eql output }
+          end
+        end
+
+        context 'with linewise' do
+          let(:formatter) { Rouge::Formatters::HTMLLinewise.new(Rouge::Formatters::HTML.new) }
+          let(:output) do
+            <<-EOS
+before
+<pre><code class="language-ruby"><div class="line-1">  <span class="k">def</span> <span class="nf">foo</span>
+</div>
+<div class="line-2">  <span class="k">end</span>
+</div></code></pre>
+after
+            EOS
+          end
+
+          it { is_expected.to eql output }
+        end
+
+        context 'with pygments' do
+          let(:wrap) { true }
+          let(:css_class) { 'codehilite' }
+          let(:formatter) { Rouge::Formatters::HTMLPygments.new(Rouge::Formatters::HTML.new) }
+
+          it { is_expected.to eql output }
+        end
+
+        context 'with table' do
+          let(:formatter) { Rouge::Formatters::HTMLTable.new(Rouge::Formatters::HTML.new) }
+          let(:output) do
+            <<-EOS
+before
+<pre><code class="language-ruby"><table class="rouge-table"><tbody><tr>
+<td class="rouge-gutter gl"><pre class="lineno">1
+2
+</pre></td>
+<td class="rouge-code"><pre>  <span class="k">def</span> <span class="nf">foo</span>
+  <span class="k">end</span></pre></td>
+</tr></tbody></table></code></pre>
+after
+            EOS
+          end
+
+          it { is_expected.to eql output }
+        end
+      end
+    end
+  end
+end

data/spec/nanoc/filters/less_spec.rb

@@ -0,0 +1,120 @@
+describe Nanoc::Filters::Less, site: true, stdio: true, v8: true do
+  # These tests are high-level in order to interact well with the compiler. This is important for
+  # this :less filter, because of the way it handles fibers.
+
+  before do
+    File.open('Rules', 'w') do |io|
+      io.write "compile '/**/*.less' do\n"
+      io.write "  filter :less\n"
+      io.write "  write item.identifier.without_ext + '.css'\n"
+      io.write "end\n"
+    end
+  end
+
+  context 'one file' do
+    let(:content_a) { 'p { color: red; }' }
+
+    before do
+      File.write('content/a.less', content_a)
+    end
+
+    it 'compiles a.less' do
+      Nanoc::CLI.run(%w(compile))
+      expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*red;?\s*\}/)
+    end
+
+    context 'with compression' do
+      let(:content_a) { '.foo { bar: a; } .bar { foo: b; }' }
+
+      before do
+        File.open('Rules', 'w') do |io|
+          io.write "compile '/*.less' do\n"
+          io.write "  filter :less, compress: true\n"
+          io.write "  write item.identifier.without_ext + '.css'\n"
+          io.write "end\n"
+        end
+      end
+
+      it 'compiles and compresses a.less' do
+        Nanoc::CLI.run(%w(compile))
+        expect(File.read('output/a.css')).to match(/^\.foo\{bar:a\}\n?\.bar\{foo:b\}/)
+      end
+    end
+  end
+
+  context 'two files' do
+    let(:content_a) { '@import "b.less";' }
+    let(:content_b) { 'p { color: red; }' }
+
+    before do
+      File.write('content/a.less', content_a)
+      File.write('content/b.less', content_b)
+    end
+
+    it 'compiles a.less' do
+      Nanoc::CLI.run(%w(compile))
+      expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*red;?\s*\}/)
+    end
+
+    it 'recompiles a.less if b.less has changed' do
+      Nanoc::CLI.run(%w(compile))
+
+      File.write('content/b.less', 'p { color: blue; }')
+
+      Nanoc::CLI.run(%w(compile))
+      expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*blue;?\s*\}/)
+    end
+  end
+
+  context 'paths relative to site directory' do
+    let(:content_a) { '@import "content/foo/bar/imported_file.less";' }
+    let(:content_b) { 'p { color: red; }' }
+
+    before do
+      FileUtils.mkdir_p('content/foo/bar')
+
+      File.write('content/a.less', content_a)
+      File.write('content/foo/bar/imported_file.less', content_b)
+    end
+
+    it 'compiles a.less' do
+      Nanoc::CLI.run(%w(compile))
+      expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*red;?\s*\}/)
+    end
+
+    it 'recompiles a.less if b.less has changed' do
+      Nanoc::CLI.run(%w(compile))
+
+      File.write('content/foo/bar/imported_file.less', 'p { color: blue; }')
+
+      Nanoc::CLI.run(%w(compile))
+      expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*blue;?\s*\}/)
+    end
+  end
+
+  context 'paths relative to current file' do
+    let(:content_a) { '@import "bar/imported_file.less";' }
+    let(:content_b) { 'p { color: red; }' }
+
+    before do
+      FileUtils.mkdir_p('content/foo/bar')
+
+      File.write('content/foo/a.less', content_a)
+      File.write('content/foo/bar/imported_file.less', content_b)
+    end
+
+    it 'compiles a.less' do
+      Nanoc::CLI.run(%w(compile))
+      expect(File.read('output/foo/a.css')).to match(/^p\s*\{\s*color:\s*red;?\s*\}/)
+    end
+
+    it 'recompiles a.less if b.less has changed' do
+      Nanoc::CLI.run(%w(compile))
+
+      File.write('content/foo/bar/imported_file.less', 'p { color: blue; }')
+
+      Nanoc::CLI.run(%w(compile))
+      expect(File.read('output/foo/a.css')).to match(/^p\s*\{\s*color:\s*blue;?\s*\}/)
+    end
+  end
+end