nanoc 4.8.12 → 4.8.13

data/spec/nanoc/helpers/filtering_spec.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Helpers::Filtering, helper: true do
-  describe '#filter' do
-    before do
-      ctx.create_item('some content', { title: 'Hello!' }, '/about.md')
-      ctx.create_rep(ctx.items['/about.md'], '/about.html')
-
-      ctx.item = ctx.items['/about.md']
-      ctx.item_rep = ctx.item.reps[:default]
-    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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,320 +0,0 @@
-# frozen_string_literal: true
-
-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
-      before do
-        ctx.create_item('content', {}, '/target')
-        ctx.create_rep(ctx.items['/target'], '/target.html')
-      end
-
-      let(:target) { ctx.items['/target'].reps[:default] }
-
-      it { is_expected.to eql('<a href="/target.html">Text</a>') }
-    end
-
-    context 'with item' do
-      before do
-        ctx.create_item('content', {}, '/target')
-      end
-
-      let(:target) { ctx.items['/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
-      before do
-        ctx.create_item('content', {}, '/target')
-        ctx.create_rep(ctx.items['/target'], nil)
-      end
-
-      let(:target) { ctx.items['/target'].reps[:default] }
-
-      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.create_item('content', {}, '/target.md')
-          ctx.create_rep(ctx.items['/target.md'], '/target.html')
-
-          ctx.item = ctx.items['/target.md']
-          ctx.item_rep = ctx.item.reps[:default]
-        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.create_item('content', {}, '/other.md')
-          ctx.create_rep(ctx.items['/other.md'], '/other.html')
-
-          ctx.item = ctx.items['/other.md']
-          ctx.item_rep = ctx.item.reps[:default]
-        end
-
-        it { is_expected.to eql('<a href="/target.html">Text</a>') }
-      end
-    end
-
-    context 'with rep' do
-      before do
-        ctx.create_item('content', {}, '/target.md')
-        ctx.create_rep(ctx.items['/target.md'], '/target.html')
-
-        ctx.create_item('content', {}, '/other.md')
-        ctx.create_rep(ctx.items['/other.md'], '/other.html')
-
-        ctx.item = ctx.items['/target.md']
-        ctx.item_rep = ctx.item.reps[:default]
-      end
-
-      let(:some_item) { ctx.items['/other.md'] }
-      let(:some_item_rep) { some_item.reps[:default] }
-
-      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.create_item('content', {}, '/target.md')
-        ctx.create_rep(ctx.items['/target.md'], '/target.html')
-
-        ctx.create_item('content', {}, '/other.md')
-        ctx.create_rep(ctx.items['/other.md'], '/other.html')
-
-        ctx.item = ctx.items['/target.md']
-        ctx.item_rep = ctx.item.reps[:default]
-      end
-
-      let(:some_item) { ctx.items['/other.md'] }
-      let(:some_item_rep) { some_item.reps[:default] }
-
-      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.create_item('content', {}, '/foo/self.md')
-      ctx.create_rep(ctx.items['/foo/self.md'], self_path)
-
-      ctx.item = ctx.items['/foo/self.md']
-      ctx.item_rep = ctx.item.reps[:default]
-    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
-        before do
-          ctx.create_rep(ctx.item, '/bar/target.html', :special)
-        end
-
-        let(:target) { ctx.item.reps[:special] }
-
-        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.items['/bar/target.md'] }
-
-        before do
-          ctx.create_item('content', {}, '/bar/target.md')
-          ctx.create_rep(ctx.items['/bar/target.md'], '/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.item.reps[:special] }
-
-        before do
-          ctx.create_rep(ctx.item, nil, :special)
-        end
-
-        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

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Helpers::Rendering, helper: true do
-  describe '#render' do
-    subject { helper.instance_eval { render('/partial.erb') } }
-
-    let(:action_sequence_for_layout) do
-      [Nanoc::Int::ProcessingActions::Filter.new(:erb, {})]
-    end
-
-    let(:layout_view) { ctx.layouts[layout_identifier] }
-    let(:layout) { layout_view.unwrap }
-
-    before do
-      ctx.create_layout(layout_content, {}, layout_identifier)
-      ctx.update_action_sequence(layout, action_sequence_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(an_instance_of(Nanoc::Int::LayoutCollection), raw_content: ['/partial/'], attributes: false, compiled_content: false, path: false)
-              .ordered
-            expect(ctx.dependency_tracker).to receive(:enter)
-              .with(layout, raw_content: true, attributes: false, compiled_content: false, path: false)
-              .ordered
-
-            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(:action_sequence_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(:action_sequence_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