chef 12.15.19-universal-mingw32 → 12.16.42-universal-mingw32

data/lib/chef/node/attribute_collections.rb

@@ -17,6 +17,7 @@
 #
 
 require "chef/node/common_api"
+require "chef/node/mixin/state_tracking"
 
 class Chef
   class Node
@@ -33,7 +34,6 @@ class Chef
         :compact!,
         :default=,
         :default_proc=,
-        :delete,
         :delete_at,
         :delete_if,
         :fill,
@@ -63,15 +63,17 @@ class Chef
       MUTATOR_METHODS.each do |mutator|
         define_method(mutator) do |*args, &block|
           ret = super(*args, &block)
-          root.reset_cache(root.top_level_breadcrumb)
+          send_reset_cache
           ret
         end
       end
 
-      attr_reader :root
+      def delete(key, &block)
+        send_reset_cache(__path__, key)
+        super
+      end
 
-      def initialize(root, data)
-        @root = root
+      def initialize(data = [])
         super(data)
         map! { |e| convert_value(e) }
       end
@@ -96,14 +98,20 @@ class Chef
         when AttrArray
           value
         when Hash
-          VividMash.new(root, value)
+          VividMash.new(value, __root__, __node__, __precedence__)
         when Array
-          AttrArray.new(root, value)
+          AttrArray.new(value, __root__, __node__, __precedence__)
         else
           value
         end
       end
 
+      # needed for __path__
+      def convert_key(key)
+        key
+      end
+
+      prepend Chef::Node::Mixin::StateTracking
     end
 
     # == VividMash
@@ -117,8 +125,6 @@ class Chef
     #   #fetch, work as normal).
     # * attr_accessor style element set and get are supported via method_missing
     class VividMash < Mash
-      attr_reader :root
-
       include CommonAPI
 
       # Methods that mutate a VividMash. Each of them is overridden so that it
