diff --git a/lib/puppet/application.rb b/lib/puppet/application.rb
index f6dac3911..c940d06c2 100644
--- a/lib/puppet/application.rb
+++ b/lib/puppet/application.rb
@@ -1,418 +1,418 @@
 require 'optparse'
 require 'puppet/util/plugins'
 
 # 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 defaul +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
 # aftect 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
 module Puppet
 class Application
   require 'puppet/util'
   include Puppet::Util
 
-  DOCPATTERN = File.expand_path(File.dirname(__FILE__) + "/util/command_line/*" )
+  DOCPATTERN = ::File.expand_path(::File.dirname(__FILE__) + "/util/command_line/*" )
 
   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
 
     def should_parse_config
       @parse_config = true
     end
 
     def should_not_parse_config
       @parse_config = false
     end
 
     def should_parse_config?
       @parse_config = true if ! defined?(@parse_config)
       @parse_config
     end
 
     # used to declare code that handle an option
     def option(*options, &block)
       long = options.find { |opt| opt =~ /^--/ }.gsub(/^--(?:\[no-\])?([^ =]+).*$/, '\1' ).gsub('-','_')
       fname = symbolize("handle_#{long}")
       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
 
     def find(name)
       klass = name.to_s.capitalize
 
       begin
-        require File.join('puppet', 'application', name.to_s.downcase)
+        require ::File.join('puppet', 'application', name.to_s.downcase)
       rescue LoadError => e
         puts "Unable to find application '#{name}'.  #{e}"
         Kernel::exit(1)
       end
 
       self.const_get(klass)
     end
 
     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)
       return @run_mode if @run_mode and not mode_name
 
       require 'puppet/util/run_mode'
       @run_mode = Puppet::Util::RunMode[ mode_name || :user ]
     end
   end
 
   attr_reader :options, :command_line
 
   # Every app responds to --version
   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 should_parse_config?
     self.class.should_parse_config?
   end
 
   # override to execute code before running anything else
   def preinit
   end
 
   def initialize(command_line = nil)
 
     require 'puppet/util/command_line'
     @command_line = command_line || Puppet::Util::CommandLine.new
     set_run_mode self.class.run_mode
     @options = {}
 
     require 'puppet'
     require 'puppet/util/instrumentation'
     Puppet::Util::Instrumentation.init
   end
 
   # WARNING: This is a totally scary, frightening, and nasty internal API.  We
   # strongly advise that you do not use this, and if you insist, we will
   # politely allow you to keep both pieces of your broken code.
   #
   # We plan to provide a supported, long-term API to deliver this in a way
   # that you can use.  Please make sure that you let us know if you do require
   # this, and this message is still present in the code. --daniel 2011-02-03
   def set_run_mode(mode)
     @run_mode = mode
     $puppet_application_mode = @run_mode
     $puppet_application_name = name
 
     if Puppet.respond_to? :settings
       # This is to reduce the amount of confusion in rspec
       # because it might have loaded defaults.rb before the globals were set
       # and thus have the wrong defaults for the current application
       Puppet.settings.set_value(:confdir, Puppet.run_mode.conf_dir, :mutable_defaults)
       Puppet.settings.set_value(:vardir, Puppet.run_mode.var_dir, :mutable_defaults)
       Puppet.settings.set_value(:name, Puppet.application_name.to_s, :mutable_defaults)
       Puppet.settings.set_value(:logdir, Puppet.run_mode.logopts, :mutable_defaults)
       Puppet.settings.set_value(:rundir, Puppet.run_mode.run_dir, :mutable_defaults)
       Puppet.settings.set_value(:run_mode, Puppet.run_mode.name.to_s, :mutable_defaults)
     end
   end
 
   # This is the main application entry point
   def run
     exit_on_fail("initialize")                                   { hook('preinit')       { preinit } }
     exit_on_fail("parse options")                                { hook('parse_options') { parse_options } }
     exit_on_fail("parse configuration file")                     { Puppet.settings.parse } if should_parse_config?
     exit_on_fail("prepare for execution")                        { hook('setup')         { setup } }
     exit_on_fail("configure routes from #{Puppet[:route_file]}") { configure_indirector_routes }
     exit_on_fail("run")                                          { hook('run_command')   { run_command } }
   end
 
   def main
     raise NotImplementedError, "No valid command or main"
   end
 
   def run_command
     main
   end
 
   def setup
     # Handle the logging settings
     if options[:debug] or options[:verbose]
       Puppet::Util::Log.newdestination(:console)
       if options[:debug]
         Puppet::Util::Log.level = :debug
       else
         Puppet::Util::Log.level = :info
       end
     end
 
     Puppet::Util::Log.newdestination(:syslog) unless options[:setdest]
   end
 
   def configure_indirector_routes
     route_file = Puppet[:route_file]
     if ::File.exists?(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
 
   def parse_options
     # Create an option parser
     option_parser = OptionParser.new(self.class.banner)
 
     # 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, arg)
     # rewrite --[no-]option to --no-option if that's what was given
     if opt =~ /\[no-\]/ and !arg
       opt = opt.gsub(/\[no-\]/,'no-')
     end
     # otherwise remove the [no-] prefix to not confuse everybody
     opt = opt.gsub(/\[no-\]/, '')
     unless respond_to?(:handle_unknown) and send(:handle_unknown, opt, arg)
       # Puppet.settings.handlearg doesn't handle direct true/false :-)
       if arg.is_a?(FalseClass)
         arg = "false"
       elsif arg.is_a?(TrueClass)
         arg = "true"
       end
       Puppet.settings.handlearg(opt, arg)
     end
   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
 
   private
 
   def exit_on_fail(message, code = 1)
     yield
   rescue ArgumentError, RuntimeError, NotImplementedError => detail
     puts detail.backtrace if Puppet[:trace]
     $stderr.puts "Could not #{message}: #{detail}"
     exit(code)
   end
 
   def 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
 end
 end
diff --git a/lib/puppet/application/apply.rb b/lib/puppet/application/apply.rb
index e9b4e7a24..3e2be4867 100644
--- a/lib/puppet/application/apply.rb
+++ b/lib/puppet/application/apply.rb
@@ -1,266 +1,266 @@
 require 'puppet/application'
 
 class Puppet::Application::Apply < Puppet::Application
 
   should_parse_config
 
   option("--debug","-d")
   option("--execute EXECUTE","-e") do |arg|
     options[:code] = arg
   end
   option("--loadclasses","-L")
   option("--verbose","-v")
   option("--use-nodes")
   option("--detailed-exitcodes")
 
   option("--apply catalog",  "-a catalog") do |arg|
     Puppet.warning <<EOM
 --apply is deprecated and will be removed in the future. Please
 use 'puppet apply --catalog <catalog>'.
 EOM
     options[:catalog] = arg
   end
 
   option("--catalog catalog",  "-c catalog") do |arg|
     options[:catalog] = arg
   end
 
   option("--logdest LOGDEST", "-l") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:logset] = true
     rescue => detail
       $stderr.puts detail.to_s
     end
   end
 
   option("--parseonly") do
     puts "--parseonly has been removed. Please use 'puppet parser validate <manifest>'"
     exit 1
   end
 
   def help
     <<-HELP
 
 puppet-apply(8) -- Apply Puppet manifests locally
 ========
 
 SYNOPSIS
 --------
 Applies a standalone Puppet manifest to the local system.
 
 
 USAGE
 -----
 puppet apply [-h|--help] [-V|--version] [-d|--debug] [-v|--verbose]
   [-e|--execute] [--detailed-exitcodes] [-l|--logdest <file>]
   [--apply <catalog>] [--catalog <catalog>] <file>
 
 
 DESCRIPTION
 -----------
 This is the standalone puppet execution tool; use it to apply
 individual manifests.
 
 When provided with a modulepath, via command line or config file, puppet
 apply can effectively mimic the catalog that would be served by puppet
 master with access to the same modules, although there are some subtle
 differences. When combined with scheduling and an automated system for
 pushing manifests, this can be used to implement a serverless Puppet
 site.
 
 Most users should use 'puppet agent' and 'puppet master' for site-wide
 manifests.
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'modulepath' is a
 valid configuration parameter, so you can specify '--tags <class>,<tag>'
 as an argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/stable/configuration.html for the
 full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet with
 '--genconfig'.
 
 * --debug:
   Enable full debugging.
 
 * --detailed-exitcodes:
   Provide transaction information via exit codes. If this is enabled, an exit
   code of '2' means there were changes, an exit code of '4' means there were
   failures during the transaction, and an exit code of '6' means there were both
   changes and failures.
 
 * --help:
   Print this help message
 
 * --loadclasses:
   Load any stored classes. 'puppet agent' caches configured classes
   (usually at /etc/puppet/classes.txt), and setting this option causes
   all of those classes to be set in your puppet manifest.
 
 * --logdest:
   Where to send messages. Choose between syslog, the console, and a log
   file. Defaults to sending messages to the console.
 
 * --execute:
   Execute a specific piece of Puppet code
 
 * --verbose:
   Print extra information.
 
 * --apply:
   Apply a JSON catalog (such as one generated with 'puppet master --compile'). You can
   either specify a JSON file or pipe in JSON from standard input. Deprecated, please
   use --catalog instead.
 
 * --catalog:
   Apply a JSON catalog (such as one generated with 'puppet master --compile'). You can
   either specify a JSON file or pipe in JSON from standard input.
 
 
 EXAMPLE
 -------
     $ puppet apply -l /tmp/manifest.log manifest.pp
     $ puppet apply --modulepath=/root/dev/modules -e "include ntpd::server"
     $ puppet apply --catalog catalog.json
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def run_command
     if options[:catalog]
       apply
     else
       main
     end
   end
 
   def apply
     if options[:catalog] == "-"
       text = $stdin.read
     else
