nanoc 4.4.5 → 4.4.6

data/spec/nanoc/helpers/blogging_spec.rb

@@ -0,0 +1,216 @@
+describe Nanoc::Helpers::Blogging, helper: true do
+  before do
+    allow(ctx.dependency_tracker).to receive(:enter)
+    allow(ctx.dependency_tracker).to receive(:exit)
+  end
+
+  describe '#articles' do
+    subject { helper.articles }
+
+    before do
+      ctx.create_item('blah', { kind: 'item' }, '/0/')
+      ctx.create_item('blah blah', { kind: 'article' }, '/1/')
+      ctx.create_item('blah blah blah', { kind: 'article' }, '/2/')
+    end
+
+    it 'returns the two articles' do
+      expect(subject.map(&:identifier)).to match_array(['/1/', '/2/'])
+    end
+  end
+
+  describe '#sorted_articles' do
+    subject { helper.sorted_articles }
+
+    before do
+      attrs = { kind: 'item' }
+      ctx.create_item('blah', attrs, '/0/')
+
+      attrs = { kind: 'article', created_at: (Date.today - 1).to_s }
+      ctx.create_item('blah blah', attrs, '/1/')
+
+      attrs = { kind: 'article', created_at: (Time.now - 500).to_s }
+      ctx.create_item('blah blah blah', attrs, '/2/')
+    end
+
+    it 'returns the two articles in descending order' do
+      expect(subject.map(&:identifier)).to eq(['/2/', '/1/'])
+    end
+  end
+
+  describe '#url_for' do
+    subject { helper.url_for(ctx.items['/stuff/']) }
+
+    let(:item_attributes) { {} }
+
+    before do
+      item = ctx.create_item('Stuff', item_attributes, '/stuff/')
+      ctx.create_rep(item, '/rep/path/stuff.html')
+
+      ctx.config[:base_url] = base_url
+    end
+
+    context 'without base_url' do
+      let(:base_url) { nil }
+
+      it 'raises' do
+        expect { subject }.to raise_error(Nanoc::Error)
+      end
+    end
+
+    context 'with base_url' do
+      let(:base_url) { 'http://url.base' }
+
+      context 'with custom_url_in_feed' do
+        let(:item_attributes) do
+          { custom_url_in_feed: 'http://example.com/stuff.html' }
+        end
+
+        it 'returns custom URL' do
+          expect(subject).to eql('http://example.com/stuff.html')
+        end
+      end
+
+      context 'without custom_url_in_feed' do
+        context 'with custom_path_in_feed' do
+          let(:item_attributes) do
+            { custom_path_in_feed: '/stuff.html' }
+          end
+
+          it 'returns base URL + custom path' do
+            expect(subject).to eql('http://url.base/stuff.html')
+          end
+        end
+
+        context 'without custom_path_in_feed' do
+          it 'returns base URL + path' do
+            expect(subject).to eql('http://url.base/rep/path/stuff.html')
+          end
+        end
+      end
+    end
+  end
+
+  describe '#feed_url' do
+    subject { helper.feed_url }
+
+    let(:item_attributes) { {} }
+
+    before do
+      ctx.item = ctx.create_item('Feed', item_attributes, '/feed/')
+      ctx.create_rep(ctx.item, '/feed.xml')
+
+      ctx.config[:base_url] = base_url
+    end
+
+    context 'without base_url' do
+      let(:base_url) { nil }
+
+      it 'raises' do
+        expect { subject }.to raise_error(Nanoc::Error)
+      end
+    end
+
+    context 'with base_url' do
+      let(:base_url) { 'http://url.base' }
+
+      context 'with feed_url' do
+        let(:item_attributes) do
+          { feed_url: 'http://custom.feed.url/feed.rss' }
+        end
+
+        it 'returns custom URL' do
+          expect(subject).to eql('http://custom.feed.url/feed.rss')
+        end
+      end
+
+      context 'without feed_url' do
+        it 'returns base URL + path' do
+          expect(subject).to eql('http://url.base/feed.xml')
+        end
+      end
+    end
+  end
+
+  describe '#attribute_to_time' do
+    subject { helper.attribute_to_time(arg) }
+
+    let(:noon_s) { 1_446_903_076 }
+    let(:beginning_of_day_s) { 1_446_854_400 }
+
+    let(:around_noon_local) { Time.at(noon_s - Time.at(noon_s).utc_offset) }
+    let(:around_noon_utc) { Time.at(noon_s) }
+    let(:beginning_of_day_utc) { Time.at(beginning_of_day_s) }
+
+    context 'with Time instance' do
+      let(:arg) { around_noon_utc }
+      it { is_expected.to eql(around_noon_utc) }
+    end
+
+    context 'with Date instance' do
+      let(:arg) { Date.new(2015, 11, 7) }
+      it { is_expected.to eql(beginning_of_day_utc) }
+    end
+
+    context 'with DateTime instance' do
+      let(:arg) { DateTime.new(2015, 11, 7, 13, 31, 16) }
+      it { is_expected.to eql(around_noon_utc) }
+    end
+
+    context 'with string' do
+      let(:arg) { '2015-11-7 13:31:16' }
+      it { is_expected.to eql(around_noon_local) }
+    end
+  end
+
+  describe '#atom_tag_for' do
+    subject { helper.atom_tag_for(ctx.items['/stuff/']) }
+
+    let(:item_attributes) { { created_at: '2015-05-19 12:34:56' } }
+    let(:item_rep_path) { '/stuff.xml' }
+    let(:base_url) { 'http://url.base' }
+
+    before do
+      item = ctx.create_item('Stuff', item_attributes, '/stuff/')
+      ctx.create_rep(item, item_rep_path)
+
+      ctx.config[:base_url] = base_url
+    end
+
+    context 'item with path' do
+      let(:item_rep_path) { '/stuff.xml' }
+      it { is_expected.to eql('tag:url.base,2015-05-19:/stuff.xml') }
+    end
+
+    context 'item without path' do
+      let(:item_rep_path) { nil }
+      it { is_expected.to eql('tag:url.base,2015-05-19:/stuff/') }
+    end
+
+    context 'bare URL without subdir' do
+      let(:base_url) { 'http://url.base' }
+      it { is_expected.to eql('tag:url.base,2015-05-19:/stuff.xml') }
+    end
+
+    context 'bare URL with subdir' do
+      let(:base_url) { 'http://url.base/sub' }
+      it { is_expected.to eql('tag:url.base,2015-05-19:/sub/stuff.xml') }
+    end
+
+    context 'created_at is date' do
+      let(:item_attributes) do
+        { created_at: Date.parse('2015-05-19 12:34:56') }
+      end
+      it { is_expected.to eql('tag:url.base,2015-05-19:/stuff.xml') }
+    end
+
+    context 'created_at is time' do
+      let(:item_attributes) do
+        { created_at: Time.parse('2015-05-19 12:34:56') }
+      end
+      it { is_expected.to eql('tag:url.base,2015-05-19:/stuff.xml') }
+    end
+
+    # TODO: handle missing base_dir
+    # TODO: handle missing created_at
+  end
+end

