nanoc 3.2.4 → 3.3.0

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

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+usage       'view [options]'
+summary     'start the web server that serves static files'
+description <<-EOS
+Start the static web server. Unless specified, the web server will run on port 3000 and listen on all IP addresses. Running this static web server requires 'adsf' (not 'asdf'!).
+EOS
+
+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)'
+
+module Nanoc::CLI::Commands
+
+  class View < ::Nanoc::CLI::CommandRunner
+
+    def run
+      load_adsf
+      require 'rack'
+
+      # Make sure we are in a nanoc site directory
+      self.require_site
+
+      # Set options
+      options_for_rack = {
+        :Port      => (options[:port] || 3000).to_i,
+        :Host      => (options[:host] || '0.0.0.0')
+      }
+
+      # Guess which handler we should use
+      unless handler = Rack::Handler.get(options[:handler])
+        begin
+          handler = Rack::Handler::Mongrel
+        rescue LoadError => e
+          handler = Rack::Handler::WEBrick
+        end
+      end
+
+      # Build app
+      site = self.site
+      app = Rack::Builder.new do
+        use Rack::CommonLogger
+        use Rack::ShowExceptions
+        use Rack::Lint
+        use Rack::Head
+        use Adsf::Rack::IndexFileFinder, :root => site.config[:output_dir]
+        run Rack::File.new(site.config[:output_dir])
+      end.to_app
+
+      # Run autocompiler
+      handler.run(app, options_for_rack)
+    end
+
+  protected
+
+    def load_adsf
+      # Load adsf
+      begin
+        require 'adsf'
+        return
+      rescue LoadError
+        $stderr.puts "Could not find the required 'adsf' gem, " \
+          "which is necessary for the view command."
+      end
+
+      # Check asdf
+      begin
+        require 'asdf'
+        $stderr.puts "You appear to have 'asdf' installed, " \
+          "but not 'adsf'. Please install 'adsf' (check the spelling)!"
+      rescue LoadError
+      end
+
+      # Done
+      exit 1
+    end
+
+  end
+
+end
+
+runner Nanoc::CLI::Commands::View

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

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+usage       'watch [options]'
+summary     'start the watcher'
+description <<-EOS
+Start the watcher. When a change is detected, the site will be recompiled.
+EOS
+
+module Nanoc::CLI::Commands
+
+  class Watch < ::Nanoc::CLI::CommandRunner
+
+    def run
+      require 'fssm'
+      require 'pathname'
+
+      require_site
+      watcher_config = self.site.config[:watcher] || {}
+
+      @notifier = Notifier.new
+
+      # Define rebuilder
+      rebuilder = lambda do |base, relative|
+        # Determine filename
+        if base.nil? || relative.nil?
+          filename = nil
+        else
+          filename = ::Pathname.new(File.join([ base, relative ])).relative_path_from(::Pathname.new(Dir.getwd)).to_s
+        end
+
+        # Notify
+        if filename
+          print "Change detected to #{filename}; recompiling… ".make_compatible_with_env
+        else
+          print "Watcher started; compiling the entire site… ".make_compatible_with_env
+        end
+
+        # Recompile
+        start = Time.now
+        site = Nanoc::Site.new('.')
+        begin
+          site.compile
+
+          # TODO include icon (--image misc/success-icon.png)
+          notify_on_compilation_success = watcher_config.fetch(:notify_on_compilation_success) { true }
+          if notify_on_compilation_success
+            @notifier.notify('Compilation complete')
+          end
+
+          time_spent = ((Time.now - start)*1000.0).round
+          puts "done in #{format '%is %ims', *(time_spent.divmod(1000))}"
+        rescue Exception => e
+          # TODO include icon (--image misc/error-icon.png)
+          notify_on_compilation_failure = watcher_config.fetch(:notify_on_compilation_failure) { true }
+          if notify_on_compilation_failure
+            @notifier.notify('Compilation failed')
+          end
+
+          puts
+          Nanoc::CLI::ErrorHandler.print_error(e)
+          puts
+        end
+      end
+
+      # Rebuild once
+      rebuilder.call(nil, nil)
+
+      # Get directories to watch
+      dirs_to_watch  = watcher_config[:dirs_to_watch]  || %w( content layouts lib )
+      files_to_watch = watcher_config[:files_to_watch] || %w( config.yaml Rules rules Rules.rb rules.rb' )
+      files_to_watch.delete_if { |f| !File.file?(f) }
+
+      # Watch
+      puts "Watching for changes…".make_compatible_with_env
+      watcher = lambda do |*args|
+        update(&rebuilder)
+        delete(&rebuilder)
+        create(&rebuilder)
+      end
+      monitor = FSSM::Monitor.new
+      dirs_to_watch.each  { |dir|      monitor.path(dir, '**/*', &watcher) }
+      files_to_watch.each { |filename| monitor.file(filename, &watcher)    }
+      monitor.run
+    end
+
+    # Allows sending user notifications in a cross-platform way.
+    class Notifier
+
+      # A list of commandline tool names that can be used to send notifications
+      TOOLS = %w( growlnotify notify-send )
+
+      # The tool to use for discovering binaries' locations
+      FIND_BINARY_COMMAND = RUBY_PLATFORM =~ /mingw|mswin/ ? "where" : "which"
+
+      # 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)
+      end
+
+    private
+
+      def tool
+        @tool ||= TOOLS.find { |t| !`#{FIND_BINARY_COMMAND} #{t}`.empty? }
+      end
+
+      def growlnotify(message)
+        system('growlnotify', '-m', message)
+      end
+
+      def notify_send(message)
+        system('notify-send', message)
+      end
+
+    end
+
+  end
+
+end
+
+runner Nanoc::CLI::Commands::Watch

data/lib/nanoc/cli/error_handler.rb

@@ -0,0 +1,199 @@
+# encoding: utf-8
+
+module Nanoc::CLI
+
+  # Catches errors and prints nice diagnostic messages, then exits.
+  #
+  # @api private
+  class ErrorHandler
+
+    # @option params [Nanoc::CLI::Command, nil] command The command that is
+    #   currently being executed, or nil if there is none
+    def initialize(params={})
+      @command = params[:command]
+    end
+
+    # Enables error handling in the given block.
+    #
+    # @option params [Nanoc::CLI::Command, nil] command The command that is
+    #   currently being executed, or nil if there is none
+    #
+    # @return [void]
+    def self.handle_while(params={}, &block)
+      self.new(params).handle_while(&block)
+    end
+
+    # Enables error handling in the given block. This method should not be
+    # called directly; use {Nanoc::CLI::ErrorHandler.handle_while} instead.
+    #
+    # @return [void]
+    #
+    # @api private
+    def handle_while(&block)
+      # Set exit handler
+      [ 'INT', 'TERM' ].each do |signal|
+        Signal.trap(signal) do
+          puts
+          exit!(0)
+        end
+      end
+
+      # Run
+      yield
+    rescue Interrupt => e
+      exit(1)
+    rescue StandardError, ScriptError => e
+      self.print_error(e)
+      exit(1)
+    end
+
+    # Prints the given error to stderr. Includes message, possible resolution
+    # (see {#resolution_for}), compilation stack, backtrace, etc.
+    #
+    # @param [Error] error The error that should be described
+    #
+    # @return [void]
+    def self.print_error(error)
+      self.new.print_error(error)
+    end
+
+    # Prints the given error to stderr. Includes message, possible resolution
+    # (see {#resolution_for}), compilation stack, backtrace, etc.
+    #
+    # @param [Error] error The error that should be described
+    #
+    # @return [void]
+    def print_error(error)
+      # Header
+      $stderr.puts
+      $stderr.puts "Captain! We’ve been hit!"
+
+      # Exception and resolution (if any)
+      $stderr.puts
+      $stderr.puts '=== MESSAGE:'
+      $stderr.puts
+      $stderr.puts "#{error.class}: #{error.message}"
+      resolution = self.resolution_for(error)
+      $stderr.puts "#{resolution}" if resolution
+
+      # Compilation stack
+      $stderr.puts
+      $stderr.puts '=== COMPILATION STACK:'
+      $stderr.puts
+      if self.stack.empty?
+        $stderr.puts "  (empty)"
+      else
+        self.stack.reverse.each do |obj|
+          if obj.is_a?(Nanoc::ItemRep)
+            $stderr.puts "  - [item]   #{obj.item.identifier} (rep #{obj.name})"
+          else # layout
+            $stderr.puts "  - [layout] #{obj.identifier}"
+          end
+        end
+      end
+
+      # Backtrace
+      $stderr.puts
+      $stderr.puts '=== BACKTRACE:'
+      $stderr.puts
+      $stderr.puts error.backtrace.to_enum(:each_with_index).map { |item, index| "  #{index}. #{item}" }.join("\n")
+
+      # Extra information
+      $stderr.puts
+      $stderr.puts '=== VERSION INFORMATION:'
+      $stderr.puts
+      $stderr.puts Nanoc.version_information
+
+      # Issue link
+      $stderr.puts
+      $stderr.puts "If you believe this is a bug in nanoc, please do report it at"
+      $stderr.puts "<https://github.com/ddfreyne/nanoc/issues/new>--thanks!"
+    end
+
+  protected
+
+    # @return [Boolean] true if debug output is enabled, false if not
+    #
+    # @see Nanoc::CLI.debug?
+    def debug?
+      Nanoc::CLI.debug?
+    end
+
+    # @return [Nanoc::Site] The site that is currently being processed
+    def site
+      @command && @command.site
+    end
+
+    # @return [Nanoc::Compiler] The compiler for the current site
+    def compiler
+      site && site.compiler
+    end
+
+    # @return [Array] The current compilation stack
+    def stack
+      (compiler && compiler.stack) || []
+    end
+
+    # A hash that contains the name of the gem for a given required file. If a
+    # `#require` fails, the gem name is looked up in this hash.
+    GEM_NAMES = {
+      'adsf'           => 'adsf',
+      'bluecloth'      => 'bluecloth',
+      'builder'        => 'builder',
+      'coderay'        => 'coderay',
+      'cri'            => 'cri',
+      'erubis'         => 'erubis',
+      'escape'         => 'escape',
+      'fssm'           => 'fssm',
+      'haml'           => 'haml',
+      'json'           => 'json',
+      'kramdown'       => 'kramdown',
+      'less'           => 'less',
+      'markaby'        => 'markaby',
+      'maruku'         => 'maruku',
+      'mime/types'     => 'mime-types',
+      'nokogiri'       => 'nokogiri',
+      'rack'           => 'rack',
+      'rack/cache'     => 'rack-cache',
+      'rainpress'      => 'rainpress',
+      'rdiscount'      => 'rdiscount',
+      'redcarpet'      => 'redcarpet',
+      'redcloth'       => 'redcloth',
+      'rubypants'      => 'rubypants',
+      'sass'           => 'sass',
+      'systemu'        => 'systemu',
+      'w3c_validators' => 'w3c_validators'
+    }
+
+    # Attempts to find a resolution for the given error, or nil if no
+    # resolution can be automatically obtained.
+    #
+    # @param [Error] error The error to find a resolution for
+    #
+    # @return [String] The resolution for the given error
+    def resolution_for(error)
+      case error
+      when LoadError
+        # Get gem name
+        matches = error.message.match(/(no such file to load|cannot load such file) -- ([^\s]+)/)
+        return nil if matches.nil?
+        gem_name = GEM_NAMES[matches[2]]
+
+        # Build message
+        if gem_name
+          "Try installing the '#{gem_name}' gem (`gem install #{gem_name}`) and then re-running the command."
+        end
+      when RuntimeError
+        if error.message =~ /^can't modify frozen/
+          "You attempted to modify immutable data. Some data, such as " \
+          "item/layout attributes and raw item/layout content, can not " \
+          "be modified once compilation has started. (This was " \
+          "unintentionally possible in 3.1.x and before, but has been " \
+          "disabled in 3.2.x in order to allow compiler optimisations.)"
+        end
+      end
+    end
+
+  end
+
+end

data/lib/nanoc/cli/logger.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+require 'singleton'
+
+module Nanoc::CLI
+
+  # Nanoc::CLI::Logger is a singleton class responsible for generating
+  # feedback in the terminal.
+  class Logger
+
+    # Maps actions (`:create`, `:update`, `:identical`, `:skip` and `:delete`)
+    # onto their ANSI color codes.
+    ACTION_COLORS = {
+      :create         => "\e[1m" + "\e[32m", # bold + green
+      :update         => "\e[1m" + "\e[33m", # bold + yellow
+      :identical      => "\e[1m",            # bold
+      :skip           => "\e[1m",            # bold
+      :delete         => "\e[1m" + "\e[31m"  # bold + red
+    }
+
+    include Singleton
+
+    # Returns the log level, which can be :high, :low or :off (which will log
+    # all messages, only high-priority messages, or no messages at all,
+    # respectively).
+    #
+    # @return [Symbol] The log level
+    attr_accessor :level
+
+    # @return [Boolean] True if color should be used, false otherwise
+    attr_writer :color
+
+    def initialize
+      @level = :high
+    end
+
+    # @return [Boolean] true if colors are enabled, false otherwise
+    def color?
+      if @color.nil?
+        @color = true
+        begin
+          require 'Win32/Console/ANSI' if RUBY_PLATFORM =~ /mswin|mingw/
+        rescue LoadError
+          @color = false
+        end
+      end
+
+      @color
+    end
+
+    # Logs a file-related action.
+    #
+    # @param [:high, :low] level The importance of this action
+    #
+    # @param [:create, :update, :identical, :skip, :delete] action The kind of file action
+    #
+    # @param [String] name The name of the file the action was performed on
+    #
+    # @return [void]
+    def file(level, action, identifier, duration=nil)
+      log(
+        level,
+        '%s%12s%s  %s%s' % [
+          color? ? ACTION_COLORS[action.to_sym] : '',
+          action,
+          color? ? "\e[0m" : '',
+          duration.nil? ? '' : "[%2.2fs]  " % [ duration ],
+          identifier
+        ]
+      )
+    end
+
+    # Logs a message.
+    #
+    # @param [:high, :low] level The importance of this message
+    #
+    # @param [String] message The message to be logged
+    #
+    # @param [#puts] io The stream to which the message should be written
+    #
+    # @return [void]
+    def log(level, message, io=$stdout)
+      # Don't log when logging is disabled
+      return if @level == :off
+
+      # Log when level permits it
+      io.puts(message) if (@level == :low or @level == level)
+    end
+
+  end
+
+end