nanoc 4.8.12 → 4.8.13

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

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::Content do
-  describe '.create' do
-    subject { described_class.create(arg, params) }
-
-    let(:params) { {} }
-
-    context 'nil arg' do
-      let(:arg) { nil }
-
-      it 'raises' do
-        expect { subject }.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'content arg' do
-      let(:arg) { Nanoc::Int::TextualContent.new('foo') }
-
-      it { is_expected.to eql(arg) }
-    end
-
-    context 'with binary: true param' do
-      let(:arg) { '/foo.dat' }
-      let(:params) { { binary: true } }
-
-      it 'returns binary content' do
-        expect(subject).to be_a(Nanoc::Int::BinaryContent)
-        expect(subject.filename).to eql('/foo.dat')
-      end
-    end
-
-    context 'with binary: false param' do
-      context 'with filename param' do
-        let(:arg) { 'foo' }
-        let(:params) { { binary: false, filename: '/foo.md' } }
-
-        it 'returns textual content' do
-          expect(subject).to be_a(Nanoc::Int::TextualContent)
-          expect(subject.string).to eql('foo')
-          expect(subject.filename).to eql('/foo.md')
-        end
-      end
-
-      context 'without filename param' do
-        let(:arg) { 'foo' }
-        let(:params) { { binary: false } }
-
-        it 'returns textual content' do
-          expect(subject).to be_a(Nanoc::Int::TextualContent)
-          expect(subject.string).to eql('foo')
-          expect(subject.filename).to be_nil
-        end
-      end
-    end
-  end
-end
-
-describe Nanoc::Int::TextualContent do
-  describe '#initialize' do
-    context 'without filename' do
-      let(:content) { described_class.new('foo') }
-
-      it 'sets string and filename' do
-        expect(content.string).to eq('foo')
-        expect(content.filename).to be_nil
-      end
-    end
-
-    context 'with absolute filename' do
-      let(:content) { described_class.new('foo', filename: '/foo.md') }
-
-      it 'sets string and filename' do
-        expect(content.string).to eq('foo')
-        expect(content.filename).to eq('/foo.md')
-      end
-    end
-
-    context 'with relative filename' do
-      let(:content) { described_class.new('foo', filename: 'foo.md') }
-
-      it 'errors' do
-        expect { content }.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'with proc' do
-      let(:content_proc) { -> { 'foo' } }
-      let(:content) { described_class.new(content_proc) }
-
-      it 'does not call the proc immediately' do
-        expect(content_proc).not_to receive(:call)
-
-        content
-      end
-
-      it 'sets string' do
-        expect(content_proc).to receive(:call).once.and_return('dataz')
-
-        expect(content.string).to eq('dataz')
-      end
-
-      it 'only calls the proc once' do
-        expect(content_proc).to receive(:call).once.and_return('dataz')
-
-        expect(content.string).to eq('dataz')
-        expect(content.string).to eq('dataz')
-      end
-    end
-  end
-
-  describe '#binary?' do
-    subject { content.binary? }
-    let(:content) { described_class.new('foo') }
-    it { is_expected.to eql(false) }
-  end
-
-  describe '#freeze' do
-    let(:content) { described_class.new('foo', filename: '/asdf.md') }
-
-    before do
-      content.freeze
-    end
-
-    it 'prevents changes to string' do
-      expect(content.string).to be_frozen
-      expect { content.string << 'asdf' }.to raise_frozen_error
-    end
-
-    it 'prevents changes to filename' do
-      expect(content.filename).to be_frozen
-      expect { content.filename << 'asdf' }.to raise_frozen_error
-    end
-
-    context 'with proc' do
-      let(:content) { described_class.new(proc { 'foo' }) }
-
-      it 'prevents changes to string' do
-        expect(content.string).to be_frozen
-        expect { content.string << 'asdf' }.to raise_frozen_error
-      end
-    end
-  end
-
-  describe 'marshalling' do
-    let(:content) { described_class.new('foo', filename: '/foo.md') }
-
-    it 'dumps as an array' do
-      expect(content.marshal_dump).to eq(['/foo.md', 'foo'])
-    end
-
-    it 'restores a dumped object' do
-      restored = Marshal.load(Marshal.dump(content))
-      expect(restored.string).to eq('foo')
-      expect(restored.filename).to eq('/foo.md')
-    end
-  end
-end
-
-describe Nanoc::Int::BinaryContent do
-  describe '#initialize' do
-    let(:content) { described_class.new('/foo.dat') }
-
-    it 'sets filename' do
-      expect(content.filename).to eql('/foo.dat')
-    end
-
-    context 'with relative filename' do
-      let(:content) { described_class.new('foo.dat') }
-
-      it 'errors' do
-        expect { content }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe '#binary?' do
-    subject { content.binary? }
-    let(:content) { described_class.new('/foo.dat') }
-    it { is_expected.to eql(true) }
-  end
-
-  describe '#freeze' do
-    let(:content) { described_class.new('/foo.dat') }
-
-    before do
-      content.freeze
-    end
-
-    it 'prevents changes' do
-      expect(content.filename).to be_frozen
-      expect { content.filename << 'asdf' }.to raise_frozen_error
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::Context do
-  let(:context) do
-    Nanoc::Int::Context.new(foo: 'bar', baz: 'quux')
-  end
-
-  it 'provides instance variables' do
-    expect(eval('@foo', context.get_binding)).to eq('bar')
-  end
-
-  it 'provides instance methods' do
-    expect(eval('foo', context.get_binding)).to eq('bar')
-  end
-
-  it 'supports #include' do
-    eval('include Nanoc::Helpers::HTMLEscape', context.get_binding)
-    expect(eval('h("<>")', context.get_binding)).to eq('&lt;&gt;')
-  end
-
-  it 'has correct examples' do
-    expect('Nanoc::Int::Context#initialize')
-      .to have_correct_yard_examples
-      .in_file('lib/nanoc/base/entities/context.rb')
-  end
-end

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

