chef 12.17.44-universal-mingw32 → 12.18.31-universal-mingw32

data/lib/chef/http/json_input.rb

@@ -33,7 +33,7 @@ class Chef
 
       def handle_request(method, url, headers = {}, data = false)
         if data && should_encode_as_json?(headers)
-          headers.delete_if { |key, _value| key.casecmp("content-type").zero? }
+          headers.delete_if { |key, _value| key.casecmp("content-type") == 0 }
           headers["Content-Type"] = "application/json"
           json_opts = {}
           json_opts[:validate_utf8] = opts[:validate_utf8] if opts.has_key?(:validate_utf8)
@@ -64,7 +64,7 @@ class Chef
         # ruby/Net::HTTP don't enforce capitalized headers (it normalizes them
         # for you before sending the request), so we have to account for all
         # the variations we might find
-        requested_content_type = headers.find { |k, v| k.casecmp("content-type").zero? }
+        requested_content_type = headers.find { |k, v| k.casecmp("content-type") == 0 }
         requested_content_type.nil? || requested_content_type.last.include?("json")
       end
 

data/lib/chef/knife.rb

@@ -145,7 +145,7 @@ class Chef
     end
 
     def self.subcommand_class_from(args)
-      if args.size == 1 && args[0].strip.casecmp("rehash").zero?
+      if args.size == 1 && args[0].strip.casecmp("rehash") == 0
         # To prevent issues with the rehash file not pointing to the correct plugins,
         # we always use the glob loader when regenerating the rehash file
         @subcommand_loader = Chef::Knife::SubcommandLoader.gem_glob_loader(chef_config_dir)

data/lib/chef/knife/cookbook_site_install.rb

@@ -83,7 +83,7 @@ class Chef
         # Check to ensure we have a valid source of cookbooks before continuing
         #
         @install_path = File.expand_path(Array(config[:cookbook_path]).first)
-        ui.info "Installing #@cookbook_name to #{@install_path}"
+        ui.info "Installing #{@cookbook_name} to #{@install_path}"
 
         @repo = CookbookSCMRepo.new(@install_path, ui, config)
         #cookbook_path = File.join(vendor_path, name_args[0])

data/lib/chef/knife/core/cookbook_scm_repo.rb

