diff --git a/lib/puppet/environments.rb b/lib/puppet/environments.rb
index a56e55c0d..03d3e8968 100644
--- a/lib/puppet/environments.rb
+++ b/lib/puppet/environments.rb
@@ -1,397 +1,397 @@
 # @api private
 module Puppet::Environments
 
   class EnvironmentNotFound < Puppet::Error
     def initialize(environment_name, original = nil)
       environmentpath = Puppet[:environmentpath]
       super("Could not find a directory environment named '#{environment_name}' anywhere in the path: #{environmentpath}. Does the directory exist?", original)
     end
   end
 
   # @api private
   module EnvironmentCreator
     # Create an anonymous environment.
     #
     # @param module_path [String] A list of module directories separated by the
     #   PATH_SEPARATOR
     # @param manifest [String] The path to the manifest
     # @return A new environment with the `name` `:anonymous`
     #
     # @api private
     def for(module_path, manifest)
       Puppet::Node::Environment.create(:anonymous,
                                        module_path.split(File::PATH_SEPARATOR),
                                        manifest)
     end
   end
 
   # Provide any common methods that loaders should have. It requires that any
   # classes that include this module implement get
   # @api private
   module EnvironmentLoader
     # @!macro loader_get_or_fail
     def get!(name)
       environment = get(name)
       if environment
         environment
       else
         raise EnvironmentNotFound, name
       end
     end
   end
 
   # @!macro [new] loader_search_paths
   #   A list of indicators of where the loader is getting its environments from.
   #   @return [Array<String>] The URIs of the load locations
   #
   # @!macro [new] loader_list
   #   @return [Array<Puppet::Node::Environment>] All of the environments known
   #     to the loader
   #
   # @!macro [new] loader_get
   #   Find a named environment
   #
   #   @param name [String,Symbol] The name of environment to find
   #   @return [Puppet::Node::Environment, nil] the requested environment or nil
   #     if it wasn't found
   #
   # @!macro [new] loader_get_conf
   #   Attempt to obtain the initial configuration for the environment.  Not all
   #   loaders can provide this.
   #
   #   @param name [String,Symbol] The name of the environment whose configuration
   #     we are looking up
   #   @return [Puppet::Setting::EnvironmentConf, nil] the configuration for the
   #     requested environment, or nil if not found or no configuration is available
   #
   # @!macro [new] loader_get_or_fail
   #   Find a named environment or raise
   #   Puppet::Environments::EnvironmentNotFound when the named environment is
   #   does not exist.
   #
   #   @param name [String,Symbol] The name of environment to find
   #   @return [Puppet::Node::Environment] the requested environment
 
   # A source of pre-defined environments.
   #
   # @api private
   class Static
     include EnvironmentCreator
     include EnvironmentLoader
 
     def initialize(*environments)
       @environments = environments
     end
 
     # @!macro loader_search_paths
     def search_paths
       ["data:text/plain,internal"]
     end
 
     # @!macro loader_list
     def list
       @environments
     end
 
     # @!macro loader_get
     def get(name)
       @environments.find do |env|
         env.name == name.intern
       end
     end
 
     # Returns a basic environment configuration object tied to the environment's
     # implementation values.  Will not interpolate.
     #
     # @!macro loader_get_conf
     def get_conf(name)
       env = get(name)
       if env
         Puppet::Settings::EnvironmentConf.static_for(env)
       else
         nil
       end
     end
   end
 
   # A source of unlisted pre-defined environments.
   #
   # Used only for internal bootstrapping environments which are not relevant
   # to an end user (such as the fall back 'configured' environment).
   #
   # @api private
   class StaticPrivate < Static
 
     # Unlisted
     #
     # @!macro loader_list
     def list
       []
     end
   end
 
   # Reads environments from a directory on disk. Each environment is
   # represented as a sub-directory. The environment's manifest setting is the
   # `manifest` directory of the environment directory. The environment's
   # modulepath setting is the global modulepath (from the `[master]` section
   # for the master) prepended with the `modules` directory of the environment
   # directory.
   #
   # @api private
   class Directories
     include EnvironmentLoader
 
     def initialize(environment_dir, global_module_path)
       @environment_dir = environment_dir
       @global_module_path = global_module_path
     end
 
     # Generate an array of directory loaders from a path string.
     # @param path [String] path to environment directories
     # @param global_module_path [Array<String>] the global modulepath setting
     # @return [Array<Puppet::Environments::Directories>] An array
     #   of configured directory loaders.
     def self.from_path(path, global_module_path)
       environments = path.split(File::PATH_SEPARATOR)
       environments.map do |dir|
         Puppet::Environments::Directories.new(dir, global_module_path)
       end
     end
 
     # @!macro loader_search_paths
     def search_paths
       ["file://#{@environment_dir}"]
     end
 
     # @!macro loader_list
     def list
       valid_directories.collect do |envdir|
         name = Puppet::FileSystem.basename_string(envdir).intern
 
         create_environment(name)
       end
     end
 
     # @!macro loader_get
     def get(name)
       if valid_directory?(File.join(@environment_dir, name.to_s))
         create_environment(name)
       end
     end
 
     # @!macro loader_get_conf
     def get_conf(name)
       envdir = File.join(@environment_dir, name.to_s)
       if valid_directory?(envdir)
         return Puppet::Settings::EnvironmentConf.load_from(envdir, @global_module_path)
       end
       nil
     end
 
     private
 
     def create_environment(name, setting_values = nil)
       env_symbol = name.intern
       setting_values = Puppet.settings.values(env_symbol, Puppet.settings.preferred_run_mode)
       Puppet::Node::Environment.create(
         env_symbol,
         Puppet::Node::Environment.split_path(setting_values.interpolate(:modulepath)),
         setting_values.interpolate(:manifest),
         setting_values.interpolate(:config_version)
       )
     end
 
     def valid_directory?(envdir)
       name = Puppet::FileSystem.basename_string(envdir)
       Puppet::FileSystem.directory?(envdir) &&
          Puppet::Node::Environment.valid_name?(name)
     end
 
     def valid_directories
       if Puppet::FileSystem.directory?(@environment_dir)
         Puppet::FileSystem.children(@environment_dir).select do |child|
           valid_directory?(child)
         end
       else
         []
       end
     end
   end
 
   # Combine together multiple loaders to act as one.
   # @api private
   class Combined
     include EnvironmentLoader
 
     def initialize(*loaders)
       @loaders = loaders
     end
 
     # @!macro loader_search_paths
     def search_paths
       @loaders.collect(&:search_paths).flatten
     end
 
     # @!macro loader_list
     def list
       @loaders.collect(&:list).flatten
     end
 
     # @!macro loader_get
     def get(name)
       @loaders.each do |loader|
         if env = loader.get(name)
           return env
         end
       end
       nil
     end
 
     # @!macro loader_get_conf
     def get_conf(name)
       @loaders.each do |loader|
         if conf = loader.get_conf(name)
           return conf
         end
       end
       nil
     end
 
   end
 
   class Cached
     include EnvironmentLoader
 
     class DefaultCacheExpirationService
       def created(env)
       end
 
       def expired?(env_name)
         false
       end
 
       def evicted(env_name)
       end
     end
 
     def self.cache_expiration_service=(service)
       @cache_expiration_service = service
     end
 
     def self.cache_expiration_service
       @cache_expiration_service || DefaultCacheExpirationService.new
     end
 
     def initialize(loader)
       @loader = loader
       @cache = {}
       @cache_expiration_service = Puppet::Environments::Cached.cache_expiration_service
     end
 
     # @!macro loader_list
     def list
       @loader.list
     end
 
     # @!macro loader_search_paths
     def search_paths
       @loader.search_paths
     end
 
     # @!macro loader_get
     def get(name)
       evict_if_expired(name)
       if result = @cache[name]
         return result.value
       elsif (result = @loader.get(name))
         @cache[name] = entry(result)
         result
       end
     end
 
     # Clears the cache of the environment with the given name.
     # (The intention is that this could be used from a MANUAL cache eviction command (TBD)
     def clear(name)
       @cache.delete(name)
     end
 
     # Clears all cached environments.
     # (The intention is that this could be used from a MANUAL cache eviction command (TBD)
     def clear_all()
       @cache = {}
     end
 
     # This implementation evicts the cache, and always gets the current
     # configuration of the environment
     #
     # TODO: While this is wasteful since it
     # needs to go on a search for the conf, it is too disruptive to optimize
     # this.
     #
     # @!macro loader_get_conf
     def get_conf(name)
       evict_if_expired(name)
       @loader.get_conf(name)
     end
 
     # Creates a suitable cache entry given the time to live for one environment
     #
     def entry(env)
       @cache_expiration_service.created(env)
       ttl = (conf = get_conf(env.name)) ? conf.environment_timeout : Puppet.settings.value(:environment_timeout)
-      Puppet.debug("Caching environment '#{env.name}' (cache ttl: #{ttl})")
+      Puppet.debug {"Caching environment '#{env.name}' (cache ttl: #{ttl})"}
       case ttl
       when 0
         NotCachedEntry.new(env)     # Entry that is always expired (avoids syscall to get time)
       when Float::INFINITY
         Entry.new(env)              # Entry that never expires (avoids syscall to get time)
       else
         TTLEntry.new(env, ttl)
       end
     end
 
     # Evicts the entry if it has expired
     # Also clears caches in Settings that may prevent the entry from being updated
     def evict_if_expired(name)
       if (result = @cache[name]) && (result.expired? || @cache_expiration_service.expired?(name))
-        Puppet.debug("Evicting cache entry for environment '#{name}'")
+      Puppet.debug {"Evicting cache entry for environment '#{name}'"}
         @cache.delete(name)
         @cache_expiration_service.evicted(name)
 
         Puppet.settings.clear_environment_settings(name)
       end
     end
 
     # Never evicting entry
     class Entry
       attr_reader :value
 
       def initialize(value)
         @value = value
       end
 
       def expired?
         false
       end
     end
 
     # Always evicting entry
     class NotCachedEntry < Entry
       def expired?
         true
       end
     end
 
     # Time to Live eviction policy entry
     class TTLEntry < Entry
       def initialize(value, ttl_seconds)
         super value
         @ttl = Time.now + ttl_seconds
       end
 
       def expired?
         Time.now > @ttl
       end
     end
   end
 end
