chef 14.13.11-universal-mingw32 → 14.14.14-universal-mingw32

data/lib/chef/chef_fs/data_handler/acl_data_handler.rb

@@ -1,26 +1,26 @@
-require "chef/chef_fs/data_handler/data_handler_base"
-
-class Chef
-  module ChefFS
-    module DataHandler
-      class AclDataHandler < DataHandlerBase
-        def normalize(acl, entry)
-          # Normalize the order of the keys for easier reading
-          result = normalize_hash(acl, {
-            "create" => {},
-            "read" => {},
-            "update" => {},
-            "delete" => {},
-            "grant" => {},
-            })
-          result.each_key do |key|
-            result[key] = normalize_hash(result[key], { "actors" => [], "groups" => [] })
-            result[key]["actors"] = result[key]["actors"].sort
-            result[key]["groups"] = result[key]["groups"].sort
-          end
-          result
-        end
-      end
-    end
-  end
-end
+require "chef/chef_fs/data_handler/data_handler_base"
+
+class Chef
+  module ChefFS
+    module DataHandler
+      class AclDataHandler < DataHandlerBase
+        def normalize(acl, entry)
+          # Normalize the order of the keys for easier reading
+          result = normalize_hash(acl, {
+            "create" => {},
+            "read" => {},
+            "update" => {},
+            "delete" => {},
+            "grant" => {},
+            })
+          result.each_key do |key|
+            result[key] = normalize_hash(result[key], { "actors" => [], "groups" => [] })
+            result[key]["actors"] = result[key]["actors"].sort
+            result[key]["groups"] = result[key]["groups"].sort
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/data_handler/client_data_handler.rb

@@ -1,39 +1,39 @@
-require "chef/chef_fs/data_handler/data_handler_base"
-require "chef/api_client"
-
-class Chef
-  module ChefFS
-    module DataHandler
-      class ClientDataHandler < DataHandlerBase
-        def normalize(client, entry)
-          defaults = {
-            "name" => remove_dot_json(entry.name),
-            "clientname" => remove_dot_json(entry.name),
-            "admin" => false,
-            "validator" => false,
-            "chef_type" => "client",
-          }
-          # Handle the fact that admin/validator have changed type from string -> boolean
-          client["admin"] = (client["admin"] == "true") if client["admin"].is_a?(String)
-          client["validator"] = (client["validator"] == "true") if client["validator"].is_a?(String)
-          if entry.respond_to?(:org) && entry.org
-            defaults["orgname"] = entry.org
-          end
-          result = normalize_hash(client, defaults)
-          result.delete("json_class")
-          result
-        end
-
-        def preserve_key?(key)
-          key == "name"
-        end
-
-        def chef_class
-          Chef::ApiClient
-        end
-
-        # There is no Ruby API for Chef::ApiClient
-      end
-    end
-  end
-end
+require "chef/chef_fs/data_handler/data_handler_base"
+require "chef/api_client"
+
+class Chef
+  module ChefFS
+    module DataHandler
+      class ClientDataHandler < DataHandlerBase
+        def normalize(client, entry)
+          defaults = {
+            "name" => remove_dot_json(entry.name),
+            "clientname" => remove_dot_json(entry.name),
+            "admin" => false,
+            "validator" => false,
+            "chef_type" => "client",
+          }
+          # Handle the fact that admin/validator have changed type from string -> boolean
+          client["admin"] = (client["admin"] == "true") if client["admin"].is_a?(String)
+          client["validator"] = (client["validator"] == "true") if client["validator"].is_a?(String)
+          if entry.respond_to?(:org) && entry.org
+            defaults["orgname"] = entry.org
+          end
+          result = normalize_hash(client, defaults)
+          result.delete("json_class")
+          result
+        end
+
+        def preserve_key?(key)
+          key == "name"
+        end
+
+        def chef_class
+          Chef::ApiClient
+        end
+
+        # There is no Ruby API for Chef::ApiClient
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/data_handler/client_key_data_handler.rb

@@ -1,11 +1,11 @@
-require "chef/chef_fs/data_handler/data_handler_base"
-require "chef/api_client"
-
-class Chef
-  module ChefFS
-    module DataHandler
-      class ClientKeyDataHandler < DataHandlerBase
-      end
-    end
-  end
-end
+require "chef/chef_fs/data_handler/data_handler_base"
+require "chef/api_client"
+
+class Chef
+  module ChefFS
+    module DataHandler
+      class ClientKeyDataHandler < DataHandlerBase
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/data_handler/container_data_handler.rb

