chef 14.2.0-universal-mingw32 → 14.3.37-universal-mingw32

data/ext/win32-eventlog/Rakefile

@@ -12,18 +12,18 @@ def ensure_present(commands)
   end
 end
 
-EVT_MC_FILE = "chef-log.man"
-EVT_RC_FILE = "chef-log.rc"
-EVT_RESOURCE_OBJECT = "resource.o"
-EVT_SHARED_OBJECT = "chef-log.dll"
-MC = "windmc"
-RC = "windres"
-CC = "gcc"
+EVT_MC_FILE = "chef-log.man".freeze
+EVT_RC_FILE = "chef-log.rc".freeze
+EVT_RESOURCE_OBJECT = "resource.o".freeze
+EVT_SHARED_OBJECT = "chef-log.dll".freeze
+MC = "windmc".freeze
+RC = "windres".freeze
+CC = "gcc".freeze
 
 ensure_present [MC, RC, CC]
 
-task :build => [EVT_RESOURCE_OBJECT, EVT_SHARED_OBJECT]
-task :default => [:build, :register]
+task build: [EVT_RESOURCE_OBJECT, EVT_SHARED_OBJECT]
+task default: [:build, :register]
 
 file EVT_RC_FILE => EVT_MC_FILE do
   sh "#{MC} #{EVT_MC_FILE}"
@@ -37,15 +37,15 @@ file EVT_SHARED_OBJECT => EVT_RESOURCE_OBJECT do
   sh "#{CC} -o #{EVT_SHARED_OBJECT} -shared #{EVT_RESOURCE_OBJECT}"
 end
 
-task :register => EVT_SHARED_OBJECT do
+task register: EVT_SHARED_OBJECT do
   require "win32/eventlog"
   dll_file = File.expand_path(EVT_SHARED_OBJECT)
   begin
     Win32::EventLog.add_event_source(
-      :source => "Application",
-      :key_name => "Chef",
-      :event_message_file => dll_file,
-      :category_message_file => dll_file
+      source: "Application",
+      key_name: "Chef",
+      event_message_file: dll_file,
+      category_message_file: dll_file
     )
   rescue Errno::EIO => e
     puts "Skipping event log registration due to missing privileges: #{e}"

data/lib/chef/api_client.rb

@@ -53,7 +53,7 @@ class Chef
       set_or_return(
         :name,
         arg,
-        :regex => /^[\-[:alnum:]_\.]+$/
+        regex: /^[\-[:alnum:]_\.]+$/
       )
     end
 
@@ -65,7 +65,7 @@ class Chef
       set_or_return(
         :admin,
         arg,
-        :kind_of => [ TrueClass, FalseClass ]
+        kind_of: [ TrueClass, FalseClass ]
       )
     end
 
@@ -77,7 +77,7 @@ class Chef
       set_or_return(
         :public_key,
         arg,
-        :kind_of => String
+        kind_of: String
       )
     end
 
@@ -90,7 +90,7 @@ class Chef
       set_or_return(
         :validator,
         arg,
-        :kind_of => [TrueClass, FalseClass]
+        kind_of: [TrueClass, FalseClass]
       )
     end
 
@@ -102,7 +102,7 @@ class Chef
       set_or_return(
         :private_key,
         arg,
-        :kind_of => [String, FalseClass]
+        kind_of: [String, FalseClass]
       )
     end
 
@@ -145,7 +145,7 @@ class Chef
     end
 
     def self.http_api
-      Chef::ServerAPI.new(Chef::Config[:chef_server_url], { :api_version => "0" })
+      Chef::ServerAPI.new(Chef::Config[:chef_server_url], { api_version: "0" })
     end
 
     def self.reregister(name)
@@ -183,18 +183,18 @@ class Chef
 
     # Save this client via the REST API, returns a hash including the private key
     def save
-      http_api.put("clients/#{name}", { :name => name, :admin => admin, :validator => validator })
+      http_api.put("clients/#{name}", { name: name, admin: admin, validator: validator })
     rescue Net::HTTPServerException => e
       # If that fails, go ahead and try and update it
       if e.response.code == "404"
-        http_api.post("clients", { :name => name, :admin => admin, :validator => validator })
+        http_api.post("clients", { name: name, admin: admin, validator: validator })
       else
         raise e
       end
     end
 
     def reregister