diff --git a/lib/puppet/parser/ast/pops_bridge.rb b/lib/puppet/parser/ast/pops_bridge.rb
index a248f8b41..97385c24c 100644
--- a/lib/puppet/parser/ast/pops_bridge.rb
+++ b/lib/puppet/parser/ast/pops_bridge.rb
@@ -1,243 +1,243 @@
 require 'puppet/parser/ast/top_level_construct'
 require 'puppet/pops'
 
 # The AST::Bridge contains classes that bridges between the new Pops based model
 # and the 3.x AST. This is required to be able to reuse the Puppet::Resource::Type which is
 # fundamental for the rest of the logic.
 #
 class Puppet::Parser::AST::PopsBridge
 
   # Bridges to one Pops Model Expression
   # The @value is the expression
   # This is used to represent the body of a class, definition, or node, and for each parameter's default value
   # expression.
   #
   class Expression < Puppet::Parser::AST::Leaf
 
     def initialize args
       super
       @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
     end
 
     def to_s
       Puppet::Pops::Model::ModelTreeDumper.new.dump(@value)
     end
 
     def evaluate(scope)
       object = @@evaluator.evaluate(scope, @value)
       @@evaluator.convert_to_3x(object, scope)
     end
 
     # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
     # by yielding self. By adding this there is no need to wrap a pops expression inside an AST::BlockExpression
     #
     def each
       yield self
     end
 
     def sequence_with(other)
       if value.nil?
         # This happens when testing and not having a complete setup
         other
       else
         # When does this happen ? Ever ?
         raise "sequence_with called on Puppet::Parser::AST::PopsBridge::Expression - please report use case"
         # What should be done if the above happens (We don't want this to happen).
         # Puppet::Parser::AST::BlockExpression.new(:children => [self] + other.children)
       end
     end
 
     # The 3x requires code plugged in to an AST to have this in certain positions in the tree. The purpose
     # is to either print the content, or to look for things that needs to be defined. This implementation
     # cheats by always returning an empty array. (This allows simple files to not require a "Program" at the top.
     #
     def children
       []
     end
   end
 
   # Bridges the top level "Program" produced by the pops parser.
   # Its main purpose is to give one point where all definitions are instantiated (actually defined since the
   # Puppet 3x terminology is somewhat misleading - the definitions are instantiated, but instances of the created types
   # are not created, that happens when classes are included / required, nodes are matched and when resources are instantiated
   # by a resource expression (which is also used to instantiate a host class).
   #
   class Program < Puppet::Parser::AST::TopLevelConstruct
     attr_reader :program_model, :context
 
     def initialize(program_model, context = {})
       @program_model = program_model
       @context = context
       @ast_transformer ||= Puppet::Pops::Model::AstTransformer.new(@context[:file])
       @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
     end
 
     # This is the 3x API, the 3x AST searches through all code to find the instructions that can be instantiated.
     # This Pops-model based instantiation relies on the parser to build this list while parsing (which is more
     # efficient as it avoids one full scan of all logic via recursive enumeration/yield)
     #
     def instantiate(modname)
       @program_model.definitions.collect do |d|
         case d
         when Puppet::Pops::Model::HostClassDefinition
           instantiate_HostClassDefinition(d, modname)
         when Puppet::Pops::Model::ResourceTypeDefinition
           instantiate_ResourceTypeDefinition(d, modname)
         when Puppet::Pops::Model::NodeDefinition
           instantiate_NodeDefinition(d, modname)
         else
           raise Puppet::ParseError, "Internal Error: Unknown type of definition - got '#{d.class}'"
         end
       end.flatten().compact() # flatten since node definition may have returned an array
                               # Compact since functions are not understood by compiler
     end
 
     def evaluate(scope)
       @@evaluator.evaluate(scope, program_model)
     end
 
     # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
     # by yielding self. This means that the HostClass container will call this bridge instance with `instantiate`.
     #
     def each
       yield self
     end
 
     private
 
     def instantiate_Parameter(o)
       # 3x needs parameters as an array of `[name]` or `[name, value_expr]`
       if o.value
         [o.name, Expression.new(:value => o.value)]
       else
         [o.name]
       end
     end
 
     def create_type_map(definition)
       result = {}
       # No need to do anything if there are no parameters
       return result unless definition.parameters.size > 0
 
       # No need to do anything if there are no typed parameters
       typed_parameters = definition.parameters.select {|p| p.type_expr }
       return result if typed_parameters.empty?
 
       # If there are typed parameters, they need to be evaluated to produce the corresponding type
       # instances. This evaluation requires a scope. A scope is not available when doing deserialization
       # (there is also no initialized evaluator). When running apply and test however, the environment is
       # reused and we may reenter without a scope (which is fine). A debug message is then output in case
       # there is the need to track down the odd corner case. See {#obtain_scope}.
       #
       if scope = obtain_scope
         typed_parameters.each do |p|
           result[p.name] =  @@evaluator.evaluate(scope, p.type_expr)
         end
       end
       result
     end
 
     # Obtains the scope or issues a warning if :global_scope is not bound
     def obtain_scope
       scope = Puppet.lookup(:global_scope) do
         # This occurs when testing and when applying a catalog (there is no scope available then), and
         # when running tests that run a partial setup.
         # This is bad if the logic is trying to compile, but a warning can not be issues since it is a normal
         # use case that there is no scope when requesting the type in order to just get the parameters.
-        Puppet.debug("Instantiating Resource with type checked parameters - scope is missing, skipping type checking.")
+        Puppet.debug {"Instantiating Resource with type checked parameters - scope is missing, skipping type checking."}
         nil
       end
       scope
     end
 
     # Produces a hash with data for Definition and HostClass
     def args_from_definition(o, modname)
       args = {
        :arguments => o.parameters.collect {|p| instantiate_Parameter(p) },
        :argument_types => create_type_map(o),
        :module_name => modname
       }
       unless is_nop?(o.body)
         args[:code] = Expression.new(:value => o.body)
       end
       @ast_transformer.merge_location(args, o)
     end
 
     def instantiate_HostClassDefinition(o, modname)
       args = args_from_definition(o, modname)
       args[:parent] = absolute_reference(o.parent_class)
       Puppet::Resource::Type.new(:hostclass, o.name, @context.merge(args))
     end
 
     def instantiate_ResourceTypeDefinition(o, modname)
       Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname)))
     end
 
     def instantiate_NodeDefinition(o, modname)
       args = { :module_name => modname }
 
       unless is_nop?(o.body)
         args[:code] = Expression.new(:value => o.body)
       end
 
       unless is_nop?(o.parent)
         args[:parent] = @ast_transformer.hostname(o.parent)
       end
 
       host_matches = @ast_transformer.hostname(o.host_matches)
       @ast_transformer.merge_location(args, o)
       host_matches.collect do |name|
         Puppet::Resource::Type.new(:node, name, @context.merge(args))
       end
     end
 
     # Propagates a found Function to the appropriate loader.
     # This is for 4x evaluator/loader
     #
     def instantiate_FunctionDefinition(function_definition, modname)
       loaders = (Puppet.lookup(:loaders) { nil })
       unless loaders
         raise Puppet::ParseError, "Internal Error: Puppet Context ':loaders' missing - cannot define any functions"
       end
       loader =
       if modname.nil? || modname == ""
         # TODO : Later when functions can be private, a decision is needed regarding what that means.
         #        A private environment loader could be used for logic outside of modules, then only that logic
         #        would see the function.
         #
         # Use the private loader, this function may see the environment's dependencies (currently, all modules)
         loaders.private_environment_loader()
       else
         # TODO : Later check if function is private, and then add it to
         #        private_loader_for_module
         #
         loaders.public_loader_for_module(modname)
       end
       unless loader
         raise Puppet::ParseError, "Internal Error: did not find public loader for module: '#{modname}'"
       end
 
       # Instantiate Function, and store it in the environment loader
       typed_name, f = Puppet::Pops::Loader::PuppetFunctionInstantiator.create_from_model(function_definition, loader)
       loader.set_entry(typed_name, f, Puppet::Pops::Adapters::SourcePosAdapter.adapt(function_definition).to_uri)
 
       nil # do not want the function to inadvertently leak into 3x
     end
 
     def code()
       Expression.new(:value => @value)
     end
 
     def is_nop?(o)
       @ast_transformer.is_nop?(o)
     end
 
     def absolute_reference(ref)
       if ref.nil? || ref.empty? || ref.start_with?('::')
         ref
       else
         "::#{ref}"
       end
     end
   end
 end
diff --git a/lib/puppet/parser/relationship.rb b/lib/puppet/parser/relationship.rb
index f27949d09..e4e1d08b3 100644
--- a/lib/puppet/parser/relationship.rb
+++ b/lib/puppet/parser/relationship.rb
@@ -1,54 +1,54 @@
 class Puppet::Parser::Relationship
   attr_accessor :source, :target, :type
 
   PARAM_MAP = {:relationship => :before, :subscription => :notify}
 
   def arrayify(resources)
     case resources
     when Puppet::Pops::Evaluator::Collectors::AbstractCollector
       resources.collected.values
     when Array
       resources
     else
       [resources]
     end
   end
 
   def evaluate(catalog)
     arrayify(source).each do |s|
       arrayify(target).each do |t|
         mk_relationship(s, t, catalog)
       end
     end
   end
 
   def initialize(source, target, type)
     @source, @target, @type = source, target, type
   end
 
   def param_name
     PARAM_MAP[type] || raise(ArgumentError, "Invalid relationship type #{type}")
   end
 
   def mk_relationship(source, target, catalog)
     # There was once an assumption that this could be an array. These raise
     # assertions are here as a sanity check for 4.0 and can be removed after
     # a release or two
     raise ArgumentError, "source shouldn't be an array" if source.is_a?(Array)
     raise ArgumentError, "target shouldn't be an array" if target.is_a?(Array)
     source = source.to_s
     target = target.to_s
 
     unless source_resource = catalog.resource(source)
       raise ArgumentError, "Could not find resource '#{source}' for relationship on '#{target}'"
     end
     unless catalog.resource(target)
       raise ArgumentError, "Could not find resource '#{target}' for relationship from '#{source}'"
     end
-    Puppet.debug "Adding relationship from #{source} to #{target} with '#{param_name}'"
+    Puppet.debug {"Adding relationship from #{source} to #{target} with '#{param_name}'"}
     if source_resource[param_name].class != Array
       source_resource[param_name] = [source_resource[param_name]].compact
     end
     source_resource[param_name] << target
   end
 end
diff --git a/lib/puppet/parser/type_loader.rb b/lib/puppet/parser/type_loader.rb
index 2ee747ec8..deb159925 100644
--- a/lib/puppet/parser/type_loader.rb
+++ b/lib/puppet/parser/type_loader.rb
@@ -1,151 +1,151 @@
 require 'find'
 require 'forwardable'
 require 'puppet/parser/parser_factory'
 
 class Puppet::Parser::TypeLoader
   extend  Forwardable
 
   class TypeLoaderError < StandardError; end
 
   # Import manifest files that match a given file glob pattern.
   #
   # @param pattern [String] the file glob to apply when determining which files
   #   to load
   # @param dir [String] base directory to use when the file is not
   #   found in a module
   # @api private
   def import(pattern, dir)
     return if Puppet[:ignoreimport]
 
     modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
     if files.empty?
       abspat = File.expand_path(pattern, dir)
       file_pattern = abspat + (File.extname(abspat).empty? ? '.pp' : '' )
 
       files = Dir.glob(file_pattern).uniq.reject { |f| FileTest.directory?(f) }
       modname = nil
 
       if files.empty?
         raise_no_files_found(pattern)
       end
     end
 
     load_files(modname, files)
   end
 
   # Load all of the manifest files in all known modules.
   # @api private
   def import_all
     # And then load all files from each module, but (relying on system
     # behavior) only load files from the first module of a given name.  E.g.,
     # given first/foo and second/foo, only files from first/foo will be loaded.
     environment.modules.each do |mod|
       load_files(mod.name, mod.all_manifests)
     end
   end
 
   def_delegator :environment, :known_resource_types
 
   def initialize(env)
     self.environment = env
   end
 
   def environment
     @environment
   end
 
   def environment=(env)
     if env.is_a?(String) or env.is_a?(Symbol)
       @environment = Puppet.lookup(:environments).get!(env)
     else
       @environment = env
     end
   end
 
   # Try to load the object with the given fully qualified name.
   def try_load_fqname(type, fqname)
     return nil if fqname == "" # special-case main.
     files_to_try_for(fqname).each do |filename|
       begin
         imported_types = import_from_modules(filename)
         if result = imported_types.find { |t| t.type == type and t.name == fqname }
-          Puppet.debug "Automatically imported #{fqname} from #{filename} into #{environment}"
+          Puppet.debug {"Automatically imported #{fqname} from #{filename} into #{environment}"}
           return result
         end
       rescue TypeLoaderError => detail
         # I'm not convienced we should just drop these errors, but this
         # preserves existing behaviours.
       end
     end
     # Nothing found.
     return nil
   end
 
   def parse_file(file)
     Puppet.debug("importing '#{file}' in environment #{environment}")
     parser = Puppet::Parser::ParserFactory.parser
     parser.file = file
     return parser.parse
   end
 
   private
 
   def import_from_modules(pattern)
     modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
     if files.empty?
       raise_no_files_found(pattern)
     end
 
     load_files(modname, files)
   end
 
   def raise_no_files_found(pattern)
     raise TypeLoaderError, "No file(s) found for import of '#{pattern}'"
   end
 
   def load_files(modname, files)
     @loaded ||= {}
     loaded_asts = []
     files.reject { |file| @loaded[file] }.each do |file|
     # The squelch_parse_errors use case is for parsing for the purpose of searching
     # for information and it should not abort.
     # There is currently one user in indirector/resourcetype/parser
     #
     if Puppet.lookup(:squelch_parse_errors) {|| false }
         begin
           loaded_asts << parse_file(file)
         rescue => e
           # Resume from errors so that all parseable files may
           # still be parsed. Mark this file as loaded so that
           # it would not be parsed next time (handle it as if
           # it was successfully parsed).
           Puppet.debug("Unable to parse '#{file}': #{e.message}")
         end
       else
         loaded_asts << parse_file(file)
       end
 
       @loaded[file] = true
     end
 
     loaded_asts.collect do |ast|
       known_resource_types.import_ast(ast, modname)
     end.flatten
   end
 
   # Return a list of all file basenames that should be tried in order
   # to load the object with the given fully qualified name.
   def files_to_try_for(qualified_name)
     qualified_name.split('::').inject([]) do |paths, name|
       add_path_for_name(paths, name)
     end
   end
 
   def add_path_for_name(paths, name)
     if paths.empty?
       [name]
     else
       paths.unshift(File.join(paths.first, name))
     end
   end
 end
