nanoc 4.4.5 → 4.4.6

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

@@ -0,0 +1,96 @@
+describe Nanoc::ConfigView do
+  let(:config) do
+    Nanoc::Int::Configuration.new(hash: hash)
+  end
+
+  let(:hash) { { amount: 9000, animal: 'donkey' } }
+
+  let(:view) { described_class.new(config, nil) }
+
+  describe '#frozen?' do
+    subject { view.frozen? }
+
+    context 'non-frozen config' do
+      it { is_expected.to be(false) }
+    end
+
+    context 'frozen config' do
+      before { config.freeze }
+      it { is_expected.to be(true) }
+    end
+  end
+
+  describe '#[]' do
+    subject { view[key] }
+
+    context 'with existant key' do
+      let(:key) { :animal }
+      it { is_expected.to eql('donkey') }
+    end
+
+    context 'with non-existant key' do
+      let(:key) { :weapon }
+      it { is_expected.to eql(nil) }
+    end
+  end
+
+  describe '#fetch' do
+    context 'with existant key' do
+      let(:key) { :animal }
+
+      subject { view.fetch(key) }
+
+      it { is_expected.to eql('donkey') }
+    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') }
+      end
+
+      context 'with block' do
+        subject { view.fetch(key) { 'nothing sorry' } }
+        it { is_expected.to eql('nothing sorry') }
+      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
+    subject { view.key?(key) }
+
+    context 'with existant key' do
+      let(:key) { :animal }
+      it { is_expected.to eql(true) }
+    end
+
+    context 'with non-existant key' do
+      let(:key) { :weapon }
+      it { is_expected.to eql(false) }
+    end
+  end
+
+  describe '#each' do
+    example do
+      res = []
+      view.each { |k, v| res << [k, v] }
+
+      expect(res).to eql([[:amount, 9000], [:animal, 'donkey']])
+    end
+  end
+
+  describe '#inspect' do
+    subject { view.inspect }
+    it { is_expected.to eql('<Nanoc::ConfigView>') }
+  end
+end

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

@@ -0,0 +1,332 @@
+shared_examples 'a document view' do
+  let(:view) { described_class.new(document, 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(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(: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/identifiable_collection_view_spec.rb

@@ -0,0 +1,190 @@
+# Needs :view_class
+shared_examples 'an identifiable collection' do
+  let(:view) { described_class.new(wrapped, view_context) }
+
+  let(:view_context) { double(:view_context) }
+
+  let(:config) do
+    { string_pattern_type: 'glob' }
+  end
+
+  describe '#frozen?' do
+    let(:wrapped) do
+      Nanoc::Int::IdentifiableCollection.new(config).tap do |arr|
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/foo'))
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/bar'))
+      end
+    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
+      Nanoc::Int::IdentifiableCollection.new(config).tap do |arr|
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/foo'))
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/bar'))
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/baz'))
+      end
+    end
+
+    subject { view.unwrap }
+
+    it { should equal(wrapped) }
+  end
+
+  describe '#each' do
+    let(:wrapped) do
+      Nanoc::Int::IdentifiableCollection.new(config).tap do |arr|
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/foo'))
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/bar'))
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/baz'))
+      end
+    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
+      Nanoc::Int::IdentifiableCollection.new(config).tap do |arr|
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/foo'))
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/bar'))
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/baz'))
+      end
+    end
+
+    subject { view.size }
+
+    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
+      Nanoc::Int::IdentifiableCollection.new(config).tap do |arr|
+        arr << page_object
+        arr << home_object
+      end
+    end
+
+    subject { view[arg] }
+
+    context 'no objects found' do
+      let(:arg) { '/donkey.*' }
+      it { is_expected.to equal(nil) }
+    end
+
+    context 'string' do
+      let(:arg) { '/home.erb' }
+
+      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 '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 'returns nil' do
+          expect(subject).to be_nil
+        end
+      end
+
+      context 'globs enabled' do
+        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 '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
+      Nanoc::Int::IdentifiableCollection.new(config).tap do |arr|
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/about.css'))
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/about.md'))
+        arr << double(:identifiable, identifier: Nanoc::Identifier.new('/style.css'))
+      end
+    end
+
+    subject { view.find_all(arg) }
+
+    context 'with string' do
+      let(:arg) { '/*.css' }
+
+      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 '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

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

@@ -0,0 +1,18 @@
+describe Nanoc::ItemCollectionWithRepsView do
+  let(:view_class) { Nanoc::ItemWithRepsView }
+  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::ItemCollectionWithRepsView>') }
+  end
+end

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

@@ -0,0 +1,18 @@
+describe Nanoc::ItemCollectionWithoutRepsView do
+  let(:view_class) { Nanoc::ItemWithoutRepsView }
+  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::ItemCollectionWithoutRepsView>') }
+  end
+end