diff --git a/lib/puppet/parser/lexer.rb b/lib/puppet/parser/lexer.rb
index 9a25263f6..71d9440ff 100644
--- a/lib/puppet/parser/lexer.rb
+++ b/lib/puppet/parser/lexer.rb
@@ -1,582 +1,583 @@
 # the scanner/lexer
 
 require 'strscan'
 require 'puppet'
 
 
 module Puppet
   class LexError < RuntimeError; end
 end
 
 module Puppet::Parser; end
 
 class Puppet::Parser::Lexer
   attr_reader :last, :file, :lexing_context, :token_queue
 
   attr_accessor :line, :indefine
 
   def lex_error msg
     raise Puppet::LexError.new(msg)
   end
 
   class Token
     attr_accessor :regex, :name, :string, :skip, :incr_line, :skip_text, :accumulate
 
     def initialize(regex, name)
       if regex.is_a?(String)
         @name, @string = name, regex
         @regex = Regexp.new(Regexp.escape(@string))
       else
         @name, @regex = name, regex
       end
     end
 
     # MQR: Why not just alias?
     %w{skip accumulate}.each do |method|
       define_method(method+"?") do
         self.send(method)
       end
     end
 
     def to_s
       if self.string
         @string
       else
         @name.to_s
       end
     end
 
     def acceptable?(context={})
       # By default tokens are aceeptable in any context
       true
     end
   end
 
   # Maintain a list of tokens.
   class TokenList
     attr_reader :regex_tokens, :string_tokens
 
     def [](name)
       @tokens[name]
     end
 
     # Create a new token.
     def add_token(name, regex, options = {}, &block)
       token = Token.new(regex, name)
       raise(ArgumentError, "Token #{name} already exists") if @tokens.include?(name)
       @tokens[token.name] = token
       if token.string
         @string_tokens << token
         @tokens_by_string[token.string] = token
       else
         @regex_tokens << token
       end
 
       options.each do |name, option|
         token.send(name.to_s + "=", option)
       end
 
       token.meta_def(:convert, &block) if block_given?
 
       token
     end
 
     def initialize
       @tokens = {}
       @regex_tokens = []
       @string_tokens = []
       @tokens_by_string = {}
     end
 
     # Look up a token by its value, rather than name.
     def lookup(string)
       @tokens_by_string[string]
     end
 
     # Define more tokens.
     def add_tokens(hash)
       hash.each do |regex, name|
         add_token(name, regex)
       end
     end
 
     # Sort our tokens by length, so we know once we match, we're done.
     # This helps us avoid the O(n^2) nature of token matching.
     def sort_tokens
       @string_tokens.sort! { |a, b| b.string.length <=> a.string.length }
     end
   end
 
   TOKENS = TokenList.new
 
     TOKENS.add_tokens(
 
       '[' => :LBRACK,
       ']' => :RBRACK,
       '{' => :LBRACE,
       '}' => :RBRACE,
       '(' => :LPAREN,
 
       ')' => :RPAREN,
       '=' => :EQUALS,
       '+=' => :APPENDS,
       '==' => :ISEQUAL,
       '>=' => :GREATEREQUAL,
       '>' => :GREATERTHAN,
       '<' => :LESSTHAN,
       '<=' => :LESSEQUAL,
       '!=' => :NOTEQUAL,
       '!' => :NOT,
       ',' => :COMMA,
       '.' => :DOT,
       ':' => :COLON,
       '@' => :AT,
       '<<|' => :LLCOLLECT,
       '->' => :IN_EDGE,
       '<-' => :OUT_EDGE,
       '~>' => :IN_EDGE_SUB,
       '<~' => :OUT_EDGE_SUB,
       '|>>' => :RRCOLLECT,
       '<|' => :LCOLLECT,
       '|>' => :RCOLLECT,
       ';' => :SEMIC,
       '?' => :QMARK,
       '\\' => :BACKSLASH,
       '=>' => :FARROW,
       '+>' => :PARROW,
       '+' => :PLUS,
       '-' => :MINUS,
       '/' => :DIV,
       '*' => :TIMES,
       '<<' => :LSHIFT,
       '>>' => :RSHIFT,
       '=~' => :MATCH,
       '!~' => :NOMATCH,
       %r{([a-z][-\w]*)?(::[a-z][-\w]*)+} => :CLASSNAME, # Require '::' in the class name, else we'd compete with NAME
       %r{((::){0,1}[A-Z][-\w]*)+} => :CLASSREF,
       "<string>" => :STRING,
       "<dqstring up to first interpolation>" => :DQPRE,
       "<dqstring between two interpolations>" => :DQMID,
       "<dqstring after final interpolation>" => :DQPOST,
       "<boolean>" => :BOOLEAN
       )
 
   TOKENS.add_token :NUMBER, %r{\b(?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?)\b} do |lexer, value|
     [TOKENS[:NAME], value]
   end
   #:stopdoc: # Issue #4161
   def (TOKENS[:NUMBER]).acceptable?(context={})
     ![:DQPRE,:DQMID].include? context[:after]
   end
   #:startdoc:
 
   TOKENS.add_token :NAME, %r{[a-z0-9][-\w]*} do |lexer, value|
     string_token = self
     # we're looking for keywords here
     if tmp = KEYWORDS.lookup(value)
       string_token = tmp
       if [:TRUE, :FALSE].include?(string_token.name)
         value = eval(value)
         string_token = TOKENS[:BOOLEAN]
       end
     end
     [string_token, value]
   end
   [:NAME,:CLASSNAME,:CLASSREF].each { |name_token|
     #:stopdoc: # Issue #4161
     def (TOKENS[name_token]).acceptable?(context={})
       ![:DQPRE,:DQMID].include? context[:after]
     end
     #:startdoc:
   }
 
   TOKENS.add_token :COMMENT, %r{#.*}, :accumulate => true, :skip => true do |lexer,value|
     value.sub!(/# ?/,'')
     [self, value]
   end
 
   TOKENS.add_token :MLCOMMENT, %r{/\*(.*?)\*/}m, :accumulate => true, :skip => true do |lexer, value|
     lexer.line += value.count("\n")
     value.sub!(/^\/\* ?/,'')
     value.sub!(/ ?\*\/$/,'')
     [self,value]
   end
 
   TOKENS.add_token :REGEX, %r{/[^/\n]*/} do |lexer, value|
     # Make sure we haven't matched an escaped /
     while value[-2..-2] == '\\'
       other = lexer.scan_until(%r{/})
       value += other
     end
     regex = value.sub(%r{\A/}, "").sub(%r{/\Z}, '').gsub("\\/", "/")
     [self, Regexp.new(regex)]
   end
 
   #:stopdoc: # Issue #4161
   def (TOKENS[:REGEX]).acceptable?(context={})
     [:NODE,:LBRACE,:RBRACE,:MATCH,:NOMATCH,:COMMA].include? context[:after]
   end
   #:startdoc:
 
   TOKENS.add_token :RETURN, "\n", :skip => true, :incr_line => true, :skip_text => true
 
   TOKENS.add_token :SQUOTE, "'" do |lexer, value|
     [TOKENS[:STRING], lexer.slurpstring(value,["'"],:ignore_invalid_escapes).first ]
   end
 
   DQ_initial_token_types      = {'$' => :DQPRE,'"' => :STRING}
   DQ_continuation_token_types = {'$' => :DQMID,'"' => :DQPOST}
 
   TOKENS.add_token :DQUOTE, /"/ do |lexer, value|
     lexer.tokenize_interpolated_string(DQ_initial_token_types)
   end
 
   TOKENS.add_token :DQCONT, /\}/ do |lexer, value|
     lexer.tokenize_interpolated_string(DQ_continuation_token_types)
   end
   #:stopdoc: # Issue #4161
   def (TOKENS[:DQCONT]).acceptable?(context={})
     context[:string_interpolation_depth] > 0
   end
   #:startdoc:
 
   TOKENS.add_token :DOLLAR_VAR, %r{\$(\w*::)*\w+} do |lexer, value|
     [TOKENS[:VARIABLE],value[1..-1]]
   end
 
   TOKENS.add_token :VARIABLE, %r{(\w*::)*\w+}
   #:stopdoc: # Issue #4161
   def (TOKENS[:VARIABLE]).acceptable?(context={})
     [:DQPRE,:DQMID].include? context[:after]
   end
   #:startdoc:
 
 
   TOKENS.sort_tokens
 
   @@pairs = {
     "{" => "}",
     "(" => ")",
     "[" => "]",
     "<|" => "|>",
     "<<|" => "|>>"
   }
 
   KEYWORDS = TokenList.new
 
 
     KEYWORDS.add_tokens(
 
       "case" => :CASE,
       "class" => :CLASS,
       "default" => :DEFAULT,
       "define" => :DEFINE,
       "import" => :IMPORT,
       "if" => :IF,
       "elsif" => :ELSIF,
       "else" => :ELSE,
       "inherits" => :INHERITS,
       "node" => :NODE,
       "and"  => :AND,
       "or"   => :OR,
       "undef"   => :UNDEF,
       "false" => :FALSE,
       "true" => :TRUE,
 
       "in" => :IN
   )
 
   def clear
     initvars
   end
 
   def expected
     return nil if @expected.empty?
     name = @expected[-1]
     TOKENS.lookup(name) or lex_error "Could not find expected token #{name}"
   end
 
   # scan the whole file
   # basically just used for testing
   def fullscan
     array = []
 
     self.scan { |token, str|
       # Ignore any definition nesting problems
       @indefine = false
       array.push([token,str])
     }
     array
   end
 
   def file=(file)
     @file = file
     @line = 1
-    @scanner = StringScanner.new(File.read(file))
+    contents = File.exists?(file) ? File.read(file) : ""
+    @scanner = StringScanner.new(contents)
   end
 
   def shift_token
     @token_queue.shift
   end
 
   def find_string_token
     # We know our longest string token is three chars, so try each size in turn
     # until we either match or run out of chars.  This way our worst-case is three
     # tries, where it is otherwise the number of string token we have.  Also,
     # the lookups are optimized hash lookups, instead of regex scans.
     #
     s = @scanner.peek(3)
     token = TOKENS.lookup(s[0,3]) || TOKENS.lookup(s[0,2]) || TOKENS.lookup(s[0,1])
     [ token, token && @scanner.scan(token.regex) ]
   end
 
   # Find the next token that matches a regex.  We look for these first.
   def find_regex_token
     @regex += 1
     best_token = nil
     best_length = 0
 
     # I tried optimizing based on the first char, but it had
     # a slightly negative affect and was a good bit more complicated.
     TOKENS.regex_tokens.each do |token|
       if length = @scanner.match?(token.regex) and token.acceptable?(lexing_context)
         # We've found a longer match
         if length > best_length
           best_length = length
           best_token = token
         end
       end
     end
 
     return best_token, @scanner.scan(best_token.regex) if best_token
   end
 
   # Find the next token, returning the string and the token.
   def find_token
     @find += 1
     shift_token || find_regex_token || find_string_token
   end
 
   def indefine?
     if defined?(@indefine)
       @indefine
     else
       false
     end
   end
 
   def initialize
     @find = 0
     @regex = 0
     initvars
   end
 
   def initvars
     @line = 1
     @previous_token = nil
     @scanner = nil
     @file = nil
     # AAARRGGGG! okay, regexes in ruby are bloody annoying
     # no one else has "\n" =~ /\s/
     @skip = %r{[ \t\r]+}
 
     @namestack = []
     @token_queue = []
     @indefine = false
     @expected = []
     @commentstack = [ ['', @line] ]
     @lexing_context = {
       :after => nil,
       :start_of_line => true,
       :string_interpolation_depth => 0
       }
   end
 
   # Make any necessary changes to the token and/or value.
   def munge_token(token, value)
     @line += 1 if token.incr_line
 
     skip if token.skip_text
 
     return if token.skip and not token.accumulate?
 
     token, value = token.convert(self, value) if token.respond_to?(:convert)
 
     return unless token
 
     if token.accumulate?
       comment = @commentstack.pop
       comment[0] << value + "\n"
       @commentstack.push(comment)
     end
 
     return if token.skip
 
     return token, { :value => value, :line => @line }
   end
 
   # Go up one in the namespace.
   def namepop
     @namestack.pop
   end
 
   # Collect the current namespace.
   def namespace
     @namestack.join("::")
   end
 
   # This value might have :: in it, but we don't care -- it'll be
   # handled normally when joining, and when popping we want to pop
   # this full value, however long the namespace is.
   def namestack(value)
     @namestack << value
   end
 
   def rest
     @scanner.rest
   end
 
   # this is the heart of the lexer
   def scan
     #Puppet.debug("entering scan")
     lex_error "Invalid or empty string" unless @scanner
 
     # Skip any initial whitespace.
     skip
 
     until token_queue.empty? and @scanner.eos? do
       yielded = false
       matched_token, value = find_token
 
       # error out if we didn't match anything at all
       lex_error "Could not match #{@scanner.rest[/^(\S+|\s+|.*)/]}" unless matched_token
 
       newline = matched_token.name == :RETURN
 
       # this matches a blank line; eat the previously accumulated comments
       getcomment if lexing_context[:start_of_line] and newline
       lexing_context[:start_of_line] = newline
 
       final_token, token_value = munge_token(matched_token, value)
 
       unless final_token
         skip
         next
       end
 
       lexing_context[:after]         = final_token.name unless newline
       lexing_context[:string_interpolation_depth] += 1 if final_token.name == :DQPRE
       lexing_context[:string_interpolation_depth] -= 1 if final_token.name == :DQPOST
 
       value = token_value[:value]
 
       if match = @@pairs[value] and final_token.name != :DQUOTE and final_token.name != :SQUOTE
         @expected << match
       elsif exp = @expected[-1] and exp == value and final_token.name != :DQUOTE and final_token.name != :SQUOTE
         @expected.pop
       end
 
       if final_token.name == :LBRACE or final_token.name == :LPAREN
         commentpush
       end
       if final_token.name == :RPAREN
         commentpop
       end
 
       yield [final_token.name, token_value]
 
       if @previous_token
         namestack(value) if @previous_token.name == :CLASS and value != '{'
 
         if @previous_token.name == :DEFINE
           if indefine?
             msg = "Cannot nest definition #{value} inside #{@indefine}"
             self.indefine = false
             raise Puppet::ParseError, msg
           end
 
           @indefine = value
         end
       end
       @previous_token = final_token
       skip
     end
     @scanner = nil
 
     # This indicates that we're done parsing.
     yield [false,false]
   end
 
   # Skip any skipchars in our remaining string.
   def skip
     @scanner.skip(@skip)
   end
 
   # Provide some limited access to the scanner, for those
   # tokens that need it.
   def scan_until(regex)
     @scanner.scan_until(regex)
   end
 
   # we've encountered the start of a string...
   # slurp in the rest of the string and return it
   def slurpstring(terminators,escapes=%w{ \\  $ ' " n t s }+["\n"],ignore_invalid_escapes=false)
     # we search for the next quote that isn't preceded by a
     # backslash; the caret is there to match empty strings
     str = @scanner.scan_until(/([^\\]|^|[^\\])([\\]{2})*[#{terminators}]/) or lex_error "Unclosed quote after '#{last}' in '#{rest}'"
     @line += str.count("\n") # literal carriage returns add to the line count.
     str.gsub!(/\\(.)/m) {
       ch = $1
       if escapes.include? ch
         case ch
         when 'n'; "\n"
         when 't'; "\t"
         when 's'; " "
         when "\n": ''
         else      ch
         end
       else
         Puppet.warning "Unrecognised escape sequence '\\#{ch}'#{file && " in file #{file}"}#{line && " at line #{line}"}" unless ignore_invalid_escapes
         "\\#{ch}"
       end
     }
     [ str[0..-2],str[-1,1] ]
   end
 
   def tokenize_interpolated_string(token_type,preamble='')
     value,terminator = slurpstring('"$')
     token_queue << [TOKENS[token_type[terminator]],preamble+value]
     if terminator != '$' or @scanner.scan(/\{/)
-      token_queue.shift 
+      token_queue.shift
     elsif var_name = @scanner.scan(%r{(\w*::)*\w+|[0-9]})
       token_queue << [TOKENS[:VARIABLE],var_name]
       tokenize_interpolated_string(DQ_continuation_token_types)
     else
       tokenize_interpolated_string(token_type,token_queue.pop.last + terminator)
     end
   end
 
   # just parse a string, not a whole file
   def string=(string)
     @scanner = StringScanner.new(string)
   end
 
   # returns the content of the currently accumulated content cache
   def commentpop
     @commentstack.pop[0]
   end
 
   def getcomment(line = nil)
     comment = @commentstack.last
     if line.nil? or comment[1] <= line
       @commentstack.pop
       @commentstack.push(['', @line])
       return comment[0]
     end
     ''
   end
 
   def commentpush
     @commentstack.push(['', @line])
   end
 end
diff --git a/lib/puppet/parser/parser_support.rb b/lib/puppet/parser/parser_support.rb
index 7a0aa2601..9e580efb2 100644
--- a/lib/puppet/parser/parser_support.rb
+++ b/lib/puppet/parser/parser_support.rb
@@ -1,237 +1,236 @@
 # I pulled this into a separate file, because I got
 # tired of rebuilding the parser.rb file all the time.
 class Puppet::Parser::Parser
   require 'puppet/parser/functions'
   require 'puppet/parser/files'
   require 'puppet/resource/type_collection'
   require 'puppet/resource/type_collection_helper'
   require 'puppet/resource/type'
   require 'monitor'
 
   AST = Puppet::Parser::AST
 
   include Puppet::Resource::TypeCollectionHelper
 
   attr_reader :version, :environment
   attr_accessor :files
 
   attr_accessor :lexer
 
   # Add context to a message; useful for error messages and such.
   def addcontext(message, obj = nil)
     obj ||= @lexer
 
     message += " on line #{obj.line}"
     if file = obj.file
       message += " in file #{file}"
     end
 
     message
   end
 
   # Create an AST array out of all of the args
   def aryfy(*args)
     if args[0].instance_of?(AST::ASTArray)
       result = args.shift
       args.each { |arg|
         result.push arg
       }
     else
       result = ast AST::ASTArray, :children => args
     end
 
     result
   end
 
   # Create an AST object, and automatically add the file and line information if
   # available.
   def ast(klass, hash = {})
     klass.new ast_context(klass.use_docs, hash[:line]).merge(hash)
   end
 
   def ast_context(include_docs = false, ast_line = nil)
     result = {
       :line => ast_line || lexer.line,
       :file => lexer.file
     }
     result[:doc] = lexer.getcomment(result[:line]) if include_docs
     result
   end
 
   # The fully qualifed name, with the full namespace.
   def classname(name)
     [@lexer.namespace, name].join("::").sub(/^::/, '')
   end
 
   def clear
     initvars
   end
 
   # Raise a Parse error.
   def error(message)
     if brace = @lexer.expected
       message += "; expected '%s'"
     end
     except = Puppet::ParseError.new(message)
     except.line = @lexer.line
     except.file = @lexer.file if @lexer.file
 
     raise except
   end
 
   def file
     @lexer.file
   end
 
   def file=(file)
     unless FileTest.exist?(file)
       unless file =~ /\.pp$/
         file = file + ".pp"
       end
-      raise Puppet::Error, "Could not find file #{file}" unless FileTest.exist?(file)
     end
     raise Puppet::AlreadyImportedError, "Import loop detected" if known_resource_types.watching_file?(file)
 
     watch_file(file)
     @lexer.file = file
   end
 
   [:hostclass, :definition, :node, :nodes?].each do |method|
     define_method(method) do |*args|
       known_resource_types.send(method, *args)
     end
   end
 
   def find_hostclass(namespace, name)
     known_resource_types.find_or_load(namespace, name, :hostclass)
   end
 
   def find_definition(namespace, name)
     known_resource_types.find_or_load(namespace, name, :definition)
   end
 
   def import(file)
     known_resource_types.loader.import(file, @lexer.file)
   end
 
   def initialize(env)
     # The environment is needed to know how to find the resource type collection.
     @environment = env.is_a?(String) ? Puppet::Node::Environment.new(env) : env
     initvars
   end
 
   # Initialize or reset all of our variables.
   def initvars
     @lexer = Puppet::Parser::Lexer.new
   end
 
   # Split an fq name into a namespace and name
   def namesplit(fullname)
     ary = fullname.split("::")
     n = ary.pop || ""
     ns = ary.join("::")
     return ns, n
   end
 
   # Create a new class, or merge with an existing class.
   def newclass(name, options = {})
     known_resource_types.add Puppet::Resource::Type.new(:hostclass, name, ast_context(true, options[:line]).merge(options))
   end
 
   # Create a new definition.
   def newdefine(name, options = {})
     known_resource_types.add Puppet::Resource::Type.new(:definition, name, ast_context(true, options[:line]).merge(options))
   end
 
   # Create a new node.  Nodes are special, because they're stored in a global
   # table, not according to namespaces.
   def newnode(names, options = {})
     names = [names] unless names.instance_of?(Array)
     context = ast_context(true, options[:line])
     names.collect do |name|
       known_resource_types.add(Puppet::Resource::Type.new(:node, name, context.merge(options)))
     end
   end
 
   def on_error(token,value,stack)
     if token == 0 # denotes end of file
       value = 'end of file'
     else
       value = "'#{value[:value]}'"
     end
     error = "Syntax error at #{value}"
 
     if brace = @lexer.expected
       error += "; expected '#{brace}'"
     end
 
     except = Puppet::ParseError.new(error)
     except.line = @lexer.line
     except.file = @lexer.file if @lexer.file
 
     raise except
   end
 
   # how should I do error handling here?
   def parse(string = nil)
     return parse_ruby_file if self.file =~ /\.rb$/
     self.string = string if string
     begin
       @yydebug = false
       main = yyparse(@lexer,:scan)
     rescue Racc::ParseError => except
       error = Puppet::ParseError.new(except)
       error.line = @lexer.line
       error.file = @lexer.file
       error.set_backtrace except.backtrace
       raise error
     rescue Puppet::ParseError => except
       except.line ||= @lexer.line
       except.file ||= @lexer.file
       raise except
     rescue Puppet::Error => except
       # and this is a framework error
       except.line ||= @lexer.line
       except.file ||= @lexer.file
       raise except
     rescue Puppet::DevError => except
       except.line ||= @lexer.line
       except.file ||= @lexer.file
       raise except
     rescue => except
       error = Puppet::DevError.new(except.message)
       error.line = @lexer.line
       error.file = @lexer.file
       error.set_backtrace except.backtrace
       raise error
     end
     if main
       # Store the results as the top-level class.
       newclass("", :code => main)
     end
     return known_resource_types
   ensure
     @lexer.clear
   end
 
   def parse_ruby_file
     # Execute the contents of the file inside its own "main" object so
     # that it can call methods in the resource type API.
     Puppet::DSL::ResourceTypeAPI.new.instance_eval(File.read(self.file))
   end
 
   def string=(string)
     @lexer.string = string
   end
 
   def version
     known_resource_types.version
   end
 
   # Add a new file to be checked when we're checking to see if we should be
   # reparsed.  This is basically only used by the TemplateWrapper to let the
   # parser know about templates that should be parsed.
   def watch_file(filename)
     known_resource_types.watch_file(filename)
   end
 end
diff --git a/lib/puppet/resource/type_collection.rb b/lib/puppet/resource/type_collection.rb
index 277d37b18..347e1c0e0 100644
--- a/lib/puppet/resource/type_collection.rb
+++ b/lib/puppet/resource/type_collection.rb
@@ -1,217 +1,216 @@
 class Puppet::Resource::TypeCollection
   attr_reader :environment
 
   def clear
     @hostclasses.clear
     @definitions.clear
     @nodes.clear
   end
 
   def initialize(env)
     @environment = env.is_a?(String) ? Puppet::Node::Environment.new(env) : env
     @hostclasses = {}
     @definitions = {}
     @nodes = {}
 
     # So we can keep a list and match the first-defined regex
     @node_list = []
 
     @watched_files = {}
   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
     require 'puppet/parser/type_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(namespaces, name, type)
     #Array("") == [] for some reason
     namespaces = [namespaces] unless namespaces.is_a?(Array)
 
     if name =~ /^::/
       return send(type, name.sub(/^::/, ''))
     end
 
     namespaces.each do |namespace|
       ary = namespace.split("::")
 
       while ary.length > 0
         tmp_namespace = ary.join("::")
         if r = find_partially_qualified(tmp_namespace, name, type)
           return r
         end
 
         # Delete the second to last object, which reduces our namespace by one.
         ary.pop
       end
 
       if result = send(type, name)
         return result
       end
     end
     nil
   end
 
   def find_or_load(namespaces, name, type)
     name      = name.downcase
     namespaces = [namespaces] unless namespaces.is_a?(Array)
     namespaces = namespaces.collect { |ns| ns.downcase }
 
     # This could be done in the load_until, but the knowledge seems to
     # belong here.
     if r = find(namespaces, name, type)
       return r
     end
 
     loader.load_until(namespaces, name) { find(namespaces, name, type) }
   end
 
   def find_node(namespaces, name)
     find("", name, :node)
   end
 
   def find_hostclass(namespaces, name)
     find_or_load(namespaces, name, :hostclass)
   end
 
   def find_definition(namespaces, name)
     find_or_load(namespaces, name, :definition)
   end
 
   [:hostclasses, :nodes, :definitions].each do |m|
     define_method(m) do
       instance_variable_get("@#{m}").dup
     end
   end
 
   def perform_initial_import
     parser = Puppet::Parser::Parser.new(environment)
     if code = Puppet.settings.uninterpolated_value(:code, environment.to_s) and code != ""
       parser.string = code
     else
       file = Puppet.settings.value(:manifest, environment.to_s)
-      return unless File.exist?(file)
       parser.file = file
     end
     parser.parse
   rescue => detail
     msg = "Could not parse for environment #{environment}: #{detail}"
     error = Puppet::Error.new(msg)
     error.set_backtrace(detail.backtrace)
     raise error
   end
 
   def stale?
     @watched_files.values.detect { |file| file.changed? }
   end
 
   def version
     return @version if defined?(@version)
 
     if environment[:config_version] == ""
       @version = Time.now.to_i
       return @version
     end
 
     @version = Puppet::Util.execute([environment[:config_version]]).strip
 
   rescue Puppet::ExecutionFailure => e
     raise Puppet::ParseError, "Unable to set config_version: #{e.message}"
   end
 
   def watch_file(file)
     @watched_files[file] = Puppet::Util::LoadedFile.new(file)
   end
 
   def watching_file?(file)
     @watched_files.include?(file)
   end
 
   private
 
   def find_partially_qualified(namespace, name, type)
     send(type, [namespace, name].join("::"))
   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/simple_graph.rb b/lib/puppet/simple_graph.rb
index c5dac0f6c..c658b3b92 100644
--- a/lib/puppet/simple_graph.rb
+++ b/lib/puppet/simple_graph.rb
@@ -1,452 +1,452 @@
 #  Created by Luke A. Kanies on 2007-11-07.
 #  Copyright (c) 2007. All rights reserved.
 
 require 'puppet/external/dot'
 require 'puppet/relationship'
 require 'set'
 
 # A hopefully-faster graph class to replace the use of GRATR.
 class Puppet::SimpleGraph
   # An internal class for handling a vertex's edges.
   class VertexWrapper
     attr_accessor :in, :out, :vertex
 
     # Remove all references to everything.
     def clear
       @adjacencies[:in].clear
       @adjacencies[:out].clear
       @vertex = nil
     end
 
     def initialize(vertex)
       @vertex = vertex
       @adjacencies = {:in => {}, :out => {}}
     end
 
     # Find adjacent vertices or edges.
     def adjacent(options)
       direction = options[:direction] || :out
       options[:type] ||= :vertices
 
       return send(direction.to_s + "_edges") if options[:type] == :edges
 
       @adjacencies[direction].keys.reject { |vertex| @adjacencies[direction][vertex].empty? }
     end
 
     # Add an edge to our list.
     def add_edge(direction, edge)
       opposite_adjacencies(direction, edge) << edge
     end
 
     # Return all known edges.
     def edges
       in_edges + out_edges
     end
 
     # Test whether we share an edge with a given vertex.
     def has_edge?(direction, vertex)
       return(vertex_adjacencies(direction, vertex).length > 0 ? true : false)
     end
 
     # Create methods for returning the degree and edges.
     [:in, :out].each do |direction|
       # LAK:NOTE If you decide to create methods for directly
       # testing the degree, you'll have to get the values and flatten
       # the results -- you might have duplicate edges, which can give
       # a false impression of what the degree is.  That's just
       # as expensive as just getting the edge list, so I've decided
       # to only add this method.
       define_method("#{direction}_edges") do
         @adjacencies[direction].values.inject([]) { |total, adjacent| total += adjacent.to_a; total }
       end
     end
 
     # The other vertex in the edge.
     def other_vertex(direction, edge)
       case direction
       when :in; edge.source
       else
         edge.target
       end
     end
 
     # Remove an edge from our list.  Assumes that we've already checked
     # that the edge is valid.
     def remove_edge(direction, edge)
       opposite_adjacencies(direction, edge).delete(edge)
     end
 
     def to_s
       vertex.to_s
     end
 
     def inspect
       { :@adjacencies => @adjacencies, :@vertex => @vertex.to_s }.inspect
     end
 
     private
 
     # These methods exist so we don't need a Hash with a default proc.
 
     # Look up the adjacencies for a vertex at the other end of an
     # edge.
     def opposite_adjacencies(direction, edge)
       opposite_vertex = other_vertex(direction, edge)
       vertex_adjacencies(direction, opposite_vertex)
     end
 
     # Look up the adjacencies for a given vertex.
     def vertex_adjacencies(direction, vertex)
       @adjacencies[direction][vertex] ||= Set.new
       @adjacencies[direction][vertex]
     end
   end
 
   def initialize
     @vertices = {}
     @edges = []
   end
 
   # Clear our graph.
   def clear
     @vertices.each { |vertex, wrapper| wrapper.clear }
     @vertices.clear
     @edges.clear
   end
 
   # Which resources a given resource depends upon.
   def dependents(resource)
     tree_from_vertex(resource).keys
   end
 
   # Which resources depend upon the given resource.
   def dependencies(resource)
     # Cache the reversal graph, because it's somewhat expensive
     # to create.
     @reversal ||= reversal
     # Strangely, it's significantly faster to search a reversed
     # tree in the :out direction than to search a normal tree
     # in the :in direction.
     @reversal.tree_from_vertex(resource, :out).keys
   end
 
   # Whether our graph is directed.  Always true.  Used to produce dot files.
   def directed?
     true
   end
 
   # Determine all of the leaf nodes below a given vertex.
   def leaves(vertex, direction = :out)
     tree = tree_from_vertex(vertex, direction)
     l = tree.keys.find_all { |c| adjacent(c, :direction => direction).empty? }
   end
 
   # Collect all of the edges that the passed events match.  Returns
   # an array of edges.
   def matching_edges(event, base = nil)
     source = base || event.resource
 
     unless vertex?(source)
       Puppet.warning "Got an event from invalid vertex #{source.ref}"
       return []
     end
     # Get all of the edges that this vertex should forward events
     # to, which is the same thing as saying all edges directly below
     # This vertex in the graph.
     adjacent(source, :direction => :out, :type => :edges).find_all do |edge|
       edge.match?(event.name)
     end
   end
 
   # Return a reversed version of this graph.
   def reversal
     result = self.class.new
     vertices.each { |vertex| result.add_vertex(vertex) }
     edges.each do |edge|
       newedge = edge.class.new(edge.target, edge.source, edge.label)
       result.add_edge(newedge)
     end
     result
   end
 
   # Return the size of the graph.
   def size
     @vertices.length
   end
 
   # Return the graph as an array.
   def to_a
     @vertices.keys
   end
 
   # Provide a topological sort.
   def topsort
     degree = {}
     zeros = []
     result = []
 
     # Collect each of our vertices, with the number of in-edges each has.
     @vertices.each do |name, wrapper|
       edges = wrapper.in_edges
       zeros << wrapper if edges.length == 0
       degree[wrapper.vertex] = edges
     end
 
     # Iterate over each 0-degree vertex, decrementing the degree of
     # each of its out-edges.
     while wrapper = zeros.pop
       result << wrapper.vertex
       wrapper.out_edges.each do |edge|
         degree[edge.target].delete(edge)
         zeros << @vertices[edge.target] if degree[edge.target].length == 0
       end
     end
 
     # If we have any vertices left with non-zero in-degrees, then we've found a cycle.
     if cycles = degree.find_all { |vertex, edges| edges.length > 0 } and cycles.length > 0
       message = cycles.collect { |vertex, edges| edges.collect { |e| e.to_s }.join(", ") }.join(", ")
       raise Puppet::Error, "Found dependency cycles in the following relationships: #{message}; try using the '--graph' option and open the '.dot' files in OmniGraffle or GraphViz"
     end
 
     result
   end
 
   # Add a new vertex to the graph.
   def add_vertex(vertex)
     @reversal = nil
     return false if vertex?(vertex)
     setup_vertex(vertex)
     true # don't return the VertexWrapper instance.
   end
 
   # Remove a vertex from the graph.
   def remove_vertex!(vertex)
     return nil unless vertex?(vertex)
     @vertices[vertex].edges.each { |edge| remove_edge!(edge) }
     @edges -= @vertices[vertex].edges
     @vertices[vertex].clear
     @vertices.delete(vertex)
   end
 
   # Test whether a given vertex is in the graph.
   def vertex?(vertex)
     @vertices.include?(vertex)
   end
 
   # Return a list of all vertices.
   def vertices
     @vertices.keys
   end
 
   # Add a new edge.  The graph user has to create the edge instance,
   # since they have to specify what kind of edge it is.
   def add_edge(source, target = nil, label = nil)
     @reversal = nil
     if target
       edge = Puppet::Relationship.new(source, target, label)
     else
       edge = source
     end
     [edge.source, edge.target].each { |vertex| setup_vertex(vertex) unless vertex?(vertex) }
     @vertices[edge.source].add_edge :out, edge
     @vertices[edge.target].add_edge :in, edge
     @edges << edge
     true
   end
 
   # Find a matching edge.  Note that this only finds the first edge,
   # not all of them or whatever.
   def edge(source, target)
     @edges.each_with_index { |test_edge, index| return test_edge if test_edge.source == source and test_edge.target == target }
   end
 
   def edge_label(source, target)
     return nil unless edge = edge(source, target)
     edge.label
   end
 
   # Is there an edge between the two vertices?
   def edge?(source, target)
     return false unless vertex?(source) and vertex?(target)
 
     @vertices[source].has_edge?(:out, target)
   end
 
   def edges
     @edges.dup
   end
 
   # Remove an edge from our graph.
   def remove_edge!(edge)
     @vertices[edge.source].remove_edge(:out, edge)
     @vertices[edge.target].remove_edge(:in, edge)
 
     @edges.delete(edge)
     nil
   end
 
   # Find adjacent edges.
   def adjacent(vertex, options = {})
     return [] unless wrapper = @vertices[vertex]
     wrapper.adjacent(options)
   end
 
   private
 
   # An internal method that skips the validation, so we don't have
   # duplicate validation calls.
   def setup_vertex(vertex)
     @vertices[vertex] = VertexWrapper.new(vertex)
   end
 
   public
 
 #    # For some reason, unconnected vertices do not show up in
 #    # this graph.
 #    def to_jpg(path, name)
 #        gv = vertices
 #        Dir.chdir(path) do
 #            induced_subgraph(gv).write_to_graphic_file('jpg', name)
 #        end
 #    end
 
   # Take container information from another graph and use it
   # to replace any container vertices with their respective leaves.
   # This creates direct relationships where there were previously
   # indirect relationships through the containers.
   def splice!(other, type)
     # We have to get the container list via a topological sort on the
     # configuration graph, because otherwise containers that contain
     # other containers will add those containers back into the
     # graph.  We could get a similar affect by only setting relationships
     # to container leaves, but that would result in many more
     # relationships.
     stage_class = Puppet::Type.type(:stage)
     whit_class  = Puppet::Type.type(:whit)
     containers = other.topsort.find_all { |v| (v.is_a?(type) or v.is_a?(stage_class)) and vertex?(v) }
     containers.each do |container|
       # Get the list of children from the other graph.
       children = other.adjacent(container, :direction => :out)
 
       # MQR TODO: Luke suggests that it should be possible to refactor the system so that
-      #           container nodes are retained, thus obviating the need for the whit. 
+      #           container nodes are retained, thus obviating the need for the whit.
       children = [whit_class.new(:name => container.name, :catalog => other)] if children.empty?
 
       # First create new edges for each of the :in edges
       [:in, :out].each do |dir|
         edges = adjacent(container, :direction => dir, :type => :edges)
         edges.each do |edge|
           children.each do |child|
             if dir == :in
               s = edge.source
               t = child
             else
               s = child
               t = edge.target
             end
 
             add_edge(s, t, edge.label)
           end
 
           # Now get rid of the edge, so remove_vertex! works correctly.
           remove_edge!(edge)
         end
       end
       remove_vertex!(container)
     end
   end
 
   # Just walk the tree and pass each edge.
   def walk(source, direction)
     # Use an iterative, breadth-first traversal of the graph. One could do
     # this recursively, but Ruby's slow function calls and even slower
     # recursion make the shorter, recursive algorithm cost-prohibitive.
     stack = [source]
     seen = Set.new
     until stack.empty?
       node = stack.shift
       next if seen.member? node
       connected = adjacent(node, :direction => direction)
       connected.each do |target|
         yield node, target
       end
       stack.concat(connected)
       seen << node
     end
   end
 
   # A different way of walking a tree, and a much faster way than the
   # one that comes with GRATR.
   def tree_from_vertex(start, direction = :out)
     predecessor={}
     walk(start, direction) do |parent, child|
       predecessor[child] = parent
     end
     predecessor
   end
 
   # LAK:FIXME This is just a paste of the GRATR code with slight modifications.
 
   # Return a DOT::DOTDigraph for directed graphs or a DOT::DOTSubgraph for an
   # undirected Graph.  _params_ can contain any graph property specified in
   # rdot.rb. If an edge or vertex label is a kind of Hash then the keys
   # which match +dot+ properties will be used as well.
   def to_dot_graph (params = {})
     params['name'] ||= self.class.name.gsub(/:/,'_')
     fontsize   = params['fontsize'] ? params['fontsize'] : '8'
     graph      = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
     edge_klass = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
     vertices.each do |v|
       name = v.to_s
       params = {'name'     => '"'+name+'"',
         'fontsize' => fontsize,
         'label'    => name}
       v_label = v.to_s
       params.merge!(v_label) if v_label and v_label.kind_of? Hash
       graph << DOT::DOTNode.new(params)
     end
     edges.each do |e|
       params = {'from'     => '"'+ e.source.to_s + '"',
         'to'       => '"'+ e.target.to_s + '"',
         'fontsize' => fontsize }
       e_label = e.to_s
       params.merge!(e_label) if e_label and e_label.kind_of? Hash
       graph << edge_klass.new(params)
     end
     graph
   end
 
   # Output the dot format as a string
   def to_dot (params={}) to_dot_graph(params).to_s; end
 
   # Call +dotty+ for the graph which is written to the file 'graph.dot'
   # in the # current directory.
   def dotty (params = {}, dotfile = 'graph.dot')
     File.open(dotfile, 'w') {|f| f << to_dot(params) }
     system('dotty', dotfile)
   end
 
   # Use +dot+ to create a graphical representation of the graph.  Returns the
   # filename of the graphics file.
   def write_to_graphic_file (fmt='png', dotfile='graph')
     src = dotfile + '.dot'
     dot = dotfile + '.' + fmt
 
     File.open(src, 'w') {|f| f << self.to_dot << "\n"}
 
     system( "dot -T#{fmt} #{src} -o #{dot}" )
     dot
   end
 
   # Produce the graph files if requested.
   def write_graph(name)
     return unless Puppet[:graph]
 
     Puppet.settings.use(:graphing)
 
     file = File.join(Puppet[:graphdir], "#{name}.dot")
     File.open(file, "w") { |f|
       f.puts to_dot("name" => name.to_s.capitalize)
     }
   end
 end
diff --git a/lib/puppet/util/loadedfile.rb b/lib/puppet/util/loadedfile.rb
index 735dba459..d2f5d0923 100755
--- a/lib/puppet/util/loadedfile.rb
+++ b/lib/puppet/util/loadedfile.rb
@@ -1,65 +1,61 @@
 # A simple class that tells us when a file has changed and thus whether we
 # should reload it
 
 require 'puppet'
 
 module Puppet
   class NoSuchFile < Puppet::Error; end
   class Util::LoadedFile
     attr_reader :file, :statted
 
     # Provide a hook for setting the timestamp during testing, so we don't
     # have to depend on the granularity of the filesystem.
     attr_writer :tstamp
 
     # Determine whether the file has changed and thus whether it should
     # be reparsed.
     def changed?
       # Allow the timeout to be disabled entirely.
       return true if Puppet[:filetimeout] < 0
       tmp = stamp
 
       # We use a different internal variable than the stamp method
       # because it doesn't keep historical state and we do -- that is,
       # we will always be comparing two timestamps, whereas
       # stamp just always wants the latest one.
       if tmp == @tstamp
         return false
       else
         @tstamp = tmp
         return @tstamp
       end
     end
 
     # Create the file.  Must be passed the file path.
     def initialize(file)
       @file = file
-      unless FileTest.exists?(@file)
-        raise Puppet::NoSuchFile,
-          "Can not use a non-existent file for parsing"
-      end
       @statted = 0
       @stamp = nil
       @tstamp = stamp
     end
 
     # Retrieve the filestamp, but only refresh it if we're beyond our
     # filetimeout
     def stamp
       if @stamp.nil? or (Time.now.to_i - @statted >= Puppet[:filetimeout])
         @statted = Time.now.to_i
         begin
           @stamp = File.stat(@file).ctime
-        rescue Errno::ENOENT
+        rescue Errno::ENOENT, Errno::ENOTDIR
           @stamp = Time.now
         end
       end
       @stamp
     end
 
     def to_s
       @file
     end
   end
 end
 
diff --git a/spec/unit/parser/lexer_spec.rb b/spec/unit/parser/lexer_spec.rb
index 4ef242cf5..d144504c5 100755
--- a/spec/unit/parser/lexer_spec.rb
+++ b/spec/unit/parser/lexer_spec.rb
@@ -1,681 +1,693 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/parser/lexer'
 
 # This is a special matcher to match easily lexer output
 RSpec::Matchers.define :be_like do |*expected|
   match do |actual|
     expected.zip(actual).all? { |e,a| !e or a[0] == e or (e.is_a? Array and a[0] == e[0] and (a[1] == e[1] or (a[1].is_a?(Hash) and a[1][:value] == e[1]))) }
   end
 end
 __ = nil
 
 describe Puppet::Parser::Lexer do
   describe "when reading strings" do
     before { @lexer = Puppet::Parser::Lexer.new }
     it "should increment the line count for every carriage return in the string" do
       @lexer.line = 10
       @lexer.string = "this\nis\natest'"
       @lexer.slurpstring("'")
 
       @lexer.line.should == 12
     end
 
     it "should not increment the line count for escapes in the string" do
       @lexer.line = 10
       @lexer.string = "this\\nis\\natest'"
       @lexer.slurpstring("'")
 
       @lexer.line.should == 10
     end
 
     it "should not think the terminator is escaped, when preceeded by an even number of backslashes" do
       @lexer.line = 10
       @lexer.string = "here\nis\nthe\nstring\\\\'with\nextra\njunk"
       @lexer.slurpstring("'")
 
       @lexer.line.should == 13
     end
   end
 end
 
 describe Puppet::Parser::Lexer::Token do
   before do
     @token = Puppet::Parser::Lexer::Token.new(%r{something}, :NAME)
   end
 
   [:regex, :name, :string, :skip, :incr_line, :skip_text, :accumulate].each do |param|
     it "should have a #{param.to_s} reader" do
       @token.should be_respond_to(param)
     end
 
     it "should have a #{param.to_s} writer" do
       @token.should be_respond_to(param.to_s + "=")
     end
   end
 end
 
 describe Puppet::Parser::Lexer::Token, "when initializing" do
   it "should create a regex if the first argument is a string" do
     Puppet::Parser::Lexer::Token.new("something", :NAME).regex.should == %r{something}
   end
 
   it "should set the string if the first argument is one" do
     Puppet::Parser::Lexer::Token.new("something", :NAME).string.should == "something"
   end
 
   it "should set the regex if the first argument is one" do
     Puppet::Parser::Lexer::Token.new(%r{something}, :NAME).regex.should == %r{something}
   end
 end
 
 describe Puppet::Parser::Lexer::TokenList do
   before do
     @list = Puppet::Parser::Lexer::TokenList.new
   end
 
   it "should have a method for retrieving tokens by the name" do
     token = @list.add_token :name, "whatever"
     @list[:name].should equal(token)
   end
 
   it "should have a method for retrieving string tokens by the string" do
     token = @list.add_token :name, "whatever"
     @list.lookup("whatever").should equal(token)
   end
 
   it "should add tokens to the list when directed" do
     token = @list.add_token :name, "whatever"
     @list[:name].should equal(token)
   end
 
   it "should have a method for adding multiple tokens at once" do
     @list.add_tokens "whatever" => :name, "foo" => :bar
     @list[:name].should_not be_nil
     @list[:bar].should_not be_nil
   end
 
   it "should fail to add tokens sharing a name with an existing token" do
     @list.add_token :name, "whatever"
     lambda { @list.add_token :name, "whatever" }.should raise_error(ArgumentError)
   end
 
   it "should set provided options on tokens being added" do
     token = @list.add_token :name, "whatever", :skip_text => true
     token.skip_text.should == true
   end
 
   it "should define any provided blocks as a :convert method" do
     token = @list.add_token(:name, "whatever")  do "foo" end
     token.convert.should == "foo"
   end
 
   it "should store all string tokens in the :string_tokens list" do
     one = @list.add_token(:name, "1")
     @list.string_tokens.should be_include(one)
   end
 
   it "should store all regex tokens in the :regex_tokens list" do
     one = @list.add_token(:name, %r{one})
     @list.regex_tokens.should be_include(one)
   end
 
   it "should not store string tokens in the :regex_tokens list" do
     one = @list.add_token(:name, "1")
     @list.regex_tokens.should_not be_include(one)
   end
 
   it "should not store regex tokens in the :string_tokens list" do
     one = @list.add_token(:name, %r{one})
     @list.string_tokens.should_not be_include(one)
   end
 
   it "should sort the string tokens inversely by length when asked" do
     one = @list.add_token(:name, "1")
     two = @list.add_token(:other, "12")
     @list.sort_tokens
     @list.string_tokens.should == [two, one]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS do
   before do
     @lexer = Puppet::Parser::Lexer.new
   end
 
   {
     :LBRACK => '[',
     :RBRACK => ']',
     :LBRACE => '{',
     :RBRACE => '}',
     :LPAREN => '(',
     :RPAREN => ')',
     :EQUALS => '=',
     :ISEQUAL => '==',
     :GREATEREQUAL => '>=',
     :GREATERTHAN => '>',
     :LESSTHAN => '<',
     :LESSEQUAL => '<=',
     :NOTEQUAL => '!=',
     :NOT => '!',
     :COMMA => ',',
     :DOT => '.',
     :COLON => ':',
     :AT => '@',
     :LLCOLLECT => '<<|',
     :RRCOLLECT => '|>>',
     :LCOLLECT => '<|',
     :RCOLLECT => '|>',
     :SEMIC => ';',
     :QMARK => '?',
     :BACKSLASH => '\\',
     :FARROW => '=>',
     :PARROW => '+>',
     :APPENDS => '+=',
     :PLUS => '+',
     :MINUS => '-',
     :DIV => '/',
     :TIMES => '*',
     :LSHIFT => '<<',
     :RSHIFT => '>>',
     :MATCH => '=~',
     :NOMATCH => '!~',
     :IN_EDGE => '->',
     :OUT_EDGE => '<-',
     :IN_EDGE_SUB => '~>',
     :OUT_EDGE_SUB => '<~',
   }.each do |name, string|
     it "should have a token named #{name.to_s}" do
       Puppet::Parser::Lexer::TOKENS[name].should_not be_nil
     end
 
     it "should match '#{string}' for the token #{name.to_s}" do
       Puppet::Parser::Lexer::TOKENS[name].string.should == string
     end
   end
 
   {
     "case" => :CASE,
     "class" => :CLASS,
     "default" => :DEFAULT,
     "define" => :DEFINE,
     "import" => :IMPORT,
     "if" => :IF,
     "elsif" => :ELSIF,
     "else" => :ELSE,
     "inherits" => :INHERITS,
     "node" => :NODE,
     "and"  => :AND,
     "or"   => :OR,
     "undef"   => :UNDEF,
     "false" => :FALSE,
     "true" => :TRUE,
     "in" => :IN,
   }.each do |string, name|
     it "should have a keyword named #{name.to_s}" do
       Puppet::Parser::Lexer::KEYWORDS[name].should_not be_nil
     end
 
     it "should have the keyword for #{name.to_s} set to #{string}" do
       Puppet::Parser::Lexer::KEYWORDS[name].string.should == string
     end
   end
 
   # These tokens' strings don't matter, just that the tokens exist.
   [:STRING, :DQPRE, :DQMID, :DQPOST, :BOOLEAN, :NAME, :NUMBER, :COMMENT, :MLCOMMENT, :RETURN, :SQUOTE, :DQUOTE, :VARIABLE].each do |name|
     it "should have a token named #{name.to_s}" do
       Puppet::Parser::Lexer::TOKENS[name].should_not be_nil
     end
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:CLASSNAME] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:CLASSNAME] }
 
   it "should match against lower-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "one::two"
   end
 
   it "should match against many lower-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "one::two::three::four::five"
   end
 
   it "should match against lower-case alpha-numeric terms prefixed by double colons" do
     @token.regex.should =~ "::one"
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:CLASSREF] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:CLASSREF] }
 
   it "should match against single upper-case alpha-numeric terms" do
     @token.regex.should =~ "One"
   end
 
   it "should match against upper-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "One::Two"
   end
 
   it "should match against many upper-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "One::Two::Three::Four::Five"
   end
 
   it "should match against upper-case alpha-numeric terms prefixed by double colons" do
     @token.regex.should =~ "::One"
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:NAME] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:NAME] }
 
   it "should match against lower-case alpha-numeric terms" do
     @token.regex.should =~ "one-two"
   end
 
   it "should return itself and the value if the matched term is not a keyword" do
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(nil)
     @token.convert(stub("lexer"), "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"]
   end
 
   it "should return the keyword token and the value if the matched term is a keyword" do
     keyword = stub 'keyword', :name => :testing
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
     @token.convert(stub("lexer"), "myval").should == [keyword, "myval"]
   end
 
   it "should return the BOOLEAN token and 'true' if the matched term is the string 'true'" do
     keyword = stub 'keyword', :name => :TRUE
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
     @token.convert(stub('lexer'), "true").should == [Puppet::Parser::Lexer::TOKENS[:BOOLEAN], true]
   end
 
   it "should return the BOOLEAN token and 'false' if the matched term is the string 'false'" do
     keyword = stub 'keyword', :name => :FALSE
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
     @token.convert(stub('lexer'), "false").should == [Puppet::Parser::Lexer::TOKENS[:BOOLEAN], false]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:NUMBER] do
   before do
     @token = Puppet::Parser::Lexer::TOKENS[:NUMBER]
     @regex = @token.regex
   end
 
   it "should match against numeric terms" do
     @regex.should =~ "2982383139"
   end
 
   it "should match against float terms" do
     @regex.should =~ "29823.235"
   end
 
   it "should match against hexadecimal terms" do
     @regex.should =~ "0xBEEF0023"
   end
 
   it "should match against float with exponent terms" do
     @regex.should =~ "10e23"
   end
 
   it "should match against float terms with negative exponents" do
     @regex.should =~ "10e-23"
   end
 
   it "should match against float terms with fractional parts and exponent" do
     @regex.should =~ "1.234e23"
   end
 
   it "should return the NAME token and the value" do
     @token.convert(stub("lexer"), "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:COMMENT] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:COMMENT] }
 
   it "should match against lines starting with '#'" do
     @token.regex.should =~ "# this is a comment"
   end
 
   it "should be marked to get skipped" do
     @token.skip?.should be_true
   end
 
   it "should be marked to accumulate" do
     @token.accumulate?.should be_true
   end
 
   it "'s block should return the comment without the #" do
     @token.convert(@lexer,"# this is a comment")[1].should == "this is a comment"
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:MLCOMMENT] do
   before do
     @token = Puppet::Parser::Lexer::TOKENS[:MLCOMMENT]
     @lexer = stub 'lexer', :line => 0
   end
 
   it "should match against lines enclosed with '/*' and '*/'" do
     @token.regex.should =~ "/* this is a comment */"
   end
 
   it "should match multiple lines enclosed with '/*' and '*/'" do
     @token.regex.should =~ """/*
       this is a comment
       */"""
   end
 
   it "should increase the lexer current line number by the amount of lines spanned by the comment" do
     @lexer.expects(:line=).with(2)
     @token.convert(@lexer, "1\n2\n3")
   end
 
   it "should not greedily match comments" do
     match = @token.regex.match("/* first */ word /* second */")
     match[1].should == " first "
   end
 
   it "should be marked to accumulate" do
     @token.accumulate?.should be_true
   end
 
   it "'s block should return the comment without the comment marks" do
     @lexer.stubs(:line=).with(0)
 
     @token.convert(@lexer,"/* this is a comment */")[1].should == "this is a comment"
   end
 
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:RETURN] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:RETURN] }
 
   it "should match against carriage returns" do
     @token.regex.should =~ "\n"
   end
 
   it "should be marked to initiate text skipping" do
     @token.skip_text.should be_true
   end
 
   it "should be marked to increment the line" do
     @token.incr_line.should be_true
   end
 end
 
 def tokens_scanned_from(s)
   lexer = Puppet::Parser::Lexer.new
   lexer.string = s
   lexer.fullscan[0..-2]
 end
 
 describe Puppet::Parser::Lexer,"when lexing strings" do
   {
     %q{'single quoted string')}                                     => [[:STRING,'single quoted string']],
     %q{"double quoted string"}                                      => [[:STRING,'double quoted string']],
     %q{'single quoted string with an escaped "\\'"'}                => [[:STRING,'single quoted string with an escaped "\'"']],
     %q{'single quoted string with an escaped "\$"'}                 => [[:STRING,'single quoted string with an escaped "\$"']],
     %q{'single quoted string with an escaped "\."'}                 => [[:STRING,'single quoted string with an escaped "\."']],
     %q{'single quoted string with an escaped "\n"'}                 => [[:STRING,'single quoted string with an escaped "\n"']],
     %q{'single quoted string with an escaped "\\\\"'}               => [[:STRING,'single quoted string with an escaped "\\\\"']],
     %q{"string with an escaped '\\"'"}                              => [[:STRING,"string with an escaped '\"'"]],
     %q{"string with an escaped '\\$'"}                              => [[:STRING,"string with an escaped '$'"]],
     %Q{"string with a line ending with a backslash: \\\nfoo"}       => [[:STRING,"string with a line ending with a backslash: foo"]],
     %q{"string with $v (but no braces)"}                            => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' (but no braces)']],
     %q["string with ${v} in braces"]                                => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' in braces']],
     %q["string with ${qualified::var} in braces"]                   => [[:DQPRE,"string with "],[:VARIABLE,'qualified::var'],[:DQPOST,' in braces']],
     %q{"string with $v and $v (but no braces)"}                     => [[:DQPRE,"string with "],[:VARIABLE,"v"],[:DQMID," and "],[:VARIABLE,"v"],[:DQPOST," (but no braces)"]],
     %q["string with ${v} and ${v} in braces"]                       => [[:DQPRE,"string with "],[:VARIABLE,"v"],[:DQMID," and "],[:VARIABLE,"v"],[:DQPOST," in braces"]],
     %q["string with ${'a nested single quoted string'} inside it."] => [[:DQPRE,"string with "],[:STRING,'a nested single quoted string'],[:DQPOST,' inside it.']],
     %q["string with ${['an array ',$v2]} in it."]                   => [[:DQPRE,"string with "],:LBRACK,[:STRING,"an array "],:COMMA,[:VARIABLE,"v2"],:RBRACK,[:DQPOST," in it."]],
     %q{a simple "scanner" test}                                     => [[:NAME,"a"],[:NAME,"simple"], [:STRING,"scanner"],[:NAME,"test"]],
     %q{a simple 'single quote scanner' test}                        => [[:NAME,"a"],[:NAME,"simple"], [:STRING,"single quote scanner"],[:NAME,"test"]],
     %q{a harder 'a $b \c"'}                                         => [[:NAME,"a"],[:NAME,"harder"], [:STRING,'a $b \c"']],
     %q{a harder "scanner test"}                                     => [[:NAME,"a"],[:NAME,"harder"], [:STRING,"scanner test"]],
     %q{a hardest "scanner \"test\""}                                => [[:NAME,"a"],[:NAME,"hardest"],[:STRING,'scanner "test"']],
     %Q{a hardestest "scanner \\"test\\"\n"}                         => [[:NAME,"a"],[:NAME,"hardestest"],[:STRING,%Q{scanner "test"\n}]],
     %q{function("call")}                                            => [[:NAME,"function"],[:LPAREN,"("],[:STRING,'call'],[:RPAREN,")"]],
     %q["string with ${(3+5)/4} nested math."]                       => [[:DQPRE,"string with "],:LPAREN,[:NAME,"3"],:PLUS,[:NAME,"5"],:RPAREN,:DIV,[:NAME,"4"],[:DQPOST," nested math."]],
     %q["$$$$"]                                                      => [[:STRING,"$$$$"]],
     %q["$variable"]                                                 => [[:DQPRE,""],[:VARIABLE,"variable"],[:DQPOST,""]],
     %q["$var$other"]                                                => [[:DQPRE,""],[:VARIABLE,"var"],[:DQMID,""],[:VARIABLE,"other"],[:DQPOST,""]],
     %q["foo$bar$"]                                                  => [[:DQPRE,"foo"],[:VARIABLE,"bar"],[:DQPOST,"$"]],
     %q["foo$$bar"]                                                  => [[:DQPRE,"foo$"],[:VARIABLE,"bar"],[:DQPOST,""]],
     %q[""]                                                          => [[:STRING,""]],
   }.each { |src,expected_result|
     it "should handle #{src} correctly" do
       tokens_scanned_from(src).should be_like(*expected_result)
     end
   }
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR] }
 
   it "should match against alpha words prefixed with '$'" do
     @token.regex.should =~ '$this_var'
   end
 
   it "should return the VARIABLE token and the variable name stripped of the '$'" do
     @token.convert(stub("lexer"), "$myval").should == [Puppet::Parser::Lexer::TOKENS[:VARIABLE], "myval"]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:REGEX] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:REGEX] }
 
   it "should match against any expression enclosed in //" do
     @token.regex.should =~ '/this is a regex/'
   end
 
   it 'should not match if there is \n in the regex' do
     @token.regex.should_not =~ "/this is \n a regex/"
   end
 
   describe "when scanning" do
     it "should not consider escaped slashes to be the end of a regex" do
       tokens_scanned_from("$x =~ /this \\/ foo/").should be_like(__,__,[:REGEX,%r{this / foo}])
     end
 
     it "should not lex chained division as a regex" do
       tokens_scanned_from("$x = $a/$b/$c").collect { |name, data| name }.should_not be_include( :REGEX )
     end
 
     it "should accept a regular expression after NODE" do
       tokens_scanned_from("node /www.*\.mysite\.org/").should be_like(__,[:REGEX,Regexp.new("www.*\.mysite\.org")])
     end
 
     it "should accept regular expressions in a CASE" do
       s = %q{case $variable {
         "something": {$othervar = 4096 / 2}
         /regex/: {notice("this notably sucks")}
         }
       }
       tokens_scanned_from(s).should be_like(
         :CASE,:VARIABLE,:LBRACE,:STRING,:COLON,:LBRACE,:VARIABLE,:EQUALS,:NAME,:DIV,:NAME,:RBRACE,[:REGEX,/regex/],:COLON,:LBRACE,:NAME,:LPAREN,:STRING,:RPAREN,:RBRACE,:RBRACE
       )
     end
 
   end
 
 
   it "should return the REGEX token and a Regexp" do
     @token.convert(stub("lexer"), "/myregex/").should == [Puppet::Parser::Lexer::TOKENS[:REGEX], Regexp.new(/myregex/)]
   end
 end
 
 describe Puppet::Parser::Lexer, "when lexing comments" do
   before { @lexer = Puppet::Parser::Lexer.new }
 
   it "should accumulate token in munge_token" do
     token = stub 'token', :skip => true, :accumulate? => true, :incr_line => nil, :skip_text => false
 
     token.stubs(:convert).with(@lexer, "# this is a comment").returns([token, " this is a comment"])
     @lexer.munge_token(token, "# this is a comment")
     @lexer.munge_token(token, "# this is a comment")
 
     @lexer.getcomment.should == " this is a comment\n this is a comment\n"
   end
 
   it "should add a new comment stack level on LBRACE" do
     @lexer.string = "{"
 
     @lexer.expects(:commentpush)
 
     @lexer.fullscan
   end
 
   it "should add a new comment stack level on LPAREN" do
     @lexer.string = "("
 
     @lexer.expects(:commentpush)
 
     @lexer.fullscan
   end
 
   it "should pop the current comment on RPAREN" do
     @lexer.string = ")"
 
     @lexer.expects(:commentpop)
 
     @lexer.fullscan
   end
 
   it "should return the current comments on getcomment" do
     @lexer.string = "# comment"
     @lexer.fullscan
 
     @lexer.getcomment.should == "comment\n"
   end
 
   it "should discard the previous comments on blank line" do
     @lexer.string = "# 1\n\n# 2"
     @lexer.fullscan
 
     @lexer.getcomment.should == "2\n"
   end
 
   it "should skip whitespace before lexing the next token after a non-token" do
     tokens_scanned_from("/* 1\n\n */ \ntest").should be_like([:NAME, "test"])
   end
 
   it "should not return comments seen after the current line" do
     @lexer.string = "# 1\n\n# 2"
     @lexer.fullscan
 
     @lexer.getcomment(1).should == ""
   end
 
   it "should return a comment seen before the current line" do
     @lexer.string = "# 1\n# 2"
     @lexer.fullscan
 
     @lexer.getcomment(2).should == "1\n2\n"
   end
 end
 
 # FIXME: We need to rewrite all of these tests, but I just don't want to take the time right now.
 describe "Puppet::Parser::Lexer in the old tests" do
   before { @lexer = Puppet::Parser::Lexer.new }
 
   it "should do simple lexing" do
     {
       %q{\\}                      => [[:BACKSLASH,"\\"]],
       %q{simplest scanner test}   => [[:NAME,"simplest"],[:NAME,"scanner"],[:NAME,"test"]],
       %Q{returned scanner test\n} => [[:NAME,"returned"],[:NAME,"scanner"],[:NAME,"test"]]
     }.each { |source,expected|
       tokens_scanned_from(source).should be_like(*expected)
     }
   end
 
   it "should fail usefully" do
     lambda { tokens_scanned_from('^') }.should raise_error(RuntimeError)
   end
 
   it "should fail if the string is not set" do
     lambda { @lexer.fullscan }.should raise_error(Puppet::LexError)
   end
 
   it "should correctly identify keywords" do
     tokens_scanned_from("case").should be_like([:CASE, "case"])
   end
 
   it "should correctly parse class references" do
     %w{Many Different Words A Word}.each { |t| tokens_scanned_from(t).should be_like([:CLASSREF,t])}
   end
 
   # #774
   it "should correctly parse namespaced class refernces token" do
     %w{Foo ::Foo Foo::Bar ::Foo::Bar}.each { |t| tokens_scanned_from(t).should be_like([:CLASSREF, t]) }
   end
 
   it "should correctly parse names" do
     %w{this is a bunch of names}.each { |t| tokens_scanned_from(t).should be_like([:NAME,t]) }
   end
 
   it "should correctly parse names with numerals" do
     %w{1name name1 11names names11}.each { |t| tokens_scanned_from(t).should be_like([:NAME,t]) }
   end
 
   it "should correctly parse empty strings" do
     lambda { tokens_scanned_from('$var = ""') }.should_not raise_error
   end
 
   it "should correctly parse virtual resources" do
     tokens_scanned_from("@type {").should be_like([:AT, "@"], [:NAME, "type"], [:LBRACE, "{"])
   end
 
   it "should correctly deal with namespaces" do
     @lexer.string = %{class myclass}
     @lexer.fullscan
     @lexer.namespace.should == "myclass"
 
     @lexer.namepop
     @lexer.namespace.should == ""
 
     @lexer.string = "class base { class sub { class more"
     @lexer.fullscan
     @lexer.namespace.should == "base::sub::more"
 
     @lexer.namepop
     @lexer.namespace.should == "base::sub"
   end
 
   it "should not put class instantiation on the namespace" do
     @lexer.string = "class base { class sub { class { mode"
     @lexer.fullscan
     @lexer.namespace.should == "base::sub"
   end
 
   it "should correctly handle fully qualified names" do
     @lexer.string = "class base { class sub::more {"
     @lexer.fullscan
     @lexer.namespace.should == "base::sub::more"
 
     @lexer.namepop
     @lexer.namespace.should == "base"
   end
 
   it "should correctly lex variables" do
     ["$variable", "$::variable", "$qualified::variable", "$further::qualified::variable"].each do |string|
       tokens_scanned_from(string).should be_like([:VARIABLE,string.sub(/^\$/,'')])
     end
   end
 end
 
 require File.dirname(__FILE__) + '/../../../test/lib/puppettest'
 require File.dirname(__FILE__) + '/../../../test/lib/puppettest/support/utils'
 describe "Puppet::Parser::Lexer in the old tests when lexing example files" do
   extend PuppetTest::Support::Utils
   textfiles do |file|
     it "should correctly lex #{file}" do
       lexer = Puppet::Parser::Lexer.new
       lexer.file = file
       lambda { lexer.fullscan }.should_not raise_error
     end
   end
 end
