chef 15.1.36-universal-mingw32 → 15.2.20-universal-mingw32

data/lib/chef/data_collector.rb

@@ -174,16 +174,20 @@ class Chef
       #
       def send_to_data_collector(message)
         return unless Chef::Config[:data_collector][:server_url]
+
         @http ||= setup_http_client(Chef::Config[:data_collector][:server_url])
         @http.post(nil, message, headers)
-      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
-        Errno::ECONNREFUSED, EOFError, Net::HTTPBadResponse,
-        Net::HTTPHeaderSyntaxError, Net::ProtocolError, OpenSSL::SSL::SSLError,
-        Errno::EHOSTDOWN => e
+      rescue => e
         # Do not disable data collector reporter if additional output_locations have been specified
         events.unregister(self) unless Chef::Config[:data_collector][:output_locations]
 
-        code = e&.response&.code&.to_s || "Exception Code Empty"
+        begin
+          code = e&.response&.code&.to_s
+        rescue
+          # i really dont care
+        end
+
+        code ||= "No HTTP Code"
 
         msg = "Error while reporting run start to Data Collector. URL: #{Chef::Config[:data_collector][:server_url]} Exception: #{code} -- #{e.message} "
 
@@ -191,9 +195,13 @@ class Chef
           Chef::Log.error(msg)
           raise
         else
-          # Make the message non-scary for folks who don't have automate:
-          msg << " (This is normal if you do not have #{Chef::Dist::AUTOMATE})"
-          Chef::Log.info(msg)
+          if code == "404"
+            # Make the message non-scary for folks who don't have automate:
+            msg << " (This is normal if you do not have #{Chef::Dist::AUTOMATE})"
+            Chef::Log.debug(msg)
+          else
+            Chef::Log.warn(msg)
+          end
         end
       end
 

data/lib/chef/data_collector/run_end_message.rb

@@ -85,12 +85,14 @@ class Chef
         # @return [Integer] the number of resources successfully updated in the chef-client run
         def updated_resource_count(action_collection)
           return 0 if action_collection.nil?
+
           action_collection.filtered_collection(up_to_date: false, skipped: false, unprocessed: false, failed: false).count
         end
 
         # @return [Array<Chef::ActionCollection::ActionRecord>] list of all action_records for all resources
         def action_records(action_collection)
           return [] if action_collection.nil?
+
           action_collection.action_records
         end
 

data/lib/chef/decorator.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright:: Copyright 2016 Chef Software, Inc.
+# Copyright:: Copyright 2016-2019, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,14 +16,13 @@
 #
 
 require "delegate"
+require_relative "constants"
 
 class Chef
   class Decorator < SimpleDelegator
-    NULL = ::Object.new
-
-    def initialize(obj = NULL)
+    def initialize(obj = NOT_PASSED)
       @__defined_methods__ = []
-      super unless obj.equal?(NULL)
+      super unless obj.equal?(NOT_PASSED)
     end
 
     # if we wrap a nil then decorator.nil? should be true
@@ -38,7 +37,7 @@ class Chef
 
     # if we wrap a Hash then decorator.kind_of?(Hash) should be true
     def kind_of?(klass)
-      __getobj__.kind_of?(klass) || super
+      __getobj__.is_a?(klass) || super
     end
 
     # reset our methods on the instance if the object changes under us (this also

data/lib/chef/deprecated.rb

