microwave 0.1006.33 → 1.0.0

data/lib/chef/nil_argument.rb

@@ -1,3 +0,0 @@
-class Chef
-  NIL_ARGUMENT = Object.new
-end

data/lib/chef/node.rb

@@ -1,440 +0,0 @@
-#
-# 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.
-# 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.
-#
-
-require 'forwardable'
-require 'chef/config'
-require 'chef/cookbook/cookbook_collection'
-require 'chef/nil_argument'
-require 'chef/mixin/check_helper'
-require 'chef/mixin/params_validate'
-require 'chef/mixin/from_file'
-require 'chef/mixin/language_include_attribute'
-require 'chef/mixin/deep_merge'
-require 'chef/environment'
-require 'chef/run_list'
-require 'chef/node/attribute'
-require 'chef/mash'
-require 'chef/json_compat'
-
-class Chef
-  class Node
-
-    extend Forwardable
-
-    def_delegators :construct_attributes, :keys, :each_key, :each_value, :key?, :has_key?
-
-    attr_accessor :recipe_list, :run_state, :run_list
-    attr_accessor :override_attrs, :default_attrs, :normal_attrs, :automatic_attrs
-
-    # TODO: 5/18/2010 cw/timh. cookbook_collection should be removed
-    # from here and for any place it's needed, it should be accessed
-    # through a Chef::RunContext
-    attr_accessor :cookbook_collection
-
-    include Chef::Mixin::CheckHelper
-    include Chef::Mixin::FromFile
-    include Chef::Mixin::ParamsValidate
-    include Chef::Mixin::LanguageIncludeAttribute
-
-    # Create a new Chef::Node object.
-    def initialize()
-      @name = nil
-
-      @chef_environment = '_default'
-      @normal_attrs = Mash.new
-      @override_attrs = Mash.new
-      @default_attrs = Mash.new
-      @automatic_attrs = Mash.new
-      @run_list = Chef::RunList.new
-
-      @run_state = {
-        :template_cache => Hash.new,
-        :seen_recipes => Hash.new,
-        :seen_attributes => Hash.new
-      }
-      # TODO: 5/20/2010 need this here as long as other objects try to access
-      # the cookbook collection via Node, otherwise get NoMethodError on nil.
-      @cookbook_collection = CookbookCollection.new
-    end
-
-    # Used by DSL
-    def node
-      self
-    end
-
-    # Find a recipe for this Chef::Node by fqdn.  Will search first for
-    # Chef::Config["node_path"]/fqdn.rb, then hostname.rb, then default.rb.
-    #
-    # Returns a new Chef::Node object.
-    #
-    # Raises an ArgumentError if it cannot find the node.
-    def find_file(fqdn)
-      host_parts = fqdn.split(".")
-      hostname = host_parts[0]
-
-      [fqdn, hostname, "default"].each { |fname|
-       node_file = File.join(Chef::Config[:node_path], "#{fname.to_s}.rb")
-       return self.from_file(node_file) if File.exists?(node_file)
-     }
-
-      raise ArgumentError, "Cannot find a node matching #{fqdn}, not even with default.rb!"
-    end
-
-    # Set the name of this Node, or return the current name.
-    def name(arg=nil)
-      if arg != nil
-        validate(
-                 {:name => arg },
-                 {:name => { :kind_of => String,
-                     :cannot_be => :blank,
-                     :regex => /^[\-[:alnum:]_:.]+$/}
-                 })
-        @name = arg
-      else
-        @name
-      end
-    end
-
-    def chef_environment(arg=nil)
-      set_or_return(
-        :chef_environment,
-        arg,
-        { :regex => /^[\-[:alnum:]_]+$/, :kind_of => String }
-      )
-    end
-
-    # Used by the DSL
-    def attribute
-      construct_attributes
-    end
-
-    def construct_attributes
-      Chef::Node::Attribute.new(normal_attrs, default_attrs, override_attrs, automatic_attrs)
-    end
-
-    def attribute=(value)
-      self.normal_attrs = value
-    end
-
-    # Return an attribute of this node.  Returns nil if the attribute is not found.
-    def [](attrib)
-      construct_attributes[attrib]
-    end
-
-    # Set an attribute of this node
-    def []=(attrib, value)
-      construct_attributes[attrib] = value
-    end
-
-    def store(attrib, value)
-      self[attrib] = value
-    end
-
-    # Set a normal attribute of this node, but auto-vivifiy any Mashes that
-    # might be missing
-    def normal
-      attrs = construct_attributes
-      attrs.set_type = :normal
-      attrs.auto_vivifiy_on_read = true
-      attrs
-    end
-
-    alias_method :set, :normal
-
-    # Set a normal attribute of this node, auto-vivifiying any mashes that are
-    # missing, but if the final value already exists, don't set it
-    def normal_unless
-      attrs = construct_attributes
-      attrs.set_type = :normal
-      attrs.auto_vivifiy_on_read = true
-      attrs.set_unless_value_present = true
-      attrs
-    end
-    alias_method :set_unless, :normal_unless
-
-    # Set a default of this node, but auto-vivifiy any Mashes that might
-    # be missing
-    def default
-      attrs = construct_attributes
-      attrs.set_type = :default
-      attrs.auto_vivifiy_on_read = true
-      attrs
-    end
-
-    # Set a default attribute of this node, auto-vivifiying any mashes that are
-    # missing, but if the final value already exists, don't set it
-    def default_unless
-      attrs = construct_attributes
-      attrs.set_type = :default
-      attrs.auto_vivifiy_on_read = true
-      attrs.set_unless_value_present = true
-      attrs
-    end
-
-    # Set an override attribute of this node, but auto-vivifiy any Mashes that
-    # might be missing
-    def override
-      attrs = construct_attributes
-      attrs.set_type = :override
-      attrs.auto_vivifiy_on_read = true
-      attrs
-    end
-
-    # Set an override attribute of this node, auto-vivifiying any mashes that
-    # are missing, but if the final value already exists, don't set it
-    def override_unless
-      attrs = construct_attributes
-      attrs.set_type = :override
-      attrs.auto_vivifiy_on_read = true
-      attrs.set_unless_value_present = true
-      attrs
-    end
-
-    # Return true if this Node has a given attribute, false if not.  Takes either a symbol or
-    # a string.
-    #
-    # Only works on the top level. Preferred way is to use the normal [] style
-    # lookup and call attribute?()
-    def attribute?(attrib)
-      construct_attributes.attribute?(attrib)
-    end
-
-    # Yield each key of the top level to the block.
-    def each(&block)
-      construct_attributes.each(&block)
-    end
-
-    # Iterates over each attribute, passing the attribute and value to the block.
-    def each_attribute(&block)
-      construct_attributes.each_attribute(&block)
-    end
-
-    # Encouraged to only get used for lookups - while you can do sets from here, it's not as explicit
-    # as using the normal/default/override interface.
-    def method_missing(symbol, *args)
-      attrs = construct_attributes
-      attrs.send(symbol, *args)
-    end
-
-    # Returns true if this Node expects a given recipe, false if not.
-    #
-    # First, the run list is consulted to see whether the recipe is
-    # explicitly included. If it's not there, it looks in
-    # run_state[:seen_recipes], which is populated by include_recipe
-    # statements in the DSL (and thus would not be in the run list).
-    #
-    # NOTE: It's used by cookbook authors
-    def recipe?(recipe_name)
-      run_list.include?(recipe_name) || run_state[:seen_recipes].include?(recipe_name)
-    end
-
-    # Returns true if this Node expects a given role, false if not.
-    def role?(role_name)
-      run_list.include?("role[#{role_name}]")
-    end
-
-    # Returns an Array of roles and recipes, in the order they will be applied.
-    # If you call it with arguments, they will become the new list of roles and recipes.
-    def run_list(*args)
-      args.length > 0 ? @run_list.reset!(args) : @run_list
-    end
-
-    # Returns true if this Node expects a given role, false if not.
-    def run_list?(item)
-      run_list.detect { |r| r == item } ? true : false
-    end
-
-    # Consume data from ohai and Attributes provided as JSON on the command line.
-    def consume_external_attrs(ohai_data, json_cli_attrs)
-      Chef::Log.debug("Extracting run list from JSON attributes provided on command line")
-      consume_attributes(json_cli_attrs)
-
-      @automatic_attrs = ohai_data
-
-      platform, version = Chef::Platform.find_platform_and_version(self)
-      Chef::Log.debug("Platform is #{platform} version #{version}")
-      @automatic_attrs[:platform] = platform
-      @automatic_attrs[:platform_version] = version
-    end
-
-    # Consumes the combined run_list and other attributes in +attrs+
-    def consume_attributes(attrs)
-      normal_attrs_to_merge = consume_run_list(attrs)
-      Chef::Log.debug("Applying attributes from json file")
-      @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
-      self[:tags] = [] unless attribute?(:tags)
-      self[:tags]
-    end
-
-    # Extracts the run list from +attrs+ and applies it. Returns the remaining attributes
-    def consume_run_list(attrs)
-      attrs = attrs ? attrs.dup : {}
-      if new_run_list = attrs.delete("recipes") || attrs.delete("run_list")
-        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.inspect} from JSON")
-        run_list(new_run_list)
-      end
-      attrs
-    end
-
-    # Clear defaults and overrides, so that any deleted attributes
-    # between runs are still gone.
-    def reset_defaults_and_overrides
-      @default_attrs = Mash.new
-      @override_attrs = Mash.new
-    end
-
-    # Expands the node's run list and sets the default and override
-    # attributes. Also applies stored attributes (from json provided
-    # on the command line)
-    #
-    # Returns the fully-expanded list of recipes, a RunListExpansion.
-    #
-    #--
-    # TODO: timh/cw, 5-14-2010: Should this method exist? Should we
-    # instead modify default_attrs and override_attrs whenever our
-    # 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 = 'disk')
-      expansion = run_list.expand(chef_environment, data_source)
-      raise Chef::Exceptions::MissingRole if expansion.errors?
-
-      self.tags # make sure they're defined
-
-      @automatic_attrs[:recipes] = expansion.recipes
-      @automatic_attrs[:roles] = expansion.roles
-
-      expansion
-    end
-
-    # Apply the default and overrides attributes from the expansion
-    # passed in, which came from roles.
-    def apply_expansion_attributes(expansion)
-      load_chef_environment_object = (chef_environment == "_default" ? nil : Chef::Environment.load(chef_environment))
-      environment_default_attrs = load_chef_environment_object.nil? ? {} : load_chef_environment_object.default_attributes
-      default_before_roles = Chef::Mixin::DeepMerge.merge(default_attrs, environment_default_attrs)
-      @default_attrs = Chef::Mixin::DeepMerge.merge(default_before_roles, expansion.default_attrs)
-      environment_override_attrs = load_chef_environment_object.nil? ? {} : load_chef_environment_object.override_attributes
-      overrides_before_environments = Chef::Mixin::DeepMerge.merge(override_attrs, expansion.override_attrs)
-      @override_attrs = Chef::Mixin::DeepMerge.merge(overrides_before_environments, environment_override_attrs)
-    end
-
-    # Transform the node to a Hash
-    def to_hash
-      index_hash = Hash.new
-      index_hash["chef_type"] = "node"
-      index_hash["name"] = name
-      index_hash["chef_environment"] = chef_environment
-      attribute.each do |key, value|
-        index_hash[key] = value
-      end
-      index_hash["recipe"] = run_list.recipe_names if run_list.recipe_names.length > 0
-      index_hash["role"] = run_list.role_names if run_list.role_names.length > 0
-      index_hash["run_list"] = run_list.run_list if run_list.run_list.length > 0
-      index_hash
-    end
-
-    def display_hash
-      display = {}
-      display["name"]             = name
-      display["chef_environment"] = chef_environment
-      display["automatic"]        = automatic_attrs
-      display["normal"]           = normal_attrs
-      display["default"]          = default_attrs
-      display["override"]         = override_attrs
-      display["run_list"]         = run_list.run_list
-      display
-    end
-
-    # Serialize this object as a hash
-    def to_json(*a)
-      result = {
-        "name" => name,
-        "chef_environment" => chef_environment,
-        'json_class' => self.class.name,
-        "automatic" => automatic_attrs,
-        "normal" => normal_attrs,
-        "chef_type" => "node",
-        "default" => default_attrs,
-        "override" => override_attrs,
-        "run_list" => run_list.run_list
-      }
-      result.to_json(*a)
-    end
-
-    def update_from!(o)
-      run_list.reset!(o.run_list)
-      @automatic_attrs = o.automatic_attrs
-      @normal_attrs = o.normal_attrs
-      @override_attrs = o.override_attrs
-      @default_attrs = o.default_attrs
-      chef_environment(o.chef_environment)
-      self
-    end
-
-    def self.build(node_name)
-      node = new
-      node.name(node_name)
-      node.chef_environment(Chef::Config[:environment]) unless Chef::Config[:environment].nil? || Chef::Config[:environment].chop.empty?
-      node
-    end
-
-    def to_s
-      "node[#{name}]"
-    end
-
-    # Load all attribute files for all cookbooks associated with this
-    # node.
-    def load_attributes
-      cookbook_collection.values.each do |cookbook|
-        cookbook.segment_filenames(:attributes).each do |segment_filename|
-          Chef::Log.debug("Node #{name} loading cookbook #{cookbook.name}'s attribute file #{segment_filename}")
-          self.from_file(segment_filename)
-        end
-      end
-    end
-
-    # Used by DSL.
-    # Loads the attribute file specified by the short name of the
-    # file, e.g., loads specified cookbook's
-    #   "attributes/mailservers.rb"
-    # if passed
-    #   "mailservers"
-    def load_attribute_by_short_filename(name, src_cookbook_name)
-      src_cookbook = cookbook_collection[src_cookbook_name]
-      raise Chef::Exceptions::CookbookNotFound, "could not find cookbook #{src_cookbook_name} while loading attribute #{name}" unless src_cookbook
-
-      attribute_filename = src_cookbook.attribute_filenames_by_short_filename[name]
-      raise Chef::Exceptions::AttributeNotFound, "could not find filename for attribute #{name} in cookbook #{src_cookbook_name}" unless attribute_filename
-
-      self.from_file(attribute_filename)
-      self
-    end
-  end
-end

