chef 12.6.0 → 12.7.2

data/lib/chef/monologger.rb

@@ -1,5 +1,5 @@
-require 'logger'
-require 'pp'
+require "logger"
+require "pp"
 
 #== MonoLogger
 # A subclass of Ruby's stdlib Logger with all the mutex and logrotation stuff
@@ -38,7 +38,6 @@ class MonoLogger < Logger
     end
   end
 
-
   class LocklessLogDevice < LogDevice
 
     def initialize(log = nil)
@@ -86,5 +85,4 @@ class MonoLogger < Logger
 
   end
 
-
 end

data/lib/chef/node.rb

@@ -1,9 +1,8 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Christopher Brown (<cb@opscode.com>)
-# Author:: Christopher Walters (<cw@opscode.com>)
-# Author:: Tim Hinderliter (<tim@opscode.com>)
-# Copyright:: Copyright (c) 2008-2011 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Christopher Brown (<cb@chef.io>)
+# Author:: Christopher Walters (<cw@chef.io>)
+# Author:: Tim Hinderliter (<tim@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");
@@ -19,22 +18,22 @@
 # limitations under the License.
 #
 
-require 'forwardable'
-require 'chef/config'
-require 'chef/nil_argument'
-require 'chef/mixin/params_validate'
-require 'chef/mixin/from_file'
-require 'chef/mixin/deep_merge'
-require 'chef/dsl/include_attribute'
-require 'chef/dsl/platform_introspection'
-require 'chef/environment'
-require 'chef/rest'
-require 'chef/run_list'
-require 'chef/node/attribute'
-require 'chef/mash'
-require 'chef/json_compat'
-require 'chef/search/query'
-require 'chef/whitelist'
+require "forwardable"
+require "chef/config"
+require "chef/nil_argument"
+require "chef/mixin/params_validate"
+require "chef/mixin/from_file"
+require "chef/mixin/deep_merge"
+require "chef/dsl/include_attribute"
+require "chef/dsl/platform_introspection"
+require "chef/environment"
+require "chef/server_api"
+require "chef/run_list"
+require "chef/node/attribute"
+require "chef/mash"
+require "chef/json_compat"
+require "chef/search/query"
+require "chef/whitelist"
 
 class Chef
   class Node
@@ -70,7 +69,7 @@ class Chef
       @chef_server_rest = chef_server_rest
       @name = nil
 
-      @chef_environment = '_default'
+      @chef_environment = "_default"
       @primary_runlist = Chef::RunList.new
       @override_runlist = Chef::RunList.new
 
@@ -100,30 +99,30 @@ class Chef
       # for saving node data we use validate_utf8: false which will not
       # raise an exception on bad utf8 data, but will replace the bad
       # characters and render valid JSON.
-      @chef_server_rest ||= Chef::REST.new(
+      @chef_server_rest ||= Chef::ServerAPI.new(
         Chef::Config[:chef_server_url],
-        Chef::Config[:node_name],
-        Chef::Config[:client_key],
+        client_name: Chef::Config[:node_name],
+        signing_key_filename: Chef::Config[:client_key],
         validate_utf8: false,
       )
     end
 
     # Set the name of this Node, or return the current name.
-    def name(arg=nil)
+    def name(arg = nil)
       if arg != nil
         validate(
-                 {:name => arg },
-                 {:name => { :kind_of => String,
-                     :cannot_be => :blank,
-                     :regex => /^[\-[:alnum:]_:.]+$/}
-                 })
+                 { :name => arg },
+                 { :name => { :kind_of => String,
+                              :cannot_be => :blank,
+                              :regex => /^[\-[:alnum:]_:.]+$/ }
+                 },)
         @name = arg
       else
         @name
       end
     end
 
