nanoc 4.6.4 → 4.7.0

data/lib/nanoc/cli/commands/nanoc.rb

@@ -24,8 +24,9 @@ opt :C, :'no-color', 'disable color' do
   $stderr.add_stream_cleaner(Nanoc::CLI::StreamCleaners::ANSIColors)
 end
 
-opt :V, :verbose, 'make output more detailed' do
+opt :V, :verbose, 'make output more detailed', multiple: true do |val|
   Nanoc::CLI::Logger.instance.level = :low
+  Nanoc::CLI.verbosity = val.size
 end
 
 opt :v, :version, 'show version information and quit' do

data/lib/nanoc/cli/error_handler.rb

@@ -179,6 +179,7 @@ module Nanoc::CLI
       'builder'        => 'builder',
       'coderay'        => 'coderay',
       'cri'            => 'cri',
+      'erubi'          => 'erubi',
       'erubis'         => 'erubis',
       'escape'         => 'escape',
       'fog'            => 'fog',

data/lib/nanoc/filters.rb

@@ -7,6 +7,7 @@ require_relative 'filters/bluecloth'
 require_relative 'filters/colorize_syntax'
 require_relative 'filters/coffeescript'
 require_relative 'filters/erb'
+require_relative 'filters/erubi'
 require_relative 'filters/erubis'
 require_relative 'filters/haml'
 require_relative 'filters/handlebars'

data/lib/nanoc/filters/erubi.rb

@@ -0,0 +1,27 @@
+module Nanoc::Filters
+  # @api private
+  class Erubi < Nanoc::Filter
+    identifier :erubi
+
+    requires 'erubi'
+
+    # Runs the content through [Erubi](https://github.com/jeremyevans/erubi).
+    # To prevent single quote escaping use :escapefunc => 'Nanoc::Helpers::HTMLEscape.html_escape'
+    # See the Erubi documentation for more options.
+    #
+    # @param [String] content The content to filter
+    #
+    # @return [String] The filtered content
+    def run(content, params = {})
+      # Create context
+      context = ::Nanoc::Int::Context.new(assigns)
+
+      # Get binding
+      proc = assigns[:content] ? -> { assigns[:content] } : nil
+      assigns_binding = context.get_binding(&proc)
+
+      # Get result
+      eval(::Erubi::Engine.new(content, { bufvar: '_erbout', filename: filename }.merge(params)).src, assigns_binding)
+    end
+  end
+end

data/lib/nanoc/rule_dsl/rule_context.rb

@@ -73,11 +73,25 @@ module Nanoc::RuleDSL
     # @param [String] path
     #
     # @return [void]
-    def write(path)
+    def write(arg)
       @_write_snapshot_counter ||= 0
       snapshot_name = "_#{@_write_snapshot_counter}".to_sym
       @_write_snapshot_counter += 1
-      snapshot(snapshot_name, path: path)
+
+      case arg
+      when String, Nanoc::Identifier
+        snapshot(snapshot_name, path: arg)
+      when Hash
+        if arg.key?(:ext)
+          ext = arg[:ext].sub(/\A\./, '')
+          path = @item.identifier.without_exts + '.' + ext
+          snapshot(snapshot_name, path: path)
+        else
+          raise ArgumentError, 'Cannot call #write this way (need path or :ext)'
+        end
+      else
+        raise ArgumentError, 'Cannot call #write this way (need path or :ext)'
+      end
     end
   end
 end

data/lib/nanoc/telemetry/labelled_counter.rb

@@ -4,23 +4,23 @@ module Nanoc::Telemetry
       @counters = {}
     end
 
-    def increment(labels)
-      get(labels).increment
+    def increment(label)
+      get(label).increment
     end
 
-    def get(labels)
-      @counters.fetch(labels) { @counters[labels] = Counter.new }
+    def get(label)
+      @counters.fetch(label) { @counters[label] = Counter.new }
     end
 
-    # TODO: add #labels
+    # TODO: add #empty?
 
-    def value(labels)
-      get(labels).value
+    def value(label)
+      get(label).value
     end
 
     def values
-      @counters.each_with_object({}) do |(labels, counter), res|
-        res[labels] = counter.value
+      @counters.each_with_object({}) do |(label, counter), res|
+        res[label] = counter.value
       end
     end
   end

data/lib/nanoc/telemetry/labelled_summary.rb

@@ -4,28 +4,32 @@ module Nanoc::Telemetry
       @summaries = {}
     end
 