-      text = File.read(options[:catalog])
+      text = ::File.read(options[:catalog])
     end
 
     begin
       catalog = Puppet::Resource::Catalog.convert_from(Puppet::Resource::Catalog.default_format,text)
       catalog = Puppet::Resource::Catalog.pson_create(catalog) unless catalog.is_a?(Puppet::Resource::Catalog)
     rescue => detail
       raise Puppet::Error, "Could not deserialize catalog from pson: #{detail}"
     end
 
     catalog = catalog.to_ral
 
     require 'puppet/configurer'
     configurer = Puppet::Configurer.new
     configurer.run :catalog => catalog
   end
 
   def main
     # Set our code or file to use.
     if options[:code] or command_line.args.length == 0
       Puppet[:code] = options[:code] || STDIN.read
     else
       manifest = command_line.args.shift
-      raise "Could not find file #{manifest}" unless File.exist?(manifest)
+      raise "Could not find file #{manifest}" unless ::File.exist?(manifest)
       Puppet.warning("Only one file can be applied per run.  Skipping #{command_line.args.join(', ')}") if command_line.args.size > 0
       Puppet[:manifest] = manifest
     end
 
     # Collect our facts.
     unless facts = Puppet::Node::Facts.indirection.find(Puppet[:node_name_value])
       raise "Could not find facts for #{Puppet[:node_name_value]}"
     end
 
     unless Puppet[:node_name_fact].empty?
       Puppet[:node_name_value] = facts.values[Puppet[:node_name_fact]]
       facts.name = Puppet[:node_name_value]
     end
 
     # Find our Node
     unless node = Puppet::Node.indirection.find(Puppet[:node_name_value])
       raise "Could not find node #{Puppet[:node_name_value]}"
     end
 
     # Merge in the facts.
     node.merge(facts.values)
 
     # Allow users to load the classes that puppet agent creates.
     if options[:loadclasses]
       file = Puppet[:classfile]
       if FileTest.exists?(file)
         unless FileTest.readable?(file)
           $stderr.puts "#{file} is not readable"
           exit(63)
         end
