nanoc 3.4.3 → 3.5.0b1

data/lib/nanoc/base/result_data/item_rep.rb

@@ -129,27 +129,15 @@ module Nanoc
         # Check if file will be created
         is_created = !File.file?(raw_path)
 
-        # Calculate characteristics of old content
-        if File.file?(raw_path)
-          hash_old = Pathname.new(raw_path).checksum
-          size_old = File.size(raw_path)
-        end
-
         # Notify
         Nanoc::NotificationCenter.post(:will_write_rep, self, snapshot)
 
         if self.binary?
-          # Calculate characteristics of new content
-          size_new = File.size(temporary_filenames[:last])
-          hash_new = Pathname.new(temporary_filenames[:last]).checksum if size_old == size_new
-
           # Check whether content was modified
-          is_modified = (size_old != size_new || hash_old != hash_new)
+          is_modified = !File.file?(raw_path) || !FileUtils.identical?(raw_path, temporary_filenames[:last])
 
-          # Copy
-          if is_modified
-            FileUtils.cp(temporary_filenames[:last], raw_path)
-          end
+          # Always copy (time spent checking modification is not useful)
+          FileUtils.cp(temporary_filenames[:last], raw_path)
         else
           # Check whether content was modified
           is_modified = (!File.file?(raw_path) || File.read(raw_path) != @content[:last])

data/lib/nanoc/base/source_data/item.rb

@@ -86,7 +86,7 @@ module Nanoc
       end
 
       # Get rest of params
-      @attributes   = attributes.symbolize_keys
+      @attributes   = attributes.symbolize_keys_recursively
       @identifier   = identifier.cleaned_identifier.freeze
 
       # Set mtime

data/lib/nanoc/base/source_data/layout.rb

@@ -35,7 +35,7 @@ module Nanoc
     #   attribute instead.
     def initialize(raw_content, attributes, identifier, params=nil)
       @raw_content  = raw_content
-      @attributes   = attributes.symbolize_keys
+      @attributes   = attributes.symbolize_keys_recursively
       @identifier   = identifier.cleaned_identifier.freeze
 
       # Set mtime

data/lib/nanoc/base/source_data/site.rb

@@ -181,25 +181,21 @@ module Nanoc
     def setup_child_parent_links
       teardown_child_parent_links
 
-      items = @items.sort_by { |i| i.identifier }
-      items.each_with_index do |item, index|
-        # Get parent
-        next if index == 0
-        parent_identifier = item.identifier.sub(/[^\/]+\/$/, '')
-        parent = nil
-        (index-1).downto(0) do |candidate_index|
-          candidate = items[candidate_index]
-          if candidate.identifier == parent_identifier
-            parent = candidate
-          elsif candidate.identifier[0..parent_identifier.size-1] != parent_identifier
-            break
+      item_map = {}
+      @items.each do |item|
+        item_map[item.identifier] = item
+      end
+
+      @items.each do |item|
+        parent_id_end = item.identifier.rindex('/', -2)
+        if parent_id_end
+          parent_id = item.identifier[0..parent_id_end]
+          parent = item_map[parent_id]
+          if parent
+            item.parent = parent
+            parent.children << item
           end
         end
-        next if parent.nil?
-
-        # Link
-        item.parent = parent
-        parent.children << item
       end
     end
 
@@ -346,8 +342,8 @@ module Nanoc
 
         # Read config from config.yaml in given dir
         config_path = File.join(dir_or_config_hash, 'config.yaml')
-        @config = DEFAULT_CONFIG.merge(YAML.load_file(config_path).symbolize_keys)
-        @config[:data_sources].map! { |ds| ds.symbolize_keys }
+        @config = DEFAULT_CONFIG.merge(YAML.load_file(config_path).symbolize_keys_recursively)
+        @config[:data_sources].map! { |ds| ds.symbolize_keys_recursively }
       else
         # Use passed config hash
         @config = DEFAULT_CONFIG.merge(dir_or_config_hash)

