nanoc 4.8.12 → 4.8.13

data/spec/nanoc/base/services/compiler/stages/compile_reps_spec.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::Compiler::Stages::CompileReps do
-  let(:stage) do
-    described_class.new(
-      reps: reps,
-      outdatedness_store: outdatedness_store,
-      dependency_store: dependency_store,
-      action_sequences: action_sequences,
-      compilation_context: compilation_context,
-      compiled_content_cache: compiled_content_cache,
-    )
-  end
-
-  let(:compilation_context) do
-    Nanoc::Int::CompilationContext.new(
-      action_provider: action_provider,
-      reps: reps,
-      site: site,
-      compiled_content_cache: compiled_content_cache,
-      snapshot_repo: snapshot_repo,
-    )
-  end
-
-  let(:action_provider) { double(:action_provider) }
-  let(:action_sequences) { double(:action_sequences) }
-  let(:reps) { Nanoc::Int::ItemRepRepo.new }
-  let(:compiled_content_cache) { Nanoc::Int::CompiledContentCache.new(items: items, site: site) }
-  let(:snapshot_repo) { Nanoc::Int::SnapshotRepo.new }
-
-  let(:outdatedness_store) { Nanoc::Int::OutdatednessStore.new(site: site) }
-  let(:dependency_store) { Nanoc::Int::DependencyStore.new(items, layouts, config) }
-
-  let(:rep) { Nanoc::Int::ItemRep.new(item, :default) }
-  let(:item) { Nanoc::Int::Item.new('<%= 1 + 2 %>', {}, '/hi.md') }
-
-  let(:other_rep) { Nanoc::Int::ItemRep.new(other_item, :default) }
-  let(:other_item) { Nanoc::Int::Item.new('other content', {}, '/other.md') }
-
-  let(:site) do
-    Nanoc::Int::Site.new(
-      config: config,
-      code_snippets: code_snippets,
-      data_source: Nanoc::Int::InMemDataSource.new(items, layouts),
-    )
-  end
-
-  let(:config) { Nanoc::Int::Configuration.new.with_defaults }
-  let(:code_snippets) { [] }
-
-  let(:layouts) do
-    Nanoc::Int::LayoutCollection.new(config)
-  end
-
-  let(:items) do
-    Nanoc::Int::ItemCollection.new(
-      config,
-      [item, other_item],
-    )
-  end
-
-  let(:memory) do
-    actions =
-      [
-        Nanoc::Int::ProcessingActions::Filter.new(:erb, {}),
-        Nanoc::Int::ProcessingActions::Snapshot.new([:last], []),
-      ]
-
-    Nanoc::Int::ActionSequence.new(nil, actions: actions)
-  end
-
-  before do
-    reps << rep
-    reps << other_rep
-
-    reps.each do |rep|
-      rep.snapshot_defs << Nanoc::Int::SnapshotDef.new(:last, binary: false)
-    end
-
-    allow(action_sequences).to receive(:[]).with(rep).and_return(memory)
-    allow(action_sequences).to receive(:[]).with(other_rep).and_return(memory)
-  end
-
-  describe '#compile_reps' do
-    subject { stage.run }
-
-    let(:snapshot_defs_for_rep) do
-      [Nanoc::Int::SnapshotDef.new(:last, binary: false)]
-    end
-
-    let(:snapshot_defs_for_other_rep) do
-      [Nanoc::Int::SnapshotDef.new(:last, binary: false)]
-    end
-
-    context 'rep not in outdatedness store' do
-      it 'keeps the item rep out of the outdatedness store' do
-        expect(outdatedness_store.include?(rep)).not_to be
-        expect { subject }.not_to change { outdatedness_store.include?(rep) }
-      end
-    end
-
-    context 'rep in outdatedness store' do
-      before { outdatedness_store.add(rep) }
-
-      it 'compiles individual reps' do
-        expect { subject }.to change { snapshot_repo.get(rep, :last) }
-          .from(nil)
-          .to(some_textual_content('3'))
-      end
-
-      it 'removes the item rep from the outdatedness store' do
-        expect { subject }.to change { outdatedness_store.include?(rep) }.from(true).to(false)
-      end
-
-      context 'exception' do
-        let(:item) { Nanoc::Int::Item.new('<%= raise "lol" %>', {}, '/hi.md') }
-
-        it 'wraps exception' do
-          expect { subject }.to raise_error(Nanoc::Int::Errors::CompilationError)
-        end
-
-        it 'contains the right item rep in the wrapped exception' do
-          expect { subject }.to raise_error do |err|
-            expect(err.item_rep).to eql(rep)
-          end
-        end
-
-        it 'contains the right wrapped exception' do
-          expect { subject }.to raise_error do |err|
-            expect(err.unwrap).to be_a(RuntimeError)
-            expect(err.unwrap.message).to eq('lol')
-          end
-        end
-
-        it 'keeps the item rep in the outdatedness store' do
-          expect(outdatedness_store.include?(rep)).to be
-          expect { subject rescue nil }.not_to change { outdatedness_store.include?(rep) }
-        end
-      end
-    end
-  end
-end

