nanoc 4.8.12 → 4.8.13

data/spec/nanoc/base/views/support/item_rep_collection_view_examples.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-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 BasicItemRepCollectionView#[] 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 BasicItemRepCollectionView#[] 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::BasicItemRepCollectionView::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

data/spec/nanoc/base/views/support/item_rep_view_examples.rb

@@ -1,308 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples 'an item rep view' do
-  # needs expected_item_view_class
-
-  let(:view_context) do
-    Nanoc::ViewContextForCompilation.new(
-      reps:                Nanoc::Int::ItemRepRepo.new,
-      items:               Nanoc::Int::ItemCollection.new(config),
-      dependency_tracker:  dependency_tracker,
-      compilation_context: compilation_context,
-      snapshot_repo:       snapshot_repo,
-    )
-  end
-
-  let(:compilation_context) { double(:compilation_context) }
-  let(:snapshot_repo) { Nanoc::Int::SnapshotRepo.new }
-
-  let(:dependency_tracker) { Nanoc::Int::DependencyTracker.new(dependency_store) }
-  let(:dependency_store) { Nanoc::Int::DependencyStore.new(empty_items, empty_layouts, config) }
-  let(:base_item) { Nanoc::Int::Item.new('base', {}, '/base.md') }
-
-  let(:empty_items) { Nanoc::Int::ItemCollection.new(config) }
-  let(:empty_layouts) { Nanoc::Int::LayoutCollection.new(config) }
-
-  let(:config) { Nanoc::Int::Configuration.new.with_defaults }
-
-  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 '#snapshot?' do
-    subject { view.snapshot?(snapshot_name) }
-
-    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, binary: false),
-        ]
-      end
-    end
-
-    let(:item) do
-      Nanoc::Int::Item.new('content', {}, '/asdf.md')
-    end
-
-    let(:snapshot_name) { raise 'override me' }
-
-    before do
-      snapshot_repo.set(rep, :last, Nanoc::Int::TextualContent.new('Hallo'))
-    end
-
-    context 'snapshot exists' do
-      let(:snapshot_name) { :last }
-
-      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 { is_expected.to be }
-    end
-
-    context 'snapshot does not exist' do
-      let(:snapshot_name) { :donkey }
-
-      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 { is_expected.not_to be }
-    end
-  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 '#binary?' 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.binary? }
-
-    context 'no :last snapshot' do
-      before do
-        item_rep.snapshot_defs = []
-      end
-
-      it 'raises' do
-        expect { subject }.to raise_error(Nanoc::Int::Errors::NoSuchSnapshot)
-      end
-    end
-
-    context ':last snapshot is textual' do
-      before do
-        item_rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(:last, binary: false)]
-      end
-
-      it { is_expected.not_to be }
-    end
-
-    context ':last snapshot is binary' do
-      before do
-        item_rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(:last, binary: true)]
-      end
-
-      it { is_expected.to be }
-    end
-  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(expected_item_view_class)
-    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('<' + described_class.to_s + ' item.identifier=/foo name=jacques>') }
-  end
-end

