nanoc 4.4.5 → 4.4.6

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

@@ -0,0 +1,131 @@
+describe Nanoc::Int::RuleMemory do
+  let(:rule_memory) { described_class.new(rep) }
+  let(:rep) { double(:rep) }
+
+  describe '#size' do
+    subject { rule_memory.size }
+
+    context 'no actions' do
+      it { is_expected.to eql(0) }
+    end
+
+    context 'some actions' do
+      before do
+        rule_memory.add_filter(:foo, {})
+      end
+
+      it { is_expected.to eql(1) }
+    end
+  end
+
+  describe '#[]' do
+    subject { rule_memory[index] }
+    let(:index) { 0 }
+
+    context 'no actions' do
+      it { is_expected.to be_nil }
+    end
+
+    context 'some actions' do
+      before do
+        rule_memory.add_filter(:foo, {})
+      end
+
+      it { is_expected.to be_a(Nanoc::Int::ProcessingActions::Filter) }
+    end
+  end
+
+  describe '#add_filter' do
+    example do
+      rule_memory.add_filter(:foo, donkey: 123)
+
+      expect(rule_memory.size).to eql(1)
+      expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Filter)
+      expect(rule_memory[0].filter_name).to eql(:foo)
+      expect(rule_memory[0].params).to eql(donkey: 123)
+    end
+  end
+
+  describe '#add_layout' do
+    example do
+      rule_memory.add_layout('/foo.*', donkey: 123)
+
+      expect(rule_memory.size).to eql(1)
+      expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Layout)
+      expect(rule_memory[0].layout_identifier).to eql('/foo.*')
+      expect(rule_memory[0].params).to eql(donkey: 123)
+    end
+  end
+
+  describe '#add_snapshot' do
+    context 'snapshot does not yet exist' do
+      example do
+        rule_memory.add_snapshot(:before_layout, '/foo.md')
+
+        expect(rule_memory.size).to eql(1)
+        expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot)
+        expect(rule_memory[0].snapshot_name).to eql(:before_layout)
+        expect(rule_memory[0].path).to eql('/foo.md')
+      end
+    end
+
+    context 'snapshot already exist' do
+      before do
+        rule_memory.add_snapshot(:before_layout, '/bar.md')
+      end
+
+      it 'raises' do
+        expect { rule_memory.add_snapshot(:before_layout, '/foo.md') }
+          .to raise_error(Nanoc::Int::Errors::CannotCreateMultipleSnapshotsWithSameName)
+      end
+    end
+  end
+
+  describe '#each' do
+    before do
+      rule_memory.add_filter(:erb, awesomeness: 'high')
+      rule_memory.add_snapshot(:bar, '/foo.md')
+      rule_memory.add_layout('/default.erb', somelayoutparam: 'yes')
+    end
+
+    example do
+      actions = []
+      rule_memory.each { |a| actions << a }
+      expect(actions.size).to eq(3)
+    end
+  end
+
+  describe '#map' do
+    before do
+      rule_memory.add_filter(:erb, awesomeness: 'high')
+      rule_memory.add_snapshot(:bar, '/foo.md')
+      rule_memory.add_layout('/default.erb', somelayoutparam: 'yes')
+    end
+
+    example do
+      res = rule_memory.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 { rule_memory.serialize }
+
+    before do
+      rule_memory.add_filter(:erb, awesomeness: 'high')
+      rule_memory.add_snapshot(:bar, '/foo.md')
+      rule_memory.add_layout('/default.erb', somelayoutparam: 'yes')
+    end
+
+    example do
+      expect(subject).to eql(
+        [
+          [:filter, :erb, 'PeWUm2PtXYtqeHJdTqnY7kkwAow='],
+          [:snapshot, :bar, true, '/foo.md'],
+          [:layout, '/default.erb', '97LAe1pYTLKczxBsu+x4MmvqdkU='],
+        ],
+      )
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+describe Nanoc::Int::Site do
+  describe '#freeze' do
+    let(:site) do
+      described_class.new(
+        config: config,
+        code_snippets: code_snippets,
+        items: items,
+        layouts: 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::IdentifiableCollection.new(config).tap do |coll|
+        coll << Nanoc::Int::Item.new('foo', {}, '/foo.md')
+        coll << Nanoc::Int::Item.new('bar', {}, '/bar.md')
+      end
+    end
+
+    let(:layouts) do
+      Nanoc::Int::IdentifiableCollection.new(config).tap do |coll|
+        coll << Nanoc::Int::Layout.new('foo', {}, '/foo.md')
+        coll << Nanoc::Int::Layout.new('bar', {}, '/bar.md')
+      end
+    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/feature_spec.rb

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

@@ -0,0 +1,99 @@
+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 '#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::ItemWithRepsView.new(item, view_context) }
+    let(:rep) { Nanoc::Int::ItemRep.new(item, :default) }
+
+    let(:view_context) do
+      Nanoc::ViewContext.new(
+        reps: reps,
+        items: double(:items),
+        dependency_tracker: dependency_tracker,
+        compilation_context: double(:compilation_context),
+      )
+    end
+
+    let(:dependency_tracker) { double(:dependency_tracker) }
+
+    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)
+    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
+  end
+end

