nanoc 4.4.5 → 4.4.6

data/spec/nanoc/helpers/filtering_spec.rb

@@ -0,0 +1,72 @@
+describe Nanoc::Helpers::Filtering, helper: true do
+  describe '#filter' do
+    before do
+      ctx.item = ctx.create_item('some content', { title: 'Hello!' }, '/about.md')
+      ctx.item_rep = ctx.create_rep(ctx.item, '/about.html')
+    end
+
+    let(:content) do
+      "A<% filter :erb do %><%%= 'X' %><% end %>B"
+    end
+
+    subject { ::ERB.new(content).result(helper.get_binding) }
+
+    context 'basic case' do
+      it { is_expected.to eql('AXB') }
+
+      it 'notifies' do
+        ns = Set.new
+        Nanoc::Int::NotificationCenter.on(:filtering_started) { ns << :filtering_started }
+        Nanoc::Int::NotificationCenter.on(:filtering_ended)   { ns << :filtering_ended   }
+
+        subject
+
+        expect(ns).to include(:filtering_started)
+        expect(ns).to include(:filtering_ended)
+      end
+    end
+
+    context 'with assigns' do
+      let(:content) do
+        'A<% filter :erb do %><%%= @item[:title] %><% end %>B'
+      end
+
+      it { is_expected.to eql('AHello!B') }
+    end
+
+    context 'unknonwn filter name' do
+      let(:content) do
+        'A<% filter :donkey do %>X<% end %>B'
+      end
+
+      it 'errors' do
+        expect { subject }.to raise_error(Nanoc::Int::Errors::UnknownFilter)
+      end
+    end
+
+    context 'with locals' do
+      let(:content) do
+        "A<% filter :erb, locals: { sheep: 'baah' } do %><%%= @sheep %><% end %>B"
+      end
+
+      it { is_expected.to eql('AbaahB') }
+    end
+
+    context 'with Haml' do
+      let(:content) do
+        "%p Foo.\n" \
+        "- filter(:erb) do\n" \
+        "  <%= 'abc' + 'xyz' %>\n" \
+        "%p Bar.\n"
+      end
+
+      before do
+        require 'haml'
+      end
+
+      subject { ::Haml::Engine.new(content).render(helper.get_binding) }
+
+      it { is_expected.to match(%r{^<p>Foo.</p>\s*abcxyz\s*<p>Bar.</p>$}) }
+    end
+  end
+end

data/spec/nanoc/helpers/html_escape_spec.rb

@@ -0,0 +1,35 @@
+describe Nanoc::Helpers::HTMLEscape, helper: true do
+  describe '#html_escape' do
+    subject { helper.html_escape(string) }
+
+    context 'given strings to escape' do
+      let(:string) { '< > & "' }
+      it { is_expected.to eql('&lt; &gt; &amp; &quot;') }
+    end
+
+    context 'given a block' do
+      let!(:_erbout) { 'moo' }
+
+      it 'adds escaped content to _erbout' do
+        helper.html_escape { _erbout << '<h1>Stuff!</h1>' }
+        expect(_erbout).to eql('moo&lt;h1&gt;Stuff!&lt;/h1&gt;')
+      end
+    end
+
+    context 'given no argument nor block' do
+      subject { helper.html_escape }
+
+      it 'raises' do
+        expect { subject }.to raise_error(RuntimeError)
+      end
+    end
+
+    context 'given argument that is not a string' do
+      let(:string) { 1 }
+
+      it 'raises an ArgumentError' do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/nanoc/helpers/link_to_spec.rb

