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

data/lib/chef/node/mixin/immutablize_hash.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright:: Copyright 2016-2018, Chef Software Inc.
+# Copyright:: Copyright 2016-2019, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,136 +21,136 @@ class Chef
       module ImmutablizeHash
         # allowed methods that MUST NOT mutate the object
         # (if any of these methods mutate the underlying object that is a bug that needs to be fixed)
-        ALLOWED_METHODS = [
-          :<,
-          :<=,
-          :>,
-          :>=,
-          :[],
-          :all?,
-          :any?,
-          :assoc,
-          :chain,
-          :chunk,
-          :chunk_while,
-          :collect,
-          :collect_concat,
-          :compact,
-          :compare_by_identity,
-          :compare_by_identity?,
-          :count,
-          :cycle,
-          :default,
-          :default_proc,
-          :detect,
-          :dig,
-          :drop,
-          :drop_while,
-          :each,
-          :each_cons,
-          :each_entry,
-          :each_key,
-          :each_pair,
-          :each_slice,
-          :each_value,
-          :each_with_index,
-          :each_with_object,
-          :empty?,
-          :entries,
-          :fetch,
-          :fetch_values,
-          :filter,
-          :find,
-          :find_all,
-          :find_index,
-          :first,
-          :flat_map,
-          :flatten,
-          :grep,
-          :grep_v,
-          :group_by,
-          :has_key?,
-          :has_value?,
-          :include?,
-          :index,
-          :inject,
-          :invert,
-          :key,
-          :key?,
-          :keys,
-          :lazy,
-          :length,
-          :map,
-          :max,
-          :max_by,
-          :member?,
-          :merge,
-          :min,
-          :min_by,
-          :minmax,
-          :minmax_by,
-          :none?,
-          :normalize_param,
-          :one?,
-          :partition,
-          :rassoc,
-          :reduce,
-          :reject,
-          :reverse_each,
-          :save_plist,
-          :select,
-          :size,
-          :slice,
-          :slice_after,
-          :slice_before,
-          :slice_when,
-          :sort,
-          :sort_by,
-          :sum,
-          :take,
-          :take_while,
-          :to_a,
-          :to_h,
-          :to_hash,
-          :to_plist,
-          :to_proc,
-          :to_set,
-          :to_xml_attributes,
-          :transform_keys,
-          :transform_values,
-          :uniq,
-          :value?,
-          :values,
-          :values_at,
-          :zip,
-        ].freeze
-        DISALLOWED_MUTATOR_METHODS = [
-          :[]=,
-          :clear,
-          :collect!,
-          :compact!,
-          :default=,
-          :default_proc=,
-          :delete,
-          :delete_if,
-          :filter!,
-          :keep_if,
-          :map!,
-          :merge!,
-          :rehash,
-          :reject!,
-          :replace,
-          :select!,
-          :shift,
-          :store,
-          :transform_keys!,
-          :transform_values!,
-          :unlink!,
-          :unlink,
-          :update,
-          :write!,
-          :write,
-        ].freeze
+        ALLOWED_METHODS = %i{
+          <
+          <=
+          >
+          >=
+          []
+          all?
+          any?
+          assoc
+          chain
+          chunk
+          chunk_while
+          collect
+          collect_concat
+          compact
+          compare_by_identity
+          compare_by_identity?
+          count
+          cycle
+          default
+          default_proc
+          detect
+          dig
+          drop
+          drop_while
+          each
+          each_cons
+          each_entry
+          each_key
+          each_pair
+          each_slice
+          each_value
+          each_with_index
+          each_with_object
+          empty?
+          entries
+          fetch
+          fetch_values
+          filter
+          find
+          find_all
+          find_index
+          first
+          flat_map
+          flatten
+          grep
+          grep_v
+          group_by
+          has_key?
+          has_value?
+          include?
+          index
+          inject
+          invert
+          key
+          key?
+          keys
+          lazy
+          length
+          map
+          max
+          max_by
+          member?
+          merge
+          min
+          min_by
+          minmax
+          minmax_by
+          none?
+          normalize_param
+          one?
+          partition
+          rassoc
+          reduce
+          reject
+          reverse_each
+          save_plist
+          select
+          size
+          slice
+          slice_after
+          slice_before
+          slice_when
+          sort
+          sort_by
+          sum
+          take
+          take_while
+          to_a
+          to_h
+          to_hash
+          to_plist
+          to_proc
+          to_set
+          to_xml_attributes
+          transform_keys
+          transform_values
+          uniq
+          value?
+          values
+          values_at
+          zip
+        }.freeze
+        DISALLOWED_MUTATOR_METHODS = %i{
+          []=
+          clear
+          collect!
+          compact!
+          default=
+          default_proc=
+          delete
+          delete_if
+          filter!
+          keep_if
+          map!
+          merge!
+          rehash
+          reject!
+          replace
+          select!
+          shift
+          store
+          transform_keys!
+          transform_values!
+          unlink!
+          unlink
+          update
+          write!
+          write
+        }.freeze
 
         # Redefine all of the methods that mutate a Hash to raise an error when called.
         # This is the magic that makes this object "Immutable"

data/lib/chef/node_map.rb

@@ -120,6 +120,7 @@ class Chef
     #
     def get(node, key, canonical: nil)
       return nil unless map.key?(key)
