nanoc 4.8.12 → 4.8.13

data/spec/nanoc/rule_dsl/recording_executor_spec.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::RuleDSL::RecordingExecutor do
-  let(:executor) { described_class.new(rep) }
-
-  let(:action_sequence) { executor.action_sequence }
-  let(:item) { Nanoc::Int::Item.new('stuff', {}, '/foo.md') }
-  let(:rep) { Nanoc::Int::ItemRep.new(item, :default) }
-
-  describe '#filter' do
-    it 'records filter call without arguments' do
-      executor.filter(:erb)
-
-      expect(action_sequence.size).to eql(1)
-      expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Filter)
-      expect(action_sequence[0].filter_name).to eql(:erb)
-      expect(action_sequence[0].params).to eql({})
-    end
-
-    it 'records filter call with arguments' do
-      executor.filter(:erb, x: 123)
-
-      expect(action_sequence.size).to eql(1)
-      expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Filter)
-      expect(action_sequence[0].filter_name).to eql(:erb)
-      expect(action_sequence[0].params).to eql(x: 123)
-    end
-  end
-
-  describe '#layout' do
-    it 'records layout call without arguments' do
-      executor.layout('/default.*')
-
-      expect(action_sequence.size).to eql(2)
-
-      expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
-      expect(action_sequence[0].snapshot_names).to eql([:pre])
-      expect(action_sequence[0].paths).to be_empty
-
-      expect(action_sequence[1]).to be_a(Nanoc::Int::ProcessingActions::Layout)
-      expect(action_sequence[1].layout_identifier).to eql('/default.*')
-      expect(action_sequence[1].params).to eql({})
-    end
-
-    it 'records layout call with arguments' do
-      executor.layout('/default.*', donkey: 123)
-
-      expect(action_sequence.size).to eql(2)
-
-      expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
-      expect(action_sequence[0].snapshot_names).to eql([:pre])
-      expect(action_sequence[0].paths).to be_empty
-
-      expect(action_sequence[1]).to be_a(Nanoc::Int::ProcessingActions::Layout)
-      expect(action_sequence[1].layout_identifier).to eql('/default.*')
-      expect(action_sequence[1].params).to eql(donkey: 123)
-    end
-
-    it 'fails when passed a symbol' do
-      expect { executor.layout(:default, donkey: 123) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#snapshot' do
-    context 'snapshot already exists' do
-      before do
-        executor.snapshot(:foo)
-      end
-
-      it 'raises when creating same snapshot' do
-        expect { executor.snapshot(:foo) }
-          .to raise_error(Nanoc::Int::Errors::CannotCreateMultipleSnapshotsWithSameName)
-      end
-    end
-
-    context 'no arguments' do
-      subject { executor.snapshot(:foo) }
-
-      it 'records' do
-        subject
-        expect(action_sequence.size).to eql(1)
-        expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
-        expect(action_sequence[0].snapshot_names).to eql([:foo])
-        expect(action_sequence[0].paths).to be_empty
-      end
-    end
-
-    context 'final argument' do
-      subject { executor.snapshot(:foo, path: path) }
-      let(:path) { nil }
-
-      context 'routing rule does not exist' do
-        context 'no explicit path given' do
-          it 'records' do
-            subject
-            expect(action_sequence.size).to eql(1)
-            expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
-            expect(action_sequence[0].snapshot_names).to eql([:foo])
-            expect(action_sequence[0].paths).to be_empty
-          end
-        end
-
-        context 'explicit path given as string' do
-          let(:path) { '/routed-foo.html' }
-
-          it 'records' do
-            subject
-            expect(action_sequence.size).to eql(1)
-            expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
-            expect(action_sequence[0].snapshot_names).to eql([:foo])
-            expect(action_sequence[0].paths).to eql(['/routed-foo.html'])
-          end
-        end
-
-        context 'explicit path given as identifier' do
-          let(:path) { Nanoc::Identifier.from('/routed-foo.html') }
-
-          it 'records' do
-            subject
-            expect(action_sequence.size).to eql(1)
-            expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
-            expect(action_sequence[0].snapshot_names).to eql([:foo])
-            expect(action_sequence[0].paths).to eql(['/routed-foo.html'])
-          end
-        end
-      end
-    end
-
-    it 'raises when given unknown arguments' do
-      expect { executor.snapshot(:foo, animal: 'giraffe') }
-        .to raise_error(ArgumentError)
-    end
-
-    it 'can create multiple snapshots with different names' do
-      executor.snapshot(:foo)
-      executor.snapshot(:bar)
-
-      expect(action_sequence.size).to eql(2)
-      expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
-      expect(action_sequence[0].snapshot_names).to eql([:foo])
-      expect(action_sequence[1]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
-      expect(action_sequence[1].snapshot_names).to eql([:bar])
-    end
-  end
-end

data/spec/nanoc/rule_dsl/rule_context_spec.rb

@@ -1,251 +0,0 @@
-# frozen_string_literal: true
-
-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::ItemCollection.new(config) }
-  let(:layouts) { Nanoc::Int::LayoutCollection.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) do
-    Nanoc::ViewContextForCompilation.new(
-      reps:                Nanoc::Int::ItemRepRepo.new,
-      items:               items,
-      dependency_tracker:  dependency_tracker,
-      compilation_context: compilation_context,
-      snapshot_repo:       snapshot_repo,
-    )
-  end
-
-  let(:dependency_tracker) { double(:dependency_tracker) }
-  let(:snapshot_repo) { double(:snapshot_repo) }
-
-  describe '#initialize' do
-    it 'wraps objects in view classes' do
-      expect(subject.rep.class).to eql(Nanoc::BasicItemRepView)
-      expect(subject.item.class).to eql(Nanoc::BasicItemView)
-      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::BasicItemView)
-    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) }
-
-      let(:items) do
-        Nanoc::Int::ItemCollection.new(config, [item, parent, 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::BasicItemView)
-        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::BasicItemView])
-        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) }
-
-    let(:items) do
-      Nanoc::Int::ItemCollection.new(config, [item, parent, 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
-      allow(dependency_tracker).to receive(:bounce).and_return(nil)
-
-      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
-    context 'with path' do
-      context 'calling once' do
-        subject { rule_context.write('/foo.html') }
-
-        it 'makes a request to the executor' do
-          expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
-          subject
-        end
-      end
-
-      context 'calling twice' do
-        subject do
-          rule_context.write('/foo.html')
-          rule_context.write('/bar.html')
-        end
-
-        it 'makes two requests to the executor with unique snapshot names' do
-          expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
-          expect(executor).to receive(:snapshot).with(:_1, path: '/bar.html')
-          subject
-        end
-      end
-    end
-
-    context 'with :ext, without period' do
-      context 'calling once' do
-        subject { rule_context.write(ext: 'html') }
-
-        it 'makes a request to the executor' do
-          expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
-          subject
-        end
-      end
-
-      context 'calling twice' do
-        subject do
-          rule_context.write(ext: 'html')
-          rule_context.write(ext: 'htm')
-        end
-
-        it 'makes a request to the executor' do
-          expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
-          expect(executor).to receive(:snapshot).with(:_1, path: '/foo.htm')
-          subject
-        end
-      end
-    end
-
-    context 'with :ext, without period' do
-      context 'calling once' do
-        subject { rule_context.write(ext: '.html') }
-
-        it 'makes a request to the executor' do
-          expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
-          subject
-        end
-      end
-
-      context 'calling twice' do
-        subject do
-          rule_context.write(ext: '.html')
-          rule_context.write(ext: '.htm')
-        end
-
-        it 'makes a request to the executor' do
-          expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
-          expect(executor).to receive(:snapshot).with(:_1, path: '/foo.htm')
-          subject
-        end
-      end
-    end
-  end
-end

data/spec/nanoc/rule_dsl/rule_spec.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::RuleDSL::Rule do
-  subject(:rule) do
-    Nanoc::RuleDSL::Rule.new(pattern, :xml, block)
-  end
-
-  let(:pattern) { Nanoc::Int::Pattern.from(%r{/(.*)/(.*)/}) }
-  let(:block) { proc {} }
-
-  describe '#matches' do
-    subject { rule.send(:matches, identifier) }
-
-    context 'does not match' do
-      let(:identifier) { '/moo/' }
-      it { is_expected.to be_nil }
-    end
-
-    context 'matches' do
-      let(:identifier) { '/anything/else/' }
-      it { is_expected.to eql(%w[anything else]) }
-    end
-  end
-
-  describe '#initialize' do
-    context 'with snapshot_name' do
-      subject { Nanoc::RuleDSL::Rule.new(pattern, :xml, proc {}, snapshot_name: :donkey) }
-
-      its(:rep_name) { is_expected.to eql(:xml) }
-      its(:pattern) { is_expected.to eql(pattern) }
-      its(:snapshot_name) { is_expected.to eql(:donkey) }
-    end
-
-    context 'without snapshot_name' do
-      subject { Nanoc::RuleDSL::Rule.new(pattern, :xml, proc {}) }
-
-      its(:rep_name) { is_expected.to eql(:xml) }
-      its(:pattern) { is_expected.to eql(pattern) }
-      its(:snapshot_name) { is_expected.to be_nil }
-    end
-  end
-
-  describe '#applicable_to?' do
-    subject { rule.applicable_to?(item) }
-
-    let(:item) { Nanoc::Int::Item.new('', {}, '/foo.md') }
-
-    context 'pattern matches' do
-      let(:pattern) { Nanoc::Int::Pattern.from(%r{^/foo.*}) }
-      it { is_expected.to be }
-    end
-
-    context 'pattern does not match' do
-      let(:pattern) { Nanoc::Int::Pattern.from(%r{^/bar.*}) }
-      it { is_expected.not_to be }
-    end
-  end
-
-  describe '#apply_to' do
-    subject { rule.apply_to(rep, site: site, executor: executor, view_context: view_context) }
-
-    let(:block) do
-      proc { self }
-    end
-
-    let(:item) { Nanoc::Int::Item.new('', {}, '/foo.md') }
-    let(:rep) { Nanoc::Int::ItemRep.new(item, :amazings) }
-
-    let(:site) { Nanoc::Int::Site.new(config: config, data_source: data_source, code_snippets: []) }
-    let(:data_source) { Nanoc::Int::InMemDataSource.new(items, layouts) }
-    let(:config) { Nanoc::Int::Configuration.new }
-    let(:executor) { nil }
-    let(:view_context) { Nanoc::ViewContextForPreCompilation.new(items: items) }
-    let(:items) { Nanoc::Int::ItemCollection.new(config, []) }
-    let(:layouts) { Nanoc::Int::LayoutCollection.new(config, []) }
-
-    it 'returns a rule context' do
-      expect(subject).to be_a(Nanoc::RuleDSL::RuleContext)
-    end
-
-    it 'makes rep accessible' do
-      expect(subject.instance_eval { rep }.unwrap).to eql(rep)
-      expect(subject.instance_eval { @rep }.unwrap).to eql(rep)
-    end
-
-    it 'makes item_rep accessible' do
-      expect(subject.instance_eval { item_rep }.unwrap).to eql(rep)
-      expect(subject.instance_eval { @item_rep }.unwrap).to eql(rep)
-    end
-
-    it 'makes item accessible' do
-      expect(subject.instance_eval { item }.unwrap).to eql(item)
-      expect(subject.instance_eval { @item }.unwrap).to eql(item)
-    end
-
-    it 'makes items accessible' do
-      expect(subject.instance_eval { items }.unwrap).to eql(items)
-      expect(subject.instance_eval { @items }.unwrap).to eql(items)
-    end
-
-    it 'makes layouts accessible' do
-      expect(subject.instance_eval { layouts }.unwrap).to eql(layouts)
-      expect(subject.instance_eval { @layouts }.unwrap).to eql(layouts)
-    end
-
-    it 'makes config accessible' do
-      expect(subject.instance_eval { config }.unwrap).to eql(config)
-      expect(subject.instance_eval { @config }.unwrap).to eql(config)
-    end
-  end
-end