@@ -122,7 +122,7 @@ class Chef
         git("branch --no-color").stdout.lines.any? { |l| l =~ /\s#{Regexp.escape(branch_name)}(?:\s|$)/ }
       end
 
-      def get_current_branch()
+      def get_current_branch
         ref = git("symbolic-ref HEAD").stdout
         ref.chomp.split("/")[2]
       end

data/lib/chef/knife/core/ui.rb

@@ -138,7 +138,7 @@ class Chef
       end
 
       def ask_question(question, opts = {})
-        question = question + "[#{opts[:default]}] " if opts[:default]
+        question += "[#{opts[:default]}] " if opts[:default]
 
         if opts[:default] && config[:defaults]
           opts[:default]

data/lib/chef/mixin/command.rb

@@ -107,6 +107,7 @@ class Chef
       end
 
       def output_of_command(command, args)
+        Chef.deprecated(:run_command, "Chef::Mixin::Command.run_command is deprecated, please use shell_out")
         Chef::Log.debug("Executing #{command}")
         stderr_string, stdout_string, status = "", "", nil
 

data/lib/chef/mixin/deep_merge.rb

@@ -75,7 +75,7 @@ class Chef
           end
         when Array
           if dest.kind_of?(Array)
-            dest = dest | source
+            dest |= source
           else
             dest = source
           end

data/lib/chef/mixin/shell_out.rb

@@ -21,6 +21,60 @@ class Chef
   module Mixin
     module ShellOut
 
+      # PREFERRED APIS:
+      #
+      # shell_out_compact and shell_out_compact! flatten their array arguments and remove nils and pass
+      # the resultant array to shell_out.  this actually eliminates spaces-in-args bugs because this:
+      #
+      # shell_out!("command #{arg}")
+      #
+      # becomes two arguments if arg has spaces and requires quotations:
+      #
+      # shell_out!("command '#{arg}'")
+      #
+      # using shell_out_compact! this becomes:
+      #
+      # shell_out_compact!("command", arg)
+      #
+      # and spaces in the arg just works and it does not become two arguments (and the shell quoting around
+      # the argument must actually be removed).
+      #
+      # there's also an implicit join between all the array elements, and nested arrays are flattened which
+      # means that odd where-do-i-put-the-spaces options handling just works, and instead of this:
+      #
+      #    opts = ""                     # needs to be empty string for when foo and bar are both missing
+      #    opts << " -foo" if needs_foo? # needs the leading space on both of these
+      #    opts << " -bar" if needs_bar?
+      #    shell_out!("cmd#{opts}")      # have to think way too hard about why there's no space here
+      #
+      # becomes:
+      #
+      #    opts = []
+      #    opts << "-foo" if needs_foo?
+      #    opts << "-bar" if needs_bar?
+      #    shell_out_compact!("cmd", opts)
+      #
+      # and opts can be an empty array or nil and it'll work out fine.
+      #
+      # generally its best to use shell_out_compact! in code and setup expectations on shell_out! in tests
+      #
+
+      def shell_out_compact(*args, **options)
+        if options.empty?
+          shell_out(*clean_array(*args))
+        else
+          shell_out(*clean_array(*args), **options)
+        end
+      end
+
+      def shell_out_compact!(*args, **options)
+        if options.empty?
+          shell_out!(*clean_array(*args))
+        else
+          shell_out!(*clean_array(*args), **options)
+        end
+      end
+
       # shell_out! runs a command on the system and will raise an error if the command fails, which is what you want
       # for debugging, shell_out and shell_out! both will display command output to the tty when the log level is debug
       # Generally speaking, 'extend Chef::Mixin::ShellOut' in your recipes and include 'Chef::Mixin::ShellOut' in your LWRPs
@@ -85,10 +139,11 @@ class Chef
       # @param args [String] variable number of string arguments
       # @return [String] nicely concatenated string or empty string
       def a_to_s(*args)
-        clean_array(*args).join(" ")
+        # FIXME: this should be deprecated in favor of shell_out_compact/shell_out_compact!
+        args.flatten.reject { |i| i.nil? || i == "" }.map(&:to_s).join(" ")
       end
 
-      # Helper for sublcasses to reject nil and empty strings out of an array.  It allows
+      # Helper for sublcasses to reject nil out of an array.  It allows
       # using the array form of shell_out (which avoids the need to surround arguments with
       # quote marks to deal with shells).
       #
@@ -105,7 +160,7 @@ class Chef
       # @param args [String] variable number of string arguments
       # @return [Array] array of strings with nil and null string rejection
       def clean_array(*args)
-        args.flatten.reject { |i| i.nil? || i == "" }.map(&:to_s)
+        args.flatten.compact.map(&:to_s)
       end
 
       private

data/lib/chef/mixin/which.rb

@@ -18,17 +18,13 @@
 class Chef
   module Mixin
     module Which
-      def which(cmd, opts = {})
-        extra_path =
-          if opts[:extra_path].nil?
-            [ "/bin", "/usr/bin", "/sbin", "/usr/sbin" ]
-          else
-            [ opts[:extra_path] ].flatten
-          end
+      def which(cmd, extra_path: nil)
+        # NOTE: unnecessarily duplicates function of path_sanity
+        extra_path ||= [ "/bin", "/usr/bin", "/sbin", "/usr/sbin" ]
         paths = ENV["PATH"].split(File::PATH_SEPARATOR) + extra_path
         paths.each do |path|
-          filename = File.join(path, cmd)
-          return filename if File.executable?(Chef.path_to(filename))
+          filename = Chef.path_to(File.join(path, cmd))
+          return filename if File.executable?(filename)
         end
         false
       end

data/lib/chef/mixin/wide_string.rb

@@ -34,7 +34,7 @@ class Chef
         ustring = (ustring + "").force_encoding("UTF-8") if ustring.respond_to?(:force_encoding) && ustring.encoding.name != "UTF-8"
 
         # ensure we have the double-null termination Windows Wide likes
-        ustring = ustring + "\000\000" if ustring.length == 0 || ustring[-1].chr != "\000"
+        ustring += "\000\000" if ustring.length == 0 || ustring[-1].chr != "\000"
 
         # encode it all as UTF-16LE AKA Windows Wide Character AKA Windows Unicode
         ustring = begin

data/lib/chef/node.rb

@@ -111,7 +111,7 @@ class Chef
 
     # Set the name of this Node, or return the current name.
     def name(arg = nil)
-      if arg != nil
+      if !arg.nil?
         validate(
                  { :name => arg },
                  { :name => { :kind_of => String,

data/lib/chef/node/attribute.rb

@@ -416,23 +416,22 @@ class Chef
 
       def normal_unless(*args)
         return Decorator::Unchain.new(self, :normal_unless) unless args.length > 0
-        write(:normal, *args) if read(*args[0...-1]).nil?
+        write(:normal, *args) if normal.read(*args[0...-1]).nil?
       end
 
       def default_unless(*args)
         return Decorator::Unchain.new(self, :default_unless) unless args.length > 0
-        write(:default, *args) if read(*args[0...-1]).nil?
+        write(:default, *args) if default.read(*args[0...-1]).nil?
       end
 
       def override_unless(*args)
         return Decorator::Unchain.new(self, :override_unless) unless args.length > 0
-        write(:override, *args) if read(*args[0...-1]).nil?
+        write(:override, *args) if override.read(*args[0...-1]).nil?
       end
 
       def set_unless(*args)
         Chef.deprecated(:attributes, "node.set_unless is deprecated and will be removed in Chef 14, please use node.default_unless/node.override_unless (or node.normal_unless if you really need persistence)")
-        return Decorator::Unchain.new(self, :default_unless) unless args.length > 0
-        write(:normal, *args) if read(*args[0...-1]).nil?
+        normal_unless(*args)
       end
 
       def has_key?(key)

data/lib/chef/node_map.rb

@@ -113,7 +113,7 @@ class Chef
       remaining
     end
 
-    protected
+    private
 
     #
     # Succeeds if:
@@ -172,7 +172,8 @@ class Chef
       !!canonical == !!matcher[:canonical]
     end
 
-    def compare_matchers(key, new_matcher, matcher)
+    # @api private
+    def dispatch_compare_matchers(key, new_matcher, matcher)
       cmp = compare_matcher_properties(new_matcher, matcher) { |m| m[:block] }
       return cmp if cmp != 0
       cmp = compare_matcher_properties(new_matcher, matcher) { |m| m[:filters][:platform_version] }
@@ -189,6 +190,21 @@ class Chef
       0
     end
 
+    #
+    # "provides" lines with identical filters sort by class name (ascending).
+    #
+    def compare_matchers(key, new_matcher, matcher)
+      cmp = dispatch_compare_matchers(key, new_matcher, matcher)
+      if cmp == 0
+        # Sort by class name (ascending) as well, if all other properties
+        # are exactly equal
+        if new_matcher[:value].is_a?(Class) && !new_matcher[:override]
+          cmp = compare_matcher_properties(new_matcher, matcher) { |m| m[:value].name }
+        end
+      end
+      cmp
+    end
+
     def compare_matcher_properties(new_matcher, matcher)
       a = yield(new_matcher)
       b = yield(matcher)

data/lib/chef/platform/provider_handler_map.rb

@@ -17,12 +17,12 @@
 #
 
 require "singleton"
-require "chef/platform/handler_map"
+require "chef/node_map"
 
 class Chef
   class Platform
     # @api private
-    class ProviderHandlerMap < Chef::Platform::HandlerMap
+    class ProviderHandlerMap < Chef::NodeMap
       include Singleton
     end
   end

data/lib/chef/platform/provider_mapping.rb

@@ -35,6 +35,7 @@ class Chef
       include Chef::Mixin::ParamsValidate
 
       def find(name, version)
+        Chef.deprecated(:chef_platform_methods, "#{self.class.name}.find is deprecated")
         provider_map = platforms[:default].clone
 
         name_sym = name
@@ -90,6 +91,7 @@ class Chef
       end
 
       def provider_for_resource(resource, action = :nothing)
+        Chef.deprecated(:chef_platform_methods, "#{self.class.name}.provider_for_resource is deprecated")
         node = resource.run_context && resource.run_context.node
         raise ArgumentError, "Cannot find the provider for a resource with no run context set" unless node
         provider = find_provider_for_node(node, resource).new(resource, resource.run_context)
@@ -102,11 +104,13 @@ class Chef
       end
 
       def find_provider_for_node(node, resource_type)
+        Chef.deprecated(:chef_platform_methods, "#{self.class.name}.find_provider_for_node is deprecated")
         platform, version = find_platform_and_version(node)
         find_provider(platform, version, resource_type)
       end
 
       def set(args)
+        Chef.deprecated(:chef_platform_methods, "#{self.class.name}.set is deprecated")
         validate(
           args,
           {
@@ -172,6 +176,7 @@ class Chef
       end
 
       def find_provider(platform, version, resource_type)
+        Chef.deprecated(:chef_platform_methods, "#{self.class.name}.find_provider is deprecated")
         provider_klass = explicit_provider(platform, version, resource_type) ||
           platform_provider(platform, version, resource_type) ||
           resource_matching_provider(platform, version, resource_type)

data/lib/chef/platform/resource_handler_map.rb

@@ -17,12 +17,12 @@
 #
 
 require "singleton"
-require "chef/platform/handler_map"
+require "chef/node_map"
 
 class Chef
   class Platform
     # @api private
-    class ResourceHandlerMap < Chef::Platform::HandlerMap
+    class ResourceHandlerMap < Chef::NodeMap
       include Singleton
     end
   end

data/lib/chef/provider/env/windows.rb

@@ -36,7 +36,7 @@ class Chef
           obj.variablevalue = @new_resource.value
           obj.put_
           value = @new_resource.value
-          value = expand_path(value) if @new_resource.key_name.casecmp("PATH").zero?
+          value = expand_path(value) if @new_resource.key_name.casecmp("PATH") == 0
           ENV[@new_resource.key_name] = value
           broadcast_env_change
         end

data/lib/chef/provider/git.rb

@@ -65,7 +65,7 @@ class Chef
           # this can't be recovered from in why-run mode, because nothing that
           # we do in the course of a run is likely to create a valid target_revision
           # if we can't resolve it up front.
-          a.assertion { target_revision != nil }
+          a.assertion { !target_revision.nil? }
           a.failure_message Chef::Exceptions::UnresolvableGitReference,
             "Unable to parse SHA reference for '#{@new_resource.revision}' in repository '#{@new_resource.repository}'. " +
             "Verify your (case-sensitive) repository URL and revision.\n" +

data/lib/chef/provider/group.rb

@@ -39,38 +39,38 @@ class Chef
       end
 
       def load_current_resource
-        @current_resource = Chef::Resource::Group.new(@new_resource.name)
-        @current_resource.group_name(@new_resource.group_name)
+        @current_resource = Chef::Resource::Group.new(new_resource.name)
+        current_resource.group_name(new_resource.group_name)
 
         group_info = nil
         begin
-          group_info = Etc.getgrnam(@new_resource.group_name)
-        rescue ArgumentError => e
+          group_info = Etc.getgrnam(new_resource.group_name)
+        rescue ArgumentError
           @group_exists = false
-          Chef::Log.debug("#{@new_resource} group does not exist")
+          Chef::Log.debug("#{new_resource} group does not exist")
         end
 
         if group_info
-          @new_resource.gid(group_info.gid) unless @new_resource.gid
-          @current_resource.gid(group_info.gid)
-          @current_resource.members(group_info.mem)
+          new_resource.gid(group_info.gid) unless new_resource.gid
+          current_resource.gid(group_info.gid)
+          current_resource.members(group_info.mem)
         end
 
-        @current_resource
+        current_resource
       end
 
       def define_resource_requirements
         requirements.assert(:modify) do |a|
           a.assertion { @group_exists }
-          a.failure_message(Chef::Exceptions::Group, "Cannot modify #{@new_resource} - group does not exist!")
-          a.whyrun("Group #{@new_resource} does not exist. Unless it would have been created earlier in this run, this attempt to modify it would fail.")
+          a.failure_message(Chef::Exceptions::Group, "Cannot modify #{new_resource} - group does not exist!")
+          a.whyrun("Group #{new_resource} does not exist. Unless it would have been created earlier in this run, this attempt to modify it would fail.")
         end
 
         requirements.assert(:all_actions) do |a|
           # Make sure that the resource doesn't contain any common
           # user names in the members and exclude_members properties.
-          if !@new_resource.members.nil? && !@new_resource.excluded_members.nil?
-            common_members = @new_resource.members & @new_resource.excluded_members
+          if !new_resource.members.nil? && !new_resource.excluded_members.nil?
+            common_members = new_resource.members & new_resource.excluded_members
             a.assertion { common_members.empty? }
             a.failure_message(Chef::Exceptions::ConflictingMembersInGroup, "Attempting to both add and remove users from a group: '#{common_members.join(', ')}'")
             # No why-run alternative
@@ -86,41 +86,39 @@ class Chef
       # <false>:: If a change is not required
       def compare_group
         @change_desc = [ ]
-        if @new_resource.gid.to_s != @current_resource.gid.to_s
-          @change_desc << "change gid #{@current_resource.gid} to #{@new_resource.gid}"
+        if new_resource.gid.to_s != current_resource.gid.to_s
+          @change_desc << "change gid #{current_resource.gid} to #{new_resource.gid}"
         end
 
-        if @new_resource.append
+        if new_resource.append
           missing_members = []
-          @new_resource.members.each do |member|
+          new_resource.members.each do |member|
             next if has_current_group_member?(member)
             validate_member!(member)
             missing_members << member
           end
-          if missing_members.length > 0
-            @change_desc << "add missing member(s): #{missing_members.join(", ")}"
+          unless missing_members.empty?
+            @change_desc << "add missing member(s): #{missing_members.join(', ')}"
           end
 
           members_to_be_removed = []
-          @new_resource.excluded_members.each do |member|
+          new_resource.excluded_members.each do |member|
             if has_current_group_member?(member)
               members_to_be_removed << member
             end
           end
-          if members_to_be_removed.length > 0
-            @change_desc << "remove existing member(s): #{members_to_be_removed.join(", ")}"
-          end
-        else
-          if @new_resource.members != @current_resource.members
-            @change_desc << "replace group members with new list of members"
+          unless members_to_be_removed.empty?
+            @change_desc << "remove existing member(s): #{members_to_be_removed.join(', ')}"
           end
+        elsif new_resource.members != current_resource.members
+          @change_desc << "replace group members with new list of members"
         end
 
         !@change_desc.empty?
       end
 
       def has_current_group_member?(member)
-        @current_resource.members.include?(member)
+        current_resource.members.include?(member)
       end
 
       def validate_member!(member)
@@ -132,44 +130,41 @@ class Chef
       def action_create
         case @group_exists
         when false
-          converge_by("create group #{@new_resource.group_name}") do
+          converge_by("create group #{new_resource.group_name}") do
             create_group
-            Chef::Log.info("#{@new_resource} created")
+            Chef::Log.info("#{new_resource} created")
           end
         else
           if compare_group
-            converge_by(["alter group #{@new_resource.group_name}"] + change_desc) do
+            converge_by(["alter group #{new_resource.group_name}"] + change_desc) do
               manage_group
-              Chef::Log.info("#{@new_resource} altered")
+              Chef::Log.info("#{new_resource} altered")
             end
           end
         end
       end
 
       def action_remove
-        if @group_exists
-          converge_by("remove group #{@new_resource.group_name}") do
-            remove_group
-            Chef::Log.info("#{@new_resource} removed")
-          end
+        return unless @group_exists
+        converge_by("remove group #{new_resource.group_name}") do
+          remove_group
+          Chef::Log.info("#{new_resource} removed")
         end
       end
 
       def action_manage
-        if @group_exists && compare_group
-          converge_by(["manage group #{@new_resource.group_name}"] + change_desc) do
-            manage_group
-            Chef::Log.info("#{@new_resource} managed")
-          end
+        return unless @group_exists && compare_group
+        converge_by(["manage group #{new_resource.group_name}"] + change_desc) do
+          manage_group
+          Chef::Log.info("#{new_resource} managed")
         end
       end
 
       def action_modify
-        if compare_group
-          converge_by(["modify group #{@new_resource.group_name}"] + change_desc) do
-            manage_group
-            Chef::Log.info("#{@new_resource} modified")
-          end
+        return unless compare_group
+        converge_by(["modify group #{new_resource.group_name}"] + change_desc) do
+          manage_group
+          Chef::Log.info("#{new_resource} modified")
         end
       end