nanoc 4.8.12 → 4.8.13

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

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-describe(Nanoc::Int::ItemRepRouter) do
-  subject(:item_rep_router) { described_class.new(reps, action_provider, site) }
-
-  let(:reps) { double(:reps) }
-  let(:action_provider) { double(:action_provider) }
-  let(:site) { double(:site, config: config) }
-  let(:config) { Nanoc::Int::Configuration.new.with_defaults }
-
-  describe '#run' do
-    subject { item_rep_router.run }
-
-    let(:item) { Nanoc::Int::Item.new('content', {}, '/foo.md') }
-
-    let(:reps) do
-      [
-        Nanoc::Int::ItemRep.new(item, :default),
-        Nanoc::Int::ItemRep.new(item, :csv),
-      ]
-    end
-
-    let(:memory_without_paths) do
-      actions =
-        [
-          Nanoc::Int::ProcessingActions::Filter.new(:erb, {}),
-          Nanoc::Int::ProcessingActions::Snapshot.new([], []),
-        ]
-
-      Nanoc::Int::ActionSequence.new(nil, actions: actions)
-    end
-
-    let(:action_sequence_for_default) do
-      actions =
-        [
-          Nanoc::Int::ProcessingActions::Filter.new(:erb, {}),
-          Nanoc::Int::ProcessingActions::Snapshot.new([:last], ['/foo/index.html']),
-        ]
-
-      Nanoc::Int::ActionSequence.new(nil, actions: actions)
-    end
-
-    let(:action_sequence_for_csv) do
-      actions =
-        [
-          Nanoc::Int::ProcessingActions::Filter.new(:erb, {}),
-          Nanoc::Int::ProcessingActions::Snapshot.new([:last], ['/foo.csv']),
-        ]
-
-      Nanoc::Int::ActionSequence.new(nil, actions: actions)
-    end
-
-    example do
-      allow(action_provider).to receive(:action_sequence_for).with(reps[0]).and_return(action_sequence_for_default)
-      allow(action_provider).to receive(:action_sequence_for).with(reps[1]).and_return(action_sequence_for_csv)
-
-      subject
-
-      expect(reps[0].raw_paths).to eql(last: ['output/foo/index.html'])
-      expect(reps[0].paths).to eql(last: ['/foo/'])
-
-      expect(reps[1].raw_paths).to eql(last: ['output/foo.csv'])
-      expect(reps[1].paths).to eql(last: ['/foo.csv'])
-    end
-
-    it 'picks the paths last returned' do
-      allow(action_provider).to receive(:action_sequence_for)
-        .with(reps[0]).and_return(memory_without_paths, action_sequence_for_default)
-      allow(action_provider).to receive(:action_sequence_for)
-        .with(reps[1]).and_return(memory_without_paths, action_sequence_for_csv)
-
-      subject
-
-      expect(reps[0].raw_paths).to eql(last: ['output/foo/index.html'])
-      expect(reps[0].paths).to eql(last: ['/foo/'])
-
-      expect(reps[1].raw_paths).to eql(last: ['output/foo.csv'])
-      expect(reps[1].paths).to eql(last: ['/foo.csv'])
-    end
-  end
-
-  describe '#route_rep' do
-    subject { item_rep_router.route_rep(rep, paths, snapshot_names, paths_to_reps) }
-
-    let(:snapshot_names) { [:foo] }
-    let(:rep) { Nanoc::Int::ItemRep.new(item, :default) }
-    let(:item) { Nanoc::Int::Item.new('content', {}, '/foo.md') }
-    let(:paths_to_reps) { {} }
-
-    context 'basic path is nil' do
-      let(:paths) { [] }
-
-      it 'assigns no paths' do
-        subject
-        expect(rep.raw_paths[:foo]).to be_empty
-      end
-    end
-
-    context 'basic path is not nil' do
-      let(:paths) { ['/foo/index.html'] }
-
-      context 'other snapshot with this path already exists' do
-        let(:paths_to_reps) { { '/foo/index.html' => Nanoc::Int::ItemRep.new(item, :other) } }
-
-        it 'errors' do
-          expect { subject }.to raise_error(Nanoc::Int::ItemRepRouter::IdenticalRoutesError)
-        end
-      end
-
-      context 'path is unique' do
-        context 'single path' do
-          it 'sets the raw path' do
-            subject
-            expect(rep.raw_paths).to eql(foo: ['output/foo/index.html'])
-          end
-
-          it 'sets the path' do
-            subject
-            expect(rep.paths).to eql(foo: ['/foo/'])
-          end
-
-          it 'adds to paths_to_reps' do
-            subject
-            expect(paths_to_reps).to have_key('/foo/index.html')
-          end
-
-          context 'path does not start with a slash' do
-            let(:paths) { ['foo/index.html'] }
-
-            it 'errors' do
-              expect { subject }.to raise_error(Nanoc::Int::ItemRepRouter::RouteWithoutSlashError)
-            end
-          end
-
-          context 'path is not UTF-8' do
-            let(:paths) { ['/foo/index.html'.encode('ISO-8859-1')] }
-
-            it 'sets the path as UTF-8' do
-              subject
-              expect(rep.paths).to eql(foo: ['/foo/'])
-              expect(rep.paths[:foo].first.encoding.to_s).to eql('UTF-8')
-            end
-
-            it 'sets the raw path as UTF-8' do
-              subject
-              expect(rep.raw_paths).to eql(foo: ['output/foo/index.html'])
-              expect(rep.raw_paths[:foo].first.encoding.to_s).to eql('UTF-8')
-            end
-          end
-        end
-
-        context 'multiple paths' do
-          let(:paths) { ['/foo/index.html', '/bar/index.html'] }
-
-          it 'sets the raw paths' do
-            subject
-            expect(rep.raw_paths).to eql(foo: ['output/foo/index.html', 'output/bar/index.html'])
-          end
-
-          it 'sets the paths' do
-            subject
-            expect(rep.paths).to eql(foo: ['/foo/', '/bar/'])
-          end
-
-          it 'adds to paths_to_reps' do
-            subject
-            expect(paths_to_reps).to have_key('/foo/index.html')
-            expect(paths_to_reps).to have_key('/bar/index.html')
-          end
-        end
-      end
-    end
-  end
-
-  describe '#strip_index_filename' do
-    subject { item_rep_router.strip_index_filename(basic_path) }
-
-    context 'basic path ends with /index.html' do
-      let(:basic_path) { '/bar/index.html' }
-      it { is_expected.to eql('/bar/') }
-    end
-
-    context 'basic path contains /index.html' do
-      let(:basic_path) { '/bar/index.html/foo' }
-      it { is_expected.to eql('/bar/index.html/foo') }
-    end
-
-    context 'basic path ends with xindex.html' do
-      let(:basic_path) { '/bar/xindex.html' }
-      it { is_expected.to eql('/bar/xindex.html') }
-    end
-
-    context 'basic path does not contain /index.html' do
-      let(:basic_path) { '/bar/foo.html' }
-      it { is_expected.to eql('/bar/foo.html') }
-    end
-  end
-end

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