data/spec/nanoc/base/services/compiler/stages/determine_outdatedness_spec.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::Compiler::Stages::DetermineOutdatedness do
-  let(:stage) do
-    described_class.new(
-      reps: reps,
-      outdatedness_checker: outdatedness_checker,
-      outdatedness_store: outdatedness_store,
-    )
-  end
-
-  let(:reps) do
-    Nanoc::Int::ItemRepRepo.new
-  end
-
-  let(:outdatedness_checker) do
-    double(:outdatedness_checker)
-  end
-
-  let(:outdatedness_store) do
-    Nanoc::Int::OutdatednessStore.new
-  end
-
-  describe '#run' do
-    subject { stage.run }
-
-    context 'outdatedness store is empty' do
-      let(:item) do
-        Nanoc::Int::Item.new('', {}, '/hi.md')
-      end
-
-      let(:rep) do
-        Nanoc::Int::ItemRep.new(item, :woof)
-      end
-
-      let(:other_rep) do
-        Nanoc::Int::ItemRep.new(item, :bark)
-      end
-
-      context 'outdatedness checker thinks rep is outdated' do
-        before do
-          reps << rep
-          reps << other_rep
-
-          expect(outdatedness_checker)
-            .to receive(:outdated?).with(rep).and_return(true)
-
-          expect(outdatedness_checker)
-            .to receive(:outdated?).with(other_rep).and_return(false)
-        end
-
-        it 'adds the rep' do
-          expect { subject }
-            .to change { outdatedness_store.include?(rep) }
-            .from(false)
-            .to(true)
-        end
-
-        it 'also adds the other rep' do
-          expect { subject }
-            .to change { outdatedness_store.include?(other_rep) }
-            .from(false)
-            .to(true)
-        end
-
-        it 'returns a list with the known rep’s item' do
-          expect(subject).to eq([rep.item])
-        end
-      end
-
-      context 'outdatedness checker thinks rep is not outdated' do
-        it 'keeps the outdatedness store empty' do
-          expect { subject }
-            .not_to change { outdatedness_store.empty? }
-        end
-
-        it 'returns an empty list' do
-          expect(subject).to be_empty
-        end
-      end
-    end
-
-    context 'outdatedness store contains known rep' do
-      let(:item) do
-        Nanoc::Int::Item.new('', {}, '/hi.md')
-      end
-
-      let(:rep) do
-        Nanoc::Int::ItemRep.new(item, :woof)
-      end
-
-      let(:other_rep) do
-        Nanoc::Int::ItemRep.new(item, :bark)
-      end
-
-      before do
-        reps << rep
-        reps << other_rep
-
-        outdatedness_store.add(rep)
-
-        expect(outdatedness_checker)
-          .to receive(:outdated?).with(other_rep).and_return(false)
-      end
-
-      it 'keeps the rep' do
-        expect { subject }
-          .not_to change { outdatedness_store.include?(rep) }
-      end
-
-      it 'also adds the other rep' do
-        expect { subject }
-          .to change { outdatedness_store.include?(other_rep) }
-          .from(false)
-          .to(true)
-      end
-
-      it 'returns a list with the known rep’s item' do
-        expect(subject).to eq([rep.item])
-      end
-    end
-
-    context 'outdatedness store contains unknown rep' do
-      let(:item) do
-        Nanoc::Int::Item.new('', {}, '/hi.md')
-      end
-
-      let(:unknown_rep) do
-        Nanoc::Int::ItemRep.new(item, :woof)
-      end
-
-      before do
-        outdatedness_store.add(unknown_rep)
-      end
-
-      it 'removes the unknown rep' do
-        expect { subject }
-          .to change { outdatedness_store.include?(unknown_rep) }
-          .from(true)
-          .to(false)
-      end
-
-      it 'returns an empty list' do
-        expect(subject).to be_empty
-      end
-    end
-  end
-end

