nanoc 4.4.5 → 4.4.6

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

@@ -0,0 +1,193 @@
+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/document_spec.rb

@@ -0,0 +1,206 @@
+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
+end