nanoc 4.8.12 → 4.8.13

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

@@ -1,297 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::ActionSequence do
-  let(:action_sequence) { raise 'override me' }
-
-  let(:item) { Nanoc::Int::Item.new('foo', {}, '/foo.md') }
-  let(:rep) { Nanoc::Int::ItemRep.new(item, :default) }
-
-  describe '#size' do
-    subject { action_sequence.size }
-
-    context 'no actions' do
-      let(:action_sequence) do
-        described_class.build(rep) do |b|
-        end
-      end
-
-      it { is_expected.to eql(0) }
-    end
-
-    context 'some actions' do
-      let(:action_sequence) do
-        described_class.build(rep) do |b|
-          b.add_filter(:foo, {})
-        end
-      end
-
-      it { is_expected.to eql(1) }
-    end
-  end
-
-  describe '#[]' do
-    subject { action_sequence[index] }
-    let(:index) { 0 }
-
-    context 'no actions' do
-      let(:action_sequence) do
-        described_class.build(rep) do |b|
-        end
-      end
-
-      it { is_expected.to be_nil }
-    end
-
-    context 'some actions' do
-      let(:action_sequence) do
-        described_class.build(rep) do |b|
-          b.add_filter(:foo, {})
-        end
-      end
-
-      it { is_expected.to be_a(Nanoc::Int::ProcessingActions::Filter) }
-    end
-  end
-
-  describe '#add_filter' do
-    let(:action_sequence) do
-      described_class.build(rep) do |b|
-        b.add_filter(:foo, donkey: 123)
-      end
-    end
-
-    example do
-      expect(action_sequence.size).to eql(1)
-      expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Filter)
-      expect(action_sequence[0].filter_name).to eql(:foo)
-      expect(action_sequence[0].params).to eql(donkey: 123)
-    end
-  end
-
-  describe '#add_layout' do
-    let(:action_sequence) do
-      described_class.build(rep) do |b|
-        b.add_layout('/foo.*', donkey: 123)
-      end
-    end
-
-    example do
-      expect(action_sequence.size).to eql(1)
-      expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Layout)
-      expect(action_sequence[0].layout_identifier).to eql('/foo.*')
-      expect(action_sequence[0].params).to eql(donkey: 123)
-    end
-  end
-
-  describe '#add_snapshot' do
-    context 'snapshot does not yet exist' do
-      let(:action_sequence) do
-        described_class.build(rep) do |b|
-          b.add_snapshot(:before_layout, '/foo.md')
-        end
-      end
-
-      example do
-        expect(action_sequence.size).to eql(1)
-        expect(action_sequence[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
-        expect(action_sequence[0].snapshot_names).to eql([:before_layout])
-        expect(action_sequence[0].paths).to eql(['/foo.md'])
-      end
-    end
-
-    context 'snapshot already exist' do
-      it 'raises' do
-        described_class.build(rep) do |b|
-          b.add_snapshot(:before_layout, '/bar.md')
-          expect { b.add_snapshot(:before_layout, '/foo.md') }
-            .to raise_error(Nanoc::Int::Errors::CannotCreateMultipleSnapshotsWithSameName)
-        end
-      end
-    end
-  end
-
-  describe '#each' do
-    let(:action_sequence) do
-      described_class.build(rep) do |b|
-        b.add_filter(:erb, awesomeness: 'high')
-        b.add_snapshot(:bar, '/foo.md')
-        b.add_layout('/default.erb', somelayoutparam: 'yes')
-      end
-    end
-
-    example do
-      actions = []
-      action_sequence.each { |a| actions << a }
-      expect(actions.size).to eq(3)
-    end
-  end
-
-  describe '#map' do
-    let(:action_sequence) do
-      described_class.build(rep) do |b|
-        b.add_filter(:erb, awesomeness: 'high')
-        b.add_snapshot(:bar, '/foo.md')
-        b.add_layout('/default.erb', somelayoutparam: 'yes')
-      end
-    end
-
-    example do
-      res = action_sequence.map { Nanoc::Int::ProcessingActions::Filter.new(:donkey, {}) }
-      expect(res.to_a.size).to eq(3)
-      expect(res.to_a).to all(be_a(Nanoc::Int::ProcessingActions::Filter))
-    end
-  end
-
-  describe '#serialize' do
-    subject { action_sequence.serialize }
-
-    let(:action_sequence) do
-      described_class.build(rep) do |b|
-        b.add_filter(:erb, awesomeness: 'high')
-        b.add_snapshot(:bar, '/foo.md')
-        b.add_layout('/default.erb', somelayoutparam: 'yes')
-      end
-    end
-
-    example do
-      expect(subject).to eql(
-        [
-          [:filter, :erb, 'PeWUm2PtXYtqeHJdTqnY7kkwAow='],
-          [:snapshot, [:bar], true, ['/foo.md']],
-          [:layout, '/default.erb', '97LAe1pYTLKczxBsu+x4MmvqdkU='],
-        ],
-      )
-    end
-  end
-
-  describe '#snapshots_defs' do
-    let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') }
-    let(:rep) { Nanoc::Int::ItemRep.new(item, :default) }
-
-    Class.new(Nanoc::Filter) do
-      identifier :RuleMemSpec_filter_b2b
-      type :binary => :binary # rubocop:disable Style/HashSyntax
-
-      def run(content, params = {}); end
-    end
-
-    Class.new(Nanoc::Filter) do
-      identifier :RuleMemSpec_filter_b2t
-      type :binary => :text # rubocop:disable Style/HashSyntax
-
-      def run(content, params = {}); end
-    end
-
-    Class.new(Nanoc::Filter) do
-      identifier :RuleMemSpec_filter_t2t
-      type :text => :text # rubocop:disable Style/HashSyntax
-
-      def run(content, params = {}); end
-    end
-
-    Class.new(Nanoc::Filter) do
-      identifier :RuleMemSpec_filter_t2b
-      type :text => :binary # rubocop:disable Style/HashSyntax
-
-      def run(content, params = {}); end
-    end
-
-    it 'has no snapshot defs by default' do
-      action_sequence =
-        described_class.build(rep) do |b|
-        end
-
-      expect(action_sequence.snapshots_defs).to be_empty
-    end
-
-    context 'textual item' do
-      let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') }
-
-      it 'generates initial textual snapshot def' do
-        action_sequence =
-          described_class.build(rep) do |b|
-            b.add_snapshot(:giraffe, nil)
-          end
-
-        expect(action_sequence.snapshots_defs.size).to eq(1)
-        expect(action_sequence.snapshots_defs[0].name).to eq(:giraffe)
-        expect(action_sequence.snapshots_defs[0]).not_to be_binary
-      end
-
-      it 'generated follow-up textual snapshot def if previous filter is textual' do
-        action_sequence =
-          described_class.build(rep) do |b|
-            b.add_snapshot(:giraffe, nil)
-            b.add_filter(:RuleMemSpec_filter_t2t, arguments: 'irrelevant')
-            b.add_snapshot(:zebra, nil)
-          end
-
-        expect(action_sequence.snapshots_defs.size).to eq(2)
-        expect(action_sequence.snapshots_defs[0].name).to eq(:giraffe)
-        expect(action_sequence.snapshots_defs[0]).not_to be_binary
-        expect(action_sequence.snapshots_defs[1].name).to eq(:zebra)
-        expect(action_sequence.snapshots_defs[1]).not_to be_binary
-      end
-
-      it 'generated follow-up binary snapshot def if previous filter is text-to-bianry' do
-        action_sequence =
-          described_class.build(rep) do |b|
-            b.add_snapshot(:giraffe, nil)
-            b.add_filter(:RuleMemSpec_filter_t2b, arguments: 'irrelevant')
-            b.add_snapshot(:zebra, nil)
-          end
-
-        expect(action_sequence.snapshots_defs.size).to eq(2)
-        expect(action_sequence.snapshots_defs[0].name).to eq(:giraffe)
-        expect(action_sequence.snapshots_defs[0]).not_to be_binary
-        expect(action_sequence.snapshots_defs[1].name).to eq(:zebra)
-        expect(action_sequence.snapshots_defs[1]).to be_binary
-      end
-    end
-
-    context 'binary item' do
-      let(:item) { Nanoc::Int::Item.new(Nanoc::Int::BinaryContent.new('/asdf.dat'), {}, '/foo.md') }
-
-      it 'generates initial binary snapshot def' do
-        action_sequence =
-          described_class.build(rep) do |b|
-            b.add_snapshot(:giraffe, nil)
-          end
-
-        expect(action_sequence.snapshots_defs.size).to eq(1)
-        expect(action_sequence.snapshots_defs[0].name).to eq(:giraffe)
-        expect(action_sequence.snapshots_defs[0]).to be_binary
-      end
-
-      it 'generated follow-up binary snapshot def if previous filter is binary' do
-        action_sequence =
-          described_class.build(rep) do |b|
-            b.add_snapshot(:giraffe, nil)
-            b.add_filter(:RuleMemSpec_filter_b2b, arguments: 'irrelevant')
-            b.add_snapshot(:zebra, nil)
-          end
-
-        expect(action_sequence.snapshots_defs.size).to eq(2)
-        expect(action_sequence.snapshots_defs[0].name).to eq(:giraffe)
-        expect(action_sequence.snapshots_defs[0]).to be_binary
-        expect(action_sequence.snapshots_defs[1].name).to eq(:zebra)
-        expect(action_sequence.snapshots_defs[1]).to be_binary
-      end
-
-      it 'generated follow-up textual snapshot def if previous filter is binary-to-text' do
-        action_sequence =
-          described_class.build(rep) do |b|
-            b.add_snapshot(:giraffe, nil)
-            b.add_filter(:RuleMemSpec_filter_b2t, arguments: 'irrelevant')
-            b.add_snapshot(:zebra, nil)
-          end
-
-        expect(action_sequence.snapshots_defs.size).to eq(2)
-        expect(action_sequence.snapshots_defs[0].name).to eq(:giraffe)
-        expect(action_sequence.snapshots_defs[0]).to be_binary
-        expect(action_sequence.snapshots_defs[1].name).to eq(:zebra)
-        expect(action_sequence.snapshots_defs[1]).not_to be_binary
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::CodeSnippet do
-  subject(:code_snippet) { described_class.new(data, 'lib/foo.rb') }
-
-  describe '#load' do
-    subject { code_snippet.load }
-
-    describe 'calling #include' do
-      let(:data) do
-        <<~EOS
-          module CodeSnippetSpecHelper1
-            def fe345b48e4
-              "fe345b48e4"
-            end
-          end
-
-          include CodeSnippetSpecHelper1
-        EOS
-      end
-
-      it 'makes helper functions available everywhere' do
-        expect { subject }
-          .to change { [Nanoc::Int::Context.new({}).respond_to?(:fe345b48e4), Complex.respond_to?(:fe345b48e4)] }
-          .from([false, false])
-          .to([true, true])
-      end
-    end
-
-    describe 'calling #use_helper' do
-      let(:data) do
-        <<~EOS
-          module CodeSnippetSpecHelper2
-            def e0f0c30b5e
-              "e0f0c30b5e"
-            end
-          end
-
-          use_helper CodeSnippetSpecHelper2
-        EOS
-      end
-
-      it 'makes helper functions available in helpers only' do
-        expect { subject }
-          .to change { [Nanoc::Int::Context.new({}).respond_to?(:e0f0c30b5e), Complex.respond_to?(:e0f0c30b5e)] }
-          .from([false, false])
-          .to([true, false])
-      end
-    end
-
-    it 'defines at top level' do
-      @foo = 'meow'
-
-      code_snippet = Nanoc::Int::CodeSnippet.new("@foo = 'woof'", 'dog.rb')
-      code_snippet.load
-
-      expect(@foo).to eq('meow')
-    end
-  end
-end

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

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::Configuration do
-  let(:hash) { { foo: 'bar' } }
-  let(:config) { described_class.new(hash: hash) }
-
-  describe '#key?' do
-    subject { config.key?(key) }
-
-    context 'non-existent key' do
-      let(:key) { :donkey }
-      it { is_expected.not_to be }
-    end
-
-    context 'existent key' do
-      let(:key) { :foo }
-      it { is_expected.to be }
-    end
-  end
-
-  describe '#with_defaults' do
-    subject { config.with_defaults }
-
-    context 'no env' do
-      it 'has a default output_dir' do
-        expect(subject[:output_dir]).to eql('output')
-      end
-    end
-
-    context 'env' do
-      let(:config) { described_class.new(hash: hash, env_name: 'giraffes') }
-
-      it 'retains the env name' do
-        expect(subject.env_name).to eql('giraffes')
-      end
-    end
-  end
-
-  describe '#output_dir' do
-    subject { config.with_defaults.output_dir }
-
-    context 'not explicitly defined' do
-      let(:hash) { { foo: 'bar' } }
-      it { is_expected.to eql('output') }
-    end
-
-    context 'explicitly defined, top-level' do
-      let(:hash) { { foo: 'bar', output_dir: 'build' } }
-      it { is_expected.to eql('build') }
-    end
-  end
-
-  describe '#output_dirs' do
-    subject { config.with_defaults.output_dirs }
-
-    let(:hash) do
-      {
-        output_dir: 'output_toplevel',
-        environments: {
-          default: {
-            output_dir: 'output_default',
-          },
-          production: {
-            output_dir: 'output_prod',
-          },
-          staging: {
-            output_dir: 'output_staging',
-          },
-          other: {},
-        },
-      }
-    end
-
-    it 'contains both top-level and default output dir' do
-      expect(subject).to include('output_toplevel')
-      expect(subject).to include('output_default')
-    end
-
-    it 'does not contain nil' do
-      expect(subject).not_to include(nil)
-    end
-
-    it 'contains all other output dirs' do
-      expect(subject).to include('output_staging')
-      expect(subject).to include('output_prod')
-    end
-  end
-
-  describe '#merge' do
-    let(:hash1) { { foo: { bar: 'baz', baz: ['biz'] } } }
-    let(:hash2) { { foo: { bar: :boz, biz: 'buz' } } }
-    let(:config1) { described_class.new(hash: hash1) }
-    let(:config2) { described_class.new(hash: hash2) }
-
-    subject { config1.merge(config2).to_h }
-
-    it 'contains the recursive merge of both configurations' do
-      expect(subject).to include(foo: { bar: :boz, baz: ['biz'], biz: 'buz' })
-    end
-  end
-
-  context 'with environments defined' do
-    let(:hash) { { foo: 'bar', environments: { test: { foo: 'test-bar' }, default: { foo: 'default-bar' } } } }
-    let(:config) { described_class.new(hash: hash, env_name: env_name).with_environment }
-
-    subject { config }
-
-    context 'with existing environment' do
-      let(:env_name) { 'test' }
-
-      it 'inherits options from given environment' do
-        expect(subject[:foo]).to eq('test-bar')
-      end
-    end
-
-    context 'with unknown environment' do
-      let(:env_name) { 'wtf' }
-
-      it 'does not inherits options from any environment' do
-        expect(subject[:foo]).to eq('bar')
-      end
-    end
-
-    context 'without given environment' do
-      let(:env_name) { nil }
-
-      it 'inherits options from default environment' do
-        expect(subject[:foo]).to eq('default-bar')
-      end
-    end
-  end
-end