nanoc 4.7.0 → 4.7.1

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

@@ -0,0 +1,30 @@
+module Nanoc::CLI::Commands::CompileListeners
+  class Abstract
+    def initialize(*); end
+
+    def self.enable_for?(command_runner) # rubocop:disable Lint/UnusedMethodArgument
+      true
+    end
+
+    def start
+      raise NotImplementedError, "Subclasses of #{self.class} must implement #start"
+    end
+
+    def stop; end
+
+    def start_safely
+      start
+      @_started = true
+    end
+
+    def stop_safely
+      stop if @_started
+      @_started = false
+    end
+
+    def on(sym)
+      # TODO: clean up on stop
+      Nanoc::Int::NotificationCenter.on(sym, self) { |*args| yield(*args) }
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Nanoc::CLI::Commands::CompileListeners
+  class DebugPrinter < Abstract
+    # @see Listener#enable_for?
+    def self.enable_for?(command_runner)
+      command_runner.debug?
+    end
+
+    # @see Listener#start
+    def start
+      Nanoc::Int::NotificationCenter.on(:compilation_started) do |rep|
+        puts "*** Started compilation of #{rep.inspect}"
+      end
+      Nanoc::Int::NotificationCenter.on(:compilation_ended) do |rep|
+        puts "*** Ended compilation of #{rep.inspect}"
+        puts
+      end
+      Nanoc::Int::NotificationCenter.on(:compilation_suspended) do |rep, e|
+        puts "*** Suspended compilation of #{rep.inspect}: #{e.message}"
+      end
+      Nanoc::Int::NotificationCenter.on(:cached_content_used) do |rep|
+        puts "*** Used cached compiled content for #{rep.inspect} instead of recompiling"
+      end
+      Nanoc::Int::NotificationCenter.on(:filtering_started) do |rep, filter_name|
+        puts "*** Started filtering #{rep.inspect} with #{filter_name}"
+      end
+      Nanoc::Int::NotificationCenter.on(:filtering_ended) do |rep, filter_name|
+        puts "*** Ended filtering #{rep.inspect} with #{filter_name}"
+      end
+      Nanoc::Int::NotificationCenter.on(:dependency_created) do |src, dst|
+        puts "*** Dependency created from #{src.inspect} onto #{dst.inspect}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module Nanoc::CLI::Commands::CompileListeners
+  class DiffGenerator < Abstract
+    # @see Listener#enable_for?
+    def self.enable_for?(command_runner)
+      command_runner.site.config[:enable_output_diff]
+    end
+
+    # @see Listener#start
+    def start
+      require 'tempfile'
+      setup_diffs
+      old_contents = {}
+      Nanoc::Int::NotificationCenter.on(:will_write_rep, self) do |rep, path|
+        old_contents[rep] = File.file?(path) ? File.read(path) : nil
+      end
+      Nanoc::Int::NotificationCenter.on(:rep_written, self) do |rep, binary, path, _is_created, _is_modified|
+        unless binary
+          new_contents = File.file?(path) ? File.read(path) : nil
+          if old_contents[rep] && new_contents
+            generate_diff_for(path, old_contents[rep], new_contents)
+          end
+          old_contents.delete(rep)
+        end
+      end
+    end
+
+    # @see Listener#stop
+    def stop
+      super
+
+      Nanoc::Int::NotificationCenter.remove(:will_write_rep, self)
+      Nanoc::Int::NotificationCenter.remove(:rep_written, self)
+
+      teardown_diffs
+    end
+
+    protected
+
+    def setup_diffs
+      @diff_lock    = Mutex.new
+      @diff_threads = []
+      FileUtils.rm('output.diff') if File.file?('output.diff')
+    end
+
+    def teardown_diffs
+      @diff_threads.each(&:join)
+    end
+
+    def generate_diff_for(path, old_content, new_content)
+      return if old_content == new_content
+
+      @diff_threads << Thread.new do
+        # Generate diff
+        diff = diff_strings(old_content, new_content)
+        diff.sub!(/^--- .*/,    '--- ' + path)
+        diff.sub!(/^\+\+\+ .*/, '+++ ' + path)
+
+        # Write diff
+        @diff_lock.synchronize do
+          File.open('output.diff', 'a') { |io| io.write(diff) }
+        end
+      end
+    end
+
+    def diff_strings(a, b)
+      require 'open3'
+
+      # Create files
+      Tempfile.open('old') do |old_file|
+        Tempfile.open('new') do |new_file|
+          # Write files
+          old_file.write(a)
+          old_file.flush
+          new_file.write(b)
+          new_file.flush
+
+          # Diff
+          cmd = ['diff', '-u', old_file.path, new_file.path]
+          Open3.popen3(*cmd) do |_stdin, stdout, _stderr|
+            result = stdout.read
+            return (result == '' ? nil : result)
+          end
+        end
+      end
+    rescue Errno::ENOENT
+      warn 'Failed to run `diff`, so no diff with the previously compiled ' \
+           'content will be available.'
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Nanoc::CLI::Commands::CompileListeners
+  class FileActionPrinter < Abstract
+    def initialize(reps:)
+      @start_times = {}
+      @acc_durations = {}
+
+      @reps = reps
+    end
+
+    # @see Listener#start
+    def start
+      Nanoc::Int::NotificationCenter.on(:compilation_started, self) do |rep|
+        @start_times[rep] = Time.now
+        @acc_durations[rep] ||= 0.0
+      end
+
+      Nanoc::Int::NotificationCenter.on(:compilation_suspended, self) do |rep|
+        @acc_durations[rep] += Time.now - @start_times[rep]
+      end
+
+      Nanoc::Int::NotificationCenter.on(:rep_written, self) do |rep, _binary, path, is_created, is_modified|
+        @acc_durations[rep] += Time.now - @start_times[rep]
+        duration = @acc_durations[rep]
+
+        action =
+          if is_created then :create
+          elsif is_modified then :update
+          else :identical
+          end
+        level =
+          if is_created then :high
+          elsif is_modified then :high
+          else :low
+          end
+        log(level, action, path, duration)
+      end
+    end
+
+    # @see Listener#stop
+    def stop
+      super
+
+      Nanoc::Int::NotificationCenter.remove(:compilation_started, self)
+      Nanoc::Int::NotificationCenter.remove(:compilation_suspended, self)
+      Nanoc::Int::NotificationCenter.remove(:rep_written, self)
+
+      @reps.reject(&:compiled?).each do |rep|
+        raw_paths = rep.raw_paths.values.flatten.uniq
+        raw_paths.each do |raw_path|
+          log(:low, :skip, raw_path, nil)
+        end
+      end
+    end
+
+    private
+
+    def log(level, action, path, duration)
+      Nanoc::CLI::Logger.instance.file(level, action, path, duration)
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Nanoc::CLI::Commands::CompileListeners
+  class StackProfProfiler < Abstract
+    PROFILE_FILE = 'tmp/stackprof_profile'.freeze
+
+    # @see Listener#enable_for?
+    def self.enable_for?(command_runner)
+      command_runner.options.fetch(:profile, false)
+    end
+
+    # @see Listener#start
+    def start
+      require 'stackprof'
+      StackProf.start(mode: :cpu)
+    end
+
+    # @see Listener#stop
+    def stop
+      StackProf.stop
+      StackProf.results(PROFILE_FILE)
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+module Nanoc::CLI::Commands::CompileListeners
+  class TimingRecorder < Abstract
+    attr_reader :telemetry
+
+    # @see Listener#enable_for?
+    def self.enable_for?(command_runner)
+      command_runner.options.fetch(:verbose, false)
+    end
+
+    # @param [Enumerable<Nanoc::Int::ItemRep>] reps
+    def initialize(reps:)
+      @reps = reps
+      @telemetry = Nanoc::Telemetry.new
+    end
+
+    # @see Listener#start
+    def start
+      stage_stopwatch = Nanoc::Telemetry::Stopwatch.new
+
+      on(:stage_started) do |_stage_name|
+        stage_stopwatch.start
+      end
+
+      on(:stage_ended) do |stage_name|
+        stage_stopwatch.stop
+        @telemetry.summary(:stages).observe(stage_stopwatch.duration, stage_name.to_s)
+        stage_stopwatch = Nanoc::Telemetry::Stopwatch.new
+      end
+
+      outdatedness_rule_stopwatches = {}
+
+      on(:outdatedness_rule_started) do |klass, obj|
+        stopwatches = outdatedness_rule_stopwatches.fetch(klass) { outdatedness_rule_stopwatches[klass] = {} }
+        stopwatch = stopwatches.fetch(obj) { stopwatches[obj] = Nanoc::Telemetry::Stopwatch.new }
+        stopwatch.start
+      end
+
+      on(:outdatedness_rule_ended) do |klass, obj|
+        stopwatches = outdatedness_rule_stopwatches.fetch(klass)
+        stopwatch = stopwatches.fetch(obj)
+        stopwatch.stop
+
+        @telemetry.summary(:outdatedness_rules).observe(stopwatch.duration, klass.to_s.sub(/.*::/, ''))
+      end
+
+      filter_stopwatches = {}
+
+      on(:filtering_started) do |rep, _filter_name|
+        stopwatch_stack = filter_stopwatches.fetch(rep) { filter_stopwatches[rep] = [] }
+        stopwatch_stack << Nanoc::Telemetry::Stopwatch.new
+        stopwatch_stack.last.start
+      end
+
+      on(:filtering_ended) do |rep, filter_name|
+        stopwatch = filter_stopwatches.fetch(rep).pop
+        stopwatch.stop
+
+        @telemetry.summary(:filters).observe(stopwatch.duration, filter_name.to_s)
+      end
+
+      on(:compilation_suspended) do |rep, _exception|
+        filter_stopwatches.fetch(rep).each(&:stop)
+      end
+
+      on(:compilation_started) do |rep|
+        filter_stopwatches.fetch(rep, []).each(&:start)
+      end
+
+      phase_stopwatches = {}
+
+      on(:phase_started) do |phase_name, rep|
+        stopwatches = phase_stopwatches.fetch(rep) { phase_stopwatches[rep] = {} }
+        stopwatches[phase_name] = Nanoc::Telemetry::Stopwatch.new.tap(&:start)
+      end
+
+      on(:phase_ended) do |phase_name, rep|
+        stopwatch = phase_stopwatches.fetch(rep).fetch(phase_name)
+        stopwatch.stop
+
+        @telemetry.summary(:phases).observe(stopwatch.duration, phase_name)
+      end
+
+      on(:phase_yielded) do |phase_name, rep|
+        stopwatch = phase_stopwatches.fetch(rep).fetch(phase_name)
+        stopwatch.stop
+      end
+
+      on(:phase_resumed) do |phase_name, rep|
+        stopwatch = phase_stopwatches.fetch(rep).fetch(phase_name)
+        stopwatch.start if stopwatch.stopped?
+      end
+
+      on(:phase_aborted) do |phase_name, rep|
+        stopwatch = phase_stopwatches.fetch(rep).fetch(phase_name)
+        stopwatch.stop if stopwatch.running?
+
+        @telemetry.summary(:phases).observe(stopwatch.duration, phase_name)
+      end
+    end
+
+    # @see Listener#stop
+    def stop
+      print_profiling_feedback
+      super
+    end
+
+    protected
+
+    def table_for_summary(name)
+      headers = [name.to_s, 'count', 'min', '.50', '.90', '.95', 'max', 'tot']
+
+      rows = @telemetry.summary(name).map do |filter_name, summary|
+        count = summary.count
+        min   = summary.min
+        p50   = summary.quantile(0.50)
+        p90   = summary.quantile(0.90)
+        p95   = summary.quantile(0.95)
+        tot   = summary.sum
+        max   = summary.max
+
+        [filter_name, count.to_s] + [min, p50, p90, p95, max, tot].map { |r| "#{format('%4.2f', r)}s" }
+      end
+
+      [headers] + rows
+    end
+
+    def table_for_summary_durations(name)
+      headers = [name.to_s, 'tot']
+
+      rows = @telemetry.summary(:stages).map do |stage_name, summary|
+        [stage_name, "#{format('%4.2f', summary.sum)}s"]
+      end
+
+      [headers] + rows
+    end
+
+    def print_profiling_feedback
+      print_table_for_summary(:filters)
+      print_table_for_summary(:phases) if Nanoc::CLI.verbosity >= 2
+      print_table_for_summary_duration(:stages) if Nanoc::CLI.verbosity >= 2
+      print_table_for_summary(:outdatedness_rules) if Nanoc::CLI.verbosity >= 2
+    end
+
+    def print_table_for_summary(name)
+      return if @telemetry.summary(name).empty?
+
+      puts
+      print_table(table_for_summary(name))
+    end
+
+    def print_table_for_summary_duration(name)
+      return if @telemetry.summary(name).empty?
+
+      puts
+      print_table(table_for_summary_durations(name))
+    end
+
+    def print_table(table)
+      lengths = table.transpose.map { |r| r.map(&:size).max }
+
+      print_row(table[0], lengths)
+
+      puts "#{'─' * lengths[0]}─┼─#{lengths[1..-1].map { |length| '─' * length }.join('───')}"
+
+      table[1..-1].each { |row| print_row(row, lengths) }
+    end
+
+    def print_row(row, lengths)
+      values = row.zip(lengths).map { |text, length| text.rjust length }
+
+      puts values[0] + ' │ ' + values[1..-1].join('   ')
+    end
+  end
+end

