puppet-retrospec 1.5.0 → 1.6.0

data/vendor/pup410/lib/puppet/pops/lookup/data_hash_function_provider.rb

@@ -0,0 +1,126 @@
+require_relative 'function_provider'
+require_relative 'interpolation'
+
+module Puppet::Pops
+module Lookup
+# @api private
+class DataHashFunctionProvider < FunctionProvider
+  include SubLookup
+  include Interpolation
+
+  TAG = 'data_hash'.freeze
+
+  def self.trusted_return_type
+    @trusted_return_type ||= Types::PHashType.new(DataProvider.key_type, DataProvider.value_type)
+  end
+
+  # Performs a lookup with the assumption that a recursive check has been made.
+  #
+  # @param key [LookupKey] The key to lookup
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @param merge [MergeStrategy,String,Hash{String => Object},nil] Merge strategy, merge strategy name, strategy and options hash, or nil (implies "first found")
+  # @return [Object] the found object
+  # @throw :no_such_key when the object is not found
+  def unchecked_key_lookup(key, lookup_invocation, merge)
+    root_key = key.root_key
+    lookup_invocation.with(:data_provider, self) do
+      MergeStrategy.strategy(merge).lookup(locations, lookup_invocation) do |location|
+        invoke_with_location(lookup_invocation, location, root_key)
+      end
+    end
+  end
+
+  private
+
+  def invoke_with_location(lookup_invocation, location, root_key)
+    if location.nil?
+      lookup_key(lookup_invocation, nil, root_key)
+    else
+      lookup_invocation.with(:location, location) do
+        if location.exist?
+          lookup_key(lookup_invocation, location, root_key)
+        else
+          lookup_invocation.report_location_not_found
+          throw :no_such_key
+        end
+      end
+    end
+  end
+
+  def lookup_key(lookup_invocation, location, root_key)
+    lookup_invocation.report_found(root_key, data_value(lookup_invocation, location, root_key))
+  end
+
+  def data_value(lookup_invocation, location, root_key)
+    hash = data_hash(lookup_invocation, location)
+    value = hash[root_key]
+    if value.nil? && !hash.include?(root_key)
+      lookup_invocation.report_not_found(root_key)
+      throw :no_such_key
+    end
+    value = validate_data_value(value) do
+      msg = "Value for key '#{root_key}', in hash returned from #{full_name}"
+      location.nil? ? msg : "#{msg}, when using location '#{location}',"
+    end
+    interpolate(value, lookup_invocation, true)
+  end
+
+  def data_hash(lookup_invocation, location)
+    ctx = function_context(lookup_invocation, location)
+    ctx.data_hash ||= parent_data_provider.validate_data_hash(call_data_hash_function(ctx, lookup_invocation, location)) do
+      msg = "Value returned from #{full_name}"
+      location.nil? ? msg : "#{msg}, when using location '#{location}',"
+    end
+  end
+
+  def call_data_hash_function(ctx, lookup_invocation, location)
+    ctx.function.call(lookup_invocation.scope, options(location), Context.new(ctx, lookup_invocation))
+  end
+end
+
+# @api private
+class V3DataHashFunctionProvider < DataHashFunctionProvider
+  TAG = 'v3_data_hash'.freeze
+
+  def initialize(name, parent_data_provider, function_name, options, locations)
+    @datadir = options.delete(HieraConfig::KEY_DATADIR)
+    super
+  end
+
+  def unchecked_key_lookup(key, lookup_invocation, merge)
+    extra_paths = lookup_invocation.hiera_v3_location_overrides
+    if extra_paths.nil? || extra_paths.empty?
+      super
+    else
+      # Extra paths provided. Must be resolved and placed in front of known paths
+      paths = parent_data_provider.config(lookup_invocation).resolve_paths(@datadir, extra_paths, lookup_invocation, false, ".#{@name}")
+      all_locations = paths + locations
+      root_key = key.root_key
+      lookup_invocation.with(:data_provider, self) do
+        MergeStrategy.strategy(merge).lookup(all_locations, lookup_invocation) do |location|
+          invoke_with_location(lookup_invocation, location, root_key)
+        end
+      end
+    end
+  end
+end
+
+# TODO: API 5.0, remove this class
+# @api private
+class V4DataHashFunctionProvider < DataHashFunctionProvider
+  TAG = 'v4_data_hash'.freeze
+
+  def name
+    "Deprecated API function \"#{function_name}\""
+  end
+
+  def full_name
+    "deprecated API function '#{function_name}'"
+  end
+
+  def call_data_hash_function(ctx, lookup_invocation, location)
+    ctx.function.call(lookup_invocation.scope)
+  end
+end
+end
+end