@@ -0,0 +1,275 @@
+describe Nanoc::Helpers::LinkTo, helper: true do
+  describe '#link_to' do
+    subject { helper.link_to(text, target, attributes) }
+
+    let(:text) { 'Text' }
+    let(:target) { raise 'override me' }
+    let(:attributes) { {} }
+
+    context 'with string path' do
+      let(:target) { '/foo/' }
+      it { is_expected.to eql('<a href="/foo/">Text</a>') }
+
+      context 'with attributes' do
+        let(:attributes) { { title: 'Donkey' } }
+        it { is_expected.to eql('<a title="Donkey" href="/foo/">Text</a>') }
+      end
+
+      context 'special HTML characters in text' do
+        let(:text) { 'Foo &amp; Bar' }
+        it { is_expected.to eql('<a href="/foo/">Foo &amp; Bar</a>') }
+        # Not escaped!
+      end
+
+      context 'special HTML characters in URL' do
+        let(:target) { '/r&d/' }
+        it { is_expected.to eql('<a href="/r&amp;d/">Text</a>') }
+      end
+
+      context 'special HTML characters in attribute' do
+        let(:attributes) { { title: 'Research & Development' } }
+        it { is_expected.to eql('<a title="Research &amp; Development" href="/foo/">Text</a>') }
+      end
+    end
+
+    context 'with rep' do
+      let(:item) { ctx.create_item('content', {}, '/target/') }
+      let(:target) { ctx.create_rep(item, '/target.html') }
+
+      it { is_expected.to eql('<a href="/target.html">Text</a>') }
+    end
+
+    context 'with item' do
+      let(:target) { ctx.create_item('content', {}, '/target/') }
+
+      before do
+        ctx.create_rep(target, '/target.html')
+      end
+
+      it { is_expected.to eql('<a href="/target.html">Text</a>') }
+    end
+
+    context 'with nil' do
+      let(:target) { nil }
+
+      it 'raises' do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with something else' do
+      let(:target) { :donkey }
+
+      it 'raises' do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with nil path' do
+      let(:item) { ctx.create_item('content', {}, '/target/') }
+      let(:target) { ctx.create_rep(item, nil) }
+
+      it 'raises' do
+        expect { subject }.to raise_error(RuntimeError)
+      end
+    end
+  end
+
+  describe '#link_to_unless_current' do
+    subject { helper.link_to_unless_current(text, target, attributes) }
+
+    let(:text) { 'Text' }
+    let(:target) { raise 'override me' }
+    let(:attributes) { {} }
+
+    context 'with string path' do
+      let(:target) { '/target.html' }
+
+      context 'current' do
+        before do
+          ctx.item = ctx.create_item('content', {}, '/target.md')
+          ctx.item_rep = ctx.create_rep(ctx.item, '/target.html')
+        end
+
+        it { is_expected.to eql('<span class="active">Text</span>') }
+      end
+
+      context 'no item rep present' do
+        it { is_expected.to eql('<a href="/target.html">Text</a>') }
+      end
+
+      context 'item rep present, but not current' do
+        before do
+          ctx.item = ctx.create_item('content', {}, '/other.md')
+          ctx.item_rep = ctx.create_rep(ctx.item, '/other.html')
+        end
+
+        it { is_expected.to eql('<a href="/target.html">Text</a>') }
+      end
+    end
+
+    context 'with rep' do
+      before do
+        ctx.item = ctx.create_item('content', {}, '/target.md')
+        ctx.item_rep = ctx.create_rep(ctx.item, '/target.html')
+      end
+
+      let(:some_item) { ctx.create_item('content', {}, '/other.md') }
+      let(:some_item_rep) { ctx.create_rep(some_item, '/other.html') }
+
+      context 'current' do
+        let(:target) { ctx.item_rep }
+        it { is_expected.to eql('<span class="active">Text</span>') }
+      end
+
+      context 'no item rep present' do
+        let(:target) { some_item_rep }
+
+        before do
+          ctx.item = nil
+          ctx.item_rep = nil
+        end
+
+        it { is_expected.to eql('<a href="/other.html">Text</a>') }
+      end
+
+      context 'item rep present, but not current' do
+        let(:target) { some_item_rep }
+        it { is_expected.to eql('<a href="/other.html">Text</a>') }
+      end
+    end
+
+    context 'with item' do
+      before do
+        ctx.item = ctx.create_item('content', {}, '/target.md')
+        ctx.item_rep = ctx.create_rep(ctx.item, '/target.html')
+      end
+
+      let!(:some_item) { ctx.create_item('content', {}, '/other.md') }
+      let!(:some_item_rep) { ctx.create_rep(some_item, '/other.html') }
+
+      context 'current' do
+        let(:target) { ctx.item }
+        it { is_expected.to eql('<span class="active">Text</span>') }
+      end
+
+      context 'no item rep present' do
+        let(:target) { some_item }
+
+        before do
+          ctx.item = nil
+          ctx.item_rep = nil
+        end
+
+        it { is_expected.to eql('<a href="/other.html">Text</a>') }
+      end
+
+      context 'item rep present, but not current' do
+        let(:target) { some_item }
+        it { is_expected.to eql('<a href="/other.html">Text</a>') }
+      end
+    end
+  end
+
+  describe '#relative_path_to' do
+    subject { helper.relative_path_to(target) }
+
+    before do
+      ctx.item = ctx.create_item('content', {}, '/foo/self.md')
+      ctx.item_rep = ctx.create_rep(ctx.item, self_path)
+    end
+
+    context 'current item rep has non-nil path' do
+      let(:self_path) { '/foo/self.html' }
+
+      context 'to string path' do
+        context 'to relative path' do
+          let(:target) { 'bar/target.html' }
+
+          it 'errors' do
+            # TODO: Might make sense to allow this case (and return the path itself)
+            expect { subject }.to raise_error(ArgumentError)
+          end
+        end
+
+        context 'to path without trailing slash' do
+          let(:target) { '/bar/target.html' }
+          it { is_expected.to eql('../bar/target.html') }
+        end
+
+        context 'to path with trailing slash' do
+          let(:target) { '/bar/target/' }
+          it { is_expected.to eql('../bar/target/') }
+        end
+
+        context 'to Windows/UNC path (forward slashes)' do
+          let(:target) { '//foo' }
+          it { is_expected.to eql('//foo') }
+        end
+
+        context 'to Windows/UNC path (backslashes)' do
+          let(:target) { '\\\\foo' }
+          it { is_expected.to eql('\\\\foo') }
+        end
+      end
+
+      context 'to rep' do
+        let(:target) { ctx.create_rep(ctx.item, '/bar/target.html') }
+        it { is_expected.to eql('../bar/target.html') }
+
+        context 'to self' do
+          let(:target) { ctx.item_rep }
+
+          context 'self is a filename' do
+            it { is_expected.to eql('self.html') }
+          end
+
+          context 'self is a directory' do
+            let(:self_path) { '/foo/self/' }
+            it { is_expected.to eql('./') }
+          end
+        end
+      end
+
+      context 'to item' do
+        let(:target) { ctx.create_item('content', {}, '/bar/target.md') }
+
+        before do
+          ctx.create_rep(target, '/bar/target.html')
+        end
+
+        it { is_expected.to eql('../bar/target.html') }
+
+        context 'to self' do
+          let(:target) { ctx.item }
+
+          context 'self is a filename' do
+            it { is_expected.to eql('self.html') }
+          end
+
+          context 'self is a directory' do
+            let(:self_path) { '/foo/self/' }
+            it { is_expected.to eql('./') }
+          end
+        end
+      end
+
+      context 'to nil path' do
+        let(:target) { ctx.create_rep(ctx.item, nil) }
+
+        it 'raises' do
+          expect { subject }.to raise_error(RuntimeError)
+        end
+      end
+    end
+
+    context 'current item rep has nil path' do
+      let(:self_path) { nil }
+      let(:target) { '/bar/target.html' }
+
+      it 'errors' do
+        expect { subject }.to raise_error(RuntimeError)
+      end
+    end
+  end
+end

