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

data/lib/chef/run_list/run_list_item.rb

@@ -18,10 +18,10 @@
 class Chef
   class RunList
     class RunListItem
-      QUALIFIED_RECIPE             = %r{^recipe\[([^\]@]+)(@([0-9]+(\.[0-9]+){1,2}))?\]$}.freeze
-      QUALIFIED_ROLE               = %r{^role\[([^\]]+)\]$}.freeze
-      VERSIONED_UNQUALIFIED_RECIPE = %r{^([^@]+)(@([0-9]+(\.[0-9]+){1,2}))$}.freeze
-      FALSE_FRIEND                 = %r{[\[\]]}.freeze
+      QUALIFIED_RECIPE             = /^recipe\[([^\]@]+)(@([0-9]+(\.[0-9]+){1,2}))?\]$/.freeze
+      QUALIFIED_ROLE               = /^role\[([^\]]+)\]$/.freeze
+      VERSIONED_UNQUALIFIED_RECIPE = /^([^@]+)(@([0-9]+(\.[0-9]+){1,2}))$/.freeze
+      FALSE_FRIEND                 = /[\[\]]/.freeze
 
       attr_reader :name, :type, :version
 
@@ -80,7 +80,7 @@ class Chef
       end
 
       def ==(other)
-        if other.kind_of?(String)
+        if other.is_a?(String)
           to_s == other.to_s
         else
           other.respond_to?(:type) && other.respond_to?(:name) && other.respond_to?(:version) && other.type == @type && other.name == @name && other.version == @version

data/lib/chef/run_list/versioned_recipe_list.rb

@@ -26,7 +26,7 @@ class Chef
 
       def initialize
         super
-        @versions = Hash.new
+        @versions = {}
       end
 
       def add_recipe(name, version = nil)

data/lib/chef/run_status.rb

@@ -75,7 +75,7 @@ class Chef::RunStatus
   # The list of all resources in the current run context's +resource_collection+
   # that are marked as updated
   def updated_resources
-    @run_context && @run_context.resource_collection.select { |r| r.updated }
+    @run_context && @run_context.resource_collection.select(&:updated)
   end
 
   # The backtrace from +exception+, if any

data/lib/chef/runner.rb

@@ -89,9 +89,7 @@ class Chef
     # +run_action+ for each resource in turn.
     def converge
       # Resolve all lazy/forward references in notifications
-      run_context.resource_collection.each do |resource|
-        resource.resolve_notification_references
-      end
+      run_context.resource_collection.each(&:resolve_notification_references)
 
       # Execute each resource.
       run_context.resource_collection.execute_each_resource do |resource|
@@ -118,7 +116,7 @@ class Chef
       collected_failures.client_run_failure(error) unless error.nil?
       delayed_actions.each do |notification|
         result = run_delayed_notification(notification)
-        if result.kind_of?(Exception)
+        if result.is_a?(Exception)
           collected_failures.notification_failure(result)
         end
       end

data/lib/chef/search/query.rb

@@ -113,7 +113,7 @@ class Chef
       end
 
       def validate_type(t)
-        unless t.kind_of?(String) || t.kind_of?(Symbol)
+        unless t.is_a?(String) || t.is_a?(Symbol)
           msg = "Invalid search object type #{t.inspect} (#{t.class}), must be a String or Symbol." +
             "Usage: search(:node, QUERY[, OPTIONAL_ARGS])" +
             "        `knife search environment QUERY (options)`"
@@ -122,10 +122,10 @@ class Chef
       end
 
       def hashify_args(*args)
-        return Hash.new if args.empty?
+        return {} if args.empty?
         return args.first if args.first.is_a?(Hash)
 
-        args_h = Hash.new
+        args_h = {}
         # If we have 4 arguments, the first is the now-removed sort option, so
         # just ignore it.
         args.pop(0) if args.length == 4

data/lib/chef/shell/ext.rb

