nanoc 4.4.5 → 4.4.6

data/spec/nanoc/base/checksummer_spec.rb

@@ -0,0 +1,381 @@
+require 'tempfile'
+
+describe Nanoc::Int::Checksummer::VerboseDigest do
+  let(:digest) { described_class.new }
+
+  it 'concatenates' do
+    digest.update('foo')
+    digest.update('bar')
+    expect(digest.to_s).to eql('foobar')
+  end
+end
+
+describe Nanoc::Int::Checksummer::CompactDigest do
+  let(:digest) { described_class.new }
+
+  it 'uses SHA1 and Base64' do
+    digest.update('foo')
+    digest.update('bar')
+    expect(digest.to_s).to eql(Digest::SHA1.base64digest('foobar'))
+  end
+end
+
+describe Nanoc::Int::Checksummer do
+  subject { described_class.calc(obj, Nanoc::Int::Checksummer::VerboseDigest) }
+
+  context 'String' do
+    let(:obj) { 'hello' }
+    it { is_expected.to eql('String<hello>') }
+  end
+
+  context 'Symbol' do
+    let(:obj) { :hello }
+    it { is_expected.to eql('Symbol<hello>') }
+  end
+
+  context 'nil' do
+    let(:obj) { nil }
+    it { is_expected.to eql('NilClass<>') }
+  end
+
+  context 'true' do
+    let(:obj) { true }
+    it { is_expected.to eql('TrueClass<>') }
+  end
+
+  context 'false' do
+    let(:obj) { false }
+    it { is_expected.to eql('FalseClass<>') }
+  end
+
+  context 'Array' do
+    let(:obj) { %w(hello goodbye) }
+    it { is_expected.to eql('Array<String<hello>,String<goodbye>,>') }
+
+    context 'different order' do
+      let(:obj) { %w(goodbye hello) }
+      it { is_expected.to eql('Array<String<goodbye>,String<hello>,>') }
+    end
+
+    context 'recursive' do
+      let(:obj) { [].tap { |arr| arr << ['hello', arr] } }
+      it { is_expected.to eql('Array<Array<String<hello>,Array<recur>,>,>') }
+    end
+
+    context 'non-serializable' do
+      let(:obj) { [-> {}] }
+      it { is_expected.to match(/\AArray<Proc<#<Proc:0x.*@.*:\d+.*>>,>\z/) }
+    end
+  end
+
+  context 'Hash' do
+    let(:obj) { { 'a' => 'foo', 'b' => 'bar' } }
+    it { is_expected.to eql('Hash<String<a>=String<foo>,String<b>=String<bar>,>') }
+
+    context 'different order' do
+      let(:obj) { { 'b' => 'bar', 'a' => 'foo' } }
+      it { is_expected.to eql('Hash<String<b>=String<bar>,String<a>=String<foo>,>') }
+    end
+
+    context 'non-serializable' do
+      let(:obj) { { 'a' => -> {} } }
+      it { is_expected.to match(/\AHash<String<a>=Proc<#<Proc:0x.*@.*:\d+.*>>,>\z/) }
+    end
+
+    context 'recursive values' do
+      let(:obj) { {}.tap { |hash| hash['a'] = hash } }
+      it { is_expected.to eql('Hash<String<a>=Hash<recur>,>') }
+    end
+
+    context 'recursive keys' do
+      let(:obj) { {}.tap { |hash| hash[hash] = 'hello' } }
+      it { is_expected.to eql('Hash<Hash<recur>=String<hello>,>') }
+    end
+  end
+
+  context 'Pathname' do
+    let(:obj) { ::Pathname.new(filename) }
+
+    let(:filename) { '/tmp/whatever' }
+    let(:mtime) { 200 }
+    let(:data) { 'stuffs' }
+
+    before do
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.write(filename, data)
+      File.utime(mtime, mtime, filename)
+    end
+
+    it { is_expected.to eql('Pathname<6-200>') }
+
+    context 'does not exist' do
+      before do
+        FileUtils.rm_rf(filename)
+      end
+
+      it { is_expected.to eql('Pathname<???>') }
+    end
+
+    context 'different data' do
+      let(:data) { 'other stuffs :o' }
+      it { is_expected.to eql('Pathname<15-200>') }
+    end
+  end
+
+  context 'Time' do
+    let(:obj) { Time.at(111_223) }
+    it { is_expected.to eql('Time<111223>') }
+  end
+
+  context 'Float' do
+    let(:obj) { 3.14 }
+    it { is_expected.to eql('Float<3.14>') }
+  end
+
+  context 'Fixnum/Integer' do
+    let(:obj) { 3 }
+    it { is_expected.to match(/\A(Integer|Fixnum)<3>\z/) }
+  end
+
+  context 'Nanoc::Identifier' do
+    let(:obj) { Nanoc::Identifier.new('/foo.md') }
+    it { is_expected.to eql('Nanoc::Identifier<String</foo.md>>') }
+  end
+
+  context 'Nanoc::RuleDSL::RulesCollection' do
+    let(:obj) do
+      Nanoc::RuleDSL::RulesCollection.new.tap { |rc| rc.data = data }
+    end
+
+    let(:data) { 'STUFF!' }
+
+    it { is_expected.to eql('Nanoc::RuleDSL::RulesCollection<String<STUFF!>>') }
+  end
+
+  context 'Nanoc::Int::CodeSnippet' do
+    let(:obj) { Nanoc::Int::CodeSnippet.new('asdf', '/bob.rb') }
+    it { is_expected.to eql('Nanoc::Int::CodeSnippet<String<asdf>>') }
+  end
+
+  context 'Nanoc::Int::Configuration' do
+    let(:obj) { Nanoc::Int::Configuration.new(hash: { 'foo' => 'bar' }) }
+    it { is_expected.to eql('Nanoc::Int::Configuration<Symbol<foo>=String<bar>,>') }
+  end
+
+  context 'Nanoc::Int::Item' do
+    let(:obj) { Nanoc::Int::Item.new('asdf', { 'foo' => 'bar' }, '/foo.md') }
+
+    it { is_expected.to eql('Nanoc::Int::Item<content=Nanoc::Int::TextualContent<String<asdf>>,attributes=Hash<Symbol<foo>=String<bar>,>,identifier=Nanoc::Identifier<String</foo.md>>>') }
+
+    context 'binary' do
+      let(:filename) { File.expand_path('foo.dat') }
+      let(:content) { Nanoc::Int::BinaryContent.new(filename) }
+      let(:obj) { Nanoc::Int::Item.new(content, { 'foo' => 'bar' }, '/foo.md') }
+
+      let(:mtime) { 200 }
+      let(:data) { 'stuffs' }
+
+      before do
+        File.write(content.filename, data)
+        File.utime(mtime, mtime, content.filename)
+      end
+
+      it { is_expected.to eql('Nanoc::Int::Item<content=Nanoc::Int::BinaryContent<Pathname<6-200>>,attributes=Hash<Symbol<foo>=String<bar>,>,identifier=Nanoc::Identifier<String</foo.md>>>') }
+    end
+
+    context 'recursive attributes' do
+      before do
+        obj.attributes[:foo] = obj
+      end
+
+      it { is_expected.to eql('Nanoc::Int::Item<content=Nanoc::Int::TextualContent<String<asdf>>,attributes=Hash<Symbol<foo>=Nanoc::Int::Item<recur>,>,identifier=Nanoc::Identifier<String</foo.md>>>') }
+    end
+
+    context 'with checksum' do
+      let(:obj) { Nanoc::Int::Item.new('asdf', { 'foo' => 'bar' }, '/foo.md', checksum_data: 'abcdef') }
+
+      it { is_expected.to eql('Nanoc::Int::Item<checksum_data=abcdef>') }
+    end
+
+    context 'with content checksum' do
+      let(:obj) { Nanoc::Int::Item.new('asdf', { 'foo' => 'bar' }, '/foo.md', content_checksum_data: 'con-cs') }
+
+      it { is_expected.to eql('Nanoc::Int::Item<content_checksum_data=con-cs,attributes=Hash<Symbol<foo>=String<bar>,>,identifier=Nanoc::Identifier<String</foo.md>>>') }
+    end
+
+    context 'with attributes checksum' do
+      let(:obj) { Nanoc::Int::Item.new('asdf', { 'foo' => 'bar' }, '/foo.md', attributes_checksum_data: 'attr-cs') }
+
+      it { is_expected.to eql('Nanoc::Int::Item<content=Nanoc::Int::TextualContent<String<asdf>>,attributes_checksum_data=attr-cs,identifier=Nanoc::Identifier<String</foo.md>>>') }
+    end
+  end
+
+  context 'Nanoc::Int::Layout' do
+    let(:obj) { Nanoc::Int::Layout.new('asdf', { 'foo' => 'bar' }, '/foo.md') }
+
+    it { is_expected.to eql('Nanoc::Int::Layout<content=Nanoc::Int::TextualContent<String<asdf>>,attributes=Hash<Symbol<foo>=String<bar>,>,identifier=Nanoc::Identifier<String</foo.md>>>') }
+
+    context 'recursive attributes' do
+      before do
+        obj.attributes[:foo] = obj
+      end
+
+      it { is_expected.to eql('Nanoc::Int::Layout<content=Nanoc::Int::TextualContent<String<asdf>>,attributes=Hash<Symbol<foo>=Nanoc::Int::Layout<recur>,>,identifier=Nanoc::Identifier<String</foo.md>>>') }
+    end
+
+    context 'with checksum' do
+      let(:obj) { Nanoc::Int::Layout.new('asdf', { 'foo' => 'bar' }, '/foo.md', checksum_data: 'abcdef') }
+
+      it { is_expected.to eql('Nanoc::Int::Layout<checksum_data=abcdef>') }
+    end
+  end
+
+  context 'Nanoc::ItemWithRepsView' do
+    let(:obj) { Nanoc::ItemWithRepsView.new(item, nil) }
+    let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') }
+
+    it { is_expected.to eql('Nanoc::ItemWithRepsView<Nanoc::Int::Item<content=Nanoc::Int::TextualContent<String<asdf>>,attributes=Hash<>,identifier=Nanoc::Identifier<String</foo.md>>>>') }
+  end
+
+  context 'Nanoc::Int::ItemRep' do
+    let(:obj) { Nanoc::Int::ItemRep.new(item, :pdf) }
+    let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') }
+
+    it { is_expected.to eql('Nanoc::Int::ItemRep<item=Nanoc::Int::Item<content=Nanoc::Int::TextualContent<String<asdf>>,attributes=Hash<>,identifier=Nanoc::Identifier<String</foo.md>>>,name=Symbol<pdf>>') }
+  end
+
+  context 'Nanoc::ItemRepView' do
+    let(:obj) { Nanoc::ItemRepView.new(rep, :_unused_context) }
+    let(:rep) { Nanoc::Int::ItemRep.new(item, :pdf) }
+    let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') }
+
+    it { is_expected.to eql('Nanoc::ItemRepView<Nanoc::Int::ItemRep<item=Nanoc::Int::Item<content=Nanoc::Int::TextualContent<String<asdf>>,attributes=Hash<>,identifier=Nanoc::Identifier<String</foo.md>>>,name=Symbol<pdf>>>') }
+  end
+
+  context 'Nanoc::ItemWithoutRepsView' do
+    let(:obj) { Nanoc::ItemWithoutRepsView.new(item, nil) }
+    let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') }
+
+    it { is_expected.to eql('Nanoc::ItemWithoutRepsView<Nanoc::Int::Item<content=Nanoc::Int::TextualContent<String<asdf>>,attributes=Hash<>,identifier=Nanoc::Identifier<String</foo.md>>>>') }
+  end
+
+  context 'Nanoc::LayoutView' do
+    let(:obj) { Nanoc::LayoutView.new(layout, nil) }
+    let(:layout) { Nanoc::Int::Layout.new('asdf', {}, '/foo.md') }
+
+    it { is_expected.to eql('Nanoc::LayoutView<Nanoc::Int::Layout<content=Nanoc::Int::TextualContent<String<asdf>>,attributes=Hash<>,identifier=Nanoc::Identifier<String</foo.md>>>>') }
+  end
+
+  context 'Nanoc::ConfigView' do
+    let(:obj) { Nanoc::ConfigView.new(config, nil) }
+    let(:config) { Nanoc::Int::Configuration.new(hash: { 'foo' => 'bar' }) }
+
+    it { is_expected.to eql('Nanoc::ConfigView<Nanoc::Int::Configuration<Symbol<foo>=String<bar>,>>') }
+  end
+
+  context 'Nanoc::ItemCollectionWithRepsView' do
+    let(:obj) { Nanoc::ItemCollectionWithRepsView.new(wrapped, nil) }
+
+    let(:config) { Nanoc::Int::Configuration.new(hash: { 'foo' => 'bar' }) }
+
+    let(:wrapped) do
+      Nanoc::Int::IdentifiableCollection.new(config).tap do |arr|
+        arr << Nanoc::Int::Item.new('foo', {}, '/foo.md')
+        arr << Nanoc::Int::Item.new('bar', {}, '/foo.md')
+      end
+    end
+
+    it { is_expected.to eql('Nanoc::ItemCollectionWithRepsView<Nanoc::Int::IdentifiableCollection<Nanoc::Int::Item<content=Nanoc::Int::TextualContent<String<foo>>,attributes=Hash<>,identifier=Nanoc::Identifier<String</foo.md>>>,Nanoc::Int::Item<content=Nanoc::Int::TextualContent<String<bar>>,attributes=Hash<>,identifier=Nanoc::Identifier<String</foo.md>>>,>>') }
+  end
+
+  context 'Nanoc::ItemCollectionWithoutRepsView' do
+    let(:obj) { Nanoc::ItemCollectionWithoutRepsView.new(wrapped, nil) }
+
+    let(:config) { Nanoc::Int::Configuration.new(hash: { 'foo' => 'bar' }) }
+
+    let(:wrapped) do
+      Nanoc::Int::IdentifiableCollection.new(config).tap do |arr|
+        arr << Nanoc::Int::Item.new('foo', {}, '/foo.md')
+        arr << Nanoc::Int::Item.new('bar', {}, '/foo.md')
+      end
+    end
+
+    it { is_expected.to eql('Nanoc::ItemCollectionWithoutRepsView<Nanoc::Int::IdentifiableCollection<Nanoc::Int::Item<content=Nanoc::Int::TextualContent<String<foo>>,attributes=Hash<>,identifier=Nanoc::Identifier<String</foo.md>>>,Nanoc::Int::Item<content=Nanoc::Int::TextualContent<String<bar>>,attributes=Hash<>,identifier=Nanoc::Identifier<String</foo.md>>>,>>') }
+  end
+
+  context 'Nanoc::RuleDSL::RuleContext' do
+    let(:obj) { Nanoc::RuleDSL::RuleContext.new(rep: rep, site: site, executor: executor, view_context: view_context) }
+
+    let(:rep) { Nanoc::Int::ItemRep.new(item, :pdf) }
+    let(:item) { Nanoc::Int::Item.new('stuff', {}, '/stuff.md') }
+
+    let(:site) do
+      Nanoc::Int::Site.new(config: config, code_snippets: code_snippets, items: items, layouts: layouts)
+    end
+
+    let(:config) { Nanoc::Int::Configuration.new(hash: { 'foo' => 'bar' }) }
+    let(:code_snippets) { [Nanoc::Int::CodeSnippet.new('asdf', '/bob.rb')] }
+    let(:items) { [item] }
+    let(:layouts) { [Nanoc::Int::Layout.new('asdf', {}, '/foo.md')] }
+
+    let(:executor) { :_unused_ }
+    let(:view_context) { :_unused_ }
+
+    let(:expected_item_checksum) { 'Nanoc::Int::Item<content=Nanoc::Int::TextualContent<String<stuff>>,attributes=Hash<>,identifier=Nanoc::Identifier<String</stuff.md>>>' }
+    let(:expected_item_rep_checksum) { 'Nanoc::Int::ItemRep<item=' + expected_item_checksum + ',name=Symbol<pdf>>' }
+    let(:expected_layout_checksum) { 'Nanoc::Int::Layout<content=Nanoc::Int::TextualContent<String<asdf>>,attributes=Hash<>,identifier=Nanoc::Identifier<String</foo.md>>>' }
+    let(:expected_config_checksum) { 'Nanoc::Int::Configuration<Symbol<foo>=String<bar>,>' }
+
+    let(:expected_checksum) do
+      [
+        'Nanoc::RuleDSL::RuleContext<',
+        'item=',
+        'Nanoc::ItemWithoutRepsView<' + expected_item_checksum + '>',
+        ',rep=',
+        'Nanoc::ItemRepView<' + expected_item_rep_checksum + '>',
+        ',items=',
+        'Nanoc::ItemCollectionWithoutRepsView<Array<' + expected_item_checksum + ',>>',
+        ',layouts=',
+        'Nanoc::LayoutCollectionView<Array<' + expected_layout_checksum + ',>>',
+        ',config=',
+        'Nanoc::ConfigView<' + expected_config_checksum + '>',
+        '>',
+      ].join('')
+    end
+
+    it { is_expected.to eql(expected_checksum) }
+  end
+
+  context 'Nanoc::Int::Context' do
+    let(:obj) { Nanoc::Int::Context.new(foo: 123) }
+
+    it { is_expected.to match(/\ANanoc::Int::Context<@foo=(Fixnum|Integer)<123>,>\z/) }
+  end
+
+  context 'Sass::Importers::Filesystem' do
+    let(:obj) { Sass::Importers::Filesystem.new('/foo') }
+
+    before { require 'sass' }
+
+    it { is_expected.to eql('Sass::Importers::Filesystem<root=/foo>') }
+  end
+
+  context 'other marshal-able classes' do
+    let(:obj) { klass.new('hello') }
+
+    let(:klass) do
+      Class.new do
+        def initialize(a)
+          @a = a
+        end
+      end
+    end
+
+    it { is_expected.to match(/\A#<Class:0x[0-9a-f]+><.*>\z/) }
+  end
+
+  context 'other non-marshal-able classes' do
+    let(:obj) { proc {} }
+    it { is_expected.to match(/\AProc<#<Proc:0x.*@.*:\d+.*>>\z/) }
+  end
+end

data/spec/nanoc/base/compiler_spec.rb

@@ -0,0 +1,181 @@
+describe Nanoc::Int::Compiler do
+  let(:compiler) do
+    described_class.new(
+      site,
+      compiled_content_cache: compiled_content_cache,
+      checksum_store: checksum_store,
+      rule_memory_store: rule_memory_store,
+      action_provider: action_provider,
+      dependency_store: dependency_store,
+      outdatedness_checker: outdatedness_checker,
+      reps: reps,
+    )
+  end
+
+  let(:checksum_store)         { :__irrelevant_checksum_store }
+  let(:rule_memory_store)      { :__irrelevant_rule_memory_store }
+
+  let(:dependency_store) { Nanoc::Int::DependencyStore.new(items.to_a) }
+  let(:reps) { Nanoc::Int::ItemRepRepo.new }
+
+  let(:outdatedness_checker) { double(:outdatedness_checker) }
+  let(:action_provider) { double(:action_provider) }
+
+  let(:compiled_content_cache) { Nanoc::Int::CompiledContentCache.new(items: items) }
+
+  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,
+      items: items,
+      layouts: layouts,
+    )
+  end
+
+  let(:config) { Nanoc::Int::Configuration.new.with_defaults }
+  let(:layouts) { [] }
+  let(:code_snippets) { [] }
+
+  let(:items) do
+    Nanoc::Int::IdentifiableCollection.new(config).tap do |col|
+      col << item
+      col << other_item
+    end
+  end
+
+  let(:memory) do
+    [
+      Nanoc::Int::ProcessingActions::Filter.new(:erb, {}),
+      Nanoc::Int::ProcessingActions::Snapshot.new(:last, nil),
+    ]
+  end
+
+  before do
+    reps << rep
+    reps << other_rep
+
+    reps.each do |rep|
+      rep.snapshot_defs << Nanoc::Int::SnapshotDef.new(:last)
+    end
+
+    allow(outdatedness_checker).to receive(:outdated?).with(rep).and_return(true)
+    allow(outdatedness_checker).to receive(:outdated?).with(other_rep).and_return(true)
+
+    allow(action_provider).to receive(:memory_for).with(rep).and_return(memory)
+    allow(action_provider).to receive(:memory_for).with(other_rep).and_return(memory)
+  end
+
+  describe '#compile_reps' do
+    subject { compiler.send(:compile_reps) }
+
+    before do
+      allow(action_provider).to receive(:snapshots_defs_for).with(rep).and_return(snapshot_defs_for_rep)
+      allow(action_provider).to receive(:snapshots_defs_for).with(other_rep).and_return(snapshot_defs_for_rep)
+    end
+
+    let(:snapshot_defs_for_rep) do
+      [Nanoc::Int::SnapshotDef.new(:last)]
+    end
+
+    let(:snapshot_defs_for_other_rep) do
+      [Nanoc::Int::SnapshotDef.new(:last)]
+    end
+
+    it 'compiles individual reps' do
+      expect { subject }.to change { rep.snapshot_contents[:last].string }
+        .from('<%= 1 + 2 %>')
+        .to('3')
+    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
+    end
+  end
+
+  describe '#compile_rep' do
+    subject { compiler.send(:compile_rep, rep, is_outdated: is_outdated) }
+
+    let(:is_outdated) { true }
+
+    it 'generates expected output' do
+      expect(rep.snapshot_contents[:last].string).to eql(item.content.string)
+      subject
+      expect(rep.snapshot_contents[:last].string).to eql('3')
+    end
+
+    it 'generates notifications in the proper order' do
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_started, rep).ordered
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_started, rep, :erb).ordered
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_ended, rep, :erb).ordered
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_ended, rep).ordered
+
+      subject
+    end
+
+    context 'interrupted compilation' do
+      let(:item) { Nanoc::Int::Item.new('other=<%= @items["/other.*"].compiled_content %>', {}, '/hi.md') }
+
+      before do
+        expect(action_provider).to receive(:memory_for).with(other_rep).and_return(memory)
+      end
+
+      it 'generates expected output' do
+        expect(rep.snapshot_contents[:last].string).to eql(item.content.string)
+
+        expect { compiler.send(:compile_rep, rep, is_outdated: true) }
+          .to raise_error(Nanoc::Int::Errors::UnmetDependency)
+        compiler.send(:compile_rep, other_rep, is_outdated: true)
+        compiler.send(:compile_rep, rep, is_outdated: true)
+
+        expect(rep.snapshot_contents[:last].string).to eql('other=other content')
+      end
+
+      it 'generates notifications in the proper order' do
+        # rep 1
+        expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_started, rep).ordered
+        expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_started, rep, :erb).ordered
+        expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:dependency_created, item, other_item).ordered
+        expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_suspended, rep, anything).ordered
+
+        # rep 2
+        expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_started, other_rep).ordered
+        expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_started, other_rep, :erb).ordered
+        expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_ended, other_rep, :erb).ordered
+        expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_ended, other_rep).ordered
+
+        # rep 1 (again)
+        expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_started, rep).ordered
+        expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_ended, rep, :erb).ordered
+        expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_ended, rep).ordered
+
+        expect { compiler.send(:compile_rep, rep, is_outdated: true) }
+          .to raise_error(Nanoc::Int::Errors::UnmetDependency)
+        compiler.send(:compile_rep, other_rep, is_outdated: true)
+        compiler.send(:compile_rep, rep, is_outdated: true)
+      end
+    end
+  end
+end

