nanoc 4.8.12 → 4.8.13

data/spec/nanoc/helpers/breadcrumbs_spec.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Helpers::Breadcrumbs, helper: true do
-  before do
-    allow(ctx.dependency_tracker).to receive(:enter)
-    allow(ctx.dependency_tracker).to receive(:exit)
-  end
-
-  describe '#breadcrumbs_trail' do
-    subject { helper.breadcrumbs_trail }
-
-    context 'legacy identifiers' do
-      context 'root' do
-        before do
-          ctx.create_item('root', {}, Nanoc::Identifier.new('/', type: :legacy))
-
-          ctx.item = ctx.items['/']
-        end
-
-        it 'returns an array with the item' do
-          expect(subject).to eql([ctx.items['/']])
-        end
-      end
-
-      context 'root and direct child' do
-        before do
-          ctx.create_item('child', {}, Nanoc::Identifier.new('/foo/', type: :legacy))
-          ctx.create_item('root', {}, Nanoc::Identifier.new('/', type: :legacy))
-
-          ctx.item = ctx.items['/foo/']
-        end
-
-        it 'returns an array with the items' do
-          expect(subject).to eql([ctx.items['/'], ctx.items['/foo/']])
-        end
-      end
-
-      context 'root, child and grandchild' do
-        before do
-          ctx.create_item('grandchild', {}, Nanoc::Identifier.new('/foo/bar/', type: :legacy))
-          ctx.create_item('child', {}, Nanoc::Identifier.new('/foo/', type: :legacy))
-          ctx.create_item('root', {}, Nanoc::Identifier.new('/', type: :legacy))
-
-          ctx.item = ctx.items['/foo/bar/']
-        end
-
-        it 'returns an array with the items' do
-          expect(subject).to eql([ctx.items['/'], ctx.items['/foo/'], ctx.items['/foo/bar/']])
-        end
-      end
-
-      context 'root, missing child and grandchild' do
-        before do
-          ctx.create_item('grandchild', {}, Nanoc::Identifier.new('/foo/bar/', type: :legacy))
-          ctx.create_item('root', {}, Nanoc::Identifier.new('/', type: :legacy))
-
-          ctx.item = ctx.items['/foo/bar/']
-        end
-
-        it 'returns an array with the items' do
-          expect(subject).to eql([ctx.items['/'], nil, ctx.items['/foo/bar/']])
-        end
-      end
-    end
-
-    context 'non-legacy identifiers' do
-      context 'root' do
-        before do
-          ctx.create_item('root', {}, Nanoc::Identifier.new('/index.md'))
-
-          ctx.item = ctx.items['/index.md']
-        end
-
-        it 'returns an array with the item' do
-          expect(subject).to eql([ctx.items['/index.md']])
-        end
-      end
-
-      context 'root and direct child' do
-        before do
-          ctx.create_item('child', {}, Nanoc::Identifier.new('/foo.md'))
-          ctx.create_item('root', {}, Nanoc::Identifier.new('/index.md'))
-
-          ctx.item = ctx.items['/foo.md']
-        end
-
-        it 'returns an array with the items' do
-          expect(subject).to eql([ctx.items['/index.md'], ctx.items['/foo.md']])
-        end
-      end
-
-      context 'root, child and grandchild' do
-        before do
-          ctx.create_item('grandchild', {}, Nanoc::Identifier.new('/foo/bar.md'))
-          ctx.create_item('child', {}, Nanoc::Identifier.new('/foo.md'))
-          ctx.create_item('root', {}, Nanoc::Identifier.new('/index.md'))
-
-          ctx.item = ctx.items['/foo/bar.md']
-        end
-
-        it 'returns an array with the items' do
-          expect(subject).to eql([ctx.items['/index.md'], ctx.items['/foo.md'], ctx.items['/foo/bar.md']])
-        end
-      end
-
-      context 'root, missing child and grandchild' do
-        before do
-          ctx.create_item('grandchild', {}, Nanoc::Identifier.new('/foo/bar.md'))
-          ctx.create_item('root', {}, Nanoc::Identifier.new('/index.md'))
-
-          ctx.item = ctx.items['/foo/bar.md']
-        end
-
-        it 'returns an array with the items' do
-          expect(subject).to eql([ctx.items['/index.md'], nil, ctx.items['/foo/bar.md']])
-        end
-      end
-
-      context 'index.md child' do
-        # No special handling of non-root index.* files.
-
-        before do
-          ctx.create_item('grandchild', {}, Nanoc::Identifier.new('/foo/index.md'))
-          ctx.create_item('root', {}, Nanoc::Identifier.new('/index.md'))
-
-          ctx.item = ctx.items['/foo/index.md']
-        end
-
-        it 'returns an array with the items' do
-          expect(subject).to eql([ctx.items['/index.md'], nil, ctx.items['/foo/index.md']])
-        end
-      end
-    end
-  end
-end

