diff --git a/lib/puppet/application.rb b/lib/puppet/application.rb
index 6f8026c90..901d8053f 100644
--- a/lib/puppet/application.rb
+++ b/lib/puppet/application.rb
@@ -1,506 +1,510 @@
 require 'optparse'
 require 'puppet/util/command_line'
 require 'puppet/util/plugins'
 require 'puppet/util/constant_inflector'
 require 'puppet/error'
 
 module Puppet
 
 # This class handles all the aspects of a Puppet application/executable
 # * setting up options
 # * setting up logs
 # * choosing what to run
 # * representing execution status
 #
 # === Usage
 # An application is a subclass of Puppet::Application.
 #
 # For legacy compatibility,
 #      Puppet::Application[:example].run
 # is equivalent to
 #      Puppet::Application::Example.new.run
 #
 #
 # class Puppet::Application::Example < Puppet::Application
 #
 #     def preinit
 #         # perform some pre initialization
 #         @all = false
 #     end
 #
 #     # run_command is called to actually run the specified command
 #     def run_command
 #         send Puppet::Util::CommandLine.new.args.shift
 #     end
 #
 #     # option uses metaprogramming to create a method
 #     # and also tells the option parser how to invoke that method
 #     option("--arg ARGUMENT") do |v|
 #         @args << v
 #     end
 #
 #     option("--debug", "-d") do |v|
 #         @debug = v
 #     end
 #
 #     option("--all", "-a:) do |v|
 #         @all = v
 #     end
 #
 #     def handle_unknown(opt,arg)
 #         # last chance to manage an option
 #         ...
 #         # let's say to the framework we finally handle this option
 #         true
 #     end
 #
 #     def read
 #         # read action
 #     end
 #
 #     def write
 #         # writeaction
 #     end
 #
 # end
 #
 # === Preinit
 # The preinit block is the first code to be called in your application, before option parsing,
 # setup or command execution.
 #
 # === Options
 # Puppet::Application uses +OptionParser+ to manage the application options.
 # Options are defined with the +option+ method to which are passed various
 # arguments, including the long option, the short option, a description...
 # Refer to +OptionParser+ documentation for the exact format.
 # * If the option method is given a block, this one will be called whenever
 # the option is encountered in the command-line argument.
 # * If the option method has no block, a default functionnality will be used, that
 # stores the argument (or true/false if the option doesn't require an argument) in
 # the global (to the application) options array.
 # * If a given option was not defined by a the +option+ method, but it exists as a Puppet settings:
 #  * if +unknown+ was used with a block, it will be called with the option name and argument
 #  * if +unknown+ wasn't used, then the option/argument is handed to Puppet.settings.handlearg for
 #    a default behavior
 #
 # --help is managed directly by the Puppet::Application class, but can be overriden.
 #
 # === Setup
 # Applications can use the setup block to perform any initialization.
 # The default +setup+ behaviour is to: read Puppet configuration and manage log level and destination
 #
 # === What and how to run
 # If the +dispatch+ block is defined it is called. This block should return the name of the registered command
 # to be run.
 # If it doesn't exist, it defaults to execute the +main+ command if defined.
 #
 # === Execution state
 # The class attributes/methods of Puppet::Application serve as a global place to set and query the execution
 # status of the application: stopping, restarting, etc.  The setting of the application status does not directly
 # affect its running status; it's assumed that the various components within the application will consult these
 # settings appropriately and affect their own processing accordingly.  Control operations (signal handlers and
 # the like) should set the status appropriately to indicate to the overall system that it's the process of
 # stopping or restarting (or just running as usual).
 #
 # So, if something in your application needs to stop the process, for some reason, you might consider:
 #
 #  def stop_me!
 #      # indicate that we're stopping
 #      Puppet::Application.stop!
 #      # ...do stuff...
 #  end
 #
 # And, if you have some component that involves a long-running process, you might want to consider:
 #
 #  def my_long_process(giant_list_to_munge)
 #      giant_list_to_munge.collect do |member|
 #          # bail if we're stopping
 #          return if Puppet::Application.stop_requested?
 #          process_member(member)
 #      end
 #  end
 class Application
   require 'puppet/util'
   include Puppet::Util
 
   DOCPATTERN = ::File.expand_path(::File.dirname(__FILE__) + "/util/command_line/*" )
   CommandLineArgs = Struct.new(:subcommand_name, :args)
 
   @loader = Puppet::Util::Autoload.new(self, 'puppet/application')
 
   class << self
     include Puppet::Util
 
     attr_accessor :run_status
 
     def clear!
       self.run_status = nil
     end
 
     def stop!
       self.run_status = :stop_requested
     end
 
     def restart!
       self.run_status = :restart_requested
     end
 
     # Indicates that Puppet::Application.restart! has been invoked and components should
     # do what is necessary to facilitate a restart.
     def restart_requested?
       :restart_requested == run_status
     end
 
     # Indicates that Puppet::Application.stop! has been invoked and components should do what is necessary
     # for a clean stop.
     def stop_requested?
       :stop_requested == run_status
     end
 
     # Indicates that one of stop! or start! was invoked on Puppet::Application, and some kind of process
     # shutdown/short-circuit may be necessary.
     def interrupted?
       [:restart_requested, :stop_requested].include? run_status
     end
 
     # Indicates that Puppet::Application believes that it's in usual running run_mode (no stop/restart request
     # currently active).
     def clear?
       run_status.nil?
     end
 
     # Only executes the given block if the run status of Puppet::Application is clear (no restarts, stops,
     # etc. requested).
     # Upon block execution, checks the run status again; if a restart has been requested during the block's
     # execution, then controlled_run will send a new HUP signal to the current process.
     # Thus, long-running background processes can potentially finish their work before a restart.
     def controlled_run(&block)
       return unless clear?
       result = block.call
       Process.kill(:HUP, $PID) if restart_requested?
       result
     end
 
     SHOULD_PARSE_CONFIG_DEPRECATION_MSG = "is no longer supported; config file parsing " +
         "is now controlled by the puppet engine, rather than by individual applications.  This " +
         "method will be removed in a future version of puppet."
 
     def should_parse_config
       Puppet.deprecation_warning("should_parse_config " + SHOULD_PARSE_CONFIG_DEPRECATION_MSG)
     end
 
     def should_not_parse_config
       Puppet.deprecation_warning("should_not_parse_config " + SHOULD_PARSE_CONFIG_DEPRECATION_MSG)
     end
 
     def should_parse_config?
       Puppet.deprecation_warning("should_parse_config? " + SHOULD_PARSE_CONFIG_DEPRECATION_MSG)
       true
     end
 
     # used to declare code that handle an option
     def option(*options, &block)
       long = options.find { |opt| opt =~ /^--/ }.gsub(/^--(?:\[no-\])?([^ =]+).*$/, '\1' ).gsub('-','_')
       fname = "handle_#{long}".intern
       if (block_given?)
         define_method(fname, &block)
       else
         define_method(fname) do |value|
           self.options["#{long}".to_sym] = value
         end
       end
       self.option_parser_commands << [options, fname]
     end
 
     def banner(banner = nil)
       @banner ||= banner
     end
 
     def option_parser_commands
       @option_parser_commands ||= (
         superclass.respond_to?(:option_parser_commands) ? superclass.option_parser_commands.dup : []
       )
       @option_parser_commands
     end
 
     # @return [Array<String>] the names of available applications
     # @api public
     def available_application_names
       @loader.files_to_load.map do |fn|
         ::File.basename(fn, '.rb')
       end.uniq
     end
 
     # Finds the class for a given application and loads the class. This does
     # not create an instance of the application, it only gets a handle to the
     # class. The code for the application is expected to live in a ruby file
     # `puppet/application/#{name}.rb` that is available on the `$LOAD_PATH`.
     #
     # @param application_name [String] the name of the application to find (eg. "apply").
     # @return [Class] the Class instance of the application that was found.
     # @raise [Puppet::Error] if the application class was not found.
     # @raise [LoadError] if there was a problem loading the application file.
     # @api public
     def find(application_name)
       begin
         require @loader.expand(application_name.to_s.downcase)
       rescue LoadError => e
         Puppet.log_and_raise(e, "Unable to find application '#{application_name}'. #{e}")
       end
 
       class_name = Puppet::Util::ConstantInflector.file2constant(application_name.to_s)
 
       clazz = try_load_class(class_name)
 
       ################################################################
       #### Begin 2.7.x backward compatibility hack;
       ####  eventually we need to issue a deprecation warning here,
       ####  and then get rid of this stanza in a subsequent release.
       ################################################################
       if (clazz.nil?)
         class_name = application_name.capitalize
         clazz = try_load_class(class_name)
       end
       ################################################################
       #### End 2.7.x backward compatibility hack
       ################################################################
 
       if clazz.nil?
         raise Puppet::Error.new("Unable to load application class '#{class_name}' from file 'puppet/application/#{application_name}.rb'")
       end
 
       return clazz
     end
 
     # Given the fully qualified name of a class, attempt to get the class instance.
     # @param [String] class_name the fully qualified name of the class to try to load
     # @return [Class] the Class instance, or nil? if it could not be loaded.
     def try_load_class(class_name)
         return self.const_defined?(class_name) ? const_get(class_name) : nil
     end
     private :try_load_class
 
     def [](name)
       find(name).new
     end
 
     # Sets or gets the run_mode name. Sets the run_mode name if a mode_name is
     # passed. Otherwise, gets the run_mode or a default run_mode
     #
     def run_mode( mode_name = nil)
       if mode_name
         Puppet.settings.preferred_run_mode = mode_name
       end
 
       return @run_mode if @run_mode and not mode_name
 
       require 'puppet/util/run_mode'
       @run_mode = Puppet::Util::RunMode[ mode_name || Puppet.settings.preferred_run_mode ]
     end
 
     # This is for testing only
     def clear_everything_for_tests
       @run_mode = @banner = @run_status = @option_parser_commands = nil
     end
   end
 
   attr_reader :options, :command_line
 
   # Every app responds to --version
   # See also `lib/puppet/util/command_line.rb` for some special case early
   # handling of this.
   option("--version", "-V") do |arg|
     puts "#{Puppet.version}"
     exit
   end
 
   # Every app responds to --help
   option("--help", "-h") do |v|
     puts help
     exit
   end
 
   def app_defaults()
     Puppet::Settings.app_defaults_for_run_mode(self.class.run_mode).merge(
         :name => name
     )
   end
 
   def initialize_app_defaults()
     Puppet.settings.initialize_app_defaults(app_defaults)
   end
 
   # override to execute code before running anything else
   def preinit
   end
 
   def initialize(command_line = Puppet::Util::CommandLine.new)
     @command_line = CommandLineArgs.new(command_line.subcommand_name, command_line.args.dup)
     @options = {}
   end
 
   # Execute the application.
   # @api public
   # @return [void]
   def run
 
     # I don't really like the names of these lifecycle phases.  It would be nice to change them to some more meaningful
     # names, and make deprecated aliases.  Also, Daniel suggests that we can probably get rid of this "plugin_hook"
     # pattern, but we need to check with PE and the community first.  --cprice 2012-03-16
     #
 
     exit_on_fail("get application-specific default settings") do
       plugin_hook('initialize_app_defaults') { initialize_app_defaults }
     end
 
     Puppet.override(Puppet.base_context(Puppet.settings)) do
+      # This use of configured environment is correct, this is used to establish
+      # the defaults for an application that does not override, or where an override
+      # has not been made from the command line.
+      #
       configured_environment = Puppet.lookup(:environments).get(Puppet[:environment])
       configured_environment = configured_environment.override_from_commandline(Puppet.settings)
 
       # Setup a new context using the app's configuration
       Puppet.override({ :current_environment => configured_environment },
                       "New base context and current environment from application's configuration") do
         require 'puppet'
         require 'puppet/util/instrumentation'
         Puppet::Util::Instrumentation.init
 
         exit_on_fail("initialize")                                   { plugin_hook('preinit')       { preinit } }
         exit_on_fail("parse application options")                    { plugin_hook('parse_options') { parse_options } }
         exit_on_fail("prepare for execution")                        { plugin_hook('setup')         { setup } }
         exit_on_fail("configure routes from #{Puppet[:route_file]}") { configure_indirector_routes }
         exit_on_fail("log runtime debug info")                       { log_runtime_environment }
         exit_on_fail("run")                                          { plugin_hook('run_command')   { run_command } }
       end
     end
   end
 
   def main
     raise NotImplementedError, "No valid command or main"
   end
 
   def run_command
     main
   end
 
   def setup
     setup_logs
   end
 
   def setup_logs
     if options[:debug] || options[:verbose]
       Puppet::Util::Log.newdestination(:console)
     end
 
     set_log_level
 
     Puppet::Util::Log.setup_default unless options[:setdest]
   end
 
   def set_log_level
     if options[:debug]
       Puppet::Util::Log.level = :debug
     elsif options[:verbose]
       Puppet::Util::Log.level = :info
     end
   end
 
   def handle_logdest_arg(arg)
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:setdest] = true
     rescue => detail
       Puppet.log_exception(detail)
     end
   end
 
   def configure_indirector_routes
     route_file = Puppet[:route_file]
     if Puppet::FileSystem.exist?(route_file)
       routes = YAML.load_file(route_file)
       application_routes = routes[name.to_s]
       Puppet::Indirector.configure_routes(application_routes) if application_routes
     end
   end
 
   # Output basic information about the runtime environment for debugging
   # purposes.
   #
   # @api public
   #
   # @param extra_info [Hash{String => #to_s}] a flat hash of extra information
   #   to log. Intended to be passed to super by subclasses.
   # @return [void]
   def log_runtime_environment(extra_info=nil)
     runtime_info = {
       'puppet_version' => Puppet.version,
       'ruby_version'   => RUBY_VERSION,
       'run_mode'       => self.class.run_mode.name,
     }
     runtime_info['default_encoding'] = Encoding.default_external if RUBY_VERSION >= '1.9.3'
     runtime_info.merge!(extra_info) unless extra_info.nil?
 
     Puppet.debug 'Runtime environment: ' + runtime_info.map{|k,v| k + '=' + v.to_s}.join(', ')
   end
 
   def parse_options
     # Create an option parser
     option_parser = OptionParser.new(self.class.banner)
 
     # Here we're building up all of the options that the application may need to handle.  The main
     # puppet settings defined in "defaults.rb" have already been parsed once (in command_line.rb) by
     # the time we get here; however, our app may wish to handle some of them specially, so we need to
     # make the parser aware of them again.  We might be able to make this a bit more efficient by
     # re-using the parser object that gets built up in command_line.rb.  --cprice 2012-03-16
 
     # Add all global options to it.
     Puppet.settings.optparse_addargs([]).each do |option|
       option_parser.on(*option) do |arg|
         handlearg(option[0], arg)
       end
     end
 
     # Add options that are local to this application, which were
     # created using the "option()" metaprogramming method.  If there
     # are any conflicts, this application's options will be favored.
     self.class.option_parser_commands.each do |options, fname|
       option_parser.on(*options) do |value|
         # Call the method that "option()" created.
         self.send(fname, value)
       end
     end
 
     # Scan command line.  We just hand any exceptions to our upper levels,
     # rather than printing help and exiting, so that we can meaningfully
     # respond with context-sensitive help if we want to. --daniel 2011-04-12
     option_parser.parse!(self.command_line.args)
   end
 
   def handlearg(opt, val)
     opt, val = Puppet::Settings.clean_opt(opt, val)
     send(:handle_unknown, opt, val) if respond_to?(:handle_unknown)
   end
 
   # this is used for testing
   def self.exit(code)
     exit(code)
   end
 
   def name
     self.class.to_s.sub(/.*::/,"").downcase.to_sym
   end
 
   def help
     "No help available for puppet #{name}"
   end
 
 
 
   def plugin_hook(step,&block)
     Puppet::Plugins.send("before_application_#{step}",:application_object => self)
     x = yield
     Puppet::Plugins.send("after_application_#{step}",:application_object => self, :return_value => x)
     x
   end
   private :plugin_hook
 end
 end
