test-kitchen 1.2.1 → 1.3.0

data/lib/kitchen/lazy_hash.rb

@@ -16,35 +16,107 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'delegate'
+require "delegate"
 
 module Kitchen
 
-  # A modifed Hash object that may contain procs as a value which must be
-  # executed in the context of another object.
+  # A modifed Hash object that may contain callables as a value which must be
+  # executed in the context of another object. This allows for delayed
+  # evaluation of a hash value while still looking and largely feeling like a
+  # normal Ruby Hash.
+  #
+  # @example normal hash accessing with regular values
+  #
+  #   data = {
+  #     :symbol => true,
+  #     "string" => "stuff"
+  #   }
+  #   context = "any object"
+  #   lazy = Kitchen::Hash.new(data, context)
+  #
+  #   lazy[:symbol] # => true
+  #   lazy.fetch("string") # => "stuff"
+  #
+  # @example hash with callable blocks as values
+  #
+  #   data = {
+  #     :lambda => ->(c) { c.length },
+  #     :proc => Proc.new { |c| c.reverse },
+  #     :simple => "value"
+  #   }
+  #   context = "any object"
+  #   lazy = Kitchen::Hash.new(data, context)
+  #
+  #   lazy[:lambda] # => 10
+  #   lazy.fetch(:proc) # => "tcejbo yna"
+  #   lazy[:simple] # => "value"
   #
   # @author Fletcher Nichol <fnichol@nichol.ca>
   class LazyHash < SimpleDelegator
 
+    # Creates a new LazyHash using a Hash-like object to populate itself and
+    # an object that can be used as context in value-callable blocks. The
+    # context object can be used to compute values for keys at the time of
+    # fetching the value.
+    #
+    # @param obj [Hash, Object] a hash-like object
+    # @param context [Object] an object that can be used to compute values
     def initialize(obj, context)
       @context = context
       super(obj)
     end
 
+    # Retrieves the rendered value object corresponding to the key object. If
+    # not found, returns the default value.
+    #
+    # @param key [Object] hash key
+    # @return [Object, nil] the value for key or the default value if key is
+    #   not found
     def [](key)
-      proc_or_val = __getobj__[key]
+      proc_or_val(__getobj__[key])
+    end
 
-      if proc_or_val.respond_to?(:call)
-        proc_or_val.call(@context)
+    # Returns a rendered value from the hash for the given key. If the key
+    # can't be found, there are several options: With no other arguments, it
+    # will raise an KeyError exception; if default is given, then that will be
+    # returned; if the optional code block is specified, then that will be run
+    # and its result returned.
+    #
+    # @param key [Object] hash key
+    # @param default [Object] default value if key is not set (optional)
+    # @return [Object, nil] the value for the key or the default value if key
+    #   is not found
+    # @raise [KeyError] if the key is not found
+    def fetch(key, default = :__undefined__, &block)
+      case default
+      when :__undefined__
+        proc_or_val(__getobj__.fetch(key, &block))
       else
-        proc_or_val
+        proc_or_val(__getobj__.fetch(key, default, &block))
       end
     end
 
+    # Returns a new Hash with all keys and rendered values of the LazyHash.
+    #
+    # @return [Hash] a new hash
     def to_hash
       hash = Hash.new
       __getobj__.keys.each { |key| hash[key] = self[key] }
       hash
     end
+
+    private
+
+    # Returns an object or invokes call with context if object is callable.
+    #
+    # @return [Object] an object
+    # @api private
+    def proc_or_val(thing)
+      if thing.respond_to?(:call)
+        thing.call(@context)
+      else
+        thing
+      end
+    end
   end
 end

data/lib/kitchen/loader/yaml.rb

@@ -16,15 +16,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'erb'
-require 'vendor/hash_recursive_merge'
+require "erb"
+require "vendor/hash_recursive_merge"
 
 if RUBY_VERSION <= "1.9.3"
   # ensure that Psych and not Syck is used for Ruby 1.9.2
