nanoc 4.8.12 → 4.8.13

data/spec/nanoc/base/repos/data_source_spec.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::DataSource, stdio: true do
-  subject(:data_source) do
-    described_class.new({}, nil, nil, {})
-  end
-
-  it 'has an empty #up implementation' do
-    data_source.up
-  end
-
-  it 'has an empty #down implementation' do
-    data_source.down
-  end
-
-  it 'returns empty #items' do
-    expect(data_source.items).to be_empty
-  end
-
-  it 'returns empty #layouts' do
-    expect(data_source.layouts).to be_empty
-  end
-
-  describe '#new_item' do
-    it 'supports checksum data' do
-      item = data_source.new_item('stuff', { title: 'Stuff!' }, '/asdf', checksum_data: 'abcdef')
-
-      expect(item.content.string).to eql('stuff')
-      expect(item.attributes[:title]).to eql('Stuff!')
-      expect(item.identifier).to eql(Nanoc::Identifier.new('/asdf'))
-      expect(item.checksum_data).to eql('abcdef')
-    end
-
-    it 'supports content/attributes checksum data' do
-      item = data_source.new_item('stuff', { title: 'Stuff!' }, '/asdf', content_checksum_data: 'con-cs', attributes_checksum_data: 'attr-cs')
-
-      expect(item.content.string).to eql('stuff')
-      expect(item.attributes[:title]).to eql('Stuff!')
-      expect(item.identifier).to eql(Nanoc::Identifier.new('/asdf'))
-      expect(item.content_checksum_data).to eql('con-cs')
-      expect(item.attributes_checksum_data).to eql('attr-cs')
-    end
-  end
-
-  describe '#new_layout' do
-    it 'supports checksum data' do
-      layout = data_source.new_layout('stuff', { title: 'Stuff!' }, '/asdf', checksum_data: 'abcdef')
-
-      expect(layout.content.string).to eql('stuff')
-      expect(layout.attributes[:title]).to eql('Stuff!')
-      expect(layout.identifier).to eql(Nanoc::Identifier.new('/asdf'))
-      expect(layout.checksum_data).to eql('abcdef')
-    end
-
-    it 'supports content/attributes checksum data' do
-      layout = data_source.new_layout('stuff', { title: 'Stuff!' }, '/asdf', content_checksum_data: 'con-cs', attributes_checksum_data: 'attr-cs')
-
-      expect(layout.content.string).to eql('stuff')
-      expect(layout.attributes[:title]).to eql('Stuff!')
-      expect(layout.identifier).to eql(Nanoc::Identifier.new('/asdf'))
-      expect(layout.content_checksum_data).to eql('con-cs')
-      expect(layout.attributes_checksum_data).to eql('attr-cs')
-    end
-  end
-
-  describe '#item_changes' do
-    subject { data_source.item_changes }
-
-    it 'warns' do
-      expect { subject }.to output("Caution: Data source nil does not implement #item_changes; live compilation will not pick up changes in this data source.\n").to_stderr
-    end
-
-    it 'never yields anything' do
-      q = SizedQueue.new(1)
-      Thread.new { subject.each { |c| q << c } }
-      sleep 0.1
-      expect { q.pop(true) }.to raise_error(ThreadError)
-    end
-  end
-
-  describe '#layout_changes' do
-    subject { data_source.layout_changes }
-
-    it 'warns' do
-      expect { subject }.to output("Caution: Data source nil does not implement #layout_changes; live compilation will not pick up changes in this data source.\n").to_stderr
-    end
-
-    it 'never yields anything' do
-      q = SizedQueue.new(1)
-      Thread.new { subject.each { |c| q << c } }
-      sleep 0.1
-      expect { q.pop(true) }.to raise_error(ThreadError)
-    end
-  end
-end

data/spec/nanoc/base/repos/dependency_store_spec.rb