@@ -1,35 +1,35 @@
-require "chef/chef_fs/data_handler/data_handler_base"
-
-class Chef
-  module ChefFS
-    module DataHandler
-      class ContainerDataHandler < DataHandlerBase
-        def normalize(container, entry)
-          normalize_hash(container, {
-            "containername" => remove_dot_json(entry.name),
-            "containerpath" => remove_dot_json(entry.name),
-          })
-        end
-
-        def preserve_key?(key)
-          key == "containername"
-        end
-
-        # Verify that the JSON hash for this type has a key that matches its name.
-        #
-        # @param object [Object] JSON hash of the object
-        # @param entry [Chef::ChefFS::FileSystem::BaseFSObject] filesystem object we are verifying
-        # @yield  [s] callback to handle errors
-        # @yieldparam [s<string>] error message
-        def verify_integrity(object, entry)
-          base_name = remove_dot_json(entry.name)
-          if object["containername"] != base_name
-            yield("Name in #{entry.path_for_printing} must be '#{base_name}' (is '#{object['containername']}')")
-          end
-        end
-
-        # There is no chef_class for users, nor does to_ruby work.
-      end
-    end
-  end
-end
+require "chef/chef_fs/data_handler/data_handler_base"
+
+class Chef
+  module ChefFS
+    module DataHandler
+      class ContainerDataHandler < DataHandlerBase
+        def normalize(container, entry)
+          normalize_hash(container, {
+            "containername" => remove_dot_json(entry.name),
+            "containerpath" => remove_dot_json(entry.name),
+          })
+        end
+
+        def preserve_key?(key)
+          key == "containername"
+        end
+
+        # Verify that the JSON hash for this type has a key that matches its name.
+        #
+        # @param object [Object] JSON hash of the object
+        # @param entry [Chef::ChefFS::FileSystem::BaseFSObject] filesystem object we are verifying
+        # @yield  [s] callback to handle errors
+        # @yieldparam [s<string>] error message
+        def verify_integrity(object, entry)
+          base_name = remove_dot_json(entry.name)
+          if object["containername"] != base_name
+            yield("Name in #{entry.path_for_printing} must be '#{base_name}' (is '#{object['containername']}')")
+          end
+        end
+
+        # There is no chef_class for users, nor does to_ruby work.
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/data_handler/cookbook_data_handler.rb

@@ -1,38 +1,38 @@
-require "chef/chef_fs/data_handler/data_handler_base"
-require "chef/cookbook/metadata"
-
-class Chef
-  module ChefFS
-    module DataHandler
-      class CookbookDataHandler < DataHandlerBase
-        def normalize(cookbook, entry)
-          version = entry.name
-          name = entry.parent.name
-          result = normalize_hash(cookbook, {
-            "name" => "#{name}-#{version}",
-            "version" => version,
-            "cookbook_name" => name,
-            "json_class" => "Chef::CookbookVersion",
-            "chef_type" => "cookbook_version",
-            "frozen?" => false,
-            "metadata" => {},
-          })
-          result["metadata"] = normalize_hash(result["metadata"], {
-            "version" => version,
-            "name" => name,
-          })
-        end
-
-        def preserve_key?(key)
-          key == "cookbook_name" || key == "version"
-        end
-
-        def chef_class
-          Chef::Cookbook::Metadata
-        end
-
-        # Not using this yet, so not sure if to_ruby will be useful.
-      end
-    end
-  end
-end
+require "chef/chef_fs/data_handler/data_handler_base"
+require "chef/cookbook/metadata"
+
+class Chef
+  module ChefFS
+    module DataHandler
+      class CookbookDataHandler < DataHandlerBase
+        def normalize(cookbook, entry)
+          version = entry.name
+          name = entry.parent.name
+          result = normalize_hash(cookbook, {
+            "name" => "#{name}-#{version}",
+            "version" => version,
+            "cookbook_name" => name,
+            "json_class" => "Chef::CookbookVersion",
+            "chef_type" => "cookbook_version",
+            "frozen?" => false,
+            "metadata" => {},
+          })
+          result["metadata"] = normalize_hash(result["metadata"], {
+            "version" => version,
+            "name" => name,
+          })
+        end
+
+        def preserve_key?(key)
+          key == "cookbook_name" || key == "version"
+        end
+
+        def chef_class
+          Chef::Cookbook::Metadata
+        end
+
+        # Not using this yet, so not sure if to_ruby will be useful.
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/data_handler/data_bag_item_data_handler.rb