diff --git a/lib/puppet/pops/loaders.rb b/lib/puppet/pops/loaders.rb
index 6109fcb13..a07761bc7 100644
--- a/lib/puppet/pops/loaders.rb
+++ b/lib/puppet/pops/loaders.rb
@@ -1,238 +1,238 @@
 class Puppet::Pops::Loaders
   class LoaderError < Puppet::Error; end
 
   attr_reader :static_loader
   attr_reader :puppet_system_loader
   attr_reader :public_environment_loader
   attr_reader :private_environment_loader
 
   def initialize(environment)
     # The static loader can only be changed after a reboot
     @@static_loader ||= Puppet::Pops::Loader::StaticLoader.new()
 
     # Create the set of loaders
     # 1. Puppet, loads from the "running" puppet - i.e. bundled functions, types, extension points and extensions
     #    Does not change without rebooting the service running puppet.
     #
     @@puppet_system_loader ||= create_puppet_system_loader()
 
     # 2. Environment loader - i.e. what is bound across the environment, may change for each setup
     #    TODO: loaders need to work when also running in an agent doing catalog application. There is no
     #    concept of environment the same way as when running as a master (except when doing apply).
     #    The creation mechanisms should probably differ between the two.
     #
     @private_environment_loader = create_environment_loader(environment)
 
     # 3. module loaders are set up from the create_environment_loader, they register themselves
   end
 
   # Clears the cached static and puppet_system loaders (to enable testing)
   #
   def self.clear
     @@static_loader = nil
     @@puppet_system_loader = nil
   end
 
   def static_loader
     @@static_loader
   end
 
   def puppet_system_loader
     @@puppet_system_loader
   end
 
   def public_loader_for_module(module_name)
     md = @module_resolver[module_name] || (return nil)
     # Note, this loader is not resolved until there is interest in the visibility of entities from the
     # perspective of something contained in the module. (Many request may pass through a module loader
     # without it loading anything.
     # See {#private_loader_for_module}, and not in {#configure_loaders_for_modules}
     md.public_loader
   end
 
   def private_loader_for_module(module_name)
     md = @module_resolver[module_name] || (return nil)
     # Since there is interest in the visibility from the perspective of entities contained in the
     # module, it must be resolved (to provide this visibility).
     # See {#configure_loaders_for_modules}
     unless md.resolved?
       @module_resolver.resolve(md)
     end
     md.private_loader
   end
 
   private
 
   def create_puppet_system_loader()
     Puppet::Pops::Loader::ModuleLoaders.system_loader_from(static_loader, self)
   end
 
   def create_environment_loader(environment)
     # This defines where to start parsing/evaluating - the "initial import" (to use 3x terminology)
     # Is either a reference to a single .pp file, or a directory of manifests. If the environment becomes
     # a module and can hold functions, types etc. then these are available across all other modules without
     # them declaring this dependency - it is however valuable to be able to treat it the same way
     # bindings and other such system related configuration.
 
     # This is further complicated by the many options available:
     # - The environment may not have a directory, the code comes from one appointed 'manifest' (site.pp)
     # - The environment may have a directory and also point to a 'manifest'
     # - The code to run may be set in settings (code)
 
     # Further complication is that there is nothing specifying what the visibility is into
     # available modules. (3x is everyone sees everything).
     # Puppet binder currently reads confdir/bindings - that is bad, it should be using the new environment support.
 
     # The environment is not a namespace, so give it a nil "module_name"
     module_name = nil
     loader_name = "environment:#{environment.name}"
     env_conf = Puppet.lookup(:environments).get_conf(environment.name)
     if env_conf.nil? || !env_conf.is_a?(Puppet::Settings::EnvironmentConf)
       # Not a real directory environment, cannot work as a module TODO: Drop when legacy env are dropped?
       loader = Puppet::Pops::Loader::SimpleEnvironmentLoader.new(puppet_system_loader, loader_name)
     else
       # View the environment as a module to allow loading from it - this module is always called 'environment'
       loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(puppet_system_loader, self, 'environment', env_conf.path_to_env)
     end
 
     # An environment has a module path even if it has a null loader
     configure_loaders_for_modules(loader, environment)
     # modules should see this loader
     @public_environment_loader = loader
 
     # Code in the environment gets to see all modules (since there is no metadata for the environment)
     # but since this is not given to the module loaders, they can not load global code (since they can not
     # have prior knowledge about this
     loader = Puppet::Pops::Loader::DependencyLoader.new(loader, "environment", @module_resolver.all_module_loaders())
 
     # The module loader gets the private loader via a lazy operation to look up the module's private loader.
     # This does not work for an environment since it is not resolved the same way.
     # TODO: The EnvironmentLoader could be a specialized loader instead of using a ModuleLoader to do the work.
     #       This is subject to future design - an Environment may move more in the direction of a Module.
     @public_environment_loader.private_loader = loader
     loader
   end
 
   def configure_loaders_for_modules(parent_loader, environment)
     @module_resolver = mr = ModuleResolver.new()
     environment.modules.each do |puppet_module|
       # Create data about this module
       md = LoaderModuleData.new(puppet_module)
       mr[puppet_module.name] = md
       md.public_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(parent_loader, self, md.name, md.path)
     end
     # NOTE: Do not resolve all modules here - this is wasteful if only a subset of modules / functions are used
     #       The resolution is triggered by asking for a module's private loader, since this means there is interest
     #       in the visibility from that perspective.
     #       If later, it is wanted that all resolutions should be made up-front (to capture errors eagerly, this
     #       can be introduced (better for production), but may be irritating in development mode.
   end
 
   # =LoaderModuleData
   # Information about a Module and its loaders.
   # TODO: should have reference to real model element containing all module data; this is faking it
   # TODO: Should use Puppet::Module to get the metadata (as a hash) - a somewhat blunt instrument, but that is
   #       what is available with a reasonable API.
   #
   class LoaderModuleData
 
     attr_accessor :state
     attr_accessor :public_loader
     attr_accessor :private_loader
     attr_accessor :resolutions
 
     # The Puppet::Module this LoaderModuleData represents in the loader configuration
     attr_reader :puppet_module
 
     # @param puppet_module [Puppet::Module] the module instance for the module being represented
     #
     def initialize(puppet_module)
       @state = :initial
       @puppet_module = puppet_module
       @resolutions = []
       @public_loader = nil
       @private_loader = nil
     end
 
     def name
       @puppet_module.name
     end
 
     def version
       @puppet_module.version
     end
 
     def path
       @puppet_module.path
     end
 
     def resolved?
       @state == :resolved
     end
 
     def restrict_to_dependencies?
       @puppet_module.has_metadata?
     end
 
     def unmet_dependencies?
       @puppet_module.unmet_dependencies.any?
     end
 
     def dependency_names
       @puppet_module.dependencies_as_modules.collect(&:name)
     end
   end
 
   # Resolves module loaders - resolution of model dependencies is done by Puppet::Module
   #
   class ModuleResolver
 
     def initialize()
       @index = {}
       @all_module_loaders = nil
     end
 
     def [](name)
       @index[name]
     end
 
     def []=(name, module_data)
       @index[name] = module_data
     end
 
     def all_module_loaders
       @all_module_loaders ||= @index.values.map {|md| md.public_loader }
     end
 
     def resolve(module_data)
       if module_data.resolved?
         return
       else
         module_data.private_loader =
           if module_data.restrict_to_dependencies?
             create_loader_with_only_dependencies_visible(module_data)
           else
             create_loader_with_all_modules_visible(module_data)
           end
       end
     end
 
     private
 
     def create_loader_with_all_modules_visible(from_module_data)
-      Puppet.debug("ModuleLoader: module '#{from_module_data.name}' has unknown dependencies - it will have all other modules visible")
+      Puppet.debug{"ModuleLoader: module '#{from_module_data.name}' has unknown dependencies - it will have all other modules visible"}
 
       Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, all_module_loaders())
     end
 
     def create_loader_with_only_dependencies_visible(from_module_data)
       if from_module_data.unmet_dependencies?
         Puppet.warning("ModuleLoader: module '#{from_module_data.name}' has unresolved dependencies"+
           " - it will only see those that are resolved."+
           " Use 'puppet module list --tree' to see information about modules")
       end
       dependency_loaders = from_module_data.dependency_names.collect { |name| @index[name].public_loader }
       Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, dependency_loaders)
     end
   end
 end