@@ -1,227 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::ItemRepSelector do
-  let(:selector) { described_class.new(reps_for_selector) }
-
-  let(:item) do
-    Nanoc::Int::Item.new('stuff', {}, '/foo.md')
-  end
-
-  let(:reps_array) do
-    [
-      Nanoc::Int::ItemRep.new(item, :a),
-      Nanoc::Int::ItemRep.new(item, :b),
-      Nanoc::Int::ItemRep.new(item, :c),
-      Nanoc::Int::ItemRep.new(item, :d),
-      Nanoc::Int::ItemRep.new(item, :e),
-    ]
-  end
-
-  let(:reps_for_selector) { reps_array }
-
-  let(:names_to_reps) do
-    reps_array.each_with_object({}) do |rep, acc|
-      acc[rep.name] = rep
-    end
-  end
-
-  let(:dependencies) { {} }
-
-  let(:result) do
-    tentatively_yielded = []
-    successfully_yielded = []
-    selector.each do |rep|
-      tentatively_yielded << rep.name
-
-      dependencies.fetch(rep.name, []).each do |name|
-        unless successfully_yielded.include?(name)
-          raise Nanoc::Int::Errors::UnmetDependency.new(names_to_reps[name])
-        end
-      end
-
-      successfully_yielded << rep.name
-    end
-
-    [tentatively_yielded, successfully_yielded]
-  end
-
-  let(:tentatively_yielded) { result[0] }
-  let(:successfully_yielded) { result[1] }
-
-  describe 'error' do
-    context 'plain error' do
-      subject { selector.each { |_rep| raise 'heh' } }
-
-      it 'raises' do
-        expect { subject }.to raise_error(RuntimeError, 'heh')
-      end
-    end
-
-    context 'plain dependency error' do
-      subject do
-        idx = 0
-        selector.each do |_rep|
-          idx += 1
-
-          raise Nanoc::Int::Errors::UnmetDependency.new(reps_array[2]) if idx == 1
-        end
-      end
-
-      it 'does not raise' do
-        expect { subject }.not_to raise_error
-      end
-    end
-
-    context 'wrapped error' do
-      subject do
-        selector.each do |rep|
-          begin
-            raise 'heh'
-          rescue => e
-            raise Nanoc::Int::Errors::CompilationError.new(e, rep)
-          end
-        end
-      end
-
-      it 'raises original error' do
-        expect { subject }.to raise_error(Nanoc::Int::Errors::CompilationError) do |err|
-          expect(err.unwrap).to be_a(RuntimeError)
-          expect(err.unwrap.message).to eq('heh')
-        end
-      end
-    end
-
-    context 'wrapped dependency error' do
-      subject do
-        idx = 0
-        selector.each do |rep|
-          idx += 1
-
-          begin
-            raise Nanoc::Int::Errors::UnmetDependency.new(reps_array[2]) if idx == 1
-          rescue => e
-            raise Nanoc::Int::Errors::CompilationError.new(e, rep)
-          end
-        end
-      end
-
-      it 'does not raise' do
-        expect { subject }.not_to raise_error
-      end
-    end
-  end
-
-  describe 'cycle' do
-    context 'dependency on self' do
-      subject do
-        selector.each { |r| raise Nanoc::Int::Errors::UnmetDependency.new(r) }
-      end
-
-      example do
-        expect { subject }.to raise_error(Nanoc::Int::Errors::DependencyCycle, <<~EOS)
-          The site cannot be compiled because there is a dependency cycle:
-
-              (1) item /foo.md, rep :a, uses compiled content of (1)
-          EOS
-      end
-    end
-
-    context 'cycle with three dependencies' do
-      subject do
-        selector.each do |r|
-          case r
-          when reps_array[0]
-            raise Nanoc::Int::Errors::UnmetDependency.new(reps_array[1])
-          when reps_array[1]
-            raise Nanoc::Int::Errors::UnmetDependency.new(reps_array[2])
-          when reps_array[2]
-            raise Nanoc::Int::Errors::UnmetDependency.new(reps_array[0])
-          end
-        end
-      end
-
-      example do
-        expect { subject }.to raise_error(Nanoc::Int::Errors::DependencyCycle, <<~EOS)
-          The site cannot be compiled because there is a dependency cycle:
-
-              (1) item /foo.md, rep :a, uses compiled content of
-              (2) item /foo.md, rep :b, uses compiled content of
-              (3) item /foo.md, rep :c, uses compiled content of (1)
-          EOS
-      end
-    end
-  end
-
-  describe 'yield order' do
-    context 'linear dependencies' do
-      let(:dependencies) do
-        {
-          a: [:b],
-          b: [:c],
-          c: [:d],
-          d: [:e],
-          e: [],
-        }
-      end
-
-      example do
-        expect(successfully_yielded).to eq %i[e d c b a]
-        expect(tentatively_yielded).to eq %i[a b c d e d c b a]
-      end
-    end
-
-    context 'no dependencies' do
-      let(:dependencies) do
-        {}
-      end
-
-      example do
-        expect(successfully_yielded).to eq %i[a b c d e]
-        expect(tentatively_yielded).to eq %i[a b c d e]
-      end
-    end
-
-    context 'star dependencies' do
-      let(:dependencies) do
-        {
-          a: %i[b c d e],
-        }
-      end
-
-      example do
-        expect(successfully_yielded).to eq %i[b c d e a]
-        expect(tentatively_yielded).to eq %i[a b a c a d a e a]
-      end
-    end
-
-    context 'star dependencies; selectively recompiling' do
-      let(:reps_for_selector) { reps_array.first(1) }
-
-      let(:dependencies) do
-        {
-          a: %i[b c d e],
-        }
-      end
-
-      example do
-        expect(successfully_yielded).to eq %i[b c d e a]
-        expect(tentatively_yielded).to eq %i[a b a c a d a e a]
-      end
-    end
-
-    context 'unrelated roots' do
-      let(:dependencies) do
-        {
-          a: [:d],
-          b: [:e],
-          c: [],
-        }
-      end
-
-      it 'picks prioritised roots' do
-        expect(successfully_yielded).to eq %i[d a e b c]
-        expect(tentatively_yielded).to eq %i[a d a b e b c]
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::NotificationCenter do
-  it 'receives notification after subscribing' do
-    ping_received = false
-    Nanoc::Int::NotificationCenter.on :ping_received, :test do
-      ping_received = true
-    end
-
-    Nanoc::Int::NotificationCenter.post :ping_received
-    expect(ping_received).to be
-  end
-
-  it 'does not receive notification after unsubscribing' do
-    ping_received = false
-    Nanoc::Int::NotificationCenter.on :ping_received, :test do
-      ping_received = true
-    end
-
-    Nanoc::Int::NotificationCenter.remove :ping_received, :test
-
-    Nanoc::Int::NotificationCenter.post :ping_received
-    expect(ping_received).not_to be
-  end
-end