data/lib/nanoc/cli.rb

@@ -53,6 +53,11 @@ module Nanoc::CLI
     end
   end
 
+  # @return [Cri::Command] The root command, i.e. the commandline tool itself
+  def self.root_command
+    @root_command
+  end
+
   # Adds the given command to the collection of available commands.
   #
   # @param [Cri::Command] cmd The command to add
@@ -80,6 +85,10 @@ protected
     # Reinit
     @root_command = nil
 
+    # Add root command
+    filename = File.dirname(__FILE__) + "/cli/commands/nanoc.rb"
+    @root_command = self.load_command_at(filename)
+
     # Add help command
     help_cmd = Cri::Command.new_basic_help
     self.add_command(help_cmd)
@@ -135,14 +144,6 @@ protected
     cmd
   end
 
-  # @return [Cri::Command] The root command, i.e. the commandline tool itself
-  def self.root_command
-    @root_command ||= begin
-      filename = File.dirname(__FILE__) + "/cli/commands/nanoc.rb"
-      self.load_command_at(filename)
-    end
-  end
-
   # @return [Array] The directory contents
   def self.recursive_contents_of(path)
     return [] unless File.directory?(path)
@@ -151,28 +152,32 @@ protected
     files
   end
 
-  # Wraps `$stdout` and `$stderr` in appropriate cleaning streams.
+  # Wraps the given stream in a cleaning stream. The cleaning streams will
+  # have the proper stream cleaners configured.
   #
-  # @return [void]
-  def self.setup_cleaning_streams
-    $stdout = Nanoc::CLI::CleaningStream.new($stdout)
-    $stderr = Nanoc::CLI::CleaningStream.new($stderr)
+  # @param [IO] io The stream to wrap
+  #
+  # @return [::Nanoc::CLI::CleaningStream]
+  def self.wrap_in_cleaning_stream(io)
+    cio = ::Nanoc::CLI::CleaningStream.new(io)
 
-    if !self.enable_utf8?($stdout)
-      $stdout.add_stream_cleaner(Nanoc::CLI::StreamCleaners::UTF8)
+    if !self.enable_utf8?(io)
+      cio.add_stream_cleaner(Nanoc::CLI::StreamCleaners::UTF8)
     end
 
-    if !self.enable_utf8?($stderr)
-      $stderr.add_stream_cleaner(Nanoc::CLI::StreamCleaners::UTF8)
+    if !self.enable_ansi_colors?(io)
+      cio.add_stream_cleaner(Nanoc::CLI::StreamCleaners::ANSIColors)
     end
 
-    if !self.enable_ansi_colors?($stdout)
-      $stdout.add_stream_cleaner(Nanoc::CLI::StreamCleaners::ANSIColors)
-    end
+    cio
+  end
 
-    if !self.enable_ansi_colors?($stderr)
-      $stderr.add_stream_cleaner(Nanoc::CLI::StreamCleaners::ANSIColors)
-    end
+  # Wraps `$stdout` and `$stderr` in appropriate cleaning streams.
+  #
+  # @return [void]
+  def self.setup_cleaning_streams
+    $stdout = self.wrap_in_cleaning_stream($stdout)
+    $stderr = self.wrap_in_cleaning_stream($stderr)
   end
 
   # @return [Boolean] true if UTF-8 support is present, false if not

data/lib/nanoc/cli/command_runner.rb

@@ -51,8 +51,12 @@ module Nanoc::CLI
     #
     # @return [void]
     def require_site
+      print "Loading site data… "
       if site.nil?
+        puts "error"
         raise ::Nanoc::Errors::GenericTrivial, "The current working directory does not seem to be a nanoc site."
+      else
+        puts "done"
       end
     end
 

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

@@ -4,12 +4,20 @@ usage       'autocompile [options]'
 summary     'start the autocompiler'
 aliases     :aco
 description <<-EOS