data/vendor/pup410/lib/puppet/pops/lookup/data_provider.rb

@@ -0,0 +1,107 @@
+module Puppet::Pops
+module Lookup
+# @api private
+module DataProvider
+  def self.key_type
+    @key_type
+  end
+
+  def self.value_type
+    @value_type
+  end
+
+  def self.register_types(loader)
+    (@key_type, @value_type) = Pcore::register_aliases({
+      # The Pcore type for all keys and subkeys in a data hash.
+      'Puppet::LookupKey' => 'Variant[String,Numeric]',
+
+      # The Pcore type for all values and sub-values in a data hash. The
+      # type is self-recursive to enforce the same constraint on values contained
+      # in arrays and hashes
+      'Puppet::LookupValue' => <<-PUPPET
+        Variant[
+          Scalar,
+          Undef,
+          Sensitive,
+          Type,
+          Hash[Puppet::LookupKey, Puppet::LookupValue],
+          Array[Puppet::LookupValue]
+        ]
+        PUPPET
+    }, Pcore::RUNTIME_NAME_AUTHORITY, loader)
+  end
+
+  # Performs a lookup with an endless recursion check.
+  #
+  # @param key [LookupKey] The key to lookup
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @param merge [MergeStrategy,String,Hash{String=>Object},nil] Merge strategy or hash with strategy and options
+  #
+  def key_lookup(key, lookup_invocation, merge)
+    lookup_invocation.check(key.to_s) { unchecked_key_lookup(key, lookup_invocation, merge) }
+  end
+
+  # Performs a lookup using a module default hierarchy with an endless recursion check. All providers except
+  # the `ModuleDataProvider` will throw `:no_such_key` if this method is called.
+  #
+  # @param key [LookupKey] The key to lookup
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @param merge [MergeStrategy,String,Hash{String=>Object},nil] Merge strategy or hash with strategy and options
+  #
+  def key_lookup_in_default(key, lookup_invocation, merge)
+    throw :no_such_key
+  end
+
+  def lookup(key, lookup_invocation, merge)
+    lookup_invocation.check(key.to_s) { unchecked_key_lookup(key, lookup_invocation, merge) }
+  end
+
+  # Performs a lookup with the assumption that a recursive check has been made.
+  #
+  # @param key [LookupKey] The key to lookup
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @param merge [MergeStrategy,String,Hash{String => Object},nil] Merge strategy, merge strategy name, strategy and options hash, or nil (implies "first found")
+  # @return [Object] the found object
+  # @throw :no_such_key when the object is not found
+  def unchecked_key_lookup(key, lookup_invocation, merge)
+    raise NotImplementedError, "Subclass of #{DataProvider.name} must implement 'unchecked_lookup' method"
+  end
+
+  # @return [String,nil] the name of the module that this provider belongs to nor `nil` if it doesn't belong to a module
+  def module_name
+    nil
+  end
+
+  # @return [String] the name of the this data provider
+  def name
+    raise NotImplementedError, "Subclass of #{DataProvider.name} must implement 'name' method"
+  end
+
+  # @returns `true` if the value provided by this instance can always be trusted, `false` otherwise
+  def value_is_validated?
+    false
+  end
+
+  # Asserts that _data_hash_ is a hash. Will yield to obtain origin of value in case an error is produced
+  #
+  # @param data_hash [Hash{String=>Object}] The data hash
+  # @return [Hash{String=>Object}] The data hash
+  def validate_data_hash(data_hash, &block)
+    Types::TypeAsserter.assert_instance_of(nil, Types::PHashType::DEFAULT, data_hash, &block)
+  end
+
+  # Asserts that _data_value_ is of valid type. Will yield to obtain origin of value in case an error is produced
+  #
+  # @param data_provider [DataProvider] The data provider that produced the hash
+  # @return [Object] The data value
+  def validate_data_value(value, &block)
+    # The DataProvider.value_type is self recursive so further recursive check of collections is needed here
+    unless value_is_validated? || DataProvider.value_type.instance?(value)
+      actual_type = Types::TypeCalculator.singleton.infer(value)
+      raise Types::TypeAssertionError.new("#{yield} has wrong type, expects Puppet::LookupValue, got #{actual_type}", DataProvider.value_type, actual_type)
+    end
+    value
+  end
+end
+end
+end