diff --git a/lib/puppet/application/doc.rb b/lib/puppet/application/doc.rb
index 866619231..a4ee8e969 100644
--- a/lib/puppet/application/doc.rb
+++ b/lib/puppet/application/doc.rb
@@ -1,280 +1,280 @@
 require 'puppet/application'
 
 class Puppet::Application::Doc < Puppet::Application
   run_mode :master
 
   attr_accessor :unknown_args, :manifest
 
   def preinit
     {:references => [], :mode => :text, :format => :to_markdown }.each do |name,value|
       options[name] = value
     end
     @unknown_args = []
     @manifest = false
   end
 
   option("--all","-a")
   option("--outputdir OUTPUTDIR","-o")
   option("--verbose","-v")
   option("--debug","-d")
   option("--charset CHARSET")
 
   option("--format FORMAT", "-f") do |arg|
     method = "to_#{arg}"
     require 'puppet/util/reference'
     if Puppet::Util::Reference.method_defined?(method)
       options[:format] = method
     else
       raise "Invalid output format #{arg}"
     end
   end
 
   option("--mode MODE", "-m") do |arg|
     require 'puppet/util/reference'
     if Puppet::Util::Reference.modes.include?(arg) or arg.intern==:rdoc
       options[:mode] = arg.intern
     else
       raise "Invalid output mode #{arg}"
     end
   end
 
   option("--list", "-l") do |arg|
     require 'puppet/util/reference'
     puts Puppet::Util::Reference.references.collect { |r| Puppet::Util::Reference.reference(r).doc }.join("\n")
     exit(0)
   end
 
   option("--reference REFERENCE", "-r") do |arg|
     options[:references] << arg.intern
   end
 
   def help
     <<-'HELP'
 
 puppet-doc(8) -- Generate Puppet documentation and references
 ========
 
 SYNOPSIS
 --------
 Generates a reference for all Puppet types. Largely meant for internal
 Puppet Labs use.
 
 WARNING: RDoc support is only available under Ruby 1.8.7 and earlier.
 
 
 USAGE
 -----
 puppet doc [-a|--all] [-h|--help] [-o|--outputdir <rdoc-outputdir>]
   [-m|--mode text|pdf|rdoc] [-r|--reference <reference-name>]
   [--charset <charset>] [<manifest-file>]
 
 
 DESCRIPTION
 -----------
 If mode is not 'rdoc', then this command generates a Markdown document
 describing all installed Puppet types or all allowable arguments to
 puppet executables. It is largely meant for internal use and is used to
 generate the reference document available on the Puppet Labs web site.
 
 In 'rdoc' mode, this command generates an html RDoc hierarchy describing
 the manifests that are in 'manifestdir' and 'modulepath' configuration
 directives. The generated documentation directory is doc by default but
 can be changed with the 'outputdir' option.
 
 If the command is run with the name of a manifest file as an argument,
 puppet doc will output a single manifest's documentation on stdout.
 
 WARNING: RDoc support is only available under Ruby 1.8.7 and earlier.
 The internal API used to support manifest documentation has changed
 radically in newer versions, and support is not yet available for
 using those versions of RDoc.
 
 
 OPTIONS
 -------
 * --all:
   Output the docs for all of the reference types. In 'rdoc' mode, this also
   outputs documentation for all resources.
 
 * --help:
   Print this help message
 
 * --outputdir:
   Used only in 'rdoc' mode. The directory to which the rdoc output should
   be written.
 
 * --mode:
   Determine the output mode. Valid modes are 'text', 'pdf' and 'rdoc'. The 'pdf'
   mode creates PDF formatted files in the /tmp directory. The default mode is
   'text'.
 
 * --reference:
   Build a particular reference. Get a list of references by running
   'puppet doc --list'.
 
 * --charset:
   Used only in 'rdoc' mode. It sets the charset used in the html files produced.
 
 * --manifestdir:
   Used only in 'rdoc' mode. The directory to scan for stand-alone manifests.
   If not supplied, puppet doc will use the manifestdir from puppet.conf.
 
 * --modulepath:
   Used only in 'rdoc' mode. The directory or directories to scan for modules.
   If not supplied, puppet doc will use the modulepath from puppet.conf.
 
 * --environment:
   Used only in 'rdoc' mode. The configuration environment from which
   to read the modulepath and manifestdir settings, when reading said settings
   from puppet.conf.
 
 
 EXAMPLE
 -------
     $ puppet doc -r type > /tmp/type_reference.markdown
 
 or
 
     $ puppet doc --outputdir /tmp/rdoc --mode rdoc /path/to/manifests
 
 or
 
     $ puppet doc /etc/puppet/manifests/site.pp
 
 or
 
     $ puppet doc -m pdf -r configuration
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
 HELP
   end
 
   def handle_unknown( opt, arg )
     @unknown_args << {:opt => opt, :arg => arg }
     true
   end
 
   def run_command
-    return[:rdoc].include?(options[:mode]) ? send(options[:mode]) : other
+    return [:rdoc].include?(options[:mode]) ? send(options[:mode]) : other
   end
 
   def rdoc
     exit_code = 0
     files = []
     unless @manifest
-      env = Puppet.lookup(:environments).get(Puppet[:environment])
+      env = Puppet.lookup(:current_environment)
       files += env.modulepath
-      files << ::File.dirname(env.manifest)
+      files << ::File.dirname(env.manifest) if env.manifest != Puppet::Node::Environment::NO_MANIFEST
     end
     files += command_line.args
     Puppet.info "scanning: #{files.inspect}"
 
     Puppet.settings[:document_all] = options[:all] || false
     begin
       require 'puppet/util/rdoc'
       if @manifest
         Puppet::Util::RDoc.manifestdoc(files)
       else
         options[:outputdir] = "doc" unless options[:outputdir]
         Puppet::Util::RDoc.rdoc(options[:outputdir], files, options[:charset])
       end
     rescue => detail
       Puppet.log_exception(detail, "Could not generate documentation: #{detail}")
       exit_code = 1
     end
     exit exit_code
   end
 
   def other
     text = ""
     with_contents = options[:references].length <= 1
     exit_code = 0
     require 'puppet/util/reference'
     options[:references].sort { |a,b| a.to_s <=> b.to_s }.each do |name|
       raise "Could not find reference #{name}" unless section = Puppet::Util::Reference.reference(name)
 
       begin
         # Add the per-section text, but with no ToC
         text += section.send(options[:format], with_contents)
       rescue => detail
         Puppet.log_exception(detail, "Could not generate reference #{name}: #{detail}")
         exit_code = 1
         next
       end
     end
 
     text += Puppet::Util::Reference.footer unless with_contents # We've only got one reference
 
     if options[:mode] == :pdf
       Puppet::Util::Reference.pdf(text)
     else
       puts text
     end
 
     exit exit_code
   end
 
   def setup
     # sole manifest documentation
     if command_line.args.size > 0
       options[:mode] = :rdoc
       @manifest = true
     end
 
     if options[:mode] == :rdoc
       setup_rdoc
     else
       setup_reference
     end
 
     setup_logging
   end
 
   def setup_reference
     if options[:all]
       # Don't add dynamic references to the "all" list.
       require 'puppet/util/reference'
       options[:references] = Puppet::Util::Reference.references.reject do |ref|
         Puppet::Util::Reference.reference(ref).dynamic?
       end
     end
 
     options[:references] << :type if options[:references].empty?
   end
 
   def setup_rdoc(dummy_argument=:work_arround_for_ruby_GC_bug)
     # consume the unknown options
     # and feed them as settings
     if @unknown_args.size > 0
       @unknown_args.each do |option|
         # force absolute path for modulepath when passed on commandline
         if option[:opt]=="--modulepath" or option[:opt] == "--manifestdir"
           option[:arg] = option[:arg].split(::File::PATH_SEPARATOR).collect { |p| ::File.expand_path(p) }.join(::File::PATH_SEPARATOR)
         end
         Puppet.settings.handlearg(option[:opt], option[:arg])
       end
     end
   end
 
   def setup_logging
   # Handle the logging settings.
     if options[:debug]
       Puppet::Util::Log.level = :debug
     elsif options[:verbose]
       Puppet::Util::Log.level = :info
     else
       Puppet::Util::Log.level = :warning
     end
 
     Puppet::Util::Log.newdestination(:console)
   end
 end
diff --git a/lib/puppet/face/node/clean.rb b/lib/puppet/face/node/clean.rb
index 903e93819..f1c3c34b8 100644
--- a/lib/puppet/face/node/clean.rb
+++ b/lib/puppet/face/node/clean.rb
@@ -1,159 +1,159 @@
 Puppet::Face.define(:node, '0.0.1') do
   action(:clean) do
     option "--[no-]unexport" do
       summary "Whether to remove this node's exported resources from other nodes"
     end
 
     summary "Clean up everything a puppetmaster knows about a node."
     arguments "<host1> [<host2> ...]"
     description <<-'EOT'
       Clean up everything a puppet master knows about a node, including certificates
       and storeconfigs data.
 
       The full list of info cleaned by this action is:
 
       <Signed certificates> - ($vardir/ssl/ca/signed/node.domain.pem)
 
       <Cached facts> - ($vardir/yaml/facts/node.domain.yaml)
 
       <Cached node objects> - ($vardir/yaml/node/node.domain.yaml)
 
       <Reports> - ($vardir/reports/node.domain)
 
       <Stored configs> - (in database) The clean action can either remove all
       data from a host in your storeconfigs database, or, with the
       <--unexport> option, turn every exported resource supporting ensure to
       absent so that any other host that collected those resources can remove
       them. Without unexporting, a removed node's exported resources become
       unmanaged by Puppet, and may linger as cruft unless you are purging
       that resource type.
     EOT
 
     when_invoked do |*args|
       nodes = args[0..-2]
       options = args.last
       raise "At least one node should be passed" if nodes.empty? || nodes == options
 
       # This seems really bad; run_mode should be set as part of a class
       # definition, and should not be modifiable beyond that.  This is one of
       # the only places left in the code that tries to manipulate it. Other
       # parts of code that handle certificates behave differently if the
       # run_mode is master. Those other behaviors are needed for cleaning the
       # certificates correctly.
       Puppet.settings.preferred_run_mode = "master"
 
       if Puppet::SSL::CertificateAuthority.ca?
         Puppet::SSL::Host.ca_location = :local
       else
         Puppet::SSL::Host.ca_location = :none
       end
 
       Puppet::Node::Facts.indirection.terminus_class = :yaml
       Puppet::Node::Facts.indirection.cache_class = :yaml
       Puppet::Node.indirection.terminus_class = :yaml
       Puppet::Node.indirection.cache_class = :yaml
 
       nodes.each { |node| cleanup(node.downcase, options[:unexport]) }
     end
   end
 
   def cleanup(node, unexport)
     clean_cert(node)
     clean_cached_facts(node)
     clean_cached_node(node)
     clean_reports(node)
     clean_storeconfigs(node, unexport)
   end
 
   # clean signed cert for +host+
   def clean_cert(node)
     if Puppet::SSL::CertificateAuthority.ca?
       Puppet::Face[:ca, :current].revoke(node)
       Puppet::Face[:ca, :current].destroy(node)
       Puppet.info "#{node} certificates removed from ca"
     else
       Puppet.info "Not managing #{node} certs as this host is not a CA"
     end
   end
 
   # clean facts for +host+
   def clean_cached_facts(node)
     Puppet::Node::Facts.indirection.destroy(node)
     Puppet.info "#{node}'s facts removed"
   end
 
   # clean cached node +host+
   def clean_cached_node(node)
     Puppet::Node.indirection.destroy(node)
     Puppet.info "#{node}'s cached node removed"
   end
 
   # clean node reports for +host+
   def clean_reports(node)
     Puppet::Transaction::Report.indirection.destroy(node)
     Puppet.info "#{node}'s reports removed"
   end
 
   # clean storeconfig for +node+
   def clean_storeconfigs(node, do_unexport=false)
     return unless Puppet[:storeconfigs] && Puppet.features.rails?
     require 'puppet/rails'
     Puppet::Rails.connect
     unless rails_node = Puppet::Rails::Host.find_by_name(node)
       Puppet.notice "No entries found for #{node} in storedconfigs."
       return
     end
 
     if do_unexport
       unexport(rails_node)
       Puppet.notice "Force #{node}'s exported resources to absent"
       Puppet.warning "Please wait until all other hosts have checked out their configuration before finishing the cleanup with:"
       Puppet.warning "$ puppet node clean #{node}"
     else
       rails_node.destroy
       Puppet.notice "#{node} storeconfigs removed"
     end
   end
 
   def unexport(node)
     # fetch all exported resource
     query = {:include => {:param_values => :param_name}}
     query[:conditions] = [ "exported=? AND host_id=?", true, node.id ]
     Puppet::Rails::Resource.find(:all, query).each do |resource|
       if type_is_ensurable(resource)
         line = 0
         param_name = Puppet::Rails::ParamName.find_or_create_by_name("ensure")
 
         if ensure_param = resource.param_values.find(
           :first,
           :conditions => [ 'param_name_id = ?', param_name.id ]
         )
           line = ensure_param.line.to_i
           Puppet::Rails::ParamValue.delete(ensure_param.id);
         end
 
         # force ensure parameter to "absent"
         resource.param_values.create(
           :value => "absent",
           :line => line,
           :param_name => param_name
         )
         Puppet.info("#{resource.name} has been marked as \"absent\"")
       end
     end
   end
 
   def environment
-    @environment ||= Puppet.lookup(:environments).get(Puppet[:environment])
+    @environment ||= Puppet.lookup(:current_environment)
   end
 
   def type_is_ensurable(resource)
     if (type = Puppet::Type.type(resource.restype)) && type.validattr?(:ensure)
       return true
     else
       type = environment.known_resource_types.find_definition('', resource.restype)
       return true if type && type.arguments.keys.include?('ensure')
     end
     return false
   end
 end
diff --git a/lib/puppet/face/parser.rb b/lib/puppet/face/parser.rb
index a3835bfa0..1417971f5 100644
--- a/lib/puppet/face/parser.rb
+++ b/lib/puppet/face/parser.rb
@@ -1,68 +1,73 @@
 require 'puppet/face'
 require 'puppet/parser'
 
 Puppet::Face.define(:parser, '0.0.1') do
   copyright "Puppet Labs", 2011
   license   "Apache 2 license; see COPYING"
 
   summary "Interact directly with the parser."
 
   action :validate do
     summary "Validate the syntax of one or more Puppet manifests."
     arguments "[<manifest>] [<manifest> ...]"
     returns "Nothing, or the first syntax error encountered."
     description <<-'EOT'
       This action validates Puppet DSL syntax without compiling a catalog or
       syncing any resources. If no manifest files are provided, it will
       validate the default site manifest.
+
+      When validating with --parser current, the validation stops after the first
+      encountered issue.
+
+      When validating with --parser future, multiple issues per file are reported up
+      to the settings of max_error, and max_warnings. The processing stops
+      after having reported issues for the first encountered file with errors.
     EOT
     examples <<-'EOT'
       Validate the default site manifest at /etc/puppet/manifests/site.pp:
 
       $ puppet parser validate
 
       Validate two arbitrary manifest files:
 
       $ puppet parser validate init.pp vhost.pp
 
       Validate from STDIN:
 
       $ cat init.pp | puppet parser validate
     EOT
     when_invoked do |*args|
       args.pop
       files = args
       if files.empty?
         if not STDIN.tty?
           Puppet[:code] = STDIN.read
           validate_manifest
         else
           manifest = Puppet.lookup(:current_environment).manifest
           files << manifest
           Puppet.notice "No manifest specified. Validating the default manifest #{manifest}"
         end
       end
       missing_files = []
       files.each do |file|
         missing_files << file if ! Puppet::FileSystem.exist?(file)
         validate_manifest(file)
       end
       raise Puppet::Error, "One or more file(s) specified did not exist:\n#{missing_files.collect {|f| " " * 3 + f + "\n"}}" if ! missing_files.empty?
       nil
     end
   end
 
   # @api private
   def validate_manifest(manifest = nil)
-    configured_environment = Puppet.lookup(:environments).get(Puppet[:environment])
-    validation_environment = manifest ?
-      configured_environment.override_with(:manifest => manifest) :
-      configured_environment
+    env = Puppet.lookup(:current_environment)
+    validation_environment = manifest ? env.override_with(:manifest => manifest) : env
 
     validation_environment.known_resource_types.clear
 
   rescue => detail
     Puppet.log_exception(detail)
     exit(1)
   end
 end
