chef 12.13.37-universal-mingw32 → 12.14.60-universal-mingw32

data/acceptance/basics/test/integration/helpers/serverspec/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+# Until https://github.com/test-kitchen/busser-serverspec/pull/42 is merged and
+# released, we need to include rake and rspec-core in the Gemfile
+gem "rake"
+gem "rspec-core"
+gem "busser-serverspec"
+gem "serverspec"

data/acceptance/data-collector/test/integration/helpers/serverspec/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+# Until https://github.com/test-kitchen/busser-serverspec/pull/42 is merged and
+# released, we need to include rake and rspec-core in the Gemfile
+gem "rake"
+gem "rspec-core"
+gem "busser-serverspec"
+gem "serverspec"

data/acceptance/fips/test/integration/fips-integration/serverspec/Gemfile

@@ -1,3 +1,9 @@
 source "https://rubygems.org"
 
+# Until https://github.com/test-kitchen/busser-serverspec/pull/42 is merged and
+# released, we need to include rake and rspec-core in the Gemfile
+gem "rake"
+gem "rspec-core"
+gem "busser-serverspec"
+gem "serverspec"
 gem "mixlib-shellout"

data/acceptance/fips/test/integration/fips-unit-functional/serverspec/Gemfile

@@ -1,3 +1,7 @@
 source "https://rubygems.org"
 
+# Until https://github.com/test-kitchen/busser-serverspec/pull/42 is merged and
+# released, we need to include rake and rspec-core in the Gemfile
+gem "rake"
+gem "rspec-core"
 gem "mixlib-shellout"

data/chef.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   s.email = "adam@chef.io"
   s.homepage = "http://www.chef.io"
 
-  s.required_ruby_version = ">= 2.1.0"
+  s.required_ruby_version = ">= 2.2.0"
 
   s.add_dependency "chef-config", "= #{Chef::VERSION}"
 
@@ -32,10 +32,11 @@ Gem::Specification.new do |s|
   s.add_dependency "erubis", "~> 2.7"
   s.add_dependency "diff-lcs", "~> 1.2", ">= 1.2.4"
 
-  s.add_dependency "chef-zero", "~> 4.8"
+  s.add_dependency "chef-zero", ">= 4.8"
 
   s.add_dependency "plist", "~> 3.2"
   s.add_dependency "iniparse", "~> 1.4"
+  s.add_dependency "addressable"
 
   # Audit mode requires these, so they are non-developmental dependencies now
   %w{rspec-core rspec-expectations rspec-mocks}.each { |gem| s.add_dependency gem, "~> 3.5" }

data/lib/chef/application/client.rb

@@ -204,9 +204,9 @@ class Chef::Application::Client < Chef::Application
     :description  => "Replace current run list with specified items for a single run",
     :proc         => lambda {|items|
       items = items.split(",")
-      items.compact.map {|item|
+      items.compact.map do |item|
         Chef::RunList::RunListItem.new(item)
-      }
+      end
     }
 
   option :runlist,
@@ -215,9 +215,9 @@ class Chef::Application::Client < Chef::Application
     :description  => "Permanently replace current run list with specified items",
     :proc         => lambda {|items|
       items = items.split(",")
-      items.compact.map {|item|
+      items.compact.map do |item|
         Chef::RunList::RunListItem.new(item)
-      }
+      end
     }
   option :why_run,
     :short        => "-W",

data/lib/chef/application/solo.rb

@@ -168,9 +168,9 @@ class Chef::Application::Solo < Chef::Application
     :description  => "Replace current run list with specified items",
     :proc         => lambda {|items|
       items = items.split(",")
-      items.compact.map {|item|
+      items.compact.map do |item|
         Chef::RunList::RunListItem.new(item)
-      }
+      end
     }
 
   option :client_fork,

data/lib/chef/chef_fs/command_line.rb

@@ -242,48 +242,50 @@ class Chef
         return [ [ :error, old_entry, new_entry, nil, nil, e ] ]
       end
 
-      private
+      class << self
+        private
 