diff --git a/lib/puppet/resource/type_collection.rb b/lib/puppet/resource/type_collection.rb
index 0de1eefc1..5d46807ca 100644
--- a/lib/puppet/resource/type_collection.rb
+++ b/lib/puppet/resource/type_collection.rb
@@ -1,180 +1,183 @@
 require 'puppet/parser/type_loader'
 require 'puppet/util/file_watcher'
 require 'puppet/util/warnings'
 
 class Puppet::Resource::TypeCollection
   attr_reader :environment
   attr_accessor :parse_failed
 
   include Puppet::Util::Warnings
 
   def clear
     @hostclasses.clear
     @definitions.clear
     @nodes.clear
     @notfound.clear
   end
 
   def initialize(env)
     @environment = env
     @hostclasses = {}
     @definitions = {}
     @nodes = {}
     @notfound = {}
 
     # So we can keep a list and match the first-defined regex
     @node_list = []
   end
 
   def import_ast(ast, modname)
     ast.instantiate(modname).each do |instance|
       add(instance)
     end
   end
 
   def inspect
     "TypeCollection" + { :hostclasses => @hostclasses.keys, :definitions => @definitions.keys, :nodes => @nodes.keys }.inspect
   end
 
   def <<(thing)
     add(thing)
     self
   end
 
   def add(instance)
     if instance.type == :hostclass and other = @hostclasses[instance.name] and other.type == :hostclass
       other.merge(instance)
       return other
     end
     method = "add_#{instance.type}"
     send(method, instance)
     instance.resource_type_collection = self
     instance
   end
 
   def add_hostclass(instance)
     dupe_check(instance, @hostclasses) { |dupe| "Class '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
     dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined as a class" }
 
     @hostclasses[instance.name] = instance
     instance
   end
 
   def hostclass(name)
     @hostclasses[munge_name(name)]
   end
 
   def add_node(instance)
     dupe_check(instance, @nodes) { |dupe| "Node '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
 
     @node_list << instance
     @nodes[instance.name] = instance
     instance
   end
 
   def loader
     @loader ||= Puppet::Parser::TypeLoader.new(environment)
   end
 
   def node(name)
     name = munge_name(name)
 
     if node = @nodes[name]
       return node
     end
 
     @node_list.each do |node|
       next unless node.name_is_regex?
       return node if node.match(name)
     end
     nil
   end
 
   def node_exists?(name)
     @nodes[munge_name(name)]
   end
 
   def nodes?
     @nodes.length > 0
   end
 
   def add_definition(instance)
     dupe_check(instance, @hostclasses) { |dupe| "'#{instance.name}' is already defined#{dupe.error_context} as a class; cannot redefine as a definition" }
     dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined" }
     @definitions[instance.name] = instance
   end
 
   def definition(name)
     @definitions[munge_name(name)]
   end
 
   def find_node(name)
     @nodes[munge_name(name)]
   end
 
   def find_hostclass(name)
     find_or_load(name, :hostclass)
   end
 
   def find_definition(name)
     find_or_load(name, :definition)
   end
 
   [:hostclasses, :nodes, :definitions].each do |m|
     define_method(m) do
       instance_variable_get("@#{m}").dup
     end
   end
 
   def parse_failed?
     @parse_failed
   end
 
   def version
     if !defined?(@version)
       if environment.config_version.nil? || environment.config_version == ""
         @version = Time.now.to_i
       else
         @version = Puppet::Util::Execution.execute([environment.config_version]).strip
       end
     end
 
     @version
   rescue Puppet::ExecutionFailure => e
     raise Puppet::ParseError, "Execution of config_version command `#{environment.config_version}` failed: #{e.message}", e.backtrace
   end
 
   private
 
   COLON_COLON = "::".freeze
 
   # Resolve namespaces and find the given object.  Autoload it if
   # necessary.
   def find_or_load(name, type)
     # Name is always absolute, but may start with :: which must be removed
     fqname = (name[0,2] == COLON_COLON ? name[2..-1] : name)
 
     result = send(type, fqname)
     unless result
       if @notfound[ fqname ] && Puppet[ :ignoremissingtypes ]
         # do not try to autoload if we already tried and it wasn't conclusive
         # as this is a time consuming operation. Warn the user.
-        debug_once "Not attempting to load #{type} #{fqname} as this object was missing during a prior compilation"
+        # Check first if debugging is on since the call to debug_once is expensive
+        if Puppet[:debug]
+          debug_once "Not attempting to load #{type} #{fqname} as this object was missing during a prior compilation"
+        end
       else
         result = loader.try_load_fqname(type, fqname)
         @notfound[ fqname ] = result.nil?
       end
     end
     result
   end
 
   def munge_name(name)
     name.to_s.downcase
   end
 
   def dupe_check(instance, hash)
     return unless dupe = hash[instance.name]
     message = yield dupe
     instance.fail Puppet::ParseError, message
   end
 end
diff --git a/lib/puppet/settings.rb b/lib/puppet/settings.rb
index 895abd495..46be3c07c 100644
--- a/lib/puppet/settings.rb
+++ b/lib/puppet/settings.rb
@@ -1,1461 +1,1461 @@
 require 'puppet'
 require 'getoptlong'
 require 'puppet/util/watched_file'
 require 'puppet/util/command_line/puppet_option_parser'
 require 'forwardable'
 
 # The class for handling configuration files.
 class Puppet::Settings
   extend Forwardable
   include Enumerable
 
   require 'puppet/settings/errors'
   require 'puppet/settings/base_setting'
   require 'puppet/settings/string_setting'
   require 'puppet/settings/enum_setting'
   require 'puppet/settings/array_setting'
   require 'puppet/settings/file_setting'
   require 'puppet/settings/directory_setting'
   require 'puppet/settings/file_or_directory_setting'
   require 'puppet/settings/path_setting'
   require 'puppet/settings/boolean_setting'
   require 'puppet/settings/terminus_setting'
   require 'puppet/settings/duration_setting'
   require 'puppet/settings/ttl_setting'
   require 'puppet/settings/priority_setting'
   require 'puppet/settings/autosign_setting'
   require 'puppet/settings/config_file'
   require 'puppet/settings/value_translator'
   require 'puppet/settings/environment_conf'
 
   # local reference for convenience
   PuppetOptionParser = Puppet::Util::CommandLine::PuppetOptionParser
 
   attr_accessor :files
   attr_reader :timer
 
   # These are the settings that every app is required to specify; there are
   # reasonable defaults defined in application.rb.
   REQUIRED_APP_SETTINGS = [:logdir, :confdir, :vardir]
 
   # The acceptable sections of the puppet.conf configuration file.
   ALLOWED_SECTION_NAMES = ['main', 'master', 'agent', 'user'].freeze
 
   # This method is intended for puppet internal use only; it is a convenience method that
   # returns reasonable application default settings values for a given run_mode.
   def self.app_defaults_for_run_mode(run_mode)
     {
         :name     => run_mode.to_s,
         :run_mode => run_mode.name,
         :confdir  => run_mode.conf_dir,
         :vardir   => run_mode.var_dir,
         :rundir   => run_mode.run_dir,
         :logdir   => run_mode.log_dir,
     }
   end
 
   def self.default_certname()
     hostname = hostname_fact
     domain = domain_fact
     if domain and domain != ""
       fqdn = [hostname, domain].join(".")
     else
       fqdn = hostname
     end
     fqdn.to_s.gsub(/\.$/, '')
   end
 
   def self.hostname_fact()
     Facter.value :hostname
   end
 
   def self.domain_fact()
     Facter.value :domain
   end
 
   def self.default_config_file_name
     "puppet.conf"
   end
 
   # Create a new collection of config settings.
   def initialize
     @config = {}
     @shortnames = {}
 
     @created = []
 
     # Keep track of set values.
     @value_sets = {
       :cli => Values.new(:cli, @config),
       :memory => Values.new(:memory, @config),
       :application_defaults => Values.new(:application_defaults, @config),
       :overridden_defaults => Values.new(:overridden_defaults, @config),
     }
     @configuration_file = nil
 
     # And keep a per-environment cache
     @cache = Hash.new { |hash, key| hash[key] = {} }
     @values = Hash.new { |hash, key| hash[key] = {} }
 
     # The list of sections we've used.
     @used = []
 
     @hooks_to_call_on_application_initialization = []
     @deprecated_setting_names = []
     @deprecated_settings_that_have_been_configured = []
 
     @translate = Puppet::Settings::ValueTranslator.new
     @config_file_parser = Puppet::Settings::ConfigFile.new(@translate)
   end
 
   # @param name [Symbol] The name of the setting to fetch
   # @return [Puppet::Settings::BaseSetting] The setting object
   def setting(name)
     @config[name]
   end
 
   # Retrieve a config value
   # @param param [Symbol] the name of the setting
   # @return [Object] the value of the setting
   # @api private
   def [](param)
     if @deprecated_setting_names.include?(param)
       issue_deprecation_warning(setting(param), "Accessing '#{param}' as a setting is deprecated.")
     end
     value(param)
   end
 
   # Set a config value.  This doesn't set the defaults, it sets the value itself.
   # @param param [Symbol] the name of the setting
   # @param value [Object] the new value of the setting
   # @api private
   def []=(param, value)
     if @deprecated_setting_names.include?(param)
       issue_deprecation_warning(setting(param), "Modifying '#{param}' as a setting is deprecated.")
     end
     @value_sets[:memory].set(param, value)
     unsafe_flush_cache
   end
 
   # Create a new default value for the given setting. The default overrides are
   # higher precedence than the defaults given in defaults.rb, but lower
   # precedence than any other values for the setting. This allows one setting
   # `a` to change the default of setting `b`, but still allow a user to provide
   # a value for setting `b`.
   #
   # @param param [Symbol] the name of the setting
   # @param value [Object] the new default value for the setting
   # @api private
   def override_default(param, value)
     @value_sets[:overridden_defaults].set(param, value)
     unsafe_flush_cache
   end
 
   # Generate the list of valid arguments, in a format that GetoptLong can
   # understand, and add them to the passed option list.
   def addargs(options)
     # Add all of the settings as valid options.
     self.each { |name, setting|
       setting.getopt_args.each { |args| options << args }
     }
 
     options
   end
 
   # Generate the list of valid arguments, in a format that OptionParser can
   # understand, and add them to the passed option list.
   def optparse_addargs(options)
     # Add all of the settings as valid options.
     self.each { |name, setting|
       options << setting.optparse_args
     }
 
     options
   end
 
   # Is our setting a boolean setting?
   def boolean?(param)
     param = param.to_sym
     @config.include?(param) and @config[param].kind_of?(BooleanSetting)
   end
 
   # Remove all set values, potentially skipping cli values.
   def clear
     unsafe_clear
   end
 
   # Remove all set values, potentially skipping cli values.
   def unsafe_clear(clear_cli = true, clear_application_defaults = false)
     if clear_application_defaults
       @value_sets[:application_defaults] = Values.new(:application_defaults, @config)
       @app_defaults_initialized = false
     end
 
     if clear_cli
       @value_sets[:cli] = Values.new(:cli, @config)
 
       # Only clear the 'used' values if we were explicitly asked to clear out
       #  :cli values; otherwise, it may be just a config file reparse,
       #  and we want to retain this cli values.
       @used = []
     end
 
     @value_sets[:memory] = Values.new(:memory, @config)
     @value_sets[:overridden_defaults] = Values.new(:overridden_defaults, @config)
 
     @deprecated_settings_that_have_been_configured.clear
     @values.clear
     @cache.clear
   end
   private :unsafe_clear
 
   # Clears all cached settings for a particular environment to ensure
   # that changes to environment.conf are reflected in the settings if
   # the environment timeout has expired.
   #
   # param [String, Symbol] environment the  name of environment to clear settings for
   #
   # @api private
   def clear_environment_settings(environment)
 
     if environment.nil?
       return
     end
 
     @cache[environment.to_sym].clear
     @values[environment.to_sym] = {}
   end
 
   # Clear @cache, @used and the Environment.
   #
   # Whenever an object is returned by Settings, a copy is stored in @cache.
   # As long as Setting attributes that determine the content of returned
   # objects remain unchanged, Settings can keep returning objects from @cache
   # without re-fetching or re-generating them.
   #
   # Whenever a Settings attribute changes, such as @values or @preferred_run_mode,
   # this method must be called to clear out the caches so that updated
   # objects will be returned.
   def flush_cache
     unsafe_flush_cache
   end
 
   def unsafe_flush_cache
     clearused
   end
   private :unsafe_flush_cache
 
   def clearused
     @cache.clear
     @used = []
   end
 
   def global_defaults_initialized?()
     @global_defaults_initialized
   end
 
   def initialize_global_settings(args = [])
     raise Puppet::DevError, "Attempting to initialize global default settings more than once!" if global_defaults_initialized?
 
     # The first two phases of the lifecycle of a puppet application are:
     # 1) Parse the command line options and handle any of them that are
     #    registered, defined "global" puppet settings (mostly from defaults.rb).
     # 2) Parse the puppet config file(s).
 
     parse_global_options(args)
     parse_config_files
 
     @global_defaults_initialized = true
   end
 
   # This method is called during application bootstrapping.  It is responsible for parsing all of the
   # command line options and initializing the settings accordingly.
   #
   # It will ignore options that are not defined in the global puppet settings list, because they may
   # be valid options for the specific application that we are about to launch... however, at this point
   # in the bootstrapping lifecycle, we don't yet know what that application is.
   def parse_global_options(args)
     # Create an option parser
     option_parser = PuppetOptionParser.new
     option_parser.ignore_invalid_options = true
 
     # Add all global options to it.
     self.optparse_addargs([]).each do |option|
       option_parser.on(*option) do |arg|
         opt, val = Puppet::Settings.clean_opt(option[0], arg)
         handlearg(opt, val)
       end
     end
 
     option_parser.on('--run_mode',
                      "The effective 'run mode' of the application: master, agent, or user.",
                      :REQUIRED) do |arg|
       Puppet.settings.preferred_run_mode = arg
     end
 
     option_parser.parse(args)
 
     # remove run_mode options from the arguments so that later parses don't think
     # it is an unknown option.
     while option_index = args.index('--run_mode') do
       args.delete_at option_index
       args.delete_at option_index
     end
     args.reject! { |arg| arg.start_with? '--run_mode=' }
   end
   private :parse_global_options
 
   # A utility method (public, is used by application.rb and perhaps elsewhere) that munges a command-line
   # option string into the format that Puppet.settings expects.  (This mostly has to deal with handling the
   # "no-" prefix on flag/boolean options).
   #
   # @param [String] opt the command line option that we are munging
   # @param [String, TrueClass, FalseClass] val the value for the setting (as determined by the OptionParser)
   def self.clean_opt(opt, val)
     # rewrite --[no-]option to --no-option if that's what was given
     if opt =~ /\[no-\]/ and !val
       opt = opt.gsub(/\[no-\]/,'no-')
     end
     # otherwise remove the [no-] prefix to not confuse everybody
     opt = opt.gsub(/\[no-\]/, '')
     [opt, val]
   end
 
 
   def app_defaults_initialized?
     @app_defaults_initialized
   end
 
   def initialize_app_defaults(app_defaults)
     REQUIRED_APP_SETTINGS.each do |key|
       raise SettingsError, "missing required app default setting '#{key}'" unless app_defaults.has_key?(key)
     end
 
     app_defaults.each do |key, value|
       if key == :run_mode
         self.preferred_run_mode = value
       else
         @value_sets[:application_defaults].set(key, value)
         unsafe_flush_cache
       end
     end
     apply_metadata
     call_hooks_deferred_to_application_initialization
     issue_deprecations
 
     @app_defaults_initialized = true
   end
 
   def call_hooks_deferred_to_application_initialization(options = {})
     @hooks_to_call_on_application_initialization.each do |setting|
       begin
         setting.handle(self.value(setting.name))
       rescue InterpolationError => err
         raise InterpolationError, err, err.backtrace unless options[:ignore_interpolation_dependency_errors]
         #swallow. We're not concerned if we can't call hooks because dependencies don't exist yet
         #we'll get another chance after application defaults are initialized
       end
     end
   end
   private :call_hooks_deferred_to_application_initialization
 
   # Return a value's description.
   def description(name)
     if obj = @config[name.to_sym]
       obj.desc
     else
       nil
     end
   end
 
   def_delegator :@config, :each
 
   # Iterate over each section name.
   def eachsection
     yielded = []
     @config.each do |name, object|
       section = object.section
       unless yielded.include? section
         yield section
         yielded << section
       end
     end
   end
 
   # Return an object by name.
   def setting(param)
     param = param.to_sym
     @config[param]
   end
 
   # Handle a command-line argument.
   def handlearg(opt, value = nil)
     @cache.clear
 
     if value.is_a?(FalseClass)
       value = "false"
     elsif value.is_a?(TrueClass)
       value = "true"
     end
 
     value &&= @translate[value]
     str = opt.sub(/^--/,'')
 
     bool = true
     newstr = str.sub(/^no-/, '')
     if newstr != str
       str = newstr
       bool = false
     end
     str = str.intern
 
     if @config[str].is_a?(Puppet::Settings::BooleanSetting)
       if value == "" or value.nil?
         value = bool
       end
     end
 
     if s = @config[str]
       @deprecated_settings_that_have_been_configured << s if s.completely_deprecated?
     end
 
     @value_sets[:cli].set(str, value)
     unsafe_flush_cache
   end
 
   def include?(name)
     name = name.intern if name.is_a? String
     @config.include?(name)
   end
 
   # check to see if a short name is already defined
   def shortinclude?(short)
     short = short.intern if name.is_a? String
     @shortnames.include?(short)
   end
 
   # Prints the contents of a config file with the available config settings, or it
   # prints a single value of a config setting.
   def print_config_options
     env = value(:environment)
     val = value(:configprint)
     if val == "all"
       hash = {}
       each do |name, obj|
         val = value(name,env)
         val = val.inspect if val == ""
         hash[name] = val
       end
       hash.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, val|
         puts "#{name} = #{val}"
       end
     else
       val.split(/\s*,\s*/).sort.each do |v|
         if include?(v)
           #if there is only one value, just print it for back compatibility
           if v == val
             puts value(val,env)
             break
           end
           puts "#{v} = #{value(v,env)}"
         else
           puts "invalid setting: #{v}"
           return false
         end
       end
     end
     true
   end
 
   def generate_config
     puts to_config
     true
   end
 
   def generate_manifest
     puts to_manifest
     true
   end
 
   def print_configs
     return print_config_options if value(:configprint) != ""
     return generate_config if value(:genconfig)
     generate_manifest if value(:genmanifest)
   end
 
   def print_configs?
     (value(:configprint) != "" || value(:genconfig) || value(:genmanifest)) && true
   end
 
   # Return a given object's file metadata.
   def metadata(param)
     if obj = @config[param.to_sym] and obj.is_a?(FileSetting)
       {
         :owner => obj.owner,
         :group => obj.group,
         :mode => obj.mode
       }.delete_if { |key, value| value.nil? }
     else
       nil
     end
   end
 
   # Make a directory with the appropriate user, group, and mode
   def mkdir(default)
     obj = get_config_file_default(default)
 
     Puppet::Util::SUIDManager.asuser(obj.owner, obj.group) do
       mode = obj.mode || 0750
       Dir.mkdir(obj.value, mode)
     end
   end
 
   # The currently configured run mode that is preferred for constructing the application configuration.
   def preferred_run_mode
     @preferred_run_mode_name || :user
   end
 
   # PRIVATE!  This only exists because we need a hook to validate the run mode when it's being set, and
   #  it should never, ever, ever, ever be called from outside of this file.
   # This method is also called when --run_mode MODE is used on the command line to set the default
   #
   # @param mode [String|Symbol] the name of the mode to have in effect
   # @api private
   def preferred_run_mode=(mode)
     mode = mode.to_s.downcase.intern
     raise ValidationError, "Invalid run mode '#{mode}'" unless [:master, :agent, :user].include?(mode)
     @preferred_run_mode_name = mode
     # Changing the run mode has far-reaching consequences. Flush any cached
     # settings so they will be re-generated.
     flush_cache
     mode
   end
 
   # Return all of the settings associated with a given section.
   def params(section = nil)
     if section
       section = section.intern if section.is_a? String
       @config.find_all { |name, obj|
         obj.section == section
       }.collect { |name, obj|
         name
       }
     else
       @config.keys
     end
   end
 
   def parse_config(text, file = "text")
     begin
       data = @config_file_parser.parse_file(file, text, ALLOWED_SECTION_NAMES)
     rescue => detail
       Puppet.log_exception(detail, "Could not parse #{file}: #{detail}")
       return
     end
 
     # If we get here and don't have any data, we just return and don't muck with the current state of the world.
     return if data.nil?
 
     # If we get here then we have some data, so we need to clear out any
     # previous settings that may have come from config files.
     unsafe_clear(false, false)
 
     # Screen settings which have been deprecated and removed from puppet.conf
     # but are still valid on the command line and/or in environment.conf
     screen_non_puppet_conf_settings(data)
 
     # Make note of deprecated settings we will warn about later in initialization
     record_deprecations_from_puppet_conf(data)
 
     # And now we can repopulate with the values from our last parsing of the config files.
     @configuration_file = data
 
     # Determine our environment, if we have one.
     if @config[:environment]
       env = self.value(:environment).to_sym
     else
       env = "none"
     end
 
     # Call any hooks we should be calling.
     value_sets = value_sets_for(env, preferred_run_mode)
     @config.values.select(&:has_hook?).each do |setting|
       value_sets.each do |source|
         if source.include?(setting.name)
           # We still have to use value to retrieve the value, since
           # we want the fully interpolated value, not $vardir/lib or whatever.
           # This results in extra work, but so few of the settings
           # will have associated hooks that it ends up being less work this
           # way overall.
           if setting.call_hook_on_initialize?
             @hooks_to_call_on_application_initialization << setting
           else
             setting.handle(ChainedValues.new(
               preferred_run_mode,
               env,
               value_sets,
               @config).interpolate(setting.name))
           end
           break
         end
       end
     end
 
     call_hooks_deferred_to_application_initialization :ignore_interpolation_dependency_errors => true
     apply_metadata
   end
 
   # Parse the configuration file.  Just provides thread safety.
   def parse_config_files
     file = which_configuration_file
     if Puppet::FileSystem.exist?(file)
       begin
         text = read_file(file)
       rescue => detail
         Puppet.log_exception(detail, "Could not load #{file}: #{detail}")
         return
       end
     else
       return
     end
 
     parse_config(text, file)
   end
   private :parse_config_files
 
   def main_config_file
     if explicit_config_file?
       return self[:config]
     else
       return File.join(Puppet::Util::RunMode[:master].conf_dir, config_file_name)
     end
   end
   private :main_config_file
 
   def user_config_file
     return File.join(Puppet::Util::RunMode[:user].conf_dir, config_file_name)
   end
   private :user_config_file
 
   # This method is here to get around some life-cycle issues.  We need to be
   # able to determine the config file name before the settings / defaults are
   # fully loaded.  However, we also need to respect any overrides of this value
   # that the user may have specified on the command line.
   #
   # The easiest way to do this is to attempt to read the setting, and if we
   # catch an error (meaning that it hasn't been set yet), we'll fall back to
   # the default value.
   def config_file_name
     begin
       return self[:config_file_name] if self[:config_file_name]
     rescue SettingsError
       # This just means that the setting wasn't explicitly set on the command line, so we will ignore it and
       #  fall through to the default name.
     end
     return self.class.default_config_file_name
   end
   private :config_file_name
 
   def apply_metadata
     # We have to do it in the reverse of the search path,
     # because multiple sections could set the same value
     # and I'm too lazy to only set the metadata once.
     if @configuration_file
       searchpath(nil, preferred_run_mode).reverse.each do |source|
         if source.type == :section && section = @configuration_file.sections[source.name]
           apply_metadata_from_section(section)
         end
       end
     end
   end
   private :apply_metadata
 
   def apply_metadata_from_section(section)
     section.settings.each do |setting|
       if setting.has_metadata? && type = @config[setting.name]
         type.set_meta(setting.meta)
       end
     end
   end
 
   SETTING_TYPES = {
       :string     => StringSetting,
       :file       => FileSetting,
       :directory  => DirectorySetting,
       :file_or_directory => FileOrDirectorySetting,
       :path       => PathSetting,
       :boolean    => BooleanSetting,
       :terminus   => TerminusSetting,
       :duration   => DurationSetting,
       :ttl        => TTLSetting,
       :array      => ArraySetting,
       :enum       => EnumSetting,
       :priority   => PrioritySetting,
       :autosign   => AutosignSetting,
   }
 
   # Create a new setting.  The value is passed in because it's used to determine
   # what kind of setting we're creating, but the value itself might be either
   # a default or a value, so we can't actually assign it.
   #
   # See #define_settings for documentation on the legal values for the ":type" option.
   def newsetting(hash)
     klass = nil
     hash[:section] = hash[:section].to_sym if hash[:section]
 
     if type = hash[:type]
       unless klass = SETTING_TYPES[type]
         raise ArgumentError, "Invalid setting type '#{type}'"
       end
       hash.delete(:type)
     else
       # The only implicit typing we still do for settings is to fall back to "String" type if they didn't explicitly
       # specify a type.  Personally I'd like to get rid of this too, and make the "type" option mandatory... but
       # there was a little resistance to taking things quite that far for now.  --cprice 2012-03-19
       klass = StringSetting
     end
     hash[:settings] = self
     setting = klass.new(hash)
 
     setting
   end
 
   # This has to be private, because it doesn't add the settings to @config
   private :newsetting
 
   # Iterate across all of the objects in a given section.
   def persection(section)
     section = section.to_sym
     self.each { |name, obj|
       if obj.section == section
         yield obj
       end
     }
   end
 
   # Reparse our config file, if necessary.
   def reparse_config_files
     if files
       if filename = any_files_changed?
         Puppet.notice "Config file #{filename} changed; triggering re-parse of all config files."
         parse_config_files
         reuse
       end
     end
   end
 
   def files
     return @files if @files
     @files = []
     [main_config_file, user_config_file].each do |path|
       if Puppet::FileSystem.exist?(path)
         @files << Puppet::Util::WatchedFile.new(path)
       end
     end
     @files
   end
   private :files
 
   # Checks to see if any of the config files have been modified
   # @return the filename of the first file that is found to have changed, or
   #   nil if no files have changed
   def any_files_changed?
     files.each do |file|
       return file.to_str if file.changed?
     end
     nil
   end
   private :any_files_changed?
 
   def reuse
     return unless defined?(@used)
     new = @used
     @used = []
     self.use(*new)
   end
 
   class SearchPathElement < Struct.new(:name, :type); end
 
   # The order in which to search for values.
   #
   # @param environment [String,Symbol] symbolic reference to an environment name
   # @param run_mode [Symbol] symbolic reference to a Puppet run mode
   # @return [Array<SearchPathElement>]
   # @api private
   def searchpath(environment = nil, run_mode = preferred_run_mode)
     searchpath = [
       SearchPathElement.new(:memory, :values),
       SearchPathElement.new(:cli, :values),
     ]
     searchpath << SearchPathElement.new(environment.intern, :environment) if environment
     searchpath << SearchPathElement.new(run_mode, :section) if run_mode
     searchpath << SearchPathElement.new(:main, :section)
     searchpath << SearchPathElement.new(:application_defaults, :values)
     searchpath << SearchPathElement.new(:overridden_defaults, :values)
   end
 
   # Get a list of objects per section
   def sectionlist
     sectionlist = []
     self.each { |name, obj|
       section = obj.section || "puppet"
       sections[section] ||= []
       sectionlist << section unless sectionlist.include?(section)
       sections[section] << obj
     }
 
     return sectionlist, sections
   end
 
   def service_user_available?
     return @service_user_available if defined?(@service_user_available)
 
     if self[:user]
       user = Puppet::Type.type(:user).new :name => self[:user], :audit => :ensure
 
       @service_user_available = user.exists?
     else
       @service_user_available = false
     end
   end
 
   def service_group_available?
     return @service_group_available if defined?(@service_group_available)
 
     if self[:group]
       group = Puppet::Type.type(:group).new :name => self[:group], :audit => :ensure
 
       @service_group_available = group.exists?
     else
       @service_group_available = false
     end
   end
 
   # Allow later inspection to determine if the setting was set on the
   # command line, or through some other code path.  Used for the
   # `dns_alt_names` option during cert generate. --daniel 2011-10-18
   def set_by_cli?(param)
     param = param.to_sym
     !@value_sets[:cli].lookup(param).nil?
   end
 
   def set_value(param, value, type, options = {})
     Puppet.deprecation_warning("Puppet.settings.set_value is deprecated. Use Puppet[]= instead.")
     if @value_sets[type]
       @value_sets[type].set(param, value)
       unsafe_flush_cache
     end
   end
 
   # Deprecated; use #define_settings instead
   def setdefaults(section, defs)
     Puppet.deprecation_warning("'setdefaults' is deprecated and will be removed; please call 'define_settings' instead")
     define_settings(section, defs)
   end
 
   # Define a group of settings.
   #
   # @param [Symbol] section a symbol to use for grouping multiple settings together into a conceptual unit.  This value
   #   (and the conceptual separation) is not used very often; the main place where it will have a potential impact
   #   is when code calls Settings#use method.  See docs on that method for further details, but basically that method
   #   just attempts to do any preparation that may be necessary before code attempts to leverage the value of a particular
   #   setting.  This has the most impact for file/directory settings, where #use will attempt to "ensure" those
   #   files / directories.
   # @param [Hash[Hash]] defs the settings to be defined.  This argument is a hash of hashes; each key should be a symbol,
   #   which is basically the name of the setting that you are defining.  The value should be another hash that specifies
   #   the parameters for the particular setting.  Legal values include:
   #    [:default] => not required; this is the value for the setting if no other value is specified (via cli, config file, etc.)
   #       For string settings this may include "variables", demarcated with $ or ${} which will be interpolated with values of other settings.
   #       The default value may also be a Proc that will be called only once to evaluate the default when the setting's value is retrieved.
   #    [:desc] => required; a description of the setting, used in documentation / help generation
   #    [:type] => not required, but highly encouraged!  This specifies the data type that the setting represents.  If
   #       you do not specify it, it will default to "string".  Legal values include:
   #       :string - A generic string setting
   #       :boolean - A boolean setting; values are expected to be "true" or "false"
   #       :file - A (single) file path; puppet may attempt to create this file depending on how the settings are used.  This type
   #           also supports additional options such as "mode", "owner", "group"
   #       :directory - A (single) directory path; puppet may attempt to create this file depending on how the settings are used.  This type
   #           also supports additional options such as "mode", "owner", "group"
   #       :path - This is intended to be used for settings whose value can contain multiple directory paths, respresented
   #           as strings separated by the system path separator (e.g. system path, module path, etc.).
   #     [:mode] => an (optional) octal value to be used as the permissions/mode for :file and :directory settings
   #     [:owner] => optional owner username/uid for :file and :directory settings
   #     [:group] => optional group name/gid for :file and :directory settings
   #
   def define_settings(section, defs)
     section = section.to_sym
     call = []
     defs.each do |name, hash|
       raise ArgumentError, "setting definition for '#{name}' is not a hash!" unless hash.is_a? Hash
 
       name = name.to_sym
       hash[:name] = name
       hash[:section] = section
       raise ArgumentError, "Setting #{name} is already defined" if @config.include?(name)
       tryconfig = newsetting(hash)
       if short = tryconfig.short
         if other = @shortnames[short]
           raise ArgumentError, "Setting #{other.name} is already using short name '#{short}'"
         end
         @shortnames[short] = tryconfig
       end
       @config[name] = tryconfig
 
       # Collect the settings that need to have their hooks called immediately.
       # We have to collect them so that we can be sure we're fully initialized before
       # the hook is called.
       if tryconfig.has_hook?
         if tryconfig.call_hook_on_define?
           call << tryconfig
         elsif tryconfig.call_hook_on_initialize?
           @hooks_to_call_on_application_initialization << tryconfig
         end
       end
 
       @deprecated_setting_names << name if tryconfig.deprecated?
     end
 
     call.each do |setting|
       setting.handle(self.value(setting.name))
     end
   end
 
   # Convert the settings we manage into a catalog full of resources that model those settings.
   def to_catalog(*sections)
     sections = nil if sections.empty?
 
     catalog = Puppet::Resource::Catalog.new("Settings", Puppet::Node::Environment::NONE)
     @config.keys.find_all { |key| @config[key].is_a?(FileSetting) }.each do |key|
       file = @config[key]
       next if file.value.nil?
       next unless (sections.nil? or sections.include?(file.section))
       next unless resource = file.to_resource
       next if catalog.resource(resource.ref)
 
-      Puppet.debug("Using settings: adding file resource '#{key}': '#{resource.inspect}'")
+      Puppet.debug {"Using settings: adding file resource '#{key}': '#{resource.inspect}'"}
 
       catalog.add_resource(resource)
     end
 
     add_user_resources(catalog, sections)
     add_environment_resources(catalog, sections)
 
     catalog
   end
 
   # Convert our list of config settings into a configuration file.
   def to_config
     str = %{The configuration file for #{Puppet.run_mode.name}.  Note that this file
 is likely to have unused settings in it; any setting that's
 valid anywhere in Puppet can be in any config file, even if it's not used.
 
 Every section can specify three special parameters: owner, group, and mode.
 These parameters affect the required permissions of any files specified after
 their specification.  Puppet will sometimes use these parameters to check its
 own configured state, so they can be used to make Puppet a bit more self-managing.
 
 The file format supports octothorpe-commented lines, but not partial-line comments.
 
 Generated on #{Time.now}.
 
 }.gsub(/^/, "# ")
 
 #         Add a section heading that matches our name.
     str += "[#{preferred_run_mode}]\n"
     eachsection do |section|
       persection(section) do |obj|
         str += obj.to_config + "\n" unless obj.name == :genconfig
       end
     end
 
     return str
   end
 
   # Convert to a parseable manifest
   def to_manifest
     catalog = to_catalog
     catalog.resource_refs.collect do |ref|
       catalog.resource(ref).to_manifest
     end.join("\n\n")
   end
 
   # Create the necessary objects to use a section.  This is idempotent;
   # you can 'use' a section as many times as you want.
   def use(*sections)
     sections = sections.collect { |s| s.to_sym }
     sections = sections.reject { |s| @used.include?(s) }
 
     return if sections.empty?
 
     begin
       catalog = to_catalog(*sections).to_ral
     rescue => detail
       Puppet.log_and_raise(detail, "Could not create resources for managing Puppet's files and directories in sections #{sections.inspect}: #{detail}")
     end
 
     catalog.host_config = false
     catalog.apply do |transaction|
       if transaction.any_failed?
         report = transaction.report
         status_failures = report.resource_statuses.values.select { |r| r.failed? }
         status_fail_msg = status_failures.
           collect(&:events).
           flatten.
           select { |event| event.status == 'failure' }.
           collect { |event| "#{event.resource}: #{event.message}" }.join("; ")
 
         raise "Got #{status_failures.length} failure(s) while initializing: #{status_fail_msg}"
       end
     end
 
     sections.each { |s| @used << s }
     @used.uniq!
   end
 
   def valid?(param)
     param = param.to_sym
     @config.has_key?(param)
   end
 
   def uninterpolated_value(param, environment = nil)
     Puppet.deprecation_warning("Puppet.settings.uninterpolated_value is deprecated. Use Puppet.settings.value instead")
     param = param.to_sym
     environment &&= environment.to_sym
 
     values(environment, self.preferred_run_mode).lookup(param)
   end
 
   # Retrieve an object that can be used for looking up values of configuration
   # settings.
   #
   # @param environment [Symbol] The name of the environment in which to lookup
   # @param section [Symbol] The name of the configuration section in which to lookup
   # @return [Puppet::Settings::ChainedValues] An object to perform lookups
   # @api public
   def values(environment, section)
     @values[environment][section] ||= ChainedValues.new(
       section,
       environment,
       value_sets_for(environment, section),
       @config)
   end
 
   # Find the correct value using our search path.
   #
   # @param param [String, Symbol] The value to look up
   # @param environment [String, Symbol] The environment to check for the value
   # @param bypass_interpolation [true, false] Whether to skip interpolation
   #
   # @return [Object] The looked up value
   #
   # @raise [InterpolationError]
   def value(param, environment = nil, bypass_interpolation = false)
     param = param.to_sym
     environment &&= environment.to_sym
 
     setting = @config[param]
 
     # Short circuit to nil for undefined settings.
     return nil if setting.nil?
 
     # Check the cache first.  It needs to be a per-environment
     # cache so that we don't spread values from one env
     # to another.
     if @cache[environment||"none"].has_key?(param)
       return @cache[environment||"none"][param]
     elsif bypass_interpolation
       val = values(environment, self.preferred_run_mode).lookup(param)
     else
       val = values(environment, self.preferred_run_mode).interpolate(param)
     end
 
     @cache[environment||"none"][param] = val
     val
   end
 
   ##
   # (#15337) All of the logic to determine the configuration file to use
   #   should be centralized into this method.  The simplified approach is:
   #
   # 1. If there is an explicit configuration file, use that.  (--confdir or
   #    --config)
   # 2. If we're running as a root process, use the system puppet.conf
   #    (usually /etc/puppet/puppet.conf)
   # 3. Otherwise, use the user puppet.conf (usually ~/.puppet/puppet.conf)
   #
   # @api private
   # @todo this code duplicates {Puppet::Util::RunMode#which_dir} as described
   #   in {http://projects.puppetlabs.com/issues/16637 #16637}
   def which_configuration_file
     if explicit_config_file? or Puppet.features.root? then
       return main_config_file
     else
       return user_config_file
     end
   end
 
   # This method just turns a file into a new ConfigFile::Conf instance
   # @param file [String] absolute path to the configuration file
   # @return [Puppet::Settings::ConfigFile::Conf]
   # @api private
   def parse_file(file, allowed_sections = [])
     @config_file_parser.parse_file(file, read_file(file), allowed_sections)
   end
 
   private
 
   DEPRECATION_REFS = {
     # intentionally empty. This could be repopulated if we deprecate more settings
     # and have reference links to associate with them 
   }.freeze
 
   def screen_non_puppet_conf_settings(puppet_conf)
     puppet_conf.sections.values.each do |section|
       forbidden = section.settings.select { |setting| Puppet::Settings::EnvironmentConf::ENVIRONMENT_CONF_ONLY_SETTINGS.include?(setting.name) }
       raise(SettingsError, "Cannot set #{forbidden.map { |s| s.name }.join(", ")} settings in puppet.conf") if !forbidden.empty?
     end
   end
 
   # Record that we want to issue a deprecation warning later in the application
   # initialization cycle when we have settings bootstrapped to the point where
   # we can read the Puppet[:disable_warnings] setting.
   #
   # We are only recording warnings applicable to settings set in puppet.conf
   # itself.
   def record_deprecations_from_puppet_conf(puppet_conf)
     puppet_conf.sections.values.each do |section|
       section.settings.each do |conf_setting|
         if setting = self.setting(conf_setting.name)
           @deprecated_settings_that_have_been_configured << setting if setting.deprecated?
         end
       end
     end
   end
 
   def issue_deprecations
     @deprecated_settings_that_have_been_configured.each do |setting|
       issue_deprecation_warning(setting)
     end
   end
 
   def issue_deprecation_warning(setting, msg = nil)
     name = setting.name
     ref = DEPRECATION_REFS.find { |params,reference| params.include?(name) }
     ref = ref[1] if ref
     case
     when msg
       msg << " #{ref}" if ref
       Puppet.deprecation_warning(msg)
     when setting.completely_deprecated?
       Puppet.deprecation_warning("Setting #{name} is deprecated. #{ref}", "setting-#{name}")
     when setting.allowed_on_commandline?
       Puppet.deprecation_warning("Setting #{name} is deprecated in puppet.conf. #{ref}", "puppet-conf-setting-#{name}")
     end
   end
 
   def get_config_file_default(default)
     obj = nil
     unless obj = @config[default]
       raise ArgumentError, "Unknown default #{default}"
     end
 
     raise ArgumentError, "Default #{default} is not a file" unless obj.is_a? FileSetting
 
     obj
   end
 
   def add_environment_resources(catalog, sections)
     path = self[:environmentpath]
     envdir = path.split(File::PATH_SEPARATOR).first if path
     configured_environment = self[:environment]
     if configured_environment == "production" && envdir && Puppet::FileSystem.exist?(envdir)
       configured_environment_path = File.join(envdir, configured_environment)
       if !Puppet::FileSystem.symlink?(configured_environment_path)
         catalog.add_resource(
           Puppet::Resource.new(:file,
                                configured_environment_path,
                                :parameters => { :ensure => 'directory' })
         )
       end
     end
   end
 
   def add_user_resources(catalog, sections)
     return unless Puppet.features.root?
     return if Puppet.features.microsoft_windows?
     return unless self[:mkusers]
 
     @config.each do |name, setting|
       next unless setting.respond_to?(:owner)
       next unless sections.nil? or sections.include?(setting.section)
 
       if user = setting.owner and user != "root" and catalog.resource(:user, user).nil?
         resource = Puppet::Resource.new(:user, user, :parameters => {:ensure => :present})
         resource[:gid] = self[:group] if self[:group]
         catalog.add_resource resource
       end
       if group = setting.group and ! %w{root wheel}.include?(group) and catalog.resource(:group, group).nil?
         catalog.add_resource Puppet::Resource.new(:group, group, :parameters => {:ensure => :present})
       end
     end
   end
 
   # Yield each search source in turn.
   def value_sets_for(environment, mode)
     searchpath(environment, mode).collect do |source|
       case source.type
       when :values
         @value_sets[source.name]
       when :section
         if @configuration_file && section = @configuration_file.sections[source.name]
           ValuesFromSection.new(source.name, section)
         end
       when :environment
         ValuesFromEnvironmentConf.new(source.name)
       else
         raise(Puppet::DevError, "Unknown searchpath case: #{source.type} for the #{source} settings path element.")
       end
     end.compact
   end
 
   # Read the file in.
   # @api private
   def read_file(file)
     return Puppet::FileSystem.read(file)
   end
 
   # Private method for internal test use only; allows to do a comprehensive clear of all settings between tests.
   #
   # @return nil
   def clear_everything_for_tests()
     unsafe_clear(true, true)
     @configuration_file = nil
     @global_defaults_initialized = false
     @app_defaults_initialized = false
   end
   private :clear_everything_for_tests
 
   def explicit_config_file?
     # Figure out if the user has provided an explicit configuration file.  If
     # so, return the path to the file, if not return nil.
     #
     # The easiest way to determine whether an explicit one has been specified
     #  is to simply attempt to evaluate the value of ":config".  This will
     #  obviously be successful if they've passed an explicit value for :config,
     #  but it will also result in successful interpolation if they've only
     #  passed an explicit value for :confdir.
     #
     # If they've specified neither, then the interpolation will fail and we'll
     #  get an exception.
     #
     begin
       return true if self[:config]
     rescue InterpolationError
       # This means we failed to interpolate, which means that they didn't
       #  explicitly specify either :config or :confdir... so we'll fall out to
       #  the default value.
       return false
     end
   end
   private :explicit_config_file?
 
   # Lookup configuration setting value through a chain of different value sources.
   #
   # @api public
   class ChainedValues
     ENVIRONMENT_SETTING = "environment".freeze
     ENVIRONMENT_INTERPOLATION_ALLOWED = ['config_version'].freeze
 
     # @see Puppet::Settings.values
     # @api private
     def initialize(mode, environment, value_sets, defaults)
       @mode = mode
       @environment = environment
       @value_sets = value_sets
       @defaults = defaults
     end
 
     # Lookup the uninterpolated value.
     #
     # @param name [Symbol] The configuration setting name to look up
     # @return [Object] The configuration setting value or nil if the setting is not known
     # @api public
     def lookup(name)
       set = @value_sets.find do |set|
         set.include?(name)
       end
       if set
         value = set.lookup(name)
         if !value.nil?
           return value
         end
       end
 
       @defaults[name].default
     end
 
     # Lookup the interpolated value. All instances of `$name` in the value will
     # be replaced by performing a lookup of `name` and substituting the text
     # for `$name` in the original value. This interpolation is only performed
     # if the looked up value is a String.
     #
     # @param name [Symbol] The configuration setting name to look up
     # @return [Object] The configuration setting value or nil if the setting is not known
     # @api public
     def interpolate(name)
       setting = @defaults[name]
 
       if setting
         val = lookup(name)
         # if we interpolate code, all hell breaks loose.
         if name == :code
           val
         else
           # Convert it if necessary
           begin
             val = convert(val, name)
           rescue InterpolationError => err
             # This happens because we don't have access to the param name when the
             # exception is originally raised, but we want it in the message
             raise InterpolationError, "Error converting value for param '#{name}': #{err}", err.backtrace
           end
 
           setting.munge(val)
         end
       else
         nil
       end
     end
 
     private
 
     def convert(value, setting_name)
       case value
       when nil
         nil
       when String
         failed_environment_interpolation = false
         interpolated_value = value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |expression|
           varname = $2 || $1
           interpolated_expression =
           if varname != ENVIRONMENT_SETTING || ok_to_interpolate_environment(setting_name)
             if varname == ENVIRONMENT_SETTING && @environment
               @environment
             elsif varname == "run_mode"
               @mode
             elsif !(pval = interpolate(varname.to_sym)).nil?
               pval
             else
               raise InterpolationError, "Could not find value for #{expression}"
             end
           else
             failed_environment_interpolation = true
             expression
           end
           interpolated_expression
         end
         if failed_environment_interpolation
           Puppet.warning("You cannot interpolate $environment within '#{setting_name}' when using directory environments.  Its value will remain #{interpolated_value}.")
         end
         interpolated_value
       else
         value
       end
     end
 
     def ok_to_interpolate_environment(setting_name)
       ENVIRONMENT_INTERPOLATION_ALLOWED.include?(setting_name.to_s)
     end
   end
 
   class Values
     extend Forwardable
 
     attr_reader :name
 
     def initialize(name, defaults)
       @name = name
       @values = {}
       @defaults = defaults
     end
 
     def_delegator :@values, :include?
     def_delegator :@values, :[], :lookup
 
     def set(name, value)
       default = @defaults[name]
 
       if !default
         raise ArgumentError,
           "Attempt to assign a value to unknown setting #{name.inspect}"
       end
 
       if default.has_hook?
         default.handle(value)
       end
 
       @values[name] = value
     end
 
     def inspect
       %Q{<#{self.class}:#{self.object_id} @name="#{@name}" @values="#{@values}">}
     end
   end
 
   class ValuesFromSection
     attr_reader :name
 
     def initialize(name, section)
       @name = name
       @section = section
     end
 
     def include?(name)
       !@section.setting(name).nil?
     end
 
     def lookup(name)
       setting = @section.setting(name)
       if setting
         setting.value
       end
     end
 
     def inspect
       %Q{<#{self.class}:#{self.object_id} @name="#{@name}" @section="#{@section}">}
     end
   end
 
   # @api private
   class ValuesFromEnvironmentConf
     def initialize(environment_name)
       @environment_name = environment_name
     end
 
     def name
       @environment_name
     end
 
     def include?(name)
       if Puppet::Settings::EnvironmentConf::VALID_SETTINGS.include?(name) && conf
         return true
       end
       false
     end
 
     def lookup(name)
       return nil unless Puppet::Settings::EnvironmentConf::VALID_SETTINGS.include?(name)
       conf.send(name) if conf
     end
 
     def conf
       @conf ||= if environments = Puppet.lookup(:environments)
                   environments.get_conf(@environment_name)
                 end
     end
 
     def inspect
       %Q{<#{self.class}:#{self.object_id} @environment_name="#{@environment_name}" @conf="#{@conf}">}
     end
   end
 end
diff --git a/lib/puppet/util/logging.rb b/lib/puppet/util/logging.rb
index 7516d10e1..10d3dc7ab 100644
--- a/lib/puppet/util/logging.rb
+++ b/lib/puppet/util/logging.rb
@@ -1,211 +1,232 @@
 # A module to make logging a bit easier.
 require 'puppet/util/log'
 require 'puppet/error'
 require 'facter'
 
 module Puppet::Util::Logging
 
   def send_log(level, message)
     Puppet::Util::Log.create({:level => level, :source => log_source, :message => message}.merge(log_metadata))
   end
 
   # Create a method for each log level.
   Puppet::Util::Log.eachlevel do |level|
+    # handle debug a special way for performance reasons
+    next if level == :debug
     define_method(level) do |args|
       args = args.join(" ") if args.is_a?(Array)
       send_log(level, args)
     end
   end
 
+  # Output a debug log message if debugging is on (but only then)
+  # If the output is anything except a static string, give the debug
+  # a block - it will be called with all other arguments, and is expected
+  # to return the single string result.
+  #
+  # Use a block at all times for increased performance.
+  #
+  # @example This takes 40% of the time compared to not using a block
+  #  Puppet.debug { "This is a string that interpolated #{x} and #{y} }"
+  #
+  def debug(*args)
+    return nil unless Puppet::Util::Log.level == :debug
+    if block_given?
+      send_log(:debug, yield(*args))
+    else
+      send_log(:debug, args.join(" "))
+    end
+  end
+
   # Log an exception via Puppet.err.  Will also log the backtrace if Puppet[:trace] is set.
   # Parameters:
   # [exception] an Exception to log
   # [message] an optional String overriding the message to be logged; by default, we log Exception.message.
   #    If you pass a String here, your string will be logged instead.  You may also pass nil if you don't
   #    wish to log a message at all; in this case it is likely that you are only calling this method in order
   #    to take advantage of the backtrace logging.
   def log_exception(exception, message = :default, options = {})
     err(format_exception(exception, message, Puppet[:trace] || options[:trace]))
   end
 
   def format_exception(exception, message = :default, trace = true)
     arr = []
     case message
     when :default
       arr << exception.message
     when nil
       # don't log anything if they passed a nil; they are just calling for the optional backtrace logging
     else
       arr << message
     end
 
     if trace and exception.backtrace
       arr << Puppet::Util.pretty_backtrace(exception.backtrace)
     end
     if exception.respond_to?(:original) and exception.original
       arr << "Wrapped exception:"
       arr << format_exception(exception.original, :default, trace)
     end
     arr.flatten.join("\n")
   end
 
   def log_and_raise(exception, message)
     log_exception(exception, message)
     raise exception, message + "\n" + exception.to_s, exception.backtrace
   end
 
   class DeprecationWarning < Exception; end
 
   # Logs a warning indicating that the Ruby code path is deprecated.  Note that
   # this method keeps track of the offending lines of code that triggered the
   # deprecation warning, and will only log a warning once per offending line of
   # code.  It will also stop logging deprecation warnings altogether after 100
   # unique deprecation warnings have been logged.  Finally, if
   # Puppet[:disable_warnings] includes 'deprecations', it will squelch all
   # warning calls made via this method.
   #
   # @param message [String] The message to log (logs via warning)
   # @param key [String] Optional key to mark the message as unique. If not
   #   passed in, the originating call line will be used instead.
   def deprecation_warning(message, key = nil)
     issue_deprecation_warning(message, key, nil, nil, true)
   end
 
   # Logs a warning whose origin comes from Puppet source rather than somewhere
   # internal within Puppet.  Otherwise the same as deprecation_warning()
   #
   # @param message [String] The message to log (logs via warning)
   # @param options [Hash]
   # @option options [String] :file File we are warning from
   # @option options [Integer] :line Line number we are warning from
   # @option options [String] :key (:file + :line) Alternative key used to mark
   #   warning as unique
   #
   # Either :file and :line and/or :key must be passed.
   def puppet_deprecation_warning(message, options = {})
     key = options[:key]
     file = options[:file]
     line = options[:line]
     raise(Puppet::DevError, "Need either :file and :line, or :key") if (key.nil?) && (file.nil? || line.nil?)
 
     key ||= "#{file}:#{line}"
     issue_deprecation_warning(message, key, file, line, false)
   end
 
   def get_deprecation_offender()
     # we have to put this in its own method to simplify testing; we need to be able to mock the offender results in
     # order to test this class, and our framework does not appear to enjoy it if you try to mock Kernel.caller
     #
     # let's find the offending line;  we need to jump back up the stack a few steps to find the method that called
     #  the deprecated method
     if Puppet[:trace]
       caller()[2..-1]
     else
       [caller()[2]]
     end
   end
 
   def clear_deprecation_warnings
     $deprecation_warnings.clear if $deprecation_warnings
   end
 
   # TODO: determine whether there might be a potential use for adding a puppet configuration option that would
   # enable this deprecation logging.
 
   # utility method that can be called, e.g., from spec_helper config.after, when tracking down calls to deprecated
   # code.
   # Parameters:
   # [deprecations_file] relative or absolute path of a file to log the deprecations to
   # [pattern] (default nil) if specified, will only log deprecations whose message matches the provided pattern
   def log_deprecations_to_file(deprecations_file, pattern = nil)
     # this method may get called lots and lots of times (e.g., from spec_helper config.after) without the global
     # list of deprecation warnings being cleared out.  We don't want to keep logging the same offenders over and over,
     # so, we need to keep track of what we've logged.
     #
     # It'd be nice if we could just clear out the list of deprecation warnings, but then the very next spec might
     # find the same offender, and we'd end up logging it again.
     $logged_deprecation_warnings ||= {}
 
     File.open(deprecations_file, "a") do |f|
       if ($deprecation_warnings) then
         $deprecation_warnings.each do |offender, message|
           if (! $logged_deprecation_warnings.has_key?(offender)) then
             $logged_deprecation_warnings[offender] = true
             if ((pattern.nil?) || (message =~ pattern)) then
               f.puts(message)
               f.puts(offender)
               f.puts()
             end
           end
         end
       end
     end
   end
 
   # Sets up Facter logging.
   # This method causes Facter output to be forwarded to Puppet.
   def self.setup_facter_logging!
     # Only recent versions of Facter support this feature
     return false unless Facter.respond_to? :on_message
 
     # The current Facter log levels are: :trace, :debug, :info, :warn, :error, and :fatal.
     # Convert to the corresponding levels in Puppet
     Facter.on_message do |level, message|
       case level
       when :trace, :debug
         level = :debug
       when :info
         # Same as Puppet
       when :warn
         level = :warning
       when :error
         level = :err
       when :fatal
         level = :crit
       else
         next
       end
       Puppet::Util::Log.create({:level => level, :source => 'Facter', :message => message})
       nil
     end
     true
   end
 
   private
 
   def issue_deprecation_warning(message, key, file, line, use_caller)
     return if Puppet[:disable_warnings].include?('deprecations')
     $deprecation_warnings ||= {}
     if $deprecation_warnings.length < 100 then
       key ||= (offender = get_deprecation_offender)
       if (! $deprecation_warnings.has_key?(key)) then
         $deprecation_warnings[key] = message
         call_trace = use_caller ?
           (offender || get_deprecation_offender).join('; ') :
           "#{file || 'unknown'}:#{line || 'unknown'}"
         warning("#{message}\n   (at #{call_trace})")
       end
     end
   end
 
   def is_resource?
     defined?(Puppet::Type) && is_a?(Puppet::Type)
   end
 
   def is_resource_parameter?
     defined?(Puppet::Parameter) && is_a?(Puppet::Parameter)
   end
 
   def log_metadata
     [:file, :line, :tags].inject({}) do |result, attr|
       result[attr] = send(attr) if respond_to?(attr)
       result
     end
   end
 
   def log_source
     # We need to guard the existence of the constants, since this module is used by the base Puppet module.
     (is_resource? or is_resource_parameter?) and respond_to?(:path) and return path.to_s
     to_s
   end
 end
diff --git a/lib/puppet/util/warnings.rb b/lib/puppet/util/warnings.rb
index 82e80e4be..5536ea0df 100644
--- a/lib/puppet/util/warnings.rb
+++ b/lib/puppet/util/warnings.rb
@@ -1,32 +1,33 @@
 # Methods to help with handling warnings.
 module Puppet::Util::Warnings
   module_function
 
   def notice_once(msg)
     Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.notice msg }
   end
 
   def debug_once(msg)
+    return nil unless Puppet[:debug]
     Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.debug msg }
   end
 
   def warnonce(msg)
     Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.warning msg }
   end
 
   def clear_warnings
     @stampwarnings = {}
     nil
   end
 
   protected
 
   def self.maybe_log(message, klass)
     @stampwarnings ||= {}
     @stampwarnings[klass] ||= []
     return nil if @stampwarnings[klass].include? message
     yield
     @stampwarnings[klass] << message
     nil
   end
 end
diff --git a/spec/unit/resource/type_collection_spec.rb b/spec/unit/resource/type_collection_spec.rb
index 0c359ca69..9e81f275c 100755
--- a/spec/unit/resource/type_collection_spec.rb
+++ b/spec/unit/resource/type_collection_spec.rb
@@ -1,302 +1,313 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/resource/type_collection'
 require 'puppet/resource/type'
 
 describe Puppet::Resource::TypeCollection do
   include PuppetSpec::Files
 
   let(:environment) { Puppet::Node::Environment.create(:testing, []) }
 
   before do
     @instance = Puppet::Resource::Type.new(:hostclass, "foo")
     @code = Puppet::Resource::TypeCollection.new(environment)
   end
 
   it "should consider '<<' to be an alias to 'add' but should return self" do
     @code.expects(:add).with "foo"
     @code.expects(:add).with "bar"
     @code << "foo" << "bar"
   end
 
   it "should set itself as the code collection for added resource types" do
     node = Puppet::Resource::Type.new(:node, "foo")
 
     @code.add(node)
     @code.node("foo").should equal(node)
 
     node.resource_type_collection.should equal(@code)
   end
 
   it "should store node resource types as nodes" do
     node = Puppet::Resource::Type.new(:node, "foo")
 
     @code.add(node)
     @code.node("foo").should equal(node)
   end
 
   it "should fail if a duplicate node is added" do
     @code.add(Puppet::Resource::Type.new(:node, "foo"))
 
     expect do
       @code.add(Puppet::Resource::Type.new(:node, "foo"))
     end.to raise_error(Puppet::ParseError, /cannot redefine/)
   end
 
   it "should store hostclasses as hostclasses" do
     klass = Puppet::Resource::Type.new(:hostclass, "foo")
 
     @code.add(klass)
     @code.hostclass("foo").should equal(klass)
   end
 
   it "merge together hostclasses of the same name" do
     klass1 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "first")
     klass2 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "second")
 
     @code.add(klass1)
     @code.add(klass2)
 
     @code.hostclass("foo").doc.should == "firstsecond"
   end
 
   it "should store definitions as definitions" do
     define = Puppet::Resource::Type.new(:definition, "foo")
 
     @code.add(define)
     @code.definition("foo").should equal(define)
   end
 
   it "should fail if a duplicate definition is added" do
     @code.add(Puppet::Resource::Type.new(:definition, "foo"))
 
     expect do
       @code.add(Puppet::Resource::Type.new(:definition, "foo"))
     end.to raise_error(Puppet::ParseError, /cannot be redefined/)
   end
 
   it "should remove all nodes, classes, and definitions when cleared" do
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add Puppet::Resource::Type.new(:hostclass, "class")
     loader.add Puppet::Resource::Type.new(:definition, "define")
     loader.add Puppet::Resource::Type.new(:node, "node")
 
     loader.clear
     loader.hostclass("class").should be_nil
     loader.definition("define").should be_nil
     loader.node("node").should be_nil
   end
 
   describe "when looking up names" do
     before do
       @type = Puppet::Resource::Type.new(:hostclass, "ns::klass")
     end
 
     it "should not attempt to import anything when the type is already defined" do
       @code.add @type
       @code.loader.expects(:import).never
       @code.find_hostclass("ns::klass").should equal(@type)
     end
 
     describe "that need to be loaded" do
       it "should use the loader to load the files" do
         @code.loader.expects(:try_load_fqname).with(:hostclass, "klass")
         @code.find_hostclass("klass")
       end
       it "should use the loader to load the files" do
         @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
         @code.find_hostclass("ns::klass")
       end
 
       it "should downcase the name and downcase and array-fy the namespaces before passing to the loader" do
         @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
         @code.find_hostclass("ns::klass")
       end
 
       it "should use the class returned by the loader" do
         @code.loader.expects(:try_load_fqname).returns(:klass)
         @code.expects(:hostclass).with("ns::klass").returns(false)
         @code.find_hostclass("ns::klass").should == :klass
       end
 
       it "should return nil if the name isn't found" do
         @code.loader.stubs(:try_load_fqname).returns(nil)
         @code.find_hostclass("Ns::Klass").should be_nil
       end
 
       it "already-loaded names at broader scopes should not shadow autoloaded names" do
         @code.add Puppet::Resource::Type.new(:hostclass, "bar")
         @code.loader.expects(:try_load_fqname).with(:hostclass, "foo::bar").returns(:foobar)
         @code.find_hostclass("foo::bar").should == :foobar
       end
 
