nanoc 4.4.5 → 4.4.6

data/spec/nanoc/rule_dsl/rule_context_spec.rb

@@ -0,0 +1,177 @@
+describe(Nanoc::RuleDSL::RuleContext) do
+  subject(:rule_context) do
+    described_class.new(rep: rep, site: site, executor: executor, view_context: view_context)
+  end
+
+  let(:item_identifier) { Nanoc::Identifier.new('/foo.md') }
+  let(:item) { Nanoc::Int::Item.new('content', {}, item_identifier) }
+  let(:config) { Nanoc::Int::Configuration.new }
+  let(:items) { Nanoc::Int::IdentifiableCollection.new(config) }
+  let(:layouts) { Nanoc::Int::IdentifiableCollection.new(config) }
+
+  let(:rep) { double(:rep, item: item) }
+  let(:site) { double(:site, items: items, layouts: layouts, config: config) }
+  let(:executor) { double(:executor) }
+  let(:reps) { double(:reps) }
+  let(:compilation_context) { double(:compilation_context) }
+  let(:view_context) { Nanoc::ViewContext.new(reps: reps, items: items, dependency_tracker: dependency_tracker, compilation_context: compilation_context) }
+  let(:dependency_tracker) { double(:dependency_tracker) }
+
+  describe '#initialize' do
+    it 'wraps objects in view classes' do
+      expect(subject.rep.class).to eql(Nanoc::ItemRepView)
+      expect(subject.item.class).to eql(Nanoc::ItemWithoutRepsView)
+      expect(subject.config.class).to eql(Nanoc::ConfigView)
+      expect(subject.layouts.class).to eql(Nanoc::LayoutCollectionView)
+      expect(subject.items.class).to eql(Nanoc::ItemCollectionWithoutRepsView)
+    end
+
+    it 'contains the right objects' do
+      expect(rule_context.rep.unwrap).to eql(rep)
+      expect(rule_context.item.unwrap).to eql(item)
+      expect(rule_context.config.unwrap).to eql(config)
+      expect(rule_context.layouts.unwrap).to eql(layouts)
+      expect(rule_context.items.unwrap).to eql(items)
+    end
+  end
+
+  describe '#item' do
+    subject { rule_context.item }
+
+    it 'is a view without reps access' do
+      expect(subject.class).to eql(Nanoc::ItemWithoutRepsView)
+    end
+
+    it 'contains the right item' do
+      expect(subject.unwrap).to eql(item)
+    end
+
+    context 'with legacy identifier and children/parent' do
+      let(:item_identifier) { Nanoc::Identifier.new('/foo/', type: :legacy) }
+
+      let(:parent_identifier) { Nanoc::Identifier.new('/', type: :legacy) }
+      let(:parent) { Nanoc::Int::Item.new('parent', {}, parent_identifier) }
+
+      let(:child_identifier) { Nanoc::Identifier.new('/foo/bar/', type: :legacy) }
+      let(:child) { Nanoc::Int::Item.new('child', {}, child_identifier) }
+
+      before do
+        items << item
+        items << parent
+        items << child
+      end
+
+      it 'has a parent' do
+        expect(subject.parent.unwrap).to eql(parent)
+      end
+
+      it 'wraps the parent in a view without reps access' do
+        expect(subject.parent.class).to eql(Nanoc::ItemWithoutRepsView)
+        expect(subject.parent).not_to respond_to(:compiled_content)
+        expect(subject.parent).not_to respond_to(:path)
+        expect(subject.parent).not_to respond_to(:reps)
+      end
+
+      it 'has children' do
+        expect(subject.children.map(&:unwrap)).to eql([child])
+      end
+
+      it 'wraps the children in a view without reps access' do
+        expect(subject.children.map(&:class)).to eql([Nanoc::ItemWithoutRepsView])
+        expect(subject.children[0]).not_to respond_to(:compiled_content)
+        expect(subject.children[0]).not_to respond_to(:path)
+        expect(subject.children[0]).not_to respond_to(:reps)
+      end
+    end
+  end
+
+  describe '#items' do
+    subject { rule_context.items }
+
+    let(:item_identifier) { Nanoc::Identifier.new('/foo/', type: :legacy) }
+
+    let(:parent_identifier) { Nanoc::Identifier.new('/', type: :legacy) }
+    let(:parent) { Nanoc::Int::Item.new('parent', {}, parent_identifier) }
+
+    let(:child_identifier) { Nanoc::Identifier.new('/foo/bar/', type: :legacy) }
+    let(:child) { Nanoc::Int::Item.new('child', {}, child_identifier) }
+
+    before do
+      items << item
+      items << parent
+      items << child
+    end
+
+    it 'is a view without reps access' do
+      expect(subject.class).to eql(Nanoc::ItemCollectionWithoutRepsView)
+    end
+
+    it 'contains all items' do
+      expect(subject.unwrap).to match_array([item, parent, child])
+    end
+
+    it 'provides no rep access' do
+      expect(subject['/']).not_to be_nil
+      expect(subject['/']).not_to respond_to(:compiled_content)
+      expect(subject['/']).not_to respond_to(:path)
+      expect(subject['/']).not_to respond_to(:reps)
+
+      expect(subject['/foo/']).not_to be_nil
+      expect(subject['/foo/']).not_to respond_to(:compiled_content)
+      expect(subject['/foo/']).not_to respond_to(:path)
+      expect(subject['/foo/']).not_to respond_to(:reps)
+
+      expect(subject['/foo/bar/']).not_to be_nil
+      expect(subject['/foo/bar/']).not_to respond_to(:compiled_content)
+      expect(subject['/foo/bar/']).not_to respond_to(:path)
+      expect(subject['/foo/bar/']).not_to respond_to(:reps)
+    end
+  end
+
+  describe '#filter' do
+    subject { rule_context.filter(filter_name, filter_args) }
+
+    let(:filter_name) { :donkey }
+    let(:filter_args) { { color: 'grey' } }
+
+    it 'makes a request to the executor' do
+      expect(executor).to receive(:filter).with(filter_name, filter_args)
+      subject
+    end
+  end
+
+  describe '#layout' do
+    subject { rule_context.layout(layout_identifier, extra_filter_args) }
+
+    let(:layout_identifier) { '/default.*' }
+    let(:extra_filter_args) { { color: 'grey' } }
+
+    it 'makes a request to the executor' do
+      expect(executor).to receive(:layout).with(layout_identifier, extra_filter_args)
+      subject
+    end
+  end
+
+  describe '#snapshot' do
+    subject { rule_context.snapshot(snapshot_name, path: path) }
+
+    let(:snapshot_name) { :for_snippet }
+    let(:path) { '/foo.html' }
+
+    it 'makes a request to the executor' do
+      expect(executor).to receive(:snapshot).with(:for_snippet, path: '/foo.html')
+      subject
+    end
+  end
+
+  describe '#write' do
+    subject { rule_context.write(path) }
+
+    let(:path) { '/foo.html' }
+
+    it 'makes a request to the executor' do
+      expect(executor).to receive(:snapshot).with(:last, path: '/foo.html')
+      subject
+    end
+  end
+end

data/spec/nanoc/rule_dsl/rule_memory_calculator_spec.rb

@@ -0,0 +1,233 @@
+describe(Nanoc::RuleDSL::RuleMemoryCalculator) do
+  subject(:rule_memory_calculator) do
+    described_class.new(site: site, rules_collection: rules_collection)
+  end
+
+  let(:rules_collection) { Nanoc::RuleDSL::RulesCollection.new }
+  let(:site) { double(:site) }
+
+  describe '#[]' do
+    subject { rule_memory_calculator[obj] }
+
+    context 'with item rep' do
+      let(:obj) { Nanoc::Int::ItemRep.new(item, :csv) }
+
+      let(:item) { Nanoc::Int::Item.new('content', {}, Nanoc::Identifier.from('/list.md')) }
+      let(:config) { Nanoc::Int::Configuration.new.with_defaults }
+      let(:items) { Nanoc::Int::IdentifiableCollection.new(config) }
+      let(:layouts) { Nanoc::Int::IdentifiableCollection.new(config) }
+      let(:site) { double(:site, items: items, layouts: layouts, config: config, compiler: compiler) }
+      let(:compiler) { double(:compiler, compilation_context: compilation_context) }
+      let(:compilation_context) { double(:compilation_context) }
+      let(:view_context) { double(:view_context) }
+
+      before do
+        expect(compilation_context).to receive(:create_view_context).and_return(view_context)
+      end
+
+      context 'no rules exist' do
+        it 'raises error' do
+          error = Nanoc::RuleDSL::RuleMemoryCalculator::NoRuleMemoryForItemRepException
+          expect { subject }.to raise_error(error)
+        end
+      end
+
+      context 'rules exist' do
+        before do
+          rules_proc = proc do
+            filter :erb, speed: :over_9000
+            layout '/default.*'
+            filter :typohero
+          end
+          rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :csv, rules_proc)
+          rules_collection.add_item_compilation_rule(rule)
+        end
+
+        example do
+          subject
+
+          expect(subject[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+          expect(subject[0].snapshot_name).to eql(:raw)
+          expect(subject[0].path).to be_nil
+
+          expect(subject[1]).to be_a(Nanoc::Int::ProcessingActions::Filter)
+          expect(subject[1].filter_name).to eql(:erb)
+          expect(subject[1].params).to eql(speed: :over_9000)
+
+          expect(subject[2]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+          expect(subject[2].snapshot_name).to eql(:pre)
+          expect(subject[2].path).to be_nil
+
+          expect(subject[3]).to be_a(Nanoc::Int::ProcessingActions::Layout)
+          expect(subject[3].layout_identifier).to eql('/default.*')
+          expect(subject[3].params).to be_nil
+
+          expect(subject[4]).to be_a(Nanoc::Int::ProcessingActions::Filter)
+          expect(subject[4].filter_name).to eql(:typohero)
+          expect(subject[4].params).to eql({})
+
+          expect(subject[5]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+          expect(subject[5].snapshot_name).to eql(:post)
+          expect(subject[5].path).to be_nil
+
+          expect(subject[6]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+          expect(subject[6].snapshot_name).to eql(:last)
+          expect(subject[6].path).to be_nil
+
+          expect(subject.size).to eql(7)
+        end
+      end
+
+      context 'no routing rule exists' do
+        before do
+          # Add compilation rule
+          compilation_rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :csv, proc {})
+          rules_collection.add_item_compilation_rule(compilation_rule)
+        end
+
+        example do
+          subject
+
+          expect(subject[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+          expect(subject[0].snapshot_name).to eql(:raw)
+          expect(subject[0].path).to be_nil
+
+          expect(subject[1]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+          expect(subject[1].snapshot_name).to eql(:last)
+          expect(subject[1].path).to be_nil
+
+          expect(subject.size).to eql(2)
+        end
+      end
+
+      context 'routing rule exists' do
+        before do
+          # Add compilation rule
+          compilation_rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :csv, proc {})
+          rules_collection.add_item_compilation_rule(compilation_rule)
+
+          # Add routing rule
+          routing_rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :csv, proc { '/foo.md' }, snapshot_name: :last)
+          rules_collection.add_item_routing_rule(routing_rule)
+        end
+
+        example do
+          subject
+
+          expect(subject[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+          expect(subject[0].snapshot_name).to eql(:raw)
+          expect(subject[0].path).to be_nil
+
+          expect(subject[1]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+          expect(subject[1].snapshot_name).to eql(:last)
+          expect(subject[1].path).to eq('/foo.md')
+
+          expect(subject.size).to eql(2)
+        end
+      end
+
+      context 'routing rule for other rep exists' do
+        before do
+          # Add compilation rule
+          compilation_rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :csv, proc {})
+          rules_collection.add_item_compilation_rule(compilation_rule)
+
+          # Add routing rule
+          routing_rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :abc, proc { '/foo.md' }, snapshot_name: :last)
+          rules_collection.add_item_routing_rule(routing_rule)
+        end
+
+        example do
+          subject
+
+          expect(subject[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+          expect(subject[0].snapshot_name).to eql(:raw)
+          expect(subject[0].path).to be_nil
+
+          expect(subject[1]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+          expect(subject[1].snapshot_name).to eql(:last)
+          expect(subject[1].path).to be_nil
+
+          expect(subject.size).to eql(2)
+        end
+      end
+    end
+
+    context 'with layout' do
+      let(:obj) { Nanoc::Int::Layout.new('content', {}, '/default.erb') }
+
+      context 'no rules exist' do
+        it 'raises error' do
+          error = Nanoc::RuleDSL::RuleMemoryCalculator::NoRuleMemoryForLayoutException
+          expect { subject }.to raise_error(error)
+        end
+      end
+
+      context 'rule exists' do
+        before do
+          pat = Nanoc::Int::Pattern.from('/*.erb')
+          rules_collection.layout_filter_mapping[pat] = [:erb, { x: 123 }]
+        end
+
+        it 'contains memory for the rule' do
+          expect(subject.size).to eql(1)
+          expect(subject[0]).to be_a(Nanoc::Int::ProcessingActions::Filter)
+          expect(subject[0].filter_name).to eql(:erb)
+          expect(subject[0].params).to eql(x: 123)
+        end
+      end
+    end
+
+    context 'with something else' do
+      let(:obj) { :donkey }
+
+      it 'errors' do
+        error = Nanoc::RuleDSL::RuleMemoryCalculator::UnsupportedObjectTypeException
+        expect { subject }.to raise_error(error)
+      end
+    end
+  end
+
+  describe '#snapshots_defs_for' do
+    subject { rule_memory_calculator.snapshots_defs_for(rep) }
+
+    let(:rep) { Nanoc::Int::ItemRep.new(item, :csv) }
+
+    let(:item) { Nanoc::Int::Item.new('content', {}, Nanoc::Identifier.from('/list.md')) }
+    let(:config) { Nanoc::Int::Configuration.new.with_defaults }
+    let(:items) { Nanoc::Int::IdentifiableCollection.new(config) }
+    let(:layouts) { Nanoc::Int::IdentifiableCollection.new(config) }
+    let(:site) { double(:site, items: items, layouts: layouts, config: config, compiler: compiler) }
+    let(:compiler) { double(:compiler, compilation_context: compilation_context) }
+    let(:compilation_context) { double(:compilation_context) }
+    let(:view_context) { double(:view_context) }
+
+    before do
+      rules_proc = proc do
+        filter :erb, speed: :over_9000
+        layout '/default.*'
+        filter :typohero
+      end
+      rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :csv, rules_proc)
+      rules_collection.add_item_compilation_rule(rule)
+
+      expect(compilation_context).to receive(:create_view_context).and_return(view_context)
+    end
+
+    example do
+      expect(subject[0]).to be_a(Nanoc::Int::SnapshotDef)
+      expect(subject[0].name).to eql(:raw)
+
+      expect(subject[1]).to be_a(Nanoc::Int::SnapshotDef)
+      expect(subject[1].name).to eql(:pre)
+
+      expect(subject[2]).to be_a(Nanoc::Int::SnapshotDef)
+      expect(subject[2].name).to eql(:post)
+
+      expect(subject[3]).to be_a(Nanoc::Int::SnapshotDef)
+      expect(subject[3].name).to eql(:last)
+
+      expect(subject.size).to eql(4)
+    end
+  end
+end

data/spec/nanoc/rule_dsl/rules_collection_spec.rb

@@ -0,0 +1,299 @@
+describe Nanoc::RuleDSL::RulesCollection do
+  let(:rules_collection) { described_class.new }
+
+  describe '#data' do
+    subject { rules_collection.data }
+
+    it 'is nil by default' do
+      expect(subject).to be_nil
+    end
+
+    it 'can be set' do
+      rules_collection.data = 'asdf'
+      expect(subject).to eq('asdf')
+    end
+  end
+
+  describe '#compilation_rule_for' do
+    let(:item) { Nanoc::Int::Item.new('content', {}, '/foo.md') }
+
+    let(:rep) { Nanoc::Int::ItemRep.new(item, rep_name) }
+
+    let(:rep_name) { :default }
+
+    subject { rules_collection.compilation_rule_for(rep) }
+
+    context 'no rules' do
+      it 'is nil' do
+        expect(subject).to be_nil
+      end
+    end
+
+    context 'some rules, none matching' do
+      before do
+        rules_collection.add_item_compilation_rule(rule)
+      end
+
+      let(:rule) do
+        Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/bar.*'), :default, proc {})
+      end
+
+      it 'is nil' do
+        expect(subject).to be_nil
+      end
+    end
+
+    context 'some rules, one matching' do
+      before do
+        rules_collection.add_item_compilation_rule(rule_a)
+        rules_collection.add_item_compilation_rule(rule_b)
+      end
+
+      let(:rule_a) do
+        Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/foo.*'), :default, proc {})
+      end
+
+      let(:rule_b) do
+        Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/bar.*'), :default, proc {})
+      end
+
+      context 'rep name does not match' do
+        let(:rep_name) { :platypus }
+
+        it 'is nil' do
+          expect(subject).to be_nil
+        end
+      end
+
+      context 'rep name matches' do
+        it 'is the rule' do
+          expect(subject).to equal(rule_a)
+        end
+      end
+    end
+
+    context 'some rules, multiple matching' do
+      before do
+        rules_collection.add_item_compilation_rule(rule_a)
+        rules_collection.add_item_compilation_rule(rule_b)
+        rules_collection.add_item_compilation_rule(rule_c)
+      end
+
+      let(:rule_a) do
+        Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/foo.*'), :default, proc {})
+      end
+
+      let(:rule_b) do
+        Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/*.*'), :default, proc {})
+      end
+
+      let(:rule_c) do
+        Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/*.*'), :foo, proc {})
+      end
+
+      context 'no rep name matches' do
+        let(:rep_name) { :platypus }
+
+        it 'is the first matching rule' do
+          expect(subject).to be_nil
+        end
+      end
+
+      context 'one rep name matches' do
+        let(:rep_name) { :foo }
+
+        it 'is the first matching rule' do
+          expect(subject).to equal(rule_c)
+        end
+      end
+
+      context 'multiple rep names match' do
+        it 'is the first matching rule' do
+          expect(subject).to equal(rule_a)
+        end
+      end
+    end
+  end
+
+  describe '#item_compilation_rules_for' do
+    let(:item) { Nanoc::Int::Item.new('content', {}, '/foo.md') }
+
+    subject { rules_collection.item_compilation_rules_for(item) }
+
+    context 'no rules' do
+      it 'is none' do
+        expect(subject).to be_empty
+      end
+    end
+
+    context 'some rules, none matching' do
+      before do
+        rules_collection.add_item_compilation_rule(rule)
+      end
+
+      let(:rule) do
+        Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/bar.*'), :default, proc {})
+      end
+
+      it 'is none' do
+        expect(subject).to be_empty
+      end
+    end
+
+    context 'some rules, one matching' do
+      before do
+        rules_collection.add_item_compilation_rule(rule_a)
+        rules_collection.add_item_compilation_rule(rule_b)
+      end
+
+      let(:rule_a) do
+        Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/foo.*'), :default, proc {})
+      end
+
+      let(:rule_b) do
+        Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/bar.*'), :default, proc {})
+      end
+
+      it 'is the single rule' do
+        expect(subject).to contain_exactly(rule_a)
+      end
+    end
+
+    context 'some rules, multiple matching' do
+      before do
+        rules_collection.add_item_compilation_rule(rule_a)
+        rules_collection.add_item_compilation_rule(rule_b)
+      end
+
+      let(:rule_a) do
+        Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/foo.*'), :default, proc {})
+      end
+
+      let(:rule_b) do
+        Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/*.*'), :default, proc {})
+      end
+
+      it 'is all matching rule' do
+        expect(subject).to contain_exactly(rule_a, rule_b)
+      end
+    end
+  end
+
+  describe '#routing_rules_for' do
+    let(:item) { Nanoc::Int::Item.new('content', {}, '/foo.md') }
+
+    let(:rep) { Nanoc::Int::ItemRep.new(item, :default) }
+
+    subject { rules_collection.routing_rules_for(rep) }
+
+    let(:rules) do
+      [
+        # Matching item, matching rep
+        Nanoc::RuleDSL::Rule.new(
+          Nanoc::Int::Pattern.from('/foo.*'), :default, proc {}, snapshot_name: :a
+        ),
+        Nanoc::RuleDSL::Rule.new(
+          Nanoc::Int::Pattern.from('/foo.*'), :default, proc {}, snapshot_name: :b
+        ),
+
+        # Matching item, non-matching rep
+        Nanoc::RuleDSL::Rule.new(
+          Nanoc::Int::Pattern.from('/foo.*'), :raw, proc {}, snapshot_name: :a
+        ),
+        Nanoc::RuleDSL::Rule.new(
+          Nanoc::Int::Pattern.from('/foo.*'), :raw, proc {}, snapshot_name: :b
+        ),
+
+        # Non-matching item, matching rep
+        Nanoc::RuleDSL::Rule.new(
+          Nanoc::Int::Pattern.from('/bar.*'), :default, proc {}, snapshot_name: :a
+        ),
+        Nanoc::RuleDSL::Rule.new(
+          Nanoc::Int::Pattern.from('/bar.*'), :default, proc {}, snapshot_name: :b
+        ),
+
+        # Non-matching item, non-matching rep
+        Nanoc::RuleDSL::Rule.new(
+          Nanoc::Int::Pattern.from('/bar.*'), :raw, proc {}, snapshot_name: :a
+        ),
+        Nanoc::RuleDSL::Rule.new(
+          Nanoc::Int::Pattern.from('/bar.*'), :raw, proc {}, snapshot_name: :b
+        ),
+
+        # Matching item, matching rep, but not the first
+        Nanoc::RuleDSL::Rule.new(
+          Nanoc::Int::Pattern.from('/*.*'), :default, proc {}, snapshot_name: :a
+        ),
+        Nanoc::RuleDSL::Rule.new(
+          Nanoc::Int::Pattern.from('/*.*'), :default, proc {}, snapshot_name: :b
+        ),
+      ]
+    end
+
+    before do
+      rules.each do |rule|
+        rules_collection.add_item_routing_rule(rule)
+      end
+    end
+
+    it 'returns the first matching rule for every snapshot' do
+      expect(subject).to eq(
+        a: rules[0],
+        b: rules[1],
+      )
+    end
+  end
+
+  describe '#filter_for_layout' do
+    let(:layout) { Nanoc::Int::Layout.new('Some content', {}, '/foo.md') }
+
+    subject { rules_collection.filter_for_layout(layout) }
+
+    let(:mapping) { {} }
+
+    before do
+      mapping.each_pair do |key, value|
+        rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(key)] = value
+      end
+    end
+
+    context 'no rules' do
+      it { is_expected.to be_nil }
+    end
+
+    context 'one non-matching rule' do
+      let(:mapping) do
+        {
+          '/default.*' => [:erb, {}],
+        }
+      end
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'one matching rule' do
+      let(:mapping) do
+        {
+          '/foo.*' => [:erb, {}],
+        }
+      end
+
+      it 'is the single one' do
+        expect(subject).to eq([:erb, {}])
+      end
+    end
+
+    context 'multiple matching rules' do
+      let(:mapping) do
+        {
+          '/foo.*' => [:erb, {}],
+          '/*' => [:haml, {}],
+        }
+      end
+
+      it 'is the first one' do
+        expect(subject).to eq([:erb, {}])
+      end
+    end
+  end
+end