nanoc 4.8.12 → 4.8.13

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

@@ -1,209 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::IdentifiableCollection do
-  shared_examples 'a generic identifiable collection' do
-    subject(:identifiable_collection) { described_class.new(config, objects) }
-
-    let(:config) { Nanoc::Int::Configuration.new }
-    let(:objects) { [] }
-
-    describe '#reject' do
-      subject { identifiable_collection.reject { |_| false } }
-
-      it { is_expected.to be_a(described_class) }
-    end
-
-    describe '#inspect' do
-      subject { identifiable_collection.inspect }
-
-      it { is_expected.to eq("<#{described_class}>") }
-    end
-
-    describe '#[]' do
-      let(:objects) do
-        [
-          Nanoc::Int::Item.new('asdf', {}, Nanoc::Identifier.new('/one')),
-          Nanoc::Int::Item.new('asdf', {}, Nanoc::Identifier.new('/two')),
-        ]
-      end
-
-      context 'string pattern style is glob' do
-        let(:config) { Nanoc::Int::Configuration.new.with_defaults }
-
-        it 'handles glob' do
-          expect(identifiable_collection['/on*']).to equal(objects[0])
-          expect(identifiable_collection['/*wo']).to equal(objects[1])
-        end
-      end
-
-      context 'string pattern style is glob' do
-        let(:config) { Nanoc::Int::Configuration.new }
-
-        it 'does not handle glob' do
-          expect(identifiable_collection['/on*']).to be_nil
-          expect(identifiable_collection['/*wo']).to be_nil
-        end
-      end
-
-      it 'handles identifier' do
-        expect(identifiable_collection['/one']).to equal(objects[0])
-        expect(identifiable_collection['/two']).to equal(objects[1])
-      end
-
-      it 'handles malformed identifier' do
-        expect(identifiable_collection['one/']).to be_nil
-        expect(identifiable_collection['/one/']).to be_nil
-        expect(identifiable_collection['one']).to be_nil
-        expect(identifiable_collection['//one']).to be_nil
-        expect(identifiable_collection['/one//']).to be_nil
-      end
-
-      it 'handles regex' do
-        expect(identifiable_collection[/one/]).to equal(objects[0])
-        expect(identifiable_collection[/on/]).to equal(objects[0])
-        expect(identifiable_collection[/\/o/]).to equal(objects[0])
-        expect(identifiable_collection[/e$/]).to equal(objects[0])
-      end
-
-      context 'frozen' do
-        before { identifiable_collection.freeze }
-
-        example do
-          expect(identifiable_collection['/one']).to equal(objects[0])
-          expect(identifiable_collection['/fifty']).to be_nil
-        end
-      end
-    end
-
-    describe '#find_all' do
-      let(:objects) do
-        [
-          double(:identifiable, identifier: Nanoc::Identifier.new('/about.css')),
-          double(:identifiable, identifier: Nanoc::Identifier.new('/about.md')),
-          double(:identifiable, identifier: Nanoc::Identifier.new('/style.css')),
-        ]
-      end
-
-      let(:arg) { raise 'override me' }
-
-      subject { identifiable_collection.find_all(arg) }
-
-      context 'with string' do
-        let(:arg) { '/*.css' }
-
-        it 'contains objects' do
-          expect(subject.size).to eql(2)
-          expect(subject.find { |iv| iv.identifier == '/about.css' }).to eq(objects[0])
-          expect(subject.find { |iv| iv.identifier == '/style.css' }).to eq(objects[2])
-        end
-      end
-
-      context 'with regex' do
-        let(:arg) { %r{\.css\z} }
-
-        it 'contains objects' do
-          expect(subject.size).to eql(2)
-          expect(subject.find { |iv| iv.identifier == '/about.css' }).to eq(objects[0])
-          expect(subject.find { |iv| iv.identifier == '/style.css' }).to eq(objects[2])
-        end
-      end
-    end
-
-    describe '#object_with_identifier' do
-      let(:objects) do
-        [
-          Nanoc::Int::Item.new('stuff', {}, Nanoc::Identifier.new('/about.css')),
-          Nanoc::Int::Item.new('stuff', {}, Nanoc::Identifier.new('/about.md')),
-          Nanoc::Int::Item.new('stuff', {}, Nanoc::Identifier.new('/style.css')),
-        ]
-      end
-
-      let(:arg) { raise 'override me' }
-
-      subject { identifiable_collection.object_with_identifier(arg) }
-
-      context 'with string' do
-        let(:arg) { '/about.css' }
-        it { is_expected.to eq(objects[0]) }
-      end
-
-      context 'with identifier' do
-        let(:arg) { Nanoc::Identifier.new('/about.css') }
-        it { is_expected.to eq(objects[0]) }
-      end
-
-      context 'with glob string' do
-        let(:arg) { '/about.*' }
-        it { is_expected.to be_nil }
-      end
-    end
-
-    describe '#reference' do
-      subject { identifiable_collection.reference }
-      it { is_expected.to eql(expected_reference) }
-    end
-
-    describe 'changing identifiers' do
-      let(:objects) do
-        [
-          Nanoc::Int::Item.new('Foo', {}, '/foo'),
-        ]
-      end
-
-      subject { objects[0].identifier = '/bar' }
-
-      it 'makes /foo nil' do
-        expect { subject }
-          .to change { identifiable_collection['/foo'] }
-          .from(objects[0])
-          .to(nil)
-      end
-
-      it 'makes /bar non-nil' do
-        expect { subject }
-          .to change { identifiable_collection['/bar'] }
-          .from(nil)
-          .to(objects[0])
-      end
-    end
-
-    describe '#each' do
-      let(:objects) do
-        [
-          Nanoc::Int::Item.new('Foo', {}, '/foo'),
-          Nanoc::Int::Item.new('Bar', {}, '/bar'),
-        ]
-      end
-
-      it 'loops' do
-        res = []
-        identifiable_collection.each { |i| res << i.identifier.to_s }
-        expect(res).to match_array(['/foo', '/bar'])
-      end
-    end
-
-    describe '#map' do
-      let(:objects) do
-        [
-          Nanoc::Int::Item.new('Foo', {}, '/foo'),
-          Nanoc::Int::Item.new('Bar', {}, '/bar'),
-        ]
-      end
-
-      it 'loops' do
-        res = identifiable_collection.map { |i| i.identifier.to_s }
-        expect(res).to match_array(['/foo', '/bar'])
-      end
-    end
-  end
-
-  describe Nanoc::Int::ItemCollection do
-    let(:expected_reference) { 'items' }
-    it_behaves_like 'a generic identifiable collection'
-  end
-
-  describe Nanoc::Int::LayoutCollection do
-    let(:expected_reference) { 'layouts' }
-    it_behaves_like 'a generic identifiable collection'
-  end
-end

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