-      def self.sort_keys(json_object)
-        if json_object.is_a?(Array)
-          json_object.map { |o| sort_keys(o) }
-        elsif json_object.is_a?(Hash)
-          new_hash = {}
-          json_object.keys.sort.each { |key| new_hash[key] = sort_keys(json_object[key]) }
-          new_hash
-        else
-          json_object
+        def sort_keys(json_object)
+          if json_object.is_a?(Array)
+            json_object.map { |o| sort_keys(o) }
+          elsif json_object.is_a?(Hash)
+            new_hash = {}
+            json_object.keys.sort.each { |key| new_hash[key] = sort_keys(json_object[key]) }
+            new_hash
+          else
+            json_object
+          end
         end
-      end
 
-      def self.canonicalize_json(json_text)
-        parsed_json = Chef::JSONCompat.parse(json_text)
-        sorted_json = sort_keys(parsed_json)
-        Chef::JSONCompat.to_json_pretty(sorted_json)
-      end
-
-      def self.diff_text(old_path, new_path, old_value, new_value)
-        # Copy to tempfiles before diffing
-        # TODO don't copy things that are already in files!  Or find an in-memory diff algorithm
-        begin
-          new_tempfile = Tempfile.new("new")
-          new_tempfile.write(new_value)
-          new_tempfile.close
+        def canonicalize_json(json_text)
+          parsed_json = Chef::JSONCompat.parse(json_text)
+          sorted_json = sort_keys(parsed_json)
+          Chef::JSONCompat.to_json_pretty(sorted_json)
+        end
 
+        def diff_text(old_path, new_path, old_value, new_value)
+          # Copy to tempfiles before diffing
+          # TODO don't copy things that are already in files!  Or find an in-memory diff algorithm
           begin
-            old_tempfile = Tempfile.new("old")
-            old_tempfile.write(old_value)
-            old_tempfile.close
+            new_tempfile = Tempfile.new("new")
+            new_tempfile.write(new_value)
+            new_tempfile.close
 