@@ -126,7 +132,6 @@ class Chef
       # object.
       MUTATOR_METHODS = [
         :clear,
-        :delete,
         :delete_if,
         :keep_if,
         :merge!,
@@ -140,23 +145,27 @@ class Chef
       # For all of the mutating methods on Mash, override them so that they
       # also invalidate the cached `merged_attributes` on the root Attribute
       # object.
+
+      def delete(key, &block)
+        send_reset_cache(__path__, key)
+        super
+      end
+
       MUTATOR_METHODS.each do |mutator|
         define_method(mutator) do |*args, &block|
-          root.reset_cache(root.top_level_breadcrumb)
+          send_reset_cache
           super(*args, &block)
         end
       end
 
-      def initialize(root, data = {})
-        @root = root
+      def initialize(data = {})
         super(data)
       end
 
       def [](key)
-        root.top_level_breadcrumb ||= key
         value = super
         if !key?(key)
-          value = self.class.new(root)
+          value = self.class.new({}, __root__)
           self[key] = value
         else
           value
@@ -164,9 +173,8 @@ class Chef
       end
 
       def []=(key, value)
-        root.top_level_breadcrumb ||= key
         ret = super
-        root.reset_cache(root.top_level_breadcrumb)
+        send_reset_cache(__path__, key)
         ret
       end
 
@@ -205,9 +213,9 @@ class Chef
         when AttrArray
           value
         when Hash
-          VividMash.new(root, value)
+          VividMash.new(value, __root__, __node__, __precedence__)
         when Array
-          AttrArray.new(root, value)
+          AttrArray.new(value, __root__, __node__, __precedence__)
         else
           value
         end
@@ -217,6 +225,7 @@ class Chef
         Mash.new(self)
       end
 
+      prepend Chef::Node::Mixin::StateTracking
     end
   end
 end

data/lib/chef/node/common_api.rb

@@ -32,7 +32,6 @@ class Chef
       # - autovivifying / autoreplacing writer
       # - non-container-ey intermediate objects are replaced with hashes
       def write(*args, &block)
-        root.top_level_breadcrumb = nil if respond_to?(:root)
         value = block_given? ? yield : args.pop
         last = args.pop
         prev_memo = prev_key = nil
@@ -56,7 +55,6 @@ class Chef
       # something that is not a container ("schema violation" issues).
       #
       def write!(*args, &block)
-        root.top_level_breadcrumb = nil if respond_to?(:root)
         value = block_given? ? yield : args.pop
         last = args.pop
         obj = args.inject(self) do |memo, key|
@@ -71,7 +69,6 @@ class Chef
 
       # return true or false based on if the attribute exists
       def exist?(*path)
-        root.top_level_breadcrumb = nil if respond_to?(:root)
         path.inject(self) do |memo, key|
           return false unless valid_container?(memo, key)
           if memo.is_a?(Hash)
@@ -103,7 +100,6 @@ class Chef
       # non-autovivifying reader that throws an exception if the attribute does not exist
       def read!(*path)
         raise Chef::Exceptions::NoSuchAttribute unless exist?(*path)
-        root.top_level_breadcrumb = nil if respond_to?(:root)
         path.inject(self) do |memo, key|
           memo[key]
         end
@@ -112,10 +108,8 @@ class Chef
       # FIXME:(?) does anyone really like the autovivifying reader that we have and wants the same behavior?  readers that write?  ugh...
 
       def unlink(*path, last)
-        root.top_level_breadcrumb = nil if respond_to?(:root)
         hash = path.empty? ? self : read(*path)
         return nil unless hash.is_a?(Hash) || hash.is_a?(Array)
-        root.top_level_breadcrumb ||= last
         hash.delete(last)
       end
 

data/lib/chef/node/immutable_collections.rb

@@ -16,6 +16,9 @@
 #
 
 require "chef/node/common_api"
+require "chef/node/mixin/state_tracking"
+require "chef/node/mixin/immutablize_array"
+require "chef/node/mixin/immutablize_hash"
 
 class Chef
   class Node
@@ -24,9 +27,9 @@ class Chef
       def immutablize(value)
         case value
         when Hash
-          ImmutableMash.new(value)
+          ImmutableMash.new(value, __root__, __node__, __precedence__)
         when Array
-          ImmutableArray.new(value)
+          ImmutableArray.new(value, __root__, __node__, __precedence__)
         else
           value
         end
@@ -49,55 +52,12 @@ class Chef
       alias :internal_push :<<
       private :internal_push
 
-      # A list of methods that mutate Array. Each of these is overridden to
-      # raise an error, making this instances of this class more or less
-      # immutable.
-      DISALLOWED_MUTATOR_METHODS = [
-        :<<,
-        :[]=,
-        :clear,
-        :collect!,
-        :compact!,
-        :default=,
-        :default_proc=,
-        :delete,
-        :delete_at,
-        :delete_if,
-        :fill,
-        :flatten!,
-        :insert,
-        :keep_if,
-        :map!,
-        :merge!,
-        :pop,
-        :push,
-        :update,
-        :reject!,
-        :reverse!,
-        :replace,
-        :select!,
-        :shift,
-        :slice!,
-        :sort!,
-        :sort_by!,
-        :uniq!,
-        :unshift,
-      ]
-
-      def initialize(array_data)
+      def initialize(array_data = [])
         array_data.each do |value|
           internal_push(immutablize(value))
         end
       end
 
-      # Redefine all of the methods that mutate a Hash to raise an error when called.
-      # This is the magic that makes this object "Immutable"
-      DISALLOWED_MUTATOR_METHODS.each do |mutator_method_name|
-        define_method(mutator_method_name) do |*args, &block|
-          raise Exceptions::ImmutableAttributeModification
-        end
-      end
-
       # For elements like Fixnums, true, nil...
       def safe_dup(e)
         e.dup
@@ -125,6 +85,13 @@ class Chef
         a
       end
 
+      # for consistency's sake -- integers 'converted' to integers
+      def convert_key(key)
+        key
+      end
+
+      prepend Chef::Node::Mixin::StateTracking
+      prepend Chef::Node::Mixin::ImmutablizeArray
     end
 
     # == ImmutableMash
@@ -140,36 +107,13 @@ class Chef
     #   it is stale.
     # * Values can be accessed in attr_reader-like fashion via method_missing.
     class ImmutableMash < Mash
-
       include Immutablize
       include CommonAPI
 
       alias :internal_set :[]=
       private :internal_set
 
-      DISALLOWED_MUTATOR_METHODS = [
-        :[]=,
-        :clear,
-        :collect!,
-        :default=,
-        :default_proc=,
-        :delete,
-        :delete_if,
-        :keep_if,
-        :map!,
-        :merge!,
-        :update,
-        :reject!,
-        :replace,
-        :select!,
-        :shift,
-        :write,
-        :write!,
-        :unlink,
-        :unlink!,
-      ]
-
-      def initialize(mash_data)
+      def initialize(mash_data = {})
         mash_data.each do |key, value|
           internal_set(key, immutablize(value))
         end
@@ -181,14 +125,6 @@ class Chef
 
       alias :attribute? :has_key?
 
-      # Redefine all of the methods that mutate a Hash to raise an error when called.
-      # This is the magic that makes this object "Immutable"
-      DISALLOWED_MUTATOR_METHODS.each do |mutator_method_name|
-        define_method(mutator_method_name) do |*args, &block|
-          raise Exceptions::ImmutableAttributeModification
-        end
-      end
-
       def method_missing(symbol, *args)
         if symbol == :to_ary
           super
@@ -238,7 +174,8 @@ class Chef
         h
       end
 
+      prepend Chef::Node::Mixin::StateTracking
+      prepend Chef::Node::Mixin::ImmutablizeHash
     end
-
   end
 end

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

@@ -0,0 +1,61 @@
+#--
+# Copyright:: Copyright 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
+  class Node
+    module Mixin
+      module DeepMergeCache
+       # Cache of deep merged values by top-level key.  This is a simple hash which has keys that are the
+       # top-level keys of the node object, and we save the computed deep-merge for that key here.  There is
+       # no cache of subtrees.
+        attr_accessor :deep_merge_cache
+
+        def initialize
+          @merged_attributes = nil
+          @combined_override = nil
+          @combined_default = nil
+          @deep_merge_cache = {}
+        end
+
+       # Invalidate a key in the deep_merge_cache.  If called with nil, or no arg, this will invalidate
+       # the entire deep_merge cache.  In the case of the user doing node.default['foo']['bar']['baz']=
+       # that eventually results in a call to reset_cache('foo') here.  A node.default=hash_thing call
+       # must invalidate the entire cache and re-deep-merge the entire node object.
+        def reset_cache(path = nil)
+          if path.nil?
+            deep_merge_cache.clear
+          else
+            deep_merge_cache.delete(path.to_s)
+          end
+        end
+
+        alias :reset :reset_cache
+
+        def [](key)
+          if deep_merge_cache.has_key?(key.to_s)
+            # return the cache of the deep merged values by top-level key
+            deep_merge_cache[key.to_s]
+          else
+            # save all the work of computing node[key]
+            deep_merge_cache[key.to_s] = merged_attributes(key)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+#--
+# Copyright:: Copyright 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
+  class Node
+    module Mixin
+      module ImmutablizeArray
+        # A list of methods that mutate Array. Each of these is overridden to
+        # raise an error, making this instances of this class more or less
+        # immutable.
+        DISALLOWED_MUTATOR_METHODS = [
+          :<<,
+          :[]=,
+          :clear,
+          :collect!,
+          :compact!,
+          :default=,
+          :default_proc=,
+          :delete,
+          :delete_at,
+          :delete_if,
+          :fill,
+          :flatten!,
+          :insert,
+          :keep_if,
+          :map!,
+          :merge!,
+          :pop,
+          :push,
+          :update,
+          :reject!,
+          :reverse!,
+          :replace,
+          :select!,
+          :shift,
+          :slice!,
+          :sort!,
+          :sort_by!,
+          :uniq!,
+          :unshift,
+        ]
+
+        # Redefine all of the methods that mutate a Hash to raise an error when called.
+        # This is the magic that makes this object "Immutable"
+        DISALLOWED_MUTATOR_METHODS.each do |mutator_method_name|
+          define_method(mutator_method_name) do |*args, &block|
+            raise Exceptions::ImmutableAttributeModification
+          end
+        end
+      end
+    end
+  end
+end