diff --git a/lib/puppet/parser/files.rb b/lib/puppet/parser/files.rb
index 78fdf0314..18bae6fa4 100644
--- a/lib/puppet/parser/files.rb
+++ b/lib/puppet/parser/files.rb
@@ -1,88 +1,88 @@
 require 'puppet/module'
 require 'puppet/parser/parser'
 
 # This is a silly central module for finding
 # different kinds of files while parsing.  This code
 # doesn't really belong in the Puppet::Module class,
 # but it doesn't really belong anywhere else, either.
 module Puppet::Parser::Files
   module_function
 
   # Return a list of manifests (as absolute filenames) that match +pat+
   # with the current directory set to +cwd+. If the first component of
   # +pat+ does not contain any wildcards and is an existing module, return
   # a list of manifests in that module matching the rest of +pat+
   # Otherwise, try to find manifests matching +pat+ relative to +cwd+
   def find_manifests(start, options = {})
     cwd = options[:cwd] || Dir.getwd
     module_name, pattern = split_file_path(start)
     begin
       if mod = Puppet::Module.find(module_name, options[:environment])
         return [mod.name, mod.match_manifests(pattern)]
       end
     rescue Puppet::Module::InvalidName
       # Than that would be a "no."
     end
     abspat = File::expand_path(start, cwd)
     [nil, Dir.glob(abspat + (File.extname(abspat).empty? ? '{.pp,.rb}' : '' )).uniq.reject { |f| FileTest.directory?(f) }]
   end
 
   # Find the concrete file denoted by +file+. If +file+ is absolute,
-  # return it directly. Otherwise try to find it as a template in a
-  # module. If that fails, return it relative to the +templatedir+ config
-  # param.
+  # return it directly. Otherwise try to find relative to the +templatedir+
+  # config param.  If that fails try to find it as a template in a
+  # module.
   # In all cases, an absolute path is returned, which does not
   # necessarily refer to an existing file
   def find_template(template, environment = nil)
     if template == File.expand_path(template)
       return template
     end
 
     if template_paths = templatepath(environment)
       # If we can find the template in :templatedir, we return that.
       template_paths.collect { |path|
         File::join(path, template)
       }.each do |f|
         return f if FileTest.exist?(f)
       end
     end
 
     # check in the default template dir, if there is one
     if td_file = find_template_in_module(template, environment)
       return td_file
     end
 
     nil
   end
 
   def find_template_in_module(template, environment = nil)
     path, file = split_file_path(template)
 
     # Because templates don't have an assumed template name, like manifests do,
     # we treat templates with no name as being templates in the main template
     # directory.
     return nil unless file
 
     if mod = Puppet::Module.find(path, environment) and t = mod.template(file)
       return t
     end
     nil
   end
 
   # Return an array of paths by splitting the +templatedir+ config
   # parameter.
   def templatepath(environment = nil)
     dirs = Puppet.settings.value(:templatedir, environment).split(File::PATH_SEPARATOR)
     dirs.select do |p|
       File::directory?(p)
     end
   end
 
   # Split the path into the module and the rest of the path, or return
   # nil if the path is empty or absolute (starts with a /).
   # This method can return nil & anyone calling it needs to handle that.
   def split_file_path(path)
     path.split(File::SEPARATOR, 2) unless path == "" or Puppet::Util.absolute_path?(path)
   end
 
 end