nanoc 4.4.5 → 4.4.6

data/spec/nanoc/base/views/post_compile_item_rep_view_spec.rb

@@ -0,0 +1,137 @@
+describe Nanoc::PostCompileItemRepView do
+  let(:item_rep) { Nanoc::Int::ItemRep.new(item, :jacques) }
+  let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo/') }
+  let(:view) { described_class.new(item_rep, view_context) }
+
+  let(:view_context) do
+    Nanoc::ViewContext.new(
+      reps: reps,
+      items: items,
+      dependency_tracker: dependency_tracker,
+      compilation_context: compilation_context,
+    )
+  end
+
+  let(:reps) { double(:reps) }
+  let(:items) { Nanoc::Int::IdentifiableCollection.new(config) }
+  let(:config) { Nanoc::Int::Configuration.new }
+  let(:dependency_tracker) { Nanoc::Int::DependencyTracker.new(double(:dependency_store)) }
+  let(:compilation_context) { double(:compilation_context, compiled_content_cache: compiled_content_cache) }
+
+  let(:snapshot_contents) do
+    {
+      last: Nanoc::Int::TextualContent.new('content-last'),
+      pre: Nanoc::Int::TextualContent.new('content-pre'),
+      donkey: Nanoc::Int::TextualContent.new('content-donkey'),
+    }
+  end
+
+  let(:compiled_content_cache) do
+    Nanoc::Int::CompiledContentCache.new(items: items).tap do |ccc|
+      ccc[item_rep] = snapshot_contents
+    end
+  end
+
+  describe '#compiled_content' do
+    subject { view.compiled_content }
+
+    context 'binary' do
+      let(:item) do
+        content = Nanoc::Int::Content.create('/foo.dat', binary: true)
+        Nanoc::Int::Item.new(content, {}, '/foo.dat')
+      end
+
+      it 'raises error' do
+        err = Nanoc::Int::Errors::CannotGetCompiledContentOfBinaryItem
+        expect { subject }.to raise_error(err)
+      end
+    end
+
+    shared_examples 'returns pre content' do
+      example { expect(subject).to eq('content-pre') }
+    end
+
+    shared_examples 'returns last content' do
+      example { expect(subject).to eq('content-last') }
+    end
+
+    shared_examples 'returns donkey content' do
+      example { expect(subject).to eq('content-donkey') }
+    end
+
+    shared_examples 'raises no-such-snapshot error' do
+      it 'raises error' do
+        err = Nanoc::Int::Errors::NoSuchSnapshot
+        expect { subject }.to raise_error(err)
+      end
+    end
+
+    context 'textual' do
+      context 'snapshot provided' do
+        subject { view.compiled_content(snapshot: :donkey) }
+        let(:expected_snapshot) { :donkey }
+
+        context 'snapshot exists' do
+          include_examples 'returns donkey content'
+        end
+
+        context 'snapshot does not exist' do
+          let(:snapshot_contents) do
+            {
+              last: Nanoc::Int::TextualContent.new('content-last'),
+              pre: Nanoc::Int::TextualContent.new('content-pre'),
+            }
+          end
+
+          include_examples 'raises no-such-snapshot error'
+        end
+      end
+
+      context 'no snapshot provided' do
+        context 'pre and last snapshots exist' do
+          let(:snapshot_contents) do
+            {
+              last: Nanoc::Int::TextualContent.new('content-last'),
+              pre: Nanoc::Int::TextualContent.new('content-pre'),
+              donkey: Nanoc::Int::TextualContent.new('content-donkey'),
+            }
+          end
+
+          include_examples 'returns pre content'
+        end
+
+        context 'pre snapshot exists' do
+          let(:snapshot_contents) do
+            {
+              pre: Nanoc::Int::TextualContent.new('content-pre'),
+              donkey: Nanoc::Int::TextualContent.new('content-donkey'),
+            }
+          end
+
+          include_examples 'returns pre content'
+        end
+
+        context 'last snapshot exists' do
+          let(:snapshot_contents) do
+            {
+              last: Nanoc::Int::TextualContent.new('content-last'),
+              donkey: Nanoc::Int::TextualContent.new('content-donkey'),
+            }
+          end
+
+          include_examples 'returns last content'
+        end
+
+        context 'neither pre nor last snapshot exists' do
+          let(:snapshot_contents) do
+            {
+              donkey: Nanoc::Int::TextualContent.new('content-donkey'),
+            }
+          end
+
+          include_examples 'raises no-such-snapshot error'
+        end
+      end
+    end
+  end
+end