-    def observe(value, labels)
-      get(labels).observe(value)
+    def observe(value, label)
+      get(label).observe(value)
     end
 
-    def get(labels)
-      @summaries.fetch(labels) { @summaries[labels] = Summary.new }
+    def get(label)
+      @summaries.fetch(label) { @summaries[label] = Summary.new }
     end
 
-    def labels
-      @summaries.keys
+    def empty?
+      @summaries.empty?
     end
 
-    def quantile(fraction, labels)
-      get(labels).quantile(fraction)
+    def quantile(fraction, label)
+      get(label).quantile(fraction)
+    end
+
+    def map
+      @summaries.map { |(label, summary)| yield(label, summary) }
     end
 
     # TODO: add quantiles(fraction)
-    # TODO: add min(labels)
+    # TODO: add min(label)
     # TODO: add mins
-    # TODO: add max(labels)
+    # TODO: add max(label)
     # TODO: add maxs
-    # TODO: add sum(labels)
+    # TODO: add sum(label)
     # TODO: add sums
   end
 end

data/lib/nanoc/version.rb

@@ -1,4 +1,4 @@
 module Nanoc
   # The current Nanoc version.
-  VERSION = '4.6.4'.freeze
+  VERSION = '4.7.0'.freeze
 end

data/spec/nanoc/base/compiler_spec.rb

@@ -70,6 +70,8 @@ describe Nanoc::Int::Compiler do
 
     allow(action_provider).to receive(:memory_for).with(rep).and_return(memory)
     allow(action_provider).to receive(:memory_for).with(other_rep).and_return(memory)
+
+    allow(Nanoc::Int::NotificationCenter).to receive(:post)
   end
 
   describe '#compile_rep' do

data/spec/nanoc/base/services/compiler/phases/abstract_spec.rb

@@ -0,0 +1,49 @@
+describe Nanoc::Int::Compiler::Phases::Abstract do
+  subject(:phase) do
+    described_class.new(wrapped: wrapped, name: 'my_phase')
+  end
+
+  let(:item) { Nanoc::Int::Item.new('foo', {}, '/stuff.md') }
+  let(:rep) { Nanoc::Int::ItemRep.new(item, :default) }
+
+  let(:wrapped) { nil }
+
+  describe '#run' do
+    subject { phase.run(rep, is_outdated: false) {} }
+
+    it 'raises' do
+      expect { subject }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#call' do
+    subject { phase.call(rep, is_outdated: false) }
+
+    let(:phase) do
+      Class.new(described_class) do
+        def run(_rep, is_outdated:) # rubocop:disable Lint/UnusedMethodArgument
+          yield
+        end
+      end.new(wrapped: wrapped, name: 'my_phase')
+    end
+
+    let(:wrapped) do
+      Class.new(described_class) do
+        def run(_rep, is_outdated:); end
+      end.new(wrapped: nil, name: 'wrapped_phase')
+    end
+
+    it 'sends the proper notifications' do
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_started, 'my_phase', rep).ordered
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_yielded, 'my_phase', rep).ordered
+
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_started, 'wrapped_phase', rep).ordered
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_ended, 'wrapped_phase', rep).ordered
+
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_resumed, 'my_phase', rep).ordered
+      expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_ended, 'my_phase', rep).ordered
+
+      subject
+    end
+  end
+end

data/spec/nanoc/base/services/compiler/phases/cache_spec.rb

@@ -14,7 +14,7 @@ describe Nanoc::Int::Compiler::Phases::Cache do
   let(:snapshot_repo) { Nanoc::Int::SnapshotRepo.new }
 
   let(:wrapped_class) do
-    Class.new do
+    Class.new(Nanoc::Int::Compiler::Phases::Abstract) do
       def initialize(snapshot_repo)
         @snapshot_repo = snapshot_repo
       end
@@ -31,10 +31,17 @@ describe Nanoc::Int::Compiler::Phases::Cache do
   let(:rep) { Nanoc::Int::ItemRep.new(item, :latex) }
 
   describe '#run' do
-    subject { phase.run(rep, is_outdated: is_outdated) }
+    subject { phase.call(rep, is_outdated: is_outdated) }
 
     let(:is_outdated) { raise 'override me' }
 
+    before do
+      allow(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_started, anything, anything)
+      allow(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_yielded, anything, anything)
+      allow(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_resumed, anything, anything)
+      allow(Nanoc::Int::NotificationCenter).to receive(:post).with(:phase_ended, anything, anything)
+    end
+
     shared_examples 'calls wrapped' do
       it 'delegates to wrapped' do
         expect(wrapped).to receive(:run).with(rep, is_outdated: is_outdated)
