nanoc-cli 4.11.13

data/lib/nanoc/cli/error_handler.rb

@@ -0,0 +1,365 @@
+# frozen_string_literal: true
+
+module Nanoc::CLI
+  # Catches errors and prints nice diagnostic messages, then exits.
+  #
+  # @api private
+  class ErrorHandler
+    # Enables error handling in the given block.
+    #
+    # @return [void]
+    def self.handle_while(exit_on_error: true)
+      if @disabled
+        yield
+      else
+        new.handle_while(exit_on_error: exit_on_error) { yield }
+      end
+    end
+
+    # Disables error handling. This is used by the test cases to prevent error
+    # from being handled by the CLI while tests are running.
+    def self.disable
+      @disabled = true
+    end
+
+    # Re-enables error handling after it was disabled. This is used by the test
+    # cases to prevent error from being handled by the CLI while tests are
+    # running.
+    def self.enable
+      @disabled = false
+    end
+
+    # Enables error handling in the given block. This method should not be
+    # called directly; use {Nanoc::CLI::ErrorHandler.handle_while} instead.
+    #
+    # @return [void]
+    def handle_while(exit_on_error:)
+      # Set exit handler
+      %w[INT TERM].each do |signal|
+        Signal.trap(signal) do
+          puts
+          exit!(0)
+        end
+      end
+
+      # Set stack trace dump handler
+      if !defined?(RUBY_ENGINE) || RUBY_ENGINE != 'jruby'
+        begin
+          Signal.trap('USR1') do
+            puts 'Caught USR1; dumping a stack trace'
+            puts caller.map { |i| "  #{i}" }.join("\n")
+          end
+        rescue ArgumentError
+        end
+      end
+
+      # Run
+      yield
+    rescue Interrupt
+      exit(1)
+    rescue StandardError, ScriptError => e
+      handle_error(e, exit_on_error: exit_on_error)
+    end
+
+    def handle_error(error, exit_on_error:)
+      if trivial?(error)
+        $stderr.puts
+        $stderr.puts "Error: #{error.message}"
+        resolution = resolution_for(error)
+        if resolution
+          $stderr.puts
+          $stderr.puts resolution
+        end
+      else
+        print_error(error)
+      end
+      exit(1) if exit_on_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 self.print_error(error)
+      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)
+      write_compact_error(error, $stderr)
+
+      File.open('crash.log', 'w') do |io|
+        cio = Nanoc::CLI.wrap_in_cleaning_stream(io)
+        cio.add_stream_cleaner(::Nanoc::CLI::StreamCleaners::ANSIColors)
+        write_verbose_error(error, cio)
+      end
+    end
+
+    # Writes a compact representation of the error, suitable for a terminal, on
+    # the given stream (probably stderr).
+    #
+    # @param [Error] error The error that should be described
+    #
+    # @param [IO] stream The stream to write the description too
+    #
+    # @return [void]
+    def write_compact_error(error, stream)
+      stream.puts
+      stream.puts 'Captain! We’ve been hit!'
+
+      if forwards_stack_trace?
+        write_stack_trace(stream, error)
+        write_error_message(stream, error)
+        write_item_rep(stream, error)
+      else
+        write_error_message(stream, error)
+        write_item_rep(stream, error)
+        write_stack_trace(stream, error)
+      end
+
+      stream.puts
+      stream.puts 'A detailed crash log has been written to ./crash.log.'
+    end
+
+    # Writes a verbose representation of the error on the given stream.
+    #
+    # @param [Error] error The error that should be described
+    #
+    # @param [IO] stream The stream to write the description too
+    #
+    # @return [void]
+    def write_verbose_error(error, stream)
+      stream.puts "Crashlog created at #{Time.now}"
+
+      write_error_message(stream, error, verbose: true)
+      write_item_rep(stream, error, verbose: true)
+      write_stack_trace(stream, error, verbose: true)
+      write_version_information(stream, verbose: true)
+      write_system_information(stream, verbose: true)
+      write_installed_gems(stream, verbose: true)
+      write_gemfile_lock(stream, verbose: true)
+      write_load_paths(stream, verbose: true)
+    end
+
+    # @api private
+    def forwards_stack_trace?
+      ruby_version.start_with?('2.5')
+    end
+
+    # @api private
+    def trivial?(error)
+      case error
+      when Nanoc::Core::TrivialError, Errno::EADDRINUSE
+        true
+      when LoadError
+        GEM_NAMES.key?(gem_name_from_load_error(error))
+      else
+        false
+      end
+    end
+
+    protected
+
+    # @return [Hash<String, Array>] A hash containing the gem names as keys and gem versions as value
+    def gems_and_versions
+      gems = {}
+      Gem::Specification.find_all.sort_by { |s| [s.name, s.version] }.each do |spec|
+        gems[spec.name] ||= []
+        gems[spec.name] << spec.version.to_s
+      end
+      gems
+    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',
+      'asciidoctor' => 'asciidoctor',
+      'bluecloth' => 'bluecloth',
+      'builder' => 'builder',
+      'coderay' => 'coderay',
+      'coffee-script' => 'coffee-script',
+      'cri' => 'cri',
+      'erubi' => 'erubi',
+      'erubis' => 'erubis',
+      'escape' => 'escape',
+      'fog' => 'fog',
+      'haml' => 'haml',
+      'json' => 'json',
+      'kramdown' => 'kramdown',
+      'less' => 'less',
+      'listen' => 'listen',
+      'markaby' => 'markaby',
+      'maruku' => 'maruku',
+      'mime/types' => 'mime-types',
+      'mustache' => 'mustache',
+      'nanoc/live' => 'nanoc-live',
+      'nokogiri' => 'nokogiri',
+      'nokogumbo' => 'nokogumbo',
+      'pandoc-ruby' => 'pandoc-ruby',
+      'pry' => 'pry',
+      'rack' => 'rack',
+      'rack/cache' => 'rack-cache',
+      'rainpress' => 'rainpress',
+      'rdiscount' => 'rdiscount',
+      'redcarpet' => 'redcarpet',
+      'redcloth' => 'RedCloth',
+      'ruby-handlebars' => 'hbs',
+      'rubypants' => 'rubypants',
+      'sass' => 'sass',
+      'slim' => 'slim',
+      'typogruby' => 'typogruby',
+      'uglifier' => 'uglifier',
+      'w3c_validators' => 'w3c_validators',
+      'yuicompressor' => 'yuicompressor',
+    }.freeze
+
+    # 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)
+      error = unwrap_error(error)
+
+      case error
+      when LoadError
+        gem_name = gem_name_from_load_error(error)
+
+        if gem_name
+          if using_bundler?
+            <<~RES
+              1. Add `gem '#{gem_name}'` to your Gemfile
+              2. Run `bundle install`
+              3. Re-run this command
+            RES
+          else
+            "Install the '#{gem_name}' gem using `gem install #{gem_name}`."
+          end
+        end
+      when RuntimeError
+        if /^can't modify frozen/.match?(error.message)
+          'You attempted to modify immutable data. Some data cannot ' \
+          'be modified once compilation has started. Such data includes ' \
+          'content and attributes of items and layouts, and filter arguments.'
+        end
+      when Errno::EADDRINUSE
+        'There already is a server running. Either shut down that one, or ' \
+        'specify a different port to run this server on.'
+      end
+    end
+
+    def gem_name_from_load_error(error)
+      matches = error.message.match(/(no such file to load|cannot load such file) -- ([^\s]+)/)
+      return nil if matches.nil?
+
+      GEM_NAMES[matches[2]]
+    end
+
+    def using_bundler?
+      defined?(Bundler) && Bundler::SharedHelpers.in_bundle?
+    end
+
+    def ruby_version
+      RUBY_VERSION
+    end
+
+    def write_section_header(stream, title, verbose: false)
+      stream.puts
+
+      if verbose
+        stream.puts '===== ' + title.upcase + ':'
+        stream.puts
+      end
+    end
+
+    def write_error_message(stream, error, verbose: false)
+      write_section_header(stream, 'Message', verbose: verbose)
+
+      error = unwrap_error(error)
+
+      message = "#{error.class}: #{message_for_error(error)}"
+      unless verbose
+        message = "\e[1m\e[31m" + message + "\e[0m"
+      end
+      stream.puts message
+      resolution = resolution_for(error)
+      stream.puts resolution.to_s if resolution
+    end
+
+    def message_for_error(error)
+      case error
+      when JsonSchema::AggregateError
+        "\n" + error.errors.map { |e| "  * #{e.pointer}: #{e.message}" }.join("\n")
+      else
+        error.message
+      end
+    end
+
+    def write_item_rep(stream, error, verbose: false)
+      return unless error.is_a?(Nanoc::Core::Errors::CompilationError)
+
+      write_section_header(stream, 'Item being compiled', verbose: verbose)
+
+      item_rep = error.item_rep
+      stream.puts "Current item: #{item_rep.item.identifier} (#{item_rep.name.inspect} representation)"
+    end
+
+    def write_stack_trace(stream, error, verbose: false)
+      write_section_header(stream, 'Stack trace', verbose: verbose)
+
+      writer = Nanoc::CLI::StackTraceWriter.new(stream, forwards: forwards_stack_trace?)
+      writer.write(unwrap_error(error), verbose: verbose)
+    end
+
+    def write_version_information(stream, verbose: false)
+      write_section_header(stream, 'Version information', verbose: verbose)
+      stream.puts Nanoc::Core.version_information
+    end
+
+    def write_system_information(stream, verbose: false)
+      uname = `uname -a`
+      write_section_header(stream, 'System information', verbose: verbose)
+      stream.puts uname
+    rescue Errno::ENOENT
+    end
+
+    def write_installed_gems(stream, verbose: false)
+      write_section_header(stream, 'Installed gems', verbose: verbose)
+      gems_and_versions.each do |g|
+        stream.puts "  #{g.first} #{g.last.join(', ')}"
+      end
+    end
+
+    def write_gemfile_lock(stream, verbose: false)
+      if File.exist?('Gemfile.lock')
+        write_section_header(stream, 'Gemfile.lock', verbose: verbose)
+        stream.puts File.read('Gemfile.lock')
+      end
+    end
+
+    def write_load_paths(stream, verbose: false)
+      write_section_header(stream, 'Load paths', verbose: verbose)
+      $LOAD_PATH.each_with_index do |i, index|
+        stream.puts "  #{index}. #{i}"
+      end
+    end
+
+    def unwrap_error(e)
+      case e
+      when Nanoc::Core::Errors::CompilationError
+        e.unwrap
+      else
+        e
+      end
+    end
+  end
+end

