error_handler.rb in nanoc-3.6.8

- old
+ new

@@ -7,25 +7,25 @@
   # @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={})
+    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)
+    def self.handle_while(params = {}, &block)
       if @disabled
         yield
       else
-        self.new(params).handle_while(&block)
+        new(params).handle_while(&block)
       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.
@@ -50,44 +50,44 @@
     # @return [void]
     #
     # @api private
     def handle_while(&block)
       # Set exit handler
-      [ 'INT', 'TERM' ].each do |signal|
+      %w( INT TERM ).each do |signal|
         Signal.trap(signal) do
           puts
           exit!(0)
         end
       end
       begin
         Signal.trap('USR1') do
-          puts "Caught USR1; dumping a stack trace"
+          puts 'Caught USR1; dumping a stack trace'
           puts caller.map { |i| "  #{i}" }.join("\n")
         end
       rescue ArgumentError
       end
 
       # Run
       yield
     rescue Nanoc::Errors::GenericTrivial => e
       $stderr.puts "Error: #{e.message}"
       exit(1)
-    rescue Interrupt => e
+    rescue Interrupt
       exit(1)
     rescue StandardError, ScriptError => e
-      self.print_error(e)
+      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)
+      new.print_error(error)
     end
 
     # Prints the given error to stderr. Includes message, possible resolution
     # (see {#resolution_for}), compilation stack, backtrace, etc.
     #
@@ -115,19 +115,19 @@
     #
     # @return [void]
     def write_compact_error(error, stream)
       # Header
       stream.puts
-      stream.puts "Captain! We’ve been hit!"
+      stream.puts 'Captain! We’ve been hit!'
 
       # Sections
-      self.write_error_message(    stream, error)
-      self.write_compilation_stack(stream, error)
-      self.write_stack_trace(      stream, error)
+      write_error_message(stream, error)
+      write_compilation_stack(stream, error)
+      write_stack_trace(stream, error)
 
       # Issue link
-      self.write_issue_link(stream)
+      write_issue_link(stream)
     end
 
     # Writes a verbose representation of the error on the given stream.
     #
     # @param [Error] error The error that should be described
@@ -140,19 +140,19 @@
     def write_verbose_error(error, stream)
       # Header
       stream.puts "Crashlog created at #{Time.now}"
 
       # Sections