@@ -84,6 +84,7 @@ class Chef
           relevant_line = location_file.readline
           relevant_line.match?(/#.*chef:silence_deprecation($|[^:]|:#{self.class.deprecation_key})/)
         end
+
         false
       end
 

data/lib/chef/dsl/data_query.rb

@@ -38,7 +38,7 @@ class Chef
         if Kernel.block_given? || args.length >= 4
           Chef::Search::Query.new.search(*args, &block)
         else
-          results = Array.new
+          results = []
           Chef::Search::Query.new.search(*args) do |o|
             results << o
           end

data/lib/chef/dsl/declare_resource.rb

@@ -41,6 +41,7 @@ class Chef
       #
       def with_run_context(rc)
         raise ArgumentError, "with_run_context is useless without a block" unless block_given?
+
         old_run_context = @run_context
         @run_context =
           case rc
@@ -202,6 +203,7 @@ class Chef
       #
       def find_resource!(type, name, run_context: self.run_context)
         raise ArgumentError, "find_resource! does not take a block" if block_given?
+
         run_context.resource_collection.find(type => name)
       end
 

data/lib/chef/dsl/platform_introspection.rb

@@ -70,6 +70,7 @@ class Chef
         def match_versions(node)
           platform, version = node[:platform].to_s, node[:platform_version].to_s
           return nil unless @values.key?(platform)
+
           node_version = Chef::Version::Platform.new(version)
           key_matches = []
           keys = @values[platform].keys
@@ -84,6 +85,7 @@ class Chef
             end
           end
           return @values[platform][version] if key_matches.include?(version)
+
           case key_matches.length
           when 0
             return nil
@@ -124,7 +126,7 @@ class Chef
         end
 
         def assert_valid_platform_values!(platforms, value)
-          unless value.kind_of?(Hash)
+          unless value.is_a?(Hash)
             msg = "platform dependent values must be specified in the format :platform => {:version => value} "
             msg << "you gave a value #{value.inspect} for platform(s) #{platforms}"
             raise ArgumentError, msg

data/lib/chef/encrypted_data_bag_item.rb

@@ -130,11 +130,12 @@ class Chef::EncryptedDataBagItem
 
   def self.load_secret(path = nil)
     path ||= Chef::Config[:encrypted_data_bag_secret]
-    if !path
-      raise ArgumentError, "No secret specified and no secret found at #{Chef::Config.platform_specific_path(Chef::Dist::CONF_DIR + '/encrypted_data_bag_secret')}"
+    unless path
+      raise ArgumentError, "No secret specified and no secret found at #{Chef::Config.platform_specific_path(Chef::Dist::CONF_DIR + "/encrypted_data_bag_secret")}"
     end
+
     secret = case path
-             when /^\w+:\/\//
+             when %r{^\w+://}
                # We have a remote key
                begin
                  Kernel.open(path).read.strip
@@ -144,14 +145,16 @@ class Chef::EncryptedDataBagItem
                  raise ArgumentError, "Remote key not found at '#{path}'"
                end
              else
-               if !File.exist?(path)
+               unless File.exist?(path)
                  raise Errno::ENOENT, "file not found '#{path}'"
                end
+
                IO.read(path).strip
              end
     if secret.size < 1
       raise ArgumentError, "invalid zero length secret in '#{path}'"
     end
+
     secret
   end
 

data/lib/chef/encrypted_data_bag_item/assertions.rb

@@ -27,7 +27,7 @@ class Chef::EncryptedDataBagItem
   module Assertions
 
     def assert_format_version_acceptable!(format_version)
-      unless format_version.kind_of?(Integer) && format_version >= Chef::Config[:data_bag_decrypt_minimum_version]
+      unless format_version.is_a?(Integer) && format_version >= Chef::Config[:data_bag_decrypt_minimum_version]
         raise UnacceptableEncryptedDataBagItemFormat,
           "The encrypted data bag item has format version `#{format_version}', " +
           "but the config setting 'data_bag_decrypt_minimum_version' requires version `#{Chef::Config[:data_bag_decrypt_minimum_version]}'"

data/lib/chef/encrypted_data_bag_item/check_encrypted.rb

@@ -40,6 +40,7 @@ class Chef::EncryptedDataBagItem
     # keys and the hash's keys.
     def looks_like_encrypted?(data)
       return false unless data.is_a?(Hash) && data.key?("version")
+
       case data["version"]
         when 1
           Chef::EncryptedDataBagItem::Encryptor::Version1Encryptor.encryptor_keys.sort == data.keys.sort

data/lib/chef/encrypted_data_bag_item/decryptor.rb

@@ -94,7 +94,7 @@ class Chef::EncryptedDataBagItem
             plaintext << openssl_decryptor.final
           rescue OpenSSL::Cipher::CipherError => e
             # if the key length is less than 255 characters, and it contains slashes, we think it may be a path.
-            raise DecryptionFailure, "Error decrypting data bag value: '#{e.message}'. Most likely the provided key is incorrect. #{(@key.length < 255 && @key.include?('/')) ? 'You may need to use --secret-file rather than --secret.' : ''}"
+            raise DecryptionFailure, "Error decrypting data bag value: '#{e.message}'. Most likely the provided key is incorrect. #{(@key.length < 255 && @key.include?("/")) ? "You may need to use --secret-file rather than --secret." : ""}"
           end
       end
 
@@ -147,7 +147,7 @@ class Chef::EncryptedDataBagItem
             plaintext << openssl_decryptor.final
           rescue OpenSSL::Cipher::CipherError => e
             # if the key length is less than 255 characters, and it contains slashes, we think it may be a path.
-            raise DecryptionFailure, "Error decrypting data bag value: '#{e.message}'. Most likely the provided key is incorrect. #{( @key.length < 255 && @key.include?('/')) ? 'You may need to use --secret-file rather than --secret.' : ''}"
+            raise DecryptionFailure, "Error decrypting data bag value: '#{e.message}'. Most likely the provided key is incorrect. #{( @key.length < 255 && @key.include?("/")) ? "You may need to use --secret-file rather than --secret." : ""}"
           end
       end
 
@@ -188,6 +188,7 @@ class Chef::EncryptedDataBagItem
 
       def candidate_hmac_matches?(expected_hmac)
         return false unless @encrypted_data["hmac"]
+
         expected_bytes = expected_hmac.bytes.to_a
         candidate_hmac_bytes = Base64.decode64(@encrypted_data["hmac"]).bytes.to_a
         valid = expected_bytes.size ^ candidate_hmac_bytes.size
@@ -213,6 +214,7 @@ class Chef::EncryptedDataBagItem
         if auth_tag_b64.nil?
           raise DecryptionFailure, "Error decrypting data bag value: invalid authentication tag. Most likely the data is corrupted"
         end
+
         Base64.decode64(auth_tag_b64)
       end
 

data/lib/chef/encrypted_data_bag_item/encryptor.rb

@@ -193,6 +193,7 @@ class Chef::EncryptedDataBagItem
         if @auth_tag.nil?
           raise EncryptionFailure, "Internal Error: GCM authentication tag read before encryption"
         end
+
         @auth_tag
       end
 

data/lib/chef/environment.rb

@@ -42,7 +42,7 @@ class Chef
       @description = ""
       @default_attributes = Mash.new
       @override_attributes = Mash.new
-      @cookbook_versions = Hash.new
+      @cookbook_versions = {}
       @chef_server_rest = chef_server_rest
     end
 
@@ -158,7 +158,7 @@ class Chef
       # reset because everything we need will be in the params, this is necessary because certain constraints
       # may have been removed in the params and need to be removed from cookbook_versions as well.
       bkup_cb_versions = cookbook_versions
-      cookbook_versions(Hash.new)
+      cookbook_versions({})
       valid = true
 
       begin
@@ -229,7 +229,7 @@ class Chef
 
     def self.list(inflate = false)
       if inflate
-        response = Hash.new
+        response = {}
         Chef::Search::Query.new.search(:environment) do |e|
           response[e.name] = e unless e.nil?
         end
@@ -278,6 +278,7 @@ class Chef
         chef_server_rest.put("environments/#{@name}", self)
       rescue Net::HTTPClientException => e
         raise e unless e.response.code == "404"
+
         chef_server_rest.post("environments", self)
       end
       self
@@ -297,7 +298,8 @@ class Chef
     end
 
     def self.validate_cookbook_versions(cv)
-      return false unless cv.kind_of?(Hash)
+      return false unless cv.is_a?(Hash)
+
       cv.each_value do |version|
         return false unless Chef::Environment.validate_cookbook_version(version)
       end
@@ -307,7 +309,7 @@ class Chef
     def self.validate_cookbook_version(version)
       if Chef::Config[:solo_legacy_mode]
         raise Chef::Exceptions::IllegalVersionConstraint,
-              "Environment cookbook version constraints not allowed in #{Chef::Dist::SOLO}"
+          "Environment cookbook version constraints not allowed in #{Chef::Dist::SOLO}"
       else
         Chef::VersionConstraint.new version
         true

data/lib/chef/event_dispatch/base.rb

@@ -29,268 +29,206 @@ class Chef
     class Base
 
       # Called at the very start of a Chef Run
-      def run_start(version, run_status)
-      end
+      def run_start(version, run_status); end
 
-      def run_started(run_status)
-      end
+      def run_started(run_status); end
 
       # Called at the end a successful Chef run.
-      def run_completed(node, run_status)
-      end
+      def run_completed(node, run_status); end
 
       # Called at the end of a failed Chef run.
-      def run_failed(exception, run_status)
-      end
+      def run_failed(exception, run_status); end
 
       # Called right after ohai runs.
       # NOTE: the node object here is always nil because of when it is called
-      def ohai_completed(node)
-      end
+      def ohai_completed(node); end
 
       # Announce that we're not going to register the client. Generally because
       # we already have the private key, or because we're deliberately not using
       # a key.
-      def skipping_registration(node_name, config)
-      end
+      def skipping_registration(node_name, config); end
 
       # About to attempt to create a private key registered to the server with
       # client +node_name+.
-      def registration_start(node_name, config)
-      end
+      def registration_start(node_name, config); end
 
       # Successfully created the private key and registered this client with the
       # server.
-      def registration_completed
-      end
+      def registration_completed; end
 
       # Failed to register this client with the server.
-      def registration_failed(node_name, exception, config)
-      end
+      def registration_failed(node_name, exception, config); end
 
       # Called before Chef client loads the node data from the server
-      def node_load_start(node_name, config)
-      end
+      def node_load_start(node_name, config); end
 
       # TODO: def node_run_list_overridden(*args)
 
       # Called once the node is loaded by the policy builder
-      def node_load_success(node)
-      end
+      def node_load_success(node); end
 
       # Failed to load node data from the server
-      def node_load_failed(node_name, exception, config)
-      end
+      def node_load_failed(node_name, exception, config); end
 
       # Error expanding the run list
-      def run_list_expand_failed(node, exception)
-      end
+      def run_list_expand_failed(node, exception); end
 
       # Called after Chef client has loaded the node data.
       # Default and override attrs from roles have been computed, but not yet applied.
       # Normal attrs from JSON have been added to the node.
-      def node_load_completed(node, expanded_run_list, config)
-      end
+      def node_load_completed(node, expanded_run_list, config); end
 
       # Called after the Policyfile was loaded. This event only occurs when
       # chef is in policyfile mode.
-      def policyfile_loaded(policy)
-      end
+      def policyfile_loaded(policy); end
 
       # Called before the cookbook collection is fetched from the server.
-      def cookbook_resolution_start(expanded_run_list)
-      end
+      def cookbook_resolution_start(expanded_run_list); end
 
       # Called when there is an error getting the cookbook collection from the
       # server.
-      def cookbook_resolution_failed(expanded_run_list, exception)
-      end
+      def cookbook_resolution_failed(expanded_run_list, exception); end
 
       # Called when the cookbook collection is returned from the server.
-      def cookbook_resolution_complete(cookbook_collection)
-      end
+      def cookbook_resolution_complete(cookbook_collection); end
 
       # Called before unneeded cookbooks are removed
-      def cookbook_clean_start
-      end
+      def cookbook_clean_start; end
 
       # Called after the file at +path+ is removed. It may be removed if the
       # cookbook containing it was removed from the run list, or if the file was
       # removed from the cookbook.
-      def removed_cookbook_file(path)
-      end
+      def removed_cookbook_file(path); end
 
       # Called when cookbook cleaning is finished.
-      def cookbook_clean_complete
-      end
+      def cookbook_clean_complete; end
 
       # Called before cookbook sync starts
-      def cookbook_sync_start(cookbook_count)
-      end
+      def cookbook_sync_start(cookbook_count); end
 
       # Called when cookbook +cookbook+ has been sync'd
-      def synchronized_cookbook(cookbook_name, cookbook)
-      end
+      def synchronized_cookbook(cookbook_name, cookbook); end
 
       # Called when an individual file in a cookbook has been updated
-      def updated_cookbook_file(cookbook_name, path)
-      end
+      def updated_cookbook_file(cookbook_name, path); end
 
       # Called when an error occurs during cookbook sync
-      def cookbook_sync_failed(cookbooks, exception)
-      end
+      def cookbook_sync_failed(cookbooks, exception); end
 
       # Called after all cookbooks have been sync'd.
-      def cookbook_sync_complete
-      end
+      def cookbook_sync_complete; end
 
       # Called when starting to collect gems from the cookbooks
-      def cookbook_gem_start(gems)
-      end
+      def cookbook_gem_start(gems); end
 
       # Called when the result of installing the bundle is to install the gem
-      def cookbook_gem_installing(gem, version)
-      end
+      def cookbook_gem_installing(gem, version); end
 
       # Called when the result of installing the bundle is to use the gem
-      def cookbook_gem_using(gem, version)
-      end
+      def cookbook_gem_using(gem, version); end
 
       # Called when finished installing cookbook gems
-      def cookbook_gem_finished
-      end
+      def cookbook_gem_finished; end
 
       # Called when cookbook gem installation fails
-      def cookbook_gem_failed(exception)
-      end
+      def cookbook_gem_failed(exception); end
 
       ## TODO: add cookbook name to the API for file load callbacks
 
       ## TODO: add callbacks for overall cookbook eval start and complete.
 
       # Called immediately after creating the run_context and before any cookbook compilation happens
-      def cookbook_compilation_start(run_context)
-      end
+      def cookbook_compilation_start(run_context); end
 
       # Called when library file loading starts
-      def library_load_start(file_count)
-      end
+      def library_load_start(file_count); end
 
       # Called when library file has been loaded
-      def library_file_loaded(path)
-      end
+      def library_file_loaded(path); end
 
       # Called when a library file has an error on load.
-      def library_file_load_failed(path, exception)
-      end
+      def library_file_load_failed(path, exception); end
 
       # Called when library file loading has finished
-      def library_load_complete
-      end
+      def library_load_complete; end
 
       # Called when LWRP loading starts
-      def lwrp_load_start(lwrp_file_count)
-      end
+      def lwrp_load_start(lwrp_file_count); end
 
       # Called after a LWR or LWP has been loaded
-      def lwrp_file_loaded(path)
-      end
+      def lwrp_file_loaded(path); end
 
       # Called after a LWR or LWP file errors on load
-      def lwrp_file_load_failed(path, exception)
-      end
+      def lwrp_file_load_failed(path, exception); end
 
       # Called when LWRPs are finished loading
-      def lwrp_load_complete
-      end
+      def lwrp_load_complete; end
 
       # Called when an ohai plugin file loading starts
-      def ohai_plugin_load_start(file_count)
-      end
+      def ohai_plugin_load_start(file_count); end
 
       # Called when an ohai plugin file has been loaded
-      def ohai_plugin_file_loaded(path)
-      end
+      def ohai_plugin_file_loaded(path); end
 
       # Called when an ohai plugin file has an error on load.
-      def ohai_plugin_file_load_failed(path, exception)
-      end
+      def ohai_plugin_file_load_failed(path, exception); end
 
       # Called when an ohai plugin file loading has finished
-      def ohai_plugin_load_complete
-      end
+      def ohai_plugin_load_complete; end
 
       # Called before attribute files are loaded
-      def attribute_load_start(attribute_file_count)
-      end
+      def attribute_load_start(attribute_file_count); end
 
       # Called after the attribute file is loaded
-      def attribute_file_loaded(path)
-      end
+      def attribute_file_loaded(path); end
 
       # Called when an attribute file fails to load.
-      def attribute_file_load_failed(path, exception)
-      end
+      def attribute_file_load_failed(path, exception); end
 
       # Called when attribute file loading is finished
-      def attribute_load_complete
-      end
+      def attribute_load_complete; end
 
       # Called before resource definitions are loaded
-      def definition_load_start(definition_file_count)
-      end
+      def definition_load_start(definition_file_count); end
 
       # Called when a resource definition has been loaded
-      def definition_file_loaded(path)
-      end
+      def definition_file_loaded(path); end
 
       # Called when a resource definition file fails to load
-      def definition_file_load_failed(path, exception)
-      end
+      def definition_file_load_failed(path, exception); end
 
       # Called when resource definitions are done loading
-      def definition_load_complete
-      end
+      def definition_load_complete; end
 
       # Called before recipes are loaded
-      def recipe_load_start(recipe_count)
-      end
+      def recipe_load_start(recipe_count); end
 
       # Called after the recipe has been loaded
-      def recipe_file_loaded(path, recipe)
-      end
+      def recipe_file_loaded(path, recipe); end
 
       # Called after a recipe file fails to load
-      def recipe_file_load_failed(path, exception, recipe)
-      end
+      def recipe_file_load_failed(path, exception, recipe); end
 
       # Called when a recipe cannot be resolved
-      def recipe_not_found(exception)
-      end
+      def recipe_not_found(exception); end
 
       # Called when recipes have been loaded.
-      def recipe_load_complete
-      end
+      def recipe_load_complete; end
 
       # This is called after all cookbook compilation phases are completed.
-      def cookbook_compilation_complete(run_context)
-      end
+      def cookbook_compilation_complete(run_context); end
 
       # Called before convergence starts
-      def converge_start(run_context)
-      end
+      def converge_start(run_context); end
 
       # Callback hook for handlers to register their interest in the action_collection
-      def action_collection_registration(action_collection)
-      end
+      def action_collection_registration(action_collection); end
 
       # Called when the converge phase is finished.
-      def converge_complete
-      end
+      def converge_complete; end
 
       # Called if the converge phase fails
-      def converge_failed(exception)
-      end
+      def converge_failed(exception); end
 
       # TODO: need events for notification resolve?
       # def notifications_resolved
@@ -320,112 +258,88 @@ class Chef
       #
 
       # Called before action is executed on a resource.
-      def resource_action_start(resource, action, notification_type = nil, notifier = nil)
-      end
+      def resource_action_start(resource, action, notification_type = nil, notifier = nil); end
 
       # Called when a resource action has been skipped b/c of a conditional
-      def resource_skipped(resource, action, conditional)
-      end
+      def resource_skipped(resource, action, conditional); end
 
       # Called after #load_current_resource has run.
-      def resource_current_state_loaded(resource, action, current_resource)
-      end
+      def resource_current_state_loaded(resource, action, current_resource); end
 
       # Called when resource current state load is skipped due to the provider
       # not supporting whyrun mode.
-      def resource_current_state_load_bypassed(resource, action, current_resource)
-      end
+      def resource_current_state_load_bypassed(resource, action, current_resource); end
 
       # Called when evaluating a resource that does not support whyrun in whyrun mode
-      def resource_bypassed(resource, action, current_resource)
-      end
+      def resource_bypassed(resource, action, current_resource); end
 
       # Called when a change has been made to a resource. May be called multiple
       # times per resource, e.g., a file may have its content updated, and then
       # its permissions updated.
-      def resource_update_applied(resource, action, update)
-      end
+      def resource_update_applied(resource, action, update); end
 
       # Called when a progress notification should be sent to the user to
       # indicate the overall progress of a long running operation, such as
       # a large file download.
-      def resource_update_progress(resource, current, total, interval)
-      end
+      def resource_update_progress(resource, current, total, interval); end
 
       # Called when a resource fails, but will retry.
-      def resource_failed_retriable(resource, action, retry_count, exception)
-      end
+      def resource_failed_retriable(resource, action, retry_count, exception); end
 
       # Called when a resource fails and will not be retried.
-      def resource_failed(resource, action, exception)
-      end
+      def resource_failed(resource, action, exception); end
 
       # Called after a resource has been completely converged, but only if
       # modifications were made.
-      def resource_updated(resource, action)
-      end
+      def resource_updated(resource, action); end
 
       # Called when a resource has no converge actions, e.g., it was already correct.
-      def resource_up_to_date(resource, action)
-      end
+      def resource_up_to_date(resource, action); end
 
       # Called when a resource action has been completed
-      def resource_completed(resource)
-      end
+      def resource_completed(resource); end
 
       # A stream has opened.
-      def stream_opened(stream, options = {})
-      end
+      def stream_opened(stream, options = {}); end
 
       # A stream has closed.
-      def stream_closed(stream, options = {})
-      end
+      def stream_closed(stream, options = {}); end
 
       # A chunk of data from a stream.  The stream is managed by "stream," which
       # can be any tag whatsoever.  Data in different "streams" may not be placed
       # on the same line or even sent to the same console.
-      def stream_output(stream, output, options = {})
-      end
+      def stream_output(stream, output, options = {}); end
 
       # Called before handlers run
-      def handlers_start(handler_count)
-      end
+      def handlers_start(handler_count); end
 
       # Called after an individual handler has run
-      def handler_executed(handler)
-      end
+      def handler_executed(handler); end
 
       # Called after all handlers have executed
-      def handlers_completed
-      end
+      def handlers_completed; end
 
       # Called when an assertion declared by a provider fails
-      def provider_requirement_failed(action, resource, exception, message)
-      end
+      def provider_requirement_failed(action, resource, exception, message); end
 
       # Called when a provider makes an assumption after a failed assertion
       # in whyrun mode, in order to allow execution to continue
-      def whyrun_assumption(action, resource, message)
-      end
+      def whyrun_assumption(action, resource, message); end
 
       # Emit a message about something being deprecated.
-      def deprecation(message, location = caller(2..2)[0])
-      end
+      def deprecation(message, location = caller(2..2)[0]); end
 
-      def run_list_expanded(run_list_expansion)
-      end
+      def run_list_expanded(run_list_expansion); end
 
       # An uncategorized message. This supports the case that a user needs to
       # pass output that doesn't fit into one of the callbacks above. Note that
       # there's no semantic information about the content or importance of the
       # message. That means that if you're using this too often, you should add a
       # callback for it.
-      def msg(message)
-      end
+      def msg(message); end
 
       # Called when an attribute is changed by simple assignment
-      def attribute_changed(precedence, keys, value)
-      end
+      def attribute_changed(precedence, keys, value); end
     end
   end
 end