data/vendor/pup410/lib/puppet/pops/lookup/environment_data_provider.rb

@@ -0,0 +1,35 @@
+require_relative 'configured_data_provider'
+
+module Puppet::Pops
+module Lookup
+# @api private
+class EnvironmentDataProvider < ConfiguredDataProvider
+  def place
+    'Environment'
+  end
+
+  protected
+
+  def assert_config_version(config)
+    if config.version > 3
+      config
+    else
+      if Puppet[:strict] == :error
+        config.fail(Issues::HIERA_VERSION_3_NOT_GLOBAL, :where => 'environment')
+      else
+        Puppet.warn_once(:hiera_v3_at_env_root, config.config_path, _('hiera.yaml version 3 found at the environment root was ignored'), config.config_path)
+      end
+      nil
+    end
+  end
+
+  # Return the root of the environment
+  #
+  # @param lookup_invocation [Invocation] The current lookup invocation
+  # @return [Pathname] Path to root of the environment
+  def provider_root(lookup_invocation)
+    Pathname.new(lookup_invocation.scope.environment.configuration.path_to_env)
+  end
+end
+end
+end

data/vendor/pup410/lib/puppet/pops/lookup/explainer.rb

@@ -0,0 +1,594 @@
+module Puppet::Pops
+module Lookup
+
+# The ExplainNode contains information of a specific node in a tree traversed during
+# lookup. The tree can be traversed using the `parent` and `branches` attributes of
+# each node.
+#
+# Each leaf node contains information about what happened when the leaf of the branch
+# was traversed.
+  class ExplainNode
+    def branches
+      @branches ||= []
+    end
+
+    def to_hash
+      hash = {}
+      hash[:branches] = @branches.map {|b| b.to_hash} unless @branches.nil? || @branches.empty?
+      hash
+    end
+
+    def explain
+      io = ''
+      dump_on(io, '', '')
+      io
+    end
+
+    def inspect
+      to_s
+    end
+
+    def to_s
+      s = self.class.name
+      s = "#{s} with #{@branches.size} branches" unless @branches.nil?
+      s
+    end
+
+    def text(text)
+      @texts ||= []
+      @texts << text
+    end
+
+    def dump_on(io, indent, first_indent)
+      dump_texts(io, indent)
+    end
+
+    def dump_texts(io, indent)
+      @texts.each { |text| io << indent << text << "\n" } if instance_variable_defined?(:@texts)
+    end
+  end
+
+  class ExplainTreeNode < ExplainNode
+    attr_reader :parent, :event, :value
+    attr_accessor :key
+
+    def initialize(parent)
+      @parent = parent
+      @event = nil
+    end
+
+    def found_in_overrides(key, value)
+      @key = key.to_s
+      @value = value
+      @event = :found_in_overrides
+    end
+
+    def found_in_defaults(key, value)
+      @key = key.to_s
+      @value = value
+      @event = :found_in_defaults
+    end
+
+    def found(key, value)
+      @key = key.to_s
+      @value = value
+      @event = :found
+    end
+
+    def result(value)
+      @value = value
+      @event = :result
+    end
+
+    def not_found(key)
+      @key = key.to_s
+      @event = :not_found
+    end
+
+    def location_not_found
+      @event = :location_not_found
+    end
+
+    def increase_indent(indent)
+      indent + '  '
+    end
+
+    def to_hash
+      hash = super
+      hash[:key] = @key unless @key.nil?
+      hash[:value] = @value if [:found, :found_in_defaults, :found_in_overrides, :result].include?(@event)
+      hash[:event] = @event unless @event.nil?
+      hash[:texts] = @texts unless @texts.nil?
+      hash[:type] = type
+      hash
+    end
+
+    def type
+      :root
+    end
+
+    def dump_outcome(io, indent)
+      case @event
+      when :not_found
+        io << indent << 'No such key: "' << @key << "\"\n"
+      when :found, :found_in_overrides, :found_in_defaults
+        io << indent << 'Found key: "' << @key << '" value: '
+        dump_value(io, indent, @value)
+        io << ' in overrides' if @event == :found_in_overrides
+        io << ' in defaults' if @event == :found_in_defaults
+        io << "\n"
+      end
+      dump_texts(io, indent)
+    end
+
+    def dump_value(io, indent, value)
+      case value
+      when Hash
+        io << '{'
+        unless value.empty?
+          inner_indent = increase_indent(indent)
+          value.reduce("\n") do |sep, (k, v)|
+            io << sep << inner_indent
+            dump_value(io, inner_indent, k)
+            io << ' => '
+            dump_value(io, inner_indent, v)
+            ",\n"
+          end
+          io << "\n" << indent
+        end
+        io << '}'
+      when Array
+        io << '['
+        unless value.empty?
+          inner_indent = increase_indent(indent)
+          value.reduce("\n") do |sep, v|
+            io << sep << inner_indent
+            dump_value(io, inner_indent, v)
+            ",\n"
+          end
+          io << "\n" << indent
+        end
+        io << ']'
+      else
+        io << value.inspect
+      end
+    end
+
+    def to_s
+      "#{self.class.name}: #{@key}, #{@event}"
+    end
+  end
+
+  class ExplainTop < ExplainTreeNode
+    def initialize(parent, type, key)
+      super(parent)
+      @type = type
+      self.key = key.to_s
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << first_indent << 'Searching for "' << key << "\"\n"
+      indent = increase_indent(indent)
+      branches.each {|b| b.dump_on(io, indent, indent)}
+    end
+  end
+
+  class ExplainInvalidKey < ExplainTreeNode
+    def initialize(parent, key)
+      super(parent)
+      @key = key.to_s
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << first_indent << "Invalid key \"" << @key << "\"\n"
+    end
+
+    def type
+      :invalid_key
+    end
+  end
+
+  class ExplainMergeSource < ExplainNode
+    attr_reader :merge_source
+
+    def initialize(merge_source)
+      @merge_source = merge_source
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << first_indent << 'Using merge options from "' << merge_source << "\" hash\n"
+    end
+
+    def to_hash
+      { :type => type, :merge_source => merge_source }
+    end
+
+    def type
+      :merge_source
+    end
+  end
+
+  class ExplainModule < ExplainTreeNode
+    def initialize(parent, module_name)
+      super(parent)
+      @module_name = module_name
+    end
+
+    def dump_on(io, indent, first_indent)
+      case @event
+      when :module_not_found
+        io << indent << 'Module "' << @module_name << "\" not found\n"
+      when :module_provider_not_found
+        io << indent << 'Module data provider for module "' << @module_name << "\" not found\n"
+      end
+    end
+
+    def module_not_found
+      @event = :module_not_found
+    end
+
+    def module_provider_not_found
+      @event = :module_provider_not_found
+    end
+
+    def type
+      :module
+    end
+  end
+
+  class ExplainInterpolate < ExplainTreeNode
+    def initialize(parent, expression)
+      super(parent)
+      @expression = expression
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << first_indent << 'Interpolation on "' << @expression << "\"\n"
+      indent = increase_indent(indent)
+      branches.each {|b| b.dump_on(io, indent, indent)}
+    end
+
+    def to_hash
+      hash = super
+      hash[:expression] = @expression
+      hash
+    end
+
+    def type
+      :interpolate
+    end
+  end
+
+  class ExplainMerge < ExplainTreeNode
+    def initialize(parent, merge)
+      super(parent)
+      @merge = merge
+    end
+
+    def dump_on(io, indent, first_indent)
+      return if branches.size == 0
+
+      # It's pointless to report a merge where there's only one branch
+      return branches[0].dump_on(io, indent, first_indent) if branches.size == 1
+
+      io << first_indent << 'Merge strategy ' << @merge.class.key.to_s << "\n"
+      indent = increase_indent(indent)
+      options = options_wo_strategy
+      unless options.nil?
+        io << indent << 'Options: '
+        dump_value(io, indent, options)
+        io << "\n"
+      end
+      branches.each {|b| b.dump_on(io, indent, indent)}
+      if @event == :result
+        io << indent << 'Merged result: '
+        dump_value(io, indent, @value)
+        io << "\n"
+      end
+    end
+
+    def to_hash
+      return branches[0].to_hash if branches.size == 1
+      hash = super
+      hash[:merge] = @merge.class.key
+      options = options_wo_strategy
+      hash[:options] = options unless options.nil?
+      hash
+    end
+
+    def type
+      :merge
+    end
+
+    def options_wo_strategy
+      options = @merge.options
+      if !options.nil? && options.include?('strategy')
+        options = options.dup
+        options.delete('strategy')
+      end
+      options.empty? ? nil : options
+    end
+  end
+
+  class ExplainGlobal < ExplainTreeNode
+    def initialize(parent, binding_terminus)
+      super(parent)
+      @binding_terminus = binding_terminus
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << first_indent << 'Data Binding "' << @binding_terminus.to_s << "\"\n"
+      indent = increase_indent(indent)
+      branches.each {|b| b.dump_on(io, indent, indent)}
+      dump_outcome(io, indent)
+    end
+
+    def to_hash
+      hash = super
+      hash[:name] = @binding_terminus
+      hash
+    end
+
+    def type
+      :global
+    end
+  end
+
+  class ExplainDataProvider < ExplainTreeNode
+    def initialize(parent, provider)
+      super(parent)
+      @provider = provider
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << first_indent << @provider.name << "\n"
+      indent = increase_indent(indent)
+      if @provider.respond_to?(:config_path)
+        path = @provider.config_path
+        io << indent << 'Using configuration "' << path.to_s << "\"\n" unless path.nil?
+      end
+      branches.each {|b| b.dump_on(io, indent, indent)}
+      dump_outcome(io, indent)
+    end
+
+    def to_hash
+      hash = super
+      hash[:name] = @provider.name
+      if @provider.respond_to?(:config_path)
+        path = @provider.config_path
+        hash[:configuration_path] = path.to_s unless path.nil?
+      end
+      hash[:module] = @provider.module_name if @provider.is_a?(ModuleDataProvider)
+      hash
+    end
+
+    def type
+      :data_provider
+    end
+  end
+
+  class ExplainLocation < ExplainTreeNode
+    def initialize(parent, location)
+      super(parent)
+      @location = location
+    end
+
+    def dump_on(io, indent, first_indent)
+      location = @location.location
+      type_name = type == :path ? 'Path' : 'URI'
+      io << indent << type_name << ' "' << location.to_s << "\"\n"
+      indent = increase_indent(indent)
+      io << indent << 'Original ' << type_name.downcase << ': "' << @location.original_location << "\"\n"
+      branches.each {|b| b.dump_on(io, indent, indent)}
+      io << indent << type_name << " not found\n" if @event == :location_not_found
+      dump_outcome(io, indent)
+    end
+
+    def to_hash
+      hash = super
+      location = @location.location
+      if type == :path
+        hash[:original_path] = @location.original_location
+        hash[:path] = location.to_s
+      else
+        hash[:original_uri] = @location.original_location
+        hash[:uri] = location.to_s
+      end
+      hash
+    end
+
+    def type
+      @location.location.is_a?(Pathname) ? :path : :uri
+    end
+  end
+
+  class ExplainSubLookup < ExplainTreeNode
+    def initialize(parent, sub_key)
+      super(parent)
+      @sub_key = sub_key
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << indent << 'Sub key: "' << @sub_key.join('.') << "\"\n"
+      indent = increase_indent(indent)
+      branches.each {|b| b.dump_on(io, indent, indent)}
+      dump_outcome(io, indent)
+    end
+
+    def type
+      :sub_key
+    end
+  end
+
+  class ExplainKeySegment < ExplainTreeNode
+    def initialize(parent, segment)
+      super(parent)
+      @segment = segment
+    end
+
+    def dump_on(io, indent, first_indent)
+      dump_outcome(io, indent)
+    end
+
+    def type
+      :segment
+    end
+  end
+
+  class ExplainScope < ExplainTreeNode
+    def initialize(parent, name)
+      super(parent)
+      @name = name
+    end
+
+    def dump_on(io, indent, first_indent)
+      io << indent << @name << "\n"
+      indent = increase_indent(indent)
+      branches.each {|b| b.dump_on(io, indent, indent)}
+      dump_outcome(io, indent)
+    end
+
+    def to_hash
+      hash = super
+      hash[:name] = @name
+      hash
+    end
+
+    def type
+      :scope
+    end
+  end
+
+  class Explainer < ExplainNode
+    def initialize(explain_options = false, only_explain_options = false)
+      @current = self
+      @explain_options = explain_options
+      @only_explain_options = only_explain_options
+    end
+
+    def push(qualifier_type, qualifier)
+      node = case (qualifier_type)
+        when :global
+         ExplainGlobal.new(@current, qualifier)
+        when :location
+          ExplainLocation.new(@current, qualifier)
+        when :interpolate
+          ExplainInterpolate.new(@current, qualifier)
+        when :data_provider
+          ExplainDataProvider.new(@current, qualifier)
+        when :merge
+          ExplainMerge.new(@current, qualifier)
+        when :module
+          ExplainModule.new(@current, qualifier)
+        when :scope
+          ExplainScope.new(@current, qualifier)
+        when :sub_lookup
+          ExplainSubLookup.new(@current, qualifier)
+        when :segment
+          ExplainKeySegment.new(@current, qualifier)
+        when :meta, :data
+          ExplainTop.new(@current, qualifier_type, qualifier)
+        when :invalid_key
+          ExplainInvalidKey.new(@current, qualifier)
+        else
+          raise ArgumentError, "Unknown Explain type #{qualifier_type}"
+        end
+      @current.branches << node
+      @current = node
+    end
+
+    def only_explain_options?
+      @only_explain_options
+    end
+
+    def explain_options?
+      @explain_options
+    end
+
+    def pop
+      @current = @current.parent unless @current.parent.nil?
+    end
+
+    def accept_found_in_overrides(key, value)
+      @current.found_in_overrides(key, value)
+    end
+
+    def accept_found_in_defaults(key, value)
+      @current.found_in_defaults(key, value)
+    end
+
+    def accept_found(key, value)
+      @current.found(key, value)
+    end
+
+    def accept_merge_source(merge_source)
+      @current.branches << ExplainMergeSource.new(merge_source)
+    end
+
+    def accept_not_found(key)
+      @current.not_found(key)
+    end
+
+    def accept_location_not_found
+      @current.location_not_found
+    end
+
+    def accept_module_not_found(module_name)
+      push(:module, module_name)
+      @current.module_not_found
+      pop
+    end
+
+    def accept_module_provider_not_found(module_name)
+      push(:module, module_name)
+      @current.module_provider_not_found
+      pop
+    end
+
+    def accept_result(result)
+      @current.result(result)
+    end
+
+    def accept_text(text)
+      @current.text(text)
+    end
+
+    def dump_on(io, indent, first_indent)
+      branches.each { |b| b.dump_on(io, indent, first_indent) }
+      dump_texts(io, indent)
+    end
+
+    def to_hash
+      branches.size == 1 ? branches[0].to_hash : super
+    end
+  end
+
+  class DebugExplainer < Explainer
+    attr_reader :wrapped_explainer
+
+    def initialize(wrapped_explainer)
+      @wrapped_explainer = wrapped_explainer
+      if wrapped_explainer.nil?
+        @current = self
+        @explain_options = false
+        @only_explain_options = false
+      else
+        @current = wrapped_explainer
+        @explain_options = wrapped_explainer.explain_options?
+        @only_explain_options = wrapped_explainer.only_explain_options?
+      end
+    end
+
+    def dump_on(io, indent, first_indent)
+      @current.equal?(self) ? super : @current.dump_on(io, indent, first_indent)
+    end
+
+    def emit_debug_info(preamble)
+      io = ''
+      io << preamble << "\n"
+      dump_on(io, '  ', '  ')
+      Puppet.debug(io.chomp!)
+    end
+  end
+end
+end