-      self.write_error_message(      stream, error, :verbose => true)
-      self.write_compilation_stack(  stream, error, :verbose => true)
-      self.write_stack_trace(        stream, error, :verbose => true)
-      self.write_version_information(stream,        :verbose => true)
-      self.write_system_information( stream,        :verbose => true)
-      self.write_installed_gems(     stream,        :verbose => true)
-      self.write_environment(        stream,        :verbose => true)
-      self.write_gemfile_lock(       stream,        :verbose => true)
-      self.write_load_paths(         stream,        :verbose => true)
+      write_error_message(stream, error, :verbose => true)
+      write_compilation_stack(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_environment(stream,        :verbose => true)
+      write_gemfile_lock(stream,        :verbose => true)
+      write_load_paths(stream,        :verbose => true)
     end
 
   protected
 
     # @return [Boolean] true if debug output is enabled, false if not
@@ -236,11 +236,11 @@
         gem_name = GEM_NAMES[matches[2]]
 
         # Build message
         if gem_name
           if self.using_bundler?
-            "Make sure the gem is added to Gemfile and run `bundle install`."
+            'Make sure the gem is added to Gemfile and run `bundle install`.'
           else
             "Install the '#{gem_name}' gem using `gem install #{gem_name}`."
           end
         end
       when RuntimeError
@@ -256,100 +256,100 @@
 
     def using_bundler?
       defined?(Bundler) && Bundler::SharedHelpers.in_bundle?
     end
 
-    def write_section_header(stream, title, params={})
+    def write_section_header(stream, title, params = {})
       stream.puts
       if params[:verbose]
         stream.puts '===== ' + title.upcase + ':'
       else
         stream.puts "\e[1m\e[31m" + title + ':' + "\e[0m"
       end
       stream.puts
     end
 
-    def write_error_message(stream, error, params={})
-      self.write_section_header(stream, 'Message', params)
+    def write_error_message(stream, error, params = {})
+      write_section_header(stream, 'Message', params)
 
       stream.puts "#{error.class}: #{error.message}"
-      resolution = self.resolution_for(error)
+      resolution = resolution_for(error)
       stream.puts "#{resolution}" if resolution
     end
 
-    def write_compilation_stack(stream, error, params={})
-      self.write_section_header(stream, 'Compilation stack', params)
+    def write_compilation_stack(stream, error, params = {})
+      write_section_header(stream, 'Compilation stack', params)
 
-      if self.stack.empty?
-        stream.puts "  (empty)"
+      if stack.empty?
+        stream.puts '  (empty)'
       else
-        self.stack.reverse.each do |obj|
+        stack.reverse.each do |obj|
           if obj.is_a?(Nanoc::ItemRep)
             stream.puts "  - [item]   #{obj.item.identifier} (rep #{obj.name})"
           else # layout
             stream.puts "  - [layout] #{obj.identifier}"
           end
         end
       end
     end
 
-    def write_stack_trace(stream, error, params={})
-      self.write_section_header(stream, 'Stack trace', params)
+    def write_stack_trace(stream, error, params = {})
+      is_verbose = params.fetch(:verbose, false)
 
-      count = params[:verbose] ? -1 : 10
+      write_section_header(stream, 'Stack trace', params)
+
+      count = is_verbose ? -1 : 10
       error.backtrace[0...count].each_with_index do |item, index|
         stream.puts "  #{index}. #{item}"
       end
-      if error.backtrace.size > count
+      if !is_verbose && error.backtrace.size > count
         stream.puts "  ... #{error.backtrace.size - count} more lines omitted. See full crash log for details."
       end
     end
 
-    def write_issue_link(stream, params={})
+    def write_issue_link(stream, params = {})
       stream.puts
-      stream.puts "If you believe this is a bug in nanoc, please do report it at"
-      stream.puts "-> https://github.com/nanoc/nanoc/issues/new <-"
+      stream.puts 'If you believe this is a bug in nanoc, please do report it at'
+      stream.puts '-> https://github.com/nanoc/nanoc/issues/new <-'
       stream.puts
-      stream.puts "A detailed crash log has been written to ./crash.log."
+      stream.puts 'A detailed crash log has been written to ./crash.log.'
     end
 
-    def write_version_information(stream, params={})
-      self.write_section_header(stream, 'Version information', params)
+    def write_version_information(stream, params = {})
+      write_section_header(stream, 'Version information', params)
       stream.puts Nanoc.version_information
     end
 
-    def write_system_information(stream, params={})
-      begin
-        uname = `uname -a`
-        self.write_section_header(stream, 'System information', params)
-        stream.puts uname
-      rescue Errno::ENOENT
-      end
+    def write_system_information(stream, params = {})
+      uname = `uname -a`
+      write_section_header(stream, 'System information', params)
+      stream.puts uname
+    rescue Errno::ENOENT
     end
 
-    def write_installed_gems(stream, params={})
-      self.write_section_header(stream, 'Installed gems', params)
-      self.gems_and_versions.each do |g|
+    def write_installed_gems(stream, params = {})
+      write_section_header(stream, 'Installed gems', params)
+      gems_and_versions.each do |g|
         stream.puts "  #{g.first} #{g.last.join(', ')}"
       end
     end
 
-    def write_environment(stream, params={})
-      self.write_section_header(stream, 'Environment', params)
+    def write_environment(stream, params = {})
+      write_section_header(stream, 'Environment', params)
       ENV.sort.each do |e|
         stream.puts "#{e.first} => #{e.last.inspect}"
       end
     end
 
-    def write_gemfile_lock(stream, params={})
+    def write_gemfile_lock(stream, params = {})
       if File.exist?('Gemfile.lock')
-        self.write_section_header(stream, 'Gemfile.lock', params)
+        write_section_header(stream, 'Gemfile.lock', params)
         stream.puts File.read('Gemfile.lock')
       end
     end
 
-    def write_load_paths(stream, params={})
-      self.write_section_header(stream, 'Load paths', params)
+    def write_load_paths(stream, params = {})
+      write_section_header(stream, 'Load paths', params)
       $LOAD_PATH.each_with_index do |i, index|
         stream.puts "  #{index}. #{i}"
       end
     end
 