@@ -47,8 +47,8 @@ module Shell
 
         unless jobs.respond_to?(:session_select)
           def jobs.select_shell_session(target_context) # rubocop:disable Lint/NestedMethodDefinition
-            session = if target_context.kind_of?(Class)
-                        select_session_by_context { |main| main.kind_of?(target_context) }
+            session = if target_context.is_a?(Class)
+                        select_session_by_context { |main| main.is_a?(target_context) }
                       else
                         select_session_by_context { |main| main.equal?(target_context) }
                       end

data/lib/chef/shell/model_wrapper.rb

@@ -33,6 +33,7 @@ module Shell
 
     def search(query)
       return all if query.to_s == "all"
+
       results = []
       Chef::Search::Query.new.search(@model_symbol, format_query(query)) do |obj|
         if block_given?
@@ -81,7 +82,7 @@ module Shell
     # the user wanted instead of the URI=>object stuff
     def list_objects
       objects = @model_class.method(:list).arity == 0 ? @model_class.list : @model_class.list(true)
-      objects.map { |obj| Array(obj).find { |o| o.kind_of?(@model_class) } }
+      objects.map { |obj| Array(obj).find { |o| o.is_a?(@model_class) } }
     end
 
     def format_query(query)

data/lib/chef/shell/shell_session.rb

@@ -260,7 +260,7 @@ module Shell
       @run_list_expansion = @node.expand!("server")
       @expanded_run_list_with_versions = @run_list_expansion.recipes.with_version_constraints_strings
       Chef::Log.info("Run List is [#{@node.run_list}]")
-      Chef::Log.info("Run List expands to [#{@expanded_run_list_with_versions.join(', ')}]")
+      Chef::Log.info("Run List expands to [#{@expanded_run_list_with_versions.join(", ")}]")
       @node
     end
 

data/lib/chef/train_transport.rb

@@ -94,13 +94,13 @@ class Chef
     def self.build_transport(logger = Chef::Log.with_child(subsystem: "transport"))
       # TODO: Consider supporting parsing the protocol from a URI passed to `--target`
       #
-      train_config = Hash.new
+      train_config = {}
 
       # Load the target_mode config context from Chef::Config, and place any valid settings into the train configuration
       tm_config = Chef::Config.target_mode
       protocol = tm_config.protocol
       train_config = tm_config.to_hash.select { |k| Train.options(protocol).key?(k) }
-      Chef::Log.trace("Using target mode options from Chef config file: #{train_config.keys.join(', ')}") if train_config
+      Chef::Log.trace("Using target mode options from Chef config file: #{train_config.keys.join(", ")}") if train_config
 
       # Load the credentials file, and place any valid settings into the train configuration
       credentials = load_credentials(tm_config.host)
@@ -108,7 +108,7 @@ class Chef
         valid_settings = credentials.select { |k| Train.options(protocol).key?(k) }
         valid_settings[:enable_password] = credentials[:enable_password] if credentials.key?(:enable_password)
         train_config.merge!(valid_settings)
-        Chef::Log.trace("Using target mode options from credentials file: #{valid_settings.keys.join(', ')}") if valid_settings
+        Chef::Log.trace("Using target mode options from credentials file: #{valid_settings.keys.join(", ")}") if valid_settings
       end
 
       train_config[:logger] = logger

data/lib/chef/user.rb

@@ -54,27 +54,27 @@ class Chef
 
     def name(arg = nil)
       set_or_return(:name, arg,
-                    regex: /^[a-z0-9\-_]+$/)
+        regex: /^[a-z0-9\-_]+$/)
     end
 
     def admin(arg = nil)
       set_or_return(:admin,
-                    arg, kind_of: [TrueClass, FalseClass])
+        arg, kind_of: [TrueClass, FalseClass])
     end
 
     def public_key(arg = nil)
       set_or_return(:public_key,
-                    arg, kind_of: String)
+        arg, kind_of: String)
     end
 
     def private_key(arg = nil)
       set_or_return(:private_key,
-                    arg, kind_of: String)
+        arg, kind_of: String)
     end
 
     def password(arg = nil)
       set_or_return(:password,
-                    arg, kind_of: String)
+        arg, kind_of: String)
     end
 
     def to_h