data/spec/nanoc/helpers/breadcrumbs_spec.rb

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

@@ -0,0 +1,181 @@
+describe Nanoc::Helpers::Capturing, helper: true do
+  describe '#content_for' do
+    before do
+      ctx.item = ctx.create_item('some content', {}, '/about.md')
+      ctx.create_rep(ctx.item, '/about.html')
+    end
+
+    describe 'with name + block' do
+      let(:_erbout) { 'existing content' }
+
+      context 'only name given' do
+        subject { helper.content_for(:foo) { _erbout << 'foo' } }
+
+        it 'stores snapshot content' do
+          subject
+          expect(ctx.item.reps[:default].unwrap.snapshot_contents[:__capture_foo].string).to eql('foo')
+        end
+      end
+
+      context 'name and params given' do
+        subject { helper.content_for(:foo, params) { _erbout << 'foo' } }
+        let(:params) { raise 'overwrite me' }
+
+        context 'no existing behavior specified' do
+          let(:params) { {} }
+
+          it 'errors after two times' do
+            helper.content_for(:foo, params) { _erbout << 'foo' }
+            expect { helper.content_for(:foo, params) { _erbout << 'bar' } }.to raise_error(RuntimeError)
+          end
+        end
+
+        context 'existing behavior is :overwrite' do
+          let(:params) { { existing: :overwrite } }
+
+          it 'overwrites' do
+            helper.content_for(:foo, params) { _erbout << 'foo' }
+            helper.content_for(:foo, params) { _erbout << 'bar' }
+            expect(ctx.item.reps[:default].unwrap.snapshot_contents[:__capture_foo].string).to eql('bar')
+          end
+        end
+
+        context 'existing behavior is :append' do
+          let(:params) { { existing: :append } }
+
+          it 'appends' do
+            helper.content_for(:foo, params) { _erbout << 'foo' }
+            helper.content_for(:foo, params) { _erbout << 'bar' }
+            expect(ctx.item.reps[:default].unwrap.snapshot_contents[:__capture_foo].string).to eql('foobar')
+          end
+        end
+
+        context 'existing behavior is :error' do
+          let(:params) { { existing: :error } }
+
+          it 'errors after two times' do
+            helper.content_for(:foo, params) { _erbout << 'foo' }
+            expect { helper.content_for(:foo, params) { _erbout << 'bar' } }.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
+
+    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
+          item = ctx.create_item('other content', {}, '/other.md')
+          ctx.create_rep(item, '/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
+        end
+
+        context 'other item is compiled' do
+          before do
+            item.reps[:default].unwrap.compiled = true
+            item.reps[:default].unwrap.snapshot_contents[:__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

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