diff --git a/lib/puppet/indirector/request.rb b/lib/puppet/indirector/request.rb
index a67753f68..0b3452b41 100644
--- a/lib/puppet/indirector/request.rb
+++ b/lib/puppet/indirector/request.rb
@@ -1,312 +1,317 @@
 require 'cgi'
 require 'uri'
 require 'puppet/indirector'
 require 'puppet/util/pson'
 require 'puppet/network/resolver'
 
 # This class encapsulates all of the information you need to make an
 # Indirection call, and as a result also handles REST calls.  It's somewhat
 # analogous to an HTTP Request object, except tuned for our Indirector.
 class Puppet::Indirector::Request
   attr_accessor :key, :method, :options, :instance, :node, :ip, :authenticated, :ignore_cache, :ignore_terminus
 
   attr_accessor :server, :port, :uri, :protocol
 
   attr_reader :indirection_name
 
   # trusted_information is specifically left out because we can't serialize it
   # and keep it "trusted"
   OPTION_ATTRIBUTES = [:ip, :node, :authenticated, :ignore_terminus, :ignore_cache, :instance, :environment]
 
   ::PSON.register_document_type('IndirectorRequest',self)
 
   def self.from_data_hash(data)
     raise ArgumentError, "No indirection name provided in data" unless indirection_name = data['type']
     raise ArgumentError, "No method name provided in data" unless method = data['method']
     raise ArgumentError, "No key provided in data" unless key = data['key']
 
     request = new(indirection_name, method, key, nil, data['attributes'])
 
     if instance = data['instance']
       klass = Puppet::Indirector::Indirection.instance(request.indirection_name).model
       if instance.is_a?(klass)
         request.instance = instance
       else
         request.instance = klass.from_data_hash(instance)
       end
     end
 
     request
   end
 
   def self.from_pson(json)
     Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
     self.from_data_hash(json)
   end
 
   def to_data_hash
     result = {
       'type' => indirection_name,
       'method' => method,
       'key' => key
     }
     attributes = {}
     OPTION_ATTRIBUTES.each do |key|
       next unless value = send(key)
       attributes[key] = value
     end
 
     options.each do |opt, value|
       attributes[opt] = value
     end
 
     result['attributes'] = attributes unless attributes.empty?
     result['instance'] = instance if instance
     result
   end
 
   def to_pson_data_hash
     {
       'document_type' => 'IndirectorRequest',
       'data' => to_data_hash,
     }
   end
 
   def to_pson(*args)
     to_pson_data_hash.to_pson(*args)
   end
 
   # Is this an authenticated request?
   def authenticated?
     # Double negative, so we just get true or false
     ! ! authenticated
   end
 
   def environment