-Start the autocompiler web server. Unless specified, the web server will run
-on port 3000 and listen on all IP addresses. Running the autocompiler requires
-the 'mime/types' and 'rack' gems.
+Start the autocompiler web server. Unless overridden with commandline options
+or configuration entries, the web server will run on port 3000 and listen on all
+IP addresses. Running the autocompiler requires the `mime/types` and `rack` gems.
+
+To specify the host and/or port options in config.yaml, you can add either (or
+both) of the following:
+
+    autocompile:
+      host: '10.0.2.0'  # override the default host
+      port: 4000        # override the default port
+
 EOS
 
-required :H, :handler, 'specify the handler to use (webrick/mongrel/...)'
+required :H, :handler, 'specify the handler to use (webrick/mongrel/…)'
 required :o, :host,    'specify the host to listen on (default: 0.0.0.0)'
 required :p, :port,    'specify the port to listen on (default: 3000)'
 
@@ -22,11 +30,12 @@ module Nanoc::CLI::Commands
 
       # Make sure we are in a nanoc site directory
       self.require_site
+      autocompile_config = self.site.config[:autocompile] || {}
 
       # Set options
       options_for_rack = {
-        :Port      => (options[:port] || 3000).to_i,
-        :Host      => (options[:host] || '0.0.0.0')
+        :Port      => (options[:port] || autocompile_config[:port] || 3000).to_i,
+        :Host      => (options[:host] || autocompile_config[:host] || '0.0.0.0')
       }
 
       # Guess which handler we should use

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+usage       'check [options] [names]'
+summary     'run issue checks'
+description <<-EOS
+Run issue checks on the current site. If the `--all` option is passed, all available issue checks will be run. If the `--deploy` option is passed, the issue checks marked for deployment will be fun.
+EOS
+
+flag :a, :all,    'run all checks'
+flag :L, :list,   'list all checks'
+flag :d, :deploy, 'run checks for deployment'
+
+module Nanoc::CLI::Commands
+
+  class Check < ::Nanoc::CLI::CommandRunner
+
+    def run
+      validate_options_and_arguments
+      self.require_site
+
+      runner = Nanoc::Extra::Checking::Runner.new(site)
+      if options[:list]
+        runner.list_checks
+      elsif options[:all]
+        runner.run_all
+      elsif options[:deploy]
+        runner.require_dsl
+        runner.run_for_deploy
+      else
+        runner.run_specific(arguments)
+      end
+    end
+
+  protected
+
+    def validate_options_and_arguments
+      if arguments.empty? && !options[:all] && !options[:deploy] && !options[:list]
+        raise Nanoc::Errors::GenericTrivial,
+          "nothing to do (pass either --all, --deploy or --list or a list of checks)"
+      end
+    end
+
+  end
+
+end
+
+runner Nanoc::CLI::Commands::Check

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

@@ -22,102 +22,227 @@ option :f, :force, '(ignored)'
 
 module Nanoc::CLI::Commands
 
-  # FIXME this command is horribly long and complicated and does way too much. plz cleanup thx.
   class Compile < ::Nanoc::CLI::CommandRunner
 
-    def run
-      # Make sure we are in a nanoc site directory
-      puts "Loading site data…"
-      self.require_site
+    extend Nanoc::Memoization
+
+    # Listens to compilation events and reacts to them. This abstract class
+    # does not have a real implementation; subclasses should override {#start}
+    # and set up notifications to listen to.
+    #
+    # @abstract Subclasses must override {#start} and may override {#stop}.
+    class Listener
+
+      # Starts the listener. Subclasses should override this method and set up listener notifications.
+      #
+      # @return [void]
+      #
+      # @abstract
+      def start
+        raise NotImplementedError, "Subclasses of Listener should implement #start"
+      end
 
-      # Check presence of --all option
-      if options.has_key?(:all) || options.has_key?(:force)
-        $stderr.puts "Warning: the --force option (and its deprecated --all alias) are, as of nanoc 3.2, no longer supported and have no effect."
+      # Stops the listener. The default implementation removes self from all notification center observers.
+      #
+      # @return [void]
+      def stop
       end
 