-  require 'yaml'
-  YAML::ENGINE.yamler = 'psych'
+  require "yaml"
+  YAML::ENGINE.yamler = "psych"
 end
-require 'safe_yaml/load'
+require "safe_yaml/load"
 
 module Kitchen
 
@@ -46,7 +46,7 @@ module Kitchen
       #   config YAML file (default: `./.kitchen.yml`)
       # @option options [String] :local_config path to the Kitchen local
       #   config YAML file (default: `./.kitchen.local.yml`)
-      # @option options [String] :local_config path to the Kitchen global
+      # @option options [String] :global_config path to the Kitchen global
       #   config YAML file (default: `$HOME/.kitchen/config.yml`)
       # @option options [String] :process_erb whether or not to process YAML
       #   through an ERB processor (default: `true`)
@@ -70,7 +70,7 @@ module Kitchen
       #
       # @return [Hash] merged configuration data
       def read
-        if ! File.exists?(config_file)
+        if !File.exist?(config_file)
           raise UserError, "Kitchen YAML file #{config_file} does not exist."
         end
 
@@ -92,64 +92,146 @@ module Kitchen
         result
       end
 
-      protected
+      private
 
-      attr_reader :config_file, :local_config_file, :global_config_file
+      # @return [String] the absolute path to the Kitchen config YAML file
+      # @api private
+      attr_reader :config_file
 
-      def default_config_file
-        File.join(Dir.pwd, '.kitchen.yml')
-      end
+      # @return [String] the absolute path to the Kitchen local config YAML
+      #   file
+      # @api private
+      attr_reader :local_config_file
+
+      # @return [String] the absolute path to the Kitchen global config YAML
+      #   file
+      # @api private
+      attr_reader :global_config_file
 
+      # Performed a prioritized recursive merge of several source Hashes and
+      # returns a new merged Hash. There are 3 sources of configuration data:
+      #
+      # 1. local config
+      # 2. project config
+      # 3. global config
+      #
+      # The merge order is local -> project -> global, meaning that elements at
+      # the top of the above list will be merged last, and have greater
+      # precedence than elements at the bottom of the list.
+      #
+      # @return [Hash] a new merged Hash
+      # @api private
       def combined_hash
-        y = if @process_local
-          normalize(yaml).rmerge(normalize(local_yaml))
+        y = if @process_global
+          normalize(global_yaml).rmerge(normalize(yaml))
         else
           normalize(yaml)
         end
-        @process_global ? y.rmerge(normalize(global_yaml)) : y
+        @process_local ? y.rmerge(normalize(local_yaml)) : y
       end
 
+      # Loads and returns the Kitchen config YAML as a Hash.
+      #
+      # @return [Hash] the config hash
+      # @api private
       def yaml
         parse_yaml_string(yaml_string(config_file), config_file)
       end
 
+      # Loads and returns the Kitchen local config YAML as a Hash.
+      #
+      # @return [Hash] the config hash
+      # @api private
       def local_yaml
         parse_yaml_string(yaml_string(local_config_file), local_config_file)
       end
 
+      # Loads and returns the Kitchen global config YAML as a Hash.
+      #
+      # @return [Hash] the config hash
+      # @api private
       def global_yaml
         parse_yaml_string(yaml_string(global_config_file), global_config_file)
       end
 
+      # Loads a file to a string and optionally passes it through an ERb
+      # process.
+      #
+      # @return [String] a file's contents as a string
+      # @api private
       def yaml_string(file)
         string = read_file(file)
 
         @process_erb ? process_erb(string, file) : string
       end
 
+      # Passes a string through ERb to evaulate any ERb blocks.
+      #
+      # @param string [String] the string to process
+      # @param file [String] an absolute path to the file represented as the
+      #   passed in string, used for error reporting
+      # @return [String] a new string, passed through an ERb process
+      # @raise [UserError] if an ERb parsing error occurs
+      # @api private
       def process_erb(string, file)
-        ERB.new(string).result
+        tpl = ERB.new(string)
+        tpl.filename = file
+        tpl.result
       rescue => e