-      reregistered_self = http_api.put("clients/#{name}", { :name => name, :admin => admin, :validator => validator, :private_key => true })
+      reregistered_self = http_api.put("clients/#{name}", { name: name, admin: admin, validator: validator, private_key: true })
       if reregistered_self.respond_to?(:[])
         private_key(reregistered_self["private_key"])
       else
@@ -219,7 +219,7 @@ class Chef
     end
 
     def http_api
-      @http_api ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url], { :api_version => "0" })
+      @http_api ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url], { api_version: "0" })
     end
 
   end

data/lib/chef/api_client/registration.rb

@@ -139,7 +139,7 @@ class Chef
       end
 
       def put_data
-        base_put_data = { :name => name, :admin => false }
+        base_put_data = { name: name, admin: false }
         if self_generate_keys?
           base_put_data[:public_key] = generated_public_key
         else
@@ -149,7 +149,7 @@ class Chef
       end
 
       def post_data
-        post_data = { :name => name, :admin => false }
+        post_data = { name: name, admin: false }
         post_data[:public_key] = generated_public_key if self_generate_keys?
         post_data
       end
@@ -157,9 +157,9 @@ class Chef
       def http_api
         @http_api ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url],
                                           {
-                                            :api_version => "0",
-                                            :client_name => Chef::Config[:validation_client_name],
-                                            :signing_key_filename => Chef::Config[:validation_key],
+                                            api_version: "0",
+                                            client_name: Chef::Config[:validation_client_name],
+                                            signing_key_filename: Chef::Config[:validation_key],
                                           }
                                          )
       end

data/lib/chef/api_client_v1.rb

@@ -44,7 +44,7 @@ class Chef
     include Chef::Mixin::ParamsValidate
     include Chef::Mixin::ApiVersionRequestHandling
 
-    SUPPORTED_API_VERSIONS = [0, 1]
+    SUPPORTED_API_VERSIONS = [0, 1].freeze
 
     # Create a new Chef::ApiClientV1 object.
     def initialize
@@ -57,15 +57,15 @@ class Chef
     end
 
     def chef_rest_v0
-      @chef_rest_v0 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url], { :api_version => "0", :inflate_json_class => false })
+      @chef_rest_v0 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url], { api_version: "0", inflate_json_class: false })
     end
 
     def chef_rest_v1
-      @chef_rest_v1 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url], { :api_version => "1", :inflate_json_class => false })
+      @chef_rest_v1 ||= Chef::ServerAPI.new(Chef::Config[:chef_server_url], { api_version: "1", inflate_json_class: false })
     end
 
     def self.http_api
-      Chef::ServerAPI.new(Chef::Config[:chef_server_url], { :api_version => "1", :inflate_json_class => false })
+      Chef::ServerAPI.new(Chef::Config[:chef_server_url], { api_version: "1", inflate_json_class: false })
     end
 
     # Gets or sets the client name.
@@ -76,7 +76,7 @@ class Chef
       set_or_return(
         :name,
         arg,
-        :regex => /^[\-[:alnum:]_\.]+$/
+        regex: /^[\-[:alnum:]_\.]+$/
       )
     end
 
@@ -88,7 +88,7 @@ class Chef
       set_or_return(
         :admin,
         arg,
-        :kind_of => [ TrueClass, FalseClass ]
+        kind_of: [ TrueClass, FalseClass ]
       )
     end
 
@@ -100,7 +100,7 @@ class Chef
       set_or_return(
         :public_key,
         arg,
-        :kind_of => String
+        kind_of: String
       )
     end
 
@@ -113,7 +113,7 @@ class Chef
       set_or_return(
         :validator,
         arg,
-        :kind_of => [TrueClass, FalseClass]
+        kind_of: [TrueClass, FalseClass]
       )
     end
 
@@ -126,7 +126,7 @@ class Chef
       set_or_return(
         :private_key,
         arg,
-        :kind_of => [String, TrueClass, FalseClass]
+        kind_of: [String, TrueClass, FalseClass]
       )
     end
 
@@ -138,7 +138,7 @@ class Chef
       set_or_return(
         :create_key,
         arg,
-        :kind_of => [ TrueClass, FalseClass ]
+        kind_of: [ TrueClass, FalseClass ]
       )
     end
 
@@ -226,7 +226,7 @@ class Chef
     def reregister
       # Try API V0 and if it fails due to V0 not being supported, raise the proper error message.
       # reregister only supported in API V0 or lesser.