data/spec/nanoc/helpers/rendering_spec.rb

@@ -0,0 +1,141 @@
+describe Nanoc::Helpers::Rendering, helper: true do
+  describe '#render' do
+    subject { helper.instance_eval { render('/partial.erb') } }
+
+    let(:rule_memory_for_layout) do
+      [Nanoc::Int::ProcessingActions::Filter.new(:erb, {})]
+    end
+
+    let(:layout_view) do
+      ctx.create_layout(layout_content, {}, layout_identifier)
+    end
+
+    let(:layout) do
+      layout_view.unwrap
+    end
+
+    before do
+      ctx.update_rule_memory(layout, rule_memory_for_layout)
+    end
+
+    context 'legacy identifier' do
+      let(:layout_identifier) { Nanoc::Identifier.new('/partial/', type: :legacy) }
+
+      context 'cleaned identifier' do
+        subject { helper.instance_eval { render('/partial/') } }
+
+        context 'layout without instructions' do
+          let(:layout_content) { 'blah' }
+
+          it { is_expected.to eql('blah') }
+
+          it 'tracks proper dependencies' do
+            expect(ctx.dependency_tracker).to receive(:enter)
+              .with(layout, raw_content: true, attributes: false, compiled_content: false, path: false)
+            subject
+          end
+        end
+
+        context 'layout with instructions' do
+          let(:layout_content) { 'blah <%= @layout.identifier %>' }
+          it { is_expected.to eql('blah /partial/') }
+        end
+      end
+
+      context 'non-cleaned identifier' do
+        subject { helper.instance_eval { render('/partial') } }
+
+        context 'layout without instructions' do
+          let(:layout_content) { 'blah' }
+          it { is_expected.to eql('blah') }
+        end
+
+        context 'layout with instructions' do
+          let(:layout_content) { 'blah <%= @layout.identifier %>' }
+          it { is_expected.to eql('blah /partial/') }
+        end
+      end
+    end
+
+    context 'full-style identifier' do
+      let(:layout_identifier) { Nanoc::Identifier.new('/partial.erb') }
+
+      context 'layout without instructions' do
+        let(:layout_content) { 'blah' }
+        it { is_expected.to eql('blah') }
+      end
+
+      context 'layout with instructions' do
+        let(:layout_content) { 'blah <%= @layout.identifier %>' }
+        it { is_expected.to eql('blah /partial.erb') }
+      end
+
+      context 'printing wrapped layout class' do
+        let(:layout_content) { 'blah <%= @layout.class %>' }
+        it { is_expected.to eql('blah Nanoc::LayoutView') }
+      end
+
+      context 'printing unwrapped layout class' do
+        let(:layout_content) { 'blah <%= @layout.unwrap.class %>' }
+        it { is_expected.to eql('blah Nanoc::Int::Layout') }
+      end
+
+      context 'unknown layout' do
+        subject { helper.instance_eval { render('/unknown.erb') } }
+
+        let(:layout_content) { 'blah' }
+
+        it 'raises' do
+          expect { subject }.to raise_error(Nanoc::Int::Errors::UnknownLayout)
+        end
+      end
+
+      context 'layout with unknown filter' do
+        let(:rule_memory_for_layout) do
+          [Nanoc::Int::ProcessingActions::Filter.new(:donkey, {})]
+        end
+
+        let(:layout_content) { 'blah' }
+
+        it 'raises' do
+          expect { subject }.to raise_error(Nanoc::Int::Errors::UnknownFilter)
+        end
+      end
+
+      context 'layout without filter' do
+        let(:rule_memory_for_layout) do
+          [Nanoc::Int::ProcessingActions::Filter.new(nil, {})]
+        end
+
+        let(:layout_content) { 'blah' }
+
+        it 'raises' do
+          expect { subject }.to raise_error(Nanoc::Int::Errors::CannotDetermineFilter)
+        end
+      end
+
+      context 'with block' do
+        subject do
+          helper.instance_eval do
+            render('/partial.erb') { _erbout << 'extra content' }
+          end
+        end
+
+        before do
+          ctx.erbout << '[erbout-before]'
+        end
+
+        let(:layout_content) { '[partial-before]<%= yield %>[partial-after]' }
+
+        it 'returns an empty string' do
+          expect(subject).to eql('')
+        end
+
+        it 'modifies erbout' do
+          subject
+          expect(ctx.erbout).to eql('[erbout-before][partial-before]extra content[partial-after]')
+        end
+      end
+    end
+  end
+end