@@ -48,8 +55,7 @@ describe Nanoc::Int::Compiler::Phases::Cache do
           .to(true)
       end
 
-      it 'sends no notifications' do
-        expect(Nanoc::Int::NotificationCenter).not_to receive(:post)
+      it 'sends no other notifications' do
         subject
       end
 
@@ -75,6 +81,7 @@ describe Nanoc::Int::Compiler::Phases::Cache do
         end
 
         it 'writes content to cache' do
+          expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:cached_content_used, rep)
           expect { subject }
             .to change { snapshot_repo.get(rep, :last) }
             .from(nil)
@@ -82,6 +89,7 @@ describe Nanoc::Int::Compiler::Phases::Cache do
         end
 
         it 'marks rep as compiled' do
+          expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:cached_content_used, rep)
           expect { subject }
             .to change { rep.compiled? }
             .from(false)
@@ -89,14 +97,10 @@ describe Nanoc::Int::Compiler::Phases::Cache do
         end
 
         it 'does not change compiled content cache' do
+          expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:cached_content_used, rep)
           expect { subject }
             .not_to change { compiled_content_cache[rep] }
         end
-
-        it 'sends notification' do
-          expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:cached_content_used, rep)
-          subject
-        end
       end
 
       context 'binary cached compiled content available' do

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

@@ -4,6 +4,8 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
   before { Timecop.freeze(Time.local(2008, 1, 2, 14, 5, 0)) }
   after { Timecop.return }
 
+  before { Nanoc::CLI.verbosity = 2 }
+
   let(:reps) do
     Nanoc::Int::ItemRepRepo.new.tap do |reps|
       reps << rep
@@ -27,7 +29,7 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
     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
+      .to output(/^\s*erb │     1   1\.00s   1\.00s   1\.00s   1\.00s$/).to_stdout
   end
 
   it 'records multiple from filtering_started to filtering_ended' do
@@ -43,7 +45,7 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
     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
+      .to output(/^\s*erb │     2   1\.00s   1\.50s   2\.00s   3\.00s$/).to_stdout
   end
 
   it 'records inner filters in nested filtering_started/filtering_ended' do
@@ -59,7 +61,7 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
     Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :outer)
 
     expect { listener.stop }
-      .to output(/^inner │     1   2\.00s   2\.00s   2\.00s   2\.00s$/).to_stdout
+      .to output(/^\s*inner │     1   2\.00s   2\.00s   2\.00s   2\.00s$/).to_stdout
   end
 
   it 'records outer filters in nested filtering_started/filtering_ended' do
@@ -75,7 +77,27 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
     Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :outer)
 
     expect { listener.stop }
-      .to output(/^outer │     1   6\.00s   6\.00s   6\.00s   6\.00s$/).to_stdout
+      .to output(/^\s*outer │     1   6\.00s   6\.00s   6\.00s   6\.00s$/).to_stdout
+  end
+
+  it 'pauses outer stopwatch when suspended' do
+    listener.start
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
+    Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :outer)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :inner)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 3))
+    Nanoc::Int::NotificationCenter.post(:compilation_suspended, rep, :__anything__)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 6))
+    Nanoc::Int::NotificationCenter.post(:compilation_started, rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 10))
+    Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :inner)
+    Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :outer)
+
+    expect { listener.stop }
+      .to output(/^\s*outer │     1   7\.00s   7\.00s   7\.00s   7\.00s$/).to_stdout
   end
 
   it 'records single from filtering_started over compilation_{suspended,started} to filtering_ended' do
@@ -92,6 +114,80 @@ describe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do
     Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb)
 
     expect { listener.stop }