-      # Warn if trying to compile a single item
-      if arguments.size == 1
-        $stderr.puts '-' * 80
-        $stderr.puts 'Note: As of nanoc 3.2, it is no longer possible to compile a single item. When invoking the “compile” command, all items in the site will be compiled.'
-        $stderr.puts '-' * 80
+    end
+
+    # Generates diffs for every output file written
+    class DiffGenerator < Listener
+
+      # @see Listener#start
+      def start
+        require 'tempfile'
+        self.setup_diffs
+        old_contents = {}
+        Nanoc::NotificationCenter.on(:will_write_rep) do |rep, snapshot|
+          path = rep.raw_path(:snapshot => snapshot)
+          old_contents[rep] = File.file?(path) ? File.read(path) : nil
+        end
+        Nanoc::NotificationCenter.on(:rep_written) do |rep, path, is_created, is_modified|
+          if !rep.binary?
+            new_contents = File.file?(path) ? File.read(path) : nil
+            if old_contents[rep] && new_contents
+              generate_diff_for(rep, old_contents[rep], new_contents)
+            end
+            old_contents.delete(rep)
+          end
+        end
       end
 
-      # Give feedback
-      puts "Compiling site…"
+      # @see Listener#stop
+      def stop
+        super
+        self.teardown_diffs
+      end
 
-      # Initialize profiling stuff
-      time_before = Time.now
-      @rep_times     = {}
-      @filter_times  = {}
-      setup_notifications
+    protected
 
-      # Prepare for generating diffs
-      setup_diffs
+      def setup_diffs
+        @diff_lock    = Mutex.new
+        @diff_threads = []
+        FileUtils.rm('output.diff') if File.file?('output.diff')
+      end
 
-      # Set up GC control
-      @gc_lock = Mutex.new
-      @gc_count = 0
+      def teardown_diffs
+        @diff_threads.each { |t| t.join }
+      end
 
-      # Compile
-      self.site.compile
+      def generate_diff_for(rep, old_content, new_content)
+        return if old_content == new_content
 
-      # Find reps
-      reps = self.site.items.map { |i| i.reps }.flatten
+        @diff_threads << Thread.new do
+          # Generate diff
+          diff = diff_strings(old_content, new_content)
+          diff.sub!(/^--- .*/,    '--- ' + rep.raw_path)
+          diff.sub!(/^\+\+\+ .*/, '+++ ' + rep.raw_path)
 
-      # Show skipped reps
-      reps.select { |r| !r.compiled? }.each do |rep|
-        rep.raw_paths.each do |snapshot_name, filename|
-          next if filename.nil?
-          duration = @rep_times[filename]
-          Nanoc::CLI::Logger.instance.file(:high, :skip, filename, duration)
+          # Write diff
+          @diff_lock.synchronize do
+            File.open('output.diff', 'a') { |io| io.write(diff) }
+          end
         end
       end
 
-      # Stop diffing
-      teardown_diffs
+      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
 
-      # Prune
-      if self.site.config[:prune][:auto_prune]
-        Nanoc::Extra::Pruner.new(self.site, :exclude => self.prune_config_exclude).run
+    end
+
+    # Records the time spent per filter and per item representation
+    class TimingRecorder < Listener
+
+      # @option params [Array<Nanoc::ItemRep>] :reps The list of item representations in the site
+      def initialize(params={})
+        @filter_times = {}
+
+        @reps       = params.fetch(:reps)
       end
 
-      # Give general feedback
-      puts
-      puts "Site compiled in #{format('%.2f', Time.now - time_before)}s."
+      # @see Listener#start
+      def start
+        Nanoc::NotificationCenter.on(:filtering_started) do |rep, filter_name|
+          @filter_times[filter_name] ||= []
+          @filter_times[filter_name] << Time.now
+        end
+        Nanoc::NotificationCenter.on(:filtering_ended) do |rep, filter_name|
+          @filter_times[filter_name] << Time.now - @filter_times[filter_name].pop
+        end
+      end
+
+      # @see Listener#stop
+      def stop
+        super
+        self.print_profiling_feedback
+      end
+
+    protected
 