data/lib/chef/node/attribute.rb

@@ -1,487 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: AJ Christensen (<aj@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, 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.
-#
-
-require 'chef/mixin/deep_merge'
-require 'chef/log'
-
-class Chef
-  class Node
-    class Attribute
-      HIDDEN_ATTRIBUES = [:@override, :@attribute, :@default, :@normal, :@automatic]
-
-      attr_accessor :normal,
-                    :default,
-                    :override,
-                    :automatic,
-                    :current_normal,
-                    :current_default,
-                    :current_override,
-                    :current_automatic,
-                    :auto_vivifiy_on_read,
-                    :set_unless_value_present,
-                    :set_type
-
-      include Enumerable
-
-      def initialize(normal, default, override, automatic, state=[])
-        @normal = normal
-        @current_normal = normal
-        @default = default
-        @current_default = default
-        @override = override
-        @current_override = override
-        @automatic = automatic
-        @current_automatic = automatic
-        @current_nesting_level = state
-        @auto_vivifiy_on_read = false
-        @set_unless_value_present = false
-        @set_type = nil
-        @has_been_read = false
-      end
-
-      def attribute
-        normal
-      end
-
-      def attribute=(value)
-        normal = value
-      end
-
-      def set_type_hash
-        case @set_type
-        when :normal
-          @normal
-        when :override
-          @override
-        when :default
-          @default
-        when :automatic
-          @automatic
-        end
-      end
-
-      # Reset our internal current_nesting_level to the top of every tree
-      def reset
-        @current_normal = @normal
-        @current_default = @default
-        @current_override = @override
-        @current_automatic = @automatic
-        @has_been_read = false
-        @current_nesting_level = []
-      end
-
-      def [](key)
-        @current_nesting_level << key
-
-        # We set this to so that we can cope with ||= as a setting.
-        # See the comments in []= for more details.
-        @has_been_read = true
-
-        # If we have a set type, our destiny is to write
-        if @set_type
-          a_value = @set_type == :automatic ? value_or_descend(current_automatic, key, auto_vivifiy_on_read) : nil
-          o_value = @set_type == :override ? value_or_descend(current_override, key, auto_vivifiy_on_read) : nil
-          n_value = @set_type == :normal ? value_or_descend(current_normal, key, auto_vivifiy_on_read) : nil
-          d_value = @set_type == :default ? value_or_descend(current_default, key, auto_vivifiy_on_read) : nil
-
-          determine_value(a_value, o_value, n_value, d_value)
-        # Our destiny is only to read, so we get the full list.
-        else
-          a_value = value_or_descend(current_automatic, key)
-          o_value = value_or_descend(current_override, key)
-          n_value = value_or_descend(current_normal, key)
-          d_value = value_or_descend(current_default, key)
-
-          determine_value(a_value, o_value, n_value, d_value)
-        end
-      end
-
-      def has_key?(key)
-        return true if component_has_key?(@default,key)
-        return true if component_has_key?(@automatic,key)
-        return true if component_has_key?(@normal,key)
-        return true if component_has_key?(@override,key)
-        false
-      end
-
-      alias :attribute? :has_key?
-      alias :include?   :has_key?
-      alias :key?       :has_key?
-      alias :member?    :has_key?
-
-      def each(&block)
-        get_keys.each do |key|
-          value = determine_value(
-            get_value(automatic, key),
-            get_value(override, key),
-            get_value(normal, key),
-            get_value(default, key)
-          )
-          block.call([key, value])
-        end
-      end
-
-      def each_pair(&block)
-        get_keys.each do |key|
-          value = determine_value(
-            get_value(automatic, key),
-            get_value(override, key),
-            get_value(normal, key),
-            get_value(default, key)
-          )
-          block.call(key, value)
-        end
-      end
-
-      def each_attribute(&block)
-        get_keys.each do |key|
-          value = determine_value(
-            get_value(automatic, key),
-            get_value(override, key),
-            get_value(normal, key),
-            get_value(default, key)
-          )
-          block.call(key, value)
-        end
-      end
-
-      def each_key(&block)
-        get_keys.each do |key|
-          block.call(key)
-        end
-      end
-
-      def each_value(&block)
-        get_keys.each do |key|
-          value = determine_value(
-            get_value(automatic, key),
-            get_value(override, key),
-            get_value(normal, key),
-            get_value(default, key)
-          )
-          block.call(value)
-        end
-      end
-
-      def empty?
-        get_keys.empty?
-      end
-
-      def fetch(key, default_value=nil, &block)
-        if get_keys.include? key
-          determine_value(
-            get_value(automatic, key),
-            get_value(override, key),
-            get_value(normal, key),
-            get_value(default, key)
-          )
-        elsif default_value
-          default_value
-        elsif block_given?
-          block.call(key)
-        else
-          raise IndexError, "Key #{key} does not exist"
-        end
-      end
-
-      # Writing this method hurts me a little bit.
-      #
-      # TODO: Refactor all this stuff so this kind of horror is no longer needed
-      #
-      # We have invented a new kind of duck-typing, we call it Madoff typing.
-      # We just lie and hope we die before you recognize our scheme. :)
-      def kind_of?(klass)
-        if klass == Hash || klass == Mash || klass == Chef::Node::Attribute
-          true
-        else
-          false
-        end
-      end
-
-      def has_value?(value)
-        self.any? do |k,v|
-          value == v
-        end
-      end
-
-      alias :value? :has_value?
-
-      def index(value)
-        index = self.find do |h|
-          value == h[1]
-        end
-        index.first if index.is_a? Array || nil
-      end
-
-      def values
-        self.collect { |h| h[1] }
-      end
-
-      def size
-        self.collect{}.length
-      end
-
-      alias :length :size
-
-      def get_keys
-        keys
-      end
-
-      def keys
-        tkeys = current_automatic ? current_automatic.keys : []
-        [ current_override, current_normal, current_default ].each do |attr_hash|
-          if attr_hash
-            attr_hash.keys.each do |key|
-              tkeys << key unless tkeys.include?(key)
-            end
-          end
-        end
-        tkeys
-      end
-
-      def get_value(data_hash, key)
-        last = nil
-
-        if @current_nesting_level.length == 0
-          if data_hash.has_key?(key) && ! data_hash[key].nil?
-            return data_hash[key]
-          else
-            return nil
-          end
-        end
-
-        0.upto(@current_nesting_level.length) do |i|
-          if i == 0
-            last = auto_vivifiy(data_hash, @current_nesting_level[i])
-          elsif i == @current_nesting_level.length
-            fk = last[@current_nesting_level[i - 1]]
-            if fk.has_key?(key) && ! fk[key].nil?
-              return fk[key]
-            else
-              return nil
-            end
-          else
-            last = auto_vivifiy(last[@current_nesting_level[i - 1]], @current_nesting_level[i])
-          end
-        end
-      end
-
-      def hash_and_not_cna?(to_check)
-        (! to_check.kind_of?(Chef::Node::Attribute)) && to_check.respond_to?(:has_key?)
-      end
-
-      def determine_value(a_value, o_value, n_value, d_value)
-        if hash_and_not_cna?(a_value)
-          value = {}
-          value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
-          value = Chef::Mixin::DeepMerge.merge(value, n_value) if hash_and_not_cna?(n_value)
-          value = Chef::Mixin::DeepMerge.merge(value, o_value) if hash_and_not_cna?(o_value)
-          value = Chef::Mixin::DeepMerge.merge(value, a_value)
-          value
-        elsif hash_and_not_cna?(o_value)
-          value = {}
-          value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
-          value = Chef::Mixin::DeepMerge.merge(value, n_value) if hash_and_not_cna?(n_value)
-          value = Chef::Mixin::DeepMerge.merge(value, o_value)
-          value
-        elsif hash_and_not_cna?(n_value)
-          value = {}
-          value = Chef::Mixin::DeepMerge.merge(value, d_value) if hash_and_not_cna?(d_value)
-          value = Chef::Mixin::DeepMerge.merge(value, n_value)
-          value
-        elsif hash_and_not_cna?(d_value)
-          d_value
-        else
-          return a_value if ! a_value.nil?
-          return o_value if ! o_value.nil?
-          return n_value if ! n_value.nil?
-          return d_value if ! d_value.nil?
-          return nil
-        end
-      end
-
-      def []=(key, value)
-        # If we don't have one, then we'll pretend we're normal
-        @set_type ||= :normal
-
-        if set_unless_value_present
-          if get_value(set_type_hash, key) != nil
-            Chef::Log.debug("Not setting #{@current_nesting_level.join("/")}/#{key} to #{value.inspect} because it has a #{@set_type} value already")
-            return false
-          end
-        end
-
-        # If we have been read, and the key we are writing is the same
-        # as our parent, we have most like been ||='ed.  So we need to
-        # just rewind a bit.
-        #
-        # In practice, these objects are single use - this is just
-        # supporting one more single-use style.
-        @current_nesting_level.pop if @has_been_read && @current_nesting_level.last == key
-
-        set_value(set_type_hash, key, value)
-        value
-      end
-
-      def set_value(data_hash, key, value)
-        last = nil
-
-        # If there is no current_nesting_level, just set the value
-        if @current_nesting_level.length == 0
-          data_hash[key] = value
-          return data_hash
-        end
-
-        # Walk all the previous places we have been
-        0.upto(@current_nesting_level.length) do |i|
-          # If we are the first, we are top level, and should vivifiy the data_hash
-          if i == 0
-            last = auto_vivifiy(data_hash, @current_nesting_level[i])
-          # If we are one past the last current_nesting_level, we are adding a key to that hash with a value
-          elsif i == @current_nesting_level.length
-            last[@current_nesting_level[i - 1]][key] = value
-          # Otherwise, we're auto-vivifiy-ing an interim mash
-          else
-            last = auto_vivifiy(last[@current_nesting_level[i - 1]], @current_nesting_level[i])
-          end
-        end
-        data_hash
-      end
-
-      def auto_vivifiy_on_read?
-        auto_vivifiy_on_read
-      end
-
-      def auto_vivifiy(data_hash, key)
-        if data_hash.has_key?(key)
-          unless data_hash[key].respond_to?(:has_key?)
-            raise ArgumentError, "You tried to set a nested key, where the parent is not a hash-like object: #{@current_nesting_level.join("/")}/#{key} " unless auto_vivifiy_on_read
-          end
-        else
-          data_hash[key] = Mash.new
-        end
-        data_hash
-      end
-
-      def value_or_descend(data_hash, key, auto_vivifiy=false)
-        if auto_vivifiy
-          hash_to_vivifiy = auto_vivifiy(data_hash, key)
-          data_hash[key] = hash_to_vivifiy[key]
-        else
-          return nil if data_hash == nil
-          return nil unless data_hash.has_key?(key)
-        end
-
-        if data_hash[key].respond_to?(:has_key?)
-          cna = Chef::Node::Attribute.new(@normal, @default, @override, @automatic, @current_nesting_level)
-          cna.current_normal = current_normal.nil? ? Mash.new : current_normal[key]
-          cna.current_default   = current_default.nil? ? Mash.new : current_default[key]
-          cna.current_override  = current_override.nil? ? Mash.new : current_override[key]
-          cna.current_automatic  = current_automatic.nil? ? Mash.new : current_automatic[key]
-          cna.auto_vivifiy_on_read = auto_vivifiy_on_read
-          cna.set_unless_value_present = set_unless_value_present
-          cna.set_type = set_type
-          cna
-        else
-          data_hash[key]
-        end
-      end
-
-      # Fetches or sets the value, depending on if any arguments are given.
-      # ==== Fetching
-      # If no arguments are given, fetches the value:
-      #   node.network
-      #   => {network data}
-      # Getters will find either a string or symbol key.
-      # ==== Setting
-      # If arguments are given, a value will be set. Both normal setter and DSL
-      # style setters are allowed:
-      #   node.foo = "bar"
-      #   node.foo("bar")
-      # Both set node[:foo] = "bar"
-      def method_missing(symbol, *args)
-        if args.empty?
-          if key?(symbol)
-            self[symbol]
-          elsif key?(symbol.to_s)
-            self[symbol.to_s]
-          elsif auto_vivifiy_on_read?
-            self[symbol] = Mash.new
-            self[symbol]
-          else
-            raise ArgumentError, "Attribute #{symbol} is not defined!" unless auto_vivifiy_on_read
-          end
-        else
-          key_to_set = symbol.to_s[/^(.+)=$/, 1] || symbol
-          self[key_to_set] = (args.length == 1 ? args[0] : args)
-        end
-      end
-
-      def inspect
-        determine_value(current_automatic, current_override, current_normal, current_default)
-
-        "#<#{self.class} " << instance_variables.map{|iv|
-          iv.to_s + '=' + (HIDDEN_ATTRIBUES.include?(iv.to_sym) ? "{...}" : instance_variable_get(iv).inspect)
-        }.join(', ') << ">"
-      end
-
-      def to_hash
-        result = determine_value(current_automatic, current_override, current_normal, current_default)
-        if result.class == Hash
-          result
-        else
-          result.to_hash
-        end
-      end
-
-      def delete(key)
-        [@automatic, @override, @normal, @default].inject(nil) do |return_value, attrs|
-          deleted_value = delete_from_component(attrs, key)
-          return_value || deleted_value
-        end
-      end
-
-      def delete_from_component(component_attrs, key)
-        # get the Hash-like object at the current nesting level:
-        nested_attrs = value_at_current_nesting(component_attrs, key)
-
-        if nested_attrs.respond_to?(:delete)
-          nested_attrs.delete(key)
-        else
-          nil
-        end
-      end
-
-      def component_has_key?(component_attrs,key)
-        # get the Hash-like object at the current nesting level:
-        nested_attrs = value_at_current_nesting(component_attrs, key)
-        nested_attrs.respond_to?(:key?) && nested_attrs.key?(key)
-      end
-
-      def value_at_current_nesting(component_attrs, key)
-        @current_nesting_level.inject(component_attrs) do |subtree, intermediate_key|
-          # if the intermediate value isn't a hash or doesn't have the intermediate key,
-          # it can't have the bottom-level key we're looking for.
-          (subtree.respond_to?(:key?) && subtree[intermediate_key]) or (return false)
-        end
-      end
-
-    end
-  end
-end