chef 14.0.202-universal-mingw32 → 14.1.1-universal-mingw32

data/lib/chef/mixin/create_path.rb

@@ -1,71 +1,71 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright 2008-2016, Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-class Chef
-  module Mixin
-    module CreatePath
-
-      # Creates a given path, including all directories that lead up to it.
-      # Like mkdir_p, but without the leaking.
-      #
-      # === Parameters
-      # file_path<String, Array>:: A string that represents the path to create,
-      #   or an Array with the path-parts.
-      #
-      # === Returns
-      # The created file_path.
-      def create_path(file_path)
-        unless file_path.kind_of?(String) || file_path.kind_of?(Array)
-          raise ArgumentError, "file_path must be a string or an array!"
-        end
-
-        if file_path.kind_of?(String)
-          file_path = File.expand_path(file_path).split(File::SEPARATOR)
-          file_path.shift if file_path[0] == ""
-          # Check if path starts with a separator or drive letter (Windows)
-          unless file_path[0].match("^#{File::SEPARATOR}|^[a-zA-Z]:")
-            file_path[0] = "#{File::SEPARATOR}#{file_path[0]}"
-          end
-        end
-
-        file_path.each_index do |i|
-          create_path = File.join(file_path[0, i + 1])
-          create_dir(create_path) unless File.directory?(create_path)
-        end
-
-        File.expand_path(File.join(file_path))
-      end
-
-      private
-
-      def create_dir(path)
-          # When doing multithreaded downloads into the file cache, the following
-          # interleaving raises an error here:
-          #
-          # thread1                                     thread2
-          # File.directory?(create_path) <- false
-          #                                             File.directory?(create_path) <- false
-          #                                             Dir.mkdir(create_path)
-          # Dir.mkdir(create_path) <- raises Errno::EEXIST
-        Chef::Log.trace("Creating directory #{path}")
-        Dir.mkdir(path)
-      rescue Errno::EEXIST
-      end
-
-    end
-  end
-end
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Chef
+  module Mixin
+    module CreatePath
+
+      # Creates a given path, including all directories that lead up to it.
+      # Like mkdir_p, but without the leaking.
+      #
+      # === Parameters
+      # file_path<String, Array>:: A string that represents the path to create,
+      #   or an Array with the path-parts.
+      #
+      # === Returns
+      # The created file_path.
+      def create_path(file_path)
+        unless file_path.kind_of?(String) || file_path.kind_of?(Array)
+          raise ArgumentError, "file_path must be a string or an array!"
+        end
+
+        if file_path.kind_of?(String)
+          file_path = File.expand_path(file_path).split(File::SEPARATOR)
+          file_path.shift if file_path[0] == ""
+          # Check if path starts with a separator or drive letter (Windows)
+          unless file_path[0].match("^#{File::SEPARATOR}|^[a-zA-Z]:")
+            file_path[0] = "#{File::SEPARATOR}#{file_path[0]}"
+          end
+        end
+
+        file_path.each_index do |i|
+          create_path = File.join(file_path[0, i + 1])
+          create_dir(create_path) unless File.directory?(create_path)
+        end
+
+        File.expand_path(File.join(file_path))
+      end
+
+      private
+
+      def create_dir(path)
+          # When doing multithreaded downloads into the file cache, the following
+          # interleaving raises an error here:
+          #
+          # thread1                                     thread2
+          # File.directory?(create_path) <- false
+          #                                             File.directory?(create_path) <- false
+          #                                             Dir.mkdir(create_path)
+          # Dir.mkdir(create_path) <- raises Errno::EEXIST
+        Chef::Log.trace("Creating directory #{path}")
+        Dir.mkdir(path)
+      rescue Errno::EEXIST
+      end
+
+    end
+  end
+end

data/lib/chef/mixin/deep_merge.rb

