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

data/lib/chef/formatters/indentable_output_stream.rb

@@ -112,7 +112,7 @@ class Chef
       end
 
       def from_args(colors, merge_options = {})
-        if colors.size == 1 && colors[0].kind_of?(Hash)
+        if colors.size == 1 && colors[0].is_a?(Hash)
           merge_options.merge(colors[0])
         else
           merge_options.merge({ colors: colors })
@@ -154,14 +154,14 @@ class Chef
       end
 
       def indent_line(options)
-        if !@line_started
+        unless @line_started
 
           # Print indents.  If there is a stream name, either print it (if we're
           # switching streams) or print enough blanks to match
           # the indents.
           if options[:name]
             if @current_stream != options[:stream]
-              @out.print "#{(' ' * indent)}[#{options[:name]}] "
+              @out.print "#{(" " * indent)}[#{options[:name]}] "
             else
               @out.print " " * (indent + 3 + options[:name].size)
             end

data/lib/chef/formatters/minimal.rb

@@ -44,36 +44,29 @@ class Chef
       end
 
       # Called right after ohai runs.
-      def ohai_completed(node)
-      end
+      def ohai_completed(node); end
 
       # Already have a client key, assuming this node has registered.
-      def skipping_registration(node_name, config)
-      end
+      def skipping_registration(node_name, config); end
 
       # About to attempt to register as +node_name+
-      def registration_start(node_name, config)
-      end
+      def registration_start(node_name, config); end
 
-      def registration_completed
-      end
+      def registration_completed; end
 
       # Failed to register this client with the server.
       def registration_failed(node_name, exception, config)
         super
       end
 
-      def node_load_start(node_name, config)
-      end
+      def node_load_start(node_name, config); 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
 
       # 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 before the cookbook collection is fetched from the server.
       def cookbook_resolution_start(expanded_run_list)
@@ -82,28 +75,23 @@ class Chef
 
       # 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
       #--
       # TODO: Should be called in CookbookVersion.sync_cookbooks
-      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)
@@ -116,8 +104,7 @@ class Chef
       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 after all cookbooks have been sync'd.
       def cookbook_sync_complete
@@ -168,16 +155,13 @@ class Chef
       end
 
       # 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 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 when a resource action has been skipped b/c of a conditional
       def resource_skipped(resource, action, conditional)
@@ -185,8 +169,7 @@ class Chef
       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 a resource has no converge actions, e.g., it was already correct.
       def resource_up_to_date(resource, action)
@@ -211,24 +194,20 @@ class Chef
       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
 
       # 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
 
     end
   end

data/lib/chef/guard_interpreter/resource_guard_interpreter.rb

@@ -91,7 +91,7 @@ class Chef
           raise ArgumentError, "Specified guard_interpreter resource #{parent_resource.guard_interpreter} unknown for this platform"
         end
 
-        if ! resource_class.ancestors.include?(Chef::Resource::Execute)
+        unless resource_class.ancestors.include?(Chef::Resource::Execute)
           raise ArgumentError, "Specified guard interpreter class #{resource_class} must be a kind of Chef::Resource::Execute resource"
         end
 

data/lib/chef/handler.rb

@@ -234,8 +234,7 @@ class Chef
 
     # The main entry point for report handling. Subclasses should override this
     # method with their own report handling logic.
-    def report
-    end
+    def report; end
 
     # Runs the report handler, rescuing and logging any errors it may cause.
     # This ensures that all handlers get a chance to run even if one fails.

data/lib/chef/http.rb

@@ -155,7 +155,7 @@ class Chef
     rescue Net::HTTPClientException => e
       http_attempts += 1
       response = e.response
-      if response.kind_of?(Net::HTTPNotAcceptable) && version_retries - http_attempts > 0
+      if response.is_a?(Net::HTTPNotAcceptable) && version_retries - http_attempts > 0
         Chef::Log.trace("Negotiating protocol version with #{url}, retry #{http_attempts}/#{version_retries}")
         retry
       else