data/spec/nanoc/base/item_rep_writer_spec.rb

@@ -0,0 +1,131 @@
+describe Nanoc::Int::ItemRepWriter do
+  describe '#write' do
+    let(:raw_path) { 'output/blah.dat' }
+
+    let(:item) { Nanoc::Int::Item.new(orig_content, {}, '/') }
+
+    let(:item_rep) do
+      Nanoc::Int::ItemRep.new(item, :default).tap do |ir|
+        ir.snapshot_contents = snapshot_contents
+        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
+
+    subject { described_class.new.write(item_rep, snapshot_name) }
+
+    before do
+      expect(File.directory?('output')).to be_falsy
+    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, '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, '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

data/spec/nanoc/base/plugin_registry_spec.rb

@@ -0,0 +1,29 @@
+describe Nanoc::Int::PluginRegistry do
+  describe '.identifier(s)' do
+    let(:identifier) { :ce79f6b8ddb22233e9aaf7d8f011689492acf02f }
+
+    context 'direct subclass' do
+      example do
+        klass =
+          Class.new(Nanoc::Filter) do
+            identifier :plugin_registry_spec
+          end
+
+        expect(klass.identifier).to eql(:plugin_registry_spec)
+      end
+    end
+
+    context 'indirect subclass' do
+      example do
+        superclass = Class.new(Nanoc::Filter)
+
+        klass =
+          Class.new(superclass) do
+            identifier :plugin_registry_spec
+          end
+
+        expect(klass.identifier).to eql(:plugin_registry_spec)
+      end
+    end
+  end
+end

data/spec/nanoc/base/repos/checksum_store_spec.rb

@@ -0,0 +1,133 @@
+describe Nanoc::Int::ChecksumStore do
+  let(:store) { described_class.new(objects: objects) }
+
+  let(:objects) { [item, code_snippet] }
+
+  let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') }
+  let(:other_item) { Nanoc::Int::Item.new('asdf', {}, '/sneaky.md') }
+
+  let(:code_snippet) { Nanoc::Int::CodeSnippet.new('def hi ; end', 'lib/foo.rb') }
+  let(:other_code_snippet) { Nanoc::Int::CodeSnippet.new('def ho ; end', 'lib/bar.rb') }
+
+  context 'nothing added' do
+    it 'has no checksum' do
+      expect(store[item]).to be_nil
+    end
+
+    it 'has no content checksum' do
+      expect(store.content_checksum_for(item)).to be_nil
+    end
+
+    it 'has no attributes checksum' do
+      expect(store.attributes_checksum_for(item)).to be_nil
+    end
+  end
+
+  context 'setting content on known non-document' do
+    before { store.add(code_snippet) }
+
+    it 'has checksum' do
+      expect(store[code_snippet]).not_to be_nil
+    end
+
+    it 'has no content checksum' do
+      expect(store.content_checksum_for(code_snippet)).to be_nil
+    end
+
+    it 'has no attributes checksum' do
+      expect(store.attributes_checksum_for(code_snippet)).to be_nil
+    end
+
+    context 'after storing and loading' do
+      before do
+        store.store
+        store.load
+      end
+
+      it 'has checksum' do
+        expect(store[code_snippet]).not_to be_nil
+      end
+    end
+  end
+
+  context 'setting content on unknown non-document' do
+    before { store.add(other_code_snippet) }
+
+    it 'has checksum' do
+      expect(store[other_code_snippet]).not_to be_nil
+    end
+
+    it 'has no content checksum' do
+      expect(store.content_checksum_for(other_code_snippet)).to be_nil
+    end
+
+    it 'has no attributes checksum' do
+      expect(store.attributes_checksum_for(other_code_snippet)).to be_nil
+    end
+
+    context 'after storing and loading' do
+      before do
+        store.store
+        store.load
+      end
+
+      it 'has no checksum' do
+        expect(store[other_code_snippet]).to be_nil
+      end
+    end
+  end
+
+  context 'setting content on known item' do
+    before { store.add(item) }
+
+    it 'has checksum' do
+      expect(store[item]).not_to be_nil
+    end
+
+    it 'has content checksum' do
+      expect(store.content_checksum_for(item)).not_to be_nil
+    end
+
+    it 'has attributes checksum' do
+      expect(store.attributes_checksum_for(item)).not_to be_nil
+    end
+
+    context 'after storing and loading' do
+      before do
+        store.store
+        store.load
+      end
+
+      it 'has checksum' do
+        expect(store[item]).not_to be_nil
+      end
+    end
+  end
+
+  context 'setting content on unknown item' do
+    before { store.add(other_item) }
+
+    it 'has checksum' do
+      expect(store[other_item]).not_to be_nil
+    end
+
+    it 'has content checksum' do
+      expect(store.content_checksum_for(other_item)).not_to be_nil
+    end
+
+    it 'has attributes checksum' do
+      expect(store.attributes_checksum_for(other_item)).not_to be_nil
+    end
+
+    context 'after storing and loading' do
+      before do
+        store.store
+        store.load
+      end
+
+      it 'has no checksum' do
+        expect(store[other_item]).to be_nil
+      end
+    end
+  end
+end