data/spec/nanoc/helpers/capturing_spec.rb

@@ -1,256 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Helpers::Capturing, helper: true do
-  describe '#content_for' do
-    before do
-      ctx.create_item('some content', {}, '/about.md')
-      ctx.create_rep(ctx.items['/about.md'], '/about.html')
-      ctx.item = ctx.items['/about.md']
-    end
-
-    describe 'setting content' do
-      let(:_erbout) { +'existing content' }
-
-      let(:params) { raise 'overwrite me' }
-
-      let(:contents_enumerator) { %w[foo bar].to_enum }
-
-      shared_examples 'setting content' do
-        context 'only name given' do
-          subject { subject_proc_without_params.call }
-
-          it 'stores snapshot content' do
-            subject
-            expect(ctx.snapshot_repo.get(ctx.item.reps[:default].unwrap, :__capture_foo).string).to eql('foo')
-          end
-        end
-
-        context 'name and params given' do
-          subject { subject_proc_with_params.call }
-          let(:params) { raise 'overwrite me' }
-
-          context 'no existing behavior specified' do
-            let(:params) { {} }
-
-            it 'errors after two times' do
-              subject_proc_with_params.call
-              expect { subject_proc_with_params.call }.to raise_error(RuntimeError)
-            end
-          end
-
-          context 'existing behavior is :overwrite' do
-            let(:params) { { existing: :overwrite } }
-
-            it 'overwrites' do
-              subject_proc_with_params.call
-              subject_proc_with_params.call
-              expect(ctx.snapshot_repo.get(ctx.item.reps[:default].unwrap, :__capture_foo).string).to eql('bar')
-            end
-          end
-
-          context 'existing behavior is :append' do
-            let(:params) { { existing: :append } }
-
-            it 'appends' do
-              subject_proc_with_params.call
-              subject_proc_with_params.call
-              expect(ctx.snapshot_repo.get(ctx.item.reps[:default].unwrap, :__capture_foo).string).to eql('foobar')
-            end
-          end
-
-          context 'existing behavior is :error' do
-            let(:params) { { existing: :error } }
-
-            it 'errors after two times' do
-              subject_proc_with_params.call
-              expect { subject_proc_with_params.call }.to raise_error(RuntimeError)
-            end
-          end
-
-          context 'existing behavior is :something else' do
-            let(:params) { { existing: :donkey } }
-
-            it 'errors' do
-              expect { subject }.to raise_error(ArgumentError)
-            end
-          end
-        end
-      end
-
-      context 'symbol name + block' do
-        let(:subject_proc_without_params) do
-          -> { helper.content_for(:foo) { _erbout << contents_enumerator.next } }
-        end
-
-        let(:subject_proc_with_params) do
-          -> { helper.content_for(:foo, params) { _erbout << contents_enumerator.next } }
-        end
-
-        include_examples 'setting content'
-      end
-
-      context 'string name + block' do
-        let(:subject_proc_without_params) do
-          -> { helper.content_for('foo') { _erbout << contents_enumerator.next } }
-        end
-
-        let(:subject_proc_with_params) do
-          -> { helper.content_for('foo', params) { _erbout << contents_enumerator.next } }
-        end
-
-        include_examples 'setting content'
-      end
-
-      context 'symbol name + string' do
-        let(:subject_proc_without_params) do
-          -> { helper.content_for(:foo, contents_enumerator.next) }
-        end
-
-        let(:subject_proc_with_params) do
-          -> { helper.content_for(:foo, params, contents_enumerator.next) }
-        end
-
-        include_examples 'setting content'
-      end
-
-      context 'string name + string' do
-        let(:subject_proc_without_params) do
-          -> { helper.content_for('foo', contents_enumerator.next) }
-        end
-
-        let(:subject_proc_with_params) do
-          -> { helper.content_for('foo', params, contents_enumerator.next) }
-        end
-
-        include_examples 'setting content'
-      end
-    end
-
-    describe 'with item + name' do
-      subject { helper.content_for(item, :foo) }
-
-      let(:_erbout) { +'existing content' }
-
-      context 'requesting for same item' do
-        let(:item) { ctx.item }
-
-        context 'nothing captured' do
-          it { is_expected.to be_nil }
-        end
-
-        context 'something captured' do
-          before do
-            helper.content_for(:foo) { _erbout << 'I have been captured!' }
-          end
-
-          it { is_expected.to eql('I have been captured!') }
-        end
-      end
-
-      context 'requesting for other item' do
-        let(:item) { ctx.items['/other.md'] }
-
-        before do
-          ctx.create_item('other content', {}, '/other.md')
-          ctx.create_rep(ctx.items['/other.md'], '/other.html')
-        end
-
-        context 'other item is not yet compiled' do
-          it 'raises an unmet dependency error' do
-            expect(ctx.dependency_tracker).to receive(:bounce).with(item.unwrap, compiled_content: true)
-            expect { subject }.to raise_error(FiberError)
-          end
-
-          it 're-runs when fiber is resumed' do
-            expect(ctx.dependency_tracker).to receive(:bounce).with(item.unwrap, compiled_content: true).twice
-
-            fiber = Fiber.new { subject }
-            expect(fiber.resume).to be_a(Nanoc::Int::Errors::UnmetDependency)
-
-            item.reps[:default].unwrap.compiled = true
-            ctx.snapshot_repo.set(
-              item.reps[:default].unwrap,
-              :__capture_foo,
-              Nanoc::Int::TextualContent.new('content after compilation'),
-            )
-            expect(fiber.resume).to eql('content after compilation')
-          end
-        end
-
-        context 'other item is compiled' do
-          before do
-            item.reps[:default].unwrap.compiled = true
-            ctx.snapshot_repo.set(
-              item.reps[:default].unwrap,
-              :__capture_foo,
-              Nanoc::Int::TextualContent.new('other captured foo'),
-            )
-          end
-
-          it 'returns the captured content' do
-            expect(ctx.dependency_tracker).to receive(:bounce).with(item.unwrap, compiled_content: true)
-            expect(subject).to eql('other captured foo')
-          end
-        end
-      end
-    end
-  end
-
-  describe '#capture' do
-    context 'with string' do
-      let(:_erbout) { +'existing content' }
-
-      subject { helper.capture { _erbout << 'new content' } }
-
-      it 'returns the appended content' do
-        expect(subject).to eql('new content')
-      end
-
-      it 'does not modify _erbout' do
-        expect { subject }.not_to change { _erbout }
-      end
-    end
-
-    context 'with array' do
-      let(:_erbout) { ['existing content'] }
-
-      shared_examples 'returns properly joined output' do
-        subject { helper.capture { _erbout << %w[new _ content] } }
-
-        it 'returns the appended content, joined' do
-          expect(subject).to eql('new_content')
-        end
-
-        it 'does not modify _erbout' do
-          expect { subject }.not_to change { _erbout.join('') }
-        end
-      end
-
-      context 'default output field separator' do
-        include_examples 'returns properly joined output'
-      end
-
-      context 'output field separator set to ,' do
-        around do |ex|
-          orig_output_field_separator = $OUTPUT_FIELD_SEPARATOR
-          $OUTPUT_FIELD_SEPARATOR = ','
-          ex.run
-          $OUTPUT_FIELD_SEPARATOR = orig_output_field_separator
-        end
-
-        include_examples 'returns properly joined output'
-      end
-
-      context 'output field separator set to nothing' do
-        around do |ex|
-          orig_output_field_separator = $OUTPUT_FIELD_SEPARATOR
-          $OUTPUT_FIELD_SEPARATOR = +''
-          ex.run
-          $OUTPUT_FIELD_SEPARATOR = orig_output_field_separator
-        end
-
-        include_examples 'returns properly joined output'
-      end
-    end
-  end
-end