-      # Give detailed feedback
-      if options.has_key?(:verbose)
-        print_profiling_feedback(reps)
+      def print_profiling_feedback
+        # Get max filter length
+        max_filter_name_length = @filter_times.keys.map { |k| k.to_s.size }.max
+        return if max_filter_name_length.nil?
+
+        # Print warning if necessary
+        if @reps.any? { |r| !r.compiled? }
+          $stderr.puts
+          $stderr.puts "Warning: profiling information may not be accurate because " +
+                       "some items were not compiled."
+        end
+
+        # Print header
+        puts
+        puts ' ' * max_filter_name_length + ' | count    min    avg    max     tot'
+        puts '-' * max_filter_name_length + '-+-----------------------------------'
+
+        @filter_times.to_a.sort_by { |r| r[1] }.each do |row|
+          self.print_row(row)
+        end
       end
+
+      def print_row(row)
+        # Extract data
+        filter_name, samples = *row
+
+        # Calculate stats
+        count = samples.size
+        min   = samples.min
+        tot   = samples.inject { |memo, i| memo + i}
+        avg   = tot/count
+        max   = samples.max
+
+        # Format stats
+        count = format('%4d',   count)
+        min   = format('%4.2f', min)
+        avg   = format('%4.2f', avg)
+        max   = format('%4.2f', max)
+        tot   = format('%5.2f', tot)
+
+        # Output stats
+        filter_name = format("%#{max_filter_name_length}s", filter_name)
+        puts "#{filter_name} |  #{count}  #{min}s  #{avg}s  #{max}s  #{tot}s"
+      end
+
     end
 
-    def setup_notifications
-      # Diff generation
-      require 'tempfile'
-      old_contents = {}
-      Nanoc::NotificationCenter.on(:will_write_rep) do |rep, snapshot|
-        path = rep.raw_path(:snapshot => snapshot)
-        old_contents[rep] = File.file?(path) ? File.read(path) : nil
+    # Controls garbage collection so that it only occurs once every 20 items
+    class GCController < Listener
+
+      def initialize
+        @gc_count = 0
       end
-      Nanoc::NotificationCenter.on(:rep_written) do |rep, path, is_created, is_modified|
-        if !rep.binary? && self.site.config[:enable_output_diff]
-          new_contents = File.file?(path) ? File.read(path) : nil
-          if old_contents[rep] && new_contents
-            generate_diff_for(rep, old_contents[rep], new_contents)
+
+      # @see Listener#start
+      def start
+        Nanoc::NotificationCenter.on(:compilation_started) do |rep|
+          if @gc_count % 20 == 0
+            GC.enable
+            GC.start
+            GC.disable
           end
+          @gc_count += 1
         end
       end
 
-      # File notifications
-      Nanoc::NotificationCenter.on(:rep_written) do |rep, path, is_created, is_modified|
-        action = (is_created ? :create : (is_modified ? :update : :identical))
-        level  = (is_created ? :high   : (is_modified ? :high   : :low))
-        duration = Time.now - @rep_times[rep.raw_path] if @rep_times[rep.raw_path]
-        Nanoc::CLI::Logger.instance.file(level, action, path, duration)
+      # @see Listener#stop
+      def stop
+        super
+        GC.enable
       end
 
-      # Debug notifications
-      if self.debug?
+    end
+
+    # Prints debug information (compilation started/ended, filtering started/ended, …)
+    class DebugPrinter < Listener
+
+      # @see Listener#start
+      def start
         Nanoc::NotificationCenter.on(:compilation_started) do |rep|
           puts "*** Started compilation of #{rep.inspect}"
         end
@@ -148,165 +273,116 @@ module Nanoc::CLI::Commands
         end
       end
 
