nanoc 4.4.5 → 4.4.6

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

@@ -0,0 +1,341 @@
+describe Nanoc::ItemWithRepsView do
+  let(:entity_class) { Nanoc::Int::Item }
+  let(:other_view_class) { Nanoc::LayoutView }
+  it_behaves_like 'a document view'
+
+  let(:view_context) { Nanoc::ViewContext.new(reps: reps, items: items, dependency_tracker: dependency_tracker, compilation_context: compilation_context) }
+  let(:reps) { [] }
+  let(:items) { [] }
+  let(:dependency_tracker) { Nanoc::Int::DependencyTracker.new(dependency_store) }
+  let(:dependency_store) { Nanoc::Int::DependencyStore.new([]) }
+  let(:compilation_context) { double(:compilation_context) }
+
+  let(:base_item) { Nanoc::Int::Item.new('base', {}, '/base.md') }
+
+  before do
+    dependency_tracker.enter(base_item)
+  end
+
+  describe '#parent' do
+    let(:item) do
+      Nanoc::Int::Item.new('me', {}, identifier)
+    end
+
+    let(:view) { described_class.new(item, view_context) }
+
+    let(:items) do
+      Nanoc::Int::IdentifiableCollection.new({}).tap do |arr|
+        arr << item
+        arr << parent_item if parent_item
+      end
+    end
+
+    subject { view.parent }
+
+    context 'with parent' do
+      let(:parent_item) do
+        Nanoc::Int::Item.new('parent', {}, '/parent/')
+      end
+
+      context 'full identifier' do
+        let(:identifier) do
+          Nanoc::Identifier.new('/parent/me.md')
+        end
+
+        it 'raises' do
+          expect { subject }.to raise_error(Nanoc::Int::Errors::CannotGetParentOrChildrenOfNonLegacyItem)
+        end
+      end
+
+      context 'legacy identifier' do
+        let(:identifier) do
+          Nanoc::Identifier.new('/parent/me/', type: :legacy)
+        end
+
+        it 'returns a view for the parent' do
+          expect(subject.class).to eql(Nanoc::ItemWithRepsView)
+          expect(subject.unwrap).to eql(parent_item)
+        end
+
+        it 'returns a view with the right context' do
+          expect(subject._context).to equal(view_context)
+        end
+
+        context 'frozen parent' do
+          before { parent_item.freeze }
+          it { is_expected.to be_frozen }
+        end
+
+        context 'non-frozen parent' do
+          it { is_expected.not_to be_frozen }
+        end
+
+        context 'with root parent' do
+          let(:parent_item) { Nanoc::Int::Item.new('parent', {}, '/') }
+          let(:identifier) { Nanoc::Identifier.new('/me/', type: :legacy) }
+
+          it 'returns a view for the parent' do
+            expect(subject.class).to eql(Nanoc::ItemWithRepsView)
+            expect(subject.unwrap).to eql(parent_item)
+          end
+        end
+      end
+    end
+
+    context 'without parent' do
+      let(:parent_item) do
+        nil
+      end
+
+      context 'full identifier' do
+        let(:identifier) do
+          Nanoc::Identifier.new('/me.md')
+        end
+
+        it 'raises' do
+          expect { subject }.to raise_error(Nanoc::Int::Errors::CannotGetParentOrChildrenOfNonLegacyItem)
+        end
+      end
+
+      context 'legacy identifier' do
+        let(:identifier) do
+          Nanoc::Identifier.new('/me/', type: :legacy)
+        end
+
+        it { is_expected.to be_nil }
+        it { is_expected.to be_frozen }
+      end
+    end
+  end
+
+  describe '#children' do
+    let(:item) do
+      Nanoc::Int::Item.new('me', {}, identifier)
+    end
+
+    let(:children) do
+      [Nanoc::Int::Item.new('child', {}, '/me/child/')]
+    end
+
+    let(:view) { described_class.new(item, view_context) }
+
+    let(:items) do
+      Nanoc::Int::IdentifiableCollection.new({}).tap do |arr|
+        arr << item
+        children.each { |child| arr << child }
+      end
+    end
+
+    subject { view.children }
+
+    context 'full identifier' do
+      let(:identifier) do
+        Nanoc::Identifier.new('/me.md')
+      end
+
+      it 'raises' do
+        expect { subject }.to raise_error(Nanoc::Int::Errors::CannotGetParentOrChildrenOfNonLegacyItem)
+      end
+    end
+
+    context 'legacy identifier' do
+      let(:identifier) do
+        Nanoc::Identifier.new('/me/', type: :legacy)
+      end
+
+      it 'returns views for the children' do
+        expect(subject.size).to eql(1)
+        expect(subject[0].class).to eql(Nanoc::ItemWithRepsView)
+        expect(subject[0].unwrap).to eql(children[0])
+      end
+
+      it { is_expected.to be_frozen }
+    end
+  end
+
+  describe '#reps' do
+    let(:item) { Nanoc::Int::Item.new('blah', {}, '/foo.md') }
+    let(:rep_a) { Nanoc::Int::ItemRep.new(item, :a) }
+    let(:rep_b) { Nanoc::Int::ItemRep.new(item, :b) }
+
+    let(:reps) do
+      Nanoc::Int::ItemRepRepo.new.tap do |reps|
+        reps << rep_a
+        reps << rep_b
+      end
+    end
+
+    let(:view) { described_class.new(item, view_context) }
+
+    subject { view.reps }
+
+    it 'returns a proper item rep collection' do
+      expect(subject.size).to eq(2)
+      expect(subject.class).to eql(Nanoc::ItemRepCollectionView)
+    end
+
+    it 'returns a view with the right context' do
+      expect(subject._context).to eq(view_context)
+    end
+  end
+
+  describe '#compiled_content' do
+    subject { view.compiled_content(params) }
+
+    let(:view) { described_class.new(item, view_context) }
+
+    let(:item) do
+      Nanoc::Int::Item.new('content', {}, '/asdf/')
+    end
+
+    let(:reps) do
+      Nanoc::Int::ItemRepRepo.new.tap do |reps|
+        reps << rep
+      end
+    end
+
+    let(:rep) do
+      Nanoc::Int::ItemRep.new(item, :default).tap do |ir|
+        ir.compiled = true
+        ir.snapshot_defs = [
+          Nanoc::Int::SnapshotDef.new(:last),
+          Nanoc::Int::SnapshotDef.new(:pre),
+          Nanoc::Int::SnapshotDef.new(:post),
+          Nanoc::Int::SnapshotDef.new(:specific),
+        ]
+        ir.snapshot_contents = {
+          last: Nanoc::Int::TextualContent.new('Last Hallo'),
+          pre: Nanoc::Int::TextualContent.new('Pre Hallo'),
+          post: Nanoc::Int::TextualContent.new('Post Hallo'),
+          specific: Nanoc::Int::TextualContent.new('Specific Hallo'),
+        }
+      end
+    end
+
+    context 'requesting implicit default rep' do
+      let(:params) { {} }
+
+      it { is_expected.to eq('Pre Hallo') }
+
+      it 'creates a dependency' do
+        expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item])
+      end
+
+      context 'requesting explicit snapshot' do
+        let(:params) { { snapshot: :specific } }
+
+        it { is_expected.to eq('Specific Hallo') }
+
+        it 'creates a dependency' do
+          expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item])
+        end
+      end
+    end
+
+    context 'requesting explicit default rep' do
+      let(:params) { { rep: :default } }
+
+      it 'creates a dependency' do
+        expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item])
+      end
+
+      it { is_expected.to eq('Pre Hallo') }
+
+      context 'requesting explicit snapshot' do
+        let(:params) { { snapshot: :specific } }
+
+        it { is_expected.to eq('Specific Hallo') }
+      end
+    end
+
+    context 'requesting other rep' do
+      let(:params) { { rep: :other } }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(Nanoc::ItemRepCollectionView::NoSuchItemRepError)
+      end
+    end
+  end
+
+  describe '#path' do
+    subject { view.path(params) }
+
+    let(:view) { described_class.new(item, view_context) }
+
+    let(:item) do
+      Nanoc::Int::Item.new('content', {}, '/asdf.md')
+    end
+
+    let(:reps) do
+      Nanoc::Int::ItemRepRepo.new.tap do |reps|
+        reps << rep
+      end
+    end
+
+    let(:rep) do
+      Nanoc::Int::ItemRep.new(item, :default).tap do |ir|
+        ir.paths = {
+          last: '/about/',
+          specific: '/about.txt',
+        }
+      end
+    end
+
+    context 'requesting implicit default rep' do
+      let(:params) { {} }
+
+      it 'creates a dependency' do
+        expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item])
+      end
+
+      it { is_expected.to eq('/about/') }
+
+      context 'requesting explicit snapshot' do
+        let(:params) { { snapshot: :specific } }
+
+        it { is_expected.to eq('/about.txt') }
+      end
+    end
+
+    context 'requesting explicit default rep' do
+      let(:params) { { rep: :default } }
+
+      it 'creates a dependency' do
+        expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item])
+      end
+
+      it { is_expected.to eq('/about/') }
+
+      context 'requesting explicit snapshot' do
+        let(:params) { { snapshot: :specific } }
+
+        it { is_expected.to eq('/about.txt') }
+      end
+    end
+
+    context 'requesting other rep' do
+      let(:params) { { rep: :other } }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(Nanoc::ItemRepCollectionView::NoSuchItemRepError)
+      end
+    end
+  end
+
+  describe '#binary?' do
+    # TODO: implement
+  end
+
+  describe '#raw_filename' do
+    # TODO: implement
+  end
+
+  describe '#inspect' do
+    let(:item) { Nanoc::Int::Item.new('content', {}, '/asdf/') }
+    let(:view) { described_class.new(item, nil) }
+
+    subject { view.inspect }
+
+    it { is_expected.to eql('<Nanoc::ItemWithRepsView identifier=/asdf/>') }
+  end
+end

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