-        raise UserError, "Error parsing ERB content in #{file} " +
-          "(#{e.class}: #{e.message}).\n" +
-          "Please run `kitchen diagnose --no-instances --loader' to help " +
+        raise UserError, "Error parsing ERB content in #{file} " \
+          "(#{e.class}: #{e.message}).\n" \
+          "Please run `kitchen diagnose --no-instances --loader' to help " \
           "debug your issue."
       end
 
+      # Reads a file and returns its contents as a string.
+      #
+      # @param file [String] a path to a file
+      # @return [String] the files contents, or an empty string if the file
+      #   does not exist
+      # @api private
       def read_file(file)
-        File.exists?(file.to_s) ? IO.read(file) : ""
+        File.exist?(file.to_s) ? IO.read(file) : ""
+      end
+
+      # Determines the default absolute path to the Kitchen config YAML file,
+      # based on current working directory.
+      #
+      # @return [String] an absolute path to a Kitchen config YAML file
+      # @api private
+      def default_config_file
+        File.join(Dir.pwd, ".kitchen.yml")
       end
 
+      # Determines the default absolute path to the Kitchen local YAML file,
+      # based on the base Kitchen config YAML file.
+      #
+      # @return [String] an absolute path to a Kitchen local YAML file
+      # @api private
       def default_local_config_file
         config_file.sub(/(#{File.extname(config_file)})$/, '.local\1')
       end
 
+      # Determines the default absolute path to the Kitchen global YAML file,
+      # based on the base Kitchen config YAML file.
+      #
+      # @return [String] an absolute path to a Kitchen global YAML file
+      # @api private
       def default_global_config_file
         File.join(File.expand_path(ENV["HOME"]), ".kitchen", "config.yml")
       end
 
+      # Generate a diganose Hash for a particular YAML file Hash. If an error
+      # occurs when loading the data, then a failure hash will be inserted
+      # into the `:raw_data` sub-hash.
+      #
+      # @param component [Symbol] a YAML source component
+      # @param file [String] the absolute path to a file which is used for
+      #   reporting (default: `nil`)
+      # @return [Hash] a hash data structure
+      # @api private
       def diagnose_component(component, file = nil)
-        return if file && !File.exists?(file)
+        return if file && !File.exist?(file)
 
         hash = begin
           send(component)
@@ -160,6 +242,12 @@ module Kitchen
         { :filename => file, :raw_data => hash }
       end
 
+      # Generates a Hash respresenting a failure, given an Exception object.
+      #
+      # @param e [Exception] an exception
+      # @param file [String] the absolute path to a file (default: `nil`)
+      # @return [Hash] a hash data structure
+      # @api private
       def failure_hash(e, file = nil)
         result = {
           :error => {
@@ -172,14 +260,50 @@ module Kitchen
         result
       end
 
+      # Destructively modify an object containing one or more hashes so that
+      # the resulting formatted data can be consumed upstream.
+      #
+      # @param obj [Object] an object
+      # @return [Object] an object
+      # @api private
       def normalize(obj)
         if obj.is_a?(Hash)
-          obj.inject(Hash.new) { |h, (k, v)| normalize_hash(h, k, v) ; h }
+          obj.inject(Hash.new) { |h, (k, v)| normalize_hash(h, k, v); h }
         else
           obj
         end
       end
 
+      # Normalizes certain keys in the root of a data hash to be a proper
+      # sub-hash in all cases. Specifically handled are the following cases:
+      #
+      # * If the value for certain keys (`"driver"`, `"provisioner"`,
+      #   `"busser"`) are set to `nil`, a new Hash will be put in its place.
+      # * If the value for certain keys is a String, then the value is
+      #   converted to a new Hash with a default key pointing to the original
+      #   String.
+      #
+      # Given a hash:
+      #
+      #   { "driver" => nil }
+      #
+      # this method would return:
+      #
+      #   { "driver" => {} }
+      #
+      # Given a hash:
+      #
+      #   { :driver => "coolbeans" }
+      #
+      # this method would return:
+      #
+      #   { :name => { "driver" => "coolbeans" } }
+      #
+      #
+      # @param hash [Hash] the Hash to normalize
+      # @param key [Symbol] the key to normalize
+      # @param value [Object] the value to normalize
+      # @api private
       def normalize_hash(hash, key, value)
         case key
         when "driver", "provisioner", "busser"
@@ -196,20 +320,28 @@ module Kitchen
         end
       end
 
+      # Parses a YAML string and returns a Hash.
+      #
+      # @param string [String] a yaml document as a string
+      # @param file_name [String] an absolute path to the file represented as
+      #   the passed in string, used for error reporting
+      # @return [Hash] a hash
+      # @raise [UserError] if the string document cannot be parsed
+      # @api private
       def parse_yaml_string(string, file_name)
         return Hash.new if string.nil? || string.empty?
 
         result = SafeYAML.load(string) || Hash.new
         unless result.is_a?(Hash)
-          raise UserError, "Error parsing #{file_name} as YAML " +
-            "(Result of parse was not a Hash, but was a #{result.class}).\n" +
-            "Please run `kitchen diagnose --no-instances --loader' to help " +
+          raise UserError, "Error parsing #{file_name} as YAML " \
+            "(Result of parse was not a Hash, but was a #{result.class}).\n" \
+            "Please run `kitchen diagnose --no-instances --loader' to help " \
             "debug your issue."
         end
         result
       rescue SyntaxError, Psych::SyntaxError
-        raise UserError, "Error parsing #{file_name} as YAML.\n" +
-          "Please run `kitchen diagnose --no-instances --loader' to help " +
+        raise UserError, "Error parsing #{file_name} as YAML.\n" \
+          "Please run `kitchen diagnose --no-instances --loader' to help " \
           "debug your issue."
       end
     end

data/lib/kitchen/logger.rb

@@ -16,8 +16,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'fileutils'
-require 'logger'
+require "fileutils"
+require "logger"
 
 module Kitchen
 
@@ -31,55 +31,261 @@ module Kitchen
 
     include ::Logger::Severity
 
+    # @return [IO] the log device
     attr_reader :logdev
 
+    # Constructs a new logger.
+    #
+    # @param options [Hash] configuration for a new logger
+    # @option options [Symbol] :color color to use when when outputting
+    #   messages
+    # @option options [Integer] :level the logging severity threshold
+    #   (default: `Kitchen::DEFAULT_LOG_LEVEL`)
+    # @option options [String,IO] :logdev filepath String or IO object to be
+    #   used for logging (default: `nil`)
+    # @option options [String] :progname program name to include in log
+    #   messages (default: `"Kitchen"`)
+    # @option options [IO] :stdout a standard out IO object to use
+    #   (default: `$stdout`)
     def initialize(options = {})
       color = options[:color]
 
       @loggers = []
       @loggers << @logdev = logdev_logger(options[:logdev]) if options[:logdev]
       @loggers << stdout_logger(options[:stdout], color) if options[:stdout]
-      @loggers << stdout_logger(STDOUT, color) if @loggers.empty?
+      @loggers << stdout_logger($stdout, color) if @loggers.empty?
 
       self.progname = options[:progname] || "Kitchen"
       self.level = options[:level] || default_log_level
     end
 
-    %w{ level progname datetime_format debug? info? error? warn? fatal?
-    }.each do |meth|
-      define_method(meth) do |*args|
-        @loggers.first.public_send(meth, *args)
+    class << self
+
+      private
+
+      # @api private
+      # @!macro delegate_to_first_logger
+      #   @method $1()
+      def delegate_to_first_logger(meth)
+        define_method(meth) { |*args| @loggers.first.public_send(meth, *args) }
       end
-    end
 
-    %w{ level= progname= datetime_format= add <<
-        banner debug info error warn fatal unknown close
-    }.map(&:to_sym).each do |meth|
-      define_method(meth) do |*args|
-        result = nil
-        @loggers.each { |l| result = l.public_send(meth, *args) }
-        result
+      # @api private
+      # @!macro delegate_to_all_loggers
+      #   @method $1()
+      def delegate_to_all_loggers(meth)
+        define_method(meth) do |*args|
+          result = nil
+          @loggers.each { |l| result = l.public_send(meth, *args) }
+          result
+        end
       end
     end
 
+    # @return [Integer] the logging severity threshold
+    # @see http://is.gd/Okuy5p
+    delegate_to_first_logger :level
+
+    # Sets the logging severity threshold.
+    #
+    # @param level [Integer] the logging severity threshold
+    # @see http://is.gd/H1VBFH
+    delegate_to_all_loggers :level=
+
+    # @return [String] program name to include in log messages
+    # @see http://is.gd/5uHGK0
+    delegate_to_first_logger :progname
+
+    # Sets the program name to include in log messages.
+    #
+    # @param progname [String] the program name to include in log messages
+    # @see http://is.gd/f2U5Xj
+    delegate_to_all_loggers :progname=
+
+    # @return [String] the date format being used
+    # @see http://is.gd/btmFWJ
+    delegate_to_first_logger :datetime_format
+
+    # Sets the date format being used.
+    #
+    # @param format [String] the date format
+    # @see http://is.gd/M36ml8
+    delegate_to_all_loggers :datetime_format=
+
+    # Log a message if the given severity is high enough.
+    #
+    # @see http://is.gd/5opBW0
+    delegate_to_all_loggers :add
+
+    # Dump one or more messages to info.
+    #
+    # @param message [#to_s] the message to log
+    # @see http://is.gd/BCp5KV
+    delegate_to_all_loggers :<<
+
+    # Log a message with severity of banner (high level).
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/pYUCYU
+    delegate_to_all_loggers :banner
+
+    # Log a message with severity of debug.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/Re97Zp
+    delegate_to_all_loggers :debug
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of debug messages
+    # @see http://is.gd/Iq08xB
+    delegate_to_first_logger :debug?
+
+    # Log a message with severity of info.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/pYUCYU
+    delegate_to_all_loggers :info
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of info messages
+    # @see http://is.gd/lBtJkT
+    delegate_to_first_logger :info?
+
+    # Log a message with severity of error.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/mLwYMl
+    delegate_to_all_loggers :error
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of error messages
+    # @see http://is.gd/QY19JL
+    delegate_to_first_logger :error?
+
+    # Log a message with severity of warn.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/PX9AIS
+    delegate_to_all_loggers :warn
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of warn messages
+    # @see http://is.gd/Gdr4lD
+    delegate_to_first_logger :warn?
+
+    # Log a message with severity of fatal.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/5ElFPK
+    delegate_to_all_loggers :fatal
+
+    # @return [true,false] whether or not the current severity level
+    #   allows for the printing of fatal messages
+    # @see http://is.gd/7PgwRl
+    delegate_to_first_logger :fatal?
+
+    # Log a message with severity of unknown.
+    #
+    # @param message_or_progname [#to_s] the message to log. In the block
+    #   form, this is the progname to use in the log message.
+    # @yield evaluates to the message to log. This is not evaluated unless the
+    #   logger's level is sufficient to log the message. This allows you to
+    #   create potentially expensive logging messages that are only called when
+    #   the logger is configured to show them.
+    # @return [nil,true] when the given severity is not high enough (for this
+    #   particular logger), log no message, and return true
+    # @see http://is.gd/Y4hqpf
+    delegate_to_all_loggers :unknown
+
+    # Close the logging devices.
+    #
+    # @see http://is.gd/b13cVn
+    delegate_to_all_loggers :close
+
     private
 
+    # @return [Integer] the default logger level
+    # @api private
     def default_log_level
       Util.to_logger_level(Kitchen::DEFAULT_LOG_LEVEL)
     end
 
+    # Construct a new standard out logger.
+    #
+    # @param stdout [IO] the IO object that represents stdout (or similar)
+    # @param color [Symbol] color to use when outputing messages
+    # @return [StdoutLogger] a new logger
+    # @api private
     def stdout_logger(stdout, color)
       logger = StdoutLogger.new(stdout)
-      logger.formatter = proc do |severity, datetime, progname, msg|
-        Color.colorize("#{msg}\n", color)
+      if Kitchen.tty?
+        logger.formatter = proc do |_severity, _datetime, _progname, msg|
+          Color.colorize("#{msg}", color).concat("\n")
+        end
+      else
+        logger.formatter = proc do |_severity, _datetime, _progname, msg|
+          msg.concat("\n")
+        end
       end
       logger
     end
 
+    # Construct a new logdev logger.
+    #
+    # @param filepath_or_logdev [String,IO] a filepath String or IO object
+    # @return [LogdevLogger] a new logger
+    # @api private
     def logdev_logger(filepath_or_logdev)
       LogdevLogger.new(resolve_logdev(filepath_or_logdev))
     end
 
+    # Return an IO object from a filepath String or the IO object itself.
+    #
+    # @param filepath_or_logdev [String,IO] a filepath String or IO object
+    # @return [IO] an IO object
+    # @api private
     def resolve_logdev(filepath_or_logdev)
       if filepath_or_logdev.is_a? String
         FileUtils.mkdir_p(File.dirname(filepath_or_logdev))
@@ -97,21 +303,39 @@ module Kitchen
 
       alias_method :super_info, :info
 
+      # Dump one or more messages to info.
+      #
+      # @param msg [String] a message
       def <<(msg)
-        msg =~ /\n/ ? msg.split("\n").each { |l| format_line(l) } : super
+        @buffer ||= ""
+        lines, _, remainder = msg.rpartition("\n")
+        if lines.empty?
+          @buffer << remainder
+        else
+          lines.insert(0, @buffer)
+          lines.split("\n").each { |l| format_line(l.chomp) }
+          @buffer = ""
+        end
       end
 
+      # Log a banner message.
+      #
+      # @param msg [String] a message
       def banner(msg = nil, &block)
         super_info("-----> #{msg}", &block)
       end
 
       private
 
+      # Reformat a line if it already contains log formatting.
+      #
+      # @param line [String] a message line
+      # @api private
       def format_line(line)
         case line
-        when %r{^-----> } then banner(line.gsub(%r{^[ >-]{6} }, ''))
-        when %r{^>>>>>> } then error(line.gsub(%r{^[ >-]{6} }, ''))
-        when %r{^       } then info(line.gsub(%r{^[ >-]{6} }, ''))
+        when %r{^-----> } then banner(line.gsub(%r{^[ >-]{6} }, ""))
+        when %r{^>>>>>> } then error(line.gsub(%r{^[ >-]{6} }, ""))
+        when %r{^       } then info(line.gsub(%r{^[ >-]{6} }, ""))
         else info(line)
         end
       end
@@ -121,25 +345,47 @@ module Kitchen
     # output.
     class StdoutLogger < LogdevLogger
 
+      # Log a debug message
+      #
+      # @param msg [String] a message
       def debug(msg = nil, &block)
         super("D      #{msg}", &block)
       end
 
+      # Log an info message
+      #
+      # @param msg [String] a message
       def info(msg = nil, &block)
         super("       #{msg}", &block)
       end
 
+      # Log a warn message
+      #
+      # @param msg [String] a message
       def warn(msg = nil, &block)
         super("$$$$$$ #{msg}", &block)
       end
 
+      # Log an error message
+      #
+      # @param msg [String] a message
       def error(msg = nil, &block)
         super(">>>>>> #{msg}", &block)
       end
 
+      # Log a fatal message
+      #
+      # @param msg [String] a message
       def fatal(msg = nil, &block)
         super("!!!!!! #{msg}", &block)
       end
+
+      # Log an unknown message
+      #
+      # @param msg [String] a message
+      def unknown(msg = nil, &block)
+        super("?????? #{msg}", &block)
+      end
     end
   end
 end