-      # Timing notifications
-      Nanoc::NotificationCenter.on(:compilation_started) do |rep|
-        if @gc_count % 20 == 0 && !ENV.has_key?('TRAVIS')
-          GC.enable
-          GC.start
-          GC.disable
-        end
-        @gc_count += 1
-        @rep_times[rep.raw_path] = Time.now
-      end
-      Nanoc::NotificationCenter.on(:compilation_ended) do |rep|
-        @rep_times[rep.raw_path] = Time.now - @rep_times[rep.raw_path]
-      end
-      Nanoc::NotificationCenter.on(:filtering_started) do |rep, filter_name|
-        @filter_times[filter_name] ||= []
-        @filter_times[filter_name] << Time.now
-        start_filter_progress(rep, filter_name)
-      end
-      Nanoc::NotificationCenter.on(:filtering_ended) do |rep, filter_name|
-        @filter_times[filter_name] << Time.now - @filter_times[filter_name].pop
-        stop_filter_progress(rep, filter_name)
-      end
     end
 
-    def setup_diffs
-      @diff_lock    = Mutex.new
-      @diff_threads = []
-      FileUtils.rm('output.diff') if File.file?('output.diff')
-    end
+    # Prints file actions (created, updated, deleted, identical, skipped)
+    class FileActionPrinter < Listener
 
-    def teardown_diffs
-      @diff_threads.each { |t| t.join }
-    end
+      # @option params [Array<Nanoc::ItemRep>] :reps The list of item representations in the site 
+      def initialize(params={})
+        @rep_times       = {}
 
-    def generate_diff_for(rep, 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!(/^--- .*/,    '--- ' + rep.raw_path)
-        diff.sub!(/^\+\+\+ .*/, '+++ ' + rep.raw_path)
+        @reps            = params.fetch(:reps)
+      end
 
-        # Write diff
-        @diff_lock.synchronize do
-          File.open('output.diff', 'a') { |io| io.write(diff) }
+      # @see Listener#start
+      def start
+        Nanoc::NotificationCenter.on(:compilation_started) do |rep|
+          @rep_times[rep.raw_path] = Time.now
+        end
+        Nanoc::NotificationCenter.on(:compilation_ended) do |rep|
+          @rep_times[rep.raw_path] = Time.now - @rep_times[rep.raw_path]
+        end
+        Nanoc::NotificationCenter.on(:rep_written) do |rep, path, is_created, is_modified|
+          action = (is_created ? :create : (is_modified ? :update : :identical))
+          level  = (is_created ? :high   : (is_modified ? :high   : :low))
+          duration = Time.now - @rep_times[rep.raw_path] if @rep_times[rep.raw_path]
+          Nanoc::CLI::Logger.instance.file(level, action, path, duration)
         end
       end
-    end
 
-    # TODO move this elsewhere
-    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)
+      # @see Listener#stop
+      def stop
+        super
+        @reps.select { |r| !r.compiled? }.each do |rep|
+          rep.raw_paths.each do |snapshot_name, filename|
+            next if filename.nil?
+            duration = @rep_times[filename]
+            Nanoc::CLI::Logger.instance.file(:high, :skip, filename, duration)
           end
         end
       end
-    rescue Errno::ENOENT
-      warn 'Failed to run `diff`, so no diff with the previously compiled ' \
-           'content will be available.'
-      nil
-    end
-
-    def start_filter_progress(rep, filter_name)
-      # Only show progress on terminals
-      return if !$stdout.tty?
 
-      @progress_thread = Thread.new do
-        delay = 1.0
-        step  = 0
-
-        text = "  running #{filter_name} filter… "
-
-        loop do
-          if Thread.current[:stopped]
-            # Clear
-            if delay < 0.1
-              $stdout.print ' ' * (text.length + 3) + "\r"
-            end
+    end
 
-            break
-          end
+    def run
+      self.require_site
+      self.check_for_deprecated_usage
+      self.setup_listeners
 