@@ -0,0 +1,18 @@
+describe Nanoc::LayoutCollectionView do
+  let(:view_class) { Nanoc::LayoutView }
+  it_behaves_like 'an identifiable collection'
+
+  describe '#inspect' do
+    let(:wrapped) do
+      Nanoc::Int::IdentifiableCollection.new(config)
+    end
+
+    let(:view) { described_class.new(wrapped, view_context) }
+    let(:view_context) { double(:view_context) }
+    let(:config) { { string_pattern_type: 'glob' } }
+
+    subject { view.inspect }
+
+    it { is_expected.to eql('<Nanoc::LayoutCollectionView>') }
+  end
+end

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

@@ -0,0 +1,14 @@
+describe Nanoc::LayoutView do
+  let(:entity_class) { Nanoc::Int::Layout }
+  let(:other_view_class) { Nanoc::ItemWithRepsView }
+  it_behaves_like 'a document view'
+
+  describe '#inspect' do
+    let(:item) { Nanoc::Int::Layout.new('content', {}, '/asdf/') }
+    let(:view) { described_class.new(item, nil) }
+
+    subject { view.inspect }
+
+    it { is_expected.to eql('<Nanoc::LayoutView identifier=/asdf/>') }
+  end
+end

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

@@ -0,0 +1,16 @@
+describe Nanoc::MutableConfigView do
+  let(:config) { {} }
+  let(:view) { described_class.new(config, nil) }
+
+  describe '#[]=' do
+    it 'sets attributes' do
+      view[:awesomeness] = 'rather high'
+      expect(config[:awesomeness]).to eq('rather high')
+    end
+  end
+
+  describe '#inspect' do
+    subject { view.inspect }
+    it { is_expected.to eql('<Nanoc::MutableConfigView>') }
+  end
+end

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