data/spec/nanoc/base/views/support/mutable_document_view_examples.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples 'a mutable document view' do
-  let(:view) { described_class.new(document, view_context) }
-
-  let(:view_context) do
-    Nanoc::ViewContextForCompilation.new(
-      reps:                Nanoc::Int::ItemRepRepo.new,
-      items:               Nanoc::Int::ItemCollection.new(config),
-      dependency_tracker:  dependency_tracker,
-      compilation_context: double(:compilation_context),
-      snapshot_repo:       snapshot_repo,
-    )
-  end
-
-  let(:dependency_tracker) { Nanoc::Int::DependencyTracker.new(double(:dependency_store)) }
-  let(:snapshot_repo) { double(:snapshot_repo) }
-  let(:config) { Nanoc::Int::Configuration.new }
-
-  describe '#raw_content=' do
-    let(:document) { entity_class.new('content', {}, '/asdf') }
-
-    it 'sets raw content' do
-      expect { view.raw_content = 'donkey' }
-        .to change { document.content.string }
-        .from('content')
-        .to('donkey')
-    end
-
-    context 'checksum_data set' do
-      before do
-        document.checksum_data = 'my checksum data'
-        document.content_checksum_data = 'my content checksum data'
-        document.attributes_checksum_data = 'my attributes checksum data'
-      end
-
-      it 'unsets checksum_data' do
-        expect { view.raw_content = 'donkey' }
-          .to change { document.checksum_data }
-          .from('my checksum data')
-          .to(nil)
-      end
-
-      it 'unsets content_checksum_data' do
-        expect { view.raw_content = 'donkey' }
-          .to change { document.content_checksum_data }
-          .from('my content checksum data')
-          .to(nil)
-      end
-
-      it 'keeps attributes_checksum_data' do
-        expect { view.raw_content = 'donkey' }
-          .not_to change { document.attributes_checksum_data }
-      end
-    end
-  end
-
-  describe '#[]=' do
-    let(:document) { entity_class.new('content', {}, '/asdf') }
-
-    it 'sets attributes' do
-      view[:title] = 'Donkey'
-      expect(view[:title]).to eq('Donkey')
-    end
-
-    it 'disallows items' do
-      item = Nanoc::Int::Item.new('content', {}, '/foo.md')
-      expect { view[:item] = item }.to raise_error(Nanoc::MutableDocumentViewMixin::DisallowedAttributeValueError)
-    end
-
-    it 'disallows layouts' do
-      layout = Nanoc::Int::Layout.new('content', {}, '/foo.md')
-      expect { view[:layout] = layout }.to raise_error(Nanoc::MutableDocumentViewMixin::DisallowedAttributeValueError)
-    end
-
-    it 'disallows item views' do
-      item = Nanoc::CompilationItemView.new(Nanoc::Int::Item.new('content', {}, '/foo.md'), nil)
-      expect { view[:item] = item }.to raise_error(Nanoc::MutableDocumentViewMixin::DisallowedAttributeValueError)
-    end
-
-    it 'disallows layout views' do
-      layout = Nanoc::LayoutView.new(Nanoc::Int::Layout.new('content', {}, '/foo.md'), nil)
-      expect { view[:layout] = layout }.to raise_error(Nanoc::MutableDocumentViewMixin::DisallowedAttributeValueError)
-    end
-
-    context 'checksum_data set' do
-      before do
-        document.checksum_data = 'my checksum data'
-        document.content_checksum_data = 'my content checksum data'
-        document.attributes_checksum_data = 'my attributes checksum data'
-      end
-
-      it 'unsets checksum_data' do
-        expect { view[:title] = 'Donkey' }
-          .to change { document.checksum_data }
-          .from('my checksum data')
-          .to(nil)
-      end
-
-      it 'unsets attributes_checksum_data' do
-        expect { view[:title] = 'Donkey' }
-          .to change { document.attributes_checksum_data }
-          .from('my attributes checksum data')
-          .to(nil)
-      end
-
-      it 'keeps content_checksum_data' do
-        expect { view[:title] = 'Donkey' }
-          .not_to change { document.content_checksum_data }
-      end
-    end
-  end
-
-  describe '#identifier=' do
-    let(:document) { entity_class.new('content', {}, '/about.md') }
-
-    subject { view.identifier = arg }
-
-    context 'given a string' do
-      let(:arg) { '/about.adoc' }
-
-      it 'changes the identifier' do
-        subject
-        expect(view.identifier).to eq('/about.adoc')
-      end
-    end
-
-    context 'given an identifier' do
-      let(:arg) { Nanoc::Identifier.new('/about.adoc') }
-
-      it 'changes the identifier' do
-        subject
-        expect(view.identifier).to eq('/about.adoc')
-      end
-    end
-
-    context 'given anything else' do
-      let(:arg) { :donkey }
-
-      it 'raises' do
-        expect { subject }.to raise_error(Nanoc::Identifier::NonCoercibleObjectError)
-      end
-    end
-  end
-
-  describe '#update_attributes' do
-    let(:document) { entity_class.new('content', {}, '/asdf') }
-
-    let(:update) { { friend: 'Giraffe' } }
-
-    subject { view.update_attributes(update) }
-
-    it 'sets attributes' do
-      expect { subject }.to change { view[:friend] }.from(nil).to('Giraffe')
-    end
-
-    it 'returns self' do
-      expect(subject).to equal(view)
-    end
-
-    context 'checksum_data set' do
-      before do
-        document.checksum_data = 'my checksum data'
-        document.content_checksum_data = 'my content checksum data'
-        document.attributes_checksum_data = 'my attributes checksum data'
-      end
-
-      it 'unsets checksum_data' do
-        expect { subject }
-          .to change { document.checksum_data }
-          .from('my checksum data')
-          .to(nil)
-      end
-
-      it 'unsets attributes_checksum_data' do
-        expect { subject }
-          .to change { document.attributes_checksum_data }
-          .from('my attributes checksum data')
-          .to(nil)
-      end
-
-      it 'keeps content_checksum_data' do
-        expect { subject }
-          .not_to change { document.content_checksum_data }
-      end
-    end
-  end
-end