@@ -181,7 +181,7 @@ class Chef
     # into the form
     # { "USERNAME" => "URI" }
     def self.transform_ohc_list_response(response)
-      new_response = Hash.new
+      new_response = {}
       response.each do |u|
         name = u["user"]["username"]
         new_response[name] = Chef::Config[:chef_server_url] + "/users/#{name}"

data/lib/chef/user_v1.rb

@@ -64,52 +64,52 @@ class Chef
 
     def username(arg = nil)
       set_or_return(:username, arg,
-                    regex: /^[a-z0-9\-_]+$/)
+        regex: /^[a-z0-9\-_]+$/)
     end
 
     def display_name(arg = nil)
       set_or_return(:display_name,
-                    arg, kind_of: String)
+        arg, kind_of: String)
     end
 
     def first_name(arg = nil)
       set_or_return(:first_name,
-                    arg, kind_of: String)
+        arg, kind_of: String)
     end
 
     def middle_name(arg = nil)
       set_or_return(:middle_name,
-                    arg, kind_of: String)
+        arg, kind_of: String)
     end
 
     def last_name(arg = nil)
       set_or_return(:last_name,
-                    arg, kind_of: String)
+        arg, kind_of: String)
     end
 
     def email(arg = nil)
       set_or_return(:email,
-                    arg, kind_of: String)
+        arg, kind_of: String)
     end
 
     def create_key(arg = nil)
       set_or_return(:create_key, arg,
-                    kind_of: [TrueClass, FalseClass])
+        kind_of: [TrueClass, FalseClass])
     end
 
     def public_key(arg = nil)
       set_or_return(:public_key,
-                    arg, kind_of: String)
+        arg, kind_of: String)
     end
 
     def private_key(arg = nil)
       set_or_return(:private_key,
-                    arg, kind_of: String)
+        arg, kind_of: String)
     end
 
     def password(arg = nil)
       set_or_return(:password,
-                    arg, kind_of: String)
+        arg, kind_of: String)
     end
 
     def to_h
@@ -154,6 +154,7 @@ class Chef
         payload[:create_key] = @create_key unless @create_key.nil?
         payload[:middle_name] = @middle_name unless @middle_name.nil?
         raise Chef::Exceptions::InvalidUserAttribute, "You cannot set both public_key and create_key for create." if !@create_key.nil? && !@public_key.nil?
+
         new_user = chef_root_rest_v1.post("users", payload)
 
         # get the private_key out of the chef_key hash if it exists
@@ -168,6 +169,7 @@ class Chef
         # rescue API V0 if 406 and the server supports V0
         supported_versions = server_client_api_version_intersection(e, SUPPORTED_API_VERSIONS)
         raise e unless supported_versions && supported_versions.include?(0)