-      reregistered_self = chef_rest_v0.put("clients/#{name}", { :name => name, :admin => admin, :validator => validator, :private_key => true })
+      reregistered_self = chef_rest_v0.put("clients/#{name}", { name: name, admin: admin, validator: validator, private_key: true })
       if reregistered_self.respond_to?(:[])
         private_key(reregistered_self["private_key"])
       else
@@ -254,7 +254,7 @@ class Chef
       # it was never implemented, we will simply ignore that functionality
       # as it is being deprecated.
       # Delete this comment after V0 support is dropped.
-      payload = { :name => name }
+      payload = { name: name }
       payload[:validator] = validator unless validator.nil?
 
       # DEPRECATION
@@ -277,11 +277,11 @@ class Chef
     # Create the client via the REST API
     def create
       payload = {
-        :name => name,
-        :validator => validator,
+        name: name,
+        validator: validator,
         # this field is ignored in API V1, but left for backwards-compat,
         # can remove after OSC 11 support is finished?
-        :admin => admin,
+        admin: admin,
       }
       begin
         # try API V1

data/lib/chef/application.rb

@@ -205,7 +205,7 @@ class Chef
     # Based on config and whether or not STDOUT is a tty, should we setup a
     # secondary logger for stdout?
     def want_additional_logger?
-      !( chef_config[:log_location].is_a?(IO) && chef_config[:log_location].tty? ) && !chef_config[:daemonize]
+      Chef::Config.is_default?(:log_location) && Chef::Config[:log_location].tty? && !Chef::Config[:daemonize]
     end
 
     def configure_stdout_logger

data/lib/chef/application/apply.rb

@@ -32,86 +32,86 @@ class Chef::Application::Apply < Chef::Application
   banner "Usage: chef-apply [RECIPE_FILE | -e RECIPE_TEXT | -s] [OPTIONS]"
 
   option :execute,
-    :short        => "-e RECIPE_TEXT",
-    :long         => "--execute RECIPE_TEXT",
-    :description  => "Execute resources supplied in a string",
-    :proc         => nil
+    short: "-e RECIPE_TEXT",
+    long: "--execute RECIPE_TEXT",
+    description: "Execute resources supplied in a string",
+    proc: nil
 
   option :stdin,
-    :short        => "-s",
-    :long         => "--stdin",
-    :description  => "Execute resources read from STDIN",
-    :boolean      => true
+    short: "-s",
+    long: "--stdin",
+    description: "Execute resources read from STDIN",
+    boolean: true
 
   option :json_attribs,
-    :short => "-j JSON_ATTRIBS",
-    :long => "--json-attributes JSON_ATTRIBS",
-    :description => "Load attributes from a JSON file or URL",
-    :proc => nil
+    short: "-j JSON_ATTRIBS",
+    long: "--json-attributes JSON_ATTRIBS",
+    description: "Load attributes from a JSON file or URL",
+    proc: nil
 
   option :force_logger,
-    :long         => "--force-logger",
-    :description  => "Use logger output instead of formatter output",
-    :boolean      => true,
-    :default      => false
+    long: "--force-logger",
+    description: "Use logger output instead of formatter output",
+    boolean: true,
+    default: false
 
   option :force_formatter,
-    :long         => "--force-formatter",
-    :description  => "Use formatter output instead of logger output",
-    :boolean      => true,
-    :default      => false
+    long: "--force-formatter",
+    description: "Use formatter output instead of logger output",
+    boolean: true,
+    default: false
 
   option :formatter,
-    :short        => "-F FORMATTER",
-    :long         => "--format FORMATTER",
-    :description  => "output format to use",
-    :proc         => lambda { |format| Chef::Config.add_formatter(format) }
+    short: "-F FORMATTER",
+    long: "--format FORMATTER",
+    description: "output format to use",
+    proc: lambda { |format| Chef::Config.add_formatter(format) }
 
   option :log_level,
-    :short        => "-l LEVEL",
-    :long         => "--log_level LEVEL",
-    :description  => "Set the log level (trace, debug, info, warn, error, fatal)",
-    :proc         => lambda { |l| l.to_sym }
+    short: "-l LEVEL",
+    long: "--log_level LEVEL",
+    description: "Set the log level (trace, debug, info, warn, error, fatal)",
+    proc: lambda { |l| l.to_sym }
 
   option :help,