-            result = Chef::Util::Diff.new.udiff(old_tempfile.path, new_tempfile.path)
-            result = result.gsub(/^--- #{old_tempfile.path}/, "--- #{old_path}")
-            result = result.gsub(/^\+\+\+ #{new_tempfile.path}/, "+++ #{new_path}")
-            result
+            begin
+              old_tempfile = Tempfile.new("old")
+              old_tempfile.write(old_value)
+              old_tempfile.close
+
+              result = Chef::Util::Diff.new.udiff(old_tempfile.path, new_tempfile.path)
+              result = result.gsub(/^--- #{old_tempfile.path}/, "--- #{old_path}")
+              result = result.gsub(/^\+\+\+ #{new_tempfile.path}/, "+++ #{new_path}")
+              result
+            ensure
+              old_tempfile.close!
+            end
           ensure
-            old_tempfile.close!
+            new_tempfile.close!
           end
-        ensure
-          new_tempfile.close!
         end
       end
     end

data/lib/chef/chef_fs/data_handler/data_handler_base.rb

@@ -93,7 +93,7 @@ class Chef
         # name to recipe[name].  Then calls uniq on the result.
         #
         def normalize_run_list(run_list)
-          run_list.map {|item|
+          run_list.map do |item|
             case item.to_s
             when /^recipe\[.*\]$/
               item # explicit recipe
@@ -102,7 +102,7 @@ class Chef
             else
               "recipe[#{item}]"
             end
-          }.uniq
+          end.uniq
         end
 
         #

data/lib/chef/chef_fs/file_pattern.rb

@@ -160,7 +160,7 @@ class Chef
         pattern
       end
 
-    private
+      private
 
       def regexp
         calculate

data/lib/chef/chef_fs/file_system.rb

@@ -68,7 +68,7 @@ class Chef
                 list_from(exact_child, &block)
               end
 
-            # Otherwise, go through all children and find any matches
+              # Otherwise, go through all children and find any matches
             elsif entry.dir?
               results = Parallelizer.parallelize(entry.children) { |child| Chef::ChefFS::FileSystem.list(child, pattern) }
               results.flatten(1).each(&block)
@@ -257,172 +257,174 @@ class Chef
         [ are_same, a_value, b_value ]
       end
 
-      private
-
-      # Copy two entries (could be files or dirs)
-      def self.copy_entries(src_entry, dest_entry, new_dest_parent, recurse_depth, options, ui, format_path)
-        # A NOTE about this algorithm:
-        # There are cases where this algorithm does too many network requests.
-        # knife upload with a specific filename will first check if the file
-        # exists (a "dir" in the parent) before deciding whether to POST or
-        # PUT it.  If we just tried PUT (or POST) and then tried the other if
-        # the conflict failed, we wouldn't need to check existence.
-        # On the other hand, we may already have DONE the request, in which
-        # case we shouldn't waste time trying PUT if we know the file doesn't
-        # exist.
-        # Will need to decide how that works with checksums, though.
-        error = false
-        begin
-          dest_path = format_path.call(dest_entry) if ui
-          src_path = format_path.call(src_entry) if ui
-          if !src_entry.exists?
-            if options[:purge]
-              # If we would not have uploaded it, we will not purge it.
-              if src_entry.parent.can_have_child?(dest_entry.name, dest_entry.dir?)
-                if options[:dry_run]
-                  ui.output "Would delete #{dest_path}" if ui
-                else
-                  begin
-                    dest_entry.delete(true)
-                    ui.output "Deleted extra entry #{dest_path} (purge is on)" if ui
-                  rescue Chef::ChefFS::FileSystem::NotFoundError
-                    ui.output "Entry #{dest_path} does not exist. Nothing to do. (purge is on)" if ui
+      class << self
+        private
+
+        # Copy two entries (could be files or dirs)
+        def copy_entries(src_entry, dest_entry, new_dest_parent, recurse_depth, options, ui, format_path)
+          # A NOTE about this algorithm:
+          # There are cases where this algorithm does too many network requests.
+          # knife upload with a specific filename will first check if the file
+          # exists (a "dir" in the parent) before deciding whether to POST or
+          # PUT it.  If we just tried PUT (or POST) and then tried the other if
+          # the conflict failed, we wouldn't need to check existence.
+          # On the other hand, we may already have DONE the request, in which
+          # case we shouldn't waste time trying PUT if we know the file doesn't
+          # exist.
+          # Will need to decide how that works with checksums, though.
+          error = false
+          begin
+            dest_path = format_path.call(dest_entry) if ui
+            src_path = format_path.call(src_entry) if ui
+            if !src_entry.exists?
+              if options[:purge]
+                # If we would not have uploaded it, we will not purge it.
+                if src_entry.parent.can_have_child?(dest_entry.name, dest_entry.dir?)
+                  if options[:dry_run]
+                    ui.output "Would delete #{dest_path}" if ui
+                  else
+                    begin
+                      dest_entry.delete(true)
+                      ui.output "Deleted extra entry #{dest_path} (purge is on)" if ui
+                    rescue Chef::ChefFS::FileSystem::NotFoundError
+                      ui.output "Entry #{dest_path} does not exist. Nothing to do. (purge is on)" if ui
+                    end
                   end
-                end
-              else
-                ui.output ("Not deleting extra entry #{dest_path} (purge is off)") if ui
-              end
-            end
-
-          elsif !dest_entry.exists?
-            if new_dest_parent.can_have_child?(src_entry.name, src_entry.dir?)
-              # If the entry can do a copy directly from filesystem, do that.
-              if new_dest_parent.respond_to?(:create_child_from)
-                if options[:dry_run]
-                  ui.output "Would create #{dest_path}" if ui
                 else
-                  new_dest_parent.create_child_from(src_entry)
-                  ui.output "Created #{dest_path}" if ui
+                  ui.output ("Not deleting extra entry #{dest_path} (purge is off)") if ui
                 end
-                return
               end
 
-              if src_entry.dir?
-                if options[:dry_run]
-                  ui.output "Would create #{dest_path}" if ui
-                  new_dest_dir = new_dest_parent.child(src_entry.name)
-                else
-                  new_dest_dir = new_dest_parent.create_child(src_entry.name, nil)
-                  ui.output "Created #{dest_path}" if ui
-                end
-                # Directory creation is recursive.
-                if recurse_depth != 0
-                  parallel_do(src_entry.children) do |src_child|
-                    new_dest_child = new_dest_dir.child(src_child.name)
-                    child_error = copy_entries(src_child, new_dest_child, new_dest_dir, recurse_depth ? recurse_depth - 1 : recurse_depth, options, ui, format_path)
-                    error ||= child_error
+            elsif !dest_entry.exists?
+              if new_dest_parent.can_have_child?(src_entry.name, src_entry.dir?)
+                # If the entry can do a copy directly from filesystem, do that.
+                if new_dest_parent.respond_to?(:create_child_from)
+                  if options[:dry_run]
+                    ui.output "Would create #{dest_path}" if ui
+                  else
+                    new_dest_parent.create_child_from(src_entry)
+                    ui.output "Created #{dest_path}" if ui
                   end
+                  return
                 end
-              else
-                if options[:dry_run]
-                  ui.output "Would create #{dest_path}" if ui
-                else
-                  child = new_dest_parent.create_child(src_entry.name, src_entry.read)
-                  ui.output "Created #{format_path.call(child)}" if ui
-                end
-              end
-            end
-
-          else
-            # Both exist.
 
-            # If the entry can do a copy directly, do that.
-            if dest_entry.respond_to?(:copy_from)
-              if options[:force] || compare(src_entry, dest_entry)[0] == false
-                if options[:dry_run]
-                  ui.output "Would update #{dest_path}" if ui
+                if src_entry.dir?
+                  if options[:dry_run]
+                    ui.output "Would create #{dest_path}" if ui
+                    new_dest_dir = new_dest_parent.child(src_entry.name)
+                  else
+                    new_dest_dir = new_dest_parent.create_child(src_entry.name, nil)
+                    ui.output "Created #{dest_path}" if ui
+                  end
+                  # Directory creation is recursive.
+                  if recurse_depth != 0
+                    parallel_do(src_entry.children) do |src_child|
+                      new_dest_child = new_dest_dir.child(src_child.name)
+                      child_error = copy_entries(src_child, new_dest_child, new_dest_dir, recurse_depth ? recurse_depth - 1 : recurse_depth, options, ui, format_path)
+                      error ||= child_error
+                    end
+                  end
                 else
-                  dest_entry.copy_from(src_entry, options)
-                  ui.output "Updated #{dest_path}" if ui
+                  if options[:dry_run]
+                    ui.output "Would create #{dest_path}" if ui
+                  else
+                    child = new_dest_parent.create_child(src_entry.name, src_entry.read)
+                    ui.output "Created #{format_path.call(child)}" if ui
+                  end
                 end
               end
-              return
-            end
 
-            # If they are different types, log an error.
-            if src_entry.dir?
-              if dest_entry.dir?
-                # If both are directories, recurse into their children
-                if recurse_depth != 0
-                  parallel_do(child_pairs(src_entry, dest_entry)) do |src_child, dest_child|
-                    child_error = copy_entries(src_child, dest_child, dest_entry, recurse_depth ? recurse_depth - 1 : recurse_depth, options, ui, format_path)
-                    error ||= child_error
+            else
+              # Both exist.
+
+              # If the entry can do a copy directly, do that.
+              if dest_entry.respond_to?(:copy_from)
+                if options[:force] || compare(src_entry, dest_entry)[0] == false
+                  if options[:dry_run]
+                    ui.output "Would update #{dest_path}" if ui
+                  else
+                    dest_entry.copy_from(src_entry, options)
+                    ui.output "Updated #{dest_path}" if ui
                   end
                 end
-              else
-                # If they are different types.
-                ui.error("File #{src_path} is a directory while file #{dest_path} is a regular file\n") if ui
                 return
               end
-            else
-              if dest_entry.dir?
-                ui.error("File #{src_path} is a regular file while file #{dest_path} is a directory\n") if ui
-                return
-              else
 
-                # Both are files!  Copy them unless we're sure they are the same.'
-                if options[:diff] == false
-                  should_copy = false
-                elsif options[:force]
-                  should_copy = true
-                  src_value = nil
+              # If they are different types, log an error.
+              if src_entry.dir?
+                if dest_entry.dir?
+                  # If both are directories, recurse into their children
+                  if recurse_depth != 0
+                    parallel_do(child_pairs(src_entry, dest_entry)) do |src_child, dest_child|
+                      child_error = copy_entries(src_child, dest_child, dest_entry, recurse_depth ? recurse_depth - 1 : recurse_depth, options, ui, format_path)
+                      error ||= child_error
+                    end
+                  end
                 else
-                  are_same, src_value, _dest_value = compare(src_entry, dest_entry)
-                  should_copy = !are_same
+                  # If they are different types.
+                  ui.error("File #{src_path} is a directory while file #{dest_path} is a regular file\n") if ui
+                  return
                 end
-                if should_copy
-                  if options[:dry_run]
-                    ui.output "Would update #{dest_path}" if ui
+              else
+                if dest_entry.dir?
+                  ui.error("File #{src_path} is a regular file while file #{dest_path} is a directory\n") if ui
+                  return
+                else
+
+                  # Both are files!  Copy them unless we're sure they are the same.'
+                  if options[:diff] == false
+                    should_copy = false
+                  elsif options[:force]
+                    should_copy = true
+                    src_value = nil
                   else
-                    src_value = src_entry.read if src_value.nil?
-                    dest_entry.write(src_value)
-                    ui.output "Updated #{dest_path}" if ui
+                    are_same, src_value, _dest_value = compare(src_entry, dest_entry)
+                    should_copy = !are_same
+                  end
+                  if should_copy
+                    if options[:dry_run]
+                      ui.output "Would update #{dest_path}" if ui
+                    else
+                      src_value = src_entry.read if src_value.nil?
+                      dest_entry.write(src_value)
+                      ui.output "Updated #{dest_path}" if ui
+                    end
                   end
                 end
               end
             end
+          rescue RubyFileError => e
+            ui.warn "#{format_path.call(e.entry)} #{e.reason}." if ui
+          rescue DefaultEnvironmentCannotBeModifiedError => e
+            ui.warn "#{format_path.call(e.entry)} #{e.reason}." if ui
+          rescue OperationFailedError => e
+            ui.error "#{format_path.call(e.entry)} failed to #{e.operation}: #{e.message}" if ui
+            error = true
+          rescue OperationNotAllowedError => e
+            ui.error "#{format_path.call(e.entry)} #{e.reason}." if ui
+            error = true
           end
-        rescue RubyFileError => e
-          ui.warn "#{format_path.call(e.entry)} #{e.reason}." if ui
-        rescue DefaultEnvironmentCannotBeModifiedError => e
-          ui.warn "#{format_path.call(e.entry)} #{e.reason}." if ui
-        rescue OperationFailedError => e
-          ui.error "#{format_path.call(e.entry)} failed to #{e.operation}: #{e.message}" if ui
-          error = true
-        rescue OperationNotAllowedError => e
-          ui.error "#{format_path.call(e.entry)} #{e.reason}." if ui
-          error = true
+          error
         end
-        error
-      end
 
-      def self.get_or_create_parent(entry, options, ui, format_path)
-        parent = entry.parent
-        if parent && !parent.exists?
-          parent_path = format_path.call(parent) if ui
-          parent_parent = get_or_create_parent(parent, options, ui, format_path)
-          if options[:dry_run]
-            ui.output "Would create #{parent_path}" if ui
-          else
-            parent = parent_parent.create_child(parent.name, nil)
-            ui.output "Created #{parent_path}" if ui
+        def get_or_create_parent(entry, options, ui, format_path)
+          parent = entry.parent
+          if parent && !parent.exists?
+            parent_path = format_path.call(parent) if ui
+            parent_parent = get_or_create_parent(parent, options, ui, format_path)
+            if options[:dry_run]
+              ui.output "Would create #{parent_path}" if ui
+            else
+              parent = parent_parent.create_child(parent.name, nil)
+              ui.output "Created #{parent_path}" if ui
+            end
           end
+          return parent
         end
-        return parent
-      end
 
-      def self.parallel_do(enum, options = {}, &block)
-        Chef::ChefFS::Parallelizer.parallel_do(enum, options, &block)
+        def parallel_do(enum, options = {}, &block)
+          Chef::ChefFS::Parallelizer.parallel_do(enum, options, &block)
+        end
       end
     end
   end