data/spec/nanoc/base/services/compiler/stages/preprocess_spec.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::Compiler::Stages::Preprocess do
-  let(:stage) do
-    described_class.new(
-      action_provider: action_provider,
-      site: site,
-      dependency_store: dependency_store,
-      checksum_store: checksum_store,
-    )
-  end
-
-  let(:action_provider) do
-    double(:action_provider)
-  end
-
-  let(:site) do
-    Nanoc::Int::Site.new(
-      config: config,
-      code_snippets: [],
-      data_source: data_source,
-    )
-  end
-
-  let(:data_source) { Nanoc::Int::InMemDataSource.new(items, layouts) }
-  let(:config) { Nanoc::Int::Configuration.new.with_defaults }
-  let(:items) { Nanoc::Int::ItemCollection.new(config) }
-  let(:layouts) { Nanoc::Int::LayoutCollection.new(config) }
-
-  let(:dependency_store) do
-    Nanoc::Int::DependencyStore.new(items, layouts, config, site: site)
-  end
-
-  let(:checksum_store) do
-    Nanoc::Int::ChecksumStore.new(site: site, objects: items.to_a + layouts.to_a)
-  end
-
-  describe '#run' do
-    subject { stage.run }
-
-    context 'no preprocessing needed' do
-      before do
-        expect(action_provider).to receive(:need_preprocessing?).and_return(false)
-      end
-
-      it 'marks the site as preprocessed' do
-        expect { subject }
-          .to change { site.preprocessed? }
-          .from(false)
-          .to(true)
-      end
-
-      it 'freezes the site' do
-        subject
-      end
-    end
-
-    context 'preprocessing needed' do
-      let(:new_item) { Nanoc::Int::Item.new('new item', {}, '/new.md') }
-      let(:new_layout) { Nanoc::Int::Layout.new('new layout', {}, '/new.md') }
-
-      before do
-        expect(action_provider).to receive(:need_preprocessing?).and_return(true)
-
-        expect(action_provider).to receive(:preprocess) do |site|
-          site.data_source =
-            Nanoc::Int::InMemDataSource.new(
-              Nanoc::Int::ItemCollection.new(config, [new_item]),
-              Nanoc::Int::LayoutCollection.new(config, [new_layout]),
-            )
-        end
-      end
-
-      it 'marks the site as preprocessed' do
-        expect { subject }
-          .to change { site.preprocessed? }
-          .from(false)
-          .to(true)
-      end
-
-      it 'freezes the site' do
-        expect { subject }
-          .to change { site.config.frozen? }
-          .from(false)
-          .to(true)
-      end
-
-      it 'sets items on dependency store' do
-        expect { subject }
-          .to change { dependency_store.items.to_a }
-          .from([])
-          .to([new_item])
-      end
-
-      it 'sets layouts on dependency store' do
-        expect { subject }
-          .to change { dependency_store.layouts.to_a }
-          .from([])
-          .to([new_layout])
-      end
-
-      it 'sets data on checksum store' do
-        expect { subject }
-          .to change { checksum_store.objects.to_a }
-          .from([])
-          .to(match_array([new_item, new_layout, config]))
-      end
-    end
-  end
-end

data/spec/nanoc/base/services/dependency_tracker_spec.rb