@@ -180,20 +180,21 @@ class Chef
       method, url, processed_headers, data = apply_request_middleware(method, url, headers, data)
 
       response, rest_request, return_value = send_http_request(method, url, processed_headers, data) do |http_response|
-        if http_response.kind_of?(Net::HTTPSuccess)
+        if http_response.is_a?(Net::HTTPSuccess)
           tempfile = stream_to_tempfile(url, http_response, tempfile, &progress_block)
         end
         apply_stream_complete_middleware(http_response, rest_request, return_value)
       end
-      return nil if response.kind_of?(Net::HTTPRedirection)
-      unless response.kind_of?(Net::HTTPSuccess)
+      return nil if response.is_a?(Net::HTTPRedirection)
+
+      unless response.is_a?(Net::HTTPSuccess)
         response.error!
       end
       tempfile
     rescue Net::HTTPClientException => e
       http_attempts += 1
       response = e.response
-      if response.kind_of?(Net::HTTPNotAcceptable) && version_retries - http_attempts > 0
+      if response.is_a?(Net::HTTPNotAcceptable) && version_retries - http_attempts > 0
         Chef::Log.trace("Negotiating protocol version with #{url}, retry #{http_attempts}/#{version_retries}")
         retry
       else
@@ -226,14 +227,15 @@ class Chef
       method, url, processed_headers, data = apply_request_middleware(method, url, headers, data)
 
       response, rest_request, return_value = send_http_request(method, url, processed_headers, data) do |http_response|
-        if http_response.kind_of?(Net::HTTPSuccess)
+        if http_response.is_a?(Net::HTTPSuccess)
           tempfile = stream_to_tempfile(url, http_response, tempfile)
         end
         apply_stream_complete_middleware(http_response, rest_request, return_value)
       end
 
-      return nil if response.kind_of?(Net::HTTPRedirection)
-      unless response.kind_of?(Net::HTTPSuccess)
+      return nil if response.is_a?(Net::HTTPRedirection)
+
+      unless response.is_a?(Net::HTTPSuccess)
         response.error!
       end
 
@@ -248,7 +250,7 @@ class Chef
     rescue Net::HTTPClientException => e
       http_attempts += 1
       response = e.response
-      if response.kind_of?(Net::HTTPNotAcceptable) && version_retries - http_attempts > 0
+      if response.is_a?(Net::HTTPNotAcceptable) && version_retries - http_attempts > 0
         Chef::Log.trace("Negotiating protocol version with #{url}, retry #{http_attempts}/#{version_retries}")
         retry
       else
@@ -309,7 +311,8 @@ class Chef
     # @api private
     def create_url(path)
       return path if path.is_a?(URI)
