nanoc 4.8.12 → 4.8.13

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

@@ -1,340 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples 'a 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:       double(:snapshot_repo),
-    )
-  end
-
-  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(:document) { entity_class.new('content', {}, '/asdf') }
-
-    subject { view.frozen? }
-
-    context 'non-frozen document' do
-      it { is_expected.to be(false) }
-    end
-
-    context 'frozen document' do
-      before { document.freeze }
-      it { is_expected.to be(true) }
-    end
-  end
-
-  describe '#== and #eql?' do
-    let(:document) { entity_class.new('content', {}, '/asdf') }
-
-    context 'comparing with document with same identifier' do
-      let(:other) { entity_class.new('content', {}, '/asdf') }
-
-      it 'is ==' do
-        expect(view).to eq(other)
-      end
-
-      it 'is not eql?' do
-        expect(view).not_to eql(other)
-      end
-    end
-
-    context 'comparing with document with different identifier' do
-      let(:other) { entity_class.new('content', {}, '/fdsa') }
-
-      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 document view with same identifier' do
-      let(:other) { other_view_class.new(entity_class.new('content', {}, '/asdf'), nil) }
-
-      it 'is ==' do
-        expect(view).to eq(other)
-      end
-
-      it 'is not eql?' do
-        expect(view).not_to eql(other)
-      end
-    end
-
-    context 'comparing with document view with different identifier' do
-      let(:other) { other_view_class.new(entity_class.new('content', {}, '/fdsa'), nil) }
-
-      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 other object' do
-      let(:other) { nil }
-
-      it 'is not ==' do
-        expect(view).not_to eq(other)
-      end
-
-      it 'is not eql?' do
-        expect(view).not_to eql(other)
-      end
-    end
-  end
-
-  describe '#[]' do
-    let(:document) { entity_class.new('stuff', { animal: 'donkey' }, '/foo') }
-
-    subject { view[key] }
-
-    context 'with existant key' do
-      let(:key) { :animal }
-
-      it { is_expected.to eql('donkey') }
-
-      it 'creates a dependency' do
-        expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document])
-      end
-
-      it 'creates a dependency with the right props' do
-        subject
-        dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0]
-
-        expect(dep.props.attributes?).to eq(true)
-
-        expect(dep.props.raw_content?).to eq(false)
-        expect(dep.props.compiled_content?).to eq(false)
-        expect(dep.props.path?).to eq(false)
-      end
-    end
-
-    context 'with non-existant key' do
-      let(:key) { :weapon }
-
-      it { is_expected.to eql(nil) }
-
-      it 'creates a dependency' do
-        expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document])
-      end
-
-      it 'creates a dependency with the right props' do
-        subject
-        dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0]
-
-        expect(dep.props.attributes?).to eq(true)
-
-        expect(dep.props.raw_content?).to eq(false)
-        expect(dep.props.compiled_content?).to eq(false)
-        expect(dep.props.path?).to eq(false)
-      end
-    end
-  end
-
-  describe '#attributes' do
-    let(:document) { entity_class.new('stuff', { animal: 'donkey' }, '/foo') }
-
-    subject { view.attributes }
-
-    it 'creates a dependency' do
-      expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document])
-    end
-
-    it 'creates a dependency with the right props' do
-      subject
-      dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0]
-
-      expect(dep.props.attributes?).to eq(true)
-
-      expect(dep.props.raw_content?).to eq(false)
-      expect(dep.props.compiled_content?).to eq(false)
-      expect(dep.props.path?).to eq(false)
-    end
-
-    it 'returns attributes' do
-      expect(subject).to eql(animal: 'donkey')
-    end
-  end
-
-  describe '#fetch' do
-    let(:document) { entity_class.new('stuff', { animal: 'donkey' }, '/foo') }
-
-    context 'with existant key' do
-      let(:key) { :animal }
-
-      subject { view.fetch(key) }
-
-      it { is_expected.to eql('donkey') }
-
-      it 'creates a dependency' do
-        expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document])
-      end
-
-      it 'creates a dependency with the right props' do
-        subject
-        dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0]
-
-        expect(dep.props.attributes?).to eq(true)
-
-        expect(dep.props.raw_content?).to eq(false)
-        expect(dep.props.compiled_content?).to eq(false)
-        expect(dep.props.path?).to eq(false)
-      end
-    end
-
-    context 'with non-existant key' do
-      let(:key) { :weapon }
-
-      context 'with fallback' do
-        subject { view.fetch(key, 'nothing sorry') }
-
-        it { is_expected.to eql('nothing sorry') }
-
-        it 'creates a dependency' do
-          expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document])
-        end
-
-        it 'creates a dependency with the right props' do
-          subject
-          dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0]
-
-          expect(dep.props.attributes?).to eq(true)
-
-          expect(dep.props.raw_content?).to eq(false)
-          expect(dep.props.compiled_content?).to eq(false)
-          expect(dep.props.path?).to eq(false)
-        end
-      end
-
-      context 'with block' do
-        subject { view.fetch(key) { 'nothing sorry' } }
-
-        it { is_expected.to eql('nothing sorry') }
-
-        it 'creates a dependency' do
-          expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document])
-        end
-
-        it 'creates a dependency with the right props' do
-          subject
-          dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0]
-
-          expect(dep.props.attributes?).to eq(true)
-
-          expect(dep.props.raw_content?).to eq(false)
-          expect(dep.props.compiled_content?).to eq(false)
-          expect(dep.props.path?).to eq(false)
-        end
-      end
-
-      context 'with no fallback and no block' do
-        subject { view.fetch(key) }
-
-        it 'raises' do
-          expect { subject }.to raise_error(KeyError)
-        end
-      end
-    end
-  end
-
-  describe '#key?' do
-    let(:document) { entity_class.new('stuff', { animal: 'donkey' }, '/foo') }
-
-    subject { view.key?(key) }
-
-    context 'with existant key' do
-      let(:key) { :animal }
-
-      it { is_expected.to eql(true) }
-
-      it 'creates a dependency' do
-        expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document])
-      end
-
-      it 'creates a dependency with the right props' do
-        subject
-        dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0]
-
-        expect(dep.props.attributes?).to eq(true)
-
-        expect(dep.props.raw_content?).to eq(false)
-        expect(dep.props.compiled_content?).to eq(false)
-        expect(dep.props.path?).to eq(false)
-      end
-    end
-
-    context 'with non-existant key' do
-      let(:key) { :weapon }
-
-      it { is_expected.to eql(false) }
-
-      it 'creates a dependency' do
-        expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document])
-      end
-
-      it 'creates a dependency with the right props' do
-        subject
-        dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0]
-
-        expect(dep.props.attributes?).to eq(true)
-
-        expect(dep.props.raw_content?).to eq(false)
-        expect(dep.props.compiled_content?).to eq(false)
-        expect(dep.props.path?).to eq(false)
-      end
-    end
-  end
-
-  describe '#hash' do
-    let(:document) { double(:document, identifier: '/foo') }
-
-    subject { view.hash }
-
-    it { should == described_class.hash ^ '/foo'.hash }
-  end
-
-  describe '#raw_content' do
-    let(:document) { entity_class.new('stuff', { animal: 'donkey' }, '/foo') }
-
-    subject { view.raw_content }
-
-    it { is_expected.to eql('stuff') }
-
-    it 'creates a dependency' do
-      expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document])
-    end
-
-    it 'creates a dependency with the right props' do
-      subject
-      dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0]
-
-      expect(dep.props.raw_content?).to eq(true)
-
-      expect(dep.props.attributes?).to eq(false)
-      expect(dep.props.compiled_content?).to eq(false)
-      expect(dep.props.path?).to eq(false)
-    end
-  end
-end

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