@@ -1,472 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Identifier do
-  describe '.from' do
-    subject { described_class.from(arg) }
-
-    context 'given an identifier' do
-      let(:arg) { Nanoc::Identifier.new('/foo.md') }
-
-      it 'returns an identifier' do
-        expect(subject).to be_a(Nanoc::Identifier)
-        expect(subject.to_s).to eq('/foo.md')
-        expect(subject).to be_full
-      end
-    end
-
-    context 'given a string' do
-      let(:arg) { '/foo.md' }
-
-      it 'returns an identifier' do
-        expect(subject).to be_a(Nanoc::Identifier)
-        expect(subject.to_s).to eq('/foo.md')
-        expect(subject).to be_full
-      end
-    end
-
-    context 'given something else' do
-      let(:arg) { 12_345 }
-
-      it 'raises' do
-        expect { subject }.to raise_error(Nanoc::Identifier::NonCoercibleObjectError)
-      end
-    end
-  end
-
-  describe '#initialize' do
-    context 'legacy type' do
-      it 'does not convert already clean paths' do
-        expect(described_class.new('/foo/bar/', type: :legacy).to_s).to eql('/foo/bar/')
-      end
-
-      it 'prepends slash if necessary' do
-        expect(described_class.new('foo/bar/', type: :legacy).to_s).to eql('/foo/bar/')
-      end
-
-      it 'appends slash if necessary' do
-        expect(described_class.new('/foo/bar', type: :legacy).to_s).to eql('/foo/bar/')
-      end
-
-      it 'removes double slashes at start' do
-        expect(described_class.new('//foo/bar/', type: :legacy).to_s).to eql('/foo/bar/')
-      end
-
-      it 'removes double slashes at end' do
-        expect(described_class.new('/foo/bar//', type: :legacy).to_s).to eql('/foo/bar/')
-      end
-
-      it 'freezes' do
-        identifier = described_class.new('/foo/bar/', type: :legacy)
-        expect { identifier.to_s << 'bbq' }.to raise_frozen_error
-      end
-    end
-
-    context 'full type' do
-      it 'refuses string not starting with a slash' do
-        expect { described_class.new('foo') }
-          .to raise_error(Nanoc::Identifier::InvalidIdentifierError)
-      end
-
-      it 'refuses string ending with a slash' do
-        expect { described_class.new('/foo/') }
-          .to raise_error(Nanoc::Identifier::InvalidFullIdentifierError)
-      end
-
-      it 'refuses string with only slash' do
-        expect { described_class.new('/') }
-          .to raise_error(Nanoc::Identifier::InvalidFullIdentifierError)
-      end
-
-      it 'has proper string representation' do
-        expect(described_class.new('/foo').to_s).to eql('/foo')
-      end
-
-      it 'freezes' do
-        identifier = described_class.new('/foo/bar')
-        expect { identifier.to_s << 'bbq' }.to raise_frozen_error
-      end
-    end
-
-    context 'other type' do
-      it 'errors' do
-        expect { described_class.new('foo', type: :donkey) }
-          .to raise_error(Nanoc::Identifier::InvalidTypeError)
-      end
-    end
-
-    context 'default type' do
-      it 'is full' do
-        expect(described_class.new('/foo')).to be_full
-      end
-    end
-
-    context 'other args specified' do
-      it 'errors' do
-        expect { described_class.new('?', animal: :donkey) }
-          .to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe '#to_s' do
-    it 'returns immutable string' do
-      expect { described_class.new('foo/', type: :legacy).to_s << 'lols' }.to raise_frozen_error
-      expect { described_class.new('/foo').to_s << 'lols' }.to raise_frozen_error
-    end
-  end
-
-  describe '#to_str' do
-    it 'returns immutable string' do
-      expect { described_class.new('/foo/bar').to_str << 'lols' }.to raise_frozen_error
-    end
-  end
-
-  describe 'Comparable' do
-    it 'can be compared' do
-      expect(described_class.new('/foo/bar') <= '/qux').to eql(true)
-    end
-  end
-
-  describe '#inspect' do
-    let(:identifier) { described_class.new('/foo/bar') }
-
-    subject { identifier.inspect }
-
-    it { should == '<Nanoc::Identifier type=full "/foo/bar">' }
-  end
-
-  describe '#== and #eql?' do
-    context 'comparing with equal identifier' do
-      let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) }
-      let(:identifier_b) { described_class.new('/foo/bar//', type: :legacy) }
-
-      it 'is ==' do
-        expect(identifier_a).to eq(identifier_b)
-      end
-
-      it 'is eql?' do
-        expect(identifier_a).to eql(identifier_b)
-      end
-    end
-
-    context 'comparing with equal string' do
-      let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) }
-      let(:identifier_b) { '/foo/bar/' }
-
-      it 'is ==' do
-        expect(identifier_a).to eq(identifier_b.to_s)
-      end
-
-      it 'is not eql?' do
-        expect(identifier_a).not_to eql(identifier_b.to_s)
-      end
-    end
-
-    context 'comparing with different identifier' do
-      let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) }
-      let(:identifier_b) { described_class.new('/baz/qux//', type: :legacy) }
-
-      it 'is not ==' do
-        expect(identifier_a).not_to eq(identifier_b)
-      end
-
-      it 'is not eql?' do
-        expect(identifier_a).not_to eql(identifier_b)
-      end
-    end
-
-    context 'comparing with different string' do
-      let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) }
-      let(:identifier_b) { '/baz/qux/' }
-
-      it 'is not equal' do
-        expect(identifier_a).not_to eq(identifier_b)
-      end
-
-      it 'is not eql?' do
-        expect(identifier_a).not_to eql(identifier_b)
-      end
-    end
-
-    context 'comparing with something that is not an identifier' do
-      let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) }
-      let(:identifier_b) { :donkey }
-
-      it 'is not equal' do
-        expect(identifier_a).not_to eq(identifier_b)
-        expect(identifier_a).not_to eql(identifier_b)
-      end
-    end
-  end
-
-  describe '#hash' do
-    context 'equal identifiers' do
-      let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) }
-      let(:identifier_b) { described_class.new('/foo/bar//', type: :legacy) }
-
-      it 'is the same' do
-        expect(identifier_a.hash == identifier_b.hash).to eql(true)
-      end
-    end
-
-    context 'different identifiers' do
-      let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) }
-      let(:identifier_b) { described_class.new('/monkey/', type: :legacy) }
-
-      it 'is different' do
-        expect(identifier_a.hash == identifier_b.hash).to eql(false)
-      end
-    end
-  end
-
-  describe '#=~' do
-    let(:identifier) { described_class.new('/foo/bar') }
-
-    subject { identifier =~ pat }
-
-    context 'given a regex' do
-      context 'matching regex' do
-        let(:pat) { %r{\A/foo/bar} }
-        it { is_expected.to eql(0) }
-      end
-
-      context 'non-matching regex' do
-        let(:pat) { %r{\A/qux/monkey} }
-        it { is_expected.to eql(nil) }
-      end
-    end
-
-    context 'given a string' do
-      context 'matching string' do
-        let(:pat) { '/foo/*' }
-        it { is_expected.to eql(0) }
-      end
-
-      context 'non-matching string' do
-        let(:pat) { '/qux/*' }
-        it { is_expected.to eql(nil) }
-      end
-    end
-  end
-
-  describe '#<=>' do
-    let(:identifier) { described_class.new('/foo/bar') }
-
-    it 'compares by string' do
-      expect(identifier <=> '/foo/aarghh').to eql(1)
-      expect(identifier <=> '/foo/bar').to eql(0)
-      expect(identifier <=> '/foo/qux').to eql(-1)
-    end
-  end
-
-  describe '#prefix' do
-    let(:identifier) { described_class.new('/foo') }
-
-    subject { identifier.prefix(prefix) }
-
-    context 'prefix not ending nor starting with a slash' do
-      let(:prefix) { 'asdf' }
-
-      it 'raises an error' do
-        expect { subject }.to raise_error(
-          Nanoc::Identifier::InvalidPrefixError,
-          'Invalid prefix (does not start with a slash): "asdf"',
-        )
-      end
-    end
-
-    context 'prefix ending with a slash' do
-      let(:prefix) { 'asdf/' }
-
-      it 'raises an error' do
-        expect { subject }.to raise_error(
-          Nanoc::Identifier::InvalidPrefixError,
-          'Invalid prefix (does not start with a slash): "asdf/"',
-        )
-      end
-    end
-
-    context 'prefix ending and starting with a slash' do
-      let(:prefix) { '/asdf/' }
-
-      it 'returns a proper new identifier' do
-        expect(subject).to be_a(Nanoc::Identifier)
-        expect(subject.to_s).to eql('/asdf/foo')
-      end
-    end
-
-    context 'prefix nstarting with a slash' do
-      let(:prefix) { '/asdf' }
-
-      it 'returns a proper new identifier' do
-        expect(subject).to be_a(Nanoc::Identifier)
-        expect(subject.to_s).to eql('/asdf/foo')
-      end
-    end
-  end
-
-  describe '#without_ext' do
-    subject { identifier.without_ext }
-
-    context 'legacy type' do
-      let(:identifier) { described_class.new('/foo/', type: :legacy) }
-
-      it 'raises an error' do
-        expect { subject }.to raise_error(Nanoc::Identifier::UnsupportedLegacyOperationError)
-      end
-    end
-
-    context 'identifier with no extension' do
-      let(:identifier) { described_class.new('/foo') }
-
-      it 'does nothing' do
-        expect(subject).to eql('/foo')
-      end
-    end
-
-    context 'identifier with extension' do
-      let(:identifier) { described_class.new('/foo.md') }
-
-      it 'removes the extension' do
-        expect(subject).to eql('/foo')
-      end
-    end
-  end
-
-  describe '#ext' do
-    subject { identifier.ext }
-
-    context 'legacy type' do
-      let(:identifier) { described_class.new('/foo/', type: :legacy) }
-
-      it 'raises an error' do
-        expect { subject }.to raise_error(Nanoc::Identifier::UnsupportedLegacyOperationError)
-      end
-    end
-
-    context 'identifier with no extension' do
-      let(:identifier) { described_class.new('/foo') }
-
-      it { is_expected.to be_nil }
-    end
-
-    context 'identifier with extension' do
-      let(:identifier) { described_class.new('/foo.md') }
-
-      it { is_expected.to eql('md') }
-    end
-  end
-
-  describe '#without_exts' do
-    subject { identifier.without_exts }
-
-    context 'legacy type' do
-      let(:identifier) { described_class.new('/foo/', type: :legacy) }
-
-      it 'raises an error' do
-        expect { subject }.to raise_error(Nanoc::Identifier::UnsupportedLegacyOperationError)
-      end
-    end
-
-    context 'identifier with no extension' do
-      let(:identifier) { described_class.new('/foo') }
-
-      it 'does nothing' do
-        expect(subject).to eql('/foo')
-      end
-    end
-
-    context 'identifier with one extension' do
-      let(:identifier) { described_class.new('/foo.md') }
-
-      it 'removes the extension' do
-        expect(subject).to eql('/foo')
-      end
-    end
-
-    context 'identifier with multiple extensions' do
-      let(:identifier) { described_class.new('/foo.html.md') }
-
-      it 'removes the extension' do
-        expect(subject).to eql('/foo')
-      end
-    end
-  end
-
-  describe '#exts' do
-    subject { identifier.exts }
-
-    context 'legacy type' do
-      let(:identifier) { described_class.new('/foo/', type: :legacy) }
-
-      it 'raises an error' do
-        expect { subject }.to raise_error(Nanoc::Identifier::UnsupportedLegacyOperationError)
-      end
-    end
-
-    context 'identifier with no extension' do
-      let(:identifier) { described_class.new('/foo') }
-
-      it { is_expected.to be_empty }
-    end
-
-    context 'identifier with one extension' do
-      let(:identifier) { described_class.new('/foo.md') }
-
-      it { is_expected.to eql(['md']) }
-    end
-
-    context 'identifier with multiple extensions' do
-      let(:identifier) { described_class.new('/foo.html.md') }
-
-      it { is_expected.to eql(%w[html md]) }
-    end
-  end
-
-  describe '#legacy?' do
-    subject { identifier.legacy? }
-
-    context 'legacy type' do
-      let(:identifier) { described_class.new('/foo/', type: :legacy) }
-      it { is_expected.to eql(true) }
-    end
-
-    context 'full type' do
-      let(:identifier) { described_class.new('/foo', type: :full) }
-      it { is_expected.to eql(false) }
-    end
-  end
-
-  describe '#full?' do
-    subject { identifier.full? }
-
-    context 'legacy type' do
-      let(:identifier) { described_class.new('/foo/', type: :legacy) }
-      it { is_expected.to eql(false) }
-    end
-
-    context 'full type' do
-      let(:identifier) { described_class.new('/foo', type: :full) }
-      it { is_expected.to eql(true) }
-    end
-  end
-
-  describe '#components' do
-    subject { identifier.components }
-
-    context 'no components' do
-      let(:identifier) { described_class.new('/', type: :legacy) }
-      it { is_expected.to eql([]) }
-    end
-
-    context 'one component' do
-      let(:identifier) { described_class.new('/foo.md') }
-      it { is_expected.to eql(['foo.md']) }
-    end
-
-    context 'two components' do
-      let(:identifier) { described_class.new('/foo/bar.md') }
-      it { is_expected.to eql(['foo', 'bar.md']) }
-    end
-  end
-end