-      if path =~ /^(http|https|chefzero):\/\//i
+
+      if path =~ %r{^(http|https|chefzero)://}i
         URI.parse(path)
       elsif path.nil? || path.empty?
         URI.parse(@url)
@@ -355,7 +358,7 @@ class Chef
 
     # @api private
     def success_response?(response)
-      response.kind_of?(Net::HTTPSuccess) || response.kind_of?(Net::HTTPRedirection)
+      response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
     end
 
     # Runs a synchronous HTTP request, with no middleware applied (use #request
@@ -369,17 +372,17 @@ class Chef
         if block_given?
           request, response = client.request(method, url, body, headers, &response_handler)
         else
-          request, response = client.request(method, url, body, headers) { |r| r.read_body }
+          request, response = client.request(method, url, body, headers, &:read_body)
           return_value = response.read_body
         end
         @last_response = response
 
-        if response.kind_of?(Net::HTTPSuccess)
+        if response.is_a?(Net::HTTPSuccess)
           [response, request, return_value]
-        elsif response.kind_of?(Net::HTTPNotModified) # Must be tested before Net::HTTPRedirection because it's subclass.
+        elsif response.is_a?(Net::HTTPNotModified) # Must be tested before Net::HTTPRedirection because it's subclass.
           [response, request, false]
         elsif redirect_location = redirected_to(response)
-          if [:GET, :HEAD].include?(method)
+          if %i{GET HEAD}.include?(method)
             follow_redirect do
               redirected_url = url + redirect_location
               if http_disable_auth_on_redirect
@@ -410,7 +413,7 @@ class Chef
           http_attempts += 1
           response, request, return_value = yield
           # handle HTTP 50X Error
-          if response.kind_of?(Net::HTTPServerError) && !Chef::Config.local_mode
+          if response.is_a?(Net::HTTPServerError) && !Chef::Config.local_mode
             if http_retry_count - http_attempts + 1 > 0
               sleep_time = 1 + (2**http_attempts) + rand(2**http_attempts)
               Chef::Log.error("Server returned error #{response.code} for #{url}, retrying #{http_attempts}/#{http_retry_count} in #{sleep_time}s")
@@ -479,6 +482,7 @@ class Chef
     # @api private
     def follow_redirect
       raise Chef::Exceptions::RedirectLimitExceeded if @redirects_followed >= redirect_limit
+
       @redirects_followed += 1
       Chef::Log.trace("Following redirect #{@redirects_followed}/#{redirect_limit}")
 
@@ -495,9 +499,10 @@ class Chef
 
     # @api private
     def redirected_to(response)
-      return nil  unless response.kind_of?(Net::HTTPRedirection)
+      return nil  unless response.is_a?(Net::HTTPRedirection)
       # Net::HTTPNotModified is undesired subclass of Net::HTTPRedirection so test for this
-      return nil  if response.kind_of?(Net::HTTPNotModified)
+      return nil  if response.is_a?(Net::HTTPNotModified)
+
       response["location"]
     end
 

data/lib/chef/http/api_versions.rb

@@ -24,8 +24,7 @@ class Chef
     # and maximum supported API versions.
     class APIVersions
 
-      def initialize(options = {})
-      end
+      def initialize(options = {}); end
 
       def handle_request(method, url, headers = {}, data = false)
         [method, url, headers, data]

data/lib/chef/http/auth_credentials.rb

@@ -40,6 +40,7 @@ class Chef
 
       def signature_headers(request_params = {})
         raise ArgumentError, "Cannot sign the request without a client name, check that :node_name is assigned" if client_name.nil?
+
         Chef::Log.trace("Signing the request as #{client_name}")
 
         # params_in = {:http_method => :GET, :path => "/clients", :body => "", :host => "localhost"}

data/lib/chef/http/basic_client.rb

@@ -135,7 +135,7 @@ class Chef
         else
           Chef::Log.trace("Using #{proxy_uri.host}:#{proxy_uri.port} for proxy")
           Net::HTTP.Proxy(proxy_uri.host, proxy_uri.port, http_proxy_user(proxy_uri),
-                          http_proxy_pass(proxy_uri))
+            http_proxy_pass(proxy_uri))
         end
       end
 

data/lib/chef/http/decompressor.rb

@@ -64,6 +64,7 @@ class Chef
         # temporary hack, skip processing if return_value is false
         # needed to keep conditional get stuff working correctly.
         return [http_response, rest_request, return_value] if return_value == false
+
         response_body = decompress_body(http_response)
         http_response.body.replace(response_body) if http_response.body.respond_to?(:replace)
         [http_response, rest_request, return_value]

data/lib/chef/http/json_output.rb

@@ -46,6 +46,7 @@ class Chef
         # temporary hack, skip processing if return_value is false
         # needed to keep conditional get stuff working correctly.
         return [http_response, rest_request, return_value] if return_value == false
+
         if http_response["content-type"] =~ /json/
           if http_response.body.nil?
             return_value = nil
@@ -60,7 +61,7 @@ class Chef
           end
           [http_response, rest_request, return_value]
         else
