nanoc 4.8.12 → 4.8.13

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::Site do
-  describe '#freeze' do
-    let(:site) do
-      described_class.new(
-        config: config,
-        code_snippets: code_snippets,
-        data_source: Nanoc::Int::InMemDataSource.new(items, layouts),
-      )
-    end
-
-    let(:config) do
-      Nanoc::Int::Configuration.new.with_defaults
-    end
-
-    let(:code_snippets) do
-      [
-        Nanoc::Int::CodeSnippet.new('FOO = 123', 'hello.rb'),
-        Nanoc::Int::CodeSnippet.new('BAR = 123', 'hi.rb'),
-      ]
-    end
-
-    let(:items) do
-      Nanoc::Int::ItemCollection.new(
-        config,
-        [
-          Nanoc::Int::Item.new('foo', {}, '/foo.md'),
-          Nanoc::Int::Item.new('bar', {}, '/bar.md'),
-        ],
-      )
-    end
-
-    let(:layouts) do
-      Nanoc::Int::LayoutCollection.new(
-        config,
-        [
-          Nanoc::Int::Layout.new('foo', {}, '/foo.md'),
-          Nanoc::Int::Layout.new('bar', {}, '/bar.md'),
-        ],
-      )
-    end
-
-    before do
-      site.freeze
-    end
-
-    it 'freezes the configuration' do
-      expect(site.config).to be_frozen
-    end
-
-    it 'freezes the configuration contents' do
-      expect(site.config[:output_dir]).to be_frozen
-    end
-
-    it 'freezes items collection' do
-      expect(site.items).to be_frozen
-    end
-
-    it 'freezes individual items' do
-      expect(site.items).to all(be_frozen)
-    end
-
-    it 'freezes layouts collection' do
-      expect(site.layouts).to be_frozen
-    end
-
-    it 'freezes individual layouts' do
-      expect(site.layouts).to all(be_frozen)
-    end
-
-    it 'freezes code snippets collection' do
-      expect(site.code_snippets).to be_frozen
-    end
-
-    it 'freezes individual code snippets' do
-      expect(site.code_snippets).to all(be_frozen)
-    end
-  end
-end

data/spec/nanoc/base/errors/dependency_cycle_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::Errors::DependencyCycle do
-  subject(:error) { described_class.new(stack) }
-
-  let(:stack) do
-    [
-      rep_a,
-      rep_b,
-      rep_c,
-      rep_d,
-      rep_e,
-      rep_b,
-    ]
-  end
-
-  let(:rep_a) { Nanoc::Int::ItemRep.new(Nanoc::Int::Item.new('a', {}, '/a.md'), :default) }
-  let(:rep_b) { Nanoc::Int::ItemRep.new(Nanoc::Int::Item.new('b', {}, '/b.md'), :default) }
-  let(:rep_c) { Nanoc::Int::ItemRep.new(Nanoc::Int::Item.new('c', {}, '/c.md'), :default) }
-  let(:rep_d) { Nanoc::Int::ItemRep.new(Nanoc::Int::Item.new('d', {}, '/d.md'), :default) }
-  let(:rep_e) { Nanoc::Int::ItemRep.new(Nanoc::Int::Item.new('e', {}, '/e.md'), :default) }
-
-  it 'has an informative error message' do
-    expected = <<~EOS
-      The site cannot be compiled because there is a dependency cycle:
-
-          (1) item /b.md, rep :default, uses compiled content of
-          (2) item /c.md, rep :default, uses compiled content of
-          (3) item /d.md, rep :default, uses compiled content of
-          (4) item /e.md, rep :default, uses compiled content of (1)
-EOS
-
-    expect(error.message).to eql(expected)
-  end
-end