-        node.classes = File.read(file).split(/[\s\n]+/)
+        node.classes = ::File.read(file).split(/[\s\n]+/)
       end
     end
 
     begin
       # Compile our catalog
       starttime = Time.now
       catalog = Puppet::Resource::Catalog.indirection.find(node.name, :use_node => node)
 
       # Translate it to a RAL catalog
       catalog = catalog.to_ral
 
       catalog.finalize
 
       catalog.retrieval_duration = Time.now - starttime
 
       require 'puppet/configurer'
       configurer = Puppet::Configurer.new
       report = configurer.run(:skip_plugin_download => true, :catalog => catalog)
 
       if not report
         exit(1)
       elsif options[:detailed_exitcodes] then
         exit(report.exit_status)
       else
         exit(0)
       end
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       $stderr.puts detail.message
       exit(1)
     end
   end
 
   def setup
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     Puppet::Util::Log.newdestination(:console) unless options[:logset]
     client = nil
     server = nil
 
     Signal.trap(:INT) do
       $stderr.puts "Exiting"
       exit(1)
     end
 
     # we want the last report to be persisted locally
     Puppet::Transaction::Report.indirection.cache_class = :yaml
 
     if options[:debug]
       Puppet::Util::Log.level = :debug
     elsif options[:verbose]
       Puppet::Util::Log.level = :info
     end
   end
 end
diff --git a/lib/puppet/application/device.rb b/lib/puppet/application/device.rb
index d0b93873e..7a602f29c 100644
--- a/lib/puppet/application/device.rb
+++ b/lib/puppet/application/device.rb
@@ -1,256 +1,256 @@
 require 'puppet/application'
 require 'puppet/util/network_device'
 
 
 class Puppet::Application::Device < Puppet::Application
 
   should_parse_config
   run_mode :agent
 
   attr_accessor :args, :agent, :host
 
   def preinit
     # Do an initial trap, so that cancels don't get a stack trace.
     Signal.trap(:INT) do
       $stderr.puts "Cancelling startup"
       exit(0)
     end
 
     {
       :waitforcert => nil,
       :detailed_exitcodes => false,
       :verbose => false,
       :debug => false,
       :centrallogs => false,
       :setdest => false,
     }.each do |opt,val|
       options[opt] = val
     end
 
     @args = {}
   end
 
   option("--centrallogging")
   option("--debug","-d")
   option("--verbose","-v")
 
   option("--detailed-exitcodes") do |arg|
     options[:detailed_exitcodes] = true
   end
 
   option("--logdest DEST", "-l DEST") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:setdest] = true
     rescue => detail
       puts detail.backtrace if Puppet[:debug]
       $stderr.puts detail.to_s
     end
   end
 
   option("--waitforcert WAITFORCERT", "-w") do |arg|
     options[:waitforcert] = arg.to_i
   end
 
   option("--port PORT","-p") do |arg|
     @args[:Port] = arg
   end
 
     def help
       <<-HELP
 
 puppet-device(8) -- Manage remote network devices
 ========
 
 SYNOPSIS
 --------
 Retrieves all configurations from the puppet master and apply
 them to the remote devices configured in /etc/puppet/device.conf.
 
 Currently must be run out periodically, using cron or something similar.
 
 USAGE
 -----
   puppet device [-d|--debug] [--detailed-exitcodes] [-V|--version]
                 [-h|--help] [-l|--logdest syslog|<file>|console]
                 [-v|--verbose] [-w|--waitforcert <seconds>]
 
 
 DESCRIPTION
 -----------
 Once the client has a signed certificate for a given remote device, it will 
 retrieve its configuration and apply it.
 
 USAGE NOTES
 -----------
 One need a /etc/puppet/device.conf file with the following content:
 
 [remote.device.fqdn]
 type <type>
 url <url>
 
 where:
  * type: the current device type (the only value at this time is cisco)
  * url: an url allowing to connect to the device
 
 Supported url must conforms to:
  scheme://user:password@hostname/?query
 
  with:
   * scheme: either ssh or telnet
   * user: username, can be omitted depending on the switch/router configuration
   * password: the connection password
   * query: this is device specific. Cisco devices supports an enable parameter whose
   value would be the enable password.
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration file
 is also a valid long argument.  For example, 'server' is a valid configuration
 parameter, so you can specify '--server <servername>' as an argument.
 
 * --debug:
   Enable full debugging.
 
 * --detailed-exitcodes:
   Provide transaction information via exit codes. If this is enabled, an exit
   code of '2' means there were changes, an exit code of '4' means there were
   failures during the transaction, and an exit code of '6' means there were both
   changes and failures.
 
 * --help:
   Print this help message
 
 * --logdest:
   Where to send messages.  Choose between syslog, the console, and a log file.
   Defaults to sending messages to syslog, or the console if debugging or
   verbosity is enabled.
 
 * --verbose:
   Turn on verbose reporting.
 
 * --waitforcert:
   This option only matters for daemons that do not yet have certificates
   and it is enabled by default, with a value of 120 (seconds).  This causes
   +puppet agent+ to connect to the server every 2 minutes and ask it to sign a
   certificate request.  This is useful for the initial setup of a puppet
   client.  You can turn off waiting for certificates by specifying a time
   of 0.
 
 EXAMPLE
 -------
       $ puppet device --server puppet.domain.com
 
 AUTHOR
 ------
 Brice Figureau
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC 
 Licensed under the Apache 2.0 License
       HELP
     end
 
 
   def main
     vardir = Puppet[:vardir]
     confdir = Puppet[:confdir]
     certname = Puppet[:certname]
 
     # find device list
     require 'puppet/util/network_device/config'
     devices = Puppet::Util::NetworkDevice::Config.devices
     if devices.empty?
       Puppet.err "No device found in #{Puppet[:deviceconfig]}"
       exit(1)
     end
     devices.each_value do |device|
       begin
         Puppet.info "starting applying configuration to #{device.name} at #{device.url}"
 
         # override local $vardir and $certname