data/spec/nanoc/base/views/post_compile_item_view_spec.rb

@@ -0,0 +1,56 @@
+describe Nanoc::PostCompileItemView do
+  let(:item) { Nanoc::Int::Item.new('blah', {}, '/foo.md') }
+  let(:rep_a) { Nanoc::Int::ItemRep.new(item, :no_mod) }
+  let(:rep_b) { Nanoc::Int::ItemRep.new(item, :modded).tap { |r| r.modified = true } }
+
+  let(:reps) do
+    Nanoc::Int::ItemRepRepo.new.tap do |reps|
+      reps << rep_a
+      reps << rep_b
+    end
+  end
+
+  let(:view_context) { double(:view_context, reps: reps) }
+  let(:view) { described_class.new(item, view_context) }
+
+  shared_examples 'a method that returns modified reps only' do
+    it 'returns only modified items' do
+      expect(subject.size).to eq(1)
+      expect(subject.map(&:name)).to eq(%i(modded))
+    end
+
+    it 'returns an array' do
+      expect(subject.class).to eql(Array)
+    end
+  end
+
+  shared_examples 'a method that returns PostCompileItemRepViews' do
+    it 'returns PostCompileItemRepViews' do
+      expect(subject).to all(be_a(Nanoc::PostCompileItemRepView))
+    end
+  end
+
+  describe '#modified_reps' do
+    subject { view.modified_reps }
+
+    it_behaves_like 'a method that returns modified reps only'
+    it_behaves_like 'a method that returns PostCompileItemRepViews'
+  end
+
+  describe '#modified' do
+    subject { view.modified }
+
+    it_behaves_like 'a method that returns modified reps only'
+    it_behaves_like 'a method that returns PostCompileItemRepViews'
+  end
+
+  describe '#reps' do
+    subject { view.reps }
+
+    it_behaves_like 'a method that returns PostCompileItemRepViews'
+
+    it 'returns a PostCompileItemRepCollectionView' do
+      expect(subject).to be_a(Nanoc::PostCompileItemRepCollectionView)
+    end
+  end
+end

data/spec/nanoc/cli/commands/compile/file_action_printer_spec.rb

@@ -0,0 +1,76 @@
+describe Nanoc::CLI::Commands::Compile::FileActionPrinter, stdio: true do
+  let(:listener) { described_class.new(reps: reps) }
+
+  before { Timecop.freeze(Time.local(2008, 1, 2, 14, 5, 0)) }
+  after { Timecop.return }
+
+  let(:reps) do
+    Nanoc::Int::ItemRepRepo.new.tap do |reps|
+      reps << rep
+    end
+  end
+
+  let(:item) { Nanoc::Int::Item.new('<%= 1 + 2 %>', {}, '/hi.md') }
+
+  let(:rep) do
+    Nanoc::Int::ItemRep.new(item, :default).tap do |rep|
+      rep.raw_paths = { default: '/hi.html' }
+    end
+  end
+
+  it 'records from compilation_started to rep_written' do
+    listener.start
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+
+    expect { Nanoc::Int::NotificationCenter.post(:rep_written, rep, '/foo.html', true, true) }
+      .to output(/create.*\[1\.00s\]/).to_stdout
+  end
+
+  it 'stops listening after #stop' do
+    listener.start
+    listener.stop
+
+    Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
+
+    expect { Nanoc::Int::NotificationCenter.post(:rep_written, rep, '/foo.html', true, true) }
+      .not_to output(/create/).to_stdout
+  end
+
+  it 'records from compilation_started over compilation_suspended to rep_written' do
+    listener.start
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:compilation_suspended, rep, :__irrelevant__)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 3))
+    Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 6))
+
+    expect { Nanoc::Int::NotificationCenter.post(:rep_written, rep, '/foo.html', true, true) }
+      .to output(/create.*\[4\.00s\]/).to_stdout
+  end
+
+  context 'log level = high' do
+    before { listener.start }
+    before { Nanoc::CLI::Logger.instance.level = :high }
+
+    it 'prints skipped (uncompiled) reps' do
+      expect { listener.stop }
+        .not_to output(/skip/).to_stdout
+    end
+  end
+
+  context 'log level = low' do
+    before { listener.start }
+    before { Nanoc::CLI::Logger.instance.level = :low }
+
+    it 'prints nothing' do
+      expect { listener.stop }
+        .to output(/skip.*\/hi\.html/).to_stdout
+    end
+  end
+end