-      .to output(/^erb │     1   5\.00s   5\.00s   5\.00s   5\.00s$/).to_stdout
+      .to output(/^\s*erb │     1   5\.00s   5\.00s   5\.00s   5\.00s$/).to_stdout
+  end
+
+  it 'records single phase start+stop' do
+    listener.start
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:phase_started, 'donkey', rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:phase_ended, 'donkey', rep)
+
+    expect { listener.stop }
+      .to output(/^\s*donkey │     1   1\.00s   1\.00s   1\.00s   1\.00s$/).to_stdout
+  end
+
+  it 'records multiple phase start+stop' do
+    listener.start
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:phase_started, 'donkey', rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:phase_ended, 'donkey', rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 11, 6, 0))
+    Nanoc::Int::NotificationCenter.post(:phase_started, 'donkey', rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 11, 6, 2))
+    Nanoc::Int::NotificationCenter.post(:phase_ended, 'donkey', rep)
+
+    expect { listener.stop }
+      .to output(/^\s*donkey │     2   1\.00s   1\.50s   2\.00s   3\.00s$/).to_stdout
+  end
+
+  it 'records single phase start+yield+resume+stop' do
+    listener.start
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:phase_started, 'donkey', rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:phase_yielded, 'donkey', rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 11, 6, 0))
+    Nanoc::Int::NotificationCenter.post(:phase_resumed, 'donkey', rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 11, 6, 2))
+    Nanoc::Int::NotificationCenter.post(:phase_ended, 'donkey', rep)
+
+    expect { listener.stop }
+      .to output(/^\s*donkey │     1   3\.00s   3\.00s   3\.00s   3\.00s$/).to_stdout
+  end
+
+  it 'records single phase start+yield+abort+start+stop' do
+    listener.start
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:phase_started, 'donkey', rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:phase_yielded, 'donkey', rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 11, 6, 0))
+    Nanoc::Int::NotificationCenter.post(:phase_aborted, 'donkey', rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 12, 7, 2))
+    Nanoc::Int::NotificationCenter.post(:phase_started, 'donkey', rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 12, 7, 5))
+    Nanoc::Int::NotificationCenter.post(:phase_ended, 'donkey', rep)
+
+    expect { listener.stop }
+      .to output(/^\s*donkey │     2   1\.00s   2\.00s   3\.00s   4\.00s$/).to_stdout
+  end
+
+  it 'records stage duration' do
+    listener.start
+
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0))
+    Nanoc::Int::NotificationCenter.post(:stage_started, 'donkey', rep)
+    Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1))
+    Nanoc::Int::NotificationCenter.post(:stage_ended, 'donkey', rep)
+
+    expect { listener.stop }
+      .to output(/^\s*donkey │ 1\.00s$/).to_stdout
   end
 end

data/spec/nanoc/rule_dsl/rule_context_spec.rb

@@ -162,25 +162,75 @@ describe(Nanoc::RuleDSL::RuleContext) do
   end
 
   describe '#write' do
-    context 'calling once' do
-      subject { rule_context.write('/foo.html') }
+    context 'with path' do
+      context 'calling once' do
+        subject { rule_context.write('/foo.html') }
+
+        it 'makes a request to the executor' do
+          expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
+          subject
+        end
+      end
+
+      context 'calling twice' do
+        subject do
+          rule_context.write('/foo.html')
+          rule_context.write('/bar.html')
+        end
+
+        it 'makes two requests to the executor with unique snapshot names' do
+          expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
+          expect(executor).to receive(:snapshot).with(:_1, path: '/bar.html')
+          subject
+        end
+      end
+    end
 
-      it 'makes a request to the executor' do
-        expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
-        subject
+    context 'with :ext, without period' do
+      context 'calling once' do
+        subject { rule_context.write(ext: 'html') }
+
+        it 'makes a request to the executor' do
+          expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
+          subject
+        end
+      end
+
+      context 'calling twice' do
+        subject do
+          rule_context.write(ext: 'html')
+          rule_context.write(ext: 'htm')
+        end
+
+        it 'makes a request to the executor' do
+          expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
+          expect(executor).to receive(:snapshot).with(:_1, path: '/foo.htm')
+          subject
+        end
       end
     end
 
-    context 'calling twice' do
-      subject do
-        rule_context.write('/foo.html')
-        rule_context.write('/bar.html')
+    context 'with :ext, without period' do
+      context 'calling once' do
+        subject { rule_context.write(ext: '.html') }
+
+        it 'makes a request to the executor' do
+          expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
+          subject
+        end
       end
 
-      it 'makes two requests to the executor with unique snapshot names' do
-        expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
-        expect(executor).to receive(:snapshot).with(:_1, path: '/bar.html')
-        subject
+      context 'calling twice' do
+        subject do
+          rule_context.write(ext: '.html')
+          rule_context.write(ext: '.htm')
+        end
+
+        it 'makes a request to the executor' do
+          expect(executor).to receive(:snapshot).with(:_0, path: '/foo.html')
+          expect(executor).to receive(:snapshot).with(:_1, path: '/foo.htm')
+          subject
+        end
       end
     end
   end