data/spec/nanoc/helpers/tagging_spec.rb

@@ -0,0 +1,104 @@
+describe Nanoc::Helpers::Tagging, helper: true do
+  describe '#tags_for' do
+    subject { helper.tags_for(item, params) }
+
+    let(:item) { ctx.items['/me.*'] }
+    let(:params) { {} }
+    let(:item_attributes) { {} }
+
+    before do
+      ctx.create_item('content', item_attributes, '/me.md')
+    end
+
+    context 'no tags' do
+      let(:item_attributes) { {} }
+      it { is_expected.to eql('(none)') }
+    end
+
+    context 'nil tag list' do
+      let(:item_attributes) { { tags: nil } }
+      it { is_expected.to eql('(none)') }
+    end
+
+    context 'empty tag list' do
+      let(:item_attributes) { { tags: [] } }
+      it { is_expected.to eql('(none)') }
+    end
+
+    context 'no tags, and custom none text' do
+      let(:item_attributes) { {} }
+      let(:params) { { none_text: 'no tags for you, fool' } }
+      it { is_expected.to eql('no tags for you, fool') }
+    end
+
+    context 'one tag' do
+      let(:item_attributes) { { tags: %w(donkey) } }
+
+      context 'implicit base_url' do
+        it { is_expected.to eql('donkey') }
+      end
+
+      context 'explicit nil base_url' do
+        let(:params) { { base_url: nil } }
+        it { is_expected.to eql('donkey') }
+      end
+
+      context 'explicit other base_url' do
+        let(:params) { { base_url: 'http://nanoc.ws/tag/' } }
+        it { is_expected.to eql('<a href="http://nanoc.ws/tag/donkey" rel="tag">donkey</a>') }
+      end
+    end
+
+    context 'two tags' do
+      let(:item_attributes) { { tags: %w(donkey giraffe) } }
+      it { is_expected.to eql('donkey, giraffe') }
+    end
+
+    context 'three tags' do
+      let(:item_attributes) { { tags: %w(donkey giraffe zebra) } }
+      it { is_expected.to eql('donkey, giraffe, zebra') }
+
+      context 'custom separator' do
+        let(:item_attributes) { { tags: %w(donkey giraffe zebra) } }
+        let(:params) { { separator: ' / ' } }
+        it { is_expected.to eql('donkey / giraffe / zebra') }
+      end
+    end
+  end
+
+  describe '#items_with_tag' do
+    subject { helper.items_with_tag(tag) }
+
+    before do
+      ctx.create_item('item 1', { tags: [:foo] }, '/item1.md')
+      ctx.create_item('item 2', { tags: [:bar] }, '/item2.md')
+      ctx.create_item('item 3', { tags: [:foo, :bar] }, '/item3.md')
+      ctx.create_item('item 4', { tags: nil }, '/item4.md')
+      ctx.create_item('item 5', {}, '/item5.md')
+    end
+
+    context 'tag that exists' do
+      let(:tag) { :foo }
+      it { is_expected.to contain_exactly(ctx.items['/item1.md'], ctx.items['/item3.md']) }
+    end
+
+    context 'tag that does not exists' do
+      let(:tag) { :other }
+      it { is_expected.to be_empty }
+    end
+  end
+
+  describe '#link_for_tag' do
+    subject { helper.link_for_tag(tag, base_url) }
+
+    let(:tag) { 'foo' }
+    let(:base_url) { 'http://nanoc.ws/tag/' }
+
+    it { is_expected.to eql('<a href="http://nanoc.ws/tag/foo" rel="tag">foo</a>') }
+
+    context 'tag with special HTML characters' do
+      let(:tag) { 'R&D' }
+      it { is_expected.to eql('<a href="http://nanoc.ws/tag/R&amp;D" rel="tag">R&amp;D</a>') }
+    end
+  end
+end