data/spec/nanoc/cli/commands/compile/timing_recorder_spec.rb

@@ -0,0 +1,66 @@
+describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
+  let(:listener) { described_class.new(reps: reps) }
+
+  before { Timecop.freeze(Time.local(2008, 1, 2, 14, 5, 0)) }
+  after { Timecop.return }
+
+  let(:reps) do
+    Nanoc::Int::ItemRepRepo.new.tap do |reps|
+      reps << rep
+    end
+  end
+
+  let(:item) { Nanoc::Int::Item.new('<%= 1 + 2 %>', {}, '/hi.md') }
+
+  let(:rep) do
+    Nanoc::Int::ItemRep.new(item, :default).tap do |rep|
+      rep.raw_paths = { default: '/hi.html' }
+    end
+  end
+
+  it 'records single from filtering_started to filtering_ended' do
+    listener.start
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb)
+
+    expect { listener.stop }
+      .to output(/^erb \|     1  1\.00s  1\.00s  1\.00s   1\.00s$/).to_stdout
+  end
+
+  it 'records multiple from filtering_started to filtering_ended' do
+    listener.start
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 14, 1))
+    Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 14, 3))
+    Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb)
+
+    expect { listener.stop }
+      .to output(/^erb \|     2  1\.00s  1\.50s  2\.00s   3\.00s$/).to_stdout
+  end
+
+  it 'records single from filtering_started over compilation_{suspended,started} to filtering_ended' do
+    listener.start
+
+    Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:compilation_suspended, rep, :__anything__)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 3))
+    Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 7))
+    Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb)
+
+    # FIXME: wrong count (should be 1, not 2)
+    expect { listener.stop }
+      .to output(/^erb \|     2  1\.00s  2\.50s  4\.00s   5\.00s$/).to_stdout
+  end
+end

data/spec/nanoc/cli/commands/compile_spec.rb

@@ -0,0 +1,64 @@
+describe Nanoc::CLI::Commands::Compile::Listener do
+  let(:klass) do
+    Class.new(described_class) do
+      attr_reader :started
+      attr_reader :stopped
+
+      def initialize
+        @started = false
+        @stopped = false
+      end
+
+      def start
+        @started = true
+      end
+
+      def stop
+        @stopped = true
+      end
+    end
+  end
+
+  subject { klass.new }
+
+  it 'starts' do
+    subject.start
+    expect(subject.started).to be
+  end
+
+  it 'stops' do
+    subject.start
+    subject.stop
+    expect(subject.stopped).to be
+  end
+
+  it 'starts safely' do
+    subject.start_safely
+    expect(subject.started).to be
+  end
+
+  it 'stops safely' do
+    subject.start_safely
+    subject.stop_safely
+    expect(subject.stopped).to be
+  end
+
+  context 'listener that does not start or stop properly' do
+    let(:klass) do
+      Class.new(described_class) do
+        def start
+          raise 'boom'
+        end
+
+        def stop
+          raise 'boom'
+        end
+      end
+    end
+
+    it 'raises on start, but not stop' do
+      expect { subject.start_safely }.to raise_error(RuntimeError)
+      expect { subject.stop_safely }.not_to raise_error
+    end
+  end
+end