@@ -1,258 +0,0 @@
-# frozen_string_literal: true
-
-shared_examples 'a document' do
-  describe '#initialize' do
-    let(:content_arg) { 'Hello world' }
-    let(:attributes_arg) { { 'title' => 'Home' } }
-    let(:identifier_arg) { '/home.md' }
-    let(:checksum_data_arg) { 'abcdef' }
-    let(:content_checksum_data_arg) { 'con-cs' }
-    let(:attributes_checksum_data_arg) { 'attr-cs' }
-
-    subject do
-      described_class.new(
-        content_arg,
-        attributes_arg,
-        identifier_arg,
-        checksum_data: checksum_data_arg,
-        content_checksum_data: content_checksum_data_arg,
-        attributes_checksum_data: attributes_checksum_data_arg,
-      )
-    end
-
-    describe 'content arg' do
-      context 'string' do
-        it 'converts content' do
-          expect(subject.content).to be_a(Nanoc::Int::TextualContent)
-          expect(subject.content.string).to eql('Hello world')
-        end
-      end
-
-      context 'content' do
-        let(:content_arg) { Nanoc::Int::TextualContent.new('foo') }
-
-        it 'reuses content' do
-          expect(subject.content).to equal(content_arg)
-        end
-      end
-    end
-
-    describe 'attributes arg' do
-      context 'hash' do
-        it 'symbolizes attributes' do
-          expect(subject.attributes).to eq(title: 'Home')
-        end
-      end
-
-      context 'proc' do
-        call_count = 0
-        let(:attributes_arg) do
-          proc do
-            call_count += 1
-            { 'title' => 'Home' }
-          end
-        end
-
-        before do
-          call_count = 0
-        end
-
-        it 'does not call the proc immediately' do
-          expect(call_count).to eql(0)
-        end
-
-        it 'symbolizes attributes' do
-          expect(subject.attributes).to eq(title: 'Home')
-        end
-
-        it 'only calls the proc once' do
-          subject.attributes
-          subject.attributes
-          expect(call_count).to eql(1)
-        end
-      end
-    end
-
-    describe 'identifier arg' do
-      context 'string' do
-        it 'converts identifier' do
-          expect(subject.identifier).to be_a(Nanoc::Identifier)
-          expect(subject.identifier.to_s).to eql('/home.md')
-        end
-      end
-
-      context 'identifier' do
-        let(:identifier_arg) { Nanoc::Identifier.new('/foo.md') }
-
-        it 'retains identifier' do
-          expect(subject.identifier).to equal(identifier_arg)
-        end
-      end
-    end
-
-    describe 'checksum_data arg' do
-      it 'reuses checksum_data' do
-        expect(subject.checksum_data).to eql(checksum_data_arg)
-      end
-    end
-
-    describe 'content_checksum_data arg' do
-      it 'reuses content_checksum_data' do
-        expect(subject.content_checksum_data).to eql(content_checksum_data_arg)
-      end
-    end
-
-    describe 'attributes_checksum_data arg' do
-      it 'reuses attributes_checksum_data' do
-        expect(subject.attributes_checksum_data).to eql(attributes_checksum_data_arg)
-      end
-    end
-  end
-
-  describe '#freeze' do
-    let(:content_arg) { 'Hallo' }
-    let(:attributes_arg) { { foo: { bar: 'asdf' } } }
-    let(:document) { described_class.new(content_arg, attributes_arg, '/foo.md') }
-
-    before do
-      document.freeze
-    end
-
-    it 'refuses changes to content' do
-      expect { document.instance_variable_set(:@content, 'hah') }.to raise_frozen_error
-      expect { document.content.string << 'hah' }.to raise_frozen_error
-    end
-
-    it 'refuses to change attributes' do
-      expect { document.instance_variable_set(:@attributes, a: 'Hi') }.to raise_frozen_error
-      expect { document.attributes[:title] = 'Bye' }.to raise_frozen_error
-      expect { document.attributes[:foo][:bar] = 'fdsa' }.to raise_frozen_error
-    end
-
-    it 'refuses to change identifier' do
-      expect { document.identifier = '/asdf' }.to raise_frozen_error
-      expect { document.identifier.to_s << '/omg' }.to raise_frozen_error
-    end
-
-    context 'binary content' do
-      let(:content_arg) { Nanoc::Int::BinaryContent.new(File.expand_path('foo.dat')) }
-
-      it 'refuses changes to content' do
-        expect { document.instance_variable_set(:@content, 'hah') }.to raise_frozen_error
-        expect { document.content.filename << 'hah' }.to raise_frozen_error
-      end
-    end
-
-    context 'attributes block' do
-      let(:attributes_arg) { proc { { foo: { bar: 'asdf' } } } }
-
-      it 'gives access to the attributes' do
-        expect(document.attributes).to eql(foo: { bar: 'asdf' })
-      end
-
-      it 'refuses to change attributes' do
-        expect { document.instance_variable_set(:@attributes, a: 'Hi') }.to raise_frozen_error
-        expect { document.attributes[:title] = 'Bye' }.to raise_frozen_error
-        expect { document.attributes[:foo][:bar] = 'fdsa' }.to raise_frozen_error
-      end
-    end
-  end
-
-  describe 'equality' do
-    let(:content_arg_a) { 'Hello world' }
-    let(:content_arg_b) { 'Bye world' }
-
-    let(:attributes_arg_a) { { 'title' => 'Home' } }
-    let(:attributes_arg_b) { { 'title' => 'About' } }
-
-    let(:identifier_arg_a) { '/home.md' }
-    let(:identifier_arg_b) { '/home.md' }
-
-    let(:document_a) { described_class.new(content_arg_a, attributes_arg_a, identifier_arg_a) }
-    let(:document_b) { described_class.new(content_arg_b, attributes_arg_b, identifier_arg_b) }
-
-    subject { document_a == document_b }
-
-    context 'same identifier' do
-      let(:identifier_arg_a) { '/home.md' }
-      let(:identifier_arg_b) { '/home.md' }
-
-      it { is_expected.to eql(true) }
-
-      it 'has same hashes' do
-        expect(document_a.hash).to eql(document_b.hash)
-      end
-    end
-
-    context 'different identifier' do
-      let(:identifier_arg_a) { '/home.md' }
-      let(:identifier_arg_b) { '/about.md' }
-
-      it { is_expected.to eql(false) }
-
-      it 'has different hashes' do
-        expect(document_a.hash).not_to eql(document_b.hash)
-      end
-    end
-
-    context 'comparing with non-document' do
-      let(:document_b) { nil }
-
-      it { is_expected.to eql(false) }
-
-      it 'has different hashes' do
-        expect(document_a.hash).not_to eql(document_b.hash)
-      end
-    end
-  end
-
-  describe '#with_identifier_prefix' do
-    let(:document) { described_class.new('kontent', { at: 'ribut' }, '/donkey.md') }
-
-    subject { document.with_identifier_prefix('/animals') }
-
-    it 'does not mutate the original' do
-      document.freeze
-      subject
-    end
-
-    it 'returns a new document with a prefixed identifier' do
-      expect(subject.identifier).to eq('/animals/donkey.md')
-    end
-
-    it 'does not change other data' do
-      expect(subject.content).to be_some_textual_content('kontent')
-      expect(subject.attributes).to eq(at: 'ribut')
-    end
-  end
-
-  describe '#identifier=' do
-    let(:document) { described_class.new('stuff', {}, '/foo.md') }
-
-    it 'allows changing to a string that contains a full identifier' do
-      expect { document.identifier = '/thing' }.not_to raise_error
-
-      expect(document.identifier).to eq('/thing')
-      expect(document.identifier).to be_full
-    end
-
-    it 'refuses changing to a string that does not contain a full identifier' do
-      expect { document.identifier = '/thing/' }
-        .to raise_error(Nanoc::Identifier::InvalidFullIdentifierError)
-    end
-
-    it 'allos changing to a full identifier' do
-      document.identifier = Nanoc::Identifier.new('/thing')
-
-      expect(document.identifier.to_s).to eq('/thing')
-      expect(document.identifier).to be_full
-    end
-
-    it 'allos changing to a legacy identifier' do
-      document.identifier = Nanoc::Identifier.new('/thing/', type: :legacy)
-
-      expect(document.identifier).to eq('/thing/')
-      expect(document.identifier).to be_legacy
-    end
-  end
-end