-    :short        => "-h",
-    :long         => "--help",
-    :description  => "Show this message",
-    :on           => :tail,
-    :boolean      => true,
-    :show_options => true,
-    :exit         => 0
+    short: "-h",
+    long: "--help",
+    description: "Show this message",
+    on: :tail,
+    boolean: true,
+    show_options: true,
+    exit: 0
 
   option :version,
-    :short        => "-v",
-    :long         => "--version",
-    :description  => "Show chef version",
-    :boolean      => true,
-    :proc         => lambda { |v| puts "Chef: #{::Chef::VERSION}" },
-    :exit         => 0
+    short: "-v",
+    long: "--version",
+    description: "Show chef version",
+    boolean: true,
+    proc: lambda { |v| puts "Chef: #{::Chef::VERSION}" },
+    exit: 0
 
   option :why_run,
-    :short        => "-W",
-    :long         => "--why-run",
-    :description  => "Enable whyrun mode",
-    :boolean      => true
+    short: "-W",
+    long: "--why-run",
+    description: "Enable whyrun mode",
+    boolean: true
 
   option :profile_ruby,
-    :long         => "--[no-]profile-ruby",
-    :description  => "Dump complete Ruby call graph stack of entire Chef run (expert only)",
-    :boolean      => true,
-    :default      => false
+    long: "--[no-]profile-ruby",
+    description: "Dump complete Ruby call graph stack of entire Chef run (expert only)",
+    boolean: true,
+    default: false
 
   option :color,
-    :long         => "--[no-]color",
-    :boolean      => true,
-    :default      => true,
-    :description  => "Use colored output, defaults to enabled"
+    long: "--[no-]color",
+    boolean: true,
+    default: true,
+    description: "Use colored output, defaults to enabled"
 
   option :minimal_ohai,
-    :long           => "--minimal-ohai",
-    :description    => "Only run the bare minimum ohai plugins chef needs to function",
-    :boolean        => true
+    long: "--minimal-ohai",
+    description: "Only run the bare minimum ohai plugins chef needs to function",
+    boolean: true
 
   attr_reader :json_attribs
 

data/lib/chef/application/client.rb

@@ -35,175 +35,174 @@ class Chef::Application::Client < Chef::Application
   include ChefConfig::Mixin::DotD
 
   # Mimic self_pipe sleep from Unicorn to capture signals safely
-  SELF_PIPE = []
+  SELF_PIPE = [] # rubocop:disable Style/MutableConstant
 
   option :config_file,
-    :short => "-c CONFIG",
-    :long  => "--config CONFIG",
-    :description => "The configuration file to use"
+    short: "-c CONFIG",
+    long: "--config CONFIG",
+    description: "The configuration file to use"
 
   option :config_option,