data/spec/nanoc/base/feature_spec.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Feature do
-  describe '.enabled?' do
-    subject { described_class.enabled?(feature_name) }
-
-    let(:feature_name) { 'magic' }
-
-    before do
-      Nanoc::Feature.reset_caches
-      ENV['NANOC_FEATURES'] = +''
-    end
-
-    context 'not set' do
-      it { is_expected.not_to be }
-    end
-
-    context 'set to list not including feature' do
-      before { ENV['NANOC_FEATURES'] = 'foo,bar' }
-      it { is_expected.not_to be }
-    end
-
-    context 'set to all' do
-      before { ENV['NANOC_FEATURES'] = 'all' }
-      it { is_expected.to be }
-    end
-
-    context 'set to list including feature' do
-      before { ENV['NANOC_FEATURES'] = 'foo,magic,bar' }
-      it { is_expected.to be }
-    end
-  end
-
-  describe '.enable' do
-    subject do
-      described_class.enable(feature_name) do
-        Nanoc::Feature.enabled?(feature_name)
-      end
-    end
-
-    let(:feature_name) { 'magic' }
-
-    before do
-      Nanoc::Feature.reset_caches
-      ENV['NANOC_FEATURES'] = +''
-    end
-
-    context 'not set' do
-      it { is_expected.to be }
-
-      it 'unsets afterwards' do
-        expect(Nanoc::Feature.enabled?(feature_name)).not_to be
-      end
-    end
-
-    context 'set to list not including feature' do
-      before { ENV['NANOC_FEATURES'] = 'foo,bar' }
-      it { is_expected.to be }
-
-      it 'unsets afterwards' do
-        expect(Nanoc::Feature.enabled?(feature_name)).not_to be
-      end
-    end
-
-    context 'set to all' do
-      before { ENV['NANOC_FEATURES'] = 'all' }
-      it { is_expected.to be }
-    end
-
-    context 'set to list including feature' do
-      before { ENV['NANOC_FEATURES'] = 'foo,magic,bar' }
-      it { is_expected.to be }
-    end
-  end
-
-  describe '.all_outdated' do
-    it 'refuses outdated features' do
-      # If this spec fails, there are features marked as experimental in the previous minor or major
-      # release, but not in the current one. Either remove the feature, or mark it as experimental
-      # in the current release.
-      expect(Nanoc::Feature.all_outdated).to be_empty
-    end
-
-    describe 'fake outdated features' do
-      before { Nanoc::Feature.define('abc', version: '4.2.x') }
-      after { Nanoc::Feature.undefine('abc') }
-
-      it 'detects outdated features' do
-        expect(Nanoc::Feature.all_outdated).to eq(['abc'])
-      end
-    end
-  end
-
-  describe '.define and .undefine' do
-    let(:feature_name) { 'testing123' }
-    after { Nanoc::Feature.undefine(feature_name) if defined?(Nanoc::Feature::TESTING123) }
-
-    it 'can define' do
-      Nanoc::Feature.define(feature_name, version: '4.3.x')
-      expect(Nanoc::Feature::TESTING123).not_to be_nil
-    end
-
-    it 'can undefine' do
-      Nanoc::Feature.define(feature_name, version: '4.3.x')
-      Nanoc::Feature.undefine(feature_name)
-      expect { Nanoc::Feature::TESTING123 }.to raise_error(NameError)
-    end
-  end
-end

data/spec/nanoc/base/filter_spec.rb