+
       map[key].map do |matcher|
         return matcher[:klass] if node_matches?(node, matcher) && canonical_matches?(canonical, matcher)
       end
@@ -140,6 +141,7 @@ class Chef
     #
     def list(node, key, canonical: nil)
       return [] unless map.key?(key)
+
       map[key].select do |matcher|
         node_matches?(node, matcher) && canonical_matches?(canonical, matcher)
       end.map { |matcher| matcher[:klass] }
@@ -155,6 +157,7 @@ class Chef
     # @return [Hash] deleted entries in the same format as the @map
     def delete_class(klass)
       raise "please use a Class type for the klass argument" unless klass.is_a?(Class)
+
       deleted = {}
       map.each do |key, matchers|
         deleted_matchers = []
@@ -224,7 +227,8 @@ class Chef
     def matches_black_white_list?(node, filters, attribute)
       # It's super common for the filter to be nil.  Catch that so we don't
       # spend any time here.
-      return true if !filters[attribute]
+      return true unless filters[attribute]
+
       filter_values = Array(filters[attribute])
       value = node[attribute]
 
@@ -241,7 +245,8 @@ class Chef
     def matches_version_list?(node, filters, attribute)
       # It's super common for the filter to be nil.  Catch that so we don't
       # spend any time here.
-      return true if !filters[attribute]
+      return true unless filters[attribute]
+
       filter_values = Array(filters[attribute])
       value = node[attribute]
 
@@ -257,6 +262,7 @@ class Chef
     #
     def matches_target_mode?(filters)
       return true unless Chef::Config.target_mode?
+
       !!filters[:target_mode]
     end
 
@@ -270,16 +276,19 @@ class Chef
 
     def block_matches?(node, block)
       return true if block.nil?
+
       block.call node
     end
 
     def node_matches?(node, matcher)
-      return true if !node
+      return true unless node
+
       filters_match?(node, matcher) && block_matches?(node, matcher[:block])
     end
 
     def canonical_matches?(canonical, matcher)
       return true if canonical.nil?
+
       !!canonical == !!matcher[:canonical]
     end
 
@@ -289,16 +298,22 @@ class Chef
     def compare_matchers(key, new_matcher, matcher)
       cmp = compare_matcher_properties(new_matcher[:block], matcher[:block])
       return cmp if cmp != 0
+
       cmp = compare_matcher_properties(new_matcher[:platform_version], matcher[:platform_version])
       return cmp if cmp != 0
+
       cmp = compare_matcher_properties(new_matcher[:platform], matcher[:platform])
       return cmp if cmp != 0
+
       cmp = compare_matcher_properties(new_matcher[:platform_family], matcher[:platform_family])
       return cmp if cmp != 0
+
       cmp = compare_matcher_properties(new_matcher[:os], matcher[:os])
       return cmp if cmp != 0
+
       cmp = compare_matcher_properties(new_matcher[:override], matcher[:override])
       return cmp if cmp != 0
+
       # If all things are identical, return 0
       0
     end

data/lib/chef/null_logger.rb

@@ -27,29 +27,21 @@ class Chef
   # probably expected a real logger and not this "fake" one.
   class NullLogger
 
-    def fatal(message, &block)
-    end
+    def fatal(message, &block); end
 
-    def error(message, &block)
-    end
+    def error(message, &block); end
 
-    def warn(message, &block)
-    end
+    def warn(message, &block); end
 
-    def info(message, &block)
-    end
+    def info(message, &block); end
 
-    def debug(message, &block)
-    end
+    def debug(message, &block); end
 
-    def trace(message, &block)
-    end
+    def trace(message, &block); end
 
-    def add(severity, message = nil, progname = nil)
-    end
+    def add(severity, message = nil, progname = nil); end
 
-    def <<(message)
-    end
+    def <<(message); end
 
     def fatal?
       false

data/lib/chef/org.rb

@@ -40,22 +40,22 @@ class Chef
 
     def name(arg = nil)
       set_or_return(:name, arg,
-                    regex: /^[a-z0-9\-_]+$/)
+        regex: /^[a-z0-9\-_]+$/)
     end
 
     def full_name(arg = nil)
       set_or_return(:full_name,
-                    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 guid(arg = nil)
       set_or_return(:guid,
-                    arg, kind_of: String)
+        arg, kind_of: String)
     end
 
     def to_h

data/lib/chef/platform/query_helpers.rb

@@ -26,6 +26,7 @@ class Chef
 
       def windows_nano_server?
         return false unless windows?
+
         require "win32/registry" unless defined?(Win32::Registry)
 
         # This method may be called before ohai runs (e.g., it may be used to
@@ -48,6 +49,7 @@ class Chef
 
       def supports_msi?
         return false unless windows?
+
         require "win32/registry" unless defined?(Win32::Registry)
 
         key = "System\\CurrentControlSet\\Services\\msiserver"
@@ -90,6 +92,7 @@ class Chef
 
       def supported_powershell_version?(node, version_string)
         return false unless node[:languages] && node[:languages][:powershell]
+
         require "rubygems" unless defined?(Gem)
         Gem::Version.new(node[:languages][:powershell][:version]) >=
           Gem::Version.new(version_string)