nanoc 4.8.12 → 4.8.13

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::ItemRep do
-  let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') }
-  let(:rep) { Nanoc::Int::ItemRep.new(item, :giraffe) }
-
-  describe '#snapshot?' do
-    subject { rep.snapshot?(snapshot_name) }
-
-    let(:snapshot_name) { raise 'override me' }
-
-    before do
-      rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(:donkey, binary: false)]
-    end
-
-    context 'snapshot does not exist' do
-      let(:snapshot_name) { :giraffe }
-      it { is_expected.not_to be }
-    end
-
-    context 'snapshot exists' do
-      let(:snapshot_name) { :donkey }
-      it { is_expected.to be }
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::Item do
-  it_behaves_like 'a document'
-
-  describe '#reference' do
-    let(:item) { described_class.new('hi', {}, '/foo.md') }
-
-    it 'has the proper reference' do
-      expect(item.reference).to eql('item:/foo.md')
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::Layout do
-  it_behaves_like 'a document'
-
-  describe '#reference' do
-    let(:layout) { described_class.new('hi', {}, '/foo.md') }
-
-    it 'has the proper reference' do
-      expect(layout.reference).to eql('layout:/foo.md')
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::LazyValue do
-  describe '#value' do
-    let(:value_arg) { +'Hello world' }
-    let(:lazy_value) { described_class.new(value_arg) }
-
-    subject { lazy_value.value }
-
-    context 'object' do
-      it { is_expected.to equal(value_arg) }
-    end
-
-    context 'proc' do
-      it 'does not call the proc immediately' do
-        expect(value_arg).not_to receive(:call)
-
-        lazy_value
-      end
-
-      it 'returns proc return value' do
-        expect(value_arg).to receive(:call).once.and_return('Hello proc')
-
-        expect(subject).to eql('Hello proc')
-      end
-
-      it 'only calls the proc once' do
-        expect(value_arg).to receive(:call).once.and_return('Hello proc')
-
-        expect(subject).to eql('Hello proc')
-        expect(subject).to eql('Hello proc')
-      end
-    end
-  end
-
-  describe '#map' do
-    let(:value_arg) { -> { 'Hello world' } }
-    let(:lazy_value) { described_class.new(value_arg) }
-
-    subject { lazy_value.map(&:upcase) }
-
-    it 'does not call the proc immediately' do
-      expect(value_arg).not_to receive(:call)
-
-      subject
-    end
-
-    it 'returns proc return value' do
-      expect(value_arg).to receive(:call).once.and_return('Hello proc')
-
-      expect(subject.value).to eql('HELLO PROC')
-    end
-
-    it 'only calls the proc once' do
-      expect(value_arg).to receive(:call).once.and_return('Hello proc')
-
-      expect(subject.value).to eql('HELLO PROC')
-      expect(subject.value).to eql('HELLO PROC')
-    end
-  end
-
-  describe '#freeze' do
-    let(:value_arg) { 'Hello world' }
-
-    subject { described_class.new(value_arg) }
-
-    before do
-      subject.freeze
-    end
-
-    context 'object' do
-      it 'returns value' do
-        expect(subject.value).to equal(value_arg)
-      end
-
-      it 'freezes value' do
-        expect(subject.value).to be_frozen
-      end
-    end
-
-    context 'proc' do
-      call_count = 0
-      let(:value_arg) do
-        proc do
-          call_count += 1
-          'Hello proc'
-        end
-      end
-
-      before do
-        call_count = 0
-        subject.freeze
-      end
-
-      it 'does not call the proc immediately' do
-        expect(call_count).to eql(0)
-      end
-
-      it 'returns proc return value' do
-        expect(subject.value).to eq('Hello proc')
-      end
-
-      it 'freezes upon access' do
-        expect(subject.value).to be_frozen
-      end
-    end
-  end
-end

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

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::OutdatednessStatus do
-  let(:status) { described_class.new }
-
-  describe '#reasons' do
-    subject { status.reasons }
-
-    context 'default' do
-      it { is_expected.to eql([]) }
-    end
-
-    context 'one passed in' do
-      let(:reasons) do
-        [
-          Nanoc::Int::OutdatednessReasons::CodeSnippetsModified,
-        ]
-      end
-
-      let(:status) { described_class.new(reasons: reasons) }
-
-      it { is_expected.to eql(reasons) }
-    end
-
-    context 'two passed in' do
-      let(:reasons) do
-        [
-          Nanoc::Int::OutdatednessReasons::CodeSnippetsModified,
-          Nanoc::Int::OutdatednessReasons::ContentModified,
-        ]
-      end
-
-      let(:status) { described_class.new(reasons: reasons) }
-
-      it { is_expected.to eql(reasons) }
-    end
-  end
-
-  describe '#props' do
-    subject { status.props.active }
-
-    context 'default' do
-      it { is_expected.to eql(Set.new) }
-    end
-
-    context 'specific one passed in' do
-      let(:props) do
-        Nanoc::Int::Props.new(attributes: true)
-      end
-
-      let(:status) { described_class.new(props: props) }
-
-      it { is_expected.to eql(Set.new([:attributes])) }
-    end
-  end
-
-  describe '#useful_to_apply' do
-    subject { status.useful_to_apply?(rule) }
-
-    let(:status) { described_class.new(props: props) }
-    let(:props) { Nanoc::Int::Props.new }
-    let(:rule) { Nanoc::Int::OutdatednessRules::RulesModified }
-
-    context 'no props' do
-      it { is_expected.to be }
-    end
-
-    context 'some props' do
-      context 'same props' do
-        let(:props) { Nanoc::Int::Props.new(compiled_content: true, path: true) }
-        it { is_expected.not_to be }
-      end
-
-      context 'different props' do
-        let(:props) { Nanoc::Int::Props.new(attributes: true) }
-        it { is_expected.to be }
-      end
-    end
-
-    context 'all props' do
-      let(:props) { Nanoc::Int::Props.new(raw_content: true, attributes: true, compiled_content: true, path: true) }
-      it { is_expected.not_to be }
-    end
-  end
-
-  describe '#update' do
-    subject { status.update(reason) }
-
-    let(:reason) { Nanoc::Int::OutdatednessReasons::ContentModified }
-
-    context 'no existing reason or props' do
-      it 'adds a reason' do
-        expect(subject.reasons).to eql([reason])
-      end
-    end
-
-    context 'existing reason' do
-      let(:status) { described_class.new(reasons: [old_reason]) }
-
-      let(:old_reason) { Nanoc::Int::OutdatednessReasons::NotWritten }
-
-      it 'adds a reason' do
-        expect(subject.reasons).to eql([old_reason, reason])
-      end
-    end
-
-    context 'existing props' do
-      let(:status) { described_class.new(props: Nanoc::Int::Props.new(attributes: true)) }
-
-      it 'updates props' do
-        expect(subject.props.active).to eql(Set.new(%i[raw_content attributes compiled_content]))
-      end
-    end
-  end
-end

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

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::Pattern do
-  describe '.from' do
-    it 'converts from string' do
-      pattern = described_class.from('/foo/x[ab]z/bar.*')
-      expect(pattern.match?('/foo/xaz/bar.html')).to eql(true)
-      expect(pattern.match?('/foo/xyz/bar.html')).to eql(false)
-    end
-
-    it 'converts from regex' do
-      pattern = described_class.from(%r{\A/foo/x[ab]z/bar\..*\z})
-      expect(pattern.match?('/foo/xaz/bar.html')).to eql(true)
-      expect(pattern.match?('/foo/xyz/bar.html')).to eql(false)
-    end
-
-    it 'converts from pattern' do
-      pattern = described_class.from('/foo/x[ab]z/bar.*')
-      pattern = described_class.from(pattern)
-      expect(pattern.match?('/foo/xaz/bar.html')).to eql(true)
-      expect(pattern.match?('/foo/xyz/bar.html')).to eql(false)
-    end
-
-    it 'converts from symbol' do
-      pattern = described_class.from(:'/foo/x[ab]z/bar.*')
-      expect(pattern.match?('/foo/xaz/bar.html')).to eql(true)
-      expect(pattern.match?('/foo/xyz/bar.html')).to eql(false)
-    end
-
-    it 'errors on other inputs' do
-      expect { described_class.from(123) }.to raise_error(ArgumentError)
-    end
-
-    it 'errors with a proper error message on other inputs' do
-      expect { described_class.from(nil) }
-        .to raise_error(ArgumentError, 'Do not know how to convert `nil` into a Nanoc::Pattern')
-    end
-  end
-
-  describe '#initialize' do
-    it 'errors' do
-      expect { described_class.new('/stuff') }
-        .to raise_error(NotImplementedError)
-    end
-  end
-
-  describe '#match?' do
-    it 'errors' do
-      expect { described_class.allocate.match?('/foo.md') }
-        .to raise_error(NotImplementedError)
-    end
-  end
-
-  describe '#captures' do
-    it 'errors' do
-      expect { described_class.allocate.captures('/foo.md') }
-        .to raise_error(NotImplementedError)
-    end
-  end
-end
-
-describe Nanoc::Int::RegexpPattern do
-  let(:pattern) { described_class.new(/the answer is (\d+)/) }
-
-  describe '#match?' do
-    it 'matches' do
-      expect(pattern.match?('the answer is 42')).to eql(true)
-      expect(pattern.match?('the answer is donkey')).to eql(false)
-    end
-  end
-
-  describe '#captures' do
-    it 'returns nil if it does not match' do
-      expect(pattern.captures('the answer is donkey')).to be_nil
-    end
-
-    it 'returns array if it matches' do
-      expect(pattern.captures('the answer is 42')).to eql(['42'])
-    end
-  end
-
-  describe '#to_s' do
-    subject { pattern.to_s }
-
-    it 'returns the regex' do
-      expect(subject).to eq('(?-mix:the answer is (\d+))')
-    end
-  end
-end
-
-describe Nanoc::Int::StringPattern do
-  describe '#match?' do
-    it 'matches simple strings' do
-      pattern = described_class.new('d*key')
-
-      expect(pattern.match?('donkey')).to eql(true)
-      expect(pattern.match?('giraffe')).to eql(false)
-    end
-
-    it 'matches with pathname option' do
-      pattern = described_class.new('/foo/*/bar/**/*.animal')
-
-      expect(pattern.match?('/foo/x/bar/a/b/donkey.animal')).to eql(true)
-      expect(pattern.match?('/foo/x/bar/donkey.animal')).to eql(true)
-      expect(pattern.match?('/foo/x/railroad/donkey.animal')).to eql(false)
-    end
-
-    it 'matches with extglob option' do
-      pattern = described_class.new('{b,gl}oat')
-
-      expect(pattern.match?('boat')).to eql(true)
-      expect(pattern.match?('gloat')).to eql(true)
-      expect(pattern.match?('stoat')).to eql(false)
-    end
-  end
-
-  describe '#captures' do
-    it 'returns nil' do
-      pattern = described_class.new('d*key')
-      expect(pattern.captures('donkey')).to be_nil
-    end
-  end
-
-  describe '#to_s' do
-    let(:pattern) { described_class.new('/foo/*/bar/**/*.animal') }
-
-    subject { pattern.to_s }
-
-    it 'returns the regex' do
-      expect(subject).to eq('/foo/*/bar/**/*.animal')
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::ProcessingAction do
-  let(:action) { described_class.new }
-
-  it 'is abstract' do
-    expect { action.serialize }.to raise_error(NotImplementedError)
-    expect { action.to_s }.to raise_error(NotImplementedError)
-    expect { action.inspect }.to raise_error(NotImplementedError)
-  end
-end

data/spec/nanoc/base/entities/processing_actions/filter_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::ProcessingActions::Filter do
-  let(:action) { described_class.new(:foo, awesome: true) }
-
-  describe '#serialize' do
-    subject { action.serialize }
-    it { is_expected.to eql([:filter, :foo, 'sJYzLjHGo1e4ytuDfnOLkqrt9QE=']) }
-  end
-
-  describe '#to_s' do
-    subject { action.to_s }
-    it { is_expected.to eql('filter :foo, {:awesome=>true}') }
-  end
-
-  describe '#inspect' do
-    subject { action.inspect }
-    it { is_expected.to eql('<Nanoc::Int::ProcessingActions::Filter :foo, "sJYzLjHGo1e4ytuDfnOLkqrt9QE=">') }
-  end
-end