nanoc-cli 4.11.13

data/lib/nanoc/cli/compile_listeners/aggregate.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Nanoc::CLI::CompileListeners
+  class Aggregate < Abstract
+    def initialize(command_runner:, site:, compiler:)
+      @site = site
+      @compiler = compiler
+      @command_runner = command_runner
+
+      @listener_classes = self.class.default_listener_classes
+    end
+
+    def start
+      setup_listeners
+    end
+
+    def stop
+      teardown_listeners
+    end
+
+    def self.default_listener_classes
+      [
+        Nanoc::CLI::CompileListeners::DiffGenerator,
+        Nanoc::CLI::CompileListeners::DebugPrinter,
+        Nanoc::CLI::CompileListeners::TimingRecorder,
+        Nanoc::CLI::CompileListeners::FileActionPrinter,
+      ]
+    end
+
+    protected
+
+    def setup_listeners
+      res = @compiler.run_until_reps_built
+      reps = res.fetch(:reps)
+
+      @listeners =
+        @listener_classes
+        .select { |klass| klass.enable_for?(@command_runner, @site) }
+        .map    { |klass| klass.new(reps: reps) }
+
+      @listeners.each(&:start_safely)
+    end
+
+    def teardown_listeners
+      return unless @listeners
+
+      @listeners.reverse_each(&:stop_safely)
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Nanoc::CLI::CompileListeners
+  class DebugPrinter < Abstract
+    # @see Listener#enable_for?
+    def self.enable_for?(command_runner, _site)
+      command_runner.debug?
+    end
+
+    COLOR_MAP = {
+      'compilation' => "\e[31m",
+      'content' => "\e[32m",
+      'filtering' => "\e[33m",
+      'dependency_tracking' => "\e[34m",
+      'phase' => "\e[35m",
+      'stage' => "\e[36m",
+    }.freeze
+
+    # @see Listener#start
+    def start
+      on(:compilation_started) do |rep|
+        log('compilation', "Started compilation of #{rep}")
+      end
+
+      on(:compilation_ended) do |rep|
+        log('compilation', "Ended compilation of #{rep}")
+        log('compilation', '')
+      end
+
+      on(:compilation_suspended) do |rep, target_rep, snapshot_name|
+        log('compilation', "Suspended compilation of #{rep}: depends on #{target_rep}, snapshot #{snapshot_name}")
+      end
+
+      on(:cached_content_used) do |rep|
+        log('content', "Used cached compiled content for #{rep} instead of recompiling")
+      end
+
+      on(:snapshot_created) do |rep, snapshot_name|
+        log('content', "Snapshot #{snapshot_name} created for #{rep}")
+      end
+
+      on(:filtering_started) do |rep, filter_name|
+        log('filtering', "Started filtering #{rep} with #{filter_name}")
+      end
+
+      on(:filtering_ended) do |rep, filter_name|
+        log('filtering', "Ended filtering #{rep} with #{filter_name}")
+      end
+
+      on(:dependency_created) do |src, dst|
+        log('dependency_tracking', "Dependency created from #{src.inspect} onto #{dst.inspect}")
+      end
+
+      on(:phase_started) do |phase_name, rep|
+        log('phase', "Phase started: #{phase_name} (rep: #{rep})")
+      end
+
+      on(:phase_yielded) do |phase_name, rep|
+        log('phase', "Phase yielded: #{phase_name} (rep: #{rep})")
+      end
+
+      on(:phase_resumed) do |phase_name, rep|
+        log('phase', "Phase resumed: #{phase_name} (rep: #{rep})")
+      end
+
+      on(:phase_ended) do |phase_name, rep|
+        log('phase', "Phase ended: #{phase_name} (rep: #{rep})")
+      end
+
+      on(:phase_aborted) do |phase_name, rep|
+        log('phase', "Phase aborted: #{phase_name} (rep: #{rep})")
+      end
+
+      on(:stage_started) do |stage_name|
+        log('stage', "Stage started: #{stage_name}")
+      end
+
+      on(:stage_ended) do |stage_name|
+        log('stage', "Stage ended: #{stage_name}")
+      end
+
+      on(:stage_aborted) do |stage_name|
+        log('stage', "Stage aborted: #{stage_name}")
+      end
+    end
+
+    def log(progname, msg)
+      logger.info(progname) { msg }
+    end
+
+    def logger
+      @_logger ||=
+        Logger.new($stdout).tap do |l|
+          l.formatter = proc do |_severity, datetime, progname, msg|
+            "*** #{datetime.strftime('%H:%M:%S.%L')} #{COLOR_MAP[progname]}#{msg}\e[0m\n"
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Nanoc::CLI::CompileListeners
+  class DiffGenerator < Abstract
+    class Differ
+      def initialize(path, str_a, str_b)
+        @path = path
+        @str_a = str_a
+        @str_b = str_b
+      end
+
+      def call
+        run
+      end
+
+      private
+
+      def run
+        lines_a = @str_a.lines.map(&:chomp)
+        lines_b = @str_b.lines.map(&:chomp)
+
+        diffs = Diff::LCS.diff(lines_a, lines_b)
+
+        output = +''
+        output << "--- #{@path}\n"
+        output << "+++ #{@path}\n"
+
+        prev_hunk = hunk = nil
+        file_length_difference = 0
+        diffs.each do |piece|
+          begin
+            hunk = Diff::LCS::Hunk.new(lines_a, lines_b, piece, 3, file_length_difference)
+            file_length_difference = hunk.file_length_difference
+
+            next unless prev_hunk
+            next if hunk.merge(prev_hunk)
+
+            output << prev_hunk.diff(:unified) << "\n"
+          ensure
+            prev_hunk = hunk
+          end
+        end
+        last = prev_hunk.diff(:unified)
+        output << last << "\n"
+
+        output
+      end
+    end
+
+    # @see Listener#enable_for?
+    def self.enable_for?(command_runner, site)
+      site.config[:enable_output_diff] || command_runner.options[:diff]
+    end
+
+    # @see Listener#start
+    def start
+      setup_diffs
+
+      on(:rep_ready_for_diff) do |raw_path, old_content, new_content|
+        generate_diff_for(raw_path, old_content, new_content)
+      end
+    end
+
+    # @see Listener#stop
+    def stop
+      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
+        # Simplify path
+        # FIXME: do not depend on working directory
+        if path.start_with?(Dir.getwd)
+          path = path[(Dir.getwd.size + 1)..path.size]
+        end
+
+        # Generate diff
+        diff = Differ.new(path, old_content, new_content).call
+
+        # Write diff
+        @diff_lock.synchronize do
+          File.open('output.diff', 'a') { |io| io.write(diff) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Nanoc::CLI::CompileListeners
+  class FileActionPrinter < Abstract
+    def initialize(reps:)
+      @reps = reps
+
+      @stopwatches = {}
+    end
+
+    # @see Listener#start
+    def start
+      on(:compilation_started) do |rep|
+        @stopwatches[rep] ||= DDMetrics::Stopwatch.new
+        @stopwatches[rep].start
+      end
+
+      on(:compilation_suspended) do |rep|
+        @stopwatches[rep].stop
+      end
+
+      cached_reps = Set.new
+      on(:cached_content_used) do |rep|
+        cached_reps << rep
+      end
+
+      on(:rep_write_enqueued) do |rep|
+        @stopwatches[rep].stop
+      end
+
+      on(:rep_write_started) do |rep, _raw_path|
+        @stopwatches[rep].start
+      end
+
+      on(:rep_write_ended) do |rep, _binary, path, is_created, is_modified|
+        @stopwatches[rep].stop
+        duration = @stopwatches[rep].duration
+
+        action =
+          if is_created then :create
+          elsif is_modified then :update
+          elsif cached_reps.include?(rep) then :cached
+          else :identical
+          end
+        level =
+          if is_created then :high
+          elsif is_modified then :high
+          else :low
+          end
+
+        # FIXME: do not depend on working directory
+        if path.start_with?(Dir.getwd)
+          path = path[(Dir.getwd.size + 1)..path.size]
+        end
+
+        log(level, action, path, duration)
+      end
+
+      on(:file_pruned) do |path|
+        Nanoc::CLI::Logger.instance.file(:high, :delete, path)
+      end
+    end
+
+    # @see Listener#stop
+    def stop
+      @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/compile_listeners/timing_recorder.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Nanoc::CLI::CompileListeners
+  class TimingRecorder < Abstract
+    attr_reader :stages_summary
+    attr_reader :phases_summary
+    attr_reader :outdatedness_rules_summary
+    attr_reader :filters_summary
+
+    # @see Listener#enable_for?
+    def self.enable_for?(_command_runner, _site)
+      Nanoc::CLI.verbosity >= 1
+    end
+
+    # @param [Enumerable<Nanoc::Core::ItemRep>] reps
+    def initialize(reps:)
+      @reps = reps
+
+      @stages_summary = DDMetrics::Summary.new
+      @phases_summary = DDMetrics::Summary.new
+      @outdatedness_rules_summary = DDMetrics::Summary.new
+      @filters_summary = DDMetrics::Summary.new
+      @load_stores_summary = DDMetrics::Summary.new
+    end
+
+    # @see Listener#start
+    def start
+      on(:stage_ran) do |duration, klass|
+        @stages_summary.observe(duration, name: klass.to_s.sub(/.*::/, ''))
+      end
+
+      on(:outdatedness_rule_ran) do |duration, klass|
+        @outdatedness_rules_summary.observe(duration, name: 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 << DDMetrics::Stopwatch.new
+        stopwatch_stack.last.start
+      end
+
+      on(:filtering_ended) do |rep, filter_name|
+        stopwatch = filter_stopwatches.fetch(rep).pop
+        stopwatch.stop
+
+        @filters_summary.observe(stopwatch.duration, name: filter_name.to_s)
+      end
+
+      on(:store_loaded) do |duration, klass|
+        @load_stores_summary.observe(duration, name: klass.to_s)
+      end
+
+      on(:compilation_suspended) do |rep, _target_rep, _snapshot_name|
+        filter_stopwatches.fetch(rep).each(&:stop)
+      end
+
+      on(:compilation_started) do |rep|
+        filter_stopwatches.fetch(rep, []).each(&:start)
+      end
+
+      setup_phase_notifications
+    end
+
+    # @see Listener#stop
+    def stop
+      print_profiling_feedback
+    end
+
+    protected
+
+    def setup_phase_notifications
+      stopwatches = {}
+
+      on(:phase_started) do |phase_name, rep|
+        stopwatch = stopwatches[[phase_name, rep]] = DDMetrics::Stopwatch.new
+        stopwatch.start
+      end
+
+      on(:phase_ended) do |phase_name, rep|
+        stopwatch = stopwatches[[phase_name, rep]]
+        stopwatch.stop
+
+        @phases_summary.observe(stopwatch.duration, name: phase_name)
+      end
+
+      on(:phase_yielded) do |phase_name, rep|
+        stopwatch = stopwatches[[phase_name, rep]]
+        stopwatch.stop
+      end
+
+      on(:phase_resumed) do |phase_name, rep|
+        # It probably looks weird that a phase can be resumed even though it was not suspended earlier. This can happen when compilation is suspended, where you’d get the sequence started -> suspended -> started -> resumed.
+        stopwatch = stopwatches[[phase_name, rep]]
+        stopwatch.start unless stopwatch.running?
+      end
+
+      on(:phase_aborted) do |phase_name, rep|
+        stopwatch = stopwatches[[phase_name, rep]]
+        stopwatch.stop if stopwatch.running?
+
+        @phases_summary.observe(stopwatch.duration, name: phase_name)
+      end
+    end
+
+    def table_for_summary(name, summary)
+      headers = [name.to_s, 'count', 'min', '.50', '.90', '.95', 'max', 'tot']
+
+      rows = summary.map do |label, stats|
+        name = label.fetch(:name)
+
+        count = stats.count
+        min   = stats.min
+        p50   = stats.quantile(0.50)
+        p90   = stats.quantile(0.90)
+        p95   = stats.quantile(0.95)
+        tot   = stats.sum
+        max   = stats.max
+
+        [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, summary)
+      headers = [name.to_s, 'tot']
+
+      rows = summary.map do |label, stats|
+        name = label.fetch(:name)
+        [name, "#{format('%4.2f', stats.sum)}s"]
+      end
+
+      [headers] + rows
+    end
+
+    def print_profiling_feedback
+      print_table_for_summary(:filters, @filters_summary)
+      print_table_for_summary(:phases, @phases_summary) if Nanoc::CLI.verbosity >= 2
+      print_table_for_summary_duration(:stages, @stages_summary) if Nanoc::CLI.verbosity >= 2
+      print_table_for_summary(:outdatedness_rules, @outdatedness_rules_summary) if Nanoc::CLI.verbosity >= 2
+      print_table_for_summary_duration(:load_stores, @load_stores_summary) if Nanoc::CLI.verbosity >= 2
+      print_ddmemoize_metrics if Nanoc::CLI.verbosity >= 2
+    end
+
+    def print_table_for_summary(name, summary)
+      return unless summary.any?
+
+      puts
+      print_table(table_for_summary(name, summary))
+    end
+
+    def print_table_for_summary_duration(name, summary)
+      return unless summary.any?
+
+      puts
+      print_table(table_for_summary_durations(name, summary))
+    end
+
+    def print_ddmemoize_metrics
+      puts
+      DDMemoize.print_metrics
+    end
+
+    def print_table(rows)
+      puts DDMetrics::Table.new(rows).to_s
+    end
+  end
+end