@@ -1,277 +0,0 @@
-# frozen_string_literal: true
-
-# Needs :view_class
-shared_examples 'an identifiable collection view' do
-  let(:view) { described_class.new(wrapped, 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:       double(:__snapshot_repo),
-    )
-  end
-
-  let(:dependency_tracker) do
-    Nanoc::Int::DependencyTracker::Null.new
-  end
-
-  let(:config) do
-    { string_pattern_type: 'glob' }
-  end
-
-  describe '#frozen?' do
-    let(:wrapped) do
-      collection_class.new(
-        config,
-        [
-          double(:identifiable, identifier: Nanoc::Identifier.new('/foo')),
-          double(:identifiable, identifier: Nanoc::Identifier.new('/bar')),
-        ],
-      )
-    end
-
-    subject { view.frozen? }
-
-    context 'non-frozen collection' do
-      it { is_expected.to be(false) }
-    end
-
-    context 'frozen collection' do
-      before do
-        wrapped.each { |o| expect(o).to receive(:freeze) }
-        wrapped.freeze
-      end
-
-      it { is_expected.to be(true) }
-    end
-  end
-
-  describe '#unwrap' do
-    let(:wrapped) do
-      collection_class.new(
-        config,
-        [
-          double(:identifiable, identifier: Nanoc::Identifier.new('/foo')),
-          double(:identifiable, identifier: Nanoc::Identifier.new('/bar')),
-          double(:identifiable, identifier: Nanoc::Identifier.new('/baz')),
-        ],
-      )
-    end
-
-    subject { view.unwrap }
-
-    it { should equal(wrapped) }
-
-    it 'does not create dependency' do
-      expect(dependency_tracker).not_to receive(:bounce)
-      subject
-    end
-  end
-
-  describe '#each' do
-    let(:wrapped) do
-      collection_class.new(
-        config,
-        [
-          double(:identifiable, identifier: Nanoc::Identifier.new('/foo')),
-          double(:identifiable, identifier: Nanoc::Identifier.new('/bar')),
-          double(:identifiable, identifier: Nanoc::Identifier.new('/baz')),
-        ],
-      )
-    end
-
-    it 'creates dependency' do
-      expect(dependency_tracker).to receive(:bounce).with(wrapped, raw_content: true)
-      view.each { |_i| }
-    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
-    let(:wrapped) do
-      collection_class.new(
-        config,
-        [
-          double(:identifiable, identifier: Nanoc::Identifier.new('/foo')),
-          double(:identifiable, identifier: Nanoc::Identifier.new('/bar')),
-          double(:identifiable, identifier: Nanoc::Identifier.new('/baz')),
-        ],
-      )
-    end
-
-    subject { view.size }
-
-    it 'creates dependency' do
-      expect(dependency_tracker).to receive(:bounce).with(wrapped, raw_content: true)
-      subject
-    end
-
-    it { should == 3 }
-  end
-
-  describe '#[]' do
-    let(:page_object) do
-      double(:identifiable, identifier: Nanoc::Identifier.new('/page.erb'))
-    end
-
-    let(:home_object) do
-      double(:identifiable, identifier: Nanoc::Identifier.new('/home.erb'))
-    end
-
-    let(:wrapped) do
-      collection_class.new(
-        config,
-        [
-          page_object,
-          home_object,
-        ],
-      )
-    end
-
-    subject { view[arg] }
-
-    context 'no objects found' do
-      let(:arg) { '/donkey.*' }
-      it { is_expected.to equal(nil) }
-
-      it 'creates dependency' do
-        expect(dependency_tracker).to receive(:bounce).with(wrapped, raw_content: ['/donkey.*'])
-        subject
-      end
-    end
-
-    context 'string' do
-      let(:arg) { '/home.erb' }
-
-      it 'creates dependency' do
-        expect(dependency_tracker).to receive(:bounce).with(wrapped, raw_content: ['/home.erb'])
-        subject
-      end
-
-      it 'returns wrapped object' do
-        expect(subject.class).to equal(view_class)
-        expect(subject.unwrap).to equal(home_object)
-      end
-
-      it 'returns objects with right context' do
-        expect(subject._context).to equal(view_context)
-      end
-    end
-
-    context 'identifier' do
-      let(:arg) { Nanoc::Identifier.new('/home.erb') }
-
-      it 'creates dependency' do
-        expect(dependency_tracker).to receive(:bounce).with(wrapped, raw_content: ['/home.erb'])
-        subject
-      end
-
-      it 'returns wrapped object' do
-        expect(subject.class).to equal(view_class)
-        expect(subject.unwrap).to equal(home_object)
-      end
-    end
-
-    context 'glob' do
-      let(:arg) { '/home.*' }
-
-      context 'globs not enabled' do
-        let(:config) { { string_pattern_type: 'legacy' } }
-
-        it 'creates dependency' do
-          expect(dependency_tracker).to receive(:bounce).with(wrapped, raw_content: ['/home.*'])
-          subject
-        end
-
-        it 'returns nil' do
-          expect(subject).to be_nil
-        end
-      end
-
-      context 'globs enabled' do
-        it 'creates dependency' do
-          expect(dependency_tracker).to receive(:bounce).with(wrapped, raw_content: ['/home.*'])
-          subject
-        end
-
-        it 'returns wrapped object' do
-          expect(subject.class).to equal(view_class)
-          expect(subject.unwrap).to equal(home_object)
-        end
-      end
-    end
-
-    context 'regex' do
-      let(:arg) { %r{\A/home} }
-
-      it 'creates dependency' do
-        expect(dependency_tracker).to receive(:bounce).with(wrapped, raw_content: [%r{\A/home}])
-        subject
-      end
-
-      it 'returns wrapped object' do
-        expect(subject.class).to equal(view_class)
-        expect(subject.unwrap).to equal(home_object)
-      end
-    end
-  end
-
-  describe '#find_all' do
-    let(:wrapped) do
-      collection_class.new(
-        config,
-        [
-          double(:identifiable, identifier: Nanoc::Identifier.new('/about.css')),
-          double(:identifiable, identifier: Nanoc::Identifier.new('/about.md')),
-          double(:identifiable, identifier: Nanoc::Identifier.new('/style.css')),
-        ],
-      )
-    end
-
-    subject { view.find_all(arg) }
-
-    context 'with string' do
-      let(:arg) { '/*.css' }
-
-      it 'creates dependency' do
-        expect(dependency_tracker).to receive(:bounce).with(wrapped, raw_content: ['/*.css'])
-        subject
-      end
-
-      it 'contains views' do
-        expect(subject.size).to eql(2)
-        about_css = subject.find { |iv| iv.identifier == '/about.css' }
-        style_css = subject.find { |iv| iv.identifier == '/style.css' }
-        expect(about_css.class).to equal(view_class)
-        expect(style_css.class).to equal(view_class)
-      end
-    end
-
-    context 'with regex' do
-      let(:arg) { %r{\.css\z} }
-
-      it 'creates dependency' do
-        expect(dependency_tracker).to receive(:bounce).with(wrapped, raw_content: [%r{\.css\z}])
-        subject
-      end
-
-      it 'contains views' do
-        expect(subject.size).to eql(2)
-        about_css = subject.find { |iv| iv.identifier == '/about.css' }
-        style_css = subject.find { |iv| iv.identifier == '/style.css' }
-        expect(about_css.class).to equal(view_class)
-        expect(style_css.class).to equal(view_class)
-      end
-    end
-  end
-end