@@ -1,166 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Filter do
-  describe '.define' do
-    context 'simple filter' do
-      let(:filter_name) { :b5355bbb4d772b9853d21be57da614dba521dbbb }
-      let(:filter_class) { Nanoc::Filter.named(filter_name) }
-
-      before do
-        Nanoc::Filter.define(filter_name) do |content, _params|
-          content.upcase
-        end
-      end
-
-      it 'defines a filter' do
-        expect(filter_class).not_to be_nil
-      end
-
-      it 'defines a callable filter' do
-        expect(filter_class.new.run('foo', {})).to eql('FOO')
-      end
-    end
-
-    context 'filter that accesses assigns' do
-      let(:filter_name) { :d7ed105d460e99a3d38f46af023d9490c140fdd9 }
-      let(:filter_class) { Nanoc::Filter.named(filter_name) }
-      let(:filter) { filter_class.new(assigns) }
-      let(:assigns) { { animal: 'Giraffe' } }
-
-      before do
-        Nanoc::Filter.define(filter_name) do |_content, _params|
-          @animal
-        end
-      end
-
-      it 'can access assigns' do
-        expect(filter.setup_and_run(:__irrelevant__, {})).to eq('Giraffe')
-      end
-    end
-  end
-
-  describe '.always_outdated? + .always_outdated' do
-    context 'not always outdated' do
-      let(:filter_class) do
-        Class.new(Nanoc::Filter) do
-          identifier :bea22a356b6b031cea1e615087179803818c6a53
-
-          def run(content, _params)
-            content.upcase
-          end
-        end
-      end
-
-      it 'is not always outdated' do
-        expect(filter_class).not_to be_always_outdated
-      end
-    end
-
-    context 'always outdated' do
-      let(:filter_class) do
-        Class.new(Nanoc::Filter) do
-          identifier :d7413fa71223e5e69b03a0abfa25806e07e14f3a
-
-          always_outdated
-
-          def run(content, _params)
-            content.upcase
-          end
-        end
-      end
-
-      it 'is always outdated' do
-        expect(filter_class).to be_always_outdated
-      end
-    end
-  end
-
-  describe '#depend_on' do
-    subject { filter.depend_on(item_views) }
-
-    let(:filter) { Nanoc::Filters::ERB.new(assigns) }
-    let(:item_views) { [item_view] }
-
-    let(:item) { Nanoc::Int::Item.new('foo', {}, '/stuff.md') }
-    let(:item_view) { Nanoc::CompilationItemView.new(item, view_context) }
-    let(:rep) { Nanoc::Int::ItemRep.new(item, :default) }
-
-    let(:view_context) do
-      Nanoc::ViewContextForCompilation.new(
-        reps:                reps,
-        items:               Nanoc::Int::ItemCollection.new(config),
-        dependency_tracker:  dependency_tracker,
-        compilation_context: double(:compilation_context),
-        snapshot_repo:       double(:snapshot_repo),
-      )
-    end
-
-    let(:dependency_tracker) { double(:dependency_tracker) }
-    let(:config) { Nanoc::Int::Configuration.new }
-
-    let(:reps) { Nanoc::Int::ItemRepRepo.new }
-
-    let(:assigns) do
-      {
-        item: item_view,
-      }
-    end
-
-    before do
-      reps << rep
-
-      expect(dependency_tracker).to receive(:bounce).with(item, compiled_content: true).at_least(:once)
-    end
-
-    context 'rep is compiled' do
-      before do
-        rep.compiled = true
-      end
-
-      example do
-        expect { subject }.not_to yield_from_fiber(an_instance_of(Nanoc::Int::Errors::UnmetDependency))
-      end
-    end
-
-    context 'rep is not compiled' do
-      example do
-        fiber = Fiber.new { subject }
-
-        # resume 1
-        res = fiber.resume
-        expect(res).to be_a(Nanoc::Int::Errors::UnmetDependency)
-        expect(res.rep).to eql(rep)
-
-        # resume 2
-        expect(fiber.resume).not_to be_a(Nanoc::Int::Errors::UnmetDependency)
-      end
-    end
-
-    context 'multiple reps exist' do
-      let(:other_rep) { Nanoc::Int::ItemRep.new(item, :default) }
-
-      before do
-        reps << other_rep
-        rep.compiled = false
-        other_rep.compiled = false
-      end
-
-      it 'yields an unmet dependency error twice' do
-        fiber = Fiber.new { subject }
-
-        # resume 1
-        res = fiber.resume
-        expect(res).to be_a(Nanoc::Int::Errors::UnmetDependency)
-        expect(res.rep).to eql(rep)
-
-        # resume 2
-        res = fiber.resume
-        expect(res).to be_a(Nanoc::Int::Errors::UnmetDependency)
-        expect(res.rep).to eql(other_rep)
-
-        # resume 3
-        expect(fiber.resume).not_to be_a(Nanoc::Int::Errors::UnmetDependency)
-      end
-    end
-  end
-end