@@ -1,245 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::DependencyTracker do
-  let(:tracker) { described_class.new(store) }
-
-  let(:store) { Nanoc::Int::DependencyStore.new(empty_items, empty_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(:empty_items) { Nanoc::Int::ItemCollection.new(config) }
-  let(:empty_layouts) { Nanoc::Int::LayoutCollection.new(config) }
-
-  let(:config) { Nanoc::Int::Configuration.new.with_defaults }
-
-  shared_examples 'a null dependency tracker' do
-    let(:tracker) { Nanoc::Int::DependencyTracker::Null.new }
-
-    example do
-      expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_a) }
-    end
-
-    example do
-      expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) }
-    end
-
-    example do
-      expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) }
-    end
-
-    example do
-      expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_a) }
-    end
-
-    example do
-      expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_b) }
-    end
-
-    example do
-      expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_c) }
-    end
-  end
-
-  describe '#enter and #exit' do
-    context 'enter' do
-      subject do
-        tracker.enter(item_a)
-      end
-
-      it_behaves_like 'a null dependency tracker'
-
-      example do
-        expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_a) }
-      end
-
-      example do
-        expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) }
-      end
-
-      example do
-        expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) }
-      end
-    end
-
-    context 'enter + enter' do
-      subject do
-        tracker.enter(item_a)
-        tracker.enter(item_b)
-      end
-
-      it_behaves_like 'a null dependency tracker'
-
-      it 'changes predecessors of item A' do
-        expect { subject }.to change { store.objects_causing_outdatedness_of(item_a) }
-          .from([]).to([item_b])
-      end
-
-      example do
-        expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) }
-      end
-
-      example do
-        expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) }
-      end
-    end
-
-    context 'enter + enter with props' do
-      subject do
-        tracker.enter(item_a)
-        tracker.enter(item_b, compiled_content: true)
-      end
-
-      it_behaves_like 'a null dependency tracker'
-
-      it 'changes predecessors of item A' do
-        expect { subject }.to change { store.objects_causing_outdatedness_of(item_a) }
-          .from([]).to([item_b])
-      end
-
-      it 'changes dependencies causing outdatedness of item A' do
-        expect { subject }.to change { store.dependencies_causing_outdatedness_of(item_a).size }
-          .from(0).to(1)
-      end
-
-      it 'creates correct new dependency causing outdatedness of item A' do
-        subject
-        dep = store.dependencies_causing_outdatedness_of(item_a)[0]
-
-        expect(dep.from).to eql(item_b)
-        expect(dep.to).to eql(item_a)
-      end
-
-      it 'creates dependency with correct props causing outdatedness of item A' do
-        subject
-        dep = store.dependencies_causing_outdatedness_of(item_a)[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
-
-      example do
-        expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) }
-      end
-
-      example do
-        expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) }
-      end
-
-      example do
-        expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_b) }
-      end
-
-      example do
-        expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_c) }
-      end
-    end
-
-    context 'enter + enter with prop + exit + enter with prop' do
-      subject do
-        tracker.enter(item_a)
-        tracker.enter(item_b, compiled_content: true)
-        tracker.exit
-        tracker.enter(item_b, attributes: true)
-      end
-
-      it_behaves_like 'a null dependency tracker'
-
-      it 'changes predecessors of item A' do
-        expect { subject }.to change { store.objects_causing_outdatedness_of(item_a) }
-          .from([]).to([item_b])
-      end
-
-      it 'changes dependencies causing outdatedness of item A' do
-        expect { subject }.to change { store.dependencies_causing_outdatedness_of(item_a).size }
-          .from(0).to(1)
-      end
-
-      it 'creates correct new dependency causing outdatedness of item A' do
-        subject
-        dep = store.dependencies_causing_outdatedness_of(item_a)[0]
-
-        expect(dep.from).to eql(item_b)
-        expect(dep.to).to eql(item_a)
-      end
-
-      it 'creates dependency with correct props causing outdatedness of item A' do
-        subject
-        dep = store.dependencies_causing_outdatedness_of(item_a)[0]
-
-        expect(dep.props.compiled_content?).to eq(true)
-        expect(dep.props.attributes?).to eq(true)
-
-        expect(dep.props.raw_content?).to eq(false)
-        expect(dep.props.path?).to eq(false)
-      end
-
-      example do
-        expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) }
-      end
-
-      example do
-        expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) }
-      end
-
-      example do
-        expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_b) }
-      end
-
-      example do
-        expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_c) }
-      end
-    end
-
-    context 'enter + enter + exit + enter' do
-      subject do
-        tracker.enter(item_a)
-        tracker.enter(item_b)
-        tracker.exit
-        tracker.enter(item_c)
-      end
-
-      it_behaves_like 'a null dependency tracker'
-
-      it 'changes predecessors of item A' do
-        expect { subject }.to change { store.objects_causing_outdatedness_of(item_a) }
-          .from([]).to([item_b, item_c])
-      end
-
-      example do
-        expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) }
-      end
-
-      example do
-        expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) }
-      end
-    end
-
-    context 'enter + bounce + enter' do
-      subject do
-        tracker.enter(item_a)
-        tracker.bounce(item_b)
-        tracker.enter(item_c)
-      end
-
-      it_behaves_like 'a null dependency tracker'
-
-      it 'changes predecessors of item A' do
-        expect { subject }.to change { store.objects_causing_outdatedness_of(item_a) }
-          .from([]).to([item_b, item_c])
-      end
-
-      example do
-        expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) }
-      end
-
-      example do
-        expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) }
-      end
-    end
-  end
-end