data/spec/nanoc/helpers/text_spec.rb

@@ -0,0 +1,58 @@
+describe Nanoc::Helpers::Text, helper: true do
+  describe '#excerptize' do
+    subject { helper.excerptize(string, params) }
+
+    let(:string) { 'Foo bar baz quux meow woof' }
+    let(:params) { {} }
+
+    context 'no params' do
+      it 'takes 25 characters' do
+        expect(subject).to eql('Foo bar baz quux meow ...')
+      end
+    end
+
+    context 'perfect fit' do
+      let(:params) { { length: 26 } }
+
+      it 'does not truncate' do
+        expect(subject).to eql('Foo bar baz quux meow woof')
+      end
+    end
+
+    context 'long length' do
+      let(:params) { { length: 27 } }
+
+      it 'does not truncate' do
+        expect(subject).to eql('Foo bar baz quux meow woof')
+      end
+    end
+
+    context 'short length' do
+      let(:params) { { length: 3 } }
+
+      it 'truncates' do
+        expect(subject).to eql('...')
+      end
+    end
+
+    context 'length shorter than omission' do
+      let(:params) { { length: 2 } }
+
+      it 'truncates, disregarding length' do
+        expect(subject).to eql('...')
+      end
+    end
+
+    context 'custom omission' do
+      let(:params) { { omission: '[continued]' } }
+
+      it 'uses custom omission string' do
+        expect(subject).to eql('Foo bar baz qu[continued]')
+      end
+    end
+  end
+
+  describe '#strip_html' do
+    # TODO: test this… or get rid of it (it’s bad!)
+  end
+end