@@ -1,67 +1,67 @@
-require "chef/chef_fs/data_handler/data_handler_base"
-require "chef/data_bag_item"
-
-class Chef
-  module ChefFS
-    module DataHandler
-      class DataBagItemDataHandler < DataHandlerBase
-        RESERVED_NAMES = /^(node|role|environment|client)$/
-
-        def normalize(data_bag_item, entry)
-          # If it's wrapped with raw_data, unwrap it.
-          if data_bag_item["json_class"] == "Chef::DataBagItem" && data_bag_item["raw_data"]
-            data_bag_item = data_bag_item["raw_data"]
-          end
-          # chef_type and data_bag come back in PUT and POST results, but we don't
-          # use those in knife-essentials.
-          normalize_hash(data_bag_item, {
-            "id" => remove_dot_json(entry.name),
-          })
-        end
-
-        def normalize_for_post(data_bag_item, entry)
-          if data_bag_item["json_class"] == "Chef::DataBagItem" && data_bag_item["raw_data"]
-            data_bag_item = data_bag_item["raw_data"]
-          end
-          {
-            "name" => "data_bag_item_#{entry.parent.name}_#{remove_dot_json(entry.name)}",
-            "json_class" => "Chef::DataBagItem",
-            "chef_type" => "data_bag_item",
-            "data_bag" => entry.parent.name,
-            "raw_data" => normalize(data_bag_item, entry),
-          }
-        end
-
-        def normalize_for_put(data_bag_item, entry)
-          normalize_for_post(data_bag_item, entry)
-        end
-
-        def preserve_key?(key)
-          key == "id"
-        end
-
-        def chef_class
-          Chef::DataBagItem
-        end
-
-        # Verify that the JSON hash for this type has a key that matches its name.
-        # Also check that the data bag name is not a reserved search index name.
-        #
-        # @param object [Object] JSON hash of the object
-        # @param entry [Chef::ChefFS::FileSystem::BaseFSObject] filesystem object we are verifying
-        # @yield  [s] callback to handle errors
-        # @yieldparam [s<string>] error message
-        def verify_integrity(object, entry)
-          base_name = remove_dot_json(entry.name)
-          if object["raw_data"]["id"] != base_name
-            yield("ID in #{entry.path_for_printing} must be '#{base_name}' (is '#{object['raw_data']['id']}')")
-          elsif entry.parent.name =~ RESERVED_NAMES
-            yield("Data bag name ('#{entry.parent.name}') must not match #{RESERVED_NAMES.inspect}")
-          end
-        end
-
-        # Data bags do not support .rb files (or if they do, it's undocumented)
-      end
-    end
-  end
-end
+require "chef/chef_fs/data_handler/data_handler_base"
+require "chef/data_bag_item"
+
+class Chef
+  module ChefFS
+    module DataHandler
+      class DataBagItemDataHandler < DataHandlerBase
+        RESERVED_NAMES = /^(node|role|environment|client)$/
+
+        def normalize(data_bag_item, entry)
+          # If it's wrapped with raw_data, unwrap it.
+          if data_bag_item["json_class"] == "Chef::DataBagItem" && data_bag_item["raw_data"]
+            data_bag_item = data_bag_item["raw_data"]
+          end
+          # chef_type and data_bag come back in PUT and POST results, but we don't
+          # use those in knife-essentials.
+          normalize_hash(data_bag_item, {
+            "id" => remove_dot_json(entry.name),
+          })
+        end
+
+        def normalize_for_post(data_bag_item, entry)
+          if data_bag_item["json_class"] == "Chef::DataBagItem" && data_bag_item["raw_data"]
+            data_bag_item = data_bag_item["raw_data"]
+          end
+          {
+            "name" => "data_bag_item_#{entry.parent.name}_#{remove_dot_json(entry.name)}",
+            "json_class" => "Chef::DataBagItem",
+            "chef_type" => "data_bag_item",
+            "data_bag" => entry.parent.name,
+            "raw_data" => normalize(data_bag_item, entry),
+          }
+        end
+
+        def normalize_for_put(data_bag_item, entry)
+          normalize_for_post(data_bag_item, entry)
+        end
+
+        def preserve_key?(key)
+          key == "id"
+        end
+
+        def chef_class
+          Chef::DataBagItem
+        end
+
+        # Verify that the JSON hash for this type has a key that matches its name.
+        # Also check that the data bag name is not a reserved search index name.
+        #
+        # @param object [Object] JSON hash of the object
+        # @param entry [Chef::ChefFS::FileSystem::BaseFSObject] filesystem object we are verifying
+        # @yield  [s] callback to handle errors
+        # @yieldparam [s<string>] error message
+        def verify_integrity(object, entry)
+          base_name = remove_dot_json(entry.name)
+          if object["raw_data"]["id"] != base_name
+            yield("ID in #{entry.path_for_printing} must be '#{base_name}' (is '#{object['raw_data']['id']}')")
+          elsif entry.parent.name =~ RESERVED_NAMES
+            yield("Data bag name ('#{entry.parent.name}') must not match #{RESERVED_NAMES.inspect}")
+          end
+        end
+
+        # Data bags do not support .rb files (or if they do, it's undocumented)
+      end
+    end
+  end
+end