+
         payload = {
           username: @username,
           display_name: @display_name,
@@ -311,7 +313,7 @@ class Chef
     # into the form
     # { "USERNAME" => "URI" }
     def self.transform_list_response(response)
-      new_response = Hash.new
+      new_response = {}
       response.each do |u|
         name = u["user"]["username"]
         new_response[name] = Chef::Config[:chef_server_url] + "/users/#{name}"

data/lib/chef/util/diff.rb

@@ -58,6 +58,7 @@ class Chef
       def for_reporting
         # caller needs to ensure that new files aren't posted to resource reporting
         return nil if @diff.nil?
+
         @diff.join("\\n")
       end
 
@@ -89,8 +90,8 @@ class Chef
         diff_str = ""
         file_length_difference = 0
 
-        old_data = IO.readlines(old_file).map { |e| e.chomp }
-        new_data = IO.readlines(new_file).map { |e| e.chomp }
+        old_data = IO.readlines(old_file).map(&:chomp)
+        new_data = IO.readlines(new_file).map(&:chomp)
         diff_data = ::Diff::LCS.diff(old_data, new_data)
 
         return diff_str if old_data.empty? && new_data.empty?
@@ -111,6 +112,7 @@ class Chef
             file_length_difference = hunk.file_length_difference
             next unless old_hunk
             next if hunk.merge(old_hunk)
+
             diff_str << old_hunk.diff(:unified) << "\n"
           ensure
             old_hunk = hunk
@@ -170,6 +172,7 @@ class Chef
             return buff !~ /\A[\s[:print:]]*\z/m
           rescue ArgumentError => e
             return true if e.message =~ /invalid byte sequence/
+
             raise
           end
         end

data/lib/chef/util/dsc/configuration_generator.rb

@@ -40,14 +40,15 @@ class Chef::Util::DSC
 
       document_generation_cmdlet = Chef::Util::Powershell::Cmdlet.new(
         @node,
-        configuration_document_generation_code(script_path, configuration_name))
+        configuration_document_generation_code(script_path, configuration_name)
+      )
 
       merged_configuration_flags = get_merged_configuration_flags!(configuration_flags, configuration_name)
 
       document_generation_cmdlet.run!(merged_configuration_flags, shellout_flags)
       configuration_document_location = find_configuration_document(configuration_name)
 
-      if ! configuration_document_location
+      unless configuration_document_location
         raise "No DSC configuration for '#{configuration_name}' was generated from supplied DSC script"
       end
 
@@ -74,6 +75,7 @@ class Chef::Util::DSC
           if merged_configuration_flags.key?(switch.to_s.downcase.to_sym)
             raise ArgumentError, "The `flags` attribute for the dsc_script resource contained a command line switch :#{switch} that is disallowed."
           end
+
           merged_configuration_flags[switch.to_s.downcase.to_sym] = value
         end
       end
@@ -100,7 +102,7 @@ class Chef::Util::DSC
           if resources.length == 0 || resources.include?("*")
             "Import-DscResource -ModuleName #{resource_module}"
           else
-            "Import-DscResource -ModuleName #{resource_module} -Name #{resources.join(',')}"
+            "Import-DscResource -ModuleName #{resource_module} -Name #{resources.join(",")}"
           end
         end
       else
@@ -131,9 +133,7 @@ class Chef::Util::DSC
     end
 
     def get_configuration_document(document_path)
-      ::File.open(document_path, "rb") do |file|
-        file.read
-      end
+      ::File.open(document_path, "rb", &:read)
     end
   end
 end

data/lib/chef/util/dsc/lcm_output_parser.rb

@@ -80,7 +80,7 @@ class Chef
 
           def self.test_dsc_parser(lcm_output)
             lcm_output ||= ""
-            current_resource = Hash.new
+            current_resource = {}
 
             resources = []
             lcm_output.lines.each do |line|
@@ -110,7 +110,7 @@ class Chef
 
           def self.what_if_parser(lcm_output)
             lcm_output ||= ""
-            current_resource = Hash.new
+            current_resource = {}
 
             resources = []
             lcm_output.lines.each do |line|

data/lib/chef/util/dsc/local_configuration_manager.rb

@@ -93,9 +93,9 @@ class Chef::Util::DSC
         # LCM returns an error if any of the resources do not support the opptional What-If
         Chef::Log.warn("Received error while testing configuration due to resource not supporting 'WhatIf'")
       elsif dsc_module_import_failure?(dsc_exception_output)
-        Chef::Log.warn("Received error while testing configuration due to a module for an imported resource possibly not being fully installed:\n#{dsc_exception_output.gsub(/\s+/, ' ')}")
+        Chef::Log.warn("Received error while testing configuration due to a module for an imported resource possibly not being fully installed:\n#{dsc_exception_output.gsub(/\s+/, " ")}")
       else