data/spec/nanoc/base/item_rep_writer_spec.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-describe Nanoc::Int::ItemRepWriter do
-  describe '#write' do
-    let(:raw_path) { 'output/blah.dat' }
-
-    let(:item) { Nanoc::Int::Item.new(orig_content, {}, '/foo') }
-
-    let(:item_rep) do
-      Nanoc::Int::ItemRep.new(item, :default).tap do |ir|
-        ir.raw_paths = raw_paths
-      end
-    end
-
-    let(:snapshot_contents) do
-      {
-        last: Nanoc::Int::TextualContent.new('last content'),
-        donkey: Nanoc::Int::TextualContent.new('donkey content'),
-      }
-    end
-
-    let(:snapshot_name) { :donkey }
-
-    let(:raw_paths) do
-      { snapshot_name => [raw_path] }
-    end
-
-    let(:snapshot_repo) { Nanoc::Int::SnapshotRepo.new }
-
-    let(:written_paths) { [] }
-
-    subject { described_class.new.write(item_rep, snapshot_repo, snapshot_name, written_paths) }
-
-    before do
-      expect(File.directory?('output')).to be_falsy
-
-      snapshot_contents.each_pair do |key, value|
-        snapshot_repo.set(item_rep, key, value)
-      end
-    end
-
-    context 'binary item rep' do
-      let(:orig_content) { Nanoc::Int::BinaryContent.new(File.expand_path('foo.dat')) }
-
-      let(:snapshot_contents) do
-        {
-          last: Nanoc::Int::BinaryContent.new(File.expand_path('input-last.dat')),
-          donkey: Nanoc::Int::BinaryContent.new(File.expand_path('input-donkey.dat')),
-        }
-      end
-
-      before do
-        File.write(snapshot_contents[:last].filename, 'binary last stuff')
-        File.write(snapshot_contents[:donkey].filename, 'binary donkey stuff')
-      end
-
-      it 'copies' do
-        expect(Nanoc::Int::NotificationCenter).to receive(:post)
-          .with(:will_write_rep, item_rep, 'output/blah.dat')
-        expect(Nanoc::Int::NotificationCenter).to receive(:post)
-          .with(:rep_written, item_rep, true, 'output/blah.dat', true, true)
-
-        subject
-
-        expect(File.read('output/blah.dat')).to eql('binary donkey stuff')
-      end
-
-      context 'output file already exists' do
-        let(:old_mtime) { Time.at((Time.now - 600).to_i) }
-
-        before do
-          FileUtils.mkdir_p('output')
-          File.write('output/blah.dat', old_content)
-          FileUtils.touch('output/blah.dat', mtime: old_mtime)
-        end
-
-        context 'file is identical' do
-          let(:old_content) { 'binary donkey stuff' }
-
-          it 'keeps mtime' do
-            subject
-            expect(File.mtime('output/blah.dat')).to eql(old_mtime)
-          end
-        end
-
-        context 'file is not identical' do
-          let(:old_content) { 'other binary donkey stuff' }
-
-          it 'updates mtime' do
-            subject
-            expect(File.mtime('output/blah.dat')).to be > (Time.now - 1)
-          end
-        end
-      end
-    end
-
-    context 'textual item rep' do
-      let(:orig_content) { Nanoc::Int::TextualContent.new('Hallo Welt') }
-
-      it 'writes' do
-        expect(Nanoc::Int::NotificationCenter).to receive(:post)
-          .with(:will_write_rep, item_rep, 'output/blah.dat')
-        expect(Nanoc::Int::NotificationCenter).to receive(:post)
-          .with(:rep_written, item_rep, false, 'output/blah.dat', true, true)
-
-        subject
-
-        expect(File.read('output/blah.dat')).to eql('donkey content')
-      end
-
-      context 'output file already exists' do
-        let(:old_mtime) { Time.at((Time.now - 600).to_i) }
-
-        before do
-          FileUtils.mkdir_p('output')
-          File.write('output/blah.dat', old_content)
-          FileUtils.touch('output/blah.dat', mtime: old_mtime)
-        end
-
-        context 'file is identical' do
-          let(:old_content) { 'donkey content' }
-
-          it 'keeps mtime' do
-            subject
-            expect(File.mtime('output/blah.dat')).to eql(old_mtime)
-          end
-        end
-
-        context 'file is not identical' do
-          let(:old_content) { 'other donkey content' }
-
-          it 'updates mtime' do
-            subject
-            expect(File.mtime('output/blah.dat')).to be > (Time.now - 1)
-          end
-        end
-      end
-    end
-  end
-end