data/lib/chef/chef_fs/data_handler/data_handler_base.rb

@@ -1,207 +1,207 @@
-class Chef
-  module ChefFS
-    module DataHandler
-      #
-      # The base class for all *DataHandlers.
-      #
-      # DataHandlers' job is to know the innards of Chef objects and manipulate
-      # JSON for them, adding defaults and formatting them.
-      #
-      class DataHandlerBase
-        #
-        # Remove all default values from a Chef object's JSON so that the only
-        # thing you see are the values that have been explicitly set.
-        # Achieves this by calling normalize({}, entry) to get the list of
-        # defaults, and subtracting anything that is the same.
-        #
-        def minimize(object, entry)
-          default_object = default(entry)
-          object.each_pair do |key, value|
-            if default_object[key] == value && !preserve_key?(key)
-              object.delete(key)
-            end
-          end
-          object
-        end
-
-        def remove_file_extension(name, ext = ".*")
-          if %w{ .rb .json }.include?(File.extname(name))
-            File.basename(name, ext)
-          else
-            name
-          end
-        end
-        alias_method :remove_dot_json, :remove_file_extension
-
-        #
-        # Return true if minimize() should preserve a key even if it is the same
-        # as the default.  Often used for ids and names.
-        #
-        def preserve_key?(key)
-          false
-        end
-
-        #
-        # Get the default value for an entry.  Calls normalize({}, entry).
-        #
-        def default(entry)
-          normalize({}, entry)
-        end
-
-        #
-        # Utility function to help subclasses do normalize().  Pass in a hash
-        # and a list of keys with defaults, and normalize will:
-        #
-        # 1. Fill in the defaults
-        # 2. Put the actual values in the order of the defaults
-        # 3. Move any other values to the end
-        #
-        # @example
-        #   normalize_hash({x: 100, c: 2, a: 1}, { a: 10, b: 20, c: 30})
-        #   -> { a: 1, b: 20, c: 2, x: 100}
-        #
-        def normalize_hash(object, defaults)
-          # Make a normalized result in the specified order for diffing
-          result = {}
-          defaults.each_pair do |key, value|
-            result[key] = object.is_a?(Hash) && object.key?(key) ? object[key] : value
-          end
-          if object.is_a?(Hash)
-            object.each_pair do |key, value|
-              result[key] = value unless result.key?(key)
-            end
-          else
-            Chef::Log.warn "Encountered invalid object during normalization. Using these defaults #{defaults}"
-          end
-          result
-        end
-
-        # Specialized function to normalize an object before POSTing it, since
-        # some object types want slightly different values on POST.
-        # If not overridden, this just calls normalize()
-        def normalize_for_post(object, entry)
-          normalize(object, entry)
-        end
-
-        # Specialized function to normalize an object before PUTing it, since
-        # some object types want slightly different values on PUT.
-        # If not overridden, this just calls normalize().
-        def normalize_for_put(object, entry)
-          normalize(object, entry)
-        end
-
-        #
-        # normalize a run list (an array of run list items).
-        # Leaves recipe[name] and role[name] alone, and translates
-        # name to recipe[name].  Then calls uniq on the result.
-        #
-        def normalize_run_list(run_list)
-          run_list.map do |item|
-            case item.to_s
-            when /^recipe\[.*\]$/
-              item # explicit recipe
-            when /^role\[.*\]$/
-              item # explicit role
-            else
-              "recipe[#{item}]"
-            end
-          end.uniq
-        end
-
-        #
-        # Bring in an instance of this object from Ruby.  (Like roles/x.rb)
-        #
-        def from_ruby(path)
-          r = chef_class.new
-          r.from_file(path)
-          r.to_h
-        end
-
-        #
-        # Turn a JSON hash into a bona fide Chef object (like Chef::Node).
-        #
-        def chef_object(object)
-          chef_class.from_hash(object)
-        end
-
-        #
-        # Write out the Ruby file for this instance.  (Like roles/x.rb)
-        #
-        def to_ruby(object)
-          raise NotImplementedError
-        end
-
-        #
-        # Get the class for instances of this type.  Must be overridden.
-        #
-        def chef_class
-          raise NotImplementedError
-        end
-
-        #
-        # Helper to write out a Ruby file for a JSON hash.  Writes out only
-        # the keys specified in "keys"; anything else must be emitted by the
-        # caller.
-        #
-        # @example
-        #   to_ruby_keys({"name" => "foo", "environment" => "desert", "foo": "bar"}, [ "name", "environment" ])
-        #   ->
-        #   'name "foo"
-        #   environment "desert"'
-        #
-        def to_ruby_keys(object, keys)
-          result = ""
-          keys.each do |key|
-            if object[key]
-              if object[key].is_a?(Hash)
-                if object[key].size > 0
-                  result << key
-                  first = true
-                  object[key].each_pair do |k, v|
-                    if first
-                      first = false
-                    else
-                      result << " " * key.length
-                    end
-                    result << " #{k.inspect} => #{v.inspect}\n"
-                  end
-                end
-              elsif object[key].is_a?(Array)
-                if object[key].size > 0
-                  result << key
-                  first = true
-                  object[key].each do |value|
-                    if first
-                      first = false
-                    else
-                      result << ", "
-                    end
-                    result << value.inspect
-                  end
-                  result << "\n"
-                end
-              elsif !object[key].nil?
-                result << "#{key} #{object[key].inspect}\n"
-              end
-            end
-          end
-          result
-        end
-
-        # Verify that the JSON hash for this type has a key that matches its name.
-        #
-        # @param object [Object] JSON hash of the object
-        # @param entry [Chef::ChefFS::FileSystem::BaseFSObject] filesystem object we are verifying
-        # @yield  [s] callback to handle errors
-        # @yieldparam [s<string>] error message
-        def verify_integrity(object, entry)
-          base_name = remove_file_extension(entry.name)
-          if object["name"] != base_name
-            yield("Name must be '#{base_name}' (is '#{object['name']}')")
-          end
-        end
-
-      end # class DataHandlerBase
-    end
-  end
-end
+class Chef
+  module ChefFS
+    module DataHandler
+      #
+      # The base class for all *DataHandlers.
+      #
+      # DataHandlers' job is to know the innards of Chef objects and manipulate
+      # JSON for them, adding defaults and formatting them.
+      #
+      class DataHandlerBase
+        #
+        # Remove all default values from a Chef object's JSON so that the only
+        # thing you see are the values that have been explicitly set.
+        # Achieves this by calling normalize({}, entry) to get the list of
+        # defaults, and subtracting anything that is the same.
+        #
+        def minimize(object, entry)
+          default_object = default(entry)
+          object.each_pair do |key, value|
+            if default_object[key] == value && !preserve_key?(key)
+              object.delete(key)
+            end
+          end
+          object
+        end
+
+        def remove_file_extension(name, ext = ".*")
+          if %w{ .rb .json }.include?(File.extname(name))
+            File.basename(name, ext)
+          else
+            name
+          end
+        end
+        alias_method :remove_dot_json, :remove_file_extension
+
+        #
+        # Return true if minimize() should preserve a key even if it is the same
+        # as the default.  Often used for ids and names.
+        #
+        def preserve_key?(key)
+          false
+        end
+
+        #
+        # Get the default value for an entry.  Calls normalize({}, entry).
+        #
+        def default(entry)
+          normalize({}, entry)
+        end
+
+        #
+        # Utility function to help subclasses do normalize().  Pass in a hash
+        # and a list of keys with defaults, and normalize will:
+        #
+        # 1. Fill in the defaults
+        # 2. Put the actual values in the order of the defaults
+        # 3. Move any other values to the end
+        #
+        # @example
+        #   normalize_hash({x: 100, c: 2, a: 1}, { a: 10, b: 20, c: 30})
+        #   -> { a: 1, b: 20, c: 2, x: 100}
+        #
+        def normalize_hash(object, defaults)
+          # Make a normalized result in the specified order for diffing
+          result = {}
+          defaults.each_pair do |key, value|
+            result[key] = object.is_a?(Hash) && object.key?(key) ? object[key] : value
+          end
+          if object.is_a?(Hash)
+            object.each_pair do |key, value|
+              result[key] = value unless result.key?(key)
+            end
+          else
+            Chef::Log.warn "Encountered invalid object during normalization. Using these defaults #{defaults}"
+          end
+          result
+        end
+
+        # Specialized function to normalize an object before POSTing it, since
+        # some object types want slightly different values on POST.
+        # If not overridden, this just calls normalize()
+        def normalize_for_post(object, entry)
+          normalize(object, entry)
+        end
+
+        # Specialized function to normalize an object before PUTing it, since
+        # some object types want slightly different values on PUT.
+        # If not overridden, this just calls normalize().
+        def normalize_for_put(object, entry)
+          normalize(object, entry)
+        end
+
+        #
+        # normalize a run list (an array of run list items).
+        # Leaves recipe[name] and role[name] alone, and translates
+        # name to recipe[name].  Then calls uniq on the result.
+        #
+        def normalize_run_list(run_list)
+          run_list.map do |item|
+            case item.to_s
+            when /^recipe\[.*\]$/
+              item # explicit recipe
+            when /^role\[.*\]$/
+              item # explicit role
+            else
+              "recipe[#{item}]"
+            end
+          end.uniq
+        end
+
+        #
+        # Bring in an instance of this object from Ruby.  (Like roles/x.rb)
+        #
+        def from_ruby(path)
+          r = chef_class.new
+          r.from_file(path)
+          r.to_h
+        end
+
+        #
+        # Turn a JSON hash into a bona fide Chef object (like Chef::Node).
+        #
+        def chef_object(object)
+          chef_class.from_hash(object)
+        end
+
+        #
+        # Write out the Ruby file for this instance.  (Like roles/x.rb)
+        #
+        def to_ruby(object)
+          raise NotImplementedError
+        end
+
+        #
+        # Get the class for instances of this type.  Must be overridden.
+        #
+        def chef_class
+          raise NotImplementedError
+        end
+
+        #
+        # Helper to write out a Ruby file for a JSON hash.  Writes out only
+        # the keys specified in "keys"; anything else must be emitted by the
+        # caller.
+        #
+        # @example
+        #   to_ruby_keys({"name" => "foo", "environment" => "desert", "foo": "bar"}, [ "name", "environment" ])
+        #   ->
+        #   'name "foo"
+        #   environment "desert"'
+        #
+        def to_ruby_keys(object, keys)
+          result = ""
+          keys.each do |key|
+            if object[key]
+              if object[key].is_a?(Hash)
+                if object[key].size > 0
+                  result << key
+                  first = true
+                  object[key].each_pair do |k, v|
+                    if first
+                      first = false
+                    else
+                      result << " " * key.length
+                    end
+                    result << " #{k.inspect} => #{v.inspect}\n"
+                  end
+                end
+              elsif object[key].is_a?(Array)
+                if object[key].size > 0
+                  result << key
+                  first = true
+                  object[key].each do |value|
+                    if first
+                      first = false
+                    else
+                      result << ", "
+                    end
+                    result << value.inspect
+                  end
+                  result << "\n"
+                end
+              elsif !object[key].nil?
+                result << "#{key} #{object[key].inspect}\n"
+              end
+            end
+          end
+          result
+        end
+
+        # Verify that the JSON hash for this type has a key that matches its name.
+        #
+        # @param object [Object] JSON hash of the object
+        # @param entry [Chef::ChefFS::FileSystem::BaseFSObject] filesystem object we are verifying
+        # @yield  [s] callback to handle errors
+        # @yieldparam [s<string>] error message
+        def verify_integrity(object, entry)
+          base_name = remove_file_extension(entry.name)
+          if object["name"] != base_name
+            yield("Name must be '#{base_name}' (is '#{object['name']}')")
+          end
+        end
+
+      end # class DataHandlerBase
+    end
+  end
+end