nanoc 4.4.5 → 4.4.6

data/spec/nanoc/base/views/item_rep_collection_view_spec.rb

@@ -0,0 +1,143 @@
+shared_examples 'an item rep collection view' do
+  let(:view) { described_class.new(wrapped, view_context) }
+
+  let(:view_context) { double(:view_context) }
+
+  let(:wrapped) do
+    [
+      double(:item_rep, name: :foo),
+      double(:item_rep, name: :bar),
+      double(:item_rep, name: :baz),
+    ]
+  end
+
+  describe '#unwrap' do
+    subject { view.unwrap }
+
+    it { should equal(wrapped) }
+  end
+
+  describe '#frozen?' do
+    subject { view.frozen? }
+
+    context 'non-frozen collection' do
+      it { is_expected.to be(false) }
+    end
+
+    context 'frozen collection' do
+      before { wrapped.freeze }
+      it { is_expected.to be(true) }
+    end
+  end
+
+  describe '#each' do
+    it 'yields' do
+      actual = [].tap { |res| view.each { |v| res << v } }
+      expect(actual.size).to eq(3)
+    end
+
+    it 'returns self' do
+      expect(view.each { |_i| }).to equal(view)
+    end
+
+    it 'yields elements with the right context' do
+      view.each { |v| expect(v._context).to equal(view_context) }
+    end
+  end
+
+  describe '#size' do
+    subject { view.size }
+
+    it { should == 3 }
+  end
+
+  describe '#to_ary' do
+    subject { view.to_ary }
+
+    it 'returns an array of item rep views' do
+      expect(subject.class).to eq(Array)
+      expect(subject.size).to eq(3)
+      expect(subject[0].class).to eql(expected_view_class)
+      expect(subject[0].name).to eql(:foo)
+    end
+
+    it 'returns an array with correct contexts' do
+      expect(subject[0]._context).to equal(view_context)
+    end
+  end
+
+  describe '#[]' do
+    subject { view[name] }
+
+    context 'when not found' do
+      let(:name) { :donkey }
+
+      it { should be_nil }
+    end
+
+    context 'when found' do
+      let(:name) { :foo }
+
+      it 'returns a view' do
+        expect(subject.class).to eq(expected_view_class)
+        expect(subject.name).to eq(:foo)
+      end
+
+      it 'returns a view with the correct context' do
+        expect(subject._context).to equal(view_context)
+      end
+    end
+
+    context 'when given a string' do
+      let(:name) { 'foo' }
+
+      it 'raises' do
+        expect { subject }.to raise_error(ArgumentError, 'expected ItemRepCollectionView#[] to be called with a symbol')
+      end
+    end
+
+    context 'when given a number' do
+      let(:name) { 0 }
+
+      it 'raises' do
+        expect { subject }.to raise_error(ArgumentError, 'expected ItemRepCollectionView#[] to be called with a symbol (you likely want `.reps[:default]` rather than `.reps[0]`)')
+      end
+    end
+  end
+
+  describe '#fetch' do
+    subject { view.fetch(name) }
+
+    context 'when not found' do
+      let(:name) { :donkey }
+
+      it 'raises' do
+        expect { subject }.to raise_error(Nanoc::ItemRepCollectionView::NoSuchItemRepError)
+      end
+    end
+
+    context 'when found' do
+      let(:name) { :foo }
+
+      it 'returns a view' do
+        expect(subject.class).to eq(expected_view_class)
+        expect(subject.name).to eq(:foo)
+      end
+
+      it 'returns a view with the correct context' do
+        expect(subject._context).to equal(view_context)
+      end
+    end
+  end
+
+  describe '#inspect' do
+    subject { view.inspect }
+
+    it { is_expected.to eql('<' + described_class.name + '>') }
+  end
+end
+
+describe Nanoc::ItemRepCollectionView do
+  it_behaves_like 'an item rep collection view'
+  let(:expected_view_class) { Nanoc::ItemRepView }
+end

data/spec/nanoc/base/views/item_rep_view_spec.rb