data/lib/nanoc/filters/xsl.rb

@@ -5,6 +5,8 @@ module Nanoc::Filters
 
     requires 'nokogiri'
 
+    always_outdated
+
     # Runs the item content through an [XSLT](http://www.w3.org/TR/xslt)
     # stylesheet using  [Nokogiri](http://nokogiri.org/).
     #

data/lib/nanoc/version.rb

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

data/spec/nanoc/base/directed_graph_spec.rb

@@ -0,0 +1,54 @@
+describe Nanoc::Int::DirectedGraph do
+  subject(:graph) { described_class.new([1, 2, 3]) }
+
+  describe '#any_cycle' do
+    subject { graph.any_cycle }
+
+    context 'no cycles' do
+      it { is_expected.to be_nil }
+    end
+
+    context 'one cycle without head' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 1)
+      end
+
+      it { is_expected.to eq([1, 2]) }
+    end
+
+    context 'one cycle with head' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 3)
+        graph.add_edge(3, 2)
+      end
+
+      it { is_expected.to eq([2, 3]) }
+    end
+
+    context 'large cycle' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 3)
+        graph.add_edge(3, 4)
+        graph.add_edge(4, 5)
+        graph.add_edge(5, 1)
+      end
+
+      it { is_expected.to eq([1, 2, 3, 4, 5]) }
+    end
+
+    context 'large cycle with head' do
+      before do
+        graph.add_edge(1, 2)
+        graph.add_edge(2, 3)
+        graph.add_edge(3, 4)
+        graph.add_edge(4, 5)
+        graph.add_edge(5, 2)
+      end
+
+      it { is_expected.to eq([2, 3, 4, 5]) }
+    end
+  end
+end