-    def chef_environment(arg=nil)
+    def chef_environment(arg = nil)
       set_or_return(
         :chef_environment,
         arg,
@@ -146,9 +145,9 @@ class Chef
     #
     # @param arg [String] the new policy_name value
     # @return [String] the current policy_name, or the one you just set
-    def policy_name(arg=NULL_ARG)
+    def policy_name(arg = NULL_ARG)
       return @policy_name if arg.equal?(NULL_ARG)
-      validate({policy_name: arg}, { policy_name: { kind_of: [ String, NilClass ], regex: /^[\-:.[:alnum:]_]+$/ } })
+      validate({ policy_name: arg }, { policy_name: { kind_of: [ String, NilClass ], regex: /^[\-:.[:alnum:]_]+$/ } })
       @policy_name = arg
     end
 
@@ -168,9 +167,9 @@ class Chef
     #
     # @param arg [String] the new policy_group value
     # @return [String] the current policy_group, or the one you just set
-    def policy_group(arg=NULL_ARG)
+    def policy_group(arg = NULL_ARG)
       return @policy_group if arg.equal?(NULL_ARG)
-      validate({policy_group: arg}, { policy_group: { kind_of: [ String, NilClass ], regex: /^[\-:.[:alnum:]_]+$/ } })
+      validate({ policy_group: arg }, { policy_group: { kind_of: [ String, NilClass ], regex: /^[\-:.[:alnum:]_]+$/ } })
       @policy_group = arg
     end
 
@@ -366,13 +365,13 @@ class Chef
       normal_attrs_to_merge = consume_run_list(attrs)
       normal_attrs_to_merge = consume_chef_environment(normal_attrs_to_merge)
       Chef::Log.debug("Applying attributes from json file")
-      self.normal_attrs = Chef::Mixin::DeepMerge.merge(normal_attrs,normal_attrs_to_merge)
+      self.normal_attrs = Chef::Mixin::DeepMerge.merge(normal_attrs, normal_attrs_to_merge)
       self.tags # make sure they're defined
     end
 
     # Lazy initializer for tags attribute
     def tags
-      normal[:tags] = [] unless attribute?(:tags)
+      normal[:tags] = Array(normal[:tags])
       normal[:tags]
     end
 
@@ -391,7 +390,7 @@ class Chef
         if attrs.key?("recipes") || attrs.key?("run_list")
           raise Chef::Exceptions::AmbiguousRunlistSpecification, "please set the node's run list using the 'run_list' attribute only."
         end
-        Chef::Log.info("Setting the run_list to #{new_run_list.to_s} from CLI options")
+        Chef::Log.info("Setting the run_list to #{new_run_list} from CLI options")
         run_list(new_run_list)
       end
       attrs
@@ -434,7 +433,7 @@ class Chef
     # run_list is mutated? Or perhaps do something smarter like
     # on-demand generation of default_attrs and override_attrs,
     # invalidated only when run_list is mutated?
-    def expand!(data_source = 'server')
+    def expand!(data_source = "server")
       expansion = run_list.expand(chef_environment, data_source)
       raise Chef::Exceptions::MissingRole, expansion if expansion.errors?
 
@@ -453,7 +452,7 @@ class Chef
     # passed in, which came from roles.
     def apply_expansion_attributes(expansion)
       loaded_environment = if chef_environment == "_default"
-                             Chef::Environment.new.tap {|e| e.name("_default")}
+                             Chef::Environment.new.tap { |e| e.name("_default") }
                            else
                              Chef::Environment.load(chef_environment)
                            end
@@ -501,14 +500,14 @@ class Chef
       result = {
         "name" => name,
         "chef_environment" => chef_environment,
-        'json_class' => self.class.name,
+        "json_class" => self.class.name,
         "automatic" => attributes.automatic,
         "normal" => attributes.normal,
         "chef_type" => "node",
         "default" => attributes.combined_default,
         "override" => attributes.combined_override,
         #Render correctly for run_list items so malformed json does not result
-        "run_list" => @primary_runlist.run_list.map { |item| item.to_s }
+        "run_list" => @primary_runlist.run_list.map { |item| item.to_s },
       }
       # Chef Server rejects node JSON with extra keys; prior to 12.3,
       # "policy_name" and "policy_group" are unknown; after 12.3 they are
@@ -533,6 +532,12 @@ class Chef
 
     # Create a Chef::Node from JSON
     def self.json_create(o)
+      Chef.log_deprecation("Auto inflation of JSON data is deprecated. Please use Chef::Node#from_hash")
+      from_hash(o)
+    end
+
+    def self.from_hash(o)
+      return o if o.kind_of? Chef::Node
       node = new
       node.name(o["name"])
       node.chef_environment(o["chef_environment"])
@@ -546,7 +551,7 @@ class Chef
 
       if o.has_key?("run_list")
         node.run_list.reset!(o["run_list"])
-      else
+      elsif o.has_key?("recipes")
         o["recipes"].each { |r| node.recipes << r }
       end
 
@@ -556,32 +561,33 @@ class Chef
       node
     end
 
-    def self.list_by_environment(environment, inflate=false)
+    def self.list_by_environment(environment, inflate = false)
       if inflate
         response = Hash.new
-        Chef::Search::Query.new.search(:node, "chef_environment:#{environment}") {|n| response[n.name] = n unless n.nil?}
+        Chef::Search::Query.new.search(:node, "chef_environment:#{environment}") { |n| response[n.name] = n unless n.nil? }
         response
       else
-        Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("environments/#{environment}/nodes")
+        Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("environments/#{environment}/nodes")
       end
     end
 
-    def self.list(inflate=false)
+    def self.list(inflate = false)
       if inflate
         response = Hash.new
         Chef::Search::Query.new.search(:node) do |n|
+          n = Chef::Node.from_hash(n)
           response[n.name] = n unless n.nil?
         end
         response
       else
-        Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("nodes")
+        Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("nodes")
       end
     end
 
     def self.find_or_create(node_name)
       load(node_name)
     rescue Net::HTTPServerException => e
-      raise unless e.response.code == '404'
+      raise unless e.response.code == "404"
       node = build(node_name)
       node.create
     end
@@ -595,12 +601,12 @@ class Chef
 
     # Load a node by name
     def self.load(name)
-      Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("nodes/#{name}")
+      from_hash(Chef::ServerAPI.new(Chef::Config[:chef_server_url]).get("nodes/#{name}"))
     end
 
     # Remove this node via the REST API
     def destroy
-      chef_server_rest.delete_rest("nodes/#{name}")
+      chef_server_rest.delete("nodes/#{name}")
     end
 
     # Save this node via the REST API
@@ -611,11 +617,11 @@ class Chef
         if Chef::Config[:why_run]
           Chef::Log.warn("In why-run mode, so NOT performing node save.")
         else
-          chef_server_rest.put_rest("nodes/#{name}", data_for_save)
+          chef_server_rest.put("nodes/#{name}", data_for_save)
         end
       rescue Net::HTTPServerException => e
         if e.response.code == "404"
-          chef_server_rest.post_rest("nodes", data_for_save)
+          chef_server_rest.post("nodes", data_for_save)
         # Chef Server before 12.3 rejects node JSON with 'policy_name' or
         # 'policy_group' keys, but 'policy_name' will be detected first.
         # Backcompat can be removed in 13.0
@@ -630,14 +636,14 @@ class Chef
 
     # Create the node via the REST API
     def create
-      chef_server_rest.post_rest("nodes", data_for_save)
+      chef_server_rest.post("nodes", data_for_save)
       self
     rescue Net::HTTPServerException => e
       # Chef Server before 12.3 rejects node JSON with 'policy_name' or
       # 'policy_group' keys, but 'policy_name' will be detected first.
       # Backcompat can be removed in 13.0
       if e.response.code == "400" && e.response.body.include?("Invalid key policy_name")
-        chef_server_rest.post_rest("nodes", data_for_save_without_policyfile_attrs)
+        chef_server_rest.post("nodes", data_for_save_without_policyfile_attrs)
       else
         raise
       end
@@ -649,7 +655,7 @@ class Chef
 
     def ==(other)
       if other.kind_of?(self.class)
-         self.name == other.name
+        self.name == other.name
       else
         false
       end
@@ -664,10 +670,10 @@ class Chef
     def save_without_policyfile_attrs
       trimmed_data = data_for_save_without_policyfile_attrs
 
-      chef_server_rest.put_rest("nodes/#{name}", trimmed_data)
+      chef_server_rest.put("nodes/#{name}", trimmed_data)
     rescue Net::HTTPServerException => e
       raise e unless e.response.code == "404"
-      chef_server_rest.post_rest("nodes", trimmed_data)
+      chef_server_rest.post("nodes", trimmed_data)
     end
 
     def data_for_save_without_policyfile_attrs

data/lib/chef/node/attribute.rb

@@ -1,7 +1,7 @@
 #--
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: AJ Christensen (<aj@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: AJ Christensen (<aj@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");
@@ -17,10 +17,10 @@
 # limitations under the License.
 #
 
-require 'chef/node/immutable_collections'
-require 'chef/node/attribute_collections'
-require 'chef/mixin/deep_merge'
-require 'chef/log'
+require "chef/node/immutable_collections"
+require "chef/node/attribute_collections"
+require "chef/mixin/deep_merge"
+require "chef/log"
 
 class Chef
   class Node
@@ -48,21 +48,21 @@ class Chef
         :@role_override,
         :@env_override,
         :@force_override,
-        :@automatic
+        :@automatic,
       ].freeze
 
       DEFAULT_COMPONENTS = [
         :@default,
         :@env_default,
         :@role_default,
-        :@force_default
+        :@force_default,
       ]
 
       OVERRIDE_COMPONENTS = [
         :@override,
         :@role_override,
         :@env_override,
-        :@force_override
+        :@force_override,
       ]
 
       [:all?,
@@ -144,34 +144,34 @@ class Chef
        end
 
        # return the cookbook level default attribute component
-       attr_reader :default
+      attr_reader :default
 
        # return the role level default attribute component
-       attr_reader :role_default
+      attr_reader :role_default
 
        # return the environment level default attribute component
-       attr_reader :env_default
+      attr_reader :env_default
 
        # return the force_default level attribute component
-       attr_reader :force_default
+      attr_reader :force_default
 
        # return the "normal" level attribute component
-       attr_reader :normal
+      attr_reader :normal
 
        # return the cookbook level override attribute component
-       attr_reader :override
+      attr_reader :override
 
        # return the role level override attribute component
-       attr_reader :role_override
+      attr_reader :role_override
 
        # return the enviroment level override attribute component
-       attr_reader :env_override
+      attr_reader :env_override
 
        # return the force override level attribute component
-       attr_reader :force_override
+      attr_reader :force_override
 
        # return the automatic level attribute component
-       attr_reader :automatic
+      attr_reader :automatic
 
        # This is used to track the top level key as we descend through method chaining into
        # a precedence level (e.g. node.default['foo']['bar']['baz']= results in 'foo' here).  We
@@ -179,36 +179,36 @@ class Chef
        # that we can invalidate the whole top-level deep merge cache for the top-level key.  It is
        # the responsibility of the accessor on the Chef::Node object to reset this to nil, and then
        # the first VividMash#[] call can ||= and set this to the first key we encounter.
-       attr_accessor :top_level_breadcrumb
+      attr_accessor :top_level_breadcrumb
 
        # 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
+      attr_accessor :deep_merge_cache
 
-       def initialize(normal, default, override, automatic)
-         @set_unless_present = false
+      def initialize(normal, default, override, automatic)
+        @set_unless_present = false
 
-         @default = VividMash.new(self, default)
-         @env_default = VividMash.new(self, {})
-         @role_default = VividMash.new(self, {})
-         @force_default = VividMash.new(self, {})
+        @default = VividMash.new(self, default)
+        @env_default = VividMash.new(self, {})
+        @role_default = VividMash.new(self, {})
+        @force_default = VividMash.new(self, {})
 
-         @normal = VividMash.new(self, normal)
+        @normal = VividMash.new(self, normal)
 
-         @override = VividMash.new(self, override)
-         @role_override = VividMash.new(self, {})
-         @env_override = VividMash.new(self, {})
-         @force_override = VividMash.new(self, {})
+        @override = VividMash.new(self, override)
+        @role_override = VividMash.new(self, {})
+        @env_override = VividMash.new(self, {})
+        @force_override = VividMash.new(self, {})
 
-         @automatic = VividMash.new(self, automatic)
+        @automatic = VividMash.new(self, automatic)
 
-         @merged_attributes = nil
-         @combined_override = nil
-         @combined_default = nil
-         @top_level_breadcrumb = nil
-         @deep_merge_cache = {}
-       end
+        @merged_attributes = nil
+        @combined_override = nil
+        @combined_default = nil
+        @top_level_breadcrumb = nil
+        @deep_merge_cache = {}
+      end
 
        # Debug what's going on with an attribute. +args+ is a path spec to the
        # attribute you're interested in. For example, to debug where the value
@@ -221,195 +221,195 @@ class Chef
        # the component, such as role default, normal, etc. and value is the
        # attribute value set at that precedence level. If there is no value at
        # that precedence level, +value+ will be the symbol +:not_present+.
-       def debug_value(*args)
-         components = COMPONENTS.map do |component|
-           ivar = instance_variable_get(component)
-           value = args.inject(ivar) do |so_far, key|
-             if so_far == :not_present
-               :not_present
-             elsif so_far.has_key?(key)
-               so_far[key]
-             else
-               :not_present
-             end
-           end
-           [component.to_s.sub(/^@/,""), value]
-         end
-         [["set_unless_enabled?", @set_unless_present]] + components
-       end
+      def debug_value(*args)
+        components = COMPONENTS.map do |component|
+          ivar = instance_variable_get(component)
+          value = args.inject(ivar) do |so_far, key|
+            if so_far == :not_present
+              :not_present
+            elsif so_far.has_key?(key)
+              so_far[key]
+            else
+              :not_present
+            end
+          end
+          [component.to_s.sub(/^@/, ""), value]
+        end
+        [["set_unless_enabled?", @set_unless_present]] + components
+      end
 
        # Enables or disables `||=`-like attribute setting. See, e.g., Node#set_unless
-       def set_unless_value_present=(setting)
-         @set_unless_present = setting
-       end
+      def set_unless_value_present=(setting)
+        @set_unless_present = setting
+      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 = {}
-         else
-           deep_merge_cache.delete(path.to_s)
-         end
-       end
+      def reset_cache(path = nil)
+        if path.nil?
+          @deep_merge_cache = {}
+        else
+          deep_merge_cache.delete(path.to_s)
+        end
+      end
 
-       alias :reset :reset_cache
+      alias :reset :reset_cache
 
        # Set the cookbook level default attribute component to +new_data+.
-       def default=(new_data)
-         reset
-         @default = VividMash.new(self, new_data)
-       end
+      def default=(new_data)
+        reset
+        @default = VividMash.new(self, new_data)
+      end
 
        # Set the role level default attribute component to +new_data+
-       def role_default=(new_data)
-         reset
-         @role_default = VividMash.new(self, new_data)
-       end
+      def role_default=(new_data)
+        reset
+        @role_default = VividMash.new(self, new_data)
+      end
 
        # Set the environment level default attribute component to +new_data+
-       def env_default=(new_data)
-         reset
-         @env_default = VividMash.new(self, new_data)
-       end
+      def env_default=(new_data)
+        reset
+        @env_default = VividMash.new(self, new_data)
+      end
 
        # Set the force_default (+default!+) level attributes to +new_data+
-       def force_default=(new_data)
-         reset
-         @force_default = VividMash.new(self, new_data)
-       end
+      def force_default=(new_data)
+        reset
+        @force_default = VividMash.new(self, new_data)
+      end
 
        # Set the normal level attribute component to +new_data+
-       def normal=(new_data)
-         reset
-         @normal = VividMash.new(self, new_data)
-       end
+      def normal=(new_data)
+        reset
+        @normal = VividMash.new(self, new_data)
+      end
 
        # Set the cookbook level override attribute component to +new_data+
-       def override=(new_data)
-         reset
-         @override = VividMash.new(self, new_data)
-       end
+      def override=(new_data)
+        reset
+        @override = VividMash.new(self, new_data)
+      end
 
        # Set the role level override attribute component to +new_data+
-       def role_override=(new_data)
-         reset
-         @role_override = VividMash.new(self, new_data)
-       end
+      def role_override=(new_data)
+        reset
+        @role_override = VividMash.new(self, new_data)
+      end
 
        # Set the environment level override attribute component to +new_data+
-       def env_override=(new_data)
-         reset
-         @env_override = VividMash.new(self, new_data)
-       end
+      def env_override=(new_data)
+        reset
+        @env_override = VividMash.new(self, new_data)
+      end
 
-       def force_override=(new_data)
-         reset
-         @force_override = VividMash.new(self, new_data)
-       end
+      def force_override=(new_data)
+        reset
+        @force_override = VividMash.new(self, new_data)
+      end
 
-       def automatic=(new_data)
-         reset
-         @automatic = VividMash.new(self, new_data)
-       end
+      def automatic=(new_data)
+        reset
+        @automatic = VividMash.new(self, new_data)
+      end
 
        #
        # Deleting attributes
        #
 
        # clears attributes from all precedence levels
-       def rm(*args)
-         reset(args[0])
-         # just easier to compute our retval, rather than collect+merge sub-retvals
-         ret = args.inject(merged_attributes) do |attr, arg|
-           if attr.nil? || !attr.respond_to?(:[])
-             nil
-           else
-             begin
-               attr[arg]
-             rescue TypeError
-               raise TypeError, "Wrong type in index of attribute (did you use a Hash index on an Array?)"
-             end
-           end
-         end
-         rm_default(*args)
-         rm_normal(*args)
-         rm_override(*args)
-         ret
-       end
+      def rm(*args)
+        reset(args[0])
+        # just easier to compute our retval, rather than collect+merge sub-retvals
+        ret = args.inject(merged_attributes) do |attr, arg|
+          if attr.nil? || !attr.respond_to?(:[])
+            nil
+          else
+            begin
+              attr[arg]
+            rescue TypeError
+              raise TypeError, "Wrong type in index of attribute (did you use a Hash index on an Array?)"
+            end
+          end
+        end
+        rm_default(*args)
+        rm_normal(*args)
+        rm_override(*args)
+        ret
+      end
 
        # does <level>['foo']['bar'].delete('baz')
-       def remove_from_precedence_level(level, *args, key)
-         multimash = level.element(*args)
-         multimash.nil? ? nil : multimash.delete(key)
-       end
+      def remove_from_precedence_level(level, *args, key)
+        multimash = level.element(*args)
+        multimash.nil? ? nil : multimash.delete(key)
+      end
 
-       private :remove_from_precedence_level
+      private :remove_from_precedence_level
 
        # clears attributes from all default precedence levels
        #
        # equivalent to: force_default!['foo']['bar'].delete('baz')
-       def rm_default(*args)
-         reset(args[0])
-         remove_from_precedence_level(force_default!(autovivify: false), *args)
-       end
+      def rm_default(*args)
+        reset(args[0])
+        remove_from_precedence_level(force_default!(autovivify: false), *args)
+      end
 
        # clears attributes from normal precedence
        #
        # equivalent to: normal!['foo']['bar'].delete('baz')
-       def rm_normal(*args)
-         reset(args[0])
-         remove_from_precedence_level(normal!(autovivify: false), *args)
-       end
+      def rm_normal(*args)
+        reset(args[0])
+        remove_from_precedence_level(normal!(autovivify: false), *args)
+      end
 
        # clears attributes from all override precedence levels
        #
        # equivalent to: force_override!['foo']['bar'].delete('baz')
-       def rm_override(*args)
-         reset(args[0])
-         remove_from_precedence_level(force_override!(autovivify: false), *args)
-       end
+      def rm_override(*args)
+        reset(args[0])
+        remove_from_precedence_level(force_override!(autovivify: false), *args)
+      end
 
        #
        # Replacing attributes without merging
        #
 
        # sets default attributes without merging
-       def default!(opts={})
-         # FIXME: do not flush whole cache
-         reset
-         MultiMash.new(self, @default, [], opts)
-       end
+      def default!(opts = {})
+        # FIXME: do not flush whole cache
+        reset
+        MultiMash.new(self, @default, [], opts)
+      end
 
        # sets normal attributes without merging
-       def normal!(opts={})
-         # FIXME: do not flush whole cache
-         reset
-         MultiMash.new(self, @normal, [], opts)
-       end
+      def normal!(opts = {})
+        # FIXME: do not flush whole cache
+        reset
+        MultiMash.new(self, @normal, [], opts)
+      end
 
        # sets override attributes without merging
-       def override!(opts={})
-         # FIXME: do not flush whole cache
-         reset
-         MultiMash.new(self, @override, [], opts)
-       end
+      def override!(opts = {})
+        # FIXME: do not flush whole cache
+        reset
+        MultiMash.new(self, @override, [], opts)
+      end
 
        # clears from all default precedence levels and then sets force_default
-       def force_default!(opts={})
-         # FIXME: do not flush whole cache
-         reset
-         MultiMash.new(self, @force_default, [@default, @env_default, @role_default], opts)
-       end
+      def force_default!(opts = {})
+        # FIXME: do not flush whole cache
+        reset
+        MultiMash.new(self, @force_default, [@default, @env_default, @role_default], opts)
+      end
 
        # clears from all override precedence levels and then sets force_override
-       def force_override!(opts={})
-         # FIXME: do not flush whole cache
-         reset
-         MultiMash.new(self, @force_override, [@override, @env_override, @role_override], opts)
-       end
+      def force_override!(opts = {})
+        # FIXME: do not flush whole cache
+        reset
+        MultiMash.new(self, @force_override, [@override, @env_override, @role_override], opts)
+      end
 
        #
        # Accessing merged attributes.
@@ -419,75 +419,75 @@ class Chef
        # all of node['foo'] even if the user only requires node['foo']['bar']['baz'].
        #
 
-       def merged_attributes(*path)
-        # immutablize(
-           merge_all(path)
-        # )
-       end
-
-       def combined_override(*path)
-         immutablize(merge_overrides(path))
-       end
-
-       def combined_default(*path)
-         immutablize(merge_defaults(path))
-       end
-
-       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
-
-       def []=(key, value)
-         raise Exceptions::ImmutableAttributeModification
-       end
-
-       def has_key?(key)
-         COMPONENTS.any? do |component_ivar|
-           instance_variable_get(component_ivar).has_key?(key)
-         end
-       end
-
-       alias :attribute? :has_key?
-       alias :member? :has_key?
-       alias :include? :has_key?
-       alias :key? :has_key?
-
-       alias :each_attribute :each
-
-       def method_missing(symbol, *args)
-         if args.empty?
-           if key?(symbol)
-             self[symbol]
-           else
-             raise NoMethodError, "Undefined method or attribute `#{symbol}' on `node'"
-           end
-         elsif symbol.to_s =~ /=$/
-           key_to_set = symbol.to_s[/^(.+)=$/, 1]
-           self[key_to_set] = (args.length == 1 ? args[0] : args)
-         else
-           raise NoMethodError, "Undefined node attribute or method `#{symbol}' on `node'"
-         end
-       end
-
-       def to_s
-         merged_attributes.to_s
-       end
-
-       def inspect
-         "#<#{self.class} " << (COMPONENTS + [:@merged_attributes, :@properties]).map{|iv|
-           "#{iv}=#{instance_variable_get(iv).inspect}"
-         }.join(', ') << ">"
-       end
-
-       def set_unless?
-         @set_unless_present
-       end
+      def merged_attributes(*path)
+       # immutablize(
+        merge_all(path)
+       # )
+      end
+
+      def combined_override(*path)
+        immutablize(merge_overrides(path))
+      end
+
+      def combined_default(*path)
+        immutablize(merge_defaults(path))
+      end
+
+      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
+
+      def []=(key, value)
+        raise Exceptions::ImmutableAttributeModification
+      end
+
+      def has_key?(key)
+        COMPONENTS.any? do |component_ivar|
+          instance_variable_get(component_ivar).has_key?(key)
+        end
+      end
+
+      alias :attribute? :has_key?
+      alias :member? :has_key?
+      alias :include? :has_key?
+      alias :key? :has_key?
+
+      alias :each_attribute :each
+
+      def method_missing(symbol, *args)
+        if args.empty?
+          if key?(symbol)
+            self[symbol]
+          else
+            raise NoMethodError, "Undefined method or attribute `#{symbol}' on `node'"
+          end
+        elsif symbol.to_s =~ /=$/
+          key_to_set = symbol.to_s[/^(.+)=$/, 1]
+          self[key_to_set] = (args.length == 1 ? args[0] : args)
+        else
+          raise NoMethodError, "Undefined node attribute or method `#{symbol}' on `node'"
+        end
+      end
+
+      def to_s
+        merged_attributes.to_s
+      end
+
+      def inspect
+        "#<#{self.class} " << (COMPONENTS + [:@merged_attributes, :@properties]).map {|iv|
+          "#{iv}=#{instance_variable_get(iv).inspect}"
+        }.join(", ") << ">"
+      end
+
+      def set_unless?
+        @set_unless_present
+      end
 
        private
 
@@ -501,32 +501,32 @@ class Chef
        # raise any TypeError if it attempts to apply a hash key to an Integer/String/TrueClass, and just returns
        # nil in that case.
        #
-       def apply_path(component, path)
-         path ||= []
-         path.inject(component) do |val, path_arg|
-           if val.respond_to?(:[])
-             # Have an Array-like or Hash-like thing
-             if !val.respond_to?(:has_key?)
-               # Have an Array-like thing
-               val[path_arg]
-             elsif val.has_key?(path_arg)
-               # Hash-like thing (must check has_key? first to protect against Autovivification)
-               val[path_arg]
-             else
-               nil
-             end
-           else
-             nil
-           end
-         end
-       end
+      def apply_path(component, path)
+        path ||= []
+        path.inject(component) do |val, path_arg|
+          if val.respond_to?(:[])
+            # Have an Array-like or Hash-like thing
+            if !val.respond_to?(:has_key?)
+              # Have an Array-like thing
+              val[path_arg]
+            elsif val.has_key?(path_arg)
+              # Hash-like thing (must check has_key? first to protect against Autovivification)
+              val[path_arg]
+            else
+              nil
+            end
+          else
+            nil
+          end
+        end
+      end
 
        # For elements like Fixnums, true, nil...
-       def safe_dup(e)
-         e.dup
-       rescue TypeError
-         e
-       end
+      def safe_dup(e)
+        e.dup
+      rescue TypeError
+        e
+      end
 
        # Deep merge all attribute levels using hash-only merging between different precidence
        # levels (so override arrays completely replace arrays set at any default level).
@@ -535,24 +535,24 @@ class Chef
        #
        # @param path [Array] Array of args to method chain to descend into the node object
        # @return [attr] Deep Merged values (may be VividMash, Hash, Array, etc) from the node object
-       def merge_all(path)
-         components = [
-           merge_defaults(path),
-           apply_path(@normal, path),
-           merge_overrides(path),
-           apply_path(@automatic, path),
-         ]
-
-         components.map! do |component|
-           safe_dup(component)
-         end
+      def merge_all(path)
+        components = [
+          merge_defaults(path),
+          apply_path(@normal, path),
+          merge_overrides(path),
+          apply_path(@automatic, path),
+        ]
 
-         return nil if components.compact.empty?
+        components.map! do |component|
+          safe_dup(component)
+        end
 
-         components.inject(ImmutableMash.new({})) do |merged, component|
-           Chef::Mixin::DeepMerge.hash_only_merge!(merged, component)
-         end
-       end
+        return nil if components.compact.empty?
+
+        components.inject(ImmutableMash.new({})) do |merged, component|
+          Chef::Mixin::DeepMerge.hash_only_merge!(merged, component)
+        end
+      end
 
        # Deep merge the default attribute levels with array merging.
        #
@@ -560,12 +560,12 @@ class Chef
        #
        # @param path [Array] Array of args to method chain to descend into the node object
        # @return [attr] Deep Merged values (may be VividMash, Hash, Array, etc) from the node object
-       def merge_defaults(path)
-         DEFAULT_COMPONENTS.inject(nil) do |merged, component_ivar|
-           component_value = apply_path(instance_variable_get(component_ivar), path)
-           Chef::Mixin::DeepMerge.deep_merge(component_value, merged)
-         end
-       end
+      def merge_defaults(path)
+        DEFAULT_COMPONENTS.inject(nil) do |merged, component_ivar|
+          component_value = apply_path(instance_variable_get(component_ivar), path)
+          Chef::Mixin::DeepMerge.deep_merge(component_value, merged)
+        end
+      end
 
        # Deep merge the override attribute levels with array merging.
        #
@@ -573,12 +573,12 @@ class Chef
        #
        # @param path [Array] Array of args to method chain to descend into the node object
        # @return [attr] Deep Merged values (may be VividMash, Hash, Array, etc) from the node object
-       def merge_overrides(path)
-         OVERRIDE_COMPONENTS.inject(nil) do |merged, component_ivar|
-           component_value = apply_path(instance_variable_get(component_ivar), path)
-           Chef::Mixin::DeepMerge.deep_merge(component_value, merged)
-         end
-       end
+      def merge_overrides(path)
+        OVERRIDE_COMPONENTS.inject(nil) do |merged, component_ivar|
+          component_value = apply_path(instance_variable_get(component_ivar), path)
+          Chef::Mixin::DeepMerge.deep_merge(component_value, merged)
+        end
+      end
 
     end