data/spec/nanoc/helpers/child_parent_spec.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Helpers::ChildParent, helper: true do
-  describe '#children_of' do
-    subject { helper.children_of(item) }
-
-    before { ctx.create_item('some content', {}, identifier) }
-    let(:item) { ctx.items[identifier] }
-
-    context 'legacy identifier' do
-      let(:identifier) { Nanoc::Identifier.new('/foo/', type: :legacy) }
-
-      before do
-        ctx.create_item('abc', {}, Nanoc::Identifier.new('/foo/a/', type: :legacy))
-        ctx.create_item('def', {}, Nanoc::Identifier.new('/foo/a/b/', type: :legacy))
-        ctx.create_item('xyz', {}, Nanoc::Identifier.new('/bar/', type: :legacy))
-      end
-
-      it 'returns only direct children' do
-        expect(subject).to eql([ctx.items['/foo/a/']])
-      end
-    end
-
-    context 'full identifier' do
-      let(:identifier) { Nanoc::Identifier.new('/foo.md', type: :full) }
-
-      before do
-        ctx.create_item('abc', {}, Nanoc::Identifier.new('/foo/a.md', type: :full))
-        ctx.create_item('def', {}, Nanoc::Identifier.new('/foo/a/b.md', type: :full))
-        ctx.create_item('xyz', {}, Nanoc::Identifier.new('/bar.md', type: :full))
-        ctx.create_item('xyz', {}, Nanoc::Identifier.new('/foo/a/index.md', type: :full))
-      end
-
-      it 'returns only direct children' do
-        expect(subject).to eql([ctx.items['/foo/a.md']])
-      end
-    end
-  end
-
-  describe '#parent_of' do
-    subject { helper.parent_of(item) }
-
-    before { ctx.create_item('some content', {}, identifier) }
-    let(:item) { ctx.items[identifier] }
-
-    context 'legacy identifier' do
-      let(:identifier) { Nanoc::Identifier.new('/foo/bar/', type: :legacy) }
-
-      before do
-        ctx.create_item('abc', {}, Nanoc::Identifier.new('/foo/', type: :legacy))
-        ctx.create_item('def', {}, Nanoc::Identifier.new('/foo/qux/', type: :legacy))
-        ctx.create_item('xyz', {}, Nanoc::Identifier.new('/foo/bar/asdf/', type: :legacy))
-        ctx.create_item('opq', {}, Nanoc::Identifier.new('/', type: :legacy))
-      end
-
-      it 'returns parent' do
-        expect(subject).to eql(ctx.items['/foo/'])
-      end
-    end
-
-    context 'full identifier' do
-      let(:identifier) { Nanoc::Identifier.new('/foo/bar.md', type: :full) }
-
-      before do
-        ctx.create_item('abc', {}, Nanoc::Identifier.new('/foo.md', type: :full))
-        ctx.create_item('def', {}, Nanoc::Identifier.new('/foo/qux.md', type: :full))
-        ctx.create_item('xyz', {}, Nanoc::Identifier.new('/foo/bar/asdf.md', type: :full))
-        ctx.create_item('opq', {}, Nanoc::Identifier.new('/index.md', type: :full))
-      end
-
-      it 'returns parent' do
-        expect(subject).to eql(ctx.items['/foo.md'])
-      end
-    end
-  end
-end