-        Puppet.settings.set_value(:confdir, File.join(Puppet[:devicedir], device.name), :cli)
-        Puppet.settings.set_value(:vardir, File.join(Puppet[:devicedir], device.name), :cli)
+        Puppet.settings.set_value(:confdir, ::File.join(Puppet[:devicedir], device.name), :cli)
+        Puppet.settings.set_value(:vardir, ::File.join(Puppet[:devicedir], device.name), :cli)
         Puppet.settings.set_value(:certname, device.name, :cli)
 
         # this will reload and recompute default settings and create the devices sub vardir, or we hope so :-)
         Puppet.settings.use :main, :agent, :ssl
 
         # this init the device singleton, so that the facts terminus
         # and the various network_device provider can use it
         Puppet::Util::NetworkDevice.init(device)
 
         # ask for a ssl cert if needed, but at least
         # setup the ssl system for this device.
         setup_host
 
         require 'puppet/configurer'
         configurer = Puppet::Configurer.new
         report = configurer.run(:network_device => true)
       rescue => detail
         puts detail.backtrace if Puppet[:trace]
         Puppet.err detail.to_s
       ensure
         Puppet.settings.set_value(:vardir, vardir, :cli)
         Puppet.settings.set_value(:confdir, confdir, :cli)
         Puppet.settings.set_value(:certname, certname, :cli)
         Puppet::SSL::Host.reset
       end
     end
   end
 
   # Handle the logging settings.
   def setup_logs
     if options[:debug] or options[:verbose]
       Puppet::Util::Log.newdestination(:console)
       if options[:debug]
         Puppet::Util::Log.level = :debug
       else
         Puppet::Util::Log.level = :info
       end
     end
 
     Puppet::Util::Log.newdestination(:syslog) unless options[:setdest]
   end
 
   def setup_host
     @host = Puppet::SSL::Host.new
     waitforcert = options[:waitforcert] || (Puppet[:onetime] ? 0 : 120)
     cert = @host.wait_for_cert(waitforcert)
   end
 
   def setup
     setup_logs
 
     args[:Server] = Puppet[:server]
     if options[:centrallogs]
       logdest = args[:Server]
 
       logdest += ":" + args[:Port] if args.include?(:Port)
       Puppet::Util::Log.newdestination(logdest)
     end
 
     Puppet.settings.use :main, :agent, :device, :ssl
 
     # Always ignoreimport for agent. It really shouldn't even try to import,
     # but this is just a temporary band-aid.
     Puppet[:ignoreimport] = true
 
     # We need to specify a ca location for all of the SSL-related i
     # indirected classes to work; in fingerprint mode we just need
     # access to the local files and we don't need a ca.
     Puppet::SSL::Host.ca_location = :remote
 
     Puppet::Transaction::Report.indirection.terminus_class = :rest
 
     # Override the default; puppetd needs this, usually.
     # You can still override this on the command-line with, e.g., :compiler.
     Puppet[:catalog_terminus] = :rest
 
     Puppet[:facts_terminus] = :network_device
 
     Puppet::Resource::Catalog.indirection.cache_class = :yaml
   end
 end
diff --git a/lib/puppet/application/doc.rb b/lib/puppet/application/doc.rb
index 6c23a7a58..d2683b0d2 100644
--- a/lib/puppet/application/doc.rb
+++ b/lib/puppet/application/doc.rb
@@ -1,275 +1,275 @@
 require 'puppet/application'
 
 class Puppet::Application::Doc < Puppet::Application
   should_not_parse_config
   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.
 
 
 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.
 
 
 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'. In 'rdoc' mode you must provide 'manifests-path'
 
 * --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. Due to a known bug, this option is not currently effective.
 
 
 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
   end
 
   def rdoc
     exit_code = 0
     files = []
     unless @manifest
       env = Puppet::Node::Environment.new
       files += env.modulepath