-      it "should not try to autoload names that we couldn't autoload in a previous step if ignoremissingtypes is enabled" do
-        Puppet[:ignoremissingtypes] = true
-        @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass").returns(nil)
-        @code.find_hostclass("ns::klass").should be_nil
+      context 'when debugging' do
+        # This test requires that debugging is on, it will otherwise not make a call to debug,
+        # which is the easiest way to detect that that a certain path has been taken.
+        before(:each) do
+          Puppet.debug = true
+        end
+
+        after (:each) do
+          Puppet.debug = false
+        end
 
-        Puppet.expects(:debug).at_least_once.with {|msg| msg =~ /Not attempting to load hostclass/}
-        @code.find_hostclass("ns::klass").should be_nil
+        it "should not try to autoload names that we couldn't autoload in a previous step if ignoremissingtypes is enabled" do
+          Puppet[:ignoremissingtypes] = true
+          @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass").returns(nil)
+          @code.find_hostclass("ns::klass").should be_nil
+          Puppet.expects(:debug).at_least_once.with {|msg| msg =~ /Not attempting to load hostclass/}
+          @code.find_hostclass("ns::klass").should be_nil
+        end
       end
     end
   end
 
   %w{hostclass node definition}.each do |data|
     describe "behavior of add for #{data}" do
 
       it "should return the added #{data}" do
         loader = Puppet::Resource::TypeCollection.new(environment)
         instance = Puppet::Resource::Type.new(data, "foo")
 
         loader.add(instance).should equal(instance)
       end
 
       it "should retrieve #{data} insensitive to case" do
         loader = Puppet::Resource::TypeCollection.new(environment)
         instance = Puppet::Resource::Type.new(data, "Bar")
 
         loader.add instance
 
         loader.send(data, "bAr").should equal(instance)
       end
 
       it "should return nil when asked for a #{data} that has not been added" do
         Puppet::Resource::TypeCollection.new(environment).send(data, "foo").should be_nil
       end
     end
   end
 
   describe "when finding a qualified instance" do
     it "should return any found instance if the instance name is fully qualified" do
       loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find_hostclass("::foo::bar").should equal(instance)
     end
 
     it "should return nil if the instance name is fully qualified and no such instance exists" do
       loader = Puppet::Resource::TypeCollection.new(environment)
       loader.find_hostclass("::foo::bar").should be_nil
     end
 
     it "should be able to find classes in the base namespace" do
       loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo")
       loader.add instance
       loader.find_hostclass("foo").should equal(instance)
     end
 
     it "should return the unqualified object if it exists in a provided namespace" do
       loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find_hostclass("foo::bar").should equal(instance)
     end
 
     it "should return nil if the object cannot be found" do
       loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find_hostclass("foo::bar::eh").should be_nil
     end
 
     describe "when topscope has a class that has the same name as a local class" do
       before do
         @loader = Puppet::Resource::TypeCollection.new(environment)
         [ "foo::bar", "bar" ].each do |name|
           @loader.add Puppet::Resource::Type.new(:hostclass, name)
         end
       end
 
       it "looks up the given name, no more, no less" do
         @loader.find_hostclass("bar").name.should == 'bar'
         @loader.find_hostclass("::bar").name.should == 'bar'
         @loader.find_hostclass("foo::bar").name.should == 'foo::bar'
         @loader.find_hostclass("::foo::bar").name.should == 'foo::bar'
       end
     end
 
     it "should not look in the local scope for classes when the name is qualified" do
         @loader = Puppet::Resource::TypeCollection.new(environment)
         @loader.add Puppet::Resource::Type.new(:hostclass, "foo::bar")
 
         @loader.find_hostclass("::bar").should == nil
     end
 
   end
 
   it "should be able to find nodes" do
     node = Puppet::Resource::Type.new(:node, "bar")
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add(node)
     loader.find_node("bar").should == node
   end
 
   it "should indicate whether any nodes are defined" do
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add_node(Puppet::Resource::Type.new(:node, "foo"))
     loader.should be_nodes
   end
 
   it "should indicate whether no nodes are defined" do
     Puppet::Resource::TypeCollection.new(environment).should_not be_nodes
   end
 
   describe "when finding nodes" do
     before :each do
       @loader = Puppet::Resource::TypeCollection.new(environment)
     end
 
     it "should return any node whose name exactly matches the provided node name" do
       node = Puppet::Resource::Type.new(:node, "foo")
       @loader << node
 
       @loader.node("foo").should equal(node)
     end
 
     it "should return the first regex node whose regex matches the provided node name" do
       node1 = Puppet::Resource::Type.new(:node, /\w/)
       node2 = Puppet::Resource::Type.new(:node, /\d/)
       @loader << node1 << node2
 
       @loader.node("foo10").should equal(node1)
     end
 
     it "should preferentially return a node whose name is string-equal over returning a node whose regex matches a provided name" do
       node1 = Puppet::Resource::Type.new(:node, /\w/)
       node2 = Puppet::Resource::Type.new(:node, "foo")
       @loader << node1 << node2
 
       @loader.node("foo").should equal(node2)
     end
   end
 
   describe "when determining the configuration version" do
     before do
       @code = Puppet::Resource::TypeCollection.new(environment)
     end
 
     it "should default to the current time" do
       time = Time.now
 
       Time.stubs(:now).returns time
       @code.version.should == time.to_i
     end
 
     context "when config_version script is specified" do
       let(:environment) { Puppet::Node::Environment.create(:testing, [], '', '/my/foo') }
 
       it "should use the output of the environment's config_version setting if one is provided" do
         Puppet::Util::Execution.expects(:execute).with(["/my/foo"]).returns "output\n"
         @code.version.should == "output"
       end
 
       it "should raise a puppet parser error if executing config_version fails" do
         Puppet::Util::Execution.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
 
         lambda { @code.version }.should raise_error(Puppet::ParseError)
       end
     end
   end
 end