@@ -1,140 +1,140 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Steve Midgley (http://www.misuse.org/science)
-# Copyright:: Copyright 2009-2016, Chef Software Inc.
-# Copyright:: Copyright 2008-2016, Steve Midgley
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-class Chef
-  module Mixin
-    # == Chef::Mixin::DeepMerge
-    # Implements a deep merging algorithm for nested data structures.
-    # ==== Notice:
-    #   This code was originally imported from deep_merge by Steve Midgley.
-    #   deep_merge is available under the MIT license from
-    #   http://trac.misuse.org/science/wiki/DeepMerge
-    module DeepMerge
-
-      extend self
-
-      def merge(first, second)
-        first  = Mash.new(first)  unless first.kind_of?(Mash)
-        second = Mash.new(second) unless second.kind_of?(Mash)
-
-        DeepMerge.deep_merge(second, first)
-      end
-
-      class InvalidParameter < StandardError; end
-
-      # Deep Merge core documentation.
-      # deep_merge! method permits merging of arbitrary child elements. The two top level
-      # elements must be hashes. These hashes can contain unlimited (to stack limit) levels
-      # of child elements. These child elements to not have to be of the same types.
-      # Where child elements are of the same type, deep_merge will attempt to merge them together.
-      # Where child elements are not of the same type, deep_merge will skip or optionally overwrite
-      # the destination element with the contents of the source element at that level.
-      # So if you have two hashes like this:
-      #   source = {:x => [1,2,3], :y => 2}
-      #   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
-      #   dest.deep_merge!(source)
-      #   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
-      # By default, "deep_merge!" will overwrite any unmergeables and merge everything else.
-      # To avoid this, use "deep_merge" (no bang/exclamation mark)
-      def deep_merge!(source, dest)
-        # if dest doesn't exist, then simply copy source to it
-        if dest.nil?
-          dest = source; return dest
-        end
-
-        case source
-        when nil
-          dest
-        when Hash
-          if dest.kind_of?(Hash)
-            source.each do |src_key, src_value|
-              if dest.key?(src_key)
-                dest[src_key] = deep_merge!(src_value, dest[src_key])
-              else # dest[src_key] doesn't exist so we take whatever source has
-                dest[src_key] = src_value
-              end
-            end
-          else # dest isn't a hash, so we overwrite it completely
-            dest = source
-          end
-        when Array
-          if dest.kind_of?(Array)
-            dest |= source
-          else
-            dest = source
-          end
-        when String
-          dest = source
-        else # src_hash is not an array or hash, so we'll have to overwrite dest
-          dest = source
-        end
-        dest
-      end # deep_merge!
-
-      def hash_only_merge(merge_onto, merge_with)
-        hash_only_merge!(safe_dup(merge_onto), safe_dup(merge_with))
-      end
-
-      def safe_dup(thing)
-        thing.dup
-      rescue TypeError
-        thing
-      end
-
-      # Deep merge without Array merge.
-      # `merge_onto` is the object that will "lose" in case of conflict.
-      # `merge_with` is the object whose values will replace `merge_onto`s
-      # values when there is a conflict.
-      def hash_only_merge!(merge_onto, merge_with)
-        # If there are two Hashes, recursively merge.
-        if merge_onto.kind_of?(Hash) && merge_with.kind_of?(Hash)
-          merge_with.each do |key, merge_with_value|
-            value =
-              if merge_onto.has_key?(key)
-                hash_only_merge(merge_onto[key], merge_with_value)
-              else
-                merge_with_value
-              end
-
-            if merge_onto.respond_to?(:public_method_that_only_deep_merge_should_use)
-              # we can't call ImmutableMash#[]= because its immutable, but we need to mutate it to build it in-place
-              merge_onto.public_method_that_only_deep_merge_should_use(key, value)
-            else
-              merge_onto[key] = value
-            end
-          end
-          merge_onto
-
-        # If merge_with is nil, don't replace merge_onto
-        elsif merge_with.nil?
-          merge_onto
-
-        # In all other cases, replace merge_onto with merge_with
-        else
-          merge_with
-        end
-      end
-
-      def deep_merge(source, dest)
-        deep_merge!(safe_dup(source), safe_dup(dest))
-      end
-
-    end
-  end
-end
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Steve Midgley (http://www.misuse.org/science)
+# Copyright:: Copyright 2009-2016, Chef Software Inc.
+# Copyright:: Copyright 2008-2016, Steve Midgley
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Chef
+  module Mixin
+    # == Chef::Mixin::DeepMerge
+    # Implements a deep merging algorithm for nested data structures.
+    # ==== Notice:
+    #   This code was originally imported from deep_merge by Steve Midgley.
+    #   deep_merge is available under the MIT license from
+    #   http://trac.misuse.org/science/wiki/DeepMerge
+    module DeepMerge
+
+      extend self
+
+      def merge(first, second)
+        first  = Mash.new(first)  unless first.kind_of?(Mash)
+        second = Mash.new(second) unless second.kind_of?(Mash)
+
+        DeepMerge.deep_merge(second, first)
+      end
+
+      class InvalidParameter < StandardError; end
+
+      # Deep Merge core documentation.
+      # deep_merge! method permits merging of arbitrary child elements. The two top level
+      # elements must be hashes. These hashes can contain unlimited (to stack limit) levels
+      # of child elements. These child elements to not have to be of the same types.
+      # Where child elements are of the same type, deep_merge will attempt to merge them together.
+      # Where child elements are not of the same type, deep_merge will skip or optionally overwrite
+      # the destination element with the contents of the source element at that level.
+      # So if you have two hashes like this:
+      #   source = {:x => [1,2,3], :y => 2}
+      #   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
+      #   dest.deep_merge!(source)
+      #   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
+      # By default, "deep_merge!" will overwrite any unmergeables and merge everything else.
+      # To avoid this, use "deep_merge" (no bang/exclamation mark)
+      def deep_merge!(source, dest)
+        # if dest doesn't exist, then simply copy source to it
+        if dest.nil?
+          dest = source; return dest
+        end
+
+        case source
+        when nil
+          dest
+        when Hash
+          if dest.kind_of?(Hash)
+            source.each do |src_key, src_value|
+              if dest.key?(src_key)
+                dest[src_key] = deep_merge!(src_value, dest[src_key])
+              else # dest[src_key] doesn't exist so we take whatever source has
+                dest[src_key] = src_value
+              end
+            end
+          else # dest isn't a hash, so we overwrite it completely
+            dest = source
+          end
+        when Array
+          if dest.kind_of?(Array)
+            dest |= source
+          else
+            dest = source
+          end
+        when String
+          dest = source
+        else # src_hash is not an array or hash, so we'll have to overwrite dest
+          dest = source
+        end
+        dest
+      end # deep_merge!
+
+      def hash_only_merge(merge_onto, merge_with)
+        hash_only_merge!(safe_dup(merge_onto), safe_dup(merge_with))
+      end
+
+      def safe_dup(thing)
+        thing.dup
+      rescue TypeError
+        thing
+      end
+
+      # Deep merge without Array merge.
+      # `merge_onto` is the object that will "lose" in case of conflict.
+      # `merge_with` is the object whose values will replace `merge_onto`s
+      # values when there is a conflict.
+      def hash_only_merge!(merge_onto, merge_with)
+        # If there are two Hashes, recursively merge.
+        if merge_onto.kind_of?(Hash) && merge_with.kind_of?(Hash)
+          merge_with.each do |key, merge_with_value|
+            value =
+              if merge_onto.has_key?(key)
+                hash_only_merge(merge_onto[key], merge_with_value)
+              else
+                merge_with_value
+              end
+
+            if merge_onto.respond_to?(:public_method_that_only_deep_merge_should_use)
+              # we can't call ImmutableMash#[]= because its immutable, but we need to mutate it to build it in-place
+              merge_onto.public_method_that_only_deep_merge_should_use(key, value)
+            else
+              merge_onto[key] = value
+            end
+          end
+          merge_onto
+
+        # If merge_with is nil, don't replace merge_onto
+        elsif merge_with.nil?
+          merge_onto
+
+        # In all other cases, replace merge_onto with merge_with
+        else
+          merge_with
+        end
+      end
+
+      def deep_merge(source, dest)
+        deep_merge!(safe_dup(source), safe_dup(dest))
+      end
+
+    end
+  end
+end

data/lib/chef/mixin/deprecation.rb

@@ -1,117 +1,117 @@
-#
-# Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2010-2016, Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-class Chef
-  module Mixin
-
-    def self.deprecated_constants
-      @deprecated_constants ||= {}
-    end
-
-    # Add a deprecated constant to the Chef::Mixin namespace.
-    #
-    # @param name [Symbol] the constant name, as a relative symbol.
-    # @param replacement [Object] the constant to return instead.
-    # @param message [String] A message telling the user what to do instead.
-    # @example
-    #   deprecate_constant(:RecipeDefinitionDSLCore, Chef::DSL::Recipe, <<-EOM)
-    #     Chef::Mixin::RecipeDefinitionDSLCore is deprecated, use Chef::DSL::Recipe instead.
-    #   EOM
-    def self.deprecate_constant(name, replacement, message)
-      deprecated_constants[name] = { :replacement => replacement, :message => message }
-    end
-
-    # Const missing hook to look up deprecated constants defined with
-    # deprecate_constant. Emits a warning to the logger and returns the
-    # replacement constant. Will call super, most likely causing an exception
-    # for the missing constant, if +name+ is not found in the
-    # deprecated_constants collection.
-    def self.const_missing(name)
-      if new_const = deprecated_constants[name]
-        Chef::Log.warn(new_const[:message])
-        Chef::Log.warn("Called from: \n#{caller[0...3].map { |l| "\t#{l}" }.join("\n")}")
-        new_const[:replacement]
-      else
-        super
-      end
-    end
-
-    module Deprecation
-
-      class DeprecatedObjectProxyBase
-        KEEPERS = %w{__id__ __send__ instance_eval == equal? initialize object_id}
-        instance_methods.each { |method_name| undef_method(method_name) unless KEEPERS.include?(method_name.to_s) }
-      end
-
-      class DeprecatedInstanceVariable < DeprecatedObjectProxyBase
-        def initialize(target, ivar_name, level = nil)
-          @target, @ivar_name = target, ivar_name
-          @level ||= :warn
-        end
-
-        def method_missing(method_name, *args, &block)
-          deprecated_msg(caller[0..3])
-          @target.send(method_name, *args, &block)
-        end
-
-        def inspect
-          @target.inspect
-        end
-
-        private
-
-        def deprecated_msg(*called_from)
-          called_from = called_from.flatten
-          log("Accessing #{@ivar_name} by the variable @#{@ivar_name} is deprecated. Support will be removed in a future release.")
-          log("Please update your cookbooks to use #{@ivar_name} in place of @#{@ivar_name}. Accessed from:")
-          called_from.each { |l| log(l) }
-        end
-
-        def log(msg)
-          # WTF: I don't get the log prefix (i.e., "[timestamp] LEVEL:") if I
-          # send to Chef::Log. No one but me should use method_missing, ever.
-          Chef::Log.logger.send(@level, msg)
-        end
-
-      end
-
-      def deprecated_ivar(obj, name, level = nil)
-        DeprecatedInstanceVariable.new(obj, name, level)
-      end
-
-      def deprecated_attr(name, alternative)
-        deprecated_attr_reader(name, alternative)
-        deprecated_attr_writer(name, alternative)
-      end
-
-      def deprecated_attr_reader(name, alternative, level = :warn)
-        define_method(name) do
-          Chef.deprecated(:internal_api, "#{self.class}.#{name} is deprecated. Support will be removed in a future release. #{alternative}")
-          instance_variable_get("@#{name}")
-        end
-      end
-
-      def deprecated_attr_writer(name, alternative, level = :warn)
-        define_method("#{name}=") do |value|
-          Chef.deprecated(:internal_api, "Writing to #{self.class}.#{name} with #{name}= is deprecated. Support will be removed in a future release. #{alternative}")
-          instance_variable_set("@#{name}", value)
-        end
-      end
-    end
-  end
-end
+#
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2010-2016, Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+class Chef
+  module Mixin
+
+    def self.deprecated_constants
+      @deprecated_constants ||= {}
+    end
+
+    # Add a deprecated constant to the Chef::Mixin namespace.
+    #
+    # @param name [Symbol] the constant name, as a relative symbol.
+    # @param replacement [Object] the constant to return instead.
+    # @param message [String] A message telling the user what to do instead.
+    # @example
+    #   deprecate_constant(:RecipeDefinitionDSLCore, Chef::DSL::Recipe, <<-EOM)
+    #     Chef::Mixin::RecipeDefinitionDSLCore is deprecated, use Chef::DSL::Recipe instead.
+    #   EOM
+    def self.deprecate_constant(name, replacement, message)
+      deprecated_constants[name] = { :replacement => replacement, :message => message }
+    end
+
+    # Const missing hook to look up deprecated constants defined with
+    # deprecate_constant. Emits a warning to the logger and returns the
+    # replacement constant. Will call super, most likely causing an exception
+    # for the missing constant, if +name+ is not found in the
+    # deprecated_constants collection.
+    def self.const_missing(name)
+      if new_const = deprecated_constants[name]
+        Chef::Log.warn(new_const[:message])
+        Chef::Log.warn("Called from: \n#{caller[0...3].map { |l| "\t#{l}" }.join("\n")}")
+        new_const[:replacement]
+      else
+        super
+      end
+    end
+
+    module Deprecation
+
+      class DeprecatedObjectProxyBase
+        KEEPERS = %w{__id__ __send__ instance_eval == equal? initialize object_id}
+        instance_methods.each { |method_name| undef_method(method_name) unless KEEPERS.include?(method_name.to_s) }
+      end
+
+      class DeprecatedInstanceVariable < DeprecatedObjectProxyBase
+        def initialize(target, ivar_name, level = nil)
+          @target, @ivar_name = target, ivar_name
+          @level ||= :warn
+        end
+
+        def method_missing(method_name, *args, &block)
+          deprecated_msg(caller[0..3])
+          @target.send(method_name, *args, &block)
+        end
+
+        def inspect
+          @target.inspect
+        end
+
+        private
+
+        def deprecated_msg(*called_from)
+          called_from = called_from.flatten
+          log("Accessing #{@ivar_name} by the variable @#{@ivar_name} is deprecated. Support will be removed in a future release.")
+          log("Please update your cookbooks to use #{@ivar_name} in place of @#{@ivar_name}. Accessed from:")
+          called_from.each { |l| log(l) }
+        end
+
+        def log(msg)
+          # WTF: I don't get the log prefix (i.e., "[timestamp] LEVEL:") if I
+          # send to Chef::Log. No one but me should use method_missing, ever.
+          Chef::Log.logger.send(@level, msg)
+        end
+
+      end
+
+      def deprecated_ivar(obj, name, level = nil)
+        DeprecatedInstanceVariable.new(obj, name, level)
+      end
+
+      def deprecated_attr(name, alternative)
+        deprecated_attr_reader(name, alternative)
+        deprecated_attr_writer(name, alternative)
+      end
+
+      def deprecated_attr_reader(name, alternative, level = :warn)
+        define_method(name) do
+          Chef.deprecated(:internal_api, "#{self.class}.#{name} is deprecated. Support will be removed in a future release. #{alternative}")
+          instance_variable_get("@#{name}")
+        end
+      end
+
+      def deprecated_attr_writer(name, alternative, level = :warn)
+        define_method("#{name}=") do |value|
+          Chef.deprecated(:internal_api, "Writing to #{self.class}.#{name} with #{name}= is deprecated. Support will be removed in a future release. #{alternative}")
+          instance_variable_set("@#{name}", value)
+        end
+      end
+    end
+  end
+end