data/spec/nanoc/base/entities/configuration_spec.rb

@@ -0,0 +1,49 @@
+describe Nanoc::Int::Configuration do
+  let(:hash) { { foo: 'bar' } }
+  let(:config) { described_class.new(hash: hash) }
+
+  describe '#key?' do
+    subject { config.key?(key) }
+
+    context 'non-existent key' do
+      let(:key) { :donkey }
+      it { is_expected.not_to be }
+    end
+
+    context 'existent key' do
+      let(:key) { :foo }
+      it { is_expected.to be }
+    end
+  end
+
+  context 'with environments defined' do
+    let(:hash) { { foo: 'bar', environments: { test: { foo: 'test-bar' }, default: { foo: 'default-bar' } } } }
+    let(:config) { described_class.new(hash: hash, env_name: env_name).with_environment }
+
+    subject { config }
+
+    context 'with existing environment' do
+      let(:env_name) { 'test' }
+
+      it 'inherits options from given environment' do
+        expect(subject[:foo]).to eq('test-bar')
+      end
+    end
+
+    context 'with unknown environment' do
+      let(:env_name) { 'wtf' }
+
+      it 'does not inherits options from any environment' do
+        expect(subject[:foo]).to eq('bar')
+      end
+    end
+
+    context 'without given environment' do
+      let(:env_name) { nil }
+
+      it 'inherits options from default environment' do
+        expect(subject[:foo]).to eq('default-bar')
+      end
+    end
+  end
+end