data/lib/nanoc/cli/logger.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module CLI
+    # Nanoc::CLI::Logger is a singleton class responsible for generating
+    # feedback in the terminal.
+    #
+    # @api private
+    class Logger
+      # Maps actions (`:create`, `:update`, `:identical`, `:cached`, `:skip` and `:delete`)
+      # onto their ANSI color codes.
+      ACTION_COLORS = {
+        create: "\e[32m", # green
+        update: "\e[33m", # yellow
+        identical: '',    # (nothing)
+        cached: '',       # (nothing)
+        skip: '',         # (nothing)
+        delete: "\e[31m", # red
+      }.freeze
+
+      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
+
+      def initialize
+        @level = :high
+        @mutex = Mutex.new
+      end
+
+      # Logs a file-related action.
+      #
+      # @param [:high, :low] level The importance of this action
+      #
+      # @param [:create, :update, :identical, :cached, :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, name, duration = nil)
+        log(
+          level,
+          format(
+            '%s%12s%s  %s%s',
+            ACTION_COLORS[action.to_sym],
+            action,
+            "\e[0m",
+            duration.nil? ? '' : format('[%2.2fs]  ', duration),
+            name,
+          ),
+        )
+      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)
+        return if @level == :off
+        return if @level != :low && @level != level
+
+        @mutex.synchronize do
+          io.puts(message)
+        end
+      end
+    end
+  end
+end