@@ -0,0 +1,265 @@
+describe Nanoc::ItemRepView do
+  let(:view_context) { Nanoc::ViewContext.new(reps: reps, items: items, dependency_tracker: dependency_tracker, compilation_context: compilation_context) }
+
+  let(:reps) { double(:reps) }
+  let(:items) { double(:items) }
+  let(:compilation_context) { double(:compilation_context) }
+
+  let(:dependency_tracker) { Nanoc::Int::DependencyTracker.new(dependency_store) }
+  let(:dependency_store) { Nanoc::Int::DependencyStore.new([]) }
+  let(:base_item) { Nanoc::Int::Item.new('base', {}, '/base.md') }
+
+  before do
+    dependency_tracker.enter(base_item)
+  end
+
+  describe '#frozen?' do
+    let(:item_rep) { Nanoc::Int::ItemRep.new(item, :jacques) }
+    let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo/') }
+    let(:view) { described_class.new(item_rep, view_context) }
+
+    subject { view.frozen? }
+
+    context 'non-frozen item rep' do
+      it { is_expected.to be(false) }
+    end
+
+    context 'frozen item rep' do
+      before { item_rep.freeze }
+      it { is_expected.to be(true) }
+    end
+  end
+
+  describe '#== and #eql?' do
+    let(:item_rep) { Nanoc::Int::ItemRep.new(item, :jacques) }
+    let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo/') }
+    let(:view) { described_class.new(item_rep, view_context) }
+
+    context 'comparing with item rep with same identifier' do
+      let(:other_item) { double(:other_item, identifier: '/foo/') }
+      let(:other) { double(:other_item_rep, item: other_item, name: :jacques) }
+
+      it 'is ==' do
+        expect(view).to eq(other)
+      end
+
+      it 'is eql?' do
+        expect(view).not_to eql(other)
+      end
+    end
+
+    context 'comparing with item rep with different identifier' do
+      let(:other_item) { double(:other_item, identifier: '/bar/') }
+      let(:other) { double(:other_item_rep, item: other_item, name: :jacques) }
+
+      it 'is not ==' do
+        expect(view).not_to eq(other)
+      end
+
+      it 'is not eql?' do
+        expect(view).not_to eql(other)
+      end
+    end
+
+    context 'comparing with item rep with different name' do
+      let(:other_item) { double(:other_item, identifier: '/foo/') }
+      let(:other) { double(:other_item_rep, item: other_item, name: :marvin) }
+
+      it 'is not ==' do
+        expect(view).not_to eq(other)
+      end
+
+      it 'is not eql?' do
+        expect(view).not_to eql(other)
+      end
+    end
+
+    context 'comparing with item rep with same identifier' do
+      let(:other_item) { double(:other_item, identifier: '/foo/') }
+      let(:other) { described_class.new(double(:other_item_rep, item: other_item, name: :jacques), view_context) }
+
+      it 'is ==' do
+        expect(view).to eq(other)
+      end
+
+      it 'is eql?' do
+        expect(view).not_to eql(other)
+      end
+    end
+
+    context 'comparing with item rep with different identifier' do
+      let(:other_item) { double(:other_item, identifier: '/bar/') }
+      let(:other) { described_class.new(double(:other_item_rep, item: other_item, name: :jacques), view_context) }
+
+      it 'is not equal' do
+        expect(view).not_to eq(other)
+        expect(view).not_to eql(other)
+      end
+    end
+
+    context 'comparing with item rep with different name' do
+      let(:other_item) { double(:other_item, identifier: '/foo/') }
+      let(:other) { described_class.new(double(:other_item_rep, item: other_item, name: :marvin), view_context) }
+
+      it 'is not equal' do
+        expect(view).not_to eq(other)
+        expect(view).not_to eql(other)
+      end
+    end
+
+    context 'comparing with something that is not an item rep' do
+      let(:other_item) { double(:other_item, identifier: '/foo/') }
+      let(:other) { :donkey }
+
+      it 'is not equal' do
+        expect(view).not_to eq(other)
+        expect(view).not_to eql(other)
+      end
+    end
+  end
+
+  describe '#hash' do
+    let(:item_rep) { Nanoc::Int::ItemRep.new(item, :jacques) }
+    let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo/') }
+    let(:view) { described_class.new(item_rep, view_context) }
+
+    subject { view.hash }
+
+    it { should == described_class.hash ^ Nanoc::Identifier.new('/foo/').hash ^ :jacques.hash }
+  end
+
+  describe '#compiled_content' do
+    subject { view.compiled_content }
+
+    let(:view) { described_class.new(rep, view_context) }
+
+    let(:rep) do
+      Nanoc::Int::ItemRep.new(item, :default).tap do |ir|
+        ir.compiled = true
+        ir.snapshot_defs = [
+          Nanoc::Int::SnapshotDef.new(:last),
+        ]
+        ir.snapshot_contents = {
+          last: Nanoc::Int::TextualContent.new('Hallo'),
+        }
+      end
+    end
+
+    let(:item) do
+      Nanoc::Int::Item.new('content', {}, '/asdf.md')
+    end
+
+    it 'creates a dependency' do
+      expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item])
+    end
+
+    it 'creates a dependency with the right props' do
+      subject
+      dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0]
+
+      expect(dep.props.compiled_content?).to eq(true)
+
+      expect(dep.props.raw_content?).to eq(false)
+      expect(dep.props.attributes?).to eq(false)
+      expect(dep.props.path?).to eq(false)
+    end
+
+    it { should eq('Hallo') }
+  end
+
+  describe '#path' do
+    subject { view.path }
+
+    let(:view) { described_class.new(rep, view_context) }
+
+    let(:rep) do
+      Nanoc::Int::ItemRep.new(item, :default).tap do |ir|
+        ir.paths = {
+          last: '/about/',
+        }
+      end
+    end
+
+    let(:item) do
+      Nanoc::Int::Item.new('content', {}, '/asdf.md')
+    end
+
+    it 'creates a dependency' do
+      expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item])
+    end
+
+    it 'creates a dependency with the right props' do
+      subject
+      dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0]
+
+      expect(dep.props.path?).to eq(true)
+
+      expect(dep.props.raw_content?).to eq(false)
+      expect(dep.props.attributes?).to eq(false)
+      expect(dep.props.compiled_content?).to eq(false)
+    end
+
+    it { should eq('/about/') }
+  end
+
+  describe '#raw_path' do
+    subject { view.raw_path }
+
+    let(:view) { described_class.new(rep, view_context) }
+
+    let(:rep) do
+      Nanoc::Int::ItemRep.new(item, :default).tap do |ir|
+        ir.raw_paths = {
+          last: 'output/about/index.html',
+        }
+      end
+    end
+
+    let(:item) do
+      Nanoc::Int::Item.new('content', {}, '/asdf.md')
+    end
+
+    it 'creates a dependency' do
+      expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item])
+    end
+
+    it 'creates a dependency with the right props' do
+      subject
+      dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0]
+
+      expect(dep.props.path?).to eq(true)
+
+      expect(dep.props.raw_content?).to eq(false)
+      expect(dep.props.attributes?).to eq(false)
+      expect(dep.props.compiled_content?).to eq(false)
+    end
+
+    it { should eq('output/about/index.html') }
+  end
+
+  describe '#item' do
+    let(:item_rep) { Nanoc::Int::ItemRep.new(item, :jacques) }
+    let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo/') }
+    let(:view) { described_class.new(item_rep, view_context) }
+
+    subject { view.item }
+
+    it 'returns an item view' do
+      expect(subject).to be_a(Nanoc::ItemWithRepsView)
+    end
+
+    it 'returns an item view with the right context' do
+      expect(subject._context).to equal(view_context)
+    end
+  end
+
+  describe '#inspect' do
+    let(:item_rep) { Nanoc::Int::ItemRep.new(item, :jacques) }
+    let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo/') }
+    let(:view) { described_class.new(item_rep, view_context) }
+
+    subject { view.inspect }
+
+    it { is_expected.to eql('<Nanoc::ItemRepView item.identifier=/foo/ name=jacques>') }
+  end
+end