+    # The lookup of the environment from the configuration is correct here
+    # as this is used to establish the environment to use for a request.
+    # If some other environment should be in effect, it should already
+    # have been set with #environment=
+    #
     @environment ||= Puppet.lookup(:environments).get(Puppet[:environment])
   end
 
   def environment=(env)
     @environment = if env.is_a?(Puppet::Node::Environment)
       env
     else
       Puppet.lookup(:environments).get(env)
     end
   end
 
   def escaped_key
     URI.escape(key)
   end
 
   # LAK:NOTE This is a messy interface to the cache, and it's only
   # used by the Configurer class.  I decided it was better to implement
   # it now and refactor later, when we have a better design, than
   # to spend another month coming up with a design now that might
   # not be any better.
   def ignore_cache?
     ignore_cache
   end
 
   def ignore_terminus?
     ignore_terminus
   end
 
   def initialize(indirection_name, method, key, instance, options = {})
     @instance = instance
     options ||= {}
 
     self.indirection_name = indirection_name
     self.method = method
 
     options = options.inject({}) { |hash, ary| hash[ary[0].to_sym] = ary[1]; hash }
 
     set_attributes(options)
 
     @options = options
 
     if key
       # If the request key is a URI, then we need to treat it specially,
       # because it rewrites the key.  We could otherwise strip server/port/etc
       # info out in the REST class, but it seemed bad design for the REST
       # class to rewrite the key.
 
       if key.to_s =~ /^\w+:\// and not Puppet::Util.absolute_path?(key.to_s) # it's a URI
         set_uri_key(key)
       else
         @key = key
       end
     end
 
     @key = @instance.name if ! @key and @instance
   end
 
   # Look up the indirection based on the name provided.
   def indirection
     Puppet::Indirector::Indirection.instance(indirection_name)
   end
 
   def indirection_name=(name)
     @indirection_name = name.to_sym
   end
 
   def model
     raise ArgumentError, "Could not find indirection '#{indirection_name}'" unless i = indirection
     i.model
   end
 
   # Are we trying to interact with multiple resources, or just one?
   def plural?
     method == :search
   end
 
   # Create the query string, if options are present.
   def query_string
     return "" if options.nil? || options.empty?
 
     # For backward compatibility with older (pre-3.3) masters,
     # this puppet option allows serialization of query parameter
     # arrays as yaml.  This can be removed when we remove yaml
     # support entirely.
     if Puppet.settings[:legacy_query_parameter_serialization]
       replace_arrays_with_yaml
     end
 
     "?" + encode_params(expand_into_parameters(options.to_a))
   end
 
   def replace_arrays_with_yaml
     options.each do |key, value|
       case value
         when Array
           options[key] = YAML.dump(value)
       end
     end
   end
 
   def expand_into_parameters(data)
     data.inject([]) do |params, key_value|
       key, value = key_value
 
       expanded_value = case value
                        when Array
                          value.collect { |val| [key, val] }
                        else
                          [key_value]
                        end
 
       params.concat(expand_primitive_types_into_parameters(expanded_value))
     end
   end
 
   def expand_primitive_types_into_parameters(data)
     data.inject([]) do |params, key_value|
       key, value = key_value
       case value
       when nil
         params
       when true, false, String, Symbol, Fixnum, Bignum, Float
         params << [key, value]
       else
         raise ArgumentError, "HTTP REST queries cannot handle values of type '#{value.class}'"
       end
     end
   end
 
   def encode_params(params)
     params.collect do |key, value|
       "#{key}=#{CGI.escape(value.to_s)}"
     end.join("&")
   end
 
   def to_hash
     result = options.dup
 
     OPTION_ATTRIBUTES.each do |attribute|
       if value = send(attribute)
         result[attribute] = value
       end
     end
     result
   end
 
   def to_s
     return(uri ? uri : "/#{indirection_name}/#{key}")
   end
 
   def do_request(srv_service=:puppet, default_server=Puppet.settings[:server], default_port=Puppet.settings[:masterport], &block)
     # We were given a specific server to use, so just use that one.
     # This happens if someone does something like specifying a file
     # source using a puppet:// URI with a specific server.
     return yield(self) if !self.server.nil?
 
     if Puppet.settings[:use_srv_records]
       Puppet::Network::Resolver.each_srv_record(Puppet.settings[:srv_domain], srv_service) do |srv_server, srv_port|
         begin
           self.server = srv_server
           self.port   = srv_port
           return yield(self)
         rescue SystemCallError => e
           Puppet.warning "Error connecting to #{srv_server}:#{srv_port}: #{e.message}"
         end
       end
     end
 
     # ... Fall back onto the default server.
     Puppet.debug "No more servers left, falling back to #{default_server}:#{default_port}" if Puppet.settings[:use_srv_records]
     self.server = default_server
     self.port   = default_port
     return yield(self)
   end
 
   def remote?
     self.node or self.ip
   end
 
   private
 
   def set_attributes(options)
     OPTION_ATTRIBUTES.each do |attribute|
       if options.include?(attribute.to_sym)
         send(attribute.to_s + "=", options[attribute])
         options.delete(attribute)
       end
     end
   end
 
   # Parse the key as a URI, setting attributes appropriately.
   def set_uri_key(key)
     @uri = key
     begin
       uri = URI.parse(URI.escape(key))
     rescue => detail
       raise ArgumentError, "Could not understand URL #{key}: #{detail}", detail.backtrace
     end
 
     # Just short-circuit these to full paths
     if uri.scheme == "file"
       @key = Puppet::Util.uri_to_path(uri)
       return
     end
 
     @server = uri.host if uri.host
 
     # If the URI class can look up the scheme, it will provide a port,
     # otherwise it will default to '0'.
     if uri.port.to_i == 0 and uri.scheme == "puppet"
       @port = Puppet.settings[:masterport].to_i
     else
       @port = uri.port.to_i
     end
 
     @protocol = uri.scheme
 
     if uri.scheme == 'puppet'
       @key = URI.unescape(uri.path.sub(/^\//, ''))
       return
     end
 
     env, indirector, @key = URI.unescape(uri.path.sub(/^\//, '')).split('/',3)
     @key ||= ''
     self.environment = env unless env == ''
   end
 end
diff --git a/lib/puppet/indirector/rest.rb b/lib/puppet/indirector/rest.rb
index 1697aa55f..e16c5118e 100644
--- a/lib/puppet/indirector/rest.rb
+++ b/lib/puppet/indirector/rest.rb
@@ -1,264 +1,260 @@
 require 'net/http'
 require 'uri'
 
 require 'puppet/network/http'
 require 'puppet/network/http_pool'
 require 'puppet/network/http/api/v1'
 require 'puppet/network/http/compression'
 
 # Access objects via REST
 class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   include Puppet::Network::HTTP::Compression.module
 
   class << self
     attr_reader :server_setting, :port_setting
   end
 
   # Specify the setting that we should use to get the server name.
   def self.use_server_setting(setting)
     @server_setting = setting
   end
 
   # Specify the setting that we should use to get the port.
   def self.use_port_setting(setting)
     @port_setting = setting
   end
 
   # Specify the service to use when doing SRV record lookup
   def self.use_srv_service(service)
     @srv_service = service
   end
 
   def self.srv_service
     @srv_service || :puppet
   end
 
   def self.server
     Puppet.settings[server_setting || :server]
   end
 
   def self.port
     Puppet.settings[port_setting || :masterport].to_i
   end
 
   # Provide appropriate headers.
   def headers
     add_accept_encoding({"Accept" => model.supported_formats.join(", ")})
   end
 
   def add_profiling_header(headers)
     if (Puppet[:profile])
       headers[Puppet::Network::HTTP::HEADER_ENABLE_PROFILING] = "true"
     end
     headers
   end
 
   def network(request)
     Puppet::Network::HttpPool.http_instance(request.server || self.class.server,
                                             request.port || self.class.port)
   end
 
   def http_get(request, path, headers = nil, *args)
     http_request(:get, request, path, add_profiling_header(headers), *args)
   end
 
   def http_post(request, path, data, headers = nil, *args)
     http_request(:post, request, path, data, add_profiling_header(headers), *args)
   end
 
   def http_head(request, path, headers = nil, *args)
     http_request(:head, request, path, add_profiling_header(headers), *args)
   end
 
   def http_delete(request, path, headers = nil, *args)
     http_request(:delete, request, path, add_profiling_header(headers), *args)
   end
 
   def http_put(request, path, data, headers = nil, *args)
     http_request(:put, request, path, data, add_profiling_header(headers), *args)
   end
 
   def http_request(method, request, *args)
     conn = network(request)
     conn.send(method, *args)
   end
 
   def find(request)
     uri, body = Puppet::Network::HTTP::API::V1.request_to_uri_and_body(request)
     uri_with_query_string = "#{uri}?#{body}"
 
     response = do_request(request) do |request|
       # WEBrick in Ruby 1.9.1 only supports up to 1024 character lines in an HTTP request
       # http://redmine.ruby-lang.org/issues/show/3991
       if "GET #{uri_with_query_string} HTTP/1.1\r\n".length > 1024
         http_post(request, uri, body, headers)
       else
         http_get(request, uri_with_query_string, headers)
       end
     end
 
     if is_http_200?(response)
       check_master_version(response)
       content_type, body = parse_response(response)
       result = deserialize_find(content_type, body)
       result.name = request.key if result.respond_to?(:name=)
       result
 
     elsif is_http_404?(response)
       # 404 gets special treatment as the indirector API can not produce a meaningful
       # reason to why something is not found - it may not be the thing the user is
       # expecting to find that is missing, but something else (like the environment).
       # While this way of handling the issue is not perfect, there is at least a warning
       # that makes a user aware of the reason for the failure.
       #
       content_type, body = parse_response(response)
       msg = "Find #{uri_with_query_string} resulted in 404 with the message: #{body}"
       # warn_once
       Puppet::Util::Warnings.maybe_log(msg, self.class){ Puppet.warning msg }
       nil
 
     else
       nil
     end
   end
 
   def head(request)
     response = do_request(request) do |request|
       http_head(request, Puppet::Network::HTTP::API::V1.indirection2uri(request), headers)
     end
 
     if is_http_200?(response)
       check_master_version(response)
       true
     else
       false
     end
   end
 
   def search(request)
     response = do_request(request) do |request|
       http_get(request, Puppet::Network::HTTP::API::V1.indirection2uri(request), headers)
     end
 
     if is_http_200?(response)
       check_master_version(response)
       content_type, body = parse_response(response)
       deserialize_search(content_type, body) || []
     else
       []
     end
   end
 
   def destroy(request)
     raise ArgumentError, "DELETE does not accept options" unless request.options.empty?
 
     response = do_request(request) do |request|
       http_delete(request, Puppet::Network::HTTP::API::V1.indirection2uri(request), headers)
     end
 
     if is_http_200?(response)
       check_master_version(response)
       content_type, body = parse_response(response)
       deserialize_destroy(content_type, body)
     else
       nil
     end
   end
 
   def save(request)
     raise ArgumentError, "PUT does not accept options" unless request.options.empty?
 
     response = do_request(request) do |request|
       http_put(request, Puppet::Network::HTTP::API::V1.indirection2uri(request), request.instance.render, headers.merge({ "Content-Type" => request.instance.mime }))
     end
 
     if is_http_200?(response)
       check_master_version(response)
       content_type, body = parse_response(response)
       deserialize_save(content_type, body)
     else
       nil
     end
   end
 
   # Encapsulate call to request.do_request with the arguments from this class
   # Then yield to the code block that was called in
   # We certainly could have retained the full request.do_request(...) { |r| ... }
   # but this makes the code much cleaner and we only then actually make the call
   # to request.do_request from here, thus if we change what we pass or how we
   # get it, we only need to change it here.
   def do_request(request)
     request.do_request(self.class.srv_service, self.class.server, self.class.port) { |request| yield(request) }
   end
 
   def validate_key(request)
     # Validation happens on the remote end
   end
 
   private
 
   def is_http_200?(response)
     case response.code
     when "404"
       false
     when /^2/
       true
     else
       # Raise the http error if we didn't get a 'success' of some kind.
       raise convert_to_http_error(response)
     end
   end
 
   def is_http_404?(response)
     response.code == "404"
   end
 
   def convert_to_http_error(response)
     message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
     Net::HTTPError.new(message, response)
   end
 
   def check_master_version response
     if !response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION] &&
        (Puppet[:legacy_query_parameter_serialization] == false || Puppet[:report_serialization_format] != "yaml")
       Puppet.notice "Using less secure serialization of reports and query parameters for compatibility"
       Puppet.notice "with older puppet master. To remove this notice, please upgrade your master(s) "
       Puppet.notice "to Puppet 3.3 or newer."
       Puppet.notice "See http://links.puppetlabs.com/deprecate_yaml_on_network for more information."
       Puppet[:legacy_query_parameter_serialization] = true
       Puppet[:report_serialization_format] = "yaml"
     end
   end
 
   # Returns the content_type, stripping any appended charset, and the
   # body, decompressed if necessary (content-encoding is checked inside
   # uncompress_body)
   def parse_response(response)
     if response['content-type']
       [ response['content-type'].gsub(/\s*;.*$/,''),
         body = uncompress_body(response) ]
     else
       raise "No content type in http response; cannot parse"
     end
   end
 
   def deserialize_find(content_type, body)
     model.convert_from(content_type, body)
   end
 
   def deserialize_search(content_type, body)
     model.convert_from_multiple(content_type, body)
   end
 
   def deserialize_destroy(content_type, body)
     model.convert_from(content_type, body)
   end
 
   def deserialize_save(content_type, body)
     nil
   end
-
-  def environment
-    Puppet.lookup(:environments).get(Puppet[:environment])
-  end
 end
diff --git a/lib/puppet/module.rb b/lib/puppet/module.rb
index 422d66d87..3a3435c35 100644
--- a/lib/puppet/module.rb
+++ b/lib/puppet/module.rb
@@ -1,338 +1,339 @@
 require 'puppet/util/logging'
 require 'semver'
 require 'json'
 
 # Support for modules
 class Puppet::Module
   class Error < Puppet::Error; end
   class MissingModule < Error; end
   class IncompatibleModule < Error; end
   class UnsupportedPlatform < Error; end
   class IncompatiblePlatform < Error; end
   class MissingMetadata < Error; end
   class InvalidName < Error; end
   class InvalidFilePattern < Error; end
 
   include Puppet::Util::Logging
 
   FILETYPES = {
     "manifests" => "manifests",
     "files" => "files",
     "templates" => "templates",
     "plugins" => "lib",
     "pluginfacts" => "facts.d",
   }
 
   # Find and return the +module+ that +path+ belongs to. If +path+ is
   # absolute, or if there is no module whose name is the first component
   # of +path+, return +nil+
   def self.find(modname, environment = nil)
     return nil unless modname
-    env = Puppet.lookup(:environments).get(environment || Puppet[:environment])
+    # Unless a specific environment is given, use the current environment
+    env = environment ? Puppet.lookup(:environments).get(environment) : Puppet.lookup(:current_environment)
     env.module(modname)
   end
 
   attr_reader :name, :environment, :path, :metadata
   attr_writer :environment
 
   attr_accessor :dependencies, :forge_name
   attr_accessor :source, :author, :version, :license, :puppetversion, :summary, :description, :project_page
 
   def initialize(name, path, environment)
     @name = name
     @path = path
     @environment = environment
 
     assert_validity
 
     load_metadata if has_metadata?
 
     validate_puppet_version
 
     @absolute_path_to_manifests = Puppet::FileSystem::PathPattern.absolute(manifests)
   end
 
   def has_metadata?
     return false unless metadata_file
 
     return false unless Puppet::FileSystem.exist?(metadata_file)
 
     begin
       metadata =  JSON.parse(File.read(metadata_file))
     rescue JSON::JSONError => e
       Puppet.debug("#{name} has an invalid and unparsable metadata.json file.  The parse error: #{e.message}")
       return false
     end
 
     return metadata.is_a?(Hash) && !metadata.keys.empty?
   end
 
   FILETYPES.each do |type, location|
     # A boolean method to let external callers determine if
     # we have files of a given type.
     define_method(type +'?') do
       type_subpath = subpath(location)
       unless Puppet::FileSystem.exist?(type_subpath)
         Puppet.debug("No #{type} found in subpath '#{type_subpath}' " +
                          "(file / directory does not exist)")
         return false
       end
 
       return true
     end
 
     # A method for returning a given file of a given type.
     # e.g., file = mod.manifest("my/manifest.pp")
     #
     # If the file name is nil, then the base directory for the
     # file type is passed; this is used for fileserving.
     define_method(type.sub(/s$/, '')) do |file|
       # If 'file' is nil then they're asking for the base path.
       # This is used for things like fileserving.
       if file
         full_path = File.join(subpath(location), file)
       else
         full_path = subpath(location)
       end
 
       return nil unless Puppet::FileSystem.exist?(full_path)
       return full_path
     end
 
     # Return the base directory for the given type
     define_method(type) do
       subpath(location)
     end
   end
 
   def license_file
     return @license_file if defined?(@license_file)
 
     return @license_file = nil unless path
     @license_file = File.join(path, "License")
   end
 
   def load_metadata
     @metadata = data = JSON.parse(File.read(metadata_file))
     @forge_name = data['name'].gsub('-', '/') if data['name']
 
     [:source, :author, :version, :license, :puppetversion, :dependencies].each do |attr|
       unless value = data[attr.to_s]
         unless attr == :puppetversion
           raise MissingMetadata, "No #{attr} module metadata provided for #{self.name}"
         end
       end
 
       # NOTICE: The fallback to `versionRequirement` is something we'd like to
       # not have to support, but we have a reasonable number of releases that
       # don't use `version_requirement`. When we can deprecate this, we should.
       if attr == :dependencies
         value.tap do |dependencies|
           dependencies.each do |dep|
             dep['version_requirement'] ||= dep['versionRequirement'] || '>= 0.0.0'
           end
         end
       end
 
       send(attr.to_s + "=", value)
     end
   end
 
   # Return the list of manifests matching the given glob pattern,
   # defaulting to 'init.{pp,rb}' for empty modules.
   def match_manifests(rest)
     if rest
       wanted_manifests = wanted_manifests_from(rest)
       searched_manifests = wanted_manifests.glob.reject { |f| FileTest.directory?(f) }
     else
       searched_manifests = []
     end
 
     # (#4220) Always ensure init.pp in case class is defined there.
     init_manifests = [manifest("init.pp"), manifest("init.rb")].compact
     init_manifests + searched_manifests
   end
 
   def all_manifests
     return [] unless Puppet::FileSystem.exist?(manifests)
 
     Dir.glob(File.join(manifests, '**', '*.{rb,pp}'))
   end
 
   def metadata_file
     return @metadata_file if defined?(@metadata_file)
 
     return @metadata_file = nil unless path
     @metadata_file = File.join(path, "metadata.json")
   end
 
   def modulepath
     File.dirname(path) if path
   end
 
   # Find all plugin directories.  This is used by the Plugins fileserving mount.
   def plugin_directory
     subpath("lib")
   end
 
   def plugin_fact_directory
     subpath("facts.d")
   end
 
   def has_external_facts?
     File.directory?(plugin_fact_directory)
   end
 
   def supports(name, version = nil)
     @supports ||= []
     @supports << [name, version]
   end
 
   def to_s
     result = "Module #{name}"
     result += "(#{path})" if path
     result
   end
 
   def dependencies_as_modules
     dependent_modules = []
     dependencies and dependencies.each do |dep|
       author, dep_name = dep["name"].split('/')
       found_module = environment.module(dep_name)
       dependent_modules << found_module if found_module
     end
 
     dependent_modules
   end
 
   def required_by
     environment.module_requirements[self.forge_name] || {}
   end
 
   def has_local_changes?
     Puppet.deprecation_warning("This method is being removed.")
     require 'puppet/module_tool/applications'
     changes = Puppet::ModuleTool::Applications::Checksummer.run(path)
     !changes.empty?
   end
 
   def local_changes
     Puppet.deprecation_warning("This method is being removed.")
     require 'puppet/module_tool/applications'
     Puppet::ModuleTool::Applications::Checksummer.run(path)
   end
 
   # Identify and mark unmet dependencies.  A dependency will be marked unmet
   # for the following reasons:
   #
   #   * not installed and is thus considered missing
   #   * installed and does not meet the version requirements for this module
   #   * installed and doesn't use semantic versioning
   #
   # Returns a list of hashes representing the details of an unmet dependency.
   #
   # Example:
   #
   #   [
   #     {
   #       :reason => :missing,
   #       :name   => 'puppetlabs-mysql',
   #       :version_constraint => 'v0.0.1',
   #       :mod_details => {
   #         :installed_version => '0.0.1'
   #       }
   #       :parent => {
   #         :name    => 'puppetlabs-bacula',
   #         :version => 'v1.0.0'
   #       }
   #     }
   #   ]
   #
   def unmet_dependencies
     unmet_dependencies = []
     return unmet_dependencies unless dependencies
 
     dependencies.each do |dependency|
       forge_name = dependency['name']
       version_string = dependency['version_requirement'] || '>= 0.0.0'
 
       dep_mod = begin
         environment.module_by_forge_name(forge_name)
       rescue
         nil
       end
 
       error_details = {
         :name => forge_name,
         :version_constraint => version_string.gsub(/^(?=\d)/, "v"),
         :parent => {
           :name => self.forge_name,
           :version => self.version.gsub(/^(?=\d)/, "v")
         },
         :mod_details => {
           :installed_version => dep_mod.nil? ? nil : dep_mod.version
         }
       }
 
       unless dep_mod
         error_details[:reason] = :missing
         unmet_dependencies << error_details
         next
       end
 
       if version_string
         begin
           required_version_semver_range = SemVer[version_string]
           actual_version_semver = SemVer.new(dep_mod.version)
         rescue ArgumentError
           error_details[:reason] = :non_semantic_version
           unmet_dependencies << error_details
           next
         end
 
         unless required_version_semver_range.include? actual_version_semver
           error_details[:reason] = :version_mismatch
           unmet_dependencies << error_details
           next
         end
       end
     end
 
     unmet_dependencies
   end
 
   def validate_puppet_version
     return unless puppetversion and puppetversion != Puppet.version
     raise IncompatibleModule, "Module #{self.name} is only compatible with Puppet version #{puppetversion}, not #{Puppet.version}"
   end
 
   private
 
   def wanted_manifests_from(pattern)
     begin
       extended = File.extname(pattern).empty? ? "#{pattern}.{pp,rb}" : pattern
       relative_pattern = Puppet::FileSystem::PathPattern.relative(extended)
     rescue Puppet::FileSystem::PathPattern::InvalidPattern => error
       raise Puppet::Module::InvalidFilePattern.new(
         "The pattern \"#{pattern}\" to find manifests in the module \"#{name}\" " +
         "is invalid and potentially unsafe.", error)
     end
 
     relative_pattern.prefix_with(@absolute_path_to_manifests)
   end
 
   def subpath(type)
     File.join(path, type)
   end
 
   def assert_validity
     raise InvalidName, "Invalid module name #{name}; module names must be alphanumeric (plus '-'), not '#{name}'" unless name =~ /^[-\w]+$/
   end
 
   def ==(other)
     self.name == other.name &&
     self.version == other.version &&
     self.path == other.path &&
     self.environment == other.environment
   end
 end
diff --git a/lib/puppet/module_tool.rb b/lib/puppet/module_tool.rb
index 6ab3e9ca2..690aa2f2d 100644
--- a/lib/puppet/module_tool.rb
+++ b/lib/puppet/module_tool.rb
@@ -1,169 +1,171 @@
 # encoding: UTF-8
 # Load standard libraries
 require 'pathname'
 require 'fileutils'
 require 'puppet/util/colors'
 
 module Puppet
   module ModuleTool
     require 'puppet/module_tool/tar'
     extend Puppet::Util::Colors
 
     # Directory and names that should not be checksummed.
     ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage', 'checksums.json', 'REVISION']
     FULL_MODULE_NAME_PATTERN = /\A([^-\/|.]+)[-|\/](.+)\z/
     REPOSITORY_URL = Puppet.settings[:module_repository]
 
     # Is this a directory that shouldn't be checksummed?
     #
     # TODO: Should this be part of Checksums?
     # TODO: Rename this method to reflect its purpose?
     # TODO: Shouldn't this be used when building packages too?
     def self.artifact?(path)
       case File.basename(path)
       when *ARTIFACTS
         true
       else
         false
       end
     end
 
     # Return the +username+ and +modname+ for a given +full_module_name+, or raise an
     # ArgumentError if the argument isn't parseable.
     def self.username_and_modname_from(full_module_name)
       if matcher = full_module_name.match(FULL_MODULE_NAME_PATTERN)
         return matcher.captures
       else
         raise ArgumentError, "Not a valid full name: #{full_module_name}"
       end
     end
 
     # Find the module root when given a path by checking each directory up from
     # its current location until it finds one that contains a file called
     # 'Modulefile'.
     #
     # @param path [Pathname, String] path to start from
     # @return [Pathname, nil] the root path of the module directory or nil if
     #   we cannot find one
     def self.find_module_root(path)
       path = Pathname.new(path) if path.class == String
 
       path.expand_path.ascend do |p|
         return p if is_module_root?(p)
       end
 
       nil
     end
 
     # Analyse path to see if it is a module root directory by detecting a
     # file named 'metadata.json' or 'Modulefile' in the directory.
     #
     # @param path [Pathname, String] path to analyse
     # @return [Boolean] true if the path is a module root, false otherwise
     def self.is_module_root?(path)
       path = Pathname.new(path) if path.class == String
 
       FileTest.file?(path + 'metadata.json') || FileTest.file?(path + 'Modulefile')
     end
 
     # Builds a formatted tree from a list of node hashes containing +:text+
     # and +:dependencies+ keys.
     def self.format_tree(nodes, level = 0)
       str = ''
       nodes.each_with_index do |node, i|
         last_node = nodes.length - 1 == i
         deps = node[:dependencies] || []
 
         str << (indent = "  " * level)
         str << (last_node ? "└" : "├")
         str << "─"
         str << (deps.empty? ? "─" : "┬")
         str << " #{node[:text]}\n"
 
         branch = format_tree(deps, level + 1)
         branch.gsub!(/^#{indent} /, indent + '│') unless last_node
         str << branch
       end
 
       return str
     end
 
     def self.build_tree(mods, dir)
       mods.each do |mod|
         version_string = mod[:version].to_s.sub(/^(?!v)/, 'v')
 
         if mod[:action] == :upgrade
           previous_version = mod[:previous_version].to_s.sub(/^(?!v)/, 'v')
           version_string = "#{previous_version} -> #{version_string}"
         end
 
         mod[:text] = "#{mod[:name]} (#{colorize(:cyan, version_string)})"
         mod[:text] += " [#{mod[:path]}]" unless mod[:path].to_s == dir.to_s
 
         deps = (mod[:dependencies] || [])
         deps.sort! { |a, b| a[:name] <=> b[:name] }
         build_tree(deps, dir)
       end
     end
 
     # @param options [Hash<Symbol,String>] This hash will contain any
     #   command-line arguments that are not Settings, as those will have already
     #   been extracted by the underlying application code.
     #
     # @note Unfortunately the whole point of this method is the side effect of
     # modifying the options parameter.  This same hash is referenced both
     # when_invoked and when_rendering.  For this reason, we are not returning
     # a duplicate.
     # @todo Validate the above note...
     #
     # An :environment_instance and a :target_dir are added/updated in the
     # options parameter.
     #
     # @api private
     def self.set_option_defaults(options)
       current_environment = environment_from_options(options)
 
       modulepath = [options[:target_dir]] + current_environment.full_modulepath
 
       face_environment = current_environment.override_with(:modulepath => modulepath.compact)
 
       options[:environment_instance] = face_environment
 
       # Note: environment will have expanded the path
       options[:target_dir] = face_environment.full_modulepath.first
     end
 
     # Given a hash of options, we should discover or create a
     # {Puppet::Node::Environment} instance that reflects the provided options.
     #
     # Generally speaking, the `:modulepath` parameter should supercede all
     # others, the `:environment` parameter should follow after that, and we
     # should default to Puppet's current environment.
     #
     # @param options [{Symbol => Object}] the options to derive environment from
     # @return [Puppet::Node::Environment] the environment described by the options
     def self.environment_from_options(options)
       if options[:modulepath]
         path = options[:modulepath].split(File::PATH_SEPARATOR)
         Puppet::Node::Environment.create(:anonymous, path, '')
       elsif options[:environment].is_a?(Puppet::Node::Environment)
         options[:environment]
       elsif options[:environment]
+        # This use of looking up an environment is correct since it honours
+        # a reguest to get a particular environment via environment name.
         Puppet.lookup(:environments).get(options[:environment])
       else
         Puppet.lookup(:current_environment)
       end
     end
   end
 end
 
 # Load remaining libraries
 require 'puppet/module_tool/errors'
 require 'puppet/module_tool/applications'
 require 'puppet/module_tool/checksums'
 require 'puppet/module_tool/contents_description'
 require 'puppet/module_tool/dependency'
 require 'puppet/module_tool/metadata'
 require 'puppet/module_tool/modulefile'
 require 'puppet/forge/cache'
 require 'puppet/forge'
diff --git a/lib/puppet/node.rb b/lib/puppet/node.rb
index fbb57b2dd..dcb0869d1 100644
--- a/lib/puppet/node.rb
+++ b/lib/puppet/node.rb
@@ -1,171 +1,175 @@
 require 'puppet/indirector'
 
 # A class for managing nodes, including their facts and environment.
 class Puppet::Node
   require 'puppet/node/facts'
   require 'puppet/node/environment'
 
   # Set up indirection, so that nodes can be looked for in
   # the node sources.
   extend Puppet::Indirector
 
   # Use the node source as the indirection terminus.
   indirects :node, :terminus_setting => :node_terminus, :doc => "Where to find node information.
     A node is composed of its name, its facts, and its environment."
 
   attr_accessor :name, :classes, :source, :ipaddress, :parameters, :trusted_data
   attr_reader :time, :facts
 
   ::PSON.register_document_type('Node',self)
 
   def self.from_data_hash(data)
     raise ArgumentError, "No name provided in serialized data" unless name = data['name']
 
     node = new(name)
     node.classes = data['classes']
     node.parameters = data['parameters']
     node.environment = data['environment']
     node
   end
 
   def self.from_pson(pson)
     Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
     self.from_data_hash(pson)
   end
 
   def to_data_hash
     result = {
       'name' => name,
       'environment' => environment.name,
     }
     result['classes'] = classes unless classes.empty?
     result['parameters'] = parameters unless parameters.empty?
     result
   end
 
   def to_pson_data_hash(*args)
     {
       'document_type' => "Node",
       'data' =>  to_data_hash,
     }
   end
 
   def to_pson(*args)
     to_pson_data_hash.to_pson(*args)
   end
 
   def environment
     if @environment
       @environment
     elsif env = parameters["environment"]
       self.environment = env
       @environment
     else
+      # This should not be :current_environment, this is the default
+      # for a node when it has not specified its environment
+      # Tt will be used to establish what the current environment is.
+      #
       Puppet.lookup(:environments).get(Puppet[:environment])
     end
   end
 
   def environment=(env)
     if env.is_a?(String) or env.is_a?(Symbol)
       @environment = Puppet.lookup(:environments).get(env)
     else
       @environment = env
     end
   end
 
   def initialize(name, options = {})
     raise ArgumentError, "Node names cannot be nil" unless name
     @name = name
 
     if classes = options[:classes]
       if classes.is_a?(String)
         @classes = [classes]
       else
         @classes = classes
       end
     else
       @classes = []
     end
 
     @parameters = options[:parameters] || {}
 
     @facts = options[:facts]
 
     if env = options[:environment]
       self.environment = env
     end
 
     @time = Time.now
   end
 
   # Merge the node facts with parameters from the node source.
   def fact_merge
     if @facts = Puppet::Node::Facts.indirection.find(name, :environment => environment)
       @facts.sanitize
       merge(@facts.values)
     end
   rescue => detail
     error = Puppet::Error.new("Could not retrieve facts for #{name}: #{detail}")
     error.set_backtrace(detail.backtrace)
     raise error
   end
 
   # Merge any random parameters into our parameter list.
   def merge(params)
     params.each do |name, value|
       @parameters[name] = value unless @parameters.include?(name)
     end
 
     @parameters["environment"] ||= self.environment.name.to_s
   end
 
   # Calculate the list of names we might use for looking
   # up our node.  This is only used for AST nodes.
   def names
     return [name] if Puppet.settings[:strict_hostname_checking]
 
     names = []
 
     names += split_name(name) if name.include?(".")
 
     # First, get the fqdn
     unless fqdn = parameters["fqdn"]
       if parameters["hostname"] and parameters["domain"]
         fqdn = parameters["hostname"] + "." + parameters["domain"]
       else
         Puppet.warning "Host is missing hostname and/or domain: #{name}"
       end
     end
 
     # Now that we (might) have the fqdn, add each piece to the name
     # list to search, in order of longest to shortest.
     names += split_name(fqdn) if fqdn
 
     # And make sure the node name is first, since that's the most
     # likely usage.
     #   The name is usually the Certificate CN, but it can be
     # set to the 'facter' hostname instead.
     if Puppet[:node_name] == 'cert'
       names.unshift name
     else
       names.unshift parameters["hostname"]
     end
     names.uniq
   end
 
   def split_name(name)
     list = name.split(".")
     tmp = []
     list.each_with_index do |short, i|
       tmp << list[0..i].join(".")
     end
     tmp.reverse
   end
 
   # Ensures the data is frozen
   #
   def trusted_data=(data)
     Puppet.warning("Trusted node data modified for node #{name}") unless @trusted_data.nil?
     @trusted_data = data.freeze
   end
 end
diff --git a/lib/puppet/util/autoload.rb b/lib/puppet/util/autoload.rb
index f8f7c260c..f6d3bdbb8 100644
--- a/lib/puppet/util/autoload.rb
+++ b/lib/puppet/util/autoload.rb
@@ -1,227 +1,227 @@
 require 'pathname'
 require 'puppet/util/rubygems'
 require 'puppet/util/warnings'
 require 'puppet/util/methodhelper'
 
 # Autoload paths, either based on names or all at once.
 class Puppet::Util::Autoload
   include Puppet::Util::MethodHelper
 
   @autoloaders = {}
   @loaded = {}
 
   class << self
     attr_reader :autoloaders
     attr_accessor :loaded
     private :autoloaders, :loaded
 
     def gem_source
       @gem_source ||= Puppet::Util::RubyGems::Source.new
     end
 
     # Has a given path been loaded?  This is used for testing whether a
     # changed file should be loaded or just ignored.  This is only
     # used in network/client/master, when downloading plugins, to
     # see if a given plugin is currently loaded and thus should be
     # reloaded.
     def loaded?(path)
       path = cleanpath(path).chomp('.rb')
       loaded.include?(path)
     end
 
     # Save the fact that a given path has been loaded.  This is so
     # we can load downloaded plugins if they've already been loaded
     # into memory.
     def mark_loaded(name, file)
       name = cleanpath(name).chomp('.rb')
       ruby_file = name + ".rb"
       $LOADED_FEATURES << ruby_file unless $LOADED_FEATURES.include?(ruby_file)
       loaded[name] = [file, File.mtime(file)]
     end
 
     def changed?(name)
       name = cleanpath(name).chomp('.rb')
       return true unless loaded.include?(name)
       file, old_mtime = loaded[name]
-      environment = Puppet.lookup(:environments).get(Puppet[:environment])
+      environment = Puppet.lookup(:current_environment)
       return true unless file == get_file(name, environment)
       begin
         old_mtime.to_i != File.mtime(file).to_i
       rescue Errno::ENOENT
         true
       end
     end
 
     # Load a single plugin by name.  We use 'load' here so we can reload a
     # given plugin.
     def load_file(name, env)
       file = get_file(name.to_s, env)
       return false unless file
       begin
         mark_loaded(name, file)
         Kernel.load file, @wrap
         return true
       rescue SystemExit,NoMemoryError
         raise
       rescue Exception => detail
         message = "Could not autoload #{name}: #{detail}"
         Puppet.log_exception(detail, message)
         raise Puppet::Error, message, detail.backtrace
       end
     end
 
     def loadall(path)
       # Load every instance of everything we can find.
       files_to_load(path).each do |file|
         name = file.chomp(".rb")
         load_file(name, nil) unless loaded?(name)
       end
     end
 
     def reload_changed
       loaded.keys.each { |file| load_file(file, nil) if changed?(file) }
     end
 
     # Get the correct file to load for a given path
     # returns nil if no file is found
     def get_file(name, env)
       name = name + '.rb' unless name =~ /\.rb$/
       path = search_directories(env).find { |dir| Puppet::FileSystem.exist?(File.join(dir, name)) }
       path and File.join(path, name)
     end
 
     def files_to_load(path)
       search_directories(nil).map {|dir| files_in_dir(dir, path) }.flatten.uniq
     end
 
     def files_in_dir(dir, path)
       dir = Pathname.new(File.expand_path(dir))
       Dir.glob(File.join(dir, path, "*.rb")).collect do |file|
         Pathname.new(file).relative_path_from(dir).to_s
       end
     end
 
     def module_directories(env)
       # We're using a per-thread cache of module directories so that we don't
       # scan the filesystem each time we try to load something. This is reset
       # at the beginning of compilation and at the end of an agent run.
       $env_module_directories ||= {}
 
 
       # This is a little bit of a hack.  Basically, the autoloader is being
       # called indirectly during application bootstrapping when we do things
       # such as check "features".  However, during bootstrapping, we haven't
       # yet parsed all of the command line parameters nor the config files,
       # and thus we don't yet know with certainty what the module path is.
       # This should be irrelevant during bootstrapping, because anything that
       # we are attempting to load during bootstrapping should be something
       # that we ship with puppet, and thus the module path is irrelevant.
       #
       # In the long term, I think the way that we want to handle this is to
       # have the autoloader ignore the module path in all cases where it is
       # not specifically requested (e.g., by a constructor param or
       # something)... because there are very few cases where we should
       # actually be loading code from the module path.  However, until that
       # happens, we at least need a way to prevent the autoloader from
       # attempting to access the module path before it is initialized.  For
       # now we are accomplishing that by calling the
       # "app_defaults_initialized?" method on the main puppet Settings object.
       # --cprice 2012-03-16
       if Puppet.settings.app_defaults_initialized?
         env ||= Puppet.lookup(:environments).get(Puppet[:environment])
 
         # if the app defaults have been initialized then it should be safe to access the module path setting.
         $env_module_directories[env] ||= env.modulepath.collect do |dir|
           Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f, "lib") }
         end.flatten.find_all do |d|
           FileTest.directory?(d)
         end
       else
         # if we get here, the app defaults have not been initialized, so we basically use an empty module path.
         []
       end
     end
 
     def libdirs()
       # See the comments in #module_directories above.  Basically, we need to be careful not to try to access the
       # libdir before we know for sure that all of the settings have been initialized (e.g., during bootstrapping).
       if (Puppet.settings.app_defaults_initialized?)
         Puppet[:libdir].split(File::PATH_SEPARATOR)
       else
         []
       end
     end
 
     def gem_directories
       gem_source.directories
     end
 
     def search_directories(env)
       [gem_directories, module_directories(env), libdirs(), $LOAD_PATH].flatten
     end
 
     # Normalize a path. This converts ALT_SEPARATOR to SEPARATOR on Windows
     # and eliminates unnecessary parts of a path.
     def cleanpath(path)
       # There are two cases here because cleanpath does not handle absolute
       # paths correctly on windows (c:\ and c:/ are treated as distinct) but
       # we don't want to convert relative paths to absolute
       if Puppet::Util.absolute_path?(path)
         File.expand_path(path)
       else
         Pathname.new(path).cleanpath.to_s
       end
     end
   end
 
   # Send [] and []= to the @autoloaders hash
   Puppet::Util.classproxy self, :autoloaders, "[]", "[]="
 
   attr_accessor :object, :path, :objwarn, :wrap
 
   def initialize(obj, path, options = {})
     @path = path.to_s
     raise ArgumentError, "Autoload paths cannot be fully qualified" if Puppet::Util.absolute_path?(@path)
     @object = obj
 
     self.class[obj] = self
 
     set_options(options)
 
     @wrap = true unless defined?(@wrap)
   end
 
   def load(name, env = nil)
     self.class.load_file(expand(name), env)
   end
 
   # Load all instances from a path of Autoload.search_directories matching the
   # relative path this Autoloader was initialized with.  For example, if we
   # have created a Puppet::Util::Autoload for Puppet::Type::User with a path of
   # 'puppet/provider/user', the search_directories path will be searched for
   # all ruby files matching puppet/provider/user/*.rb and they will then be
   # loaded from the first directory in the search path providing them.  So
   # earlier entries in the search path may shadow later entries.
   #
   # This uses require, rather than load, so that already-loaded files don't get
   # reloaded unnecessarily.
   def loadall
     self.class.loadall(@path)
   end
 
   def loaded?(name)
     self.class.loaded?(expand(name))
   end
 
   def changed?(name)
     self.class.changed?(expand(name))
   end
 
   def files_to_load
     self.class.files_to_load(@path)
   end
 
   def expand(name)
     ::File.join(@path, name.to_s)
   end
 end
diff --git a/lib/puppet/util/command_line.rb b/lib/puppet/util/command_line.rb
index 35a38f5c3..def593ab5 100644
--- a/lib/puppet/util/command_line.rb
+++ b/lib/puppet/util/command_line.rb
@@ -1,182 +1,188 @@
 # Bundler and rubygems maintain a set of directories from which to
 # load gems. If Bundler is loaded, let it determine what can be
 # loaded. If it's not loaded, then use rubygems. But do this before
 # loading any puppet code, so that our gem loading system is sane.
 if not defined? ::Bundler
   begin
     require 'rubygems'
   rescue LoadError
   end
 end
 
 require 'puppet'
 require 'puppet/util'
 require "puppet/util/plugins"
 require "puppet/util/rubygems"
 require "puppet/util/limits"
 
 module Puppet
   module Util
     # This is the main entry point for all puppet applications / faces; it
     # is basically where the bootstrapping process / lifecycle of an app
     # begins.
     class CommandLine
       include Puppet::Util::Limits
 
       OPTION_OR_MANIFEST_FILE = /^-|\.pp$|\.rb$/
 
       # @param zero [String] the name of the executable
       # @param argv [Array<String>] the arguments passed on the command line
       # @param stdin [IO] (unused)
       def initialize(zero = $0, argv = ARGV, stdin = STDIN)
         @command = File.basename(zero, '.rb')
         @argv = argv
         Puppet::Plugins.on_commandline_initialization(:command_line_object => self)
       end
 
       # @return [String] name of the subcommand is being executed
       # @api public
       def subcommand_name
         return @command if @command != 'puppet'
 
         if @argv.first =~ OPTION_OR_MANIFEST_FILE
           nil
         else
           @argv.first
         end
       end
 
       # @return [Array<String>] the command line arguments being passed to the subcommand
       # @api public
       def args
         return @argv if @command != 'puppet'
 
         if subcommand_name.nil?
           @argv
         else
           @argv[1..-1]
         end
       end
 
       # @api private
       # @deprecated
       def self.available_subcommands
         Puppet.deprecation_warning('Puppet::Util::CommandLine.available_subcommands is deprecated; please use Puppet::Application.available_application_names instead.')
         Puppet::Application.available_application_names
       end
 
       # available_subcommands was previously an instance method, not a class
       # method, and we have an unknown number of user-implemented applications
       # that depend on that behaviour.  Forwarding allows us to preserve a
       # backward compatible API. --daniel 2011-04-11
       # @api private
       # @deprecated
       def available_subcommands
         Puppet.deprecation_warning('Puppet::Util::CommandLine#available_subcommands is deprecated; please use Puppet::Application.available_application_names instead.')
         Puppet::Application.available_application_names
       end
 
       # Run the puppet subcommand. If the subcommand is determined to be an
       # external executable, this method will never return and the current
       # process will be replaced via {Kernel#exec}.
       #
       # @return [void]
       def execute
         Puppet::Util.exit_on_fail("initialize global default settings") do
           Puppet.initialize_settings(args)
         end
 
         setpriority(Puppet[:priority])
 
         find_subcommand.run
       end
 
       # @api private
       def external_subcommand
         Puppet::Util.which("puppet-#{subcommand_name}")
       end
 
       private
 
       def find_subcommand
         if subcommand_name.nil?
           NilSubcommand.new(self)
         elsif Puppet::Application.available_application_names.include?(subcommand_name)
           ApplicationSubcommand.new(subcommand_name, self)
         elsif path_to_subcommand = external_subcommand
           ExternalSubcommand.new(path_to_subcommand, self)
         else
           UnknownSubcommand.new(subcommand_name, self)
         end
       end
 
       # @api private
       class ApplicationSubcommand
         def initialize(subcommand_name, command_line)
           @subcommand_name = subcommand_name
           @command_line = command_line
         end
 
         def run
           # For most applications, we want to be able to load code from the modulepath,
           # such as apply, describe, resource, and faces.
           # For agent, we only want to load pluginsync'ed code from libdir.
           # For master, we shouldn't ever be loading per-enviroment code into the master's
           # ruby process, but that requires fixing (#17210, #12173, #8750). So for now
           # we try to restrict to only code that can be autoloaded from the node's
           # environment.
+
+          # PUP-2114 - is the current implementation the correct one?
+          #   Where is current_environment established? Do other applications override this?
+          #   or is this the place that all commands get their "curent environment from" ?
+          #   Or... is this only used to find the commands?
+          #
           if @subcommand_name != 'master' and @subcommand_name != 'agent'
             Puppet.lookup(:environments).get(Puppet[:environment]).each_plugin_directory do |dir|
               $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
             end
           end
 
           app = Puppet::Application.find(@subcommand_name).new(@command_line)
           Puppet::Plugins.on_application_initialization(:application_object => @command_line)
 
           app.run
         end
       end
 
       # @api private
       class ExternalSubcommand
         def initialize(path_to_subcommand, command_line)
           @path_to_subcommand = path_to_subcommand
           @command_line = command_line
         end
 
         def run
           Kernel.exec(@path_to_subcommand, *@command_line.args)
         end
       end
 
       # @api private
       class NilSubcommand
         def initialize(command_line)
           @command_line = command_line
         end
 
         def run
           if @command_line.args.include? "--version" or @command_line.args.include? "-V"
             puts Puppet.version
           else
             puts "See 'puppet help' for help on available puppet subcommands"
           end
         end
       end
 
       # @api private
       class UnknownSubcommand < NilSubcommand
         def initialize(subcommand_name, command_line)
           @subcommand_name = subcommand_name
           super(command_line)
         end
 
         def run
           puts "Error: Unknown Puppet subcommand '#{@subcommand_name}'"
           super
         end
       end
     end
   end
 end
diff --git a/lib/puppet/util/rdoc.rb b/lib/puppet/util/rdoc.rb
index 9119784e7..5921ef6cc 100644
--- a/lib/puppet/util/rdoc.rb
+++ b/lib/puppet/util/rdoc.rb
@@ -1,89 +1,89 @@
 require 'puppet/util'
 module Puppet::Util::RDoc
   module_function
 
   # launch a rdoc documenation process
   # with the files/dir passed in +files+
   def rdoc(outputdir, files, charset = nil)
     Puppet[:ignoreimport] = true
 
     # then rdoc
     require 'rdoc/rdoc'
     require 'rdoc/options'
 
     # load our parser
     require 'puppet/util/rdoc/parser'
 
     r = RDoc::RDoc.new
 
     if Puppet.features.rdoc1?
       RDoc::RDoc::GENERATORS["puppet"] = RDoc::RDoc::Generator.new(
           "puppet/util/rdoc/generators/puppet_generator.rb",
           :PuppetGenerator,
           "puppet"
         )
     end
 
     # specify our own format & where to output
     options = [ "--fmt", "puppet",
                 "--quiet",
                 "--exclude", "/modules/[^/]*/spec/.*$",
                 "--exclude", "/modules/[^/]*/files/.*$",
                 "--exclude", "/modules/[^/]*/tests/.*$",
                 "--exclude", "/modules/[^/]*/templates/.*$",
                 "--op", outputdir ]
 
     if !Puppet.features.rdoc1? || ::Options::OptionList.options.any? { |o| o[0] == "--force-update" } # Options is a root object in the rdoc1 namespace...
       options << "--force-update"
     end
     options += [ "--charset", charset] if charset
     options += files
 
     # launch the documentation process
     r.document(options)
   end
 
   # launch an output to console manifest doc
   def manifestdoc(files)
     Puppet[:ignoreimport] = true
     files.select { |f| FileTest.file?(f) }.each do |f|
-      parser = Puppet::Parser::Parser.new(Puppet.lookup(:environments).get(Puppet[:environment]))
+      parser = Puppet::Parser::Parser.new(Puppet.lookup(:current_environment))
       parser.file = f
       ast = parser.parse
       output(f, ast)
     end
   end
 
   # Ouputs to the console the documentation
   # of a manifest
   def output(file, ast)
     astobj = []
     ast.instantiate('').each do |resource_type|
       astobj << resource_type if resource_type.file == file
     end
 
     astobj.sort! {|a,b| a.line <=> b.line }.each do |k|
       output_astnode_doc(k)
     end
   end
 
   def output_astnode_doc(ast)
     puts ast.doc if !ast.doc.nil? and !ast.doc.empty?
     if Puppet.settings[:document_all]
       # scan each underlying resources to produce documentation
       code = ast.code.children if ast.code.is_a?(Puppet::Parser::AST::ASTArray)
       code ||= ast.code
       output_resource_doc(code) unless code.nil?
     end
   end
 
   def output_resource_doc(code)
     code.sort { |a,b| a.line <=> b.line }.each do |stmt|
       output_resource_doc(stmt.children) if stmt.is_a?(Puppet::Parser::AST::ASTArray)
 
       if stmt.is_a?(Puppet::Parser::AST::Resource)
         puts stmt.doc if !stmt.doc.nil? and !stmt.doc.empty?
       end
     end
   end
 end
diff --git a/lib/puppet/util/rdoc/parser/puppet_parser_core.rb b/lib/puppet/util/rdoc/parser/puppet_parser_core.rb
index baff91e98..4d29cc127 100644
--- a/lib/puppet/util/rdoc/parser/puppet_parser_core.rb
+++ b/lib/puppet/util/rdoc/parser/puppet_parser_core.rb
@@ -1,477 +1,477 @@
 # Functionality common to both our RDoc version 1 and 2 parsers.
 module RDoc::PuppetParserCore
 
   SITE = "__site__"
 
   def self.included(base)
     base.class_eval do
       attr_accessor :input_file_name, :top_level
 
       # parser registration into RDoc
       parse_files_matching(/\.(rb|pp)$/)
     end
   end
 
   # called with the top level file
   def initialize(top_level, file_name, body, options, stats)
     @options = options
     @stats   = stats
     @input_file_name = file_name
     @top_level = top_level
     @top_level.extend(RDoc::PuppetTopLevel)
     @progress = $stderr unless options.quiet
   end
 
   # main entry point
   def scan
-    environment = Puppet.lookup(:environments).get(Puppet[:environment])
+    environment = Puppet.lookup(:current_environment)
     known_resource_types = environment.known_resource_types
     unless known_resource_types.watching_file?(@input_file_name)
       Puppet.info "rdoc: scanning #{@input_file_name}"
       if @input_file_name =~ /\.pp$/
         @parser = Puppet::Parser::Parser.new(environment)
         @parser.file = @input_file_name
         @parser.parse.instantiate('').each do |type|
           known_resource_types.add type
         end
       end
     end
 
     scan_top_level(@top_level, environment)
     @top_level
   end
 
   # Due to a bug in RDoc, we need to roll our own find_module_named
   # The issue is that RDoc tries harder by asking the parent for a class/module
   # of the name. But by doing so, it can mistakenly use a module of same name
   # but from which we are not descendant.
   def find_object_named(container, name)
     return container if container.name == name
     container.each_classmodule do |m|
       return m if m.name == name
     end
     nil
   end
 
   # walk down the namespace and lookup/create container as needed
   def get_class_or_module(container, name)
 
     # class ::A -> A is in the top level
     if name =~ /^::/
       container = @top_level
     end
 
     names = name.split('::')
 
     final_name = names.pop
     names.each do |name|
       prev_container = container
       container = find_object_named(container, name)
       container ||= prev_container.add_class(RDoc::PuppetClass, name, nil)
     end
     [container, final_name]
   end
 
   # split_module tries to find if +path+ belongs to the module path
   # if it does, it returns the module name, otherwise if we are sure
   # it is part of the global manifest path, "__site__" is returned.
   # And finally if this path couldn't be mapped anywhere, nil is returned.
   def split_module(path, environment)
     # find a module
     fullpath = File.expand_path(path)
     Puppet.debug "rdoc: testing #{fullpath}"
     if fullpath =~ /(.*)\/([^\/]+)\/(?:manifests|plugins|lib)\/.+\.(pp|rb)$/
       modpath = $1
       name = $2
       Puppet.debug "rdoc: module #{name} into #{modpath} ?"
       environment.modulepath.each do |mp|
         if File.identical?(modpath,mp)
           Puppet.debug "rdoc: found module #{name}"
           return name
         end
       end
     end
     if fullpath =~ /\.(pp|rb)$/
       # there can be paths we don't want to scan under modules
       # imagine a ruby or manifest that would be distributed as part as a module
       # but we don't want those to be hosted under <site>
       environment.modulepath.each do |mp|
         # check that fullpath is a descendant of mp
         dirname = fullpath
         previous = dirname
         while (dirname = File.dirname(previous)) != previous
           previous = dirname
           return nil if File.identical?(dirname,mp)
         end
       end
     end
     # we are under a global manifests
     Puppet.debug "rdoc: global manifests"
     SITE
   end
 
   # create documentation for the top level +container+
   def scan_top_level(container, environment)
     # use the module README as documentation for the module
     comment = ""
     %w{README README.rdoc}.each do |rfile|
       readme = File.join(File.dirname(File.dirname(@input_file_name)), rfile)
       comment = File.open(readme,"r") { |f| f.read } if FileTest.readable?(readme)
     end
     look_for_directives_in(container, comment) unless comment.empty?
 
     # infer module name from directory
     name = split_module(@input_file_name, environment)
     if name.nil?
       # skip .pp files that are not in manifests directories as we can't guarantee they're part
       # of a module or the global configuration.
       container.document_self = false
       return
     end
 
     Puppet.debug "rdoc: scanning for #{name}"
 
     container.module_name = name
     container.global=true if name == SITE
 
     container, name  = get_class_or_module(container,name)
     mod = container.add_module(RDoc::PuppetModule, name)
     mod.record_location(@top_level)
     mod.add_comment(comment, @input_file_name)
 
     if @input_file_name =~ /\.pp$/
       parse_elements(mod, environment.known_resource_types)
     elsif @input_file_name =~ /\.rb$/
       parse_plugins(mod)
     end
   end
 
   # create documentation for include statements we can find in +code+
   # and associate it with +container+
   def scan_for_include_or_require(container, code)
     code = [code] unless code.is_a?(Array)
     code.each do |stmt|
       scan_for_include_or_require(container,stmt.children) if stmt.is_a?(Puppet::Parser::AST::BlockExpression)
 
       if stmt.is_a?(Puppet::Parser::AST::Function) and ['include','require'].include?(stmt.name)
         stmt.arguments.each do |included|
           Puppet.debug "found #{stmt.name}: #{included}"
           container.send("add_#{stmt.name}", RDoc::Include.new(included.to_s, stmt.doc))
         end
       end
     end
   end
 
   # create documentation for realize statements we can find in +code+
   # and associate it with +container+
   def scan_for_realize(container, code)
     code = [code] unless code.is_a?(Array)
     code.each do |stmt|
       scan_for_realize(container,stmt.children) if stmt.is_a?(Puppet::Parser::AST::BlockExpression)
 
       if stmt.is_a?(Puppet::Parser::AST::Function) and stmt.name == 'realize'
         stmt.arguments.each do |realized|
           Puppet.debug "found #{stmt.name}: #{realized}"
           container.add_realize( RDoc::Include.new(realized.to_s, stmt.doc))
         end
       end
     end
   end
 
   # create documentation for global variables assignements we can find in +code+
   # and associate it with +container+
   def scan_for_vardef(container, code)
     code = [code] unless code.is_a?(Array)
     code.each do |stmt|
       scan_for_vardef(container,stmt.children) if stmt.is_a?(Puppet::Parser::AST::BlockExpression)
 
       if stmt.is_a?(Puppet::Parser::AST::VarDef)
         Puppet.debug "rdoc: found constant: #{stmt.name} = #{stmt.value}"
         container.add_constant(RDoc::Constant.new(stmt.name.to_s, stmt.value.to_s, stmt.doc))
       end
     end
   end
 
   # create documentation for resources we can find in +code+
   # and associate it with +container+
   def scan_for_resource(container, code)
     code = [code] unless code.is_a?(Array)
     code.each do |stmt|
       scan_for_resource(container,stmt.children) if stmt.is_a?(Puppet::Parser::AST::BlockExpression)
 
       if stmt.is_a?(Puppet::Parser::AST::Resource) and !stmt.type.nil?
         begin
           type = stmt.type.split("::").collect { |s| s.capitalize }.join("::")
           stmt.instances.each do |inst|
             title = inst.title.is_a?(Puppet::Parser::AST::ASTArray) ? inst.title.to_s.gsub(/\[(.*)\]/,'\1') : inst.title.to_s
             Puppet.debug "rdoc: found resource: #{type}[#{title}]"
 
             param = []
             inst.parameters.children.each do |p|
               res = {}
               res["name"] = p.param
               res["value"] = "#{p.value.to_s}" unless p.value.nil?
 
               param << res
             end
 
             container.add_resource(RDoc::PuppetResource.new(type, title, stmt.doc, param))
           end
         rescue => detail
           raise Puppet::ParseError, "impossible to parse resource in #{stmt.file} at line #{stmt.line}: #{detail}", detail.backtrace
         end
       end
     end
   end
 
   # create documentation for a class named +name+
   def document_class(name, klass, container)
     Puppet.debug "rdoc: found new class #{name}"
     container, name = get_class_or_module(container, name)
 
     superclass = klass.parent
     superclass = "" if superclass.nil? or superclass.empty?
 
     comment = klass.doc
     look_for_directives_in(container, comment) unless comment.empty?
     cls = container.add_class(RDoc::PuppetClass, name, superclass)
     # it is possible we already encountered this class, while parsing some namespaces
     # from other classes of other files. But at that time we couldn't know this class superclass
     # so, now we know it and force it.
     cls.superclass = superclass
     cls.record_location(@top_level)
 
     # scan class code for include
     code = klass.code.children if klass.code.is_a?(Puppet::Parser::AST::BlockExpression)
     code ||= klass.code
     unless code.nil?
       scan_for_include_or_require(cls, code)
       scan_for_realize(cls, code)
       scan_for_resource(cls, code) if Puppet.settings[:document_all]
     end
 
     cls.add_comment(comment, klass.file)
   rescue => detail
     raise Puppet::ParseError, "impossible to parse class '#{name}' in #{klass.file} at line #{klass.line}: #{detail}", detail.backtrace
   end
 
   # create documentation for a node
   def document_node(name, node, container)
     Puppet.debug "rdoc: found new node #{name}"
     superclass = node.parent
     superclass = "" if superclass.nil? or superclass.empty?
 
     comment = node.doc
     look_for_directives_in(container, comment) unless comment.empty?
     n = container.add_node(name, superclass)
     n.record_location(@top_level)
 
     code = node.code.children if node.code.is_a?(Puppet::Parser::AST::BlockExpression)
     code ||= node.code
     unless code.nil?
       scan_for_include_or_require(n, code)
       scan_for_realize(n, code)
       scan_for_vardef(n, code)
       scan_for_resource(n, code) if Puppet.settings[:document_all]
     end
 
     n.add_comment(comment, node.file)
   rescue => detail
     raise Puppet::ParseError, "impossible to parse node '#{name}' in #{node.file} at line #{node.line}: #{detail}", detail.backtrace
   end
 
   # create documentation for a define
   def document_define(name, define, container)
     Puppet.debug "rdoc: found new definition #{name}"
     # find superclas if any
 
     # find the parent
     # split define name by :: to find the complete module hierarchy
     container, name = get_class_or_module(container,name)
 
     # build up declaration
     declaration = ""
     define.arguments.each do |arg,value|
       declaration << "\$#{arg}"
       unless value.nil?
         declaration << " => "
         case value
         when Puppet::Parser::AST::Leaf
           declaration << "'#{value.value}'"
         when Puppet::Parser::AST::BlockExpression
           declaration << "[#{value.children.collect { |v| "'#{v}'" }.join(", ")}]"
         else
           declaration << "#{value.to_s}"
         end
       end
       declaration << ", "
     end
     declaration.chop!.chop! if declaration.size > 1
 
     # register method into the container
     meth =  RDoc::AnyMethod.new(declaration, name)
     meth.comment = define.doc
     container.add_method(meth)
     look_for_directives_in(container, meth.comment) unless meth.comment.empty?
     meth.params = "( #{declaration} )"
     meth.visibility = :public
     meth.document_self = true
     meth.singleton = false
   rescue => detail
     raise Puppet::ParseError, "impossible to parse definition '#{name}' in #{define.file} at line #{define.line}: #{detail}", detail.backtrace
   end
 
   # Traverse the AST tree and produce code-objects node
   # that contains the documentation
   def parse_elements(container, known_resource_types)
     Puppet.debug "rdoc: scanning manifest"
 
     known_resource_types.hostclasses.values.sort { |a,b| a.name <=> b.name }.each do |klass|
       name = klass.name
       if klass.file == @input_file_name
         unless name.empty?
           document_class(name,klass,container)
         else # on main class document vardefs
           code = klass.code.children if klass.code.is_a?(Puppet::Parser::AST::BlockExpression)
           code ||= klass.code
           scan_for_vardef(container, code) unless code.nil?
         end
       end
     end
 
     known_resource_types.definitions.each do |name, define|
       if define.file == @input_file_name
         document_define(name,define,container)
       end
     end
 
     known_resource_types.nodes.each do |name, node|
       if node.file == @input_file_name
         document_node(name.to_s,node,container)
       end
     end
   end
 
   # create documentation for plugins
   def parse_plugins(container)
     Puppet.debug "rdoc: scanning plugin or fact"
     if @input_file_name =~ /\/facter\/[^\/]+\.rb$/
       parse_fact(container)
     else
       parse_puppet_plugin(container)
     end
   end
 
   # this is a poor man custom fact parser :-)
   def parse_fact(container)
     comments = ""
     current_fact = nil
     parsed_facts = []
     File.open(@input_file_name) do |of|
       of.each do |line|
         # fetch comments
         if line =~ /^[ \t]*# ?(.*)$/
           comments += $1 + "\n"
         elsif line =~ /^[ \t]*Facter.add\(['"](.*?)['"]\)/
           current_fact = RDoc::Fact.new($1,{})
           look_for_directives_in(container, comments) unless comments.empty?
           current_fact.comment = comments
           parsed_facts << current_fact
           comments = ""
           Puppet.debug "rdoc: found custom fact #{current_fact.name}"
         elsif line =~ /^[ \t]*confine[ \t]*:(.*?)[ \t]*=>[ \t]*(.*)$/
           current_fact.confine = { :type => $1, :value => $2 } unless current_fact.nil?
         else # unknown line type
           comments =""
         end
       end
     end
     parsed_facts.each do |f|
       container.add_fact(f)
       f.record_location(@top_level)
     end
   end
 
   # this is a poor man puppet plugin parser :-)
   # it doesn't extract doc nor desc :-(
   def parse_puppet_plugin(container)
     comments = ""
     current_plugin = nil
 
     File.open(@input_file_name) do |of|
       of.each do |line|
         # fetch comments
         if line =~ /^[ \t]*# ?(.*)$/
           comments += $1 + "\n"
         elsif line =~ /^[ \t]*(?:Puppet::Parser::Functions::)?newfunction[ \t]*\([ \t]*:(.*?)[ \t]*,[ \t]*:type[ \t]*=>[ \t]*(:rvalue|:lvalue)/
           current_plugin = RDoc::Plugin.new($1, "function")
           look_for_directives_in(container, comments) unless comments.empty?
           current_plugin.comment = comments
           current_plugin.record_location(@top_level)
           container.add_plugin(current_plugin)
           comments = ""
           Puppet.debug "rdoc: found new function plugins #{current_plugin.name}"
         elsif line =~ /^[ \t]*Puppet::Type.newtype[ \t]*\([ \t]*:(.*?)\)/
           current_plugin = RDoc::Plugin.new($1, "type")
           look_for_directives_in(container, comments) unless comments.empty?
           current_plugin.comment = comments
           current_plugin.record_location(@top_level)
           container.add_plugin(current_plugin)
           comments = ""
           Puppet.debug "rdoc: found new type plugins #{current_plugin.name}"
         elsif line =~ /module Puppet::Parser::Functions/
           # skip
         else # unknown line type
           comments =""
         end
       end
     end
   end
 
   # New instance of the appropriate PreProcess for our RDoc version.
   def create_rdoc_preprocess
     raise(NotImplementedError, "This method must be overwritten for whichever version of RDoc this parser is working with")
   end
 
   # look_for_directives_in scans the current +comment+ for RDoc directives
   def look_for_directives_in(context, comment)
     preprocess = create_rdoc_preprocess
 
     preprocess.handle(comment) do |directive, param|
       case directive
       when "stopdoc"
         context.stop_doc
         ""
       when "startdoc"
         context.start_doc
         context.force_documentation = true
         ""
       when "enddoc"
         #context.done_documenting = true
         #""
         throw :enddoc
       when "main"
         options = Options.instance
         options.main_page = param
         ""
       when "title"
         options = Options.instance
         options.title = param
         ""
       when "section"
         context.set_current_section(param, comment)
         comment.replace("") # 1.8 doesn't support #clear
         break
       else
         warn "Unrecognized directive '#{directive}'"
         break
       end
     end
     remove_private_comments(comment)
   end
 
   def remove_private_comments(comment)
     comment.gsub!(/^#--.*?^#\+\+/m, '')
     comment.sub!(/^#--.*/m, '')
   end
 end
diff --git a/spec/integration/application/doc_spec.rb b/spec/integration/application/doc_spec.rb
index 77fc38625..040dde72d 100755
--- a/spec/integration/application/doc_spec.rb
+++ b/spec/integration/application/doc_spec.rb
@@ -1,56 +1,57 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet/application/doc'
 
 describe Puppet::Application::Doc do
   include PuppetSpec::Files
 
   it "should not generate an error when module dir overlaps parent of site.pp (#4798)",
      :if => (Puppet.features.rdoc1? and not Puppet.features.microsoft_windows?) do
     begin
       # Note: the directory structure below is more complex than it
       # needs to be, but it's representative of the directory structure
       # used in bug #4798.
       old_dir = Dir.getwd # Note: can't use chdir with a block because it will generate bogus warnings
       tmpdir = tmpfile('doc_spec')
       Dir.mkdir(tmpdir)
       Dir.chdir(tmpdir)
       site_file = 'site.pp'
       File.open(site_file, 'w') do |f|
         f.puts '# A comment'
       end
       modules_dir = 'modules'
       Dir.mkdir(modules_dir)
       rt_dir = File.join(modules_dir, 'rt')
       Dir.mkdir(rt_dir)
       manifests_dir = File.join(rt_dir, 'manifests')
       Dir.mkdir(manifests_dir)
       rt_file = File.join(manifests_dir, 'rt.pp')
       File.open(rt_file, 'w') do |f|
         f.puts '# A class'
         f.puts 'class foo { }'
         f.puts '# A definition'
         f.puts 'define bar { }'
       end
 
       puppet = Puppet::Application[:doc]
-      Puppet[:modulepath] = modules_dir
-      Puppet[:manifest] = site_file
       puppet.options[:mode] = :rdoc
 
-      expect { puppet.run_command }.to exit_with 0
+      env = Puppet::Node::Environment.create(:rdoc, [modules_dir], site_file) 
+      Puppet.override(:current_environment =>  env) do
+        expect { puppet.run_command }.to exit_with 0
+      end
 
       Puppet::FileSystem.exist?('doc').should be_true
     ensure
       Dir.chdir(old_dir)
     end
   end
 
   it "should respect the -o option" do
     puppetdoc = Puppet::Application[:doc]
     puppetdoc.command_line.stubs(:args).returns(['foo', '-o', 'bar'])
     puppetdoc.parse_options
     puppetdoc.options[:outputdir].should == 'bar'
   end
 end
diff --git a/spec/integration/util/rdoc/parser_spec.rb b/spec/integration/util/rdoc/parser_spec.rb
index d3bbef45c..2fdaf8019 100755
--- a/spec/integration/util/rdoc/parser_spec.rb
+++ b/spec/integration/util/rdoc/parser_spec.rb
@@ -1,261 +1,268 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/rdoc'
 
 describe "RDoc::Parser" do
   require 'puppet_spec/files'
   include PuppetSpec::Files
 
   let(:document_all) { false }
   let(:tmp_dir) { tmpdir('rdoc_parser_tmp') }
   let(:doc_dir) { File.join(tmp_dir, 'doc') }
   let(:manifests_dir) { File.join(tmp_dir, 'manifests') }
   let(:modules_dir) { File.join(tmp_dir, 'modules') }
 
   let(:modules_and_manifests) do
     {
       :site => [
         File.join(manifests_dir, 'site.pp'),
         <<-EOF
 # The test class comment
 class test {
   # The virtual resource comment
   @notify { virtual: }
   # The a_notify_resource comment
   notify { a_notify_resource:
     message => "a_notify_resource message"
   }
 }
 
 # The includes_another class comment
 class includes_another {
   include another
 }
 
 # The requires_another class comment
 class requires_another {
   require another
 }
 
 # node comment
 node foo {
   include test
   $a_var = "var_value"
   realize Notify[virtual]
   notify { bar: }
 }
         EOF
       ],
       :module_readme => [
         File.join(modules_dir, 'a_module', 'README'),
         <<-EOF
 The a_module README docs.
         EOF
       ],
       :module_init => [
         File.join(modules_dir, 'a_module', 'manifests', 'init.pp'),
         <<-EOF
 # The a_module class comment
 class a_module {}
 
 class another {}
         EOF
       ],
       :module_type => [
         File.join(modules_dir, 'a_module', 'manifests', 'a_type.pp'),
         <<-EOF
 # The a_type type comment
 define a_module::a_type() {}
         EOF
       ],
       :module_plugin => [
         File.join(modules_dir, 'a_module', 'lib', 'puppet', 'type', 'a_plugin.rb'),
         <<-EOF
 # The a_plugin type comment
 Puppet::Type.newtype(:a_plugin) do
   @doc = "Not presented"
 end
         EOF
       ],
       :module_function => [
         File.join(modules_dir, 'a_module', 'lib', 'puppet', 'parser', 'a_function.rb'),
         <<-EOF
 # The a_function function comment
 module Puppet::Parser::Functions
   newfunction(:a_function, :type => :rvalue) do
     return
   end
 end
         EOF
       ],
       :module_fact => [
         File.join(modules_dir, 'a_module', 'lib', 'facter', 'a_fact.rb'),
         <<-EOF
 # The a_fact fact comment
 Facter.add("a_fact") do
 end
         EOF
       ],
     }
   end
 
   def write_file(file, content)
     FileUtils.mkdir_p(File.dirname(file))
     File.open(file, 'w') do |f|
       f.puts(content)
     end
   end
 
   def prepare_manifests_and_modules
     modules_and_manifests.each do |key,array|
       write_file(*array)
     end
   end
 
   def file_exists_and_matches_content(file, *content_patterns)
     Puppet::FileSystem.exist?(file).should(be_true, "Cannot find #{file}")
     content_patterns.each do |pattern|
       content = File.read(file)
       content.should match(pattern)
     end
   end
 
   def some_file_exists_with_matching_content(glob, *content_patterns)
     Dir.glob(glob).select do |f|
       contents = File.read(f)
       content_patterns.all? { |p| p.match(contents) }
     end.should_not(be_empty, "Could not match #{content_patterns} in any of the files found in #{glob}")
   end
 
+  around(:each) do |example|
+    env = Puppet::Node::Environment.create(:doc_test_env, [modules_dir], manifests_dir)
+    Puppet.override({:environments => Puppet::Environments::Static.new(env), :current_environment => env}) do
+      example.run
+    end
+  end
+
   before :each do
     prepare_manifests_and_modules
     Puppet.settings[:document_all] = document_all
     Puppet.settings[:modulepath] = modules_dir
     Puppet::Util::RDoc.rdoc(doc_dir, [modules_dir, manifests_dir])
   end
 
   module RdocTesters
     def has_module_rdoc(module_name, *other_test_patterns)
       file_exists_and_matches_content(module_path(module_name), /Module:? +#{module_name}/i, *other_test_patterns)
     end
 
     def has_node_rdoc(module_name, node_name, *other_test_patterns)
       file_exists_and_matches_content(node_path(module_name, node_name), /#{node_name}/, /node comment/, *other_test_patterns)
     end
 
     def has_defined_type(module_name, type_name)
       file_exists_and_matches_content(module_path(module_name), /#{type_name}.*?\(\s*\)/m, "The .*?#{type_name}.*? type comment")
     end
 
     def has_class_rdoc(module_name, class_name, *other_test_patterns)
       file_exists_and_matches_content(class_path(module_name, class_name), /#{class_name}.*? class comment/, *other_test_patterns)
     end
 
     def has_plugin_rdoc(module_name, type, name)
       file_exists_and_matches_content(plugin_path(module_name, type, name), /The .*?#{name}.*?\s*#{type} comment/m, /Type.*?#{type}/m)
     end
   end
 
   shared_examples_for :an_rdoc_site do
     it "documents the __site__ module" do
       has_module_rdoc("__site__")
     end
 
     it "documents the __site__::test class" do
       has_class_rdoc("__site__", "test")
     end
 
     it "documents the __site__::foo node" do
       has_node_rdoc("__site__", "foo")
     end
 
     it "documents the a_module module" do
       has_module_rdoc("a_module", /The .*?a_module.*? .*?README.*?docs/m)
     end
 
     it "documents the a_module::a_module class" do
       has_class_rdoc("a_module", "a_module")
     end
 
     it "documents the a_module::a_type defined type" do
       has_defined_type("a_module", "a_type")
     end
 
     it "documents the a_module::a_plugin type" do
       has_plugin_rdoc("a_module", :type, 'a_plugin')
     end
 
     it "documents the a_module::a_function function" do
       has_plugin_rdoc("a_module", :function, 'a_function')
     end
 
     it "documents the a_module::a_fact fact" do
       has_plugin_rdoc("a_module", :fact, 'a_fact')
     end
 
     it "documents included classes" do
       has_class_rdoc("__site__", "includes_another", /Included.*?another/m)
     end
   end
 
   shared_examples_for :an_rdoc1_site do
     it "documents required classes" do
       has_class_rdoc("__site__", "requires_another", /Required Classes.*?another/m)
     end
 
     it "documents realized resources" do
       has_node_rdoc("__site__", "foo", /Realized Resources.*?Notify\[virtual\]/m)
     end
 
     it "documents global variables" do
       has_node_rdoc("__site__", "foo", /Global Variables.*?a_var.*?=.*?var_value/m)
     end
 
     describe "when document_all is true" do
       let(:document_all) { true }
 
       it "documents virtual resource declarations" do
         has_class_rdoc("__site__", "test", /Resources.*?Notify\[virtual\]/m, /The virtual resource comment/)
       end
 
       it "documents resources" do
         has_class_rdoc("__site__", "test", /Resources.*?Notify\[a_notify_resource\]/m, /message => "a_notify_resource message"/, /The a_notify_resource comment/)
       end
     end
   end
 
   describe "rdoc1 support", :if => Puppet.features.rdoc1? do
     def module_path(module_name); "#{doc_dir}/classes/#{module_name}.html" end
     def node_path(module_name, node_name);  "#{doc_dir}/nodes/**/*.html" end
     def class_path(module_name, class_name); "#{doc_dir}/classes/#{module_name}/#{class_name}.html" end
     def plugin_path(module_name, type, name); "#{doc_dir}/plugins/#{name}.html" end
 
     include RdocTesters
 
     def has_node_rdoc(module_name, node_name, *other_test_patterns)
       some_file_exists_with_matching_content(node_path(module_name, node_name), /#{node_name}/, /node comment/, *other_test_patterns)
     end
 
     it_behaves_like :an_rdoc_site
     it_behaves_like :an_rdoc1_site
 
     it "references nodes and classes in the __site__ module" do
       file_exists_and_matches_content("#{doc_dir}/classes/__site__.html", /Node.*__site__::foo/, /Class.*__site__::test/)
     end
 
     it "references functions, facts, and type plugins in the a_module module" do
       file_exists_and_matches_content("#{doc_dir}/classes/a_module.html", /a_function/, /a_fact/, /a_plugin/, /Class.*a_module::a_module/)
     end
   end
 
   describe "rdoc2 support", :if => !Puppet.features.rdoc1? do
     def module_path(module_name); "#{doc_dir}/#{module_name}.html" end
     def node_path(module_name, node_name);  "#{doc_dir}/#{module_name}/__nodes__/#{node_name}.html" end
     def class_path(module_name, class_name); "#{doc_dir}/#{module_name}/#{class_name}.html" end
     def plugin_path(module_name, type, name); "#{doc_dir}/#{module_name}/__#{type}s__.html" end
 
     include RdocTesters
 
     it_behaves_like :an_rdoc_site
   end
 end
diff --git a/spec/unit/application/doc_spec.rb b/spec/unit/application/doc_spec.rb
index 8e43907ca..2f8624abd 100755
--- a/spec/unit/application/doc_spec.rb
+++ b/spec/unit/application/doc_spec.rb
@@ -1,340 +1,344 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/application/doc'
 require 'puppet/util/reference'
 require 'puppet/util/rdoc'
 
 describe Puppet::Application::Doc do
   before :each do
     @doc = Puppet::Application[:doc]
     @doc.stubs(:puts)
     @doc.preinit
     Puppet::Util::Log.stubs(:newdestination)
   end
 
   it "should declare an other command" do
     @doc.should respond_to(:other)
   end
 
   it "should declare a rdoc command" do
     @doc.should respond_to(:rdoc)
   end
 
   it "should declare a fallback for unknown options" do
     @doc.should respond_to(:handle_unknown)
   end
 
   it "should declare a preinit block" do
     @doc.should respond_to(:preinit)
   end
 
   describe "in preinit" do
     it "should set references to []" do
       @doc.preinit
 
       @doc.options[:references].should == []
     end
 
     it "should init mode to text" do
       @doc.preinit
 
       @doc.options[:mode].should == :text
     end
 
     it "should init format to to_markdown" do
       @doc.preinit
 
       @doc.options[:format].should == :to_markdown
     end
   end
 
   describe "when handling options" do
     [:all, :outputdir, :verbose, :debug, :charset].each do |option|
       it "should declare handle_#{option} method" do
         @doc.should respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @doc.options.expects(:[]=).with(option, 'arg')
         @doc.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should store the format if valid" do
       Puppet::Util::Reference.stubs(:method_defined?).with('to_format').returns(true)
 
       @doc.handle_format('format')
       @doc.options[:format].should == 'to_format'
     end
 
     it "should raise an error if the format is not valid" do
       Puppet::Util::Reference.stubs(:method_defined?).with('to_format').returns(false)
       expect { @doc.handle_format('format') }.to raise_error(RuntimeError, /Invalid output format/)
     end
 
     it "should store the mode if valid" do
       Puppet::Util::Reference.stubs(:modes).returns(stub('mode', :include? => true))
 
       @doc.handle_mode('mode')
       @doc.options[:mode].should == :mode
     end
 
     it "should store the mode if :rdoc" do
       Puppet::Util::Reference.modes.stubs(:include?).with('rdoc').returns(false)
 
       @doc.handle_mode('rdoc')
       @doc.options[:mode].should == :rdoc
     end
 
     it "should raise an error if the mode is not valid" do
       Puppet::Util::Reference.modes.stubs(:include?).with('unknown').returns(false)
       expect { @doc.handle_mode('unknown') }.to raise_error(RuntimeError, /Invalid output mode/)
     end
 
     it "should list all references on list and exit" do
       reference = stubs 'reference'
       ref = stubs 'ref'
       Puppet::Util::Reference.stubs(:references).returns([reference])
 
       Puppet::Util::Reference.expects(:reference).with(reference).returns(ref)
       ref.expects(:doc)
 
       expect { @doc.handle_list(nil) }.to exit_with 0
     end
 
     it "should add reference to references list with --reference" do
       @doc.options[:references] = [:ref1]
 
       @doc.handle_reference('ref2')
 
       @doc.options[:references].should == [:ref1,:ref2]
     end
   end
 
   describe "during setup" do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
       @doc.command_line.stubs(:args).returns([])
     end
 
     it "should default to rdoc mode if there are command line arguments" do
       @doc.command_line.stubs(:args).returns(["1"])
       @doc.stubs(:setup_rdoc)
 
       @doc.setup
       @doc.options[:mode].should == :rdoc
     end
 
     it "should call setup_rdoc in rdoc mode" do
       @doc.options[:mode] = :rdoc
 
       @doc.expects(:setup_rdoc)
 
       @doc.setup
     end
 
     it "should call setup_reference if not rdoc" do
       @doc.options[:mode] = :test
 
       @doc.expects(:setup_reference)
 
       @doc.setup
     end
 
     describe "configuring logging" do
       before :each do
         Puppet::Util::Log.stubs(:newdestination)
       end
 
       describe "with --debug" do
         before do
           @doc.options[:debug] = true
         end
 
         it "should set log level to debug" do
           @doc.setup
           Puppet::Util::Log.level.should == :debug
         end
 
         it "should set log destination to console" do
           Puppet::Util::Log.expects(:newdestination).with(:console)
           @doc.setup
         end
       end
 
       describe "with --verbose" do
         before do
           @doc.options[:verbose] = true
         end
 
         it "should set log level to info" do
           @doc.setup
           Puppet::Util::Log.level.should == :info
         end
 
         it "should set log destination to console" do
           Puppet::Util::Log.expects(:newdestination).with(:console)
           @doc.setup
         end
       end
 
       describe "without --debug or --verbose" do
         before do
           @doc.options[:debug] = false
           @doc.options[:verbose] = false
         end
 
         it "should set log level to warning" do
           @doc.setup
           Puppet::Util::Log.level.should == :warning
         end
 
         it "should set log destination to console" do
           Puppet::Util::Log.expects(:newdestination).with(:console)
           @doc.setup
         end
       end
     end
 
     describe "in non-rdoc mode" do
       it "should get all non-dynamic reference if --all" do
         @doc.options[:all] = true
         static = stub 'static', :dynamic? => false
         dynamic = stub 'dynamic', :dynamic? => true
         Puppet::Util::Reference.stubs(:reference).with(:static).returns(static)
         Puppet::Util::Reference.stubs(:reference).with(:dynamic).returns(dynamic)
         Puppet::Util::Reference.stubs(:references).returns([:static,:dynamic])
 
         @doc.setup_reference
         @doc.options[:references].should == [:static]
       end
 
       it "should default to :type if no references" do
         @doc.setup_reference
         @doc.options[:references].should == [:type]
       end
     end
 
     describe "in rdoc mode" do
       describe "when there are unknown args" do
         it "should expand --modulepath if any" do
           @doc.unknown_args = [ { :opt => "--modulepath", :arg => "path" } ]
           Puppet.settings.stubs(:handlearg)
 
           @doc.setup_rdoc
 
           @doc.unknown_args[0][:arg].should == File.expand_path('path')
         end
 
         it "should expand --manifestdir if any" do
           @doc.unknown_args = [ { :opt => "--manifestdir", :arg => "path" } ]
           Puppet.settings.stubs(:handlearg)
 
           @doc.setup_rdoc
 
           @doc.unknown_args[0][:arg].should == File.expand_path('path')
         end
 
         it "should give them to Puppet.settings" do
           @doc.unknown_args = [ { :opt => :option, :arg => :argument } ]
           Puppet.settings.expects(:handlearg).with(:option,:argument)
 
           @doc.setup_rdoc
         end
       end
 
       it "should operate in master run_mode" do
         @doc.class.run_mode.name.should == :master
 
         @doc.setup_rdoc
       end
     end
   end
 
   describe "when running" do
     describe "in rdoc mode" do
       include PuppetSpec::Files
 
       let(:envdir) { tmpdir('env') }
       let(:modules) { File.join(envdir, "modules") }
+      let(:modules2) { File.join(envdir, "modules2") }
       let(:manifests) { File.join(envdir, "manifests") }
 
       before :each do
         @doc.manifest = false
         Puppet.stubs(:info)
         Puppet[:trace] = false
         Puppet[:modulepath] = modules
         Puppet[:manifestdir] = manifests
         @doc.options[:all] = false
         @doc.options[:outputdir] = 'doc'
         @doc.options[:charset] = nil
         Puppet.settings.stubs(:define_settings)
         Puppet::Util::RDoc.stubs(:rdoc)
         @doc.command_line.stubs(:args).returns([])
       end
 
       around(:each) do |example|
         FileUtils.mkdir_p(modules)
-        @env = Puppet::Node::Environment.create(Puppet[:environment].to_sym, [modules], "#{manifests}/site.pp")
-        Puppet.override(:environments => Puppet::Environments::Static.new(@env)) do
+        env = Puppet::Node::Environment.create(Puppet[:environment].to_sym, [modules], "#{manifests}/site.pp")
+        Puppet.override({:environments => Puppet::Environments::Static.new(env), :current_environment => env}) do
           example.run
         end
       end
 
       it "should set document_all on --all" do
         @doc.options[:all] = true
         Puppet.settings.expects(:[]=).with(:document_all, true)
 
-        expect { @doc.rdoc }.to exit_with 0
+        expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should call Puppet::Util::RDoc.rdoc in full mode" do
         Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], nil)
-        expect { @doc.rdoc }.to exit_with 0
+        expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should call Puppet::Util::RDoc.rdoc with a charset if --charset has been provided" do
         @doc.options[:charset] = 'utf-8'
         Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], "utf-8")
-        expect { @doc.rdoc }.to exit_with 0
+        expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should call Puppet::Util::RDoc.rdoc in full mode with outputdir set to doc if no --outputdir" do
         @doc.options[:outputdir] = false
         Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], nil)
-        expect { @doc.rdoc }.to exit_with 0
+        expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should call Puppet::Util::RDoc.manifestdoc in manifest mode" do
         @doc.manifest = true
         Puppet::Util::RDoc.expects(:manifestdoc)
-        expect { @doc.rdoc }.to exit_with 0
+        expect { @doc.rdoc }.to exit_with(0)
       end
 
       it "should get modulepath and manifestdir values from the environment" do
-        @env.expects(:modulepath).returns(['envmodules1','envmodules2'])
-        @env.expects(:manifest).returns('envmanifests/site.pp')
-
-        Puppet::Util::RDoc.expects(:rdoc).with('doc', ['envmodules1','envmodules2','envmanifests'], nil)
-
-        expect { @doc.rdoc }.to exit_with 0
+        FileUtils.mkdir_p(modules)
+        FileUtils.mkdir_p(modules2)
+        env = Puppet::Node::Environment.create(Puppet[:environment].to_sym,
+          [modules, modules2],
+          "envmanifests/site.pp")
+        Puppet.override({:environments => Puppet::Environments::Static.new(env), :current_environment => env}) do
+           Puppet::Util::RDoc.stubs(:rdoc).with('doc', [modules.to_s, modules2.to_s, env.manifest.to_s], nil)
+          expect { @doc.rdoc }.to exit_with(0)
+        end
       end
     end
 
     describe "in the other modes" do
       it "should get reference in given format" do
         reference = stub 'reference'
         @doc.options[:mode] = :none
         @doc.options[:references] = [:ref]
         Puppet::Util::Reference.expects(:reference).with(:ref).returns(reference)
         @doc.options[:format] = :format
         @doc.stubs(:exit)
 
         reference.expects(:send).with { |format,contents| format == :format }.returns('doc')
         @doc.other
       end
     end
   end
 end
diff --git a/spec/unit/face/parser_spec.rb b/spec/unit/face/parser_spec.rb
index 9b1b07a47..62f41a42a 100644
--- a/spec/unit/face/parser_spec.rb
+++ b/spec/unit/face/parser_spec.rb
@@ -1,73 +1,71 @@
 require 'spec_helper'
 require 'puppet_spec/files'
 
 require 'puppet/face'
 
 describe Puppet::Face[:parser, :current] do
   include PuppetSpec::Files
 
   let(:parser) { Puppet::Face[:parser, :current] }
 
   context "from an interactive terminal" do
     before :each do
       from_an_interactive_terminal
     end
 
     it "validates the configured site manifest when no files are given" do
       manifest = file_containing('site.pp', "{ invalid =>")
 
       configured_environment = Puppet::Node::Environment.create(:default, [], manifest)
       Puppet.override(:current_environment => configured_environment) do
         expect { parser.validate() }.to exit_with(1)
       end
     end
 
     it "validates the given file" do
       manifest = file_containing('site.pp', "{ invalid =>")
 
       expect { parser.validate(manifest) }.to exit_with(1)
     end
 
     it "runs error free when there are no validation errors" do
       manifest = file_containing('site.pp', "notify { valid: }")
 
       parser.validate(manifest)
     end
 
     it "reports missing files" do
       expect do
         parser.validate("missing.pp")
       end.to raise_error(Puppet::Error, /One or more file\(s\) specified did not exist.*missing\.pp/m)
     end
 
     it "parses supplied manifest files in the context of a directory environment" do
       manifest = file_containing('test.pp', "{ invalid =>")
 
-      env_loader = Puppet::Environments::Static.new(
-        Puppet::Node::Environment.create(:special, [])
-      )
-      Puppet.override(:environments => env_loader) do
-        Puppet[:environment] = 'special'
+      env = Puppet::Node::Environment.create(:special, [])
+      env_loader = Puppet::Environments::Static.new(env)
+      Puppet.override({:environments => env_loader, :current_environment => env}) do
         expect { parser.validate(manifest) }.to exit_with(1)
       end
 
       expect(@logs.join).to match(/environment special.*Syntax error at '\{'/)
     end
 
   end
 
   it "validates the contents of STDIN when no files given and STDIN is not a tty" do
     from_a_piped_input_of("{ invalid =>")
 
     expect { parser.validate() }.to exit_with(1)
   end
 
   def from_an_interactive_terminal
     STDIN.stubs(:tty?).returns(true)
   end
 
   def from_a_piped_input_of(contents)
     STDIN.stubs(:tty?).returns(false)
     STDIN.stubs(:read).returns(contents)
   end
 end
diff --git a/spec/unit/util/rdoc/parser_spec.rb b/spec/unit/util/rdoc/parser_spec.rb
index acc606b76..7ed2cffcc 100755
--- a/spec/unit/util/rdoc/parser_spec.rb
+++ b/spec/unit/util/rdoc/parser_spec.rb
@@ -1,600 +1,608 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 describe "RDoc::Parser", :if => Puppet.features.rdoc1? do
   before :all do
     require 'puppet/resource/type_collection'
     require 'puppet/util/rdoc/parser'
     require 'puppet/util/rdoc/code_objects'
     require 'rdoc/options'
     require 'rdoc/rdoc'
   end
 
   include PuppetSpec::Files
 
   before :each do
     stub_file = stub('init.pp', :stat => stub())
     # Ruby 1.8.7 needs the following call to be stubs and not expects
     Puppet::FileSystem.stubs(:stat).with('init.pp').returns stub() # stub_file
     @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
+    around(:each) do |example|
+      Puppet.override({
+          :current_environment => Puppet::Node::Environment.create(:doc, [], '/somewhere/etc/manifests/site.pp')
+        },
+        "A fake current environment that the application would have established by now"
+      ) do
+
+        example.run
+      end
+    end
+
     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).returns(Puppet::Parser::AST::Hostclass.new('')).at_least_once
       parser.expects(:file=).with("module/manifests/init.pp")
       parser.expects(:file=).with do |args|
         args =~ /.*\/etc\/manifests\/site.pp/
       end
 
       @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(:parse).returns(Puppet::Parser::AST::Hostclass.new('')).at_least_once
 
       @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(:parse).returns(Puppet::Parser::AST::Hostclass.new('')).at_least_once
 
       @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 = Puppet::Node::Environment.create(Puppet[:environment].to_sym, [])
+      env = Puppet.lookup(:current_environment)
       env.stubs(:known_resource_types).returns(known_type)
       known_type.expects(:watching_file?).with("module/manifests/init.pp").returns(true)
-      Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
-
-        @parser.expects(:scan_top_level)
+      @parser.expects(:scan_top_level)
 
-        @parser.scan
-      end
+      @parser.scan
     end
   end
 
   describe "when scanning top level entities" do
     let(:environment) { Puppet::Node::Environment.create(:env, []) }
 
     before :each do
       @resource_type_collection = resource_type_collection = stub_everything('resource_type_collection')
       environment.stubs(:known_resource_types).returns(@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?).with("module/README").returns(true)
       FileTest.stubs(:readable?).with("module/README.rdoc").returns(false)
       File.stubs(:open).returns("readme")
       @parser.stubs(:parse_elements)
 
       @module.expects(:add_comment).with("readme", "module/manifests/init.pp")
 
       @parser.scan_top_level(@topcontainer, environment)
     end
 
     it "should read any present README.rdoc as module documentation" do
       FileTest.stubs(:readable?).with("module/README.rdoc").returns(true)
       FileTest.stubs(:readable?).with("module/README").returns(false)
       File.stubs(:open).returns("readme")
       @parser.stubs(:parse_elements)
 
       @module.expects(:add_comment).with("readme", "module/manifests/init.pp")
 
       @parser.scan_top_level(@topcontainer, environment)
     end
 
     it "should prefer README.rdoc over README as module documentation" do
       FileTest.stubs(:readable?).with("module/README.rdoc").returns(true)
       FileTest.stubs(:readable?).with("module/README").returns(true)
       File.stubs(:open).with("module/README", "r").returns("readme")
       File.stubs(:open).with("module/README.rdoc", "r").returns("readme.rdoc")
       @parser.stubs(:parse_elements)
 
       @module.expects(:add_comment).with("readme.rdoc", "module/manifests/init.pp")
 
       @parser.scan_top_level(@topcontainer, environment)
     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, environment)
     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, environment)
     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, environment)
     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, environment)
     end
 
     it "should defer ast parsing to parse_elements for this module" do
       @parser.expects(:parse_elements).with(@module, @resource_type_collection)
 
       @parser.scan_top_level(@topcontainer, environment)
     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, environment)
     end
   end
 
   describe "when finding modules from filepath" do
     let(:environment) {
       Puppet::FileSystem.expects(:directory?).with("/path/to/modules").at_least_once.returns(true)
       Puppet::Node::Environment.create(:env, ["/path/to/modules"])
     }
 
     it "should return the module name for modulized puppet manifests" do
       File.stubs(:identical?).with("/path/to/modules", "/path/to/modules").returns(true)
       @parser.split_module("/path/to/modules/mymodule/manifests/init.pp", environment).should == "mymodule"
     end
 
     it "should return <site> for manifests not under module path" do
       File.stubs(:identical?).returns(false)
       @parser.split_module("/path/to/manifests/init.pp", environment).should == RDoc::Parser::SITE
     end
 
     it "should handle windows paths with drive letters", :if => Puppet.features.microsoft_windows? && Puppet.features.rdoc1? do
       @parser.split_module("C:/temp/init.pp", environment).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 = resource_type_collection = Puppet::Resource::TypeCollection.new("env")
       @parser.instance_eval { @known_resource_types = 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, @resource_type_collection)
     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, @resource_type_collection)
     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, @resource_type_collection)
     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, @resource_type_collection)
     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, @resource_type_collection)
     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, @resource_type_collection)
     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, @resource_type_collection)
     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(:add_comment).with("mydoc", "file")
       @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[:document_all] = 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(:add_comment).with("mydoc", "file")
       @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[:document_all] = 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::BlockExpression).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::BlockExpression).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::BlockExpression).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::BlockExpression).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",
         :instances  => Puppet::Parser::AST::BlockExpression.new(:children => [
           Puppet::Parser::AST::ResourceInstance.new(
             :title => Puppet::Parser::AST::Name.new(:value => "myfile"),
             :parameters => Puppet::Parser::AST::BlockExpression.new(:children => [])
           )
         ]),
         :doc        => 'mydoc'
       )
 
       @code = stub_everything 'code'
       @code.stubs(:is_a?).with(Puppet::Parser::AST::BlockExpression).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