@@ -1,515 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::DependencyStore do
-  let(:store) { described_class.new(items, layouts, config) }
-
-  let(:item_a) { Nanoc::Int::Item.new('a', {}, '/a.md') }
-  let(:item_b) { Nanoc::Int::Item.new('b', {}, '/b.md') }
-  let(:item_c) { Nanoc::Int::Item.new('c', {}, '/c.md') }
-
-  let(:layout_a) { Nanoc::Int::Layout.new('la', {}, '/la.md') }
-  let(:layout_b) { Nanoc::Int::Layout.new('lb', {}, '/lb.md') }
-
-  let(:items) { Nanoc::Int::ItemCollection.new(config, [item_a, item_b, item_c]) }
-  let(:layouts) { Nanoc::Int::LayoutCollection.new(config, [layout_a, layout_b]) }
-  let(:config) { Nanoc::Int::Configuration.new }
-
-  it 'is empty by default' do
-    expect(store.objects_causing_outdatedness_of(item_a)).to be_empty
-    expect(store.objects_causing_outdatedness_of(item_b)).to be_empty
-    expect(store.objects_causing_outdatedness_of(item_c)).to be_empty
-    expect(store.objects_causing_outdatedness_of(layout_a)).to be_empty
-    expect(store.objects_causing_outdatedness_of(layout_b)).to be_empty
-  end
-
-  describe '#dependencies_causing_outdatedness_of' do
-    context 'no dependencies' do
-      it 'returns nothing for each' do
-        expect(store.dependencies_causing_outdatedness_of(item_a)).to be_empty
-        expect(store.dependencies_causing_outdatedness_of(item_b)).to be_empty
-        expect(store.dependencies_causing_outdatedness_of(item_c)).to be_empty
-      end
-    end
-
-    context 'one dependency' do
-      context 'dependency on config, no props' do
-        before do
-          store.record_dependency(item_a, config)
-        end
-
-        it 'returns one dependency' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps.size).to eql(1)
-        end
-
-        it 'returns dependency from a onto config' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps[0].from).to eql(config)
-          expect(deps[0].to).to eql(item_a)
-        end
-
-        it 'returns true for all props by default' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps[0].props.raw_content?).to eq(true)
-          expect(deps[0].props.attributes?).to eq(true)
-          expect(deps[0].props.compiled_content?).to eq(true)
-          expect(deps[0].props.path?).to eq(true)
-        end
-
-        it 'returns nothing for the others' do
-          expect(store.dependencies_causing_outdatedness_of(item_b)).to be_empty
-          expect(store.dependencies_causing_outdatedness_of(item_c)).to be_empty
-        end
-      end
-
-      context 'dependency on config, generic attributes prop' do
-        before do
-          store.record_dependency(item_a, config, attributes: true)
-        end
-
-        it 'returns false for all unspecified props' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps[0].props.raw_content?).to eq(false)
-          expect(deps[0].props.compiled_content?).to eq(false)
-          expect(deps[0].props.path?).to eq(false)
-        end
-
-        it 'returns the specified props' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps[0].props.attributes?).to eq(true)
-        end
-      end
-
-      context 'dependency on config, specific attributes prop' do
-        before do
-          store.record_dependency(item_a, config, attributes: [:donkey])
-        end
-
-        it 'returns false for all unspecified props' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps[0].props.raw_content?).to eq(false)
-          expect(deps[0].props.compiled_content?).to eq(false)
-          expect(deps[0].props.path?).to eq(false)
-        end
-
-        it 'returns the specified props' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps[0].props.attributes?).to eq(true)
-          expect(deps[0].props.attributes).to contain_exactly(:donkey)
-        end
-      end
-
-      context 'dependency on items, generic prop' do
-        before do
-          store.record_dependency(item_a, items)
-        end
-
-        it 'creates one dependency' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps.size).to eql(1)
-        end
-
-        it 'returns true for all props' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps[0].props.raw_content?).to be
-          expect(deps[0].props.compiled_content?).to be
-          expect(deps[0].props.path?).to be
-          expect(deps[0].props.attributes?).to be
-        end
-      end
-
-      context 'no props' do
-        before do
-          store.record_dependency(item_a, item_b)
-        end
-
-        it 'returns one dependency' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps.size).to eql(1)
-        end
-
-        it 'returns dependency from b to a' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps[0].from).to eql(item_b)
-          expect(deps[0].to).to eql(item_a)
-        end
-
-        it 'returns true for all props by default' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps[0].props.raw_content?).to eq(true)
-          expect(deps[0].props.attributes?).to eq(true)
-          expect(deps[0].props.compiled_content?).to eq(true)
-          expect(deps[0].props.path?).to eq(true)
-        end
-
-        it 'returns nothing for the others' do
-          expect(store.dependencies_causing_outdatedness_of(item_b)).to be_empty
-          expect(store.dependencies_causing_outdatedness_of(item_c)).to be_empty
-        end
-      end
-
-      context 'one prop' do
-        before do
-          store.record_dependency(item_a, item_b, compiled_content: true)
-        end
-
-        it 'returns false for all unspecified props' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps[0].props.raw_content?).to eq(false)
-          expect(deps[0].props.attributes?).to eq(false)
-          expect(deps[0].props.path?).to eq(false)
-        end
-
-        it 'returns the specified props' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps[0].props.compiled_content?).to eq(true)
-        end
-      end
-
-      context 'two props' do
-        before do
-          store.record_dependency(item_a, item_b, compiled_content: true)
-          store.record_dependency(item_a, item_b, attributes: true)
-        end
-
-        it 'returns false for all unspecified props' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps[0].props.raw_content?).to eq(false)
-          expect(deps[0].props.path?).to eq(false)
-        end
-
-        it 'returns the specified props' do
-          deps = store.dependencies_causing_outdatedness_of(item_a)
-          expect(deps[0].props.attributes?).to eq(true)
-          expect(deps[0].props.compiled_content?).to eq(true)
-        end
-      end
-    end
-
-    context 'two dependency in a chain' do
-      before do
-        store.record_dependency(item_a, item_b)
-        store.record_dependency(item_b, item_c)
-      end
-
-      it 'returns one dependency for object A' do
-        deps = store.dependencies_causing_outdatedness_of(item_a)
-        expect(deps.size).to eql(1)
-        expect(deps[0].from).to eql(item_b)
-      end
-
-      it 'returns one dependency for object B' do
-        deps = store.dependencies_causing_outdatedness_of(item_b)
-        expect(deps.size).to eql(1)
-        expect(deps[0].from).to eql(item_c)
-      end
-
-      it 'returns nothing for the others' do
-        expect(store.dependencies_causing_outdatedness_of(item_c)).to be_empty
-      end
-    end
-  end
-
-  describe 'reloading - item a -> b' do
-    before do
-      store.record_dependency(item_a, item_b, compiled_content: true)
-      store.record_dependency(item_a, item_b, attributes: true)
-
-      store.store
-    end
-
-    let(:reloaded_store) do
-      described_class.new(items_after, layouts, config).tap(&:load)
-    end
-
-    context 'no new items' do
-      let(:items_after) { items }
-
-      it 'has the right dependencies for item A' do
-        deps = reloaded_store.dependencies_causing_outdatedness_of(item_a)
-        expect(deps.size).to eql(1)
-
-        expect(deps[0].from).to eql(item_b)
-        expect(deps[0].to).to eql(item_a)
-
-        expect(deps[0].props.raw_content?).to eq(false)
-        expect(deps[0].props.attributes?).to eq(true)
-        expect(deps[0].props.compiled_content?).to eq(true)
-        expect(deps[0].props.path?).to eq(false)
-      end
-
-      it 'has the right dependencies for item B' do
-        deps = reloaded_store.dependencies_causing_outdatedness_of(item_b)
-        expect(deps).to be_empty
-      end
-
-      it 'has the right dependencies for item C' do
-        deps = reloaded_store.dependencies_causing_outdatedness_of(item_c)
-        expect(deps).to be_empty
-      end
-    end
-
-    context 'one new item' do
-      let(:items_after) do
-        Nanoc::Int::ItemCollection.new(config, [item_a, item_b, item_c, item_d])
-      end
-
-      let(:item_d) { Nanoc::Int::Item.new('d', {}, '/d.md') }
-
-      it 'does not mark items as outdated' do
-        expect(reloaded_store.objects_causing_outdatedness_of(item_a)).not_to include(item_d)
-        expect(reloaded_store.objects_causing_outdatedness_of(item_b)).not_to include(item_d)
-        expect(reloaded_store.objects_causing_outdatedness_of(item_c)).not_to include(item_d)
-        expect(reloaded_store.objects_causing_outdatedness_of(item_d)).not_to include(item_d)
-      end
-    end
-
-    context 'unrelated item removed' do
-      let(:items_after) do
-        Nanoc::Int::ItemCollection.new(config, [item_a, item_b])
-      end
-
-      it 'does not mark items as outdated' do
-        expect(reloaded_store.objects_causing_outdatedness_of(item_a)).to eq([item_b])
-        expect(reloaded_store.objects_causing_outdatedness_of(item_b)).to be_empty
-        expect(reloaded_store.objects_causing_outdatedness_of(item_c)).to be_empty
-      end
-    end
-
-    context 'related item removed' do
-      let(:items_after) do
-        Nanoc::Int::ItemCollection.new(config, [item_a, item_c])
-      end
-
-      it 'does not mark items as outdated' do
-        expect(reloaded_store.objects_causing_outdatedness_of(item_a)).to eq([nil])
-        expect(reloaded_store.objects_causing_outdatedness_of(item_b)).to be_empty
-        expect(reloaded_store.objects_causing_outdatedness_of(item_c)).to be_empty
-      end
-    end
-  end
-
-  describe 'reloading - item a -> config' do
-    before do
-      store.record_dependency(item_a, config, attributes: [:donkey])
-
-      store.store
-      store.load
-    end
-
-    it 'has the right dependencies for item A' do
-      deps = store.dependencies_causing_outdatedness_of(item_a)
-      expect(deps.size).to eql(1)
-
-      expect(deps[0].from).to eql(config)
-      expect(deps[0].to).to eql(item_a)
-
-      expect(deps[0].props.raw_content?).to eq(false)
-      expect(deps[0].props.attributes?).to eq(true)
-      expect(deps[0].props.attributes).to contain_exactly(:donkey)
-      expect(deps[0].props.compiled_content?).to eq(false)
-      expect(deps[0].props.path?).to eq(false)
-    end
-
-    it 'has the right dependencies for item B' do
-      deps = store.dependencies_causing_outdatedness_of(item_b)
-      expect(deps).to be_empty
-    end
-
-    it 'has the right dependencies for item C' do
-      deps = store.dependencies_causing_outdatedness_of(item_c)
-      expect(deps).to be_empty
-    end
-  end
-
-  shared_examples 'records dependencies' do
-    context 'no props' do
-      subject { store.record_dependency(source_obj, item_b) }
-
-      it 'records a dependency' do
-        expect { subject }
-          .to change { store.objects_causing_outdatedness_of(source_obj) }
-          .from([])
-          .to([item_b])
-      end
-
-      it 'ignores all other objects' do
-        subject
-        expect(other_items).to all(satisfy { |o| store.dependencies_causing_outdatedness_of(o).empty? })
-      end
-
-      context 'dependency on self' do
-        subject { store.record_dependency(source_obj, item_a) }
-
-        it 'does not create dependency on self' do
-          expect { subject }
-            .not_to change { store.objects_causing_outdatedness_of(source_obj) }
-        end
-      end
-
-      context 'two dependencies' do
-        subject do
-          store.record_dependency(source_obj, item_b)
-          store.record_dependency(source_obj, item_b)
-        end
-
-        it 'does not create duplicate dependencies' do
-          expect { subject }
-            .to change { store.objects_causing_outdatedness_of(source_obj) }
-            .from([])
-            .to([item_b])
-        end
-      end
-
-      context 'dependency to nil' do
-        subject { store.record_dependency(source_obj, nil) }
-
-        it 'creates a dependency to nil' do
-          expect { subject }
-            .to change { store.objects_causing_outdatedness_of(source_obj) }
-            .from([])
-            .to([nil])
-        end
-      end
-
-      context 'dependency from nil' do
-        subject { store.record_dependency(nil, item_b) }
-
-        it 'does not create a dependency from nil' do
-          expect { subject }
-            .not_to change { store.objects_causing_outdatedness_of(item_b) }
-        end
-      end
-    end
-
-    context 'compiled content prop' do
-      subject { store.record_dependency(source_obj, target_obj, compiled_content: true) }
-
-      it 'records a dependency' do
-        expect { subject }
-          .to change { store.objects_causing_outdatedness_of(source_obj) }
-          .from([])
-          .to([target_obj])
-      end
-
-      it 'records a dependency with the right props' do
-        subject
-        deps = store.dependencies_causing_outdatedness_of(source_obj)
-
-        expect(deps.first.props.attributes?).not_to be
-        expect(deps.first.props.compiled_content?).to be
-      end
-
-      it 'ignores all other objects' do
-        subject
-        expect(other_items).to all(satisfy { |o| store.dependencies_causing_outdatedness_of(o).empty? })
-      end
-    end
-
-    context 'attribute prop (true)' do
-      subject { store.record_dependency(source_obj, target_obj, attributes: true) }
-
-      it 'records a dependency' do
-        expect { subject }
-          .to change { store.objects_causing_outdatedness_of(source_obj) }
-          .from([])
-          .to([target_obj])
-      end
-
-      it 'records a dependency with the right props' do
-        subject
-        deps = store.dependencies_causing_outdatedness_of(source_obj)
-
-        expect(deps.first.props.attributes?).to be
-        expect(deps.first.props.attributes).to be
-        expect(deps.first.props.compiled_content?).not_to be
-      end
-
-      it 'ignores all other objects' do
-        subject
-        expect(other_items).to all(satisfy { |o| store.dependencies_causing_outdatedness_of(o).empty? })
-      end
-    end
-
-    context 'attribute prop (true)' do
-      subject { store.record_dependency(source_obj, target_obj, attributes: [:giraffe]) }
-
-      it 'records a dependency' do
-        expect { subject }
-          .to change { store.objects_causing_outdatedness_of(source_obj) }
-          .from([])
-          .to([target_obj])
-      end
-
-      it 'records a dependency with the right props' do
-        subject
-        deps = store.dependencies_causing_outdatedness_of(source_obj)
-
-        expect(deps.first.props.attributes?).to be
-        expect(deps.first.props.attributes).to match_array([:giraffe])
-        expect(deps.first.props.compiled_content?).not_to be
-      end
-
-      it 'ignores all other objects' do
-        subject
-        expect(other_items).to all(satisfy { |o| store.dependencies_causing_outdatedness_of(o).empty? })
-      end
-    end
-  end
-
-  describe '#record_dependency' do
-    context 'item on item' do
-      let(:source_obj) { item_a }
-      let(:target_obj) { item_b }
-      let(:other_items) { [item_c] }
-
-      include_examples 'records dependencies'
-    end
-
-    context 'item on layout' do
-      let(:source_obj) { item_a }
-      let(:target_obj) { layout_a }
-      let(:other_items) { [item_b, item_c] }
-
-      include_examples 'records dependencies'
-    end
-
-    context 'item on config' do
-      let(:source_obj) { item_a }
-      let(:target_obj) { config }
-      let(:other_items) { [item_b, item_c] }
-
-      include_examples 'records dependencies'
-    end
-  end
-
-  describe '#forget_dependencies_for' do
-    before do
-      store.record_dependency(item_a, item_b)
-      store.record_dependency(item_a, item_c)
-      store.record_dependency(item_b, item_a)
-      store.record_dependency(item_b, item_c)
-      store.record_dependency(item_c, item_a)
-      store.record_dependency(item_c, item_b)
-    end
-
-    subject { store.forget_dependencies_for(item_b) }
-
-    it 'removes dependencies from item_a' do
-      expect { subject }
-        .not_to change { store.objects_causing_outdatedness_of(item_a) }
-    end
-
-    it 'removes dependencies from item_b' do
-      expect { subject }
-        .to change { store.objects_causing_outdatedness_of(item_b) }
-        .from(match_array([item_a, item_c]))
-        .to(be_empty)
-    end
-
-    it 'removes dependencies from item_c' do
-      expect { subject }
-        .not_to change { store.objects_causing_outdatedness_of(item_c) }
-    end
-  end
-end