-          # Show progress
-          if delay < 0.1
-            $stdout.print text + %w( | / - \\ )[step] + "\r"
-            step = (step + 1) % 4
-          end
+      puts "Compiling site…"
+      time_before = Time.now
+      self.site.compile
+      self.prune
+      time_after = Time.now
+      puts
+      puts "Site compiled in #{format('%.2f', time_after - time_before)}s."
+    end
 
-          sleep 0.1
-          delay -= 0.1
-        end
+  protected
 
+    def prune  
+      if self.site.config[:prune][:auto_prune]
+        Nanoc::Extra::Pruner.new(self.site, :exclude => self.prune_config_exclude).run
       end
     end
 
-    def stop_filter_progress(rep, filter_name)
-      # Only show progress on terminals
-      return if !$stdout.tty?
+    def setup_listeners
+      @listeners = []
 
-      @progress_thread[:stopped] = true
-    end
+      if self.site.config[:enable_output_diff]
+        @listeners << Nanoc::CLI::Commands::Compile::DiffGenerator.new
+      end
 
-    def print_profiling_feedback(reps)
-      # Get max filter length
-      max_filter_name_length = @filter_times.keys.map { |k| k.to_s.size }.max
-      return if max_filter_name_length.nil?
+      if self.debug?
+        @listeners << Nanoc::CLI::Commands::Compile::DebugPrinter.new
+      end
 
-      # Print warning if necessary
-      if reps.any? { |r| !r.compiled? }
-        $stderr.puts
-        $stderr.puts "Warning: profiling information may not be accurate because " +
-                     "some items were not compiled."
+      if options.fetch(:verbose, false)
+        @listeners << Nanoc::CLI::Commands::Compile::TimingRecorder.new(:reps => self.reps)
       end
 
-      # Print header
-      puts
-      puts ' ' * max_filter_name_length + ' | count    min    avg    max     tot'
-      puts '-' * max_filter_name_length + '-+-----------------------------------'
+      unless ENV.has_key?('TRAVIS')
+        @listeners << Nanoc::CLI::Commands::Compile::GCController.new
+      end
 
-      @filter_times.to_a.sort_by { |r| r[1] }.each do |row|
-        # Extract data
-        filter_name, samples = *row
+      @listeners << Nanoc::CLI::Commands::Compile::FileActionPrinter.new(:reps => self.reps)
 
-        # Calculate stats
-        count = samples.size
-        min   = samples.min
-        tot   = samples.inject { |memo, i| memo + i}
-        avg   = tot/count
-        max   = samples.max
+      @listeners.each { |s| s.start }
+    end
 
-        # Format stats
-        count = format('%4d',   count)
-        min   = format('%4.2f', min)
-        avg   = format('%4.2f', avg)
-        max   = format('%4.2f', max)
-        tot   = format('%5.2f', tot)
+    def teardown_listeners
+      @listeners.each { |s| s.stop }
+    end
 
-        # Output stats
-        filter_name = format("%#{max_filter_name_length}s", filter_name)
-        puts "#{filter_name} |  #{count}  #{min}s  #{avg}s  #{max}s  #{tot}s"
-      end
+    def reps
+      self.site.items.map { |i| i.reps }.flatten
     end
+    memoize :reps
 
-  protected
+    def check_for_deprecated_usage
+      # Check presence of --all option
+      if options.has_key?(:all) || options.has_key?(:force)
+        $stderr.puts "Warning: the --force option (and its deprecated --all alias) are, as of nanoc 3.2, no longer supported and have no effect."
+      end
+
+      # Warn if trying to compile a single item
+      if arguments.size == 1
+        $stderr.puts '-' * 80
+        $stderr.puts 'Note: As of nanoc 3.2, it is no longer possible to compile a single item. When invoking the “compile” command, all items in the site will be compiled.'
+        $stderr.puts '-' * 80
+      end
+    end
 
     def prune_config
       self.site.config[:prune] || {}