-    :long         => "--config-option OPTION=VALUE",
-    :description  => "Override a single configuration option",
-    :proc         => lambda { |option, existing|
+    long: "--config-option OPTION=VALUE",
+    description: "Override a single configuration option",
+    proc: lambda { |option, existing|
       (existing ||= []) << option
       existing
     }
 
   option :formatter,
-    :short        => "-F FORMATTER",
-    :long         => "--format FORMATTER",
-    :description  => "output format to use",
-    :proc         => lambda { |format| Chef::Config.add_formatter(format) }
+    short: "-F FORMATTER",
+    long: "--format FORMATTER",
+    description: "output format to use",
+    proc: lambda { |format| Chef::Config.add_formatter(format) }
 
   option :force_logger,
-    :long         => "--force-logger",
-    :description  => "Use logger output instead of formatter output",
-    :boolean      => true,
-    :default      => false
+    long: "--force-logger",
+    description: "Use logger output instead of formatter output",
+    boolean: true,
+    default: false
 
   option :force_formatter,
-    :long         => "--force-formatter",
-    :description  => "Use formatter output instead of logger output",
-    :boolean      => true,
-    :default      => false
+    long: "--force-formatter",
+    description: "Use formatter output instead of logger output",
+    boolean: true,
+    default: false
 
   option :profile_ruby,
-    :long         => "--[no-]profile-ruby",
-    :description  => "Dump complete Ruby call graph stack of entire Chef run (expert only)",
-    :boolean      => true,
-    :default      => false
+    long: "--[no-]profile-ruby",
+    description: "Dump complete Ruby call graph stack of entire Chef run (expert only)",
+    boolean: true,
+    default: false
 
   option :color,
-    :long         => "--[no-]color",
-    :boolean      => true,
-    :default      => true,
-    :description  => "Use colored output, defaults to enabled"
+    long: "--[no-]color",
+    boolean: true,
+    default: true,
+    description: "Use colored output, defaults to enabled"
 
   option :log_level,
-    :short        => "-l LEVEL",
-    :long         => "--log_level LEVEL",
-    :description  => "Set the log level (auto, trace, debug, info, warn, error, fatal)",
-    :proc         => lambda { |l| l.to_sym }
+    short: "-l LEVEL",
+    long: "--log_level LEVEL",
+    description: "Set the log level (auto, trace, debug, info, warn, error, fatal)",
+    proc: lambda { |l| l.to_sym }
 
   option :log_location,
-    :short        => "-L LOGLOCATION",
-    :long         => "--logfile LOGLOCATION",
-    :description  => "Set the log file location, defaults to STDOUT - recommended for daemonizing",
-    :proc         => nil
+    short: "-L LOGLOCATION",
+    long: "--logfile LOGLOCATION",
+    description: "Set the log file location, defaults to STDOUT - recommended for daemonizing",
+    proc: nil
 
   option :help,
-    :short        => "-h",
-    :long         => "--help",
-    :description  => "Show this message",
-    :on           => :tail,
-    :boolean      => true,
-    :show_options => true,
-    :exit         => 0
+    short: "-h",
+    long: "--help",
+    description: "Show this message",
+    on: :tail,
+    boolean: true,
+    show_options: true,
+    exit: 0
 
   option :user,
-    :short => "-u USER",
-    :long => "--user USER",
-    :description => "User to set privilege to",
-    :proc => nil
+    short: "-u USER",
+    long: "--user USER",
+    description: "User to set privilege to",
+    proc: nil
 
   option :group,
-    :short => "-g GROUP",
-    :long => "--group GROUP",
-    :description => "Group to set privilege to",
-    :proc => nil
+    short: "-g GROUP",
+    long: "--group GROUP",
+    description: "Group to set privilege to",
+    proc: nil
 
   unless Chef::Platform.windows?
     option :daemonize,
-      :short => "-d [WAIT]",
-      :long => "--daemonize [WAIT]",
-      :description =>
-        "Daemonize the process. Accepts an optional integer which is the " \
+      short: "-d [WAIT]",
+      long: "--daemonize [WAIT]",
+      description:         "Daemonize the process. Accepts an optional integer which is the " \
         "number of seconds to wait before the first daemonized run.",
-      :proc => lambda { |wait| wait =~ /^\d+$/ ? wait.to_i : true }
+      proc: lambda { |wait| wait =~ /^\d+$/ ? wait.to_i : true }
   end
 
   option :pid_file,
-    :short        => "-P PID_FILE",
-    :long         => "--pid PIDFILE",
-    :description  => "Set the PID file location, for the chef-client daemon process. Defaults to /tmp/chef-client.pid",
-    :proc         => nil
+    short: "-P PID_FILE",
+    long: "--pid PIDFILE",
+    description: "Set the PID file location, for the chef-client daemon process. Defaults to /tmp/chef-client.pid",
+    proc: nil
 
   option :lockfile,
-    :long         => "--lockfile LOCKFILE",
-    :description  => "Set the lockfile location. Prevents multiple client processes from converging at the same time",
-    :proc         => nil
+    long: "--lockfile LOCKFILE",
+    description: "Set the lockfile location. Prevents multiple client processes from converging at the same time",
+    proc: nil
 
   option :interval,
-    :short => "-i SECONDS",
-    :long => "--interval SECONDS",
-    :description => "Run chef-client periodically, in seconds",
-    :proc => lambda { |s| s.to_i }
+    short: "-i SECONDS",
+    long: "--interval SECONDS",
+    description: "Run chef-client periodically, in seconds",
+    proc: lambda { |s| s.to_i }
 
   option :once,
-    :long => "--once",
-    :description => "Cancel any interval or splay options, run chef once and exit",
-    :boolean => true
+    long: "--once",
+    description: "Cancel any interval or splay options, run chef once and exit",
+    boolean: true
 
   option :json_attribs,
-    :short => "-j JSON_ATTRIBS",
-    :long => "--json-attributes JSON_ATTRIBS",
-    :description => "Load attributes from a JSON file or URL",
-    :proc => nil
+    short: "-j JSON_ATTRIBS",
+    long: "--json-attributes JSON_ATTRIBS",
+    description: "Load attributes from a JSON file or URL",
+    proc: nil
 
   option :node_name,
-    :short => "-N NODE_NAME",
-    :long => "--node-name NODE_NAME",
-    :description => "The node name for this client",
-    :proc => nil
+    short: "-N NODE_NAME",
+    long: "--node-name NODE_NAME",
+    description: "The node name for this client",
+    proc: nil
 
   option :splay,
-    :short => "-s SECONDS",
-    :long => "--splay SECONDS",
-    :description => "The splay time for running at intervals, in seconds",
-    :proc => lambda { |s| s.to_i }
+    short: "-s SECONDS",
+    long: "--splay SECONDS",
+    description: "The splay time for running at intervals, in seconds",
+    proc: lambda { |s| s.to_i }
 
   option :chef_server_url,
-    :short => "-S CHEFSERVERURL",
-    :long => "--server CHEFSERVERURL",
-    :description => "The chef server URL",
-    :proc => nil
+    short: "-S CHEFSERVERURL",
+    long: "--server CHEFSERVERURL",
+    description: "The chef server URL",
+    proc: nil
 
   option :validation_key,
-    :short        => "-K KEY_FILE",
-    :long         => "--validation_key KEY_FILE",
-    :description  => "Set the validation key file location, used for registering new clients",
-    :proc         => nil
+    short: "-K KEY_FILE",
+    long: "--validation_key KEY_FILE",
+    description: "Set the validation key file location, used for registering new clients",
+    proc: nil
 
   option :client_key,
-    :short        => "-k KEY_FILE",
-    :long         => "--client_key KEY_FILE",
-    :description  => "Set the client key file location",
-    :proc         => nil
+    short: "-k KEY_FILE",
+    long: "--client_key KEY_FILE",
+    description: "Set the client key file location",
+    proc: nil
 
   option :named_run_list,
-    :short        => "-n NAMED_RUN_LIST",
-    :long         => "--named-run-list NAMED_RUN_LIST",
-    :description  => "Use a policyfile's named run list instead of the default run list"
+    short: "-n NAMED_RUN_LIST",
+    long: "--named-run-list NAMED_RUN_LIST",
+    description: "Use a policyfile's named run list instead of the default run list"
 
   option :environment,
-    :short        => "-E ENVIRONMENT",
-    :long         => "--environment ENVIRONMENT",
-    :description  => "Set the Chef Environment on the node"
+    short: "-E ENVIRONMENT",
+    long: "--environment ENVIRONMENT",
+    description: "Set the Chef Environment on the node"
 
   option :version,
-    :short        => "-v",
-    :long         => "--version",
-    :description  => "Show chef version",
-    :boolean      => true,
-    :proc         => lambda { |v| puts "Chef: #{::Chef::VERSION}" },
-    :exit         => 0
+    short: "-v",
+    long: "--version",
+    description: "Show chef version",
+    boolean: true,
+    proc: lambda { |v| puts "Chef: #{::Chef::VERSION}" },
+    exit: 0
 
   option :override_runlist,
-    :short        => "-o RunlistItem,RunlistItem...",
-    :long         => "--override-runlist RunlistItem,RunlistItem...",
-    :description  => "Replace current run list with specified items for a single run",
-    :proc         => lambda { |items|
+    short: "-o RunlistItem,RunlistItem...",
+    long: "--override-runlist RunlistItem,RunlistItem...",
+    description: "Replace current run list with specified items for a single run",
+    proc: lambda { |items|
       items = items.split(",")
       items.compact.map do |item|
         Chef::RunList::RunListItem.new(item)
@@ -211,97 +210,97 @@ class Chef::Application::Client < Chef::Application
     }
 
   option :runlist,
-    :short        => "-r RunlistItem,RunlistItem...",
-    :long         => "--runlist RunlistItem,RunlistItem...",
-    :description  => "Permanently replace current run list with specified items",
-    :proc         => lambda { |items|
+    short: "-r RunlistItem,RunlistItem...",
+    long: "--runlist RunlistItem,RunlistItem...",
+    description: "Permanently replace current run list with specified items",
+    proc: lambda { |items|
       items = items.split(",")
       items.compact.map do |item|
         Chef::RunList::RunListItem.new(item)
       end
     }
   option :why_run,
-    :short        => "-W",
-    :long         => "--why-run",
-    :description  => "Enable whyrun mode",
-    :boolean      => true
+    short: "-W",
+    long: "--why-run",
+    description: "Enable whyrun mode",
+    boolean: true
 
   option :client_fork,
-    :short        => "-f",
-    :long         => "--[no-]fork",
-    :description  => "Fork client"
+    short: "-f",
+    long: "--[no-]fork",
+    description: "Fork client"
 
   option :recipe_url,
-    :long         => "--recipe-url=RECIPE_URL",
-    :description  => "Pull down a remote archive of recipes and unpack it to the cookbook cache. Only used in local mode."
+    long: "--recipe-url=RECIPE_URL",
+    description: "Pull down a remote archive of recipes and unpack it to the cookbook cache. Only used in local mode."
 
   option :enable_reporting,
-    :short        => "-R",
-    :long         => "--enable-reporting",
-    :description  => "Enable reporting data collection for chef runs",
-    :boolean      => true
+    short: "-R",
+    long: "--enable-reporting",
+    description: "Enable reporting data collection for chef runs",
+    boolean: true
 
   option :local_mode,
-    :short        => "-z",
-    :long         => "--local-mode",
-    :description  => "Point chef-client at local repository",
-    :boolean      => true
+    short: "-z",
+    long: "--local-mode",
+    description: "Point chef-client at local repository",
+    boolean: true
 
   option :chef_zero_host,
-    :long         => "--chef-zero-host HOST",
-    :description  => "Host to start chef-zero on"
+    long: "--chef-zero-host HOST",
+    description: "Host to start chef-zero on"
 
   option :chef_zero_port,
-    :long         => "--chef-zero-port PORT",
-    :description  => "Port (or port range) to start chef-zero on.  Port ranges like 1000,1010 or 8889-9999 will try all given ports until one works."
+    long: "--chef-zero-port PORT",
+    description: "Port (or port range) to start chef-zero on.  Port ranges like 1000,1010 or 8889-9999 will try all given ports until one works."
 
   option :disable_config,
-    :long         => "--disable-config",
-    :description  => "Refuse to load a config file and use defaults. This is for development and not a stable API",
-    :boolean      => true
+    long: "--disable-config",
+    description: "Refuse to load a config file and use defaults. This is for development and not a stable API",
+    boolean: true
 
   option :run_lock_timeout,
-    :long         => "--run-lock-timeout SECONDS",
-    :description  => "Set maximum duration to wait for another client run to finish, default is indefinitely.",
-    :proc         => lambda { |s| s.to_i }
+    long: "--run-lock-timeout SECONDS",
+    description: "Set maximum duration to wait for another client run to finish, default is indefinitely.",
+    proc: lambda { |s| s.to_i }
 
   if Chef::Platform.windows?
     option :fatal_windows_admin_check,
-      :short        => "-A",
-      :long         => "--fatal-windows-admin-check",
-      :description  => "Fail the run when chef-client doesn't have administrator privileges on Windows",
-      :boolean      => true
+      short: "-A",
+      long: "--fatal-windows-admin-check",
+      description: "Fail the run when chef-client doesn't have administrator privileges on Windows",
+      boolean: true
   end
 
   option :audit_mode,
-    :long           => "--audit-mode MODE",
-    :description    => "Enable audit-mode with `enabled`. Disable audit-mode with `disabled`. Skip converge and only perform audits with `audit-only`",
-    :proc           => lambda { |mo| mo.tr("-", "_").to_sym }
+    long: "--audit-mode MODE",
+    description: "Enable audit-mode with `enabled`. Disable audit-mode with `disabled`. Skip converge and only perform audits with `audit-only`",
+    proc: lambda { |mo| mo.tr("-", "_").to_sym }
 
   option :minimal_ohai,
-    :long           => "--minimal-ohai",
-    :description    => "Only run the bare minimum ohai plugins chef needs to function",
-    :boolean        => true
+    long: "--minimal-ohai",
+    description: "Only run the bare minimum ohai plugins chef needs to function",
+    boolean: true
 
   option :listen,
-    :long           => "--[no-]listen",
-    :description    => "Whether a local mode (-z) server binds to a port",
-    :boolean        => false
+    long: "--[no-]listen",
+    description: "Whether a local mode (-z) server binds to a port",
+    boolean: false
 
   option :fips,
-    :long         => "--[no-]fips",
-    :description  => "Enable fips mode",
-    :boolean      => true
+    long: "--[no-]fips",
+    description: "Enable fips mode",
+    boolean: true
 
   option :delete_entire_chef_repo,
-    :long           => "--delete-entire-chef-repo",
-    :description    => "DANGEROUS: does what it says, only useful with --recipe-url",
-    :boolean        => true
+    long: "--delete-entire-chef-repo",
+    description: "DANGEROUS: does what it says, only useful with --recipe-url",
+    boolean: true
 
   option :skip_cookbook_sync,
-    :long           => "--[no-]skip-cookbook-sync",
-    :description    => "Use cached cookbooks without overwriting local differences from the server",
-    :boolean        => false
+    long: "--[no-]skip-cookbook-sync",
+    description: "Use cached cookbooks without overwriting local differences from the server",
+    boolean: false
 
   IMMEDIATE_RUN_SIGNAL = "1".freeze
   RECONFIGURE_SIGNAL = "H".freeze
@@ -317,18 +316,18 @@ class Chef::Application::Client < Chef::Application
 
     set_specific_recipes
 
-    Chef::Config[:fips] = config[:fips] if config.has_key? :fips
+    Chef::Config[:fips] = config[:fips] if config.key? :fips
 
-    Chef::Config[:chef_server_url] = config[:chef_server_url] if config.has_key? :chef_server_url
+    Chef::Config[:chef_server_url] = config[:chef_server_url] if config.key? :chef_server_url
 
-    Chef::Config.local_mode = config[:local_mode] if config.has_key?(:local_mode)
+    Chef::Config.local_mode = config[:local_mode] if config.key?(:local_mode)
 
-    if Chef::Config.has_key?(:chef_repo_path) && Chef::Config.chef_repo_path.nil?
+    if Chef::Config.key?(:chef_repo_path) && Chef::Config.chef_repo_path.nil?
       Chef::Config.delete(:chef_repo_path)
       Chef::Log.warn "chef_repo_path was set in a config file but was empty. Assuming #{Chef::Config.chef_repo_path}"
     end
 
-    if Chef::Config.local_mode && !Chef::Config.has_key?(:cookbook_path) && !Chef::Config.has_key?(:chef_repo_path)
+    if Chef::Config.local_mode && !Chef::Config.key?(:cookbook_path) && !Chef::Config.key?(:chef_repo_path)
       Chef::Config.chef_repo_path = Chef::Config.find_chef_repo_path(Dir.pwd)
     end
 
@@ -338,7 +337,7 @@ class Chef::Application::Client < Chef::Application
       else
         if Chef::Config[:delete_entire_chef_repo]
           Chef::Log.trace "Cleanup path #{Chef::Config.chef_repo_path} before extract recipes into it"
-          FileUtils.rm_rf(recipes_path, :secure => true)
+          FileUtils.rm_rf(recipes_path, secure: true)
         end
         Chef::Log.trace "Creating path #{Chef::Config.chef_repo_path} to extract recipes into"
         FileUtils.mkdir_p(Chef::Config.chef_repo_path)
@@ -385,7 +384,7 @@ class Chef::Application::Client < Chef::Application
   end
 
   def load_config_file
-    if !config.has_key?(:config_file) && !config[:disable_config]
+    if !config.key?(:config_file) && !config[:disable_config]
       if config[:local_mode]
         config[:config_file] = Chef::WorkstationConfigLoader.new(nil, Chef::Log).config_location
       else
@@ -518,7 +517,7 @@ class Chef::Application::Client < Chef::Application
   def unforked_interval_error_message
     "Unforked chef-client interval runs are disabled in Chef 12." +
       "\nConfiguration settings:" +
-      "#{"\n  interval  = #{Chef::Config[:interval]} seconds" if Chef::Config[:interval]}" +
+      ("\n  interval  = #{Chef::Config[:interval]} seconds" if Chef::Config[:interval]).to_s +
       "\nEnable chef-client interval runs by setting `:client_fork = true` in your config file or adding `--fork` to your command line options."
   end