diff --git a/spec/unit/util/warnings_spec.rb b/spec/unit/util/warnings_spec.rb
index f926ae10b..492c3540b 100755
--- a/spec/unit/util/warnings_spec.rb
+++ b/spec/unit/util/warnings_spec.rb
@@ -1,38 +1,46 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Util::Warnings do
   before(:all) do
     @msg1 = "booness"
     @msg2 = "more booness"
   end
 
+  before(:each) do
+    Puppet.debug = true
+  end
+
+  after (:each) do
+    Puppet.debug = false
+  end
+
   {:notice => "notice_once", :warning => "warnonce", :debug => "debug_once"}.each do |log, method|
     describe "when registring '#{log}' messages" do
       it "should always return nil" do
         Puppet::Util::Warnings.send(method, @msg1).should be(nil)
       end
 
       it "should issue a warning" do
         Puppet.expects(log).with(@msg1)
         Puppet::Util::Warnings.send(method, @msg1)
       end
 
       it "should issue a warning exactly once per unique message" do
         Puppet.expects(log).with(@msg1).once
         Puppet::Util::Warnings.send(method, @msg1)
         Puppet::Util::Warnings.send(method, @msg1)
       end
 
       it "should issue multiple warnings for multiple unique messages" do
         Puppet.expects(log).times(2)
         Puppet::Util::Warnings.send(method, @msg1)
         Puppet::Util::Warnings.send(method, @msg2)
       end
     end
   end
 
   after(:each) do
     Puppet::Util::Warnings.clear_warnings
   end
 end