-          Chef::Log.trace("Expected JSON response, but got content-type '#{http_response['content-type']}'")
+          Chef::Log.trace("Expected JSON response, but got content-type '#{http_response["content-type"]}'")
           if http_response.body
             Chef::Log.trace("Response body contains:\n#{http_response.body.length < 256 ? http_response.body : http_response.body[0..256] + " [...truncated...]"}")
           end

data/lib/chef/http/json_to_model_output.rb

@@ -26,7 +26,7 @@ class Chef
     # a `json_class` key.
     class JSONToModelOutput < JSONOutput
       def initialize(opts = {})
-        opts[:inflate_json_class] = true if !opts.key?(:inflate_json_class)
+        opts[:inflate_json_class] = true unless opts.key?(:inflate_json_class)
         super
       end
     end

data/lib/chef/http/remote_request_id.rb

@@ -21,8 +21,7 @@ class Chef
   class HTTP
     class RemoteRequestID
 
-      def initialize(opts = {})
-      end
+      def initialize(opts = {}); end
 
       def handle_request(method, url, headers = {}, data = false)
         headers["X-REMOTE-REQUEST-ID"] = Chef::RequestID.instance.request_id

data/lib/chef/http/socketless_chef_zero_client.rb

@@ -134,7 +134,7 @@ class Chef
         511 => "Network Authentication Required",
       }.freeze
 
-      STATUS_MESSAGE.each_value { |v| v.freeze }
+      STATUS_MESSAGE.each_value(&:freeze)
       STATUS_MESSAGE.freeze
 
       def initialize(base_url)
@@ -181,6 +181,7 @@ class Chef
         body = chunked_body.join("")
         msg = STATUS_MESSAGE[code]
         raise "Cannot determine HTTP status message for code #{code}" unless msg
+
         response = Net::HTTPResponse.send(:response_class, code.to_s).new("1.0", code.to_s, msg)
         response.instance_variable_set(:@body, body)
         headers.each do |name, value|
@@ -200,7 +201,7 @@ class Chef
 
       def headers_extracted_from_options
         options.reject { |name, _| KNOWN_OPTIONS.include?(name) }.map do |name, value|
-          [name.to_s.split("_").map { |segment| segment.capitalize }.join("-"), value]
+          [name.to_s.split("_").map(&:capitalize).join("-"), value]
         end
       end
 

data/lib/chef/http/ssl_policies.rb

@@ -62,11 +62,13 @@ class Chef
           unless ::File.exist?(config[:ssl_ca_path])
             raise Chef::Exceptions::ConfigurationError, "The configured ssl_ca_path #{config[:ssl_ca_path]} does not exist"
           end
+
           http_client.ca_path = config[:ssl_ca_path]
         elsif config[:ssl_ca_file]
           unless ::File.exist?(config[:ssl_ca_file])
             raise Chef::Exceptions::ConfigurationError, "The configured ssl_ca_file #{config[:ssl_ca_file]} does not exist"
           end
+
           http_client.ca_file = config[:ssl_ca_file]
         end
       end
@@ -96,6 +98,7 @@ class Chef
           unless ::File.exists?(config[:ssl_client_key])
             raise Chef::Exceptions::ConfigurationError, "The configured ssl_client_key #{config[:ssl_client_key]} does not exist"
           end
+
           http_client.cert = OpenSSL::X509::Certificate.new(::File.read(config[:ssl_client_cert]))
           http_client.key = OpenSSL::PKey::RSA.new(::File.read(config[:ssl_client_key]))
         end

data/lib/chef/http/validate_content_length.rb

@@ -41,8 +41,7 @@ class Chef
         end
       end
 
-      def initialize(opts = {})
-      end
+      def initialize(opts = {}); end
 
       def handle_request(method, url, headers = {}, data = false)
         [method, url, headers, data]
@@ -74,6 +73,7 @@ class Chef
 
       def response_content_length(response)
         return nil if response["content-length"].nil?
+
         if response["content-length"].is_a?(Array)
           response["content-length"].first.to_i
         else