@@ -0,0 +1,92 @@
+shared_examples 'a mutable document view' do
+  let(:view) { described_class.new(item, view_context) }
+
+  let(:view_context) do
+    Nanoc::ViewContext.new(
+      reps: double(:reps),
+      items: double(:items),
+      dependency_tracker: dependency_tracker,
+      compilation_context: double(:compilation_context),
+    )
+  end
+
+  let(:dependency_tracker) { Nanoc::Int::DependencyTracker.new(double(:dependency_store)) }
+
+  describe '#[]=' do
+    # FIXME: rename :item to :document
+    let(:item) { 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::ItemWithRepsView.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
+  end
+
+  describe '#identifier=' do
+    let(:item) { 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(:item) { 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
+  end
+end

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

@@ -0,0 +1,36 @@
+shared_examples 'a mutable identifiable collection' do
+  let(:view) { described_class.new(wrapped, view_context) }
+
+  let(:view_context) { double(:view_context) }
+
+  let(:config) do
+    {}
+  end
+
+  describe '#delete_if' do
+    let(:wrapped) do
+      Nanoc::Int::IdentifiableCollection.new(config).tap do |coll|
+        coll << double(:identifiable, identifier: Nanoc::Identifier.new('/asdf/'))
+      end
+    end
+
+    it 'deletes matching' do
+      view.delete_if { |i| i.identifier == '/asdf/' }
+      expect(wrapped).to be_empty
+    end
+
+    it 'deletes no non-matching' do
+      view.delete_if { |i| i.identifier == '/blah/' }
+      expect(wrapped).not_to be_empty
+    end
+
+    it 'returns self' do
+      ret = view.delete_if { |_i| false }
+      expect(ret).to equal(view)
+    end
+
+    it 'yields items with the proper context' do
+      view.delete_if { |i| expect(i._context).to equal(view_context) }
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+describe Nanoc::MutableItemCollectionView do
+  let(:view_class) { Nanoc::MutableItemView }
+  it_behaves_like 'an identifiable collection'
+  it_behaves_like 'a mutable identifiable collection'
+
+  let(:config) do
+    { string_pattern_type: 'glob' }
+  end
+
+  describe '#create' do
+    let(:item) do
+      Nanoc::Int::Layout.new('content', {}, '/asdf/')
+    end
+
+    let(:wrapped) do
+      Nanoc::Int::IdentifiableCollection.new(config).tap do |coll|
+        coll << item
+      end
+    end
+
+    let(:view) { described_class.new(wrapped, nil) }
+
+    it 'creates an object' do
+      view.create('new content', { title: 'New Page' }, '/new/')
+
+      expect(wrapped.size).to eq(2)
+      expect(wrapped['/new/'].content.string).to eq('new content')
+    end
+
+    it 'returns self' do
+      ret = view.create('new content', { title: 'New Page' }, '/new/')
+      expect(ret).to equal(view)
+    end
+  end
+
+  describe '#inspect' do
+    let(:wrapped) do
+      Nanoc::Int::IdentifiableCollection.new(config)
+    end
+
+    let(:view) { described_class.new(wrapped, view_context) }
+    let(:view_context) { double(:view_context) }
+    let(:config) { { string_pattern_type: 'glob' } }
+
+    subject { view.inspect }
+
+    it { is_expected.to eql('<Nanoc::MutableItemCollectionView>') }
+  end
+end

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

@@ -0,0 +1,22 @@
+describe Nanoc::MutableItemView do
+  let(:entity_class) { Nanoc::Int::Item }
+  it_behaves_like 'a mutable document view'
+
+  let(:item) { entity_class.new('content', {}, '/asdf/') }
+  let(:view) { described_class.new(item, nil) }
+
+  it 'does have rep access' do
+    expect(view).not_to respond_to(:compiled_content)
+    expect(view).not_to respond_to(:path)
+    expect(view).not_to respond_to(:reps)
+  end
+
+  describe '#inspect' do
+    let(:item) { Nanoc::Int::Item.new('content', {}, '/asdf/') }
+    let(:view) { described_class.new(item, nil) }
+
+    subject { view.inspect }
+
+    it { is_expected.to eql('<Nanoc::MutableItemView identifier=/asdf/>') }
+  end
+end

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

@@ -0,0 +1,49 @@
+describe Nanoc::MutableLayoutCollectionView do
+  let(:view_class) { Nanoc::MutableLayoutView }
+  it_behaves_like 'an identifiable collection'
+  it_behaves_like 'a mutable identifiable collection'
+
+  let(:config) do
+    { string_pattern_type: 'glob' }
+  end
+
+  describe '#create' do
+    let(:layout) do
+      Nanoc::Int::Layout.new('content', {}, '/asdf/')
+    end
+
+    let(:wrapped) do
+      Nanoc::Int::IdentifiableCollection.new(config).tap do |coll|
+        coll << layout
+      end
+    end
+
+    let(:view) { described_class.new(wrapped, nil) }
+
+    it 'creates an object' do
+      view.create('new content', { title: 'New Page' }, '/new/')
+
+      expect(wrapped.size).to eq(2)
+      expect(wrapped['/new/'].content.string).to eq('new content')
+    end
+
+    it 'returns self' do
+      ret = view.create('new content', { title: 'New Page' }, '/new/')
+      expect(ret).to equal(view)
+    end
+  end
+
+  describe '#inspect' do
+    let(:wrapped) do
+      Nanoc::Int::IdentifiableCollection.new(config)
+    end
+
+    let(:view) { described_class.new(wrapped, view_context) }
+    let(:view_context) { double(:view_context) }
+    let(:config) { { string_pattern_type: 'glob' } }
+
+    subject { view.inspect }
+
+    it { is_expected.to eql('<Nanoc::MutableLayoutCollectionView>') }
+  end
+end

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

@@ -0,0 +1,13 @@
+describe Nanoc::MutableLayoutView do
+  let(:entity_class) { Nanoc::Int::Layout }
+  it_behaves_like 'a mutable document view'
+
+  describe '#inspect' do
+    let(:item) { Nanoc::Int::Item.new('content', {}, '/asdf/') }
+    let(:view) { described_class.new(item, nil) }
+
+    subject { view.inspect }
+
+    it { is_expected.to eql('<Nanoc::MutableLayoutView identifier=/asdf/>') }
+  end
+end

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

@@ -0,0 +1,4 @@
+describe Nanoc::PostCompileItemRepCollectionView do
+  it_behaves_like 'an item rep collection view'
+  let(:expected_view_class) { Nanoc::PostCompileItemRepView }
+end