data/lib/nanoc/cli/stack_trace_writer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Nanoc
+  module CLI
+    class StackTraceWriter
+      def initialize(stream, forwards:)
+        @stream = stream
+        @forwards = forwards
+      end
+
+      def write(error, verbose:)
+        if @forwards
+          write_forwards(error, verbose: verbose)
+        else
+          write_backwards(error, verbose: verbose)
+        end
+      end
+
+      private
+
+      def write_backwards(error, verbose:)
+        count = verbose ? -1 : 10
+
+        error.backtrace[0...count].each_with_index do |item, index|
+          @stream.puts "  #{index}. #{item}"
+        end
+
+        if !verbose && error.backtrace.size > count
+          @stream.puts "  ... #{error.backtrace.size - count} lines omitted (see crash.log for details)"
+        end
+      end
+
+      def write_forwards(error, verbose:)
+        count = 10
+        backtrace = verbose ? error.backtrace : error.backtrace.take(count)
+
+        if !verbose && error.backtrace.size > count
+          @stream.puts "  ... #{error.backtrace.size - count} lines omitted (see crash.log for details)"
+        end
+
+        backtrace.each_with_index.to_a.reverse_each do |(item, index)|
+          if index.zero?
+            @stream.puts "  #{item}"
+          else
+            @stream.puts "  #{index}. from #{item}"
+          end
+        end
+      end
+    end
+  end
+end