-      files << File.dirname(env[:manifest])
+      files << ::File.dirname(env[: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
       puts detail.backtrace if Puppet[:trace]
       $stderr.puts "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
         puts detail.backtrace
         $stderr.puts "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
   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)
+          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
 
     # Now parse the config
     Puppet.parse_config
 
     # Handle the logging settings.
     if options[:debug] or options[:verbose]
       if options[:debug]
         Puppet::Util::Log.level = :debug
       else
         Puppet::Util::Log.level = :info
       end
 
       Puppet::Util::Log.newdestination(:console)
     end
   end
 end
diff --git a/lib/puppet/application/inspect.rb b/lib/puppet/application/inspect.rb
index 6737128aa..ad31d8de5 100644
--- a/lib/puppet/application/inspect.rb
+++ b/lib/puppet/application/inspect.rb
@@ -1,190 +1,190 @@
 require 'puppet/application'
 
 class Puppet::Application::Inspect < Puppet::Application
 
   should_parse_config
   run_mode :agent
 
   option("--debug","-d")
   option("--verbose","-v")
 
   option("--logdest LOGDEST", "-l") do |arg|
     begin
       Puppet::Util::Log.newdestination(arg)
       options[:logset] = true
     rescue => detail
       $stderr.puts detail.to_s
     end
   end
 
   def help
     <<-HELP
 
 puppet-inspect(8) -- Send an inspection report
 ========
 
 SYNOPSIS
 --------
 
 Prepares and submits an inspection report to the puppet master.
 
 
 USAGE
 -----
 puppet inspect [--archive_files] [--archive_file_server]
 
 
 DESCRIPTION
 -----------
 
 This command uses the cached catalog from the previous run of 'puppet
 agent' to determine which attributes of which resources have been
 marked as auditable with the 'audit' metaparameter. It then examines
 the current state of the system, writes the state of the specified
 resource attributes to a report, and submits the report to the puppet
 master.
 
 Puppet inspect does not run as a daemon, and must be run manually or
 from cron.
 
 
 OPTIONS
 -------
 
 Any configuration setting which is valid in the configuration file is
 also a valid long argument, e.g. '--server=master.domain.com'. See the
 configuration file documentation at
 http://docs.puppetlabs.com/references/latest/configuration.html for
 the full list of acceptable settings.
 
 * --archive_files:
   During an inspect run, whether to archive files whose contents are audited to
   a file bucket.
 
 * --archive_file_server:
   During an inspect run, the file bucket server to archive files to if
   archive_files is set.  The default value is '$server'.
 
 
 AUTHOR
 ------
 
 Puppet Labs
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def setup
     exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     raise "Inspect requires reporting to be enabled. Set report=true in puppet.conf to enable reporting." unless Puppet[:report]
 
     @report = Puppet::Transaction::Report.new("inspect")
 
     Puppet::Util::Log.newdestination(@report)
     Puppet::Util::Log.newdestination(:console) unless options[:logset]
 
     Signal.trap(:INT) do
       $stderr.puts "Exiting"
       exit(1)
     end
 
     if options[:debug]
       Puppet::Util::Log.level = :debug
     elsif options[:verbose]
       Puppet::Util::Log.level = :info
     end
 
     Puppet::Transaction::Report.indirection.terminus_class = :rest
     Puppet::Resource::Catalog.indirection.terminus_class = :yaml
   end
 
   def preinit
     require 'puppet'
     require 'puppet/file_bucket/dipper'
   end
 
   def run_command
     benchmark(:notice, "Finished inspection") do
       retrieval_starttime = Time.now
 
       unless catalog = Puppet::Resource::Catalog.indirection.find(Puppet[:certname])
         raise "Could not find catalog for #{Puppet[:certname]}"
       end
 
       @report.configuration_version = catalog.version
 
       inspect_starttime = Time.now
       @report.add_times("config_retrieval", inspect_starttime - retrieval_starttime)
 
       if Puppet[:archive_files]
         dipper = Puppet::FileBucket::Dipper.new(:Server => Puppet[:archive_file_server])
       end
 
       catalog.to_ral.resources.each do |ral_resource|
         audited_attributes = ral_resource[:audit]
         next unless audited_attributes
 
         status = Puppet::Resource::Status.new(ral_resource)
 
         begin
           audited_resource = ral_resource.to_resource
         rescue StandardError => detail
           puts detail.backtrace if Puppet[:trace]
           ral_resource.err "Could not inspect #{ral_resource}; skipping: #{detail}"
           audited_attributes.each do |name|
             event = ral_resource.event(
                                        :property => name,
                                        :status   => "failure",
                                        :audited  => true,
                                        :message  => "failed to inspect #{name}"
                                        )
             status.add_event(event)
           end
         else
           audited_attributes.each do |name|
             next if audited_resource[name].nil?
             # Skip :absent properties of :absent resources. Really, it would be nicer if the RAL returned nil for those, but it doesn't. ~JW
             if name == :ensure or audited_resource[:ensure] != :absent or audited_resource[name] != :absent
               event = ral_resource.event(
                                          :previous_value => audited_resource[name],
                                          :property       => name,
                                          :status         => "audit",
                                          :audited        => true,
                                          :message        => "inspected value is #{audited_resource[name].inspect}"
                                          )
               status.add_event(event)
             end
           end
         end
         if Puppet[:archive_files] and ral_resource.type == :file and audited_attributes.include?(:content)
           path = ral_resource[:path]
-          if File.readable?(path)
+          if ::File.readable?(path)
             begin
               dipper.backup(path)
             rescue StandardError => detail
               Puppet.warning detail
             end
           end
         end
         @report.add_resource_status(status)
       end
 
       finishtime = Time.now
       @report.add_times("inspect", finishtime - inspect_starttime)
       @report.finalize_report
 
       begin
         Puppet::Transaction::Report.indirection.save(@report)
       rescue => detail
         puts detail.backtrace if Puppet[:trace]
         Puppet.err "Could not send report: #{detail}"
       end
     end
   end
 end
diff --git a/spec/unit/application_spec.rb b/spec/unit/application_spec.rb
index 591358efb..efd5b4678 100755
--- a/spec/unit/application_spec.rb
+++ b/spec/unit/application_spec.rb
@@ -1,611 +1,617 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application'
 require 'puppet'
 require 'getoptlong'
 
 describe Puppet::Application do
 
   before do
     Puppet::Util::Instrumentation.stubs(:init)
     @app = Class.new(Puppet::Application).new
     @appclass = @app.class
 
     @app.stubs(:name).returns("test_app")
     # avoid actually trying to parse any settings
     Puppet.settings.stubs(:parse)
   end
 
   describe "finding" do
     before do
       @klass = Puppet::Application
       @klass.stubs(:puts)
     end
 
     it "should find classes in the namespace" do
       @klass.find("Agent").should == @klass::Agent
     end
 
     it "should not find classes outside the namespace", :'fails_on_ruby_1.9.2' => true do
       expect { @klass.find("String") }.to exit_with 1
     end
 
     it "should exit if it can't find a class" do
       reg = "Unable to find application 'ThisShallNeverEverEverExist'.  "
       reg += "no such file to load -- puppet/application/thisshallneverevereverexist"
       @klass.expects(:puts).with(reg)
 
       expect { @klass.find("ThisShallNeverEverEverExist") }.to exit_with 1
     end
+
+    it "#12114: should prevent File namespace collisions" do
+      # have to require the file face once, then the second time around it would fail
+      @klass.find("File").should == Puppet::Application::File
+      @klass.find("File").should == Puppet::Application::File
+    end
   end
 
   describe ".run_mode" do
     it "should default to user" do
       @appclass.run_mode.name.should == :user
     end
 
     it "should set and get a value" do
       @appclass.run_mode :agent
       @appclass.run_mode.name.should == :agent
     end
   end
 
   it "should sadly and frighteningly allow run_mode to change at runtime" do
     class TestApp < Puppet::Application
       run_mode :master
       def run_command
         # This is equivalent to calling these methods externally to the
         # instance, but since this is what "real world" code is likely to do
         # (and we need the class anyway) we may as well test that. --daniel 2011-02-03
         set_run_mode self.class.run_mode "agent"
       end
     end
 
     Puppet[:run_mode].should == "user"
 
     expect {
       app = TestApp.new
 
       Puppet[:run_mode].should == "master"
 
       app.run
 
       app.class.run_mode.name.should == :agent
       $puppet_application_mode.name.should == :agent
     }.should_not raise_error
 
     Puppet[:run_mode].should == "agent"
   end
 
   it "it should not allow run mode to be set multiple times" do
     pending "great floods of tears, you can do this right now" # --daniel 2011-02-03
     app = Puppet::Application.new
     expect {
       app.set_run_mode app.class.run_mode "master"
       $puppet_application_mode.name.should == :master
       app.set_run_mode app.class.run_mode "agent"
       $puppet_application_mode.name.should == :agent
     }.should raise_error
   end
 
   it "should explode when an invalid run mode is set at runtime, for great victory"
   # ...but you can, and while it will explode, that only happens too late for
   # us to easily test. --daniel 2011-02-03
 
   it "should have a run entry-point" do
     @app.should respond_to(:run)
   end
 
   it "should have a read accessor to options" do
     @app.should respond_to(:options)
   end
 
   it "should include a default setup method" do
     @app.should respond_to(:setup)
   end
 
   it "should include a default preinit method" do
     @app.should respond_to(:preinit)
   end
 
   it "should include a default run_command method" do
     @app.should respond_to(:run_command)
   end
 
   it "should invoke main as the default" do
     @app.expects( :main )
     @app.run_command
   end
 
   it "should initialize the Puppet Instrumentation layer on creation" do
     Puppet::Util::Instrumentation.expects(:init)
     Class.new(Puppet::Application).new
   end
 
   describe 'when invoking clear!' do
     before :each do
       Puppet::Application.run_status = :stop_requested
       Puppet::Application.clear!
     end
 
     it 'should have nil run_status' do
       Puppet::Application.run_status.should be_nil
     end
 
     it 'should return false for restart_requested?' do
       Puppet::Application.restart_requested?.should be_false
     end
 
     it 'should return false for stop_requested?' do
       Puppet::Application.stop_requested?.should be_false
     end
 
     it 'should return false for interrupted?' do
       Puppet::Application.interrupted?.should be_false
     end
 
     it 'should return true for clear?' do
       Puppet::Application.clear?.should be_true
     end
   end
 
   describe 'after invoking stop!' do
     before :each do
       Puppet::Application.run_status = nil
       Puppet::Application.stop!
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
 
     it 'should have run_status of :stop_requested' do
       Puppet::Application.run_status.should == :stop_requested
     end
 
     it 'should return true for stop_requested?' do
       Puppet::Application.stop_requested?.should be_true
     end
 
     it 'should return false for restart_requested?' do
       Puppet::Application.restart_requested?.should be_false
     end
 
     it 'should return true for interrupted?' do
       Puppet::Application.interrupted?.should be_true
     end
 
     it 'should return false for clear?' do
       Puppet::Application.clear?.should be_false
     end
   end
 
   describe 'when invoking restart!' do
     before :each do
       Puppet::Application.run_status = nil
       Puppet::Application.restart!
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
 
     it 'should have run_status of :restart_requested' do
       Puppet::Application.run_status.should == :restart_requested
     end
 
     it 'should return true for restart_requested?' do
       Puppet::Application.restart_requested?.should be_true
     end
 
     it 'should return false for stop_requested?' do
       Puppet::Application.stop_requested?.should be_false
     end
 
     it 'should return true for interrupted?' do
       Puppet::Application.interrupted?.should be_true
     end
 
     it 'should return false for clear?' do
       Puppet::Application.clear?.should be_false
     end
   end
 
   describe 'when performing a controlled_run' do
     it 'should not execute block if not :clear?' do
       Puppet::Application.run_status = :stop_requested
       target = mock 'target'
       target.expects(:some_method).never
       Puppet::Application.controlled_run do
         target.some_method
       end
     end
 
     it 'should execute block if :clear?' do
       Puppet::Application.run_status = nil
       target = mock 'target'
       target.expects(:some_method).once
       Puppet::Application.controlled_run do
         target.some_method
       end
     end
 
     describe 'on POSIX systems', :if => Puppet.features.posix? do
       it 'should signal process with HUP after block if restart requested during block execution', :'fails_on_ruby_1.9.2' => true do
         Puppet::Application.run_status = nil
         target = mock 'target'
         target.expects(:some_method).once
         old_handler = trap('HUP') { target.some_method }
         begin
           Puppet::Application.controlled_run do
             Puppet::Application.run_status = :restart_requested
           end
         ensure
           trap('HUP', old_handler)
         end
       end
     end
 
     after :each do
       Puppet::Application.run_status = nil
     end
   end
 
   describe "when parsing command-line options" do
 
     before :each do
       @app.command_line.stubs(:args).returns([])
 
       Puppet.settings.stubs(:optparse_addargs).returns([])
     end
 
     it "should pass the banner to the option parser" do
       option_parser = stub "option parser"
       option_parser.stubs(:on)
       option_parser.stubs(:parse!)
       @app.class.instance_eval do
         banner "banner"
       end
 
       OptionParser.expects(:new).with("banner").returns(option_parser)
 
       @app.parse_options
     end
 
     it "should get options from Puppet.settings.optparse_addargs" do
       Puppet.settings.expects(:optparse_addargs).returns([])
 
       @app.parse_options
     end
 
     it "should add Puppet.settings options to OptionParser" do
       Puppet.settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option"]])
       Puppet.settings.expects(:handlearg).with("--option", 'true')
       @app.command_line.stubs(:args).returns(["--option"])
       @app.parse_options
     end
 
     it "should ask OptionParser to parse the command-line argument" do
       @app.command_line.stubs(:args).returns(%w{ fake args })
       OptionParser.any_instance.expects(:parse!).with(%w{ fake args })
 
       @app.parse_options
     end
 
     describe "when using --help" do
 
       it "should call exit" do
         @app.stubs(:puts)
         expect { @app.handle_help(nil) }.to exit_with 0
       end
 
     end
 
     describe "when using --version" do
       it "should declare a version option" do
         @app.should respond_to(:handle_version)
       end
 
       it "should exit after printing the version" do
         @app.stubs(:puts)
         expect { @app.handle_version(nil) }.to exit_with 0
       end
     end
 
     describe "when dealing with an argument not declared directly by the application" do
       it "should pass it to handle_unknown if this method exists" do
         Puppet.settings.stubs(:optparse_addargs).returns([["--not-handled", :REQUIRED]])
 
         @app.expects(:handle_unknown).with("--not-handled", "value").returns(true)
         @app.command_line.stubs(:args).returns(["--not-handled", "value"])
         @app.parse_options
       end
 
       it "should pass it to Puppet.settings if handle_unknown says so" do
         Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet", :REQUIRED]])
 
         @app.stubs(:handle_unknown).with("--topuppet", "value").returns(false)
 
         Puppet.settings.expects(:handlearg).with("--topuppet", "value")
         @app.command_line.stubs(:args).returns(["--topuppet", "value"])
         @app.parse_options
       end
 
       it "should pass it to Puppet.settings if there is no handle_unknown method" do
         Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet", :REQUIRED]])
 
         @app.stubs(:respond_to?).returns(false)
 
         Puppet.settings.expects(:handlearg).with("--topuppet", "value")
         @app.command_line.stubs(:args).returns(["--topuppet", "value"])
         @app.parse_options
       end
 
       it "should transform boolean false value to string for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--option", "false")
         @app.handlearg("--option", false)
       end
 
       it "should transform boolean true value to string for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--option", "true")
         @app.handlearg("--option", true)
       end
 
       it "should transform boolean option to normal form for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--option", "true")
         @app.handlearg("--[no-]option", true)
       end
 
       it "should transform boolean option to no- form for Puppet.settings" do
         Puppet.settings.expects(:handlearg).with("--no-option", "false")
         @app.handlearg("--[no-]option", false)
       end
 
     end
   end
 
   describe "when calling default setup" do
 
     before :each do
       @app.stubs(:should_parse_config?).returns(false)
       @app.options.stubs(:[])
     end
 
     [ :debug, :verbose ].each do |level|
       it "should honor option #{level}" do
         @app.options.stubs(:[]).with(level).returns(true)
         Puppet::Util::Log.stubs(:newdestination)
         @app.setup
         Puppet::Util::Log.level.should == (level == :verbose ? :info : :debug)
       end
     end
 
     it "should honor setdest option" do
       @app.options.stubs(:[]).with(:setdest).returns(false)
 
       Puppet::Util::Log.expects(:newdestination).with(:syslog)
 
       @app.setup
     end
 
   end
 
   describe "when configuring routes" do
     include PuppetSpec::Files
 
     before :each do
       Puppet::Node.indirection.reset_terminus_class
     end
 
     after :each do
       Puppet::Node.indirection.reset_terminus_class
     end
 
     it "should use the routes specified for only the active application" do
       Puppet[:route_file] = tmpfile('routes')
       File.open(Puppet[:route_file], 'w') do |f|
         f.print <<-ROUTES
           test_app:
             node:
               terminus: exec
           other_app:
             node:
               terminus: plain
             catalog:
               terminus: invalid
         ROUTES
       end
 
       @app.configure_indirector_routes
 
       Puppet::Node.indirection.terminus_class.should == 'exec'
     end
 
     it "should not fail if the route file doesn't exist" do
       Puppet[:route_file] = "/dev/null/non-existent"
 
       expect { @app.configure_indirector_routes }.should_not raise_error
     end
 
     it "should raise an error if the routes file is invalid" do
       Puppet[:route_file] = tmpfile('routes')
       File.open(Puppet[:route_file], 'w') do |f|
         f.print <<-ROUTES
          invalid : : yaml
         ROUTES
       end
 
       expect { @app.configure_indirector_routes }.should raise_error
     end
   end
 
   describe "when running" do
 
     before :each do
       @app.stubs(:preinit)
       @app.stubs(:setup)
       @app.stubs(:parse_options)
     end
 
     it "should call preinit" do
       @app.stubs(:run_command)
 
       @app.expects(:preinit)
 
       @app.run
     end
 
     it "should call parse_options" do
       @app.stubs(:run_command)
 
       @app.expects(:parse_options)
 
       @app.run
     end
 
     it "should call run_command" do
 
       @app.expects(:run_command)
 
       @app.run
     end
 
     it "should parse Puppet configuration if should_parse_config is called" do
       @app.stubs(:run_command)
       @app.class.should_parse_config
 
       Puppet.settings.expects(:parse)
 
       @app.run
     end
 
     it "should not parse_option if should_not_parse_config is called" do
       @app.stubs(:run_command)
       @app.class.should_not_parse_config
 
       Puppet.settings.expects(:parse).never
 
       @app.run
     end
 
     it "should parse Puppet configuration if needed" do
       @app.stubs(:run_command)
       @app.stubs(:should_parse_config?).returns(true)
 
       Puppet.settings.expects(:parse)
 
       @app.run
     end
 
     it "should call run_command" do
       @app.expects(:run_command)
 
       @app.run
     end
 
     it "should call main as the default command" do
       @app.expects(:main)
 
       @app.run
     end
 
     it "should warn and exit if no command can be called" do
       $stderr.expects(:puts)
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns no command" do
       @app.stubs(:get_command).returns(nil)
       $stderr.expects(:puts)
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns an invalid command" do
       @app.stubs(:get_command).returns(:this_function_doesnt_exist)
       $stderr.expects(:puts)
       expect { @app.run }.to exit_with 1
     end
   end
 
   describe "when metaprogramming" do
 
     describe "when calling option" do
       it "should create a new method named after the option" do
         @app.class.option("--test1","-t") do
         end
 
         @app.should respond_to(:handle_test1)
       end
 
       it "should transpose in option name any '-' into '_'" do
         @app.class.option("--test-dashes-again","-t") do
         end
 
         @app.should respond_to(:handle_test_dashes_again)
       end
 
       it "should create a new method called handle_test2 with option(\"--[no-]test2\")" do
         @app.class.option("--[no-]test2","-t") do
         end
 
         @app.should respond_to(:handle_test2)
       end
 
       describe "when a block is passed" do
         it "should create a new method with it" do
           @app.class.option("--[no-]test2","-t") do
             raise "I can't believe it, it works!"
           end
 
           lambda { @app.handle_test2 }.should raise_error
         end
 
         it "should declare the option to OptionParser" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.expects(:on).with { |*arg| arg[0] == "--[no-]test3" }
 
           @app.class.option("--[no-]test3","-t") do
           end
 
           @app.parse_options
         end
 
         it "should pass a block that calls our defined method" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.stubs(:on).with('--test4','-t').yields(nil)
 
           @app.expects(:send).with(:handle_test4, nil)
 
           @app.class.option("--test4","-t") do
           end
 
           @app.parse_options
         end
       end
 
       describe "when no block is given" do
         it "should declare the option to OptionParser" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.expects(:on).with("--test4","-t")
 
           @app.class.option("--test4","-t")
 
           @app.parse_options
         end
 
         it "should give to OptionParser a block that adds the the value to the options array" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.stubs(:on).with("--test4","-t").yields(nil)
 
           @app.options.expects(:[]=).with(:test4,nil)
 
           @app.class.option("--test4","-t")
 
           @app.parse_options
         end
       end
     end
 
   end
 end