-        Chef::Log.warn("Received error while testing configuration:\n#{dsc_exception_output.gsub(/\s+/, ' ')}")
+        Chef::Log.warn("Received error while testing configuration:\n#{dsc_exception_output.gsub(/\s+/, " ")}")
       end
     end
 

data/lib/chef/util/dsc/resource_store.rb

@@ -84,7 +84,7 @@ class Chef
         # Returns a list of dsc resources
         def query_resources
           cmdlet = Chef::Util::Powershell::Cmdlet.new(nil, "get-dscresource",
-              :object)
+            :object)
           result = cmdlet.run
           result.return_value
         end
@@ -92,7 +92,7 @@ class Chef
         # Returns a list of dsc resources matching the provided name
         def query_resource(resource_name)
           cmdlet = Chef::Util::Powershell::Cmdlet.new(nil, "get-dscresource #{resource_name}",
-              :object)
+            :object)
           result = cmdlet.run
           ret_val = result.return_value
           if ret_val.nil?

data/lib/chef/util/file_edit.rb

@@ -30,6 +30,7 @@ class Chef
 
       def initialize(filepath)
         raise ArgumentError, "File '#{filepath}' does not exist" unless File.exist?(filepath)
+
         @editor = Editor.new(File.open(filepath, &:readlines))
         @original_pathname = filepath
         @file_edited = false

data/lib/chef/util/powershell/cmdlet.rb

@@ -89,7 +89,7 @@ class Chef
         def run!(switches = {}, execution_options = {}, *arguments)
           result = run(switches, execution_options, arguments)
 
-          if ! result.succeeded?
+          unless result.succeeded?
             raise Chef::Exceptions::PowershellCmdletException, "PowerShell Cmdlet failed: #{result.stderr}"
           end
 

data/lib/chef/util/threaded_job_queue.rb

@@ -54,7 +54,7 @@ class Chef
           end
         end
         workers.each { |worker| self << Thread.method(:exit) }
-        workers.each { |worker| worker.join }
+        workers.each(&:join)
       end
     end
   end

data/lib/chef/util/windows/logon_session.rb

@@ -51,7 +51,7 @@ class Chef
           logon_type = (authentication == :local) ? (Chef::ReservedNames::Win32::API::Security::LOGON32_LOGON_NETWORK) : (Chef::ReservedNames::Win32::API::Security::LOGON32_LOGON_NEW_CREDENTIALS)
           status = Chef::ReservedNames::Win32::API::Security.LogonUserW(username, domain, password, logon_type, Chef::ReservedNames::Win32::API::Security::LOGON32_PROVIDER_DEFAULT, token)
 
-          if !status
+          unless status
             last_error = FFI::LastError.error
             raise Chef::Exceptions::Win32APIError, "Logon for user `#{original_username}` failed with Win32 status #{last_error}."
           end
@@ -74,7 +74,7 @@ class Chef
         def set_user_context
           validate_session_open!
 
-          if ! session_opened
+          unless session_opened
             raise "Attempted to set the user context before opening a session."
           end
 
@@ -84,7 +84,7 @@ class Chef
 
           status = Chef::ReservedNames::Win32::API::Security.ImpersonateLoggedOnUser(token.read_ulong)
 
-          if !status
+          unless status
             last_error = FFI::LastError.error
             raise Chef::Exceptions::Win32APIError, "Attempt to impersonate user `#{original_username}` failed with Win32 status #{last_error}."
           end
@@ -98,7 +98,7 @@ class Chef
           if impersonating
             status = Chef::ReservedNames::Win32::API::Security.RevertToSelf
 
-            if !status
+            unless status
               last_error = FFI::LastError.error
               raise Chef::Exceptions::Win32APIError, "Unable to restore user context with Win32 status #{last_error}."
             end
@@ -119,7 +119,7 @@ class Chef
         attr_reader :impersonating
 
         def validate_session_open!
-          if ! session_opened
+          unless session_opened
             raise "Attempted to set the user context before opening a session."
           end
         end