+
+describe "when trying to lex an non-existent file" do
+  include PuppetSpec::Files
+
+  it "should return an empty list of tokens" do
+    lexer = Puppet::Parser::Lexer.new
+    lexer.file = nofile = tmpfile('lexer')
+    File.exists?(nofile).should == false
+
+    lexer.fullscan.should == [[false,false]]
+  end
+end
diff --git a/spec/unit/resource/type_collection_spec.rb b/spec/unit/resource/type_collection_spec.rb
index ff4c22234..cf7039a51 100644
--- a/spec/unit/resource/type_collection_spec.rb
+++ b/spec/unit/resource/type_collection_spec.rb
@@ -1,459 +1,456 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/resource/type_collection'
 require 'puppet/resource/type'
 
 describe Puppet::Resource::TypeCollection do
+  include PuppetSpec::Files
   before do
     @instance = Puppet::Resource::Type.new(:hostclass, "foo")
     @code = Puppet::Resource::TypeCollection.new("env")
   end
 
   it "should require an environment at initialization" do
     env = Puppet::Node::Environment.new("testing")
     Puppet::Resource::TypeCollection.new(env).environment.should equal(env)
   end
 
   it "should convert the environment into an environment instance if a string is provided" do
     env = Puppet::Node::Environment.new("testing")
     Puppet::Resource::TypeCollection.new("testing").environment.should equal(env)
   end
 
   it "should create a 'loader' at initialization" do
     Puppet::Resource::TypeCollection.new("testing").loader.should be_instance_of(Puppet::Parser::TypeLoader)
   end
 
   it "should be able to add a resource type" do
     Puppet::Resource::TypeCollection.new("env").should respond_to(:add)
   end
 
   it "should consider '<<' to be an alias to 'add' but should return self" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.expects(:add).with "foo"
     loader.expects(:add).with "bar"
     loader << "foo" << "bar"
   end
 
   it "should set itself as the code collection for added resource types" do
     loader = Puppet::Resource::TypeCollection.new("env")
 
     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 store hostclasses as hostclasses" do
     klass = Puppet::Resource::Type.new(:hostclass, "foo")
 
     @code.add(klass)
     @code.hostclass("foo").should equal(klass)
   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 merge new classes with existing classes of the same name" do
     loader = Puppet::Resource::TypeCollection.new("env")
     first = Puppet::Resource::Type.new(:hostclass, "foo")
     second = Puppet::Resource::Type.new(:hostclass, "foo")
     loader.add first
     first.expects(:merge).with(second)
     loader.add(second)
   end
 
   it "should remove all nodes, classes, and definitions when cleared" do
     loader = Puppet::Resource::TypeCollection.new("env")
     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 support looking up with multiple namespaces" do
       @code.add @type
       @code.find_hostclass(%w{boo baz ns}, "klass").should equal(@type)
     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(%w{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(:load_until).with(["ns"], "klass")
         @code.find_or_load(["ns"], "klass", :hostclass)
       end
 
       it "should downcase the name and downcase and array-fy the namespaces before passing to the loader" do
         @code.loader.expects(:load_until).with(["ns"], "klass")
         @code.find_or_load("Ns", "Klass", :hostclass)
       end
 
       it "should attempt to find the type when the loader yields" do
         @code.loader.expects(:load_until).yields
         @code.expects(:find).with(["ns"], "klass", :hostclass).times(2).returns(false).then.returns(true)
         @code.find_or_load("ns", "klass", :hostclass)
       end
 
       it "should return the result of 'load_until'" do
         @code.loader.expects(:load_until).returns "foo"
         @code.find_or_load("Ns", "Klass", :hostclass).should == "foo"
       end
 
       it "should return nil if the name isn't found" do
         @code.stubs(:load_until).returns(nil)
         @code.find_or_load("Ns", "Klass", :hostclass).should be_nil
       end
     end
   end
 
   %w{hostclass node definition}.each do |data|
     before do
       @instance = Puppet::Resource::Type.new(data, "foo")
     end
 
     it "should have a method for adding a #{data}" do
       Puppet::Resource::TypeCollection.new("env").should respond_to("add_#{data}")
     end
 
     it "should use the name of the instance to add it" do
       loader = Puppet::Resource::TypeCollection.new("env")
       loader.send("add_#{data}", @instance)
       loader.send(data, @instance.name).should equal(@instance)
     end
 
     unless data == "hostclass"
       it "should fail to add a #{data} when one already exists" do
         loader = Puppet::Resource::TypeCollection.new("env")
         loader.add @instance
         lambda { loader.add(@instance) }.should raise_error(Puppet::ParseError)
       end
     end
 
     it "should return the added #{data}" do
       loader = Puppet::Resource::TypeCollection.new("env")
 
       loader.add(@instance).should equal(@instance)
     end
 
     it "should be able to retrieve #{data} by name" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(data, "bar")
       loader.add instance
       loader.send(data, "bar").should equal(instance)
     end
 
     it "should retrieve #{data} insensitive to case" do
       loader = Puppet::Resource::TypeCollection.new("env")
       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("env").send(data, "foo").should be_nil
     end
 
     it "should be able to retrieve all #{data}s" do
       plurals = { "hostclass" => "hostclasses", "node" => "nodes", "definition" => "definitions" }
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(data, "foo")
       loader.add instance
       loader.send(plurals[data]).should == { "foo" => instance }
     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("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find("namespace", "::foo::bar", :hostclass).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("env")
       loader.find("namespace", "::foo::bar", :hostclass).should be_nil
     end
 
     it "should be able to find classes in the base namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo")
       loader.add instance
       loader.find("", "foo", :hostclass).should equal(instance)
     end
 
     it "should return the partially qualified object if it exists in a provided namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find("foo", "bar::baz", :hostclass).should equal(instance)
     end
 
     it "should be able to find partially qualified objects in any of the provided namespaces" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find(["nons", "foo", "otherns"], "bar::baz", :hostclass).should equal(instance)
     end
 
     it "should return the unqualified object if it exists in a provided namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find("foo", "bar", :hostclass).should equal(instance)
     end
 
     it "should return the unqualified object if it exists in the parent namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
       loader.find("foo::bar::baz", "bar", :hostclass).should equal(instance)
     end
 
     it "should should return the partially qualified object if it exists in the parent namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find("foo::bar", "bar::baz", :hostclass).should equal(instance)
     end
 
     it "should return the qualified object if it exists in the root namespace" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find("foo::bar", "foo::bar::baz", :hostclass).should equal(instance)
     end
 
     it "should return nil if the object cannot be found" do
       loader = Puppet::Resource::TypeCollection.new("env")
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
       loader.find("foo::bar", "eh", :hostclass).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("env")
         [ "foo::bar", "bar" ].each do |name|
           @loader.add Puppet::Resource::Type.new(:hostclass, name)
         end
       end
 
       it "should favor the local class, if the name is unqualified" do
         @loader.find("foo", "bar",   :hostclass).name.should == 'foo::bar'
       end
 
       it "should only look in the topclass, if the name is qualified" do
         @loader.find("foo", "::bar", :hostclass).name.should == 'bar'
       end
 
     end
-    
+
     it "should not look in the local scope for classes when the name is qualified" do
         @loader = Puppet::Resource::TypeCollection.new("env")
         @loader.add Puppet::Resource::Type.new(:hostclass, "foo::bar")
 
         @loader.find("foo", "::bar", :hostclass).should == nil
     end
 
   end
 
   it "should use the generic 'find' method with an empty namespace to find nodes" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.expects(:find).with("", "bar", :node)
     loader.find_node(stub("ignored"), "bar")
   end
 
   it "should use the 'find_or_load' method to find hostclasses" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.expects(:find_or_load).with("foo", "bar", :hostclass)
     loader.find_hostclass("foo", "bar")
   end
 
   it "should use the 'find_or_load' method to find definitions" do
     loader = Puppet::Resource::TypeCollection.new("env")
     loader.expects(:find_or_load).with("foo", "bar", :definition)
     loader.find_definition("foo", "bar")
   end
 
   it "should indicate whether any nodes are defined" do
     loader = Puppet::Resource::TypeCollection.new("env")
     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("env").should_not be_nodes
   end
 
   describe "when finding nodes" do
     before :each do
       @loader = Puppet::Resource::TypeCollection.new("env")
     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 managing files" do
     before do
       @loader = Puppet::Resource::TypeCollection.new("env")
       Puppet::Util::LoadedFile.stubs(:new).returns stub("watched_file")
     end
 
     it "should have a method for specifying a file should be watched" do
       @loader.should respond_to(:watch_file)
     end
 
     it "should have a method for determining if a file is being watched" do
       @loader.watch_file("/foo/bar")
       @loader.should be_watching_file("/foo/bar")
     end
 
     it "should use LoadedFile to watch files" do
       Puppet::Util::LoadedFile.expects(:new).with("/foo/bar").returns stub("watched_file")
       @loader.watch_file("/foo/bar")
     end
 
     it "should be considered stale if any files have changed" do
       file1 = stub 'file1', :changed? => false
       file2 = stub 'file2', :changed? => true
       Puppet::Util::LoadedFile.expects(:new).times(2).returns(file1).then.returns(file2)
       @loader.watch_file("/foo/bar")
       @loader.watch_file("/other/bar")
 
       @loader.should be_stale
     end
 
     it "should not be considered stable if no files have changed" do
       file1 = stub 'file1', :changed? => false
       file2 = stub 'file2', :changed? => false
       Puppet::Util::LoadedFile.expects(:new).times(2).returns(file1).then.returns(file2)
       @loader.watch_file("/foo/bar")
       @loader.watch_file("/other/bar")
 
       @loader.should_not be_stale
     end
   end
 
   describe "when performing initial import" do
     before do
-      @parser = stub 'parser', :file= => nil, :string => nil, :parse => nil
+      @parser = stub 'parser'
       Puppet::Parser::Parser.stubs(:new).returns @parser
       @code = Puppet::Resource::TypeCollection.new("env")
     end
 
-    it "should create a new parser instance" do
-      Puppet::Parser::Parser.expects(:new).returns @parser
-      @code.perform_initial_import
-    end
-
     it "should set the parser's string to the 'code' setting and parse if code is available" do
       Puppet.settings[:code] = "my code"
       @parser.expects(:string=).with "my code"
       @parser.expects(:parse)
       @code.perform_initial_import
     end
 
     it "should set the parser's file to the 'manifest' setting and parse if no code is available and the manifest is available" do
-      File.stubs(:expand_path).with("/my/file").returns "/my/file"
-      File.expects(:exist?).with("/my/file").returns true
-      Puppet.settings[:manifest] = "/my/file"
-      @parser.expects(:file=).with "/my/file"
+      filename = tmpfile('myfile')
+      File.open(filename, 'w'){|f| }
+      Puppet.settings[:manifest] = filename
+      @parser.expects(:file=).with filename
       @parser.expects(:parse)
       @code.perform_initial_import
     end
 
-    it "should not attempt to load a manifest if none is present" do
-      File.stubs(:expand_path).with("/my/file").returns "/my/file"
-      File.expects(:exist?).with("/my/file").returns false
-      Puppet.settings[:manifest] = "/my/file"
-      @parser.expects(:file=).never
-      @parser.expects(:parse).never
+    it "should pass the manifest file to the parser even if it does not exist on disk" do
+      filename = tmpfile('myfile')
+      Puppet.settings[:code] = ""
+      Puppet.settings[:manifest] = filename
+      @parser.expects(:file=).with(filename).once
+      @parser.expects(:parse).once
       @code.perform_initial_import
     end
 
     it "should fail helpfully if there is an error importing" do
       File.stubs(:exist?).returns true
       @parser.expects(:parse).raises ArgumentError
+      @parser.stubs(:file=)
       lambda { @code.perform_initial_import }.should raise_error(Puppet::Error)
     end
   end
 
   describe "when determining the configuration version" do
     before do
       @code = Puppet::Resource::TypeCollection.new("env")
     end
 
     it "should default to the current time" do
       time = Time.now
 
       Time.stubs(:now).returns time
       @code.version.should == time.to_i
     end
 
     it "should use the output of the environment's config_version setting if one is provided" do
       @code.environment.stubs(:[]).with(:config_version).returns("/my/foo")
 
       Puppet::Util.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
       @code.environment.stubs(:[]).with(:config_version).returns("test")
       Puppet::Util.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
 
       lambda { @code.version }.should raise_error(Puppet::ParseError)
     end
 
   end
 
 end
diff --git a/spec/unit/util/loadedfile_spec.rb b/spec/unit/util/loadedfile_spec.rb
index 3bc26a421..c6fd625fc 100755
--- a/spec/unit/util/loadedfile_spec.rb
+++ b/spec/unit/util/loadedfile_spec.rb
@@ -1,65 +1,72 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'tempfile'
 require 'puppet/util/loadedfile'
 
 describe Puppet::Util::LoadedFile do
+  include PuppetSpec::Files
   before(:each) do
     @f = Tempfile.new('loadedfile_test')
     @f.puts "yayness"
     @f.flush
 
     @loaded = Puppet::Util::LoadedFile.new(@f.path)
 
     fake_ctime = Time.now - (2 * Puppet[:filetimeout])
     @stat = stub('stat', :ctime => fake_ctime)
     @fake_now = Time.now + (2 * Puppet[:filetimeout])
   end
 
+  it "should accept files that don't exist" do
+    nofile = tmpfile('testfile')
+    File.exists?(nofile).should == false
+    lambda{ Puppet::Util::LoadedFile.new(nofile) }.should_not raise_error
+  end
+
   it "should recognize when the file has not changed" do
     # Use fake "now" so that we can be sure changed? actually checks, without sleeping
     # for Puppet[:filetimeout] seconds.
     Time.stubs(:now).returns(@fake_now)
     @loaded.changed?.should == false
   end
 
   it "should recognize when the file has changed" do
     # Fake File.stat so we don't have to depend on the filesystem granularity. Doing a flush()
     # just didn't do the job.
     File.stubs(:stat).returns(@stat)
     # Use fake "now" so that we can be sure changed? actually checks, without sleeping
     # for Puppet[:filetimeout] seconds.
     Time.stubs(:now).returns(@fake_now)
     @loaded.changed?.should be_an_instance_of(Time)
   end
 
   it "should not catch a change until the timeout has elapsed" do
     # Fake File.stat so we don't have to depend on the filesystem granularity. Doing a flush()
     # just didn't do the job.
     File.stubs(:stat).returns(@stat)
     @loaded.changed?.should be(false)
     # Use fake "now" so that we can be sure changed? actually checks, without sleeping
     # for Puppet[:filetimeout] seconds.
     Time.stubs(:now).returns(@fake_now)
     @loaded.changed?.should_not be(false)
   end
 
   it "should consider a file changed when that file is missing" do
     @f.close!
     # Use fake "now" so that we can be sure changed? actually checks, without sleeping
     # for Puppet[:filetimeout] seconds.
     Time.stubs(:now).returns(@fake_now)
     @loaded.changed?.should_not be(false)
   end
 
   it "should disable checking if Puppet[:filetimeout] is negative" do
     Puppet[:filetimeout] = -1
     @loaded.changed?.should_not be(false)
   end
 
   after(:each) do
     @f.close
   end
 end
diff --git a/spec/unit/util/rdoc/parser_spec.rb b/spec/unit/util/rdoc/parser_spec.rb
index b4453ae86..6ae28b40a 100755
--- a/spec/unit/util/rdoc/parser_spec.rb
+++ b/spec/unit/util/rdoc/parser_spec.rb
@@ -1,556 +1,557 @@
 #!/usr/bin/env ruby
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
 require 'puppet/resource/type_collection'
 require 'puppet/util/rdoc/parser'
 require 'puppet/util/rdoc/code_objects'
 require 'rdoc/options'
 require 'rdoc/rdoc'
 
 describe RDoc::Parser do
   before :each do
     File.stubs(:stat).with("init.pp")
     @top_level = stub_everything 'toplevel', :file_relative_name => "init.pp"
     @parser = RDoc::Parser.new(@top_level, "module/manifests/init.pp", nil, Options.instance, RDoc::Stats.new)
   end
 
   describe "when scanning files" do
     it "should parse puppet files with the puppet parser" do
       @parser.stubs(:scan_top_level)
       parser = stub 'parser'
       Puppet::Parser::Parser.stubs(:new).returns(parser)
-      parser.expects(:parse)
+      parser.expects(:parse).at_least_once
       parser.expects(:file=).with("module/manifests/init.pp")
+      parser.expects(:file=).with("/dev/null/manifests/site.pp")
 
       @parser.scan
     end
 
     it "should scan the ast for Puppet files" do
       parser = stub_everything 'parser'
       Puppet::Parser::Parser.stubs(:new).returns(parser)
 
       @parser.expects(:scan_top_level)
 
       @parser.scan
     end
 
     it "should return a PuppetTopLevel to RDoc" do
       parser = stub_everything 'parser'
       Puppet::Parser::Parser.stubs(:new).returns(parser)
 
       @parser.expects(:scan_top_level)
 
       @parser.scan.should be_a(RDoc::PuppetTopLevel)
     end
 
     it "should scan the top level even if the file has already parsed" do
       known_type = stub 'known_types'
       env = stub 'env'
       Puppet::Node::Environment.stubs(:new).returns(env)
       env.stubs(:known_resource_types).returns(known_type)
       known_type.expects(:watching_file?).with("module/manifests/init.pp").returns(true)
 
       @parser.expects(:scan_top_level)
 
       @parser.scan
     end
   end
 
   describe "when scanning top level entities" do
     before :each do
       @resource_type_collection = stub_everything 'resource_type_collection'
       @parser.ast = @resource_type_collection
       @parser.stubs(:split_module).returns("module")
 
       @topcontainer = stub_everything 'topcontainer'
       @container = stub_everything 'container'
       @module = stub_everything 'module'
       @container.stubs(:add_module).returns(@module)
       @parser.stubs(:get_class_or_module).returns([@container, "module"])
     end
 
     it "should read any present README as module documentation" do
       FileTest.stubs(:readable?).returns(true)
       File.stubs(:open).returns("readme")
       @parser.stubs(:parse_elements)
 
       @module.expects(:comment=).with("readme")
 
       @parser.scan_top_level(@topcontainer)
     end
 
     it "should tell the container its module name" do
       @parser.stubs(:parse_elements)
 
       @topcontainer.expects(:module_name=).with("module")
 
       @parser.scan_top_level(@topcontainer)
     end
 
     it "should not document our toplevel if it isn't a valid module" do
       @parser.stubs(:split_module).returns(nil)
 
       @topcontainer.expects(:document_self=).with(false)
       @parser.expects(:parse_elements).never
 
       @parser.scan_top_level(@topcontainer)
     end
 
     it "should set the module as global if we parse the global manifests (ie __site__ module)" do
       @parser.stubs(:split_module).returns(RDoc::Parser::SITE)
       @parser.stubs(:parse_elements)
 
       @topcontainer.expects(:global=).with(true)
 
       @parser.scan_top_level(@topcontainer)
     end
 
     it "should attach this module container to the toplevel container" do
       @parser.stubs(:parse_elements)
 
       @container.expects(:add_module).with(RDoc::PuppetModule, "module").returns(@module)
 
       @parser.scan_top_level(@topcontainer)
     end
 
     it "should defer ast parsing to parse_elements for this module" do
       @parser.expects(:parse_elements).with(@module)
 
       @parser.scan_top_level(@topcontainer)
     end
 
     it "should defer plugins parsing to parse_plugins for this module" do
       @parser.input_file_name = "module/lib/puppet/parser/function.rb"
 
       @parser.expects(:parse_plugins).with(@module)
 
       @parser.scan_top_level(@topcontainer)
     end
   end
 
   describe "when finding modules from filepath" do
     before :each do
       Puppet::Module.stubs(:modulepath).returns("/path/to/modules")
     end
 
     it "should return the module name for modulized puppet manifests" do
       File.stubs(:expand_path).returns("/path/to/module/manifests/init.pp")
       File.stubs(:identical?).with("/path/to", "/path/to/modules").returns(true)
       @parser.split_module("/path/to/modules/mymodule/manifests/init.pp").should == "module"
     end
 
     it "should return <site> for manifests not under module path" do
       File.stubs(:expand_path).returns("/path/to/manifests/init.pp")
       File.stubs(:identical?).returns(false)
       @parser.split_module("/path/to/manifests/init.pp").should == RDoc::Parser::SITE
     end
   end
 
   describe "when parsing AST elements" do
     before :each do
       @klass = stub_everything 'klass', :file => "module/manifests/init.pp", :name => "myclass", :type => :hostclass
       @definition = stub_everything 'definition', :file => "module/manifests/init.pp", :type => :definition, :name => "mydef"
       @node = stub_everything 'node', :file => "module/manifests/init.pp", :type => :node, :name => "mynode"
 
       @resource_type_collection = Puppet::Resource::TypeCollection.new("env")
       @parser.ast = @resource_type_collection
 
       @container = stub_everything 'container'
     end
 
     it "should document classes in the parsed file" do
       @resource_type_collection.add_hostclass(@klass)
 
       @parser.expects(:document_class).with("myclass", @klass, @container)
 
       @parser.parse_elements(@container)
     end
 
     it "should not document class parsed in an other file" do
       @klass.stubs(:file).returns("/not/same/path/file.pp")
       @resource_type_collection.add_hostclass(@klass)
 
       @parser.expects(:document_class).with("myclass", @klass, @container).never
 
       @parser.parse_elements(@container)
     end
 
     it "should document vardefs for the main class" do
       @klass.stubs(:name).returns :main
       @resource_type_collection.add_hostclass(@klass)
 
       code = stub 'code', :is_a? => false
       @klass.stubs(:name).returns("")
       @klass.stubs(:code).returns(code)
 
       @parser.expects(:scan_for_vardef).with(@container, code)
 
       @parser.parse_elements(@container)
     end
 
     it "should document definitions in the parsed file" do
       @resource_type_collection.add_definition(@definition)
 
       @parser.expects(:document_define).with("mydef", @definition, @container)
 
       @parser.parse_elements(@container)
     end
 
     it "should not document definitions parsed in an other file" do
       @definition.stubs(:file).returns("/not/same/path/file.pp")
       @resource_type_collection.add_definition(@definition)
 
       @parser.expects(:document_define).with("mydef", @definition, @container).never
 
       @parser.parse_elements(@container)
     end
 
     it "should document nodes in the parsed file" do
       @resource_type_collection.add_node(@node)
 
       @parser.expects(:document_node).with("mynode", @node, @container)
 
       @parser.parse_elements(@container)
     end
 
     it "should not document node parsed in an other file" do
       @node.stubs(:file).returns("/not/same/path/file.pp")
       @resource_type_collection.add_node(@node)
 
       @parser.expects(:document_node).with("mynode", @node, @container).never
 
       @parser.parse_elements(@container)
     end
   end
 
   describe "when documenting definition" do
     before(:each) do
       @define = stub_everything 'define', :arguments => [], :doc => "mydoc", :file => "file", :line => 42
       @class = stub_everything 'class'
       @parser.stubs(:get_class_or_module).returns([@class, "mydef"])
     end
 
     it "should register a RDoc method to the current container" do
       @class.expects(:add_method).with { |m| m.name == "mydef"}
       @parser.document_define("mydef", @define, @class)
     end
 
     it "should attach the documentation to this method" do
       @class.expects(:add_method).with { |m| m.comment = "mydoc" }
 
       @parser.document_define("mydef", @define, @class)
     end
 
     it "should produce a better error message on unhandled exception" do
       @class.expects(:add_method).raises(ArgumentError)
 
       lambda { @parser.document_define("mydef", @define, @class) }.should raise_error(Puppet::ParseError, /in file at line 42/)
     end
 
     it "should convert all definition parameter to string" do
       arg = stub 'arg'
       val = stub 'val'
 
       @define.stubs(:arguments).returns({arg => val})
 
       arg.expects(:to_s).returns("arg")
       val.expects(:to_s).returns("val")
 
       @parser.document_define("mydef", @define, @class)
     end
   end
 
   describe "when documenting nodes" do
     before :each do
       @code = stub_everything 'code'
       @node = stub_everything 'node', :doc => "mydoc", :parent => "parent", :code => @code, :file => "file", :line => 42
       @rdoc_node = stub_everything 'rdocnode'
 
       @class = stub_everything 'class'
       @class.stubs(:add_node).returns(@rdoc_node)
     end
 
     it "should add a node to the current container" do
       @class.expects(:add_node).with("mynode", "parent").returns(@rdoc_node)
       @parser.document_node("mynode", @node, @class)
     end
 
     it "should associate the node documentation to the rdoc node" do
       @rdoc_node.expects(:comment=).with("mydoc")
       @parser.document_node("mynode", @node, @class)
     end
 
     it "should scan for include and require" do
       @parser.expects(:scan_for_include_or_require).with(@rdoc_node, @code)
       @parser.document_node("mynode", @node, @class)
     end
 
     it "should scan for variable definition" do
       @parser.expects(:scan_for_vardef).with(@rdoc_node, @code)
       @parser.document_node("mynode", @node, @class)
     end
 
     it "should scan for resources if needed" do
       Puppet.settings.stubs(:[]).with(:document_all).returns(true)
       @parser.expects(:scan_for_resource).with(@rdoc_node, @code)
       @parser.document_node("mynode", @node, @class)
     end
 
     it "should produce a better error message on unhandled exception" do
       @class.stubs(:add_node).raises(ArgumentError)
 
       lambda { @parser.document_node("mynode", @node, @class) }.should raise_error(Puppet::ParseError, /in file at line 42/)
     end
   end
 
   describe "when documenting classes" do
     before :each do
       @code = stub_everything 'code'
       @class = stub_everything 'class', :doc => "mydoc", :parent => "parent", :code => @code, :file => "file", :line => 42
       @rdoc_class = stub_everything 'rdoc-class'
 
       @module = stub_everything 'class'
       @module.stubs(:add_class).returns(@rdoc_class)
       @parser.stubs(:get_class_or_module).returns([@module, "myclass"])
     end
 
     it "should add a class to the current container" do
       @module.expects(:add_class).with(RDoc::PuppetClass, "myclass", "parent").returns(@rdoc_class)
       @parser.document_class("mynode", @class, @module)
     end
 
     it "should set the superclass" do
       @rdoc_class.expects(:superclass=).with("parent")
       @parser.document_class("mynode", @class, @module)
     end
 
     it "should associate the node documentation to the rdoc class" do
       @rdoc_class.expects(:comment=).with("mydoc")
       @parser.document_class("mynode", @class, @module)
     end
 
     it "should scan for include and require" do
       @parser.expects(:scan_for_include_or_require).with(@rdoc_class, @code)
       @parser.document_class("mynode", @class, @module)
     end
 
     it "should scan for resources if needed" do
       Puppet.settings.stubs(:[]).with(:document_all).returns(true)
       @parser.expects(:scan_for_resource).with(@rdoc_class, @code)
       @parser.document_class("mynode", @class, @module)
     end
 
     it "should produce a better error message on unhandled exception" do
       @module.stubs(:add_class).raises(ArgumentError)
 
       lambda { @parser.document_class("mynode", @class, @module) }.should raise_error(Puppet::ParseError, /in file at line 42/)
     end
   end
 
   describe "when scanning for includes and requires" do
 
     def create_stmt(name)
       stmt_value = stub "#{name}_value", :to_s => "myclass"
 
       Puppet::Parser::AST::Function.new(
         :name      => name,
         :arguments => [stmt_value],
         :doc       => 'mydoc'
       )
     end
 
     before(:each) do
       @class = stub_everything 'class'
       @code = stub_everything 'code'
       @code.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(true)
     end
 
     it "should also scan mono-instruction code" do
       @class.expects(:add_include).with { |i| i.is_a?(RDoc::Include) and i.name == "myclass" and i.comment == "mydoc" }
 
       @parser.scan_for_include_or_require(@class, create_stmt("include"))
     end
 
     it "should register recursively includes to the current container" do
       @code.stubs(:children).returns([ create_stmt("include") ])
 
       @class.expects(:add_include)#.with { |i| i.is_a?(RDoc::Include) and i.name == "myclass" and i.comment == "mydoc" }
       @parser.scan_for_include_or_require(@class, [@code])
     end
 
     it "should register requires to the current container" do
       @code.stubs(:children).returns([ create_stmt("require") ])
 
       @class.expects(:add_require).with { |i| i.is_a?(RDoc::Include) and i.name == "myclass" and i.comment == "mydoc" }
       @parser.scan_for_include_or_require(@class, [@code])
     end
   end
 
   describe "when scanning for realized virtual resources" do
 
     def create_stmt
       stmt_value = stub "resource_ref", :to_s => "File[\"/tmp/a\"]"
       Puppet::Parser::AST::Function.new(
         :name      => 'realize',
         :arguments => [stmt_value],
         :doc       => 'mydoc'
       )
     end
 
     before(:each) do
       @class = stub_everything 'class'
       @code = stub_everything 'code'
       @code.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(true)
     end
 
     it "should also scan mono-instruction code" do
       @class.expects(:add_realize).with { |i| i.is_a?(RDoc::Include) and i.name == "File[\"/tmp/a\"]" and i.comment == "mydoc" }
 
       @parser.scan_for_realize(@class,create_stmt)
     end
 
     it "should register recursively includes to the current container" do
       @code.stubs(:children).returns([ create_stmt ])
 
       @class.expects(:add_realize).with { |i| i.is_a?(RDoc::Include) and i.name == "File[\"/tmp/a\"]" and i.comment == "mydoc" }
       @parser.scan_for_realize(@class, [@code])
     end
   end
 
   describe "when scanning for variable definition" do
     before :each do
       @class = stub_everything 'class'
 
       @stmt = stub_everything 'stmt', :name => "myvar", :value => "myvalue", :doc => "mydoc"
       @stmt.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(false)
       @stmt.stubs(:is_a?).with(Puppet::Parser::AST::VarDef).returns(true)
 
       @code = stub_everything 'code'
       @code.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(true)
     end
 
     it "should recursively register variables to the current container" do
       @code.stubs(:children).returns([ @stmt ])
 
       @class.expects(:add_constant).with { |i| i.is_a?(RDoc::Constant) and i.name == "myvar" and i.comment == "mydoc" }
       @parser.scan_for_vardef(@class, [ @code ])
     end
 
     it "should also scan mono-instruction code" do
       @class.expects(:add_constant).with { |i| i.is_a?(RDoc::Constant) and i.name == "myvar" and i.comment == "mydoc" }
 
       @parser.scan_for_vardef(@class, @stmt)
     end
   end
 
   describe "when scanning for resources" do
     before :each do
       @class = stub_everything 'class'
       @stmt = Puppet::Parser::AST::Resource.new(
         :type       => "File",
         :title      => "myfile",
         :doc        => 'mydoc',
         :parameters => Puppet::Parser::AST::ASTArray.new(:children => [])
       )
 
       @code = stub_everything 'code'
       @code.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(true)
     end
 
     it "should register a PuppetResource to the current container" do
       @code.stubs(:children).returns([ @stmt ])
 
       @class.expects(:add_resource).with { |i| i.is_a?(RDoc::PuppetResource) and i.title == "myfile" and i.comment == "mydoc" }
       @parser.scan_for_resource(@class, [ @code ])
     end
 
     it "should also scan mono-instruction code" do
       @class.expects(:add_resource).with { |i| i.is_a?(RDoc::PuppetResource) and i.title == "myfile" and i.comment == "mydoc" }
 
       @parser.scan_for_resource(@class, @stmt)
     end
   end
 
   describe "when parsing plugins" do
     before :each do
       @container = stub 'container'
     end
 
     it "should delegate parsing custom facts to parse_facts" do
       @parser = RDoc::Parser.new(@top_level, "module/manifests/lib/puppet/facter/test.rb", nil, Options.instance, RDoc::Stats.new)
 
       @parser.expects(:parse_fact).with(@container)
       @parser.parse_plugins(@container)
     end
 
     it "should delegate parsing plugins to parse_plugins" do
       @parser = RDoc::Parser.new(@top_level, "module/manifests/lib/puppet/functions/test.rb", nil, Options.instance, RDoc::Stats.new)
 
       @parser.expects(:parse_puppet_plugin).with(@container)
       @parser.parse_plugins(@container)
     end
   end
 
   describe "when parsing plugins" do
     before :each do
       @container = stub_everything 'container'
     end
 
     it "should add custom functions to the container" do
       File.stubs(:open).yields("# documentation
       module Puppet::Parser::Functions
       	newfunction(:myfunc, :type => :rvalue) do |args|
       		File.dirname(args[0])
       	end
       end".split("\n"))
 
       @container.expects(:add_plugin).with do |plugin|
         plugin.comment == "documentation\n" #and
         plugin.name == "myfunc"
       end
 
       @parser.parse_puppet_plugin(@container)
     end
 
     it "should add custom types to the container" do
       File.stubs(:open).yields("# documentation
       Puppet::Type.newtype(:mytype) do
       end".split("\n"))
 
       @container.expects(:add_plugin).with do |plugin|
         plugin.comment == "documentation\n" #and
         plugin.name == "mytype"
       end
 
       @parser.parse_puppet_plugin(@container)
     end
   end
 
   describe "when parsing facts" do
     before :each do
       @container = stub_everything 'container'
       File.stubs(:open).yields(["# documentation", "Facter.add('myfact') do", "confine :kernel => :linux", "end"])
     end
 
     it "should add facts to the container" do
       @container.expects(:add_fact).with do |fact|
         fact.comment == "documentation\n" and
         fact.name == "myfact"
       end
 
       @parser.parse_fact(@container)
     end
 
     it "should add confine to the parsed facts" do
       ourfact = nil
       @container.expects(:add_fact).with do |fact|
         ourfact = fact
         true
       end
 
       @parser.parse_fact(@container)
       ourfact.confine.should == { :type => "kernel", :value => ":linux" }
     end
   end
 end