nanoc 4.4.5 → 4.4.6

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

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

@@ -0,0 +1,113 @@
+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([:raw_content, :attributes, :compiled_content]))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+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 '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

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

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

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

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

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

@@ -0,0 +1,32 @@
+describe Nanoc::Int::ProcessingActions::Snapshot do
+  let(:action) { described_class.new(:before_layout, '/foo.md') }
+
+  describe '#serialize' do
+    subject { action.serialize }
+    it { is_expected.to eql([:snapshot, :before_layout, true, '/foo.md']) }
+  end
+
+  describe '#to_s' do
+    subject { action.to_s }
+    it { is_expected.to eql('snapshot :before_layout, path: "/foo.md"') }
+  end
+
+  describe '#inspect' do
+    subject { action.inspect }
+    it { is_expected.to eql('<Nanoc::Int::ProcessingActions::Snapshot :before_layout, true, "/foo.md">') }
+  end
+
+  describe '#copy' do
+    context 'without path' do
+      subject { action.copy }
+      its(:snapshot_name) { is_expected.to eql(:before_layout) }
+      its(:path) { is_expected.to eql('/foo.md') }
+    end
+
+    context 'with path' do
+      subject { action.copy(path: '/donkey.md') }
+      its(:snapshot_name) { is_expected.to eql(:before_layout) }
+      its(:path) { is_expected.to eql('/donkey.md') }
+    end
+  end
+end

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

@@ -0,0 +1,195 @@
+describe Nanoc::Int::Props do
+  let(:props) { described_class.new }
+
+  let(:props_all) do
+    described_class.new(raw_content: true, attributes: true, compiled_content: true, path: true)
+  end
+
+  describe '#inspect' do
+    subject { props.inspect }
+
+    context 'nothing active' do
+      it { is_expected.to eql('Props(____)') }
+    end
+
+    context 'attributes active' do
+      let(:props) { described_class.new(attributes: true) }
+      it { is_expected.to eql('Props(_a__)') }
+    end
+
+    context 'attributes and compiled_content active' do
+      let(:props) { described_class.new(attributes: true, compiled_content: true) }
+      it { is_expected.to eql('Props(_ac_)') }
+    end
+
+    context 'compiled_content active' do
+      let(:props) { described_class.new(compiled_content: true) }
+      it { is_expected.to eql('Props(__c_)') }
+    end
+  end
+
+  describe '#raw_content?' do
+    # …
+  end
+
+  describe '#attributes?' do
+    subject { props.attributes? }
+
+    context 'nothing active' do
+      it { is_expected.not_to be }
+    end
+
+    context 'attributes active' do
+      let(:props) { described_class.new(attributes: true) }
+      it { is_expected.to be }
+    end
+
+    context 'attributes and compiled_content active' do
+      let(:props) { described_class.new(attributes: true, compiled_content: true) }
+      it { is_expected.to be }
+    end
+
+    context 'compiled_content active' do
+      let(:props) { described_class.new(compiled_content: true) }
+      it { is_expected.not_to be }
+    end
+
+    context 'all active' do
+      let(:props) { described_class.new(raw_content: true, attributes: true, compiled_content: true, path: true) }
+      it { is_expected.to be }
+    end
+  end
+
+  describe '#compiled_content?' do
+    # …
+  end
+
+  describe '#path?' do
+    # …
+  end
+
+  describe '#merge' do
+    subject { props.merge(other_props).active }
+
+    context 'nothing + nothing' do
+      let(:props) { described_class.new }
+      let(:other_props) { described_class.new }
+
+      it { is_expected.to eql(Set.new) }
+    end
+
+    context 'nothing + some' do
+      let(:props) { described_class.new }
+      let(:other_props) { described_class.new(raw_content: true) }
+
+      it { is_expected.to eql(Set.new([:raw_content])) }
+    end
+
+    context 'nothing + all' do
+      let(:props) { described_class.new }
+      let(:other_props) { props_all }
+
+      it { is_expected.to eql(Set.new([:raw_content, :attributes, :compiled_content, :path])) }
+    end
+
+    context 'some + nothing' do
+      let(:props) { described_class.new(compiled_content: true) }
+      let(:other_props) { described_class.new }
+
+      it { is_expected.to eql(Set.new([:compiled_content])) }
+    end
+
+    context 'some + others' do
+      let(:props) { described_class.new(compiled_content: true) }
+      let(:other_props) { described_class.new(raw_content: true) }
+
+      it { is_expected.to eql(Set.new([:raw_content, :compiled_content])) }
+    end
+
+    context 'some + all' do
+      let(:props) { described_class.new(compiled_content: true) }
+      let(:other_props) { props_all }
+
+      it { is_expected.to eql(Set.new([:raw_content, :attributes, :compiled_content, :path])) }
+    end
+
+    context 'all + nothing' do
+      let(:props) { props_all }
+      let(:other_props) { described_class.new }
+
+      it { is_expected.to eql(Set.new([:raw_content, :attributes, :compiled_content, :path])) }
+    end
+
+    context 'some + all' do
+      let(:props) { props_all }
+      let(:other_props) { described_class.new(compiled_content: true) }
+
+      it { is_expected.to eql(Set.new([:raw_content, :attributes, :compiled_content, :path])) }
+    end
+
+    context 'all + all' do
+      let(:props) { props_all }
+      let(:other_props) { props_all }
+
+      it { is_expected.to eql(Set.new([:raw_content, :attributes, :compiled_content, :path])) }
+    end
+  end
+
+  describe '#active' do
+    subject { props.active }
+
+    context 'nothing active' do
+      let(:props) { described_class.new }
+      it { is_expected.to eql(Set.new) }
+    end
+
+    context 'raw_content active' do
+      let(:props) { described_class.new(raw_content: true) }
+      it { is_expected.to eql(Set.new([:raw_content])) }
+    end
+
+    context 'attributes active' do
+      let(:props) { described_class.new(attributes: true) }
+      it { is_expected.to eql(Set.new([:attributes])) }
+    end
+
+    context 'compiled_content active' do
+      let(:props) { described_class.new(compiled_content: true) }
+      it { is_expected.to eql(Set.new([:compiled_content])) }
+    end
+
+    context 'path active' do
+      let(:props) { described_class.new(path: true) }
+      it { is_expected.to eql(Set.new([:path])) }
+    end
+
+    context 'attributes and compiled_content active' do
+      let(:props) { described_class.new(attributes: true, compiled_content: true) }
+      it { is_expected.to eql(Set.new([:attributes, :compiled_content])) }
+    end
+
+    context 'all active' do
+      let(:props) { described_class.new(raw_content: true, attributes: true, compiled_content: true, path: true) }
+      it { is_expected.to eql(Set.new([:raw_content, :attributes, :compiled_content, :path])) }
+    end
+  end
+
+  describe '#to_h' do
+    subject { props.to_h }
+
+    context 'nothing' do
+      let(:props) { described_class.new }
+      it { is_expected.to eql(raw_content: false, attributes: false, compiled_content: false, path: false) }
+    end
+
+    context 'some' do
+      let(:props) { described_class.new(attributes: true, compiled_content: true) }
+      it { is_expected.to eql(raw_content: false, attributes: true, compiled_content: true, path: false) }
+    end
+
+    context 'all' do
+      let(:props) { props_all }
+      it { is_expected.to eql(raw_content: true, attributes: true, compiled_content: true, path: true) }
+    end
+  end
+end