nanoc 3.6.2 → 3.6.3

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

@@ -33,6 +33,18 @@ module Nanoc::CLI::Commands
     # @abstract Subclasses must override {#start} and may override {#stop}.
     class Listener
 
+      def initialize(params={})
+      end
+
+      # @param [Nanoc::CLI::CommandRunner] command_runner The command runner for this listener
+      #
+      # @return [Boolean] true if this listener should be enabled for the given command runner, false otherwise
+      #
+      # @abstract Returns `true` by default, but subclasses may override this.
+      def self.enable_for?(command_runner)
+        true
+      end
+
       # Starts the listener. Subclasses should override this method and set up listener notifications.
       #
       # @return [void]
@@ -53,6 +65,11 @@ module Nanoc::CLI::Commands
     # Generates diffs for every output file written
     class DiffGenerator < Listener
 
+      # @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'
@@ -138,6 +155,11 @@ module Nanoc::CLI::Commands
     # Records the time spent per filter and per item representation
     class TimingRecorder < Listener
 
+      # @see Listener#enable_for?
+      def self.enable_for?(command_runner)
+        command_runner.options.fetch(:verbose, false)
+      end
+
       # @option params [Array<Nanoc::ItemRep>] :reps The list of item representations in the site
       def initialize(params={})
         @filter_times = {}
@@ -205,7 +227,7 @@ module Nanoc::CLI::Commands
         tot   = format('%5.2f', tot)
 
         # Output stats
-        filter_name = format("%#{max_filter_name_length}s", filter_name)
+        filter_name = format("%#{max}s", filter_name)
         puts "#{filter_name} |  #{count}  #{min}s  #{avg}s  #{max}s  #{tot}s"
       end
 
@@ -214,7 +236,12 @@ module Nanoc::CLI::Commands
     # Controls garbage collection so that it only occurs once every 20 items
     class GCController < Listener
 
-      def initialize
+      # @see Listener#enable_for?
+      def self.enable_for?(command_runner)
+        ! ENV.has_key?('TRAVIS')
+      end
+
+      def initialize(params={})
         @gc_count = 0
       end
 
@@ -241,6 +268,11 @@ module Nanoc::CLI::Commands
     # Prints debug information (compilation started/ended, filtering started/ended, …)
     class DebugPrinter < Listener
 
+      # @see Listener#enable_for?
+      def self.enable_for?(command_runner)
+        command_runner.debug?
+      end
+
       # @see Listener#start
       def start
         Nanoc::NotificationCenter.on(:compilation_started) do |rep|
@@ -315,15 +347,23 @@ module Nanoc::CLI::Commands
 
     end
 
+    def initialize(options, arguments, command, params={})
+      super(options, arguments, command)
+      @listener_classes = params.fetch(:listener_classes, self.default_listener_classes)
+    end
+
     def run
+      time_before = Time.now
+
       self.load_site
       self.check_for_deprecated_usage
-      self.setup_listeners
 
       puts "Compiling site…"
-      time_before = Time.now
-      self.site.compile
-      self.prune
+      self.run_listeners_while do
+        self.site.compile
+        self.prune
+      end
+
       time_after = Time.now
       puts
       puts "Site compiled in #{format('%.2f', time_after - time_before)}s."
@@ -337,28 +377,33 @@ module Nanoc::CLI::Commands
       end
     end
 
-    def setup_listeners
-      @listeners = []
-
-      if self.site.config[:enable_output_diff]
-        @listeners << Nanoc::CLI::Commands::Compile::DiffGenerator.new
-      end
-
-      if self.debug?
-        @listeners << Nanoc::CLI::Commands::Compile::DebugPrinter.new
-      end
+    def default_listener_classes
+      [
+        Nanoc::CLI::Commands::Compile::DiffGenerator,
+        Nanoc::CLI::Commands::Compile::DebugPrinter,
+        Nanoc::CLI::Commands::Compile::TimingRecorder,
+        Nanoc::CLI::Commands::Compile::GCController,
+        Nanoc::CLI::Commands::Compile::FileActionPrinter
+      ]
+    end
 
-      if options.fetch(:verbose, false)
-        @listeners << Nanoc::CLI::Commands::Compile::TimingRecorder.new(:reps => self.reps)
-      end
+    def setup_listeners
+      @listeners = @listener_classes.
+        select { |klass| klass.enable_for?(self) }.
+        map    { |klass| klass.new(:reps => self.reps) }
 
-      unless ENV.has_key?('TRAVIS')
-        @listeners << Nanoc::CLI::Commands::Compile::GCController.new
-      end
+      @listeners.each { |s| s.start }
+    end
 
-      @listeners << Nanoc::CLI::Commands::Compile::FileActionPrinter.new(:reps => self.reps)
+    def listeners
+      @listeners
+    end
 
-      @listeners.each { |s| s.start }
+    def run_listeners_while
+      self.setup_listeners
+      yield
+    ensure
+      self.teardown_listeners
     end
 
     def teardown_listeners

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

@@ -80,12 +80,12 @@ module Nanoc::CLI::Commands
           rebuilder.call(removed[0]) if removed[0]
         end
 
-        listener = Listen::MultiListener.new(*dirs_to_watch).change(&callback)
-        listener_root = Listen::MultiListener.new('', :filter => files_to_watch, :ignore => ignore_dir).change(&callback)
+        listener = Listen::Listener.new(*dirs_to_watch).change(&callback)
+        listener_root = Listen::Listener.new('.', :filter => files_to_watch, :ignore => ignore_dir).change(&callback)
 
         begin
-          listener_root.start(false)
-          listener.start
+          listener_root.start
+          listener.start!
         rescue Interrupt
           listener.stop
           listener_root.stop
@@ -98,30 +98,47 @@ module Nanoc::CLI::Commands
       # A list of commandline tool names that can be used to send notifications
       TOOLS = %w( growlnotify notify-send ) unless defined? TOOLS
 
-      # The tool to use for discovering binaries' locations
-      FIND_BINARY_COMMAND = RUBY_PLATFORM =~ /mingw|mswin/ ? "where" : "which" unless defined? FIND_BINARY_COMMAND
-
       # Send a notification. If no notifier is found, no notification will be
       # created.
       #
       # @param [String] message The message to include in the notification
       def notify(message)
         return if tool.nil?
-        send(tool.tr('-', '_'), message)
+        if tool == 'growlnotify' && self.on_windows?
+          self.growlnotify_windows(message)
+        else
+          send(tool.tr('-', '_'), message)
+        end
+      end
+
+    protected
+
+      def have_tool_nix?(tool)
+        !`which #{tool}`.empty?
+      rescue Errno::ENOENT
+        false
+      end
+
+      def have_tool_windows?(tool)
+        !`where #{tool} 2> nul`.empty?
+      rescue Errno::ENOENT
+        false
       end
 
-    private
+      def have_tool?(tool)
+        if self.on_windows?
+          self.have_tool_windows?(tool)
+        else
+          self.have_tool_nix?(tool)
+        end
+      end
 
       def tool
         @tool ||= begin
           require 'terminal-notifier'
           'terminal-notify'
         rescue LoadError
-          begin
-            TOOLS.find { |t| !`#{FIND_BINARY_COMMAND} #{t}`.empty? }
-          rescue Errno::ENOENT
-            nil
-          end
+          TOOLS.find { |t| have_tool?(t) }
         end
       end
 
@@ -129,14 +146,30 @@ module Nanoc::CLI::Commands
         TerminalNotifier.notify(message, :title => "nanoc")
       end
 
+      def growlnotify_cmd_for(message)
+        [ 'growlnotify', '-m', message ]
+      end
+
       def growlnotify(message)
-        system('growlnotify', '-m', message)
+        system(*self.growlnotify_cmd_for(message))
+      end
+
+      def growlnotify_windows_cmd_for(message)
+        [ 'growlnotify', '/t:nanoc', message ]
+      end
+
+      def growlnotify_windows(message)
+        system(*self.growlnotify_windows_cmd_for(message))
       end
 
       def notify_send(message)
         system('notify-send', message)
       end
 
+      def on_windows?
+        !!(RUBY_PLATFORM =~ /(mingw|bccwin|wince|mswin32)/i)
+      end
+
     end
 
   end

data/lib/nanoc/data_sources/filesystem.rb

@@ -52,7 +52,7 @@ module Nanoc::DataSources
       create_object('layouts', content, attributes, identifier, params)
     end
 
-  private
+  protected
 
     # Creates a new object (item or layout) on disk in dir_name according to
     # the given identifier. The file will have its attributes taken from the
@@ -144,7 +144,7 @@ module Nanoc::DataSources
     #   }
     def all_split_files_in(dir_name)
       # Get all good file names
-      filenames = Dir[dir_name + '/**/*'].select { |i| File.file?(i) }
+      filenames = self.all_files_in(dir_name)
       filenames.reject! { |fn| fn =~ /(~|\.orig|\.rej|\.bak)$/ }
 
       # Group by identifier
@@ -173,6 +173,11 @@ module Nanoc::DataSources
       grouped_filenames
     end
 
+    # Returns all files in the given directory and directories below it.
+    def all_files_in(dir_name)
+      Nanoc::Extra::FilesystemTools.all_files_in(dir_name)
+    end
+
     # Returns the filename for the given base filename and the extension.
     #
     # If the extension is nil, this function should return nil as well.

data/lib/nanoc/data_sources/static.rb

@@ -26,24 +26,21 @@ module Nanoc::DataSources
   # exclude them from the Blogging helper's atom feed generator, among other
   # things.
   class Static < Nanoc::DataSource
+
     identifier :static
 
     def items
       # Get prefix
       prefix = config[:prefix] || 'static'
 
-      # Get all files under prefix dir
-      filenames = Dir[prefix + '/**/*'].select { |f| File.file?(f) }
-
       # Convert filenames to items
-      filenames.map do |filename|
+      self.all_files_in(prefix).map do |filename|
         attributes = {
           :extension => File.extname(filename)[1..-1],
           :filename  => filename,
         }
         attributes[:is_hidden] = true unless config[:hide_items] == false
         identifier = filename[(prefix.length+1)..-1] + '/'
-
         mtime      = File.mtime(filename)
         checksum   = Pathname.new(filename).checksum
 
@@ -56,5 +53,12 @@ module Nanoc::DataSources
       end
     end
 
+  protected
+
+    def all_files_in(dir_name)
+      Nanoc::Extra::FilesystemTools.all_files_in(dir_name)
+    end
+
   end
+
 end

data/lib/nanoc/extra.rb

@@ -5,6 +5,7 @@ module Nanoc::Extra
   autoload 'AutoCompiler',      'nanoc/extra/auto_compiler'
   autoload 'Checking',          'nanoc/extra/checking'
   autoload 'CHiCk',             'nanoc/extra/chick'
+  autoload 'FilesystemTools',   'nanoc/extra/filesystem_tools'
   autoload 'LinkCollector',     'nanoc/extra/link_collector.rb'
   autoload 'Pruner',            'nanoc/extra/pruner'
   autoload 'Validators',        'nanoc/extra/validators'

data/lib/nanoc/extra/checking/checks/external_links.rb

@@ -136,9 +136,22 @@ module ::Nanoc::Extra::Checking::Checks
       raise 'should not have gotten here'
     end
 
+    def path_for_url(url)
+      if url.path.nil? || url.path.empty?
+        path = '/'
+      else
+        path = url.path
+      end
+
+      if url.query
+        path << '?' << url.query
+      end
+
+      path
+    end
+
     def request_url_once(url, req_method = Net::HTTP::Head)
-      path = (url.path.nil? || url.path.empty? ? '/' : url.path)
-      req = req_method.new(path)
+      req = req_method.new(self.path_for_url(url))
       http = Net::HTTP.new(url.host, url.port)
       if url.instance_of? URI::HTTPS
         http.use_ssl = true

data/lib/nanoc/extra/file_proxy.rb

@@ -16,7 +16,7 @@ module Nanoc::Extra
     def freeze
     end
 
-    def respond_to?(meth)
+    def respond_to?(meth, include_all=false)
       file_instance_methods.include?(meth.to_sym)
     end
 

data/lib/nanoc/extra/filesystem_tools.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+module Nanoc::Extra
+
+  # Contains useful functions for managing the filesystem.
+  #
+  # @api private
+  module FilesystemTools
+
+    # Error that is raised when too many symlink indirections are encountered.
+    #
+    # @api private
+    class MaxSymlinkDepthExceededError < ::Nanoc::Errors::GenericTrivial
+
+      # @return [String] The last filename that was attempted to be
+      #   resolved before giving up
+      attr_reader :filename
+
+      # @param [String] filename The last filename that was attempted to be
+      #   resolved before giving up
+      def initialize(filename)
+        @filename = filename
+        super("Too many indirections while resolving symlinks. I gave up after finding out #{filename} was yet another symlink. Sorry!")
+      end
+
+    end
+
+    # Error that is raised when a file of an unknown type is encountered
+    # (something other than file, directory or link).
+    #
+    # @api private
+    class UnsupportedFileTypeError < ::Nanoc::Errors::GenericTrivial
+
+      # @return [String] The filename of the file whose type is not supported
+      attr_reader :filename
+
+      # @param [String] filename The filename of the file whose type is not
+      #   supported
+      def initialize(filename)
+        @filename = filename
+        super("The file at #{filename} is of an unsupported type (expected file, directory or link, but it is #{File.ftype(filename)}")
+      end
+
+    end
+
+    # Returns all files in the given directory and directories below it,
+    # following symlinks up to a maximum of `recursion_limit` times.
+    #
+    # @param [String] dir_name The name of the directory whose contents to
+    #   fetch
+    #
+    # @param [Integer] recursion_limit The maximum number of times to
+    #   recurse into a symlink to a directory
+    #
+    # @return [Array<String>] A list of filenames
+    #
+    # @raise [MaxSymlinkDepthExceededError] if too many indirections are
+    #   encountered while resolving symlinks
+    #
+    # @raise [UnsupportedFileTypeError] if a file of an unsupported type is
+    #   detected (something other than file, directory or link)
+    def all_files_in(dir_name, recursion_limit=10)
+      Dir[dir_name + '/**/*'].map do |fn|
+        case File.ftype(fn)
+        when 'link'
+          if 0 == recursion_limit
+            raise MaxSymlinkDepthExceededError.new(fn)
+          else
+            absolute_target = self.resolve_symlink(fn)
+            if File.file?(absolute_target)
+              fn
+            else
+              all_files_in(absolute_target, recursion_limit-1).map do |sfn|
+                fn + sfn[absolute_target.size..-1]
+              end
+            end
+          end
+        when 'file'
+          fn
+        when 'directory'
+          nil
+        else
+          raise UnsupportedFileTypeError.new(fn)
+        end
+      end.compact.flatten
+    end
+    module_function :all_files_in
+
+    # Resolves the given symlink into an absolute path.
+    #
+    # @param [String] filename The filename of the symlink to resolve
+    #
+    # @param [Integer] recursion_limit The maximum number of times to recurse
+    #   into a symlink
+    #
+    # @return [String] The absolute resolved filename of the symlink target
+    #
+    # @raise [MaxSymlinkDepthExceededError] if too many indirections are
+    #   encountered while resolving symlinks
+    #
+    # @raise [UnsupportedFileTypeError] if a file of an unsupported type is
+    #   detected (something other than file, directory or link)
+    def resolve_symlink(filename, recursion_limit=5)
+      target = File.readlink(filename)
+      absolute_target = File.expand_path(target, File.dirname(filename))
+
+      case File.ftype(absolute_target)
+      when 'link'
+        if 0 == recursion_limit
+          raise MaxSymlinkDepthExceededError.new(absolute_target)
+        else
+          self.resolve_symlink(absolute_target, recursion_limit-1)
+        end
+      when 'file', 'directory'
+        absolute_target
+      else
+        raise UnsupportedFileTypeError.new(absolute_target)
+      end
+    end
+    module_function :resolve_symlink
+
+  end
+
+end