nanoc 4.8.12 → 4.8.13

data/spec/nanoc/rule_dsl/rules_collection_spec.rb

@@ -1,301 +0,0 @@
-# frozen_string_literal: true
-
-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

data/spec/nanoc/spec_spec.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Spec::HelperContext do
-  let(:helper) do
-    Module.new {}
-  end
-
-  subject(:ctx) { described_class.new(helper) }
-
-  it 'has no items by default' do
-    # TODO: Add #empty? to item collection view
-    expect(subject.items.size).to eq(0)
-  end
-
-  it 'has no layouts by default' do
-    # TODO: Add #empty? to item collection view
-    expect(subject.layouts.size).to eq(0)
-  end
-
-  describe '#create_item' do
-    subject { ctx.create_item('foo', {}, '/foo.md') }
-
-    it 'creates item' do
-      expect { subject }
-        .to change { ctx.items.size }
-        .from(0).to(1)
-    end
-
-    it 'creates item without reps' do
-      subject
-      expect(ctx.items['/foo.md'].reps.size).to eq(0)
-    end
-
-    it 'returns self' do
-      expect(subject).to eq(ctx)
-    end
-  end
-
-  describe '#create_layout' do
-    subject { ctx.create_layout('foo', {}, '/foo.md') }
-
-    it 'creates layout' do
-      expect { subject }
-        .to change { ctx.layouts.size }
-        .from(0).to(1)
-    end
-
-    it 'returns self' do
-      expect(subject).to eq(ctx)
-    end
-  end
-
-  describe '#create_rep' do
-    before do
-      ctx.create_item('foo', {}, '/foo.md')
-    end
-
-    subject { ctx.create_rep(ctx.items['/foo.md'], '/foo.html') }
-
-    it 'creates rep' do
-      expect { subject }
-        .to change { ctx.items['/foo.md'].reps.size }
-        .from(0).to(1)
-    end
-
-    it 'returns self' do
-      expect(subject).to eq(ctx)
-    end
-  end
-end

data/spec/nanoc/telemetry/counter_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Telemetry::Counter do
-  subject(:counter) { described_class.new }
-
-  it 'starts at 0' do
-    expect(counter.value).to eq(0)
-  end
-
-  describe '#increment' do
-    subject { counter.increment }
-
-    it 'increments' do
-      expect { subject }
-        .to change { counter.value }
-        .from(0)
-        .to(1)
-    end
-  end
-end

data/spec/nanoc/telemetry/labelled_counter_spec.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Telemetry::LabelledCounter do
-  subject(:counter) { described_class.new }
-
-  describe 'new counter' do
-    it 'starts at 0' do
-      expect(subject.value(:erb)).to eq(0)
-      expect(subject.value(:haml)).to eq(0)
-    end
-
-    it 'has no values' do
-      expect(subject.values).to eq({})
-    end
-  end
-
-  describe '#increment' do
-    subject { counter.increment(:erb) }
-
-    it 'increments the matching value' do
-      expect { subject }
-        .to change { counter.value(:erb) }
-        .from(0)
-        .to(1)
-    end
-
-    it 'does not increment any other value' do
-      expect(counter.value(:haml)).to eq(0)
-      expect { subject }
-        .not_to change { counter.value(:haml) }
-    end
-
-    it 'correctly changes #values' do
-      expect { subject }
-        .to change { counter.values }
-        .from({})
-        .to(erb: 1)
-    end
-  end
-
-  describe '#get' do
-    subject { counter.get(:erb) }
-
-    context 'not incremented' do
-      its(:value) { is_expected.to eq(0) }
-    end
-
-    context 'incremented' do
-      before { counter.increment(:erb) }
-      its(:value) { is_expected.to eq(1) }
-    end
-
-    context 'other incremented' do
-      before { counter.increment(:haml) }
-      its(:value) { is_expected.to eq(0) }
-    end
-  end
-
-  describe '#empty?' do
-    subject { counter.empty? }
-
-    context 'not incremented' do
-      it { is_expected.to be }
-    end
-
-    context 'incremented' do
-      before { counter.increment(:erb) }
-      it { is_expected.not_to be }
-    end
-  end
-
-  describe '#map' do
-    subject { counter.map { |label, counter| [label, counter.value] } }
-
-    context 'not incremented' do
-      it { is_expected.to be_empty }
-    end
-
-    context 'incremented once' do
-      before { counter.increment(:erb) }
-      it { is_expected.to eq [[:erb, 1]] }
-    end
-
-    context 'both incremental multiple times' do
-      before do
-        counter.increment(:erb)
-        counter.increment(:erb)
-        counter.increment(:haml)
-      end
-
-      it { is_expected.to eq [[:erb, 2], [:haml, 1]] }
-    end
-  end
-end