diff --git a/ext/nagios/naggen b/ext/nagios/naggen
index 16dbe6ce4..6d5be7b0f 100755
--- a/ext/nagios/naggen
+++ b/ext/nagios/naggen
@@ -1,309 +1,309 @@
 #!/usr/bin/env ruby
 #
 # = Synopsis
 #
 # Generate Nagios configurations from Puppet Resources in an ActiveRecord database
 #
 # = Usage
 #
 #   naggen [-h|--help] [-d|--debug] [-v|--verbose] [--compare]
 #
 # = Description
 #
 # This executable is a means of short-circuiting the process of generating nagios
 # configurations on your server using Puppet Exported Resources.  It skips any possible
 # naming conflicts resulting from Puppet's resource uniqueness requirements, and it
 # also skips the inefficiencies involved in converting and transporting large numbers
 # of Puppet resources.
 #
 # At the least, the machine that runs this will need ActiveRecord (2.0.2) installed,
 # along with any database libraries you use.
 #
 # = Options
 #
 # Note that any configuration parameter that's valid in the configuration file
 # is also a valid long argument.  For example, 'ssldir' is a valid configuration
 # parameter, so you can specify '--ssldir <directory>' as an argument.
 #
 # You can add naggen-specific settings to your puppet.conf in a '[naggen]' section,
 # just like any other executable.
 #
 # See the configuration file documentation at
 # http://reductivelabs.com/projects/puppet/reference/configref.html for
 # the full list of acceptable parameters. A commented list of all
 # configuration options can also be generated by running puppet with
 # '--genconfig'.
 #
 # compare::
 #   Compare new and old files and only backup and write if the files are different.
 #   Potentially expensive computationally, but idempotent.  Will exit with 0 if
 #   no changes were made and 1 if there were.
 #
 # 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, and an exit code of '4' means that there
 #   were failures during the transaction.
 #
 # help::
 #   Print this help message
 #
 # verbose::
 #   Print extra information.
 #
 # = Example
 #
 #   naggen --storeconfigs --confdir /foo --compare
 #
 #
 # = License
 #   Copyright 2011 Luke Kanies
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
 #   You may obtain a copy of the License at
 #
 #       http://www.apache.org/licenses/LICENSE-2.0
 #
 #   Unless required by applicable law or agreed to in writing, software
 #   distributed under the License is distributed on an "AS IS" BASIS,
 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
 require 'puppet'
 require 'puppet/rails'
 require 'puppet/rails/resource'
 require 'puppet/rails/param_value'
 require 'puppet/network/client'
 require 'puppet/parser/collector'
 require 'puppet/provider/naginator'
 require 'getoptlong'
 
 # Monkey-patch the rails resources so we can
 # easily convert them to nagios instances.
 class Puppet::Rails::Resource
     def to_param_hash
         values = @params_hash || Puppet::Rails::ParamValue.find_all_params_from_resource(self)
         if values.size == 0
             return {}
         end
         values.inject({}) do |hash, value|
             hash[value['name']] ||= []
             hash[value['name']] << value["value"]
             hash
         end
     end
 
     def to_nagios
         unless nagios_type = Nagios::Base.type(restype.sub("Nagios_", '').to_sym)
             raise Puppet::DevError, "Could not find nagios type '%s'" % restype
         end
 
         result = nagios_type.new
 
         to_param_hash.each do |param, value|
             next unless nagios_type.parameter?(param)
             result[param] = value
         end
 
         result[:name] = self.title
 
         result
     end
 end
 
 class NagiosWriter
     class FakeScope
         def debug(string)
             Puppet.debug string
         end
 
         def host
             "this host doesn't exist"
         end
     end
 
     attr_accessor :nagios_type, :bucket
 
     def backup(target)
         return unless FileTest.exist?(target) and File.stat(target).size > 0
 
         Puppet.info "Backing up %s" % target
         bucket.backup(target)
     end
 
     def collector
         collector = Puppet::Parser::Collector.new(FakeScope.new, "nagios_" + @nagios_type.to_s, nil, nil, :exported)
 
         # We don't have a scope, so we're stubbing everything out that would interact
         # with the scope.
         class << collector
             def collect_virtual(*args)
                 []
             end
 
             def exported_resource(res)
                 res
             end
         end
 
         collector
     end
 
     def default_target
         "/etc/nagios/nagios_#{nagios_type.to_s}.cfg"
     end
 
     def evaluate
         return unless resources = rails_resources()
 
         resources_by_target = resources.inject({}) do |hash, resource|
             target = resource["target"] || default_target
             hash[target] ||= []
             hash[target] << resource
             hash
         end
 
         changed = false
         resources_by_target.each do |target, resources|
             begin
                 result = write(target, resources)
             rescue => detail
                 $stderr.puts detail.backtrace
                 Puppet.err "Could not write to %s: %s" % [target, detail]
             end
 
             changed = true if result
         end
 
         changed
     end
 
     def initialize(nagios_type)
         @nagios_type = nagios_type
 
         @bucket = Puppet::FileBucket::Dipper.new(:Path => Puppet[:clientbucketdir])
     end
 
     def rails_resources
         collector.send(:collect_exported)
     end
 
     def write(target, resources)
         # Skip the nagios type when we have no resources and no existing
         # file.
         return if resources.empty? and ! FileTest.exist?(target)
 
         dir = File.dirname(target)
         unless FileTest.exist?(dir)
             FileUtils.mkdir_p(dir)
         end
 
         count = 0
 
         tempfile = target + ".tmp"
         File.open(tempfile, "w") do |file|
             resources.each do |resource|
                 count += 1
                 file.puts resource.to_nagios.to_s.gsub("_naginator_name", Puppet::Provider::Naginator::NAME_STRING)
             end
         end
 
         if $options[:compare]
             if FileTest.exist?(target) and File.read(tempfile) == File.read(target)
                 return false
             end
         end
 
         backup(target)
 
         # Atomic rename
         File.rename(tempfile, target)
 
         Puppet.notice "Wrote %s resources to %s" % [count, target]
 
         return true
     ensure
         File.unlink(tempfile) if tempfile and FileTest.exist?(tempfile)
     end
 end
 
 arguments = [
     [ "--compare", "-c", GetoptLong::NO_ARGUMENT ],
     [ "--debug",   "-d", GetoptLong::NO_ARGUMENT ],
     [ "--verbose", "-v", GetoptLong::NO_ARGUMENT ],
     [ "--help",    "-h", GetoptLong::NO_ARGUMENT ]
 ]
 
 Puppet.settings.addargs(arguments)
 
 result = GetoptLong.new(*arguments)
 
 $options = {}
 result.each { |opt,arg|
     case opt
         when "--help"
             begin
                 require 'rdoc/usage'
                 RDoc::usage && exit
             rescue LoadError
                 docs = []
                 File.readlines(__FILE__).each do |line|
                     next if line =~ /^#\!/
                     unless line =~ /^#/
                         next if docs.length == 0 # skip the first line or so
                         break # else, we've passed the docs, so just break
                     end
                     docs << line.sub(/^# ?/, '')
                 end
 
                 print docs
                 exit
             end
         when "--compare"
             $options[:compare] = true
         when "--verbose"
             $options[:verbose] = true
         when "--debug"
             $options[:debug] = true
         when "--debug"
             $options[:debug] = true
     else
             Puppet.settings.handlearg(opt, arg)
     end
 }
 
 # Read in Puppet settings, so we know how Puppet's configured.
-Puppet.parse_config
+Puppet.initialize_settings
 
 Puppet::Util::Log.newdestination(:console)
 
 if $options[:debug]
     Puppet::Util::Log.level = :debug
 elsif $options[:verbose]
     Puppet::Util::Log.level = :info
 end
 
 # See if Naginator is installed directly, else load Puppet's version.
 begin
     require 'nagios'
 rescue LoadError
     require 'puppet/external/nagios'
 end
 
 changed = false
 Nagios::Base.eachtype do |name, type|
     writer = NagiosWriter.new(name)
 
     changed = true if writer.evaluate
 end
 
 if $options[:compare] and changed
     exit(1)
 else
     exit(0)
 end
 
diff --git a/ext/puppet-test b/ext/puppet-test
index affb01249..c2264da8c 100755
--- a/ext/puppet-test
+++ b/ext/puppet-test
@@ -1,566 +1,566 @@
 #!/usr/bin/env ruby
 # == Synopsis
 #
 # Test individual client performance.  Can compile configurations, describe
 # files, or retrieve files.
 #
 # = Usage
 #
 #   puppet-test  [-c|--compile] [-D|--describe <file>] [-d|--debug]
 #       [--fork <num>] [-h|--help] [-H|--hostname <host name>] [-l|--list] [-r|--repeat <number=1>]
 #       [-R|--retrieve <file>] [-t|--test <test>] [-V|--version] [-v|--verbose]
 #
 # = Description
 #
 # This is a simple script meant for doing performance tests with Puppet.  By
 # default it pulls down a compiled configuration, but it supports multiple
 # other tests.
 #
 # = 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.
 #
 # See the configuration file documentation at
 # http://reductivelabs.com/projects/puppet/reference/configref.html for
 # the full list of acceptable parameters. A commented list of all
 # configuration $options can also be generated by running puppetd with
 # '--genconfig'.
 #
 # compile::
 #   Compile the client's configuration.  The default.
 #
 # debug::
 #   Enable full debugging.
 #
 # describe::
 #   Describe the file being tested.  This is a query to get information about
 #   the file from the server, to determine if it should be copied, and is the
 #   first half of every file transfer.
 #
 # fork::
 #   Fork the specified number of times, thus acting as multiple clients.
 #
 # fqdn::
 #   Set the fully-qualified domain name of the client.  This is only used for
 #   certificate purposes, but can be used to override the discovered hostname.
 #   If you need to use this flag, it is generally an indication of a setup problem.
 #
 # help::
 #   Print this help message
 #
 # list::
 #   List all available tests.
 #
 # node::
 #  Specify the node to use.  This is useful for looking up cached yaml data
 #  in your :clientyaml directory, and forcing a specific host's configuration to
 #  get compiled.
 #
 # pause::
 #  Pause before starting test (useful for testing with dtrace).
 #
 # repeat::
 #  How many times to perform the test.
 #
 # retrieve::
 #   Test file retrieval performance.  Retrieves the specified file from the
 #   remote system.  Note that the server should be specified via --server,
 #   so the argument to this option is just the remote module name and path,
 #   e.g., "/dist/apps/myapp/myfile", where "dist" is the module and
 #   "apps/myapp/myfile" is the path to the file relative to the module.
 #
 # test::
 #   Specify the test to run.  You can see the list of tests by running this command with --list.
 #
 # verbose::
 #   Turn on verbose reporting.
 #
 # version::
 #   Print the puppet version number and exit.
 #
 # = Example
 #
 #   puppet-test --retrieve /module/path/to/file
 #
 # = License
 #   Copyright 2011 Luke Kanies
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
 #   You may obtain a copy of the License at
 #
 #       http://www.apache.org/licenses/LICENSE-2.0
 #
 #   Unless required by applicable law or agreed to in writing, software
 #   distributed under the License is distributed on an "AS IS" BASIS,
 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
 # Do an initial trap, so that cancels don't get a stack trace.
 trap(:INT) do
     $stderr.puts "Cancelling startup"
     exit(1)
 end
 
 require 'puppet'
 require 'puppet/network/client'
 require 'getoptlong'
 
 class Suite
     attr_reader :name, :doc
 
     @@suites = {}
     @@tests = {}
 
     def self.[](name)
         @@suites[name]
     end
 
     # Run a test by first finding the suite then running the appropriate test.
     def self.run(test)
         unless suite_name = @@tests[test]
             raise "Unknown test %s" % test
 
         end
         unless suite = @@suites[suite_name]
             raise "Unknown test suite %s from test %s" % [suite_name, test]
         end
 
         suite.run(test)
     end
 
     # What suites are available?
     def self.suites
         @@suites.keys
     end
 
     def forked?
         defined? @forking
     end
 
     # Create a new test suite.
     def initialize(name, doc, &block)
         @name = name
         @doc = doc
 
         @tests = {}
 
         @@suites[name] = self
 
         raise "You must pass a block to the Test" unless block_given?
         instance_eval(&block)
     end
 
     # Define a new type of test on this suite.
     def newtest(name, doc, &block)
         @tests[name] = doc
 
         if @@tests[name]
             raise "Test names must be unique; cannot redefine %s" % name
         end
 
         @@tests[name] = @name
 
         meta_def(name, &block)
     end
 
     # Run the actual test.
     def run(test)
         unless doc = @tests[test]
             raise "Suite %s only supports tests %s; not %s" % [@name, @tests.keys.collect { |k| k.to_s }.join(","), test]
         end
         puts "Running %s %s test" % [@name, test]
 
         prepare() if respond_to?(:prepare)
 
         if $options[:pause]
             puts "Hit any key to continue"
             $stdin.readline
             puts "Continuing with test"
         end
 
         if $options[:fork] > 0
             @forking = true
             $options[:fork].times {
                 if pid = fork
                     $pids << pid
                 else
                     break
                 end
             }
         end
 
         $options[:repeat].times do |i|
             @count = i
             if forked?
                 msg = doc + " in PID %s" % Process.pid
             else
                 msg = doc
             end
             Puppet::Util.benchmark(:notice, msg) do
                 begin
                     send(test)
                 rescue => detail
                     puts detail.backtrace if Puppet[:trace]
                     Puppet.err "%s failed: %s" % [@name, detail.to_s]
                 end
             end
         end
     end
 
     # What tests are available on this suite?
     def tests
         @tests.keys
     end
 end
 
 Suite.new :parser, "Manifest parsing" do
     newtest :parse, "Parsed files" do
         @parser = Puppet::Parser::Parser.new(:environment => Puppet[:environment])
         @parser.file = Puppet[:manifest]
         @parser.parse
     end
 end
 
 Suite.new :local_catalog, "Local catalog handling" do
     def prepare
         @node = Puppet::Node.find($options[:nodes][0])
     end
 
     newtest :compile, "Compiled catalog" do
         Puppet::Resource::Catalog.find(@node)
     end
 end
 
 Suite.new :resource_type, "Managing resource types" do
     newtest :find, "Find a type" do
         Puppet::Resource::Type.terminus_class = :parser
         ARGV.each do |name|
             json = Puppet::Resource::Type.find(name).to_pson
             data = PSON.parse(json)
             p Puppet::Resource::Type.from_pson(data)
         end
     end
 
     newtest :search_types, "Find all types" do
         Puppet::Resource::Type.terminus_class = :rest
         result = Puppet::Resource::Type.search("*")
         result.each { |r| p r }
     end
 
     newtest :restful_type, "Find a type and return it via REST" do
         Puppet::Resource::Type.terminus_class = :rest
         ARGV.each do |name|
             p Puppet::Resource::Type.find(name)
         end
     end
 end
 
 Suite.new :remote_catalog, "Remote catalog handling" do
     def prepare
         $args[:cache] = false
         # Create a config client and pull the config down
         @client = Puppet::Network::Client.master.new($args)
         unless @client.read_cert
             fail "Could not read client certificate"
         end
 
         if tmp = Puppet::Node::Facts.find($options[:nodes][0])
             @facts = tmp.values
         else
             raise "Could not find facts for %s" % $optins[:nodes][0]
         end
 
         if host = $options[:fqdn]
             @facts["fqdn"] = host
             @facts["hostname"] = host.sub(/\..+/, '')
             @facts["domain"] = host.sub(/^[^.]+\./, '')
         end
 
         @facts = YAML.dump(@facts)
     end
 
     newtest :getconfig, "Compiled catalog" do
         @client.driver.getconfig(@facts, "yaml")
     end
 
     # This test will always force a false answer.
     newtest :fresh, "Checked freshness" do
         @client.driver.freshness
     end
 end
 
 Suite.new :file, "File interactions" do
     def prepare
         unless $options[:file]
             fail "You must specify a file (using --file <file>) to interact with on the server"
         end
         @client = Puppet::Network::Client.file.new($args)
         unless @client.read_cert
             fail "Could not read client certificate"
         end
     end
 
     newtest :describe, "Described file" do
         @client.describe($options[:file], :ignore)
     end
 
     newtest :retrieve, "Retrieved file" do
         @client.retrieve($options[:file], :ignore)
     end
 end
 
 Suite.new :filebucket, "Filebucket interactions" do
     def prepare
         require 'tempfile'
         @client = Puppet::FileBucket::Dipper.new($args)
     end
 
     newtest :backup, "Backed up file" do
         Tempfile.open("bucket_testing") do |f|
             f.print rand(1024)
             f.close
             @client.backup(f.path)
         end
     end
 end
 
 # Note that this uses an env variable to determine how many resources per
 # host to create (with a default of 10).  'repeat' determines how
 # many hosts to create.  You probably will get mad failures if you
 # use forking and sqlite.
 # Here's an example run of this test, using sqlite:
 #   RESOURCE_COUNT=50 ext/puppet-test --suite rails --test storage --confdir /tmp/storagetesting --vardir /tmp/storagetesting --repeat 10
 Suite.new :rails, "Rails Interactions" do
     def prepare
         Puppet::Rails.init
         @facts = Facter.to_hash
 
         if num = ENV["RESOURCECOUNT"]
             @resources = Integer(num)
         else
             @resources = 10
         end
     end
 
     Resource = Puppet::Parser::Resource
 
     def execute(test, msg)
         begin
             send(test)
         rescue => detail
             puts detail.backtrace if Puppet[:trace]
             Puppet.err "%s failed: %s" % [@name, detail.to_s]
         end
     end
 
     def mkresource(type, title, parameters)
         source = "fakesource"
         res = Resource.new(:type => type, :title => title, :source => source, :scope => "fakescope")
 
         parameters.each do |param, value|
             res.set(param, value, source)
         end
         res
     end
 
     def ref(type, title)
         Resource::Reference.new(:type => type, :title => title)
     end
 
     newtest :storage, "Stored resources" do
         hostname = "host%s" % @count
         @facts["hostname"] = hostname
         args = {:facts => @facts, :name => hostname}
 
         # Make all of the resources we want.  Make them at least slightly complex,
         # so we model real resources as close as we can.
         resources = []
         args[:resources] = resources
         @resources.times do |resnum|
             exec = mkresource("exec", "exec%s" % resnum, :command => "/bin/echo do something %s" % resnum)
             exec.tags = %w{exec one} << "exec%s" % resnum
             user = mkresource("user", "user%s" % resnum, :uid => resnum.to_s, :require => ref("exec", "exec%s" % resnum))
             user.tags = %w{user one two} << "user%s" % resnum
             file = mkresource("file", "/tmp/file%s" % resnum, :owner => resnum.to_s, :require => [ref("exec", "exec%s" % resnum), ref("user", "user%s" % resnum)])
             file.tags = %w{file one three} << "file%s" % resnum
             file.exported = true
             resources << exec << user << file
         end
         Puppet::Rails::Host.store(args)
     end
 end
 
 Suite.new :report, "Reports interactions" do
     def prepare
         Puppet::Transaction::Report.terminus_class = :rest
     end
 
     newtest :empty, "send empty report" do
         report = Puppet::Transaction::Report.new
         report.time = Time.now
         report.save
     end
 
     newtest :fake, "send fake report" do
         report = Puppet::Transaction::Report.new
 
         resourcemetrics = {
             :total => 12,
             :out_of_sync => 20,
             :applied => 45,
             :skipped => 1,
             :restarted => 23,
             :failed_restarts => 1,
             :scheduled => 10
         }
         report.newmetric(:resources, resourcemetrics)
 
         timemetrics = {
             :resource1 => 10,
             :resource2 => 50,
             :resource3 => 40,
             :resource4 => 20,
         }
         report.newmetric(:times, timemetrics)
 
         report.newmetric(:changes,
             :total => 20
         )
 
         report.time = Time.now
         report.save
     end
 end
 
 
 $cmdargs = [
     [ "--compile",  "-c", GetoptLong::NO_ARGUMENT       ],
     [ "--describe",       GetoptLong::REQUIRED_ARGUMENT ],
     [ "--retrieve", "-R", GetoptLong::REQUIRED_ARGUMENT ],
     [ "--fork",           GetoptLong::REQUIRED_ARGUMENT ],
     [ "--fqdn",     "-F", GetoptLong::REQUIRED_ARGUMENT ],
     [ "--suite",    "-s", GetoptLong::REQUIRED_ARGUMENT ],
     [ "--test",     "-t", GetoptLong::REQUIRED_ARGUMENT ],
     [ "--pause",    "-p", GetoptLong::NO_ARGUMENT       ],
     [ "--repeat",   "-r", GetoptLong::REQUIRED_ARGUMENT ],
     [ "--node",     "-n", GetoptLong::REQUIRED_ARGUMENT ],
     [ "--debug",    "-d", GetoptLong::NO_ARGUMENT       ],
     [ "--help",     "-h", GetoptLong::NO_ARGUMENT       ],
     [ "--list",     "-l", GetoptLong::NO_ARGUMENT       ],
     [ "--verbose",  "-v", GetoptLong::NO_ARGUMENT       ],
     [ "--version",  "-V", GetoptLong::NO_ARGUMENT       ],
 ]
 
 # Add all of the config parameters as valid $options.
 Puppet.settings.addargs($cmdargs)
 Puppet::Util::Log.newdestination(:console)
 
 Puppet::Node.terminus_class = :plain
 Puppet::Node.cache_class = :yaml
 Puppet::Node::Facts.terminus_class = :facter
 Puppet::Node::Facts.cache_class = :yaml
 
 result = GetoptLong.new(*$cmdargs)
 
 $args = {}
 
 $options = {:repeat => 1, :fork => 0, :pause => false, :nodes => []}
 
 begin
     explicit_waitforcert = false
     result.each { |opt,arg|
         case opt
             # First check to see if the argument is a valid configuration parameter;
             # if so, set it.
             when "--compile"
                 $options[:suite] = :configuration
                 $options[:test] = :compile
             when "--retrieve"
                 $options[:suite] = :file
                 $options[:test] = :retrieve
                 $options[:file] = arg
             when "--fork"
                 begin
                     $options[:fork] = Integer(arg)
                 rescue => detail
                     $stderr.puts "The argument to 'fork' must be an integer"
                     exit(14)
                 end
             when "--describe"
                 $options[:suite] = :file
                 $options[:test] = :describe
                 $options[:file] = arg
             when "--fqdn"
                 $options[:fqdn] = arg
             when "--repeat"
                 $options[:repeat] = Integer(arg)
             when "--help"
                 if Puppet.features.usage?
                     RDoc::usage && exit
                 else
                     puts "No help available unless you have RDoc::usage installed"
                     exit
                 end
             when "--version"
                 puts "%s" % Puppet.version
                 exit
             when "--verbose"
                 Puppet::Util::Log.level = :info
                 Puppet::Util::Log.newdestination(:console)
             when "--debug"
                 Puppet::Util::Log.level = :debug
                 Puppet::Util::Log.newdestination(:console)
             when "--suite"
                 $options[:suite] = arg.intern
             when "--test"
                 $options[:test] = arg.intern
             when "--file"
                 $options[:file] = arg
             when "--pause"
                 $options[:pause] = true
             when "--node"
                 $options[:nodes] << arg
             when "--list"
                 Suite.suites.sort { |a,b| a.to_s <=> b.to_s }.each do |suite_name|
                     suite = Suite[suite_name]
                     tests = suite.tests.sort { |a,b| a.to_s <=> b.to_s }.join(", ")
                     puts "%20s: %s" % [suite_name, tests]
                 end
                 exit(0)
             else
                 Puppet.settings.handlearg(opt, arg)
         end
     }
 rescue GetoptLong::InvalidOption => detail
     $stderr.puts detail
     $stderr.puts "Try '#{$0} --help'"
     exit(1)
 end
 
 # Now parse the config
-Puppet.parse_config
+Puppet.initialize_settings
 
 $options[:nodes] << Puppet.settings[:certname] if $options[:nodes].empty?
 
 $args[:Server] = Puppet[:server]
 
 unless $options[:test]
     $options[:suite] = :remote_catalog
     $options[:test] = :getconfig
 end
 
 unless $options[:test]
     raise "A suite was specified without a test"
 end
 
 $pids = []
 
 Suite.run($options[:test])
 
 if $options[:fork] > 0
     Process.waitall
 end
diff --git a/ext/puppetlisten/puppetlisten.rb b/ext/puppetlisten/puppetlisten.rb
index 9c1709cde..c7308753a 100755
--- a/ext/puppetlisten/puppetlisten.rb
+++ b/ext/puppetlisten/puppetlisten.rb
@@ -1,76 +1,75 @@
 #! /usr/bin/env ruby
 # this is a daemon which accepts non standard (within puppet normal intervals) puppet configruation run request
 # uses SSL for communication based on the puppet infrastructure
 # ohadlevy@gmail.com
 
 port = 8139
 cmd = "puppetd -o -v --no-daemonize"
 
 require 'puppet/sslcertificates/support'
 require 'socket'
 require 'facter'
 
 # load puppet configuration, needed to find SSL certificates
-Puppet[:config] = "/etc/puppet/puppet.conf"
-Puppet.parse_config
+Puppet.initialize_settings
 
 # set the SSL environment
 ctx = OpenSSL::SSL::SSLContext.new
 ctx.key = OpenSSL::PKey::RSA.new(File::read(Puppet[:hostprivkey]))
 ctx.cert = OpenSSL::X509::Certificate.new(File::read(Puppet[:hostcert]))
 ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER|OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
 ctx.ca_file = Puppet[:localcacert]
 
 # find which hosts are allowed to trigger us
 allowed_servers = Array.new
 runner = false;
 File.open(Puppet[:authconfig]).each do |line|
   case line
   when /^\s*#/: next # skip comments
   when /^\s*$/: next # skip blank lines
   when /\[puppetrunner\]/: # puppetrunner section
     runner=true
   when /^\s*(\w+)\s+(.+)$/:
     var = $1
     value = $2
     case var
     when "allow":
       value.split(/\s*,\s*/).each { |val|
       allowed_servers << val
       puts "allowing #{val} access"
     } if runner==true
     end
   else
     runner=false
   end
 end
 
 # be a daemon
 sock = TCPServer.new(port)
 ssls = OpenSSL::SSL::SSLServer.new(sock, ctx)
 
 loop do
   begin
     ns = ssls.accept # start SSL session
     af, port, host, ip = ns.peeraddr
     print "connection from #{host+"("+ip+")"} "
     if allowed_servers.include?(host)
       #TODO add support for tags and other command line arguments
       puts "accepted"
       ns.puts "Executing #{cmd} on #{Facter.fqdn}.\n*******OUTPUT********\n\n"
       IO.popen(cmd) do |f|
         while line = f.gets
           ns.puts line
         end
       end
       ns.puts "\n*********DONE**********"
     else
       ns.puts "denied\n"
       puts "denied"
     end
     ns.close
   rescue
     ns.close
     next
   end
 end
diff --git a/ext/puppetlisten/puppetrun.rb b/ext/puppetlisten/puppetrun.rb
index 2fe31b7f4..9c6b72d59 100755
--- a/ext/puppetlisten/puppetrun.rb
+++ b/ext/puppetlisten/puppetrun.rb
@@ -1,39 +1,38 @@
 #! /usr/bin/env ruby
 # this scripts calls a client and ask him to trigger a puppetd run
 # uses SSL for communication based on the puppet infrastructure
 # the client allows access based on the namespaceauth
 # ohadlevy@gmail.com
 
 port = 8139
 if ARGV[0].nil?
   warn "Usage: hostname to run against"
   exit 1
 else
   host = ARGV[0]
 end
 
 require 'puppet/sslcertificates/support'
 require 'socket'
 
 # load puppet configuration, needed to find ssl certificates
-Puppet[:config] = "/etc/puppet/puppet.conf"
-Puppet.parse_config
+Puppet.initialize_settings
 
 # establish the certificate
 ctx = OpenSSL::SSL::SSLContext.new
 ctx.key = OpenSSL::PKey::RSA.new(File::read(Puppet[:hostprivkey]))
 ctx.cert = OpenSSL::X509::Certificate.new(File::read(Puppet[:hostcert]))
 ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
 ctx.ca_file = Puppet[:localcacert]
 
 # establish the connection
 s = TCPSocket.new(host, port)
 ssl = OpenSSL::SSL::SSLSocket.new(s, ctx)
 ssl.connect # start SSL session
 ssl.sync_close = true  # if true the underlying socket will be
 #                        closed in SSLSocket#close. (default: false)
 while (line = ssl.gets)
   puts line
 end
 
 ssl.close
diff --git a/lib/puppet.rb b/lib/puppet.rb
index d1643f61f..d5c5fed8e 100644
--- a/lib/puppet.rb
+++ b/lib/puppet.rb
@@ -1,140 +1,166 @@
 # Try to load rubygems.  Hey rubygems, I hate you.
 begin
   require 'rubygems'
 rescue LoadError
 end
 
 # see the bottom of the file for further inclusions
 require 'singleton'
 require 'facter'
 require 'puppet/error'
 require 'puppet/util'
 require 'puppet/util/autoload'
 require 'puppet/util/settings'
 require 'puppet/util/feature'
 require 'puppet/util/suidmanager'
 require 'puppet/util/run_mode'
 
 #------------------------------------------------------------
 # the top-level module
 #
 # all this really does is dictate how the whole system behaves, through
 # preferences for things like debugging
 #
 # it's also a place to find top-level commands like 'debug'
 
 module Puppet
   PUPPETVERSION = '2.7.14'
 
   def Puppet.version
     PUPPETVERSION
   end
 
   class << self
     include Puppet::Util
     attr_reader :features
     attr_writer :name
   end
 
   # the hash that determines how our system behaves
   @@settings = Puppet::Util::Settings.new
 
   # The services running in this process.
   @services ||= []
 
   require 'puppet/util/logging'
 
   extend Puppet::Util::Logging
 
   # The feature collection
   @features = Puppet::Util::Feature.new('puppet/feature')
 
   # Load the base features.
   require 'puppet/feature/base'
 
   # Store a new default value.
   def self.define_settings(section, hash)
     @@settings.define_settings(section, hash)
   end
 
   # configuration parameter access and stuff
   def self.[](param)
     if param == :debug
       return Puppet::Util::Log.level == :debug
     else
       return @@settings[param]
     end
   end
 
   # configuration parameter access and stuff
   def self.[]=(param,value)
     @@settings[param] = value
   end
 
   def self.clear
     @@settings.clear
   end
 
   def self.debug=(value)
     if value
       Puppet::Util::Log.level=(:debug)
     else
       Puppet::Util::Log.level=(:notice)
     end
   end
 
   def self.settings
     @@settings
   end
 
 
   def self.run_mode
     # This sucks (the existence of this method); there are a lot of places in our code that branch based the value of
     # "run mode", but there used to be some really confusing code paths that made it almost impossible to determine
     # when during the lifecycle of a puppet application run the value would be set properly.  A lot of the lifecycle
     # stuff has been cleaned up now, but it still seems frightening that we rely so heavily on this value.
     #
     # I'd like to see about getting rid of the concept of "run_mode" entirely, but there are just too many places in
     # the code that call this method at the moment... so I've settled for isolating it inside of the Settings class
     # (rather than using a global variable, as we did previously...).  Would be good to revisit this at some point.
     #
     # --cprice 2012-03-16
     Puppet::Util::RunMode[@@settings.run_mode]
   end
 
   # Load all of the configuration parameters.
   require 'puppet/defaults'
 
   def self.genmanifest
     if Puppet[:genmanifest]
       puts Puppet.settings.to_manifest
       exit(0)
     end
   end
 
   # Parse the config file for this process.
-  def self.parse_config
-    Puppet.settings.parse
+  def self.parse_config()
+    Puppet.deprecation_warning("Puppet.parse_config is deprecated; please use Faces API (which will handle settings and state management for you), or (less desirable) call Puppet.initialize_settings")
+    Puppet.initialize_settings
   end
 
+  # Initialize puppet's settings.  This is intended only for use by external tools that are not
+  #  built off of the Faces API or the Puppet::Util::Application class.  It may also be used
+  #  to initialize state so that a Face may be used programatically, rather than as a stand-alone
+  #  command-line tool.
+  #
+  # Note that this API may be subject to change in the future.
+  def self.initialize_settings()
+    do_initialize_settings_for_run_mode(:user)
+  end
+
+  # Initialize puppet's settings for a specified run_mode.  This
+  def self.initialize_settings_for_run_mode(run_mode)
+    Puppet.deprecation_warning("initialize_settings_for_run_mode may be removed in a future release, as may run_mode itself")
+    do_initialize_settings_for_run_mode(run_mode)
+  end
+
+  # private helper method to provide the implementation details of initializing for a run mode,
+  #  but allowing us to control where the deprecation warning is issued
+  def self.do_initialize_settings_for_run_mode(run_mode)
+    Puppet.settings.initialize_global_settings
+    run_mode = Puppet::Util::RunMode[run_mode]
+    Puppet.settings.initialize_app_defaults(Puppet::Util::Settings.app_defaults_for_run_mode(run_mode))
+  end
+  private_class_method :do_initialize_settings_for_run_mode
+
   # Create a new type.  Just proxy to the Type class.  The mirroring query
   # code was deprecated in 2008, but this is still in heavy use.  I suppose
   # this can count as a soft deprecation for the next dev. --daniel 2011-04-12
   def self.newtype(name, options = {}, &block)
     Puppet::Type.newtype(name, options, &block)
   end
 end
 
 # This feels weird to me; I would really like for us to get to a state where there is never a "require" statement
 #  anywhere besides the very top of a file.  That would not be possible at the moment without a great deal of
 #  effort, but I think we should strive for it and revisit this at some point.  --cprice 2012-03-16
 
 require 'puppet/type'
 require 'puppet/parser'
 require 'puppet/resource'
 require 'puppet/network'
 require 'puppet/ssl'
 require 'puppet/module'
 require 'puppet/util/storage'
 require 'puppet/status'
 require 'puppet/file_bucket/file'
diff --git a/lib/puppet/application.rb b/lib/puppet/application.rb
index b009902bf..f2d792ee1 100644
--- a/lib/puppet/application.rb
+++ b/lib/puppet/application.rb
@@ -1,414 +1,410 @@
 require 'optparse'
 require 'puppet/util/plugins'
 require 'puppet/error'
 
 # 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/*" )
 
 
   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 = 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)
       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
 
     #
     # I think that it would be nice to look into changing this into two methods (getter/setter); however,
     #  it sounds like this is a desirable feature of our ruby DSL. --cprice 2012-03-06
     #
 
     # 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 app_defaults()
-    {
-        :run_mode => self.class.run_mode.name,
-        :confdir  => self.class.run_mode.conf_dir,
-        :vardir   => self.class.run_mode.var_dir,
-        :rundir   => self.class.run_mode.run_dir,
-        :logdir   => self.class.run_mode.log_dir,
-    }
+    Puppet::Util::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 = nil)
 
     require 'puppet/util/command_line'
     @command_line = command_line || Puppet::Util::CommandLine.new
     @options = {}
 
   end
 
   # This is the main application entry point
   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
 
     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("run")                                          { plugin_hook('run_command')   { run_command } }
   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] 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.setup_default 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)
 
     # He're 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::Util::CommandLine.clean_opt(opt, val)
+    opt, val = Puppet::Util::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 a368ffdc8..c044c7997 100644
--- a/lib/puppet/application/doc.rb
+++ b/lib/puppet/application/doc.rb
@@ -1,279 +1,276 @@
 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'. 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])
     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
   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
 
-    # 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/face_base.rb b/lib/puppet/application/face_base.rb
index b8ecc9c00..9615f120e 100644
--- a/lib/puppet/application/face_base.rb
+++ b/lib/puppet/application/face_base.rb
@@ -1,265 +1,261 @@
 require 'puppet/application'
 require 'puppet/face'
 require 'optparse'
 require 'pp'
 
 class Puppet::Application::FaceBase < Puppet::Application
   run_mode :agent
 
   option("--debug", "-d") do |arg|
     Puppet::Util::Log.level = :debug
   end
 
   option("--verbose", "-v") do |_|
     Puppet::Util::Log.level = :info
   end
 
   option("--render-as FORMAT") do |format|
     self.render_as = format.to_sym
   end
 
   # This seems like a bad thing; it seems like--in an ideal world--a given app/face should have one constant run mode.
   #  This isn't currently possible because of issues relating to the certificate authority, but I've left some notes
   #  about "run_mode" in settings.rb and defaults.rb, and if we are able to tighten up the behavior / implementation
   #  of that setting, we might want to revisit this.  --cprice 2012-03-16
   option("--mode RUNMODE", "-r") do |arg|
     raise "Invalid run mode #{arg}; supported modes are user, agent, master" unless %w{user agent master}.include?(arg)
     self.class.run_mode(arg.to_sym)
   end
 
 
   attr_accessor :face, :action, :type, :arguments, :render_as
 
   def render_as=(format)
     if format == :json then
       @render_as = Puppet::Network::FormatHandler.format(:pson)
     else
       @render_as = Puppet::Network::FormatHandler.format(format)
     end
     @render_as or raise ArgumentError, "I don't know how to render '#{format}'"
   end
 
   def render(result, args_and_options)
     hook = action.when_rendering(render_as.name)
 
     if hook
       # when defining when_rendering on your action you can optionally
       # include arguments and options
       if hook.arity > 1
         result = hook.call(result, *args_and_options)
       else
         result = hook.call(result)
       end
     end
 
     render_as.render(result)
   end
 
   def preinit
     super
     Signal.trap(:INT) do
       $stderr.puts "Cancelling Face"
       exit(0)
     end
   end
 
   def parse_options
     # We need to parse enough of the command line out early, to identify what
     # the action is, so that we can obtain the full set of options to parse.
 
     # REVISIT: These should be configurable versions, through a global
     # '--version' option, but we don't implement that yet... --daniel 2011-03-29
     @type = self.class.name.to_s.sub(/.+:/, '').downcase.to_sym
+
     @face = Puppet::Face[@type, :current]
 
     # Now, walk the command line and identify the action.  We skip over
     # arguments based on introspecting the action and all, and find the first
     # non-option word to use as the action.
     action_name = nil
     index       = -1
     until action_name or (index += 1) >= command_line.args.length do
       item = command_line.args[index]
       if item =~ /^-/ then
         option = @face.options.find do |name|
           item =~ /^-+#{name.to_s.gsub(/[-_]/, '[-_]')}(?:[ =].*)?$/
         end
         if option then
           option = @face.get_option(option)
           # If we have an inline argument, just carry on.  We don't need to
           # care about optional vs mandatory in that case because we do a real
           # parse later, and that will totally take care of raising the error
           # when we get there. --daniel 2011-04-04
           if option.takes_argument? and !item.index('=') then
             index += 1 unless
               (option.optional_argument? and command_line.args[index + 1] =~ /^-/)
           end
         elsif option = find_global_settings_argument(item) then
           unless Puppet.settings.boolean? option.name then
             # As far as I can tell, we treat non-bool options as always having
             # a mandatory argument. --daniel 2011-04-05
             index += 1          # ...so skip the argument.
           end
         elsif option = find_application_argument(item) then
           index += 1 if (option[:argument] and not option[:optional])
         else
           raise OptionParser::InvalidOption.new(item.sub(/=.*$/, ''))
         end
       else
         # Stash away the requested action name for later, and try to fetch the
         # action object it represents; if this is an invalid action name that
         # will be nil, and handled later.
         action_name = item.to_sym
         @action = Puppet::Face.find_action(@face.name, action_name)
         @face   = @action.face if @action
       end
     end
 
     if @action.nil?
       if @action = @face.get_default_action() then
         @is_default_action = true
       else
-        # REVISIT: ...and this horror thanks to our log setup, which doesn't
-        # initialize destinations until the setup method, which we will never
-        # reach.  We could also just print here, but that is actually a little
-        # uglier and nastier in the long term, in which we should do log setup
-        # earlier if at all possible. --daniel 2011-05-31
-        Puppet::Util::Log.newdestination(:console)
-
         face   = @face.name
         action = action_name.nil? ? 'default' : "'#{action_name}'"
         msg = "'#{face}' has no #{action} action.  See `puppet help #{face}`."
+
         Puppet.err(msg)
+        Puppet::Util::Log.force_flushqueue()
 
         exit false
       end
     end
 
     # Now we can interact with the default option code to build behaviour
     # around the full set of options we now know we support.
     @action.options.each do |option|
       option = @action.get_option(option) # make it the object.
       self.class.option(*option.optparse) # ...and make the CLI parse it.
     end
 
     # ...and invoke our parent to parse all the command line options.
     super
   end
 
   def find_global_settings_argument(item)
     Puppet.settings.each do |name, object|
       object.optparse_args.each do |arg|
         next unless arg =~ /^-/
         # sadly, we have to emulate some of optparse here...
         pattern = /^#{arg.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
         pattern.match item and return object
       end
     end
     return nil                  # nothing found.
   end
 
   def find_application_argument(item)
     self.class.option_parser_commands.each do |options, function|
       options.each do |option|
         next unless option =~ /^-/
         pattern = /^#{option.sub('[no-]', '').sub(/[ =].*$/, '')}(?:[ =].*)?$/
         next unless pattern.match(item)
         return {
           :argument => option =~ /[ =]/,
           :optional => option =~ /[ =]\[/
         }
       end
     end
     return nil                  # not found
   end
 
   def setup
     Puppet::Util::Log.newdestination :console
 
     @arguments = command_line.args
 
     # Note: because of our definition of where the action is set, we end up
     # with it *always* being the first word of the remaining set of command
     # line arguments.  So, strip that off when we construct the arguments to
     # pass down to the face action. --daniel 2011-04-04
     # Of course, now that we have default actions, we should leave the
     # "action" name on if we didn't actually consume it when we found our
     # action.
     @arguments.delete_at(0) unless @is_default_action
 
     # We copy all of the app options to the end of the call; This allows each
     # action to read in the options.  This replaces the older model where we
     # would invoke the action with options set as global state in the
     # interface object.  --daniel 2011-03-28
     @arguments << options
 
     # If we don't have a rendering format, set one early.
     self.render_as ||= (@action.render_as || :console)
   end
 
 
   def main
     status = false
 
     # Call the method associated with the provided action (e.g., 'find').
     unless @action
       puts Puppet::Face[:help, :current].help(@face.name)
       raise "#{face} does not respond to action #{arguments.first}"
     end
 
     # We need to do arity checking here because this is generic code
     # calling generic methods – that have argument defaulting.  We need to
     # make sure we don't accidentally pass the options as the first
     # argument to a method that takes one argument.  eg:
     #
     #   puppet facts find
     #   => options => {}
     #      @arguments => [{}]
     #   => @face.send :bar, {}
     #
     #   def face.bar(argument, options = {})
     #   => bar({}, {})  # oops!  we thought the options were the
     #                   # positional argument!!
     #
     # We could also fix this by making it mandatory to pass the options on
     # every call, but that would make the Ruby API much more annoying to
     # work with; having the defaulting is a much nicer convention to have.
     #
     # We could also pass the arguments implicitly, by having a magic
     # 'options' method that was visible in the scope of the action, which
     # returned the right stuff.
     #
     # That sounds attractive, but adds complications to all sorts of
     # things, especially when you think about how to pass options when you
     # are writing Ruby code that calls multiple faces.  Especially if
     # faces are involved in that. ;)
     #
     # --daniel 2011-04-27
     if (arity = @action.positional_arg_count) > 0
       unless (count = arguments.length) == arity then
         s = arity == 2 ? '' : 's'
         raise ArgumentError, "puppet #{@face.name} #{@action.name} takes #{arity-1} argument#{s}, but you gave #{count-1}"
       end
     end
 
     result = @face.send(@action.name, *arguments)
     puts render(result, arguments) unless result.nil?
     status = true
 
   # We need an easy way for the action to set a specific exit code, so we
   # rescue SystemExit here; This allows each action to set the desired exit
   # code by simply calling Kernel::exit.  eg:
   #
   #   exit(2)
   #
   # --kelsey 2012-02-14
   rescue SystemExit => detail
     status = detail.status
 
   rescue Exception => detail
     Puppet.log_exception(detail)
     Puppet.err "Try 'puppet help #{@face.name} #{@action.name}' for usage"
 
   ensure
     exit status
   end
 end
diff --git a/lib/puppet/application/filebucket.rb b/lib/puppet/application/filebucket.rb
index c58d8a23f..174f3d110 100644
--- a/lib/puppet/application/filebucket.rb
+++ b/lib/puppet/application/filebucket.rb
@@ -1,188 +1,185 @@
 require 'puppet/application'
 
 class Puppet::Application::Filebucket < Puppet::Application
 
   option("--bucket BUCKET","-b")
   option("--debug","-d")
   option("--local","-l")
   option("--remote","-r")
   option("--verbose","-v")
 
   attr :args
 
   def help
     <<-HELP
 
 puppet-filebucket(8) -- Store and retrieve files in a filebucket
 ========
 
 SYNOPSIS
 --------
 A stand-alone Puppet filebucket client.
 
 
 USAGE
 -----
 puppet filebucket <mode> [-h|--help] [-V|--version] [-d|--debug]
   [-v|--verbose] [-l|--local] [-r|--remote] [-s|--server <server>]
   [-b|--bucket <directory>] <file> <file> ...
 
 Puppet filebucket can operate in three modes, with only one mode per call:
 
 backup:
   Send one or more files to the specified file bucket. Each sent file is
   printed with its resulting md5 sum.
 
 get:
   Return the text associated with an md5 sum. The text is printed to
   stdout, and only one file can be retrieved at a time.
 
 restore:
   Given a file path and an md5 sum, store the content associated with
   the sum into the specified file path. You can specify an entirely new
   path to this argument; you are not restricted to restoring the content
   to its original location.
 
 
 DESCRIPTION
 -----------
 This is a stand-alone filebucket client for sending files to a local or
 central filebucket.
 
 Note that 'filebucket' defaults to using a network-based filebucket
 available on the server named 'puppet'. To use this, you'll have to be
 running as a user with valid Puppet certificates. Alternatively, you can
 use your local file bucket by specifying '--local'.
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'ssldir' is a valid
 configuration parameter, so you can specify '--ssldir <directory>' 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.
 
 * --help:
   Print this help message
 
 * --local:
   Use the local filebucket. This will use the default configuration
   information.
 
 * --remote:
   Use a remote filebucket. This will use the default configuration
   information.
 
 * --server:
   The server to send the file to, instead of locally.
 
 * --verbose:
   Print extra information.
 
 * --version:
   Print version information.
 
 
 EXAMPLE
 -------
     $ puppet filebucket backup /etc/passwd
     /etc/passwd: 429b225650b912a2ee067b0a4cf1e949
     $ puppet filebucket restore /tmp/passwd 429b225650b912a2ee067b0a4cf1e949
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
 
   def run_command
     @args = command_line.args
     command = args.shift
     return send(command) if %w{get backup restore}.include? command
     help
   end
 
   def get
     md5 = args.shift
     out = @client.getfile(md5)
     print out
   end
 
   def backup
     raise "You must specify a file to back up" unless args.length > 0
 
     args.each do |file|
       unless FileTest.exists?(file)
         $stderr.puts "#{file}: no such file"
         next
       end
       unless FileTest.readable?(file)
         $stderr.puts "#{file}: cannot read file"
         next
       end
       md5 = @client.backup(file)
       puts "#{file}: #{md5}"
     end
   end
 
   def restore
     file = args.shift
     md5 = args.shift
     @client.restore(file, md5)
   end
 
   def setup
     Puppet::Log.newdestination(:console)
 
     @client = nil
     @server = nil
 
     Signal.trap(:INT) do
       $stderr.puts "Cancelling"
       exit(1)
     end
 
     if options[:debug]
       Puppet::Log.level = :debug
     elsif options[:verbose]
       Puppet::Log.level = :info
     end
 
-    # Now parse the config
-    Puppet.parse_config
-
       exit(Puppet.settings.print_configs ? 0 : 1) if Puppet.settings.print_configs?
 
     require 'puppet/file_bucket/dipper'
     begin
       if options[:local] or options[:bucket]
         path = options[:bucket] || Puppet[:bucketdir]
         @client = Puppet::FileBucket::Dipper.new(:Path => path)
       else
         @client = Puppet::FileBucket::Dipper.new(:Server => Puppet[:server])
       end
     rescue => detail
       Puppet.log_exception(detail)
       exit(1)
     end
   end
 
 end
 
diff --git a/lib/puppet/application/kick.rb b/lib/puppet/application/kick.rb
index b9fc10775..d371ce25d 100644
--- a/lib/puppet/application/kick.rb
+++ b/lib/puppet/application/kick.rb
@@ -1,348 +1,345 @@
 require 'puppet/application'
 
 class Puppet::Application::Kick < Puppet::Application
 
   attr_accessor :hosts, :tags, :classes
 
   option("--all","-a")
   option("--foreground","-f")
   option("--debug","-d")
   option("--ping","-P")
   option("--test")
 
   option("--host HOST") do |arg|
     @hosts << arg
   end
 
   option("--tag TAG", "-t") do |arg|
     @tags << arg
   end
 
   option("--class CLASS", "-c") do |arg|
     @classes << arg
   end
 
   option("--no-fqdn", "-n") do |arg|
     options[:fqdn] = false
   end
 
   option("--parallel PARALLEL", "-p") do |arg|
     begin
       options[:parallel] = Integer(arg)
     rescue
       $stderr.puts "Could not convert #{arg.inspect} to an integer"
       exit(23)
     end
   end
 
   def help
     <<-HELP
 
 puppet-kick(8) -- Remotely control puppet agent
 ========
 
 SYNOPSIS
 --------
 Trigger a puppet agent run on a set of hosts.
 
 
 USAGE
 -----
 puppet kick [-a|--all] [-c|--class <class>] [-d|--debug] [-f|--foreground]
   [-h|--help] [--host <host>] [--no-fqdn] [--ignoreschedules]
   [-t|--tag <tag>] [--test] [-p|--ping] <host> [<host> [...]]
 
 
 DESCRIPTION
 -----------
 This script can be used to connect to a set of machines running 'puppet
 agent' and trigger them to run their configurations. The most common
 usage would be to specify a class of hosts and a set of tags, and
 'puppet kick' would look up in LDAP all of the hosts matching that
 class, then connect to each host and trigger a run of all of the objects
 with the specified tags.
 
 If you are not storing your host configurations in LDAP, you can specify
 hosts manually.
 
 You will most likely have to run 'puppet kick' as root to get access to
 the SSL certificates.
 
 'puppet kick' reads 'puppet master''s configuration file, so that it can
 copy things like LDAP settings.
 
 
 USAGE NOTES
 -----------
 Puppet kick needs the puppet agent on the target machine to be running as a
 daemon, be configured to listen for incoming network connections, and have an
 appropriate security configuration.
 
 The specific changes required are:
 
 * Set `listen = true` in the agent's `puppet.conf` file (or `--listen` on the
   command line)
 * Configure the node's firewall to allow incoming connections on port 8139
 * Insert the following stanza at the top of the node's `auth.conf` file:
 
         # Allow puppet kick access
         path    /run
         method  save
         auth    any
         allow   workstation.example.com
 
 This example would allow the machine `workstation.example.com` to trigger a
 Puppet run; adjust the "allow" directive to suit your site. You may also use
 `allow *` to allow anyone to trigger a Puppet run, but that makes it possible
 to interfere with your site by triggering excessive Puppet runs.
 
 See `http://docs.puppetlabs.com/guides/rest_auth_conf.html` for more details
 about security settings.
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'ssldir' is a valid
 configuration parameter, so you can specify '--ssldir <directory>' as an
 argument.
 
 See the configuration file documentation at
 http://docs.puppetlabs.com/references/latest/configuration.html for
 the full list of acceptable parameters. A commented list of all
 configuration options can also be generated by running puppet master
 with '--genconfig'.
 
 * --all:
   Connect to all available hosts. Requires LDAP support at this point.
 
 * --class:
   Specify a class of machines to which to connect. This only works if
   you have LDAP configured, at the moment.
 
 * --debug:
   Enable full debugging.
 
 * --foreground:
   Run each configuration in the foreground; that is, when connecting to
   a host, do not return until the host has finished its run. The default
   is false.
 
 * --help:
   Print this help message
 
 * --host:
   A specific host to which to connect. This flag can be specified more
   than once.
 
 * --ignoreschedules:
   Whether the client should ignore schedules when running its
   configuration. This can be used to force the client to perform work it
   would not normally perform so soon. The default is false.
 
 * --parallel:
   How parallel to make the connections. Parallelization is provided by
   forking for each client to which to connect. The default is 1, meaning
   serial execution.
 
 * --tag:
   Specify a tag for selecting the objects to apply. Does not work with
   the --test option.
 
 * --test:
   Print the hosts you would connect to but do not actually connect. This
   option requires LDAP support at this point.
 
 * --ping:
   Do a ICMP echo against the target host. Skip hosts that don't respond
   to ping.
 
 
 EXAMPLE
 -------
     $ sudo puppet kick -p 10 -t remotefile -t webserver host1 host2
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def run_command
     @hosts += command_line.args
     options[:test] ? test : main
   end
 
   def test
     puts "Skipping execution in test mode"
     exit(0)
   end
 
   def main
     Puppet.warning "Failed to load ruby LDAP library. LDAP functionality will not be available" unless Puppet.features.ldap?
     require 'puppet/util/ldap/connection'
 
     todo = @hosts.dup
 
     failures = []
 
     # Now do the actual work
     go = true
     while go
       # If we don't have enough children in process and we still have hosts left to
       # do, then do the next host.
       if @children.length < options[:parallel] and ! todo.empty?
         host = todo.shift
         pid = safe_posix_fork do
           run_for_host(host)
         end
         @children[pid] = host
       else
         # Else, see if we can reap a process.
         begin
           pid = Process.wait
 
           if host = @children[pid]
             # Remove our host from the list of children, so the parallelization
             # continues working.
             @children.delete(pid)
             failures << host if $CHILD_STATUS.exitstatus != 0
             print "#{host} finished with exit code #{$CHILD_STATUS.exitstatus}\n"
           else
             $stderr.puts "Could not find host for PID #{pid} with status #{$CHILD_STATUS.exitstatus}"
           end
         rescue Errno::ECHILD
           # There are no children left, so just exit unless there are still
           # children left to do.
           next unless todo.empty?
 
           if failures.empty?
             puts "Finished"
             exit(0)
           else
             puts "Failed: #{failures.join(", ")}"
             exit(3)
           end
         end
       end
     end
   end
 
   def run_for_host(host)
     if options[:ping]
       out = %x{ping -c 1 #{host}}
       unless $CHILD_STATUS == 0
         $stderr.print "Could not contact #{host}\n"
         exit($CHILD_STATUS)
       end
     end
 
     require 'puppet/run'
     Puppet::Run.indirection.terminus_class = :rest
     port = Puppet[:puppetport]
     url = ["https://#{host}:#{port}", "production", "run", host].join('/')
 
     print "Triggering #{host}\n"
     begin
       run_options = {
         :tags => @tags,
         :background => ! options[:foreground],
         :ignoreschedules => options[:ignoreschedules]
       }
       run = Puppet::Run.indirection.save(Puppet::Run.new( run_options ), url)
       puts "Getting status"
       result = run.status
       puts "status is #{result}"
     rescue => detail
       Puppet.log_exception(detail, "Host #{host} failed: #{detail}\n")
       exit(2)
     end
 
     case result
     when "success";
       exit(0)
     when "running"
       $stderr.puts "Host #{host} is already running"
       exit(3)
     else
       $stderr.puts "Host #{host} returned unknown answer '#{result}'"
       exit(12)
     end
   end
 
   def initialize(*args)
     super
     @hosts = []
     @classes = []
     @tags = []
   end
 
   def preinit
     [:INT, :TERM].each do |signal|
       Signal.trap(signal) do
         $stderr.puts "Cancelling"
         exit(1)
       end
     end
     options[:parallel] = 1
     options[:verbose] = true
     options[:fqdn] = true
     options[:ignoreschedules] = false
     options[:foreground] = false
   end
 
   def setup
     raise Puppet::Error.new("Puppet kick is not supported on Microsoft Windows") if Puppet.features.microsoft_windows?
 
     if options[:debug]
       Puppet::Util::Log.level = :debug
     else
       Puppet::Util::Log.level = :info
     end
 
-    # Now parse the config
-    Puppet.parse_config
-
     if Puppet[:node_terminus] == "ldap" and (options[:all] or @classes)
       if options[:all]
         @hosts = Puppet::Node.indirection.search("whatever", :fqdn => options[:fqdn]).collect { |node| node.name }
         puts "all: #{@hosts.join(", ")}"
       else
         @hosts = []
         @classes.each do |klass|
           list = Puppet::Node.indirection.search("whatever", :fqdn => options[:fqdn], :class => klass).collect { |node| node.name }
           puts "#{klass}: #{list.join(", ")}"
 
           @hosts += list
         end
       end
     elsif ! @classes.empty?
       $stderr.puts "You must be using LDAP to specify host classes"
       exit(24)
     end
 
     @children = {}
 
     # If we get a signal, then kill all of our children and get out.
     [:INT, :TERM].each do |signal|
       Signal.trap(signal) do
         Puppet.notice "Caught #{signal}; shutting down"
         @children.each do |pid, host|
           Process.kill("INT", pid)
         end
 
         waitall
 
         exit(1)
       end
     end
 
   end
 
 end
diff --git a/lib/puppet/application/resource.rb b/lib/puppet/application/resource.rb
index a11b03f91..defb6696f 100644
--- a/lib/puppet/application/resource.rb
+++ b/lib/puppet/application/resource.rb
@@ -1,235 +1,233 @@
 require 'puppet/application'
 
 class Puppet::Application::Resource < Puppet::Application
 
   attr_accessor :host, :extra_params
 
   def preinit
     @extra_params = []
     Facter.loadfacts
   end
 
   option("--debug","-d")
   option("--verbose","-v")
   option("--edit","-e")
 
   option("--host HOST","-H") do |arg|
     @host = arg
   end
 
   option("--types", "-t") do |arg|
     types = []
     Puppet::Type.loadall
     Puppet::Type.eachtype do |t|
       next if t.name == :component
       types << t.name.to_s
     end
     puts types.sort
     exit
   end
 
   option("--param PARAM", "-p") do |arg|
     @extra_params << arg.to_sym
   end
 
   def help
     <<-HELP
 
 puppet-resource(8) -- The resource abstraction layer shell
 ========
 
 SYNOPSIS
 --------
 Uses the Puppet RAL to directly interact with the system.
 
 
 USAGE
 -----
 puppet resource [-h|--help] [-d|--debug] [-v|--verbose] [-e|--edit]
   [-H|--host <host>] [-p|--param <parameter>] [-t|--types] <type>
   [<name>] [<attribute>=<value> ...]
 
 
 DESCRIPTION
 -----------
 This command provides simple facilities for converting current system
 state into Puppet code, along with some ability to modify the current
 state using Puppet's RAL.
 
 By default, you must at least provide a type to list, in which case
 puppet resource will tell you everything it knows about all resources of
 that type. You can optionally specify an instance name, and puppet
 resource will only describe that single instance.
 
 If given a type, a name, and a series of <attribute>=<value> pairs,
 puppet resource will modify the state of the specified resource.
 Alternately, if given a type, a name, and the '--edit' flag, puppet
 resource will write its output to a file, open that file in an editor,
 and then apply the saved file as a Puppet transaction.
 
 
 OPTIONS
 -------
 Note that any configuration parameter that's valid in the configuration
 file is also a valid long argument. For example, 'ssldir' is a valid
 configuration parameter, so you can specify '--ssldir <directory>' 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.
 
 * --edit:
   Write the results of the query to a file, open the file in an editor,
   and read the file back in as an executable Puppet manifest.
 
 * --host:
   When specified, connect to the resource server on the named host
   and retrieve the list of resouces of the type specified.
 
 * --help:
   Print this help message.
 
 * --param:
   Add more parameters to be outputted from queries.
 
 * --types:
   List all available types.
 
 * --verbose:
   Print extra information.
 
 
 EXAMPLE
 -------
 This example uses `puppet resource` to return a Puppet configuration for
 the user `luke`:
 
     $ puppet resource user luke
     user { 'luke':
      home => '/home/luke',
      uid => '100',
      ensure => 'present',
      comment => 'Luke Kanies,,,',
      gid => '1000',
      shell => '/bin/bash',
      groups => ['sysadmin','audio','video','puppet']
     }
 
 
 AUTHOR
 ------
 Luke Kanies
 
 
 COPYRIGHT
 ---------
 Copyright (c) 2011 Puppet Labs, LLC Licensed under the Apache 2.0 License
 
     HELP
   end
 
   def main
     type, name, params = parse_args(command_line.args)
 
     raise "You cannot edit a remote host" if options[:edit] and @host
 
     resources = find_or_save_resources(type, name, params)
     text = resources.
       map { |resource| resource.prune_parameters(:parameters_to_include => @extra_params).to_manifest }.
       join("\n")
 
     options[:edit] ?
       handle_editing(text) :
       (puts text)
   end
 
   def setup
     Puppet::Util::Log.newdestination(:console)
 
-    Puppet.parse_config
-
     if options[:debug]
       Puppet::Util::Log.level = :debug
     elsif options[:verbose]
       Puppet::Util::Log.level = :info
     end
   end
 
   private
 
   def remote_key(type, name)
     Puppet::Resource.indirection.terminus_class = :rest
     port = Puppet[:puppetport]
     ["https://#{@host}:#{port}", "production", "resources", type, name].join('/')
   end
 
   def local_key(type, name)
     [type, name].join('/')
   end
 
   def handle_editing(text)
     require 'tempfile'
     # Prefer the current directory, which is more likely to be secure
     # and, in the case of interactive use, accessible to the user.
     tmpfile = Tempfile.new('x2puppet', Dir.pwd)
     begin
       # sync write, so nothing buffers before we invoke the editor.
       tmpfile.sync = true
       tmpfile.puts text
 
       # edit the content
       system(ENV["EDITOR"] || 'vi', tmpfile.path)
 
       # ...and, now, pass that file to puppet to apply.  Because
       # many editors rename or replace the original file we need to
       # feed the pathname, not the file content itself, to puppet.
       system('puppet apply -v ' + tmpfile.path)
     ensure
       # The temporary file will be safely removed.
       tmpfile.close(true)
     end
   end
 
   def parse_args(args)
     type = args.shift or raise "You must specify the type to display"
     Puppet::Type.type(type) or raise "Could not find type #{type}"
     name = args.shift
     params = {}
     args.each do |setting|
       if setting =~ /^(\w+)=(.+)$/
         params[$1] = $2
       else
         raise "Invalid parameter setting #{setting}"
       end
     end
 
     [type, name, params]
   end
 
   def find_or_save_resources(type, name, params)
     key = @host ? remote_key(type, name) : local_key(type, name)
 
     if name
       if params.empty?
         [ Puppet::Resource.indirection.find( key ) ]
       else
         resource = Puppet::Resource.new( type, name, :parameters => params )
 
         # save returns [resource that was saved, transaction log from applying the resource]
         save_result = Puppet::Resource.indirection.save(resource, key)
         [ save_result.first ]
       end
     else
       if type == "file"
         raise "Listing all file instances is not supported.  Please specify a file or directory, e.g. puppet resource file /etc"
       end
       Puppet::Resource.indirection.search( key, {} )
     end
   end
 end
diff --git a/lib/puppet/interface.rb b/lib/puppet/interface.rb
index 4cd3857a0..b768452b7 100644
--- a/lib/puppet/interface.rb
+++ b/lib/puppet/interface.rb
@@ -1,157 +1,158 @@
 require 'puppet'
 require 'puppet/util/autoload'
 require 'puppet/interface/documentation'
 require 'prettyprint'
 require 'semver'
 
 class Puppet::Interface
   include FullDocs
 
   require 'puppet/interface/face_collection'
 
   require 'puppet/interface/action_manager'
   include Puppet::Interface::ActionManager
   extend Puppet::Interface::ActionManager
 
   require 'puppet/interface/option_manager'
   include Puppet::Interface::OptionManager
   extend Puppet::Interface::OptionManager
 
   include Puppet::Util
 
   class << self
     # This is just so we can search for actions.  We only use its
     # list of directories to search.
     # Can't we utilize an external autoloader, or simply use the $LOAD_PATH? -pvb
     def autoloader
       @autoloader ||= Puppet::Util::Autoload.new(:application, "puppet/face")
     end
 
     def faces
       Puppet::Interface::FaceCollection.faces
     end
 
     def register(instance)
       Puppet::Interface::FaceCollection.register(instance)
     end
 
     def define(name, version, &block)
       face = Puppet::Interface::FaceCollection[name, version]
       if face.nil? then
         face = self.new(name, version)
         Puppet::Interface::FaceCollection.register(face)
         # REVISIT: Shouldn't this be delayed until *after* we evaluate the
         # current block, not done before? --daniel 2011-04-07
         face.load_actions
       end
 
       face.instance_eval(&block) if block_given?
 
       return face
     end
 
     def face?(name, version)
       Puppet::Interface::FaceCollection[name, version]
     end
 
     def [](name, version)
       unless face = Puppet::Interface::FaceCollection[name, version]
         if current = Puppet::Interface::FaceCollection[name, :current]
           raise Puppet::Error, "Could not find version #{version} of #{name}"
         else
           raise Puppet::Error, "Could not find Puppet Face #{name.inspect}"
         end
       end
+
       face
     end
 
     def find_action(name, action, version = :current)
       Puppet::Interface::FaceCollection.get_action_for_face(name, action, version)
     end
   end
 
   def set_default_format(format)
     Puppet.deprecation_warning("set_default_format is deprecated (and ineffective); use render_as on your actions instead.")
   end
 
 
   ########################################################################
   # Documentation.  We currently have to rewrite both getters because we share
   # the same instance between build-time and the runtime instance.  When that
   # splits out this should merge into a module that both the action and face
   # include. --daniel 2011-04-17
   def synopsis
     build_synopsis self.name, '<action>'
   end
 
 
   ########################################################################
   attr_reader :name, :version, :loader
   private :loader
 
   def initialize(name, version, &block)
     unless SemVer.valid?(version)
       raise ArgumentError, "Cannot create face #{name.inspect} with invalid version number '#{version}'!"
     end
 
     @name    = Puppet::Interface::FaceCollection.underscorize(name)
     @version = SemVer.new(version)
 
     # The few bits of documentation we actually demand.  The default license
     # is a favour to our end users; if you happen to get that in a core face
     # report it as a bug, please. --daniel 2011-04-26
     @authors  = []
     @license  = 'All Rights Reserved'
 
     @loader = Puppet::Util::Autoload.new(@name, "puppet/face/#{@name}")
     instance_eval(&block) if block_given?
   end
 
   # Try to find actions defined in other files.
   def load_actions
     loader.loadall
   end
 
   def to_s
     "Puppet::Face[#{name.inspect}, #{version.inspect}]"
   end
 
   ########################################################################
   # Action decoration, whee!  You are not expected to care about this code,
   # which exists to support face building and construction.  I marked these
   # private because the implementation is crude and ugly, and I don't yet know
   # enough to work out how to make it clean.
   #
   # Once we have established that these methods will likely change radically,
   # to be unrecognizable in the final outcome.  At which point we will throw
   # all this away, replace it with something nice, and work out if we should
   # be making this visible to the outside world... --daniel 2011-04-14
   private
   def __invoke_decorations(type, action, passed_args = [], passed_options = {})
     [:before, :after].member?(type) or fail "unknown decoration type #{type}"
 
     # Collect the decoration methods matching our pass.
     methods = action.options.select do |name|
       passed_options.has_key? name
     end.map do |name|
       action.get_option(name).__decoration_name(type)
     end
 
     methods.reverse! if type == :after
 
     # Exceptions here should propagate up; this implements a hook we can use
     # reasonably for option validation.
     methods.each do |hook|
       respond_to? hook and self.__send__(hook, action, passed_args, passed_options)
     end
   end
 
   def __add_method(name, proc)
     meta_def(name, &proc)
     method(name).unbind
   end
   def self.__add_method(name, proc)
     define_method(name, proc)
     instance_method(name)
   end
 end
diff --git a/lib/puppet/util.rb b/lib/puppet/util.rb
index 29b2fbcb5..b2b45eb56 100644
--- a/lib/puppet/util.rb
+++ b/lib/puppet/util.rb
@@ -1,576 +1,579 @@
 # A module to collect utility functions.
 
 require 'English'
 require 'puppet/external/lock'
 require 'puppet/error'
 require 'puppet/util/execution_stub'
 require 'uri'
 require 'sync'
 require 'monitor'
 require 'tempfile'
 require 'pathname'
 require 'ostruct'
 
 module Puppet
 module Util
   require 'puppet/util/monkey_patches'
   require 'benchmark'
 
   # These are all for backward compatibility -- these are methods that used
   # to be in Puppet::Util but have been moved into external modules.
   require 'puppet/util/posix'
   extend Puppet::Util::POSIX
 
   @@sync_objects = {}.extend MonitorMixin
 
 
   def self.activerecord_version
     if (defined?(::ActiveRecord) and defined?(::ActiveRecord::VERSION) and defined?(::ActiveRecord::VERSION::MAJOR) and defined?(::ActiveRecord::VERSION::MINOR))
       ([::ActiveRecord::VERSION::MAJOR, ::ActiveRecord::VERSION::MINOR].join('.').to_f)
     else
       0
     end
   end
 
 
   # Run some code with a specific environment.  Resets the environment back to
   # what it was at the end of the code.
   def self.withenv(hash)
     saved = ENV.to_hash
     hash.each do |name, val|
       ENV[name.to_s] = val
     end
 
     yield
   ensure
     ENV.clear
     saved.each do |name, val|
       ENV[name] = val
     end
   end
 
 
   # Execute a given chunk of code with a new umask.
   def self.withumask(mask)
     cur = File.umask(mask)
 
     begin
       yield
     ensure
       File.umask(cur)
     end
   end
 
 
   def self.synchronize_on(x,type)
     sync_object,users = 0,1
     begin
       @@sync_objects.synchronize {
         (@@sync_objects[x] ||= [Sync.new,0])[users] += 1
       }
       @@sync_objects[x][sync_object].synchronize(type) { yield }
     ensure
       @@sync_objects.synchronize {
         @@sync_objects.delete(x) unless (@@sync_objects[x][users] -= 1) > 0
       }
     end
   end
 
   # Change the process to a different user
   def self.chuser
     if group = Puppet[:group]
       begin
         Puppet::Util::SUIDManager.change_group(group, true)
       rescue => detail
         Puppet.warning "could not change to group #{group.inspect}: #{detail}"
         $stderr.puts "could not change to group #{group.inspect}"
 
         # Don't exit on failed group changes, since it's
         # not fatal
         #exit(74)
       end
     end
 
     if user = Puppet[:user]
       begin
         Puppet::Util::SUIDManager.change_user(user, true)
       rescue => detail
         $stderr.puts "Could not change to user #{user}: #{detail}"
         exit(74)
       end
     end
   end
 
   # Create instance methods for each of the log levels.  This allows
   # the messages to be a little richer.  Most classes will be calling this
   # method.
   def self.logmethods(klass, useself = true)
     Puppet::Util::Log.eachlevel { |level|
       klass.send(:define_method, level, proc { |args|
         args = args.join(" ") if args.is_a?(Array)
         if useself
 
           Puppet::Util::Log.create(
             :level => level,
             :source => self,
             :message => args
           )
         else
 
           Puppet::Util::Log.create(
             :level => level,
             :message => args
           )
         end
       })
     }
   end
 
   # Proxy a bunch of methods to another object.
   def self.classproxy(klass, objmethod, *methods)
     classobj = class << klass; self; end
     methods.each do |method|
       classobj.send(:define_method, method) do |*args|
         obj = self.send(objmethod)
 
         obj.send(method, *args)
       end
     end
   end
 
   # Proxy a bunch of methods to another object.
   def self.proxy(klass, objmethod, *methods)
     methods.each do |method|
       klass.send(:define_method, method) do |*args|
         obj = self.send(objmethod)
 
         obj.send(method, *args)
       end
     end
   end
 
 
   def benchmark(*args)
     msg = args.pop
     level = args.pop
     object = nil
 
     if args.empty?
       if respond_to?(level)
         object = self
       else
         object = Puppet
       end
     else
       object = args.pop
     end
 
     raise Puppet::DevError, "Failed to provide level to :benchmark" unless level
 
     unless level == :none or object.respond_to? level
       raise Puppet::DevError, "Benchmarked object does not respond to #{level}"
     end
 
     # Only benchmark if our log level is high enough
     if level != :none and Puppet::Util::Log.sendlevel?(level)
       result = nil
       seconds = Benchmark.realtime {
         yield
       }
       object.send(level, msg + (" in %0.2f seconds" % seconds))
       return seconds
     else
       yield
     end
   end
 
   def which(bin)
     if absolute_path?(bin)
       return bin if FileTest.file? bin and FileTest.executable? bin
     else
       ENV['PATH'].split(File::PATH_SEPARATOR).each do |dir|
         begin
           dest = File.expand_path(File.join(dir, bin))
         rescue ArgumentError => e
           # if the user's PATH contains a literal tilde (~) character and HOME is not set, we may get
           # an ArgumentError here.  Let's check to see if that is the case; if not, re-raise whatever error
           # was thrown.
           raise e unless ((dir =~ /~/) && ((ENV['HOME'].nil? || ENV['HOME'] == "")))
 
           # if we get here they have a tilde in their PATH.  We'll issue a single warning about this and then
           # ignore this path element and carry on with our lives.
           Puppet::Util::Warnings.warnonce("PATH contains a ~ character, and HOME is not set; ignoring PATH element '#{dir}'.")
           next
         end
         if Puppet.features.microsoft_windows? && File.extname(dest).empty?
           exts = ENV['PATHEXT']
           exts = exts ? exts.split(File::PATH_SEPARATOR) : %w[.COM .EXE .BAT .CMD]
           exts.each do |ext|
             destext = File.expand_path(dest + ext)
 
             return destext if FileTest.file? destext and FileTest.executable? destext
           end
         end
         return dest if FileTest.file? dest and FileTest.executable? dest
       end
     end
     nil
   end
   module_function :which
 
   # Determine in a platform-specific way whether a path is absolute. This
   # defaults to the local platform if none is specified.
   def absolute_path?(path, platform=nil)
     # Escape once for the string literal, and once for the regex.
     slash = '[\\\\/]'
     name = '[^\\\\/]+'
     regexes = {
       :windows => %r!^(([A-Z]:#{slash})|(#{slash}#{slash}#{name}#{slash}#{name})|(#{slash}#{slash}\?#{slash}#{name}))!i,
       :posix   => %r!^/!,
     }
 
     # Due to weird load order issues, I was unable to remove this require.
     # This is fixed in Telly so it can be removed there.
     require 'puppet'
 
     # Ruby only sets File::ALT_SEPARATOR on Windows and the Ruby standard
     # library uses that to test what platform it's on.  Normally in Puppet we
     # would use Puppet.features.microsoft_windows?, but this method needs to
     # be called during the initialization of features so it can't depend on
     # that.
     platform ||= File::ALT_SEPARATOR ? :windows : :posix
 
     !! (path =~ regexes[platform])
   end
   module_function :absolute_path?
 
   # Convert a path to a file URI
   def path_to_uri(path)
     return unless path
 
     params = { :scheme => 'file' }
 
     if Puppet.features.microsoft_windows?
       path = path.gsub(/\\/, '/')
 
       if unc = /^\/\/([^\/]+)(\/[^\/]+)/.match(path)
         params[:host] = unc[1]
         path = unc[2]
       elsif path =~ /^[a-z]:\//i
         path = '/' + path
       end
     end
 
     params[:path] = URI.escape(path)
 
     begin
       URI::Generic.build(params)
     rescue => detail
       raise Puppet::Error, "Failed to convert '#{path}' to URI: #{detail}"
     end
   end
   module_function :path_to_uri
 
   # Get the path component of a URI
   def uri_to_path(uri)
     return unless uri.is_a?(URI)
 
     path = URI.unescape(uri.path)
 
     if Puppet.features.microsoft_windows? and uri.scheme == 'file'
       if uri.host
         path = "//#{uri.host}" + path # UNC
       else
         path.sub!(/^\//, '')
       end
     end
 
     path
   end
   module_function :uri_to_path
 
   def safe_posix_fork(stdin=$stdin, stdout=$stdout, stderr=$stderr, &block)
     child_pid = Kernel.fork do
       $stdin.reopen(stdin)
       $stdout.reopen(stdout)
       $stderr.reopen(stderr)
 
       3.upto(256){|fd| IO::new(fd).close rescue nil}
 
       block.call if block
     end
     child_pid
   end
   module_function :safe_posix_fork
 
   # Create an exclusive lock.
   def threadlock(resource, type = Sync::EX)
     Puppet::Util.synchronize_on(resource,type) { yield }
   end
 
 
   module_function :benchmark
 
   def memory
     unless defined?(@pmap)
       @pmap = which('pmap')
     end
     if @pmap
       %x{#{@pmap} #{Process.pid}| grep total}.chomp.sub(/^\s*total\s+/, '').sub(/K$/, '').to_i
     else
       0
     end
   end
 
   def symbolize(value)
     if value.respond_to? :intern
       value.intern
     else
       value
     end
   end
 
   def symbolizehash(hash)
     newhash = {}
     hash.each do |name, val|
       if name.is_a? String
         newhash[name.intern] = val
       else
         newhash[name] = val
       end
     end
     newhash
   end
 
   def symbolizehash!(hash)
     # this is not the most memory-friendly way to accomplish this, but the
     #  code re-use and clarity seems worthwhile.
     newhash = symbolizehash(hash)
     hash.clear
     hash.merge!(newhash)
 
     hash
   end
   module_function :symbolize, :symbolizehash, :symbolizehash!
 
   # Just benchmark, with no logging.
   def thinmark
     seconds = Benchmark.realtime {
       yield
     }
 
     seconds
   end
 
   module_function :memory, :thinmark
 
   # Because IO#binread is only available in 1.9
   def binread(file)
     File.open(file, 'rb') { |f| f.read }
   end
   module_function :binread
 
   # utility method to get the current call stack and format it to a human-readable string (which some IDEs/editors
   # will recognize as links to the line numbers in the trace)
   def self.pretty_backtrace(backtrace = caller(1))
     backtrace.collect do |line|
       file_path, line_num = line.split(":")
       file_path = expand_symlinks(File.expand_path(file_path))
 
       file_path + ":" + line_num
     end .join("\n")
 
   end
 
   # utility method that takes a path as input, checks each component of the path to see if it is a symlink, and expands
   # it if it is.  returns the expanded path.
   def self.expand_symlinks(file_path)
     file_path.split("/").inject do |full_path, next_dir|
       next_path = full_path + "/" + next_dir
       if File.symlink?(next_path) then
         link = File.readlink(next_path)
         next_path =
             case link
               when /^\// then link
               else
                 File.expand_path(full_path + "/" + link)
             end
       end
       next_path
     end
   end
 
   # Replace a file, securely.  This takes a block, and passes it the file
   # handle of a file open for writing.  Write the replacement content inside
   # the block and it will safely replace the target file.
   #
   # This method will make no changes to the target file until the content is
   # successfully written and the block returns without raising an error.
   #
   # As far as possible the state of the existing file, such as mode, is
   # preserved.  This works hard to avoid loss of any metadata, but will result
   # in an inode change for the file.
   #
   # Arguments: `filename`, `default_mode`
   #
   # The filename is the file we are going to replace.
   #
   # The default_mode is the mode to use when the target file doesn't already
   # exist; if the file is present we copy the existing mode/owner/group values
   # across.
   def replace_file(file, default_mode, &block)
     raise Puppet::DevError, "replace_file requires a block" unless block_given?
 
     file     = Pathname(file)
     tempfile = Tempfile.new(file.basename.to_s, file.dirname.to_s)
 
     file_exists = file.exist?
 
     # Set properties of the temporary file before we write the content, because
     # Tempfile doesn't promise to be safe from reading by other people, just
     # that it avoids races around creating the file.
     #
     # Our Windows emulation is pretty limited, and so we have to carefully
     # and specifically handle the platform, which has all sorts of magic.
     # So, unlike Unix, we don't pre-prep security; we use the default "quite
     # secure" tempfile permissions instead.  Magic happens later.
     unless Puppet.features.microsoft_windows?
       # Grab the current file mode, and fall back to the defaults.
       stat = file.lstat rescue OpenStruct.new(:mode => default_mode,
                                               :uid  => Process.euid,
                                               :gid  => Process.egid)
 
       # We only care about the bottom four slots, which make the real mode,
       # and not the rest of the platform stat call fluff and stuff.
       tempfile.chmod(stat.mode & 07777)
       tempfile.chown(stat.uid, stat.gid)
     end
 
     # OK, now allow the caller to write the content of the file.
     yield tempfile
 
     # Now, make sure the data (which includes the mode) is safe on disk.
     tempfile.flush
     begin
       tempfile.fsync
     rescue NotImplementedError
       # fsync may not be implemented by Ruby on all platforms, but
       # there is absolutely no recovery path if we detect that.  So, we just
       # ignore the return code.
       #
       # However, don't be fooled: that is accepting that we are running in
       # an unsafe fashion.  If you are porting to a new platform don't stub
       # that out.
     end
 
     tempfile.close
 
     if Puppet.features.microsoft_windows?
       # This will appropriately clone the file, but only if the file we are
       # replacing exists.  Which is kind of annoying; thanks Microsoft.
       #
       # So, to avoid getting into an infinite loop we will retry once if the
       # file doesn't exist, but only the once...
       have_retried = false
 
       begin
         # Yes, the arguments are reversed compared to the rename in the rest
         # of the world.
         Puppet::Util::Windows::File.replace_file(file, tempfile.path)
       rescue Puppet::Util::Windows::Error => e
         # This might race, but there are enough possible cases that there
         # isn't a good, solid "better" way to do this, and the next call
         # should fail in the same way anyhow.
         raise if have_retried or File.exist?(file)
         have_retried = true
 
         # OK, so, we can't replace a file that doesn't exist, so let us put
         # one in place and set the permissions.  Then we can retry and the
         # magic makes this all work.
         #
         # This is the least-worst option for handling Windows, as far as we
         # can determine.
         File.open(file, 'a') do |fh|
           # this space deliberately left empty for auto-close behaviour,
           # append mode, and not actually changing any of the content.
         end
 
         # Set the permissions to what we want.
         Puppet::Util::Windows::Security.set_mode(default_mode, file.to_s)
 
         # ...and finally retry the operation.
         retry
       end
     else
       File.rename(tempfile.path, file)
     end
 
     # Ideally, we would now fsync the directory as well, but Ruby doesn't
     # have support for that, and it doesn't matter /that/ much...
 
     # Return something true, and possibly useful.
     file
   end
   module_function :replace_file
 
 
   # Executes a block of code, wrapped with some special exception handling.  Causes the ruby interpreter to
   #  exit if the block throws an exception.
   #
   # @param [String] message a message to log if the block fails
   # @param [Integer] code the exit code that the ruby interpreter should return if the block fails
   # @yield
   def exit_on_fail(message, code = 1)
     yield
   # First, we need to check and see if we are catching a SystemExit error.  These will be raised
   #  when we daemonize/fork, and they do not necessarily indicate a failure case.
   rescue SystemExit => err
     raise err
 
   # Now we need to catch *any* other kind of exception, because we may be calling third-party
   #  code (e.g. webrick), and we have no idea what they might throw.
   rescue Exception => err
+    ## NOTE: when debugging spec failures, these two lines can be very useful
+    #puts err.inspect
+    #puts Puppet::Util.pretty_backtrace(err.backtrace)
     Puppet.log_exception(err, "Could not #{message}: #{err}")
     Puppet::Util::Log.force_flushqueue()
     exit(code)
   end
   module_function :exit_on_fail
 
 
 
 
   #######################################################################################################
   # Deprecated methods relating to process execution; these have been moved to Puppet::Util::Execution
   #######################################################################################################
 
   def execpipe(command, failonfail = true, &block)
     Puppet.deprecation_warning("Puppet::Util.execpipe is deprecated; please use Puppet::Util::Execution.execpipe")
     Puppet::Util::Execution.execpipe(command, failonfail, &block)
   end
   module_function :execpipe
 
   def execfail(command, exception)
     Puppet.deprecation_warning("Puppet::Util.execfail is deprecated; please use Puppet::Util::Execution.execfail")
     Puppet::Util::Execution.execfail(command, exception)
   end
   module_function :execfail
 
   def execute(command, arguments = {})
     Puppet.deprecation_warning("Puppet::Util.execute is deprecated; please use Puppet::Util::Execution.execute")
     Puppet::Util::Execution.execute(command, arguments)
   end
   module_function :execute
 
 end
 end
 
 
 require 'puppet/util/errors'
 require 'puppet/util/methodhelper'
 require 'puppet/util/metaid'
 require 'puppet/util/classgen'
 require 'puppet/util/docs'
 require 'puppet/util/execution'
 require 'puppet/util/logging'
 require 'puppet/util/package'
 require 'puppet/util/warnings'
diff --git a/lib/puppet/util/command_line.rb b/lib/puppet/util/command_line.rb
index 4200f7a34..b4606f22f 100644
--- a/lib/puppet/util/command_line.rb
+++ b/lib/puppet/util/command_line.rb
@@ -1,184 +1,116 @@
 require 'puppet'
 require "puppet/util/plugins"
-require 'puppet/util/command_line/puppet_option_parser'
 
 module Puppet
   module Util
     class CommandLine
 
       def initialize(zero = $0, argv = ARGV, stdin = STDIN)
         @zero  = zero
         @argv  = argv.dup
         @stdin = stdin
 
         @subcommand_name, @args = subcommand_and_args(@zero, @argv, @stdin)
         Puppet::Plugins.on_commandline_initialization(:command_line_object => self)
       end
 
       attr :subcommand_name
       attr :args
 
       def appdir
         File.join('puppet', 'application')
       end
 
-      # This method is called during application bootstrapping.  It is responsible for parsing all of the
-      # command line options and initializing the values in Puppet.settings accordingly.
-      #
-      # It will ignore options that are not defined in the global puppet settings list, because they may
-      # be valid options for the specific application that we are about to launch... however, at this point
-      # in the bootstrapping lifecycle, we don't yet know what that application is.
-      def parse_global_options
-        # Create an option parser
-        option_parser = PuppetOptionParser.new
-        option_parser.ignore_invalid_options = true
-
-        # 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
-
-        option_parser.parse(args)
-
-      end
-      private :parse_global_options
-
-
-      # Private utility method; this is the callback that the OptionParser will use when it finds
-      # an option that was defined in Puppet.settings.  All that this method does is a little bit
-      # of clanup to get the option into the exact format that Puppet.settings expects it to be in,
-      # and then passes it along to Puppet.settings.
-      #
-      # @param [String] opt the command-line option that was matched
-      # @param [String, TrueClass, FalseClass] the value for the setting (as determined by the OptionParser)
-      def handlearg(opt, val)
-        opt, val = self.class.clean_opt(opt, val)
-        Puppet.settings.handlearg(opt, val)
-      end
-      private :handlearg
-
-      # A utility method (public, is used by application.rb and perhaps elsewhere) that munges a command-line
-      # option string into the format that Puppet.settings expects.  (This mostly has to deal with handling the
-      # "no-" prefix on flag/boolean options).
-      #
-      # @param [String] opt the command line option that we are munging
-      # @param [String, TrueClass, FalseClass] the value for the setting (as determined by the OptionParser)
-      def self.clean_opt(opt, val)
-        # rewrite --[no-]option to --no-option if that's what was given
-        if opt =~ /\[no-\]/ and !val
-          opt = opt.gsub(/\[no-\]/,'no-')
-        end
-        # otherwise remove the [no-] prefix to not confuse everybody
-        opt = opt.gsub(/\[no-\]/, '')
-        [opt, val]
-      end
 
 
 
       def self.available_subcommands
         # Eventually we probably want to replace this with a call to the autoloader.  however, at the moment
         #  the autoloader considers the module path when loading, and we don't want to allow apps / faces to load
         #  from there.  Once that is resolved, this should be replaced.  --cprice 2012-03-06
         absolute_appdirs = $LOAD_PATH.collect do |x|
           File.join(x,'puppet','application')
         end.select{ |x| File.directory?(x) }
         absolute_appdirs.inject([]) do |commands, dir|
           commands + Dir[File.join(dir, '*.rb')].map{|fn| File.basename(fn, '.rb')}
         end.uniq
       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
       def available_subcommands
         self.class.available_subcommands
       end
 
       def require_application(application)
         require File.join(appdir, application)
       end
 
       # This is the main entry point for all puppet applications / faces; it is basically where the bootstrapping
       # process / lifecycle of an app begins.
       def execute
-        # The first two phases of the lifecycle of a puppet application are:
-        #  1) To parse the command line options and handle any of them that are registered, defined "global" puppet
-        #     settings (mostly from defaults.rb).)
-        #  2) To parse the puppet config file(s).
-        #
-        # These 2 steps are being handled explicitly here.  If there ever arises a situation where they need to be
-        # triggered from outside of this class, without triggering the rest of the lifecycle--we might want to move them
-        # out into a separate method that we call from here.  However, this seems to be sufficient for now.
-        #  --cprice 2012-03-16
-
-        # Here's step 1.
-        Puppet::Util.exit_on_fail("parse global options")     { parse_global_options }
-
-        # Here's step 2.  NOTE: this is a change in behavior where we are now parsing the config file on every run;
-        # before, there were several apps that specifically registered themselves as not requiring anything from
-        # the config file.  The fact that we're always parsing it now might be a small performance hit, but it was
-        # necessary in order to make sure that we can resolve the libdir before we look for the available applications.
-        Puppet::Util.exit_on_fail("parse configuration file") { Puppet.settings.parse }
+        Puppet::Util.exit_on_fail("intialize global default settings") do
+          Puppet.settings.initialize_global_settings(args)
+        end
 
         # OK, now that we've processed the command line options and the config files, we should be able to say that
         # we definitively know where the libdir is... which means that we can now look for our available
         # applications / subcommands / faces.
 
         if subcommand_name and available_subcommands.include?(subcommand_name) then
           require_application subcommand_name
           # This will need to be cleaned up to do something that is not so application-specific
           #  (i.e.. so that we can load faces).  Longer-term, use the autoloader.  See comments in
           #  #available_subcommands method above.  --cprice 2012-03-06
           app = Puppet::Application.find(subcommand_name).new(self)
           Puppet::Plugins.on_application_initialization(:appliation_object => self)
 
           app.run
         elsif ! execute_external_subcommand then
           unless subcommand_name.nil? then
             puts "Error: Unknown Puppet subcommand '#{subcommand_name}'"
           end
           puts "See 'puppet help' for help on available puppet subcommands"
         end
       end
 
       def execute_external_subcommand
         external_command = "puppet-#{subcommand_name}"
 
         require 'puppet/util'
         path_to_subcommand = Puppet::Util.which(external_command)
         return false unless path_to_subcommand
 
         exec(path_to_subcommand, *args)
       end
 
       def legacy_executable_name
         name = CommandLine::LegacyCommandLine::LEGACY_NAMES[ subcommand_name.intern ]
         return name unless name.nil?
         return subcommand_name.intern
       end
 
       private
 
       def subcommand_and_args(zero, argv, stdin)
         zero = File.basename(zero, '.rb')
 
         if zero == 'puppet'
           case argv.first
             # if they didn't pass a command, or passed a help flag, we will fall back to showing a usage message.
             #  we no longer default to 'apply'
             when nil, "--help", "-h", /^-|\.pp$|\.rb$/
               [nil, argv]
             else
               [argv.first, argv[1..-1]]
           end
         else
           [zero, argv]
         end
       end
 
     end
   end
 end
diff --git a/lib/puppet/util/settings.rb b/lib/puppet/util/settings.rb
index 0090b4ec8..fdec7ae45 100644
--- a/lib/puppet/util/settings.rb
+++ b/lib/puppet/util/settings.rb
@@ -1,1178 +1,1281 @@
 require 'puppet'
 require 'sync'
 require 'getoptlong'
 require 'puppet/util/loadedfile'
+require 'puppet/util/command_line/puppet_option_parser'
 
 class Puppet::SettingsError < Puppet::Error
 end
 
 # The class for handling configuration files.
 class Puppet::Util::Settings
   include Enumerable
 
   require 'puppet/util/settings/string_setting'
   require 'puppet/util/settings/file_setting'
   require 'puppet/util/settings/directory_setting'
   require 'puppet/util/settings/boolean_setting'
 
+  # local reference for convenience
+  PuppetOptionParser = Puppet::Util::CommandLine::PuppetOptionParser
+
   attr_accessor :files
   attr_reader :timer
 
   READ_ONLY_SETTINGS = [:run_mode]
 
   # These are the settings that every app is required to specify; there are reasonable defaults defined in application.rb.
   REQUIRED_APP_SETTINGS = [:run_mode, :logdir, :confdir, :vardir]
 
+  # This method is intended for puppet internal use only; it is a convenience method that
+  #  returns reasonable application default settings values for a given run_mode.
+  def self.app_defaults_for_run_mode(run_mode)
+    {
+        :name     => run_mode.to_s,
+        :run_mode => run_mode.name,
+        :confdir  => run_mode.conf_dir,
+        :vardir   => run_mode.var_dir,
+        :rundir   => run_mode.run_dir,
+        :logdir   => run_mode.log_dir,
+    }
+  end
+
   def self.default_global_config_dir()
     Puppet.features.microsoft_windows? ? File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "etc") : "/etc/puppet"
   end
 
   def self.default_user_config_dir()
     "~/.puppet"
   end
 
   def self.default_global_var_dir()
     Puppet.features.microsoft_windows? ? File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "var") : "/var/lib/puppet"
   end
 
   def self.default_user_var_dir()
     "~/.puppet/var"
   end
 
   def self.default_config_file_name()
     "puppet.conf"
   end
 
 
   # Retrieve a config value
   def [](param)
     value(param)
   end
 
   # Set a config value.  This doesn't set the defaults, it sets the value itself.
   def []=(param, value)
     set_value(param, value, :memory)
   end
 
   # Generate the list of valid arguments, in a format that GetoptLong can
   # understand, and add them to the passed option list.
   def addargs(options)
     # Add all of the config parameters as valid options.
     self.each { |name, setting|
       setting.getopt_args.each { |args| options << args }
     }
 
     options
   end
 
   # Generate the list of valid arguments, in a format that OptionParser can
   # understand, and add them to the passed option list.
   def optparse_addargs(options)
     # Add all of the config parameters as valid options.
     self.each { |name, setting|
       options << setting.optparse_args
     }
 
     options
   end
 
   # Is our parameter a boolean parameter?
   def boolean?(param)
     param = param.to_sym
     !!(@config.include?(param) and @config[param].kind_of? BooleanSetting)
   end
 
   # Remove all set values, potentially skipping cli values.
   def clear
     @sync.synchronize do
       unsafe_clear
     end
   end
 
   # Remove all set values, potentially skipping cli values.
   def unsafe_clear(clear_cli = true, clear_application_defaults = false)
     @values.each do |name, values|
       next if ((name == :application_defaults) and !clear_application_defaults)
       next if ((name == :cli) and !clear_cli)
       @values.delete(name)
     end
 
     # Only clear the 'used' values if we were explicitly asked to clear out
     #  :cli values; otherwise, it may be just a config file reparse,
     #  and we want to retain this cli values.
     @used = [] if clear_cli
 
     @app_defaults_initialized = false if clear_application_defaults
 
     @cache.clear
   end
   private :unsafe_clear
 
 
 
   # This is mostly just used for testing.
   def clearused
     @cache.clear
     @used = []
   end
 
+  def global_defaults_initialized?()
+    @global_defaults_initialized
+  end
+
+  def initialize_global_settings(args = [])
+    raise Puppet::DevError, "Attempting to initialize global default settings more than once!" if global_defaults_initialized?
+
+    # The first two phases of the lifecycle of a puppet application are:
+    #  1) To parse the command line options and handle any of them that are registered, defined "global" puppet
+    #     settings (mostly from defaults.rb).)
+    #  2) To parse the puppet config file(s).
+    #
+    # These 2 steps are being handled explicitly here.  If there ever arises a situation where they need to be
+    # triggered from outside of this class, without triggering the rest of the lifecycle--we might want to move them
+    # out into a separate method that we call from here.  However, this seems to be sufficient for now.
+    #  --cprice 2012-03-16
+
+    # Here's step 1.
+    parse_global_options(args)
+
+    # Here's step 2.  NOTE: this is a change in behavior where we are now parsing the config file on every run;
+    # before, there were several apps that specifically registered themselves as not requiring anything from
+    # the config file.  The fact that we're always parsing it now might be a small performance hit, but it was
+    # necessary in order to make sure that we can resolve the libdir before we look for the available applications.
+    parse_config_files
+
+    @global_defaults_initialized = true
+  end
+
+  # This method is called during application bootstrapping.  It is responsible for parsing all of the
+  # command line options and initializing the settings accordingly.
+  #
+  # It will ignore options that are not defined in the global puppet settings list, because they may
+  # be valid options for the specific application that we are about to launch... however, at this point
+  # in the bootstrapping lifecycle, we don't yet know what that application is.
+  def parse_global_options(args)
+    # Create an option parser
+    option_parser = PuppetOptionParser.new
+    option_parser.ignore_invalid_options = true
+
+    # Add all global options to it.
+    self.optparse_addargs([]).each do |option|
+      option_parser.on(*option) do |arg|
+        opt, val = Puppet::Util::Settings.clean_opt(option[0], arg)
+        handlearg(opt, val)
+      end
+    end
+
+    option_parser.parse(args)
+
+  end
+  private :parse_global_options
+
+
+  ## Private utility method; this is the callback that the OptionParser will use when it finds
+  ## an option that was defined in Puppet.settings.  All that this method does is a little bit
+  ## of clanup to get the option into the exact format that Puppet.settings expects it to be in,
+  ## and then passes it along to Puppet.settings.
+  ##
+  ## @param [String] opt the command-line option that was matched
+  ## @param [String, TrueClass, FalseClass] the value for the setting (as determined by the OptionParser)
+  #def handlearg(opt, val)
+  #  opt, val = self.class.clean_opt(opt, val)
+  #  Puppet.settings.handlearg(opt, val)
+  #end
+  #private :handlearg
+
+
+  # A utility method (public, is used by application.rb and perhaps elsewhere) that munges a command-line
+  # option string into the format that Puppet.settings expects.  (This mostly has to deal with handling the
+  # "no-" prefix on flag/boolean options).
+  #
+  # @param [String] opt the command line option that we are munging
+  # @param [String, TrueClass, FalseClass] the value for the setting (as determined by the OptionParser)
+  def self.clean_opt(opt, val)
+    # rewrite --[no-]option to --no-option if that's what was given
+    if opt =~ /\[no-\]/ and !val
+      opt = opt.gsub(/\[no-\]/,'no-')
+    end
+    # otherwise remove the [no-] prefix to not confuse everybody
+    opt = opt.gsub(/\[no-\]/, '')
+    [opt, val]
+  end
+
 
   def app_defaults_initialized?()
     @app_defaults_initialized
   end
 
   def initialize_app_defaults(app_defaults)
     raise Puppet::DevError, "Attempting to initialize application default settings more than once!" if app_defaults_initialized?
     REQUIRED_APP_SETTINGS.each do |key|
       raise Puppet::SettingsError, "missing required app default setting '#{key}'" unless app_defaults.has_key?(key)
     end
     app_defaults.each do |key, value|
       set_value(key, value, :application_defaults)
     end
     call_hooks_deferred_to_application_initialization
 
     @app_defaults_initialized = true
   end
 
   def call_hooks_deferred_to_application_initialization(options = {})
     @hooks_to_call_on_application_initialization.each do |setting| 
       begin
         setting.handle(self.value(setting.name))
       rescue Puppet::SettingsError => err
         raise err unless options[:ignore_interpolation_dependency_errors]
         #swallow. We're not concerned if we can't call hooks because dependencies don't exist yet
         #we'll get another chance after application defaults are initialized
       end
     end
   end
   private :call_hooks_deferred_to_application_initialization
 
   # Do variable interpolation on the value.
   def convert(value, environment = nil)
     return nil if value.nil?
     return value unless value.is_a? String
     newval = value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |value|
       varname = $2 || $1
       if varname == "environment" and environment
         environment
       elsif pval = self.value(varname, environment)
         pval
       else
         raise Puppet::SettingsError, "Could not find value for #{value}"
       end
     end
 
     newval
   end
 
   # Return a value's description.
   def description(name)
     if obj = @config[name.to_sym]
       obj.desc
     else
       nil
     end
   end
 
   def each
     @config.each { |name, object|
       yield name, object
     }
   end
 
   # Iterate over each section name.
   def eachsection
     yielded = []
     @config.each do |name, object|
       section = object.section
       unless yielded.include? section
         yield section
         yielded << section
       end
     end
   end
 
   # Return an object by name.
   def setting(param)
     param = param.to_sym
     @config[param]
   end
 
   # Handle a command-line argument.
   def handlearg(opt, value = nil)
     @cache.clear
 
     if value.is_a?(FalseClass)
       value = "false"
     elsif value.is_a?(TrueClass)
       value = "true"
     end
 
 
     value &&= munge_value(value)
     str = opt.sub(/^--/,'')
 
     bool = true
     newstr = str.sub(/^no-/, '')
     if newstr != str
       str = newstr
       bool = false
     end
     str = str.intern
 
     if @config[str].is_a?(Puppet::Util::Settings::BooleanSetting)
       if value == "" or value.nil?
         value = bool
       end
     end
 
     set_value(str, value, :cli)
   end
 
   def include?(name)
     name = name.intern if name.is_a? String
     @config.include?(name)
   end
 
   # check to see if a short name is already defined
   def shortinclude?(short)
     short = short.intern if name.is_a? String
     @shortnames.include?(short)
   end
 
   # Create a new collection of config settings.
   def initialize
     @config = {}
     @shortnames = {}
 
     @created = []
     @searchpath = nil
 
     # Mutex-like thing to protect @values
     @sync = Sync.new
 
     # Keep track of set values.
     @values = Hash.new { |hash, key| hash[key] = {} }
 
     # And keep a per-environment cache
     @cache = Hash.new { |hash, key| hash[key] = {} }
 
     # The list of sections we've used.
     @used = []
 
     @hooks_to_call_on_application_initialization = []
   end
 
   # NOTE: ACS ahh the util classes. . .sigh
   # as part of a fix for 1183, I pulled the logic for the following 5 methods out of the executables and puppet.rb
   # They probably deserve their own class, but I don't want to do that until I can refactor environments
   # its a little better than where they were
 
   # Prints the contents of a config file with the available config settings, or it
   # prints a single value of a config setting.
   def print_config_options
     env = value(:environment)
     val = value(:configprint)
     if val == "all"
       hash = {}
       each do |name, obj|
         val = value(name,env)
         val = val.inspect if val == ""
         hash[name] = val
       end
       hash.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, val|
         puts "#{name} = #{val}"
       end
     else
       val.split(/\s*,\s*/).sort.each do |v|
         if include?(v)
           #if there is only one value, just print it for back compatibility
           if v == val
             puts value(val,env)
             break
           end
           puts "#{v} = #{value(v,env)}"
         else
           puts "invalid parameter: #{v}"
           return false
         end
       end
     end
     true
   end
 
   def generate_config
     puts to_config
     true
   end
 
   def generate_manifest
     puts to_manifest
     true
   end
 
   def print_configs
     return print_config_options if value(:configprint) != ""
     return generate_config if value(:genconfig)
     generate_manifest if value(:genmanifest)
   end
 
   def print_configs?
     (value(:configprint) != "" || value(:genconfig) || value(:genmanifest)) && true
   end
 
   # Return a given object's file metadata.
   def metadata(param)
     if obj = @config[param.to_sym] and obj.is_a?(FileSetting)
       return [:owner, :group, :mode].inject({}) do |meta, p|
         if v = obj.send(p)
           meta[p] = v
         end
         meta
       end
     else
       nil
     end
   end
 
   # Make a directory with the appropriate user, group, and mode
   def mkdir(default)
     obj = get_config_file_default(default)
 
     Puppet::Util::SUIDManager.asuser(obj.owner, obj.group) do
       mode = obj.mode || 0750
       Dir.mkdir(obj.value, mode)
     end
   end
 
   # Figure out the section name for the run_mode.
   def run_mode
     @run_mode || :user
   end
 
   # PRIVATE!  This only exists because we need a hook to validate the run mode when it's being set, and
   #  it should never, ever, ever, ever be called from outside of this file.
   def run_mode=(mode)
     raise Puppet::DevError, "Invalid run mode '#{mode}'" unless [:master, :agent, :user].include?(mode)
     @run_mode = mode
   end
   private :run_mode=
 
   # Return all of the parameters associated with a given section.
   def params(section = nil)
     if section
       section = section.intern if section.is_a? String
       @config.find_all { |name, obj|
         obj.section == section
       }.collect { |name, obj|
         name
       }
     else
       @config.keys
     end
   end
 
   # Parse the configuration file.  Just provides
   # thread safety.
-  def parse
+  def parse_config_files
     # we are now supporting multiple config files; the "main" config file will be the one located in
     # /etc/puppet (or overridden $confdir)... but we will also look for a config file in the user's home
     # directory.  This was introduced in an effort to provide maximum backwards compatibility while
     # de-coupling the process of locating the config file from the "run mode" of the application.
     files = [main_config_file]
     files << user_config_file unless Puppet.features.root?
 
     @sync.synchronize do
       unsafe_parse(files)
     end
     
     # talking with cprice, Settings.parse will not be the final location for this. He's working on ticket
     # that, as a side effect, will create a more appropriate place for this. At that time, this will be
     # moved to the new location. --jeffweiss 24 apr 2012
     call_hooks_deferred_to_application_initialization :ignore_interpolation_dependency_errors => true
   end
+  private :parse_config_files
 
   def main_config_file
     # the algorithm here is basically this:
     #  * use the explicit config file location if one has been specified; this can be affected by modifications
     #    to either the "confdir" or "config" settings (most likely via CLI arguments).
     #  * if no explicit config location has been specified, we fall back to the default.
     #
     # The easiest way to determine whether an explicit one has been specified is to simply attempt to evaluate
     #  the value of ":config".  This will obviously be successful if they've passed an explicit value for :config,
     #  but it will also result in successful interpolation if they've only passed an explicit value for :confdir.
     #
     # If they've specified neither, then the interpolation will fail and we'll get an exception.
     #
     begin
       return self[:config] if self[:config]
     rescue Puppet::SettingsError => err
       # This means we failed to interpolate, which means that they didn't explicitly specify either :config or
       # :confdir... so we'll fall out to the default value.
     end
     # return the default value.
     return File.join(self.class.default_global_config_dir, config_file_name)
   end
   private :main_config_file
 
   def user_config_file
     return File.join(self.class.default_user_config_dir, config_file_name)
   end
   private :user_config_file
 
   # This method is here to get around some life-cycle issues.  We need to be able to determine the config file name
   # before the settings / defaults are fully loaded.  However, we also need to respect any overrides of this value
   # that the user may have specified on the command line.
   #
   # The easiest way to do this is to attempt to read the setting, and if we catch an error (meaning that it hasn't been
   #  set yet), we'll fall back to the default value.
   def config_file_name
     begin
       return self[:config_file_name] if self[:config_file_name]
     rescue Puppet::SettingsError => err
       # This just means that the setting wasn't explicitly set on the command line, so we will ignore it and
       #  fall through to the default name.
     end
     return self.class.default_config_file_name
   end
   private :config_file_name
 
   # Unsafely parse the file -- this isn't thread-safe and causes plenty of problems if used directly.
   def unsafe_parse(files)
     raise Puppet::DevError unless files.length > 0
 
     # build up a single data structure that contains the values from all of the parsed files.
     data = {}
     files.each do |file|
       next unless FileTest.exist?(file)
       begin
         file_data = parse_file(file)
 
         # This is a little kludgy; basically we are merging a hash of hashes.  We can't use "merge" at the
         # outermost level or we risking losing data from the hash we're merging into.
         file_data.keys.each do |key|
           if data.has_key?(key)
             data[key].merge!(file_data[key])
           else
             data[key] = file_data[key]
           end
         end
 
       rescue => detail
         Puppet.log_exception(detail, "Could not parse #{file}: #{detail}")
         return
       end
     end
 
     # If we get here and don't have any data, we just return and don't muck with the current state of the world.
     return if data.empty?
 
     # If we get here then we have some data, so we need to clear out any previous settings that may have come from
     #  config files.
     unsafe_clear(false, false)
 
     # And now we can repopulate with the values from our last parsing of the config files.
     metas = {}
     data.each do |area, values|
       metas[area] = values.delete(:_meta)
       values.each do |key,value|
         set_value(key, value, area, :dont_trigger_handles => true, :ignore_bad_settings => true )
       end
     end
 
     # Determine our environment, if we have one.
     if @config[:environment]
       env = self.value(:environment).to_sym
     else
       env = "none"
     end
 
     # Call any hooks we should be calling.
     settings_with_hooks.each do |setting|
       each_source(env) do |source|
         if value = @values[source][setting.name]
           # We still have to use value to retrieve the value, since
           # we want the fully interpolated value, not $vardir/lib or whatever.
           # This results in extra work, but so few of the settings
           # will have associated hooks that it ends up being less work this
           # way overall.
           setting.handle(self.value(setting.name, env))
           break
         end
       end
     end
 
     # We have to do it in the reverse of the search path,
     # because multiple sections could set the same value
     # and I'm too lazy to only set the metadata once.
     searchpath.reverse.each do |source|
       source = run_mode if source == :run_mode
       source = @name if (@name && source == :name)
       if meta = metas[source]
         set_metadata(meta)
       end
     end
   end
   private :unsafe_parse
 
 
   # Create a new setting.  The value is passed in because it's used to determine
   # what kind of setting we're creating, but the value itself might be either
   # a default or a value, so we can't actually assign it.
   #
   # See #define_settings for documentation on the legal values for the ":type" option.
   def newsetting(hash)
     klass = nil
     hash[:section] = hash[:section].to_sym if hash[:section]
 
     if type = hash[:type]
       unless klass = {
           :string     => StringSetting,
           :file       => FileSetting,
           :directory  => DirectorySetting,
           :path       => StringSetting,
           :boolean    => BooleanSetting,
       } [type]
         raise ArgumentError, "Invalid setting type '#{type}'"
       end
       hash.delete(:type)
     else
       # The only implicit typing we still do for settings is to fall back to "String" type if they didn't explicitly
       # specify a type.  Personally I'd like to get rid of this too, and make the "type" option mandatory... but
       # there was a little resistance to taking things quite that far for now.  --cprice 2012-03-19
       klass = StringSetting
     end
     hash[:settings] = self
     setting = klass.new(hash)
 
     setting
   end
 
   # This has to be private, because it doesn't add the settings to @config
   private :newsetting
 
   # Iterate across all of the objects in a given section.
   def persection(section)
     section = section.to_sym
     self.each { |name, obj|
       if obj.section == section
         yield obj
       end
     }
   end
 
   # Reparse our config file, if necessary.
-  def reparse
+  def reparse_config_files
     if files
       if filename = any_files_changed?
         Puppet.notice "Config file #{filename} changed; triggering re-parse of all config files."
-        parse
+        parse_config_files
         reuse
       end
     end
   end
 
   def files
     return @files if @files
     @files = []
     [main_config_file, user_config_file].each do |path|
       if FileTest.exist?(path)
         @files << Puppet::Util::LoadedFile.new(path)
       end
     end
     @files
   end
   private :files
 
   # Checks to see if any of the config files have been modified
   # @return the filename of the first file that is found to have changed, or nil if no files have changed
   def any_files_changed?
     files.each do |file|
       return file.file if file.changed?
     end
     nil
   end
   private :any_files_changed?
 
   def reuse
     return unless defined?(@used)
     @sync.synchronize do # yay, thread-safe
       new = @used
       @used = []
       self.use(*new)
     end
   end
 
   # The order in which to search for values.
   def searchpath(environment = nil)
     if environment
       [:cli, :memory, environment, :run_mode, :main, :application_defaults]
     else
       [:cli, :memory, :run_mode, :main, :application_defaults]
     end
   end
 
   # Get a list of objects per section
   def sectionlist
     sectionlist = []
     self.each { |name, obj|
       section = obj.section || "puppet"
       sections[section] ||= []
       sectionlist << section unless sectionlist.include?(section)
       sections[section] << obj
     }
 
     return sectionlist, sections
   end
 
   def service_user_available?
     return @service_user_available if defined?(@service_user_available)
 
     return @service_user_available = false unless user_name = self[:user]
 
     user = Puppet::Type.type(:user).new :name => self[:user], :audit => :ensure
 
     @service_user_available = user.exists?
   end
 
   def legacy_to_mode(type, param)
     require 'puppet/util/command_line/legacy_command_line'
     if Puppet::Util::CommandLine::LegacyCommandLine::LEGACY_APPS.has_key?(type)
       new_type = Puppet::Util::CommandLine::LegacyCommandLine::LEGACY_APPS[type].run_mode
       Puppet.deprecation_warning "You have configuration parameter $#{param} specified in [#{type}], which is a deprecated section. I'm assuming you meant [#{new_type}]"
       return new_type
     end
     type
   end
   
   # Allow later inspection to determine if the setting was set on the
   # command line, or through some other code path.  Used for the
   # `dns_alt_names` option during cert generate. --daniel 2011-10-18
   def set_by_cli?(param)
     param = param.to_sym
     !@values[:cli][param].nil?
   end
 
   def set_value(param, value, type, options = {})
     param = param.to_sym
 
     unless setting = @config[param]
       if options[:ignore_bad_settings]
         return
       else
         raise ArgumentError,
           "Attempt to assign a value to unknown configuration parameter #{param.inspect}"
       end
     end
 
     value = setting.munge(value) if setting.respond_to?(:munge)
     setting.handle(value) if setting.has_hook? and not options[:dont_trigger_handles]
     if read_only_settings.include? param and type != :application_defaults
       raise ArgumentError,
         "You're attempting to set configuration parameter $#{param}, which is read-only."
     end
     type = legacy_to_mode(type, param)
     @sync.synchronize do # yay, thread-safe
 
       @values[type][param] = value
       @cache.clear
 
       clearused
 
       # Clear the list of environments, because they cache, at least, the module path.
       # We *could* preferentially just clear them if the modulepath is changed,
       # but we don't really know if, say, the vardir is changed and the modulepath
       # is defined relative to it. We need the defined?(stuff) because of loading
       # order issues.
       Puppet::Node::Environment.clear if defined?(Puppet::Node) and defined?(Puppet::Node::Environment)
     end
 
     # This is a hack.  The run_mode should probably not be a "normal" setting, because the places
     #  it is used tend to create lifecycle issues and cause other weird problems.  In some places
     #  we need for it to have a default value, in other places it may be preferable to be able to
     #  determine that it has not yet been set.  There used to be a global variable that some
     #  code paths would access; as a first step towards cleaning it up, I've gotten rid of the global
     #  variable and am instead using an instance variable in this class, but that means that if
     #  someone modifies the value of the setting at a later point during execution, then the
     #  instance variable needs to be updated as well... so that's what we're doing here.
     #
     #  This code should be removed if we get a chance to remove run_mode from the defined settings.
     #  --cprice 2012-03-19
     self.run_mode = value if param == :run_mode
 
     value
   end
 
 
 
 
   # Deprecated; use #define_settings instead
   def setdefaults(section, defs)
     Puppet.deprecation_warning("'setdefaults' is deprecated and will be removed; please call 'define_settings' instead")
     define_settings(section, defs)
   end
 
   # Define a group of settings.
   #
   # @param [Symbol] section a symbol to use for grouping multiple settings together into a conceptual unit.  This value
   #   (and the conceptual separation) is not used very often; the main place where it will have a potential impact
   #   is when code calls Settings#use method.  See docs on that method for further details, but basically that method
   #   just attempts to do any preparation that may be necessary before code attempts to leverage the value of a particular
   #   setting.  This has the most impact for file/directory settings, where #use will attempt to "ensure" those
   #   files / directories.
   # @param [Hash[Hash]] defs the settings to be defined.  This argument is a hash of hashes; each key should be a symbol,
   #   which is basically the name of the setting that you are defining.  The value should be another hash that specifies
   #   the parameters for the particular setting.  Legal values include:
   #    [:default] => required; this is a string value that will be used as a default value for a setting if no other
   #       value is specified (via cli, config file, etc.)  This string may include "variables", demarcated with $ or ${},
   #       which will be interpolated with values of other settings.
   #    [:desc] => required; a description of the setting, used in documentation / help generation
   #    [:type] => not required, but highly encouraged!  This specifies the data type that the setting represents.  If
   #       you do not specify it, it will default to "string".  Legal values include:
   #       :string - A generic string setting
   #       :boolean - A boolean setting; values are expected to be "true" or "false"
   #       :file - A (single) file path; puppet may attempt to create this file depending on how the settings are used.  This type
   #           also supports additional options such as "mode", "owner", "group"
   #       :directory - A (single) directory path; puppet may attempt to create this file depending on how the settings are used.  This type
   #           also supports additional options such as "mode", "owner", "group"
   #       :path - This is intended to be used for settings whose value can contain multiple directory paths, respresented
   #           as strings separated by the system path separator (e.g. system path, module path, etc.).
   #     [:mode] => an (optional) octal value to be used as the permissions/mode for :file and :directory settings
   #     [:owner] => optional owner username/uid for :file and :directory settings
   #     [:group] => optional group name/gid for :file and :directory settings
   #
   def define_settings(section, defs)
     section = section.to_sym
     call = []
     defs.each { |name, hash|
       raise ArgumentError, "setting definition for '#{name}' is not a hash!" unless hash.is_a? Hash
 
       name = name.to_sym
       hash[:name] = name
       hash[:section] = section
       raise ArgumentError, "Parameter #{name} is already defined" if @config.include?(name)
       tryconfig = newsetting(hash)
       if short = tryconfig.short
         if other = @shortnames[short]
           raise ArgumentError, "Parameter #{other.name} is already using short name '#{short}'"
         end
         @shortnames[short] = tryconfig
       end
       @config[name] = tryconfig
 
       # Collect the settings that need to have their hooks called immediately.
       # We have to collect them so that we can be sure we're fully initialized before
       # the hook is called.
       call << tryconfig if tryconfig.call_hook_on_define?
       @hooks_to_call_on_application_initialization << tryconfig if tryconfig.call_hook_on_initialize?
     }
 
     call.each { |setting| setting.handle(self.value(setting.name)) }
   end
 
   # Convert the settings we manage into a catalog full of resources that model those settings.
   def to_catalog(*sections)
     sections = nil if sections.empty?
 
     catalog = Puppet::Resource::Catalog.new("Settings")
 
     @config.keys.find_all { |key| @config[key].is_a?(FileSetting) }.each do |key|
       file = @config[key]
       next unless (sections.nil? or sections.include?(file.section))
       next unless resource = file.to_resource
       next if catalog.resource(resource.ref)
 
       Puppet.debug("Using settings: adding file resource '#{key}': '#{resource.inspect}'")
 
       catalog.add_resource(resource)
     end
 
     add_user_resources(catalog, sections)
 
     catalog
   end
 
   # Convert our list of config settings into a configuration file.
   def to_config
     str = %{The configuration file for #{Puppet.run_mode.name}.  Note that this file
 is likely to have unused configuration parameters in it; any parameter that's
 valid anywhere in Puppet can be in any config file, even if it's not used.
 
 Every section can specify three special parameters: owner, group, and mode.
 These parameters affect the required permissions of any files specified after
 their specification.  Puppet will sometimes use these parameters to check its
 own configured state, so they can be used to make Puppet a bit more self-managing.
 
 Generated on #{Time.now}.
 
 }.gsub(/^/, "# ")
 
 #         Add a section heading that matches our name.
 if @config.include?(:run_mode)
   str += "[#{self[:run_mode]}]\n"
     end
     eachsection do |section|
       persection(section) do |obj|
         str += obj.to_config + "\n" unless read_only_settings.include? obj.name or obj.name == :genconfig
       end
     end
 
     return str
   end
 
   # Convert to a parseable manifest
   def to_manifest
     catalog = to_catalog
     catalog.resource_refs.collect do |ref|
       catalog.resource(ref).to_manifest
     end.join("\n\n")
   end
 
   # Create the necessary objects to use a section.  This is idempotent;
   # you can 'use' a section as many times as you want.
   def use(*sections)
     sections = sections.collect { |s| s.to_sym }
     @sync.synchronize do # yay, thread-safe
       sections = sections.reject { |s| @used.include?(s) }
 
       return if sections.empty?
 
       begin
         catalog = to_catalog(*sections).to_ral
       rescue => detail
         Puppet.log_and_raise(detail, "Could not create resources for managing Puppet's files and directories in sections #{sections.inspect}: #{detail}")
       end
 
       catalog.host_config = false
       catalog.apply do |transaction|
         if transaction.any_failed?
           report = transaction.report
           failures = report.logs.find_all { |log| log.level == :err }
           raise "Got #{failures.length} failure(s) while initializing: #{failures.collect { |l| l.to_s }.join("; ")}"
         end
       end
 
       sections.each { |s| @used << s }
       @used.uniq!
     end
   end
 
   def valid?(param)
     param = param.to_sym
     @config.has_key?(param)
   end
 
   def uninterpolated_value(param, environment = nil)
     param = param.to_sym
     environment &&= environment.to_sym
 
     # See if we can find it within our searchable list of values
     val = find_value(environment, param)
 
     # If we didn't get a value, use the default
     val = @config[param].default if val.nil?
 
     val
   end
 
   def find_value(environment, param)
       each_source(environment) do |source|
         # Look for the value.  We have to test the hash for whether
         # it exists, because the value might be false.
         @sync.synchronize do
           return @values[source][param] if @values[source].include?(param)
         end
       end
       return nil
   end
   private :find_value
 
   # Find the correct value using our search path.  Optionally accept an environment
   # in which to search before the other configuration sections.
   def value(param, environment = nil, bypass_interpolation = false)
     param = param.to_sym
     environment &&= environment.to_sym
 
     # Short circuit to nil for undefined parameters.
     return nil unless @config.include?(param)
 
     # Yay, recursion.
     #self.reparse unless [:config, :filetimeout].include?(param)
 
     # Check the cache first.  It needs to be a per-environment
     # cache so that we don't spread values from one env
     # to another.
     if cached = @cache[environment||"none"][param]
       return cached
     end
 
     val = uninterpolated_value(param, environment)
 
     return val if bypass_interpolation
     if param == :code
       # if we interpolate code, all hell breaks loose.
       return val
     end
 
     # Convert it if necessary
     begin
       val = convert(val, environment)
     rescue Puppet::SettingsError => err
       raise Puppet::SettingsError.new("Error converting value for param '#{param}': #{err}")
     end
 
 
     # And cache it
     @cache[environment||"none"][param] = val
     val
   end
 
   # Open a file with the appropriate user, group, and mode
   def write(default, *args, &bloc)
     obj = get_config_file_default(default)
     writesub(default, value(obj.name), *args, &bloc)
   end
 
   # Open a non-default file under a default dir with the appropriate user,
   # group, and mode
   def writesub(default, file, *args, &bloc)
     obj = get_config_file_default(default)
     chown = nil
     if Puppet.features.root?
       chown = [obj.owner, obj.group]
     else
       chown = [nil, nil]
     end
 
     Puppet::Util::SUIDManager.asuser(*chown) do
       mode = obj.mode ? obj.mode.to_i : 0640
       args << "w" if args.empty?
 
       args << mode
 
       # Update the umask to make non-executable files
       Puppet::Util.withumask(File.umask ^ 0111) do
         File.open(file, *args) do |file|
           yield file
         end
       end
     end
   end
 
   def readwritelock(default, *args, &bloc)
     file = value(get_config_file_default(default).name)
     tmpfile = file + ".tmp"
     sync = Sync.new
     raise Puppet::DevError, "Cannot create #{file}; directory #{File.dirname(file)} does not exist" unless FileTest.directory?(File.dirname(tmpfile))
 
     sync.synchronize(Sync::EX) do
       File.open(file, ::File::CREAT|::File::RDWR, 0600) do |rf|
         rf.lock_exclusive do
           if File.exist?(tmpfile)
             raise Puppet::Error, ".tmp file already exists for #{file}; Aborting locked write. Check the .tmp file and delete if appropriate"
           end
 
           # If there's a failure, remove our tmpfile
           begin
             writesub(default, tmpfile, *args, &bloc)
           rescue
             File.unlink(tmpfile) if FileTest.exist?(tmpfile)
             raise
           end
 
           begin
             File.rename(tmpfile, file)
           rescue => detail
             Puppet.err "Could not rename #{file} to #{tmpfile}: #{detail}"
             File.unlink(tmpfile) if FileTest.exist?(tmpfile)
           end
         end
       end
     end
   end
 
   private
 
   # This is just here to simplify testing.  This method can be stubbed easily.  Constants can't.
   def read_only_settings()
     READ_ONLY_SETTINGS
   end
 
   def get_config_file_default(default)
     obj = nil
     unless obj = @config[default]
       raise ArgumentError, "Unknown default #{default}"
     end
 
     raise ArgumentError, "Default #{default} is not a file" unless obj.is_a? FileSetting
 
     obj
   end
 
   def add_user_resources(catalog, sections)
     return unless Puppet.features.root?
     return if Puppet.features.microsoft_windows?
     return unless self[:mkusers]
 
     @config.each do |name, setting|
       next unless setting.respond_to?(:owner)
       next unless sections.nil? or sections.include?(setting.section)
 
       if user = setting.owner and user != "root" and catalog.resource(:user, user).nil?
         resource = Puppet::Resource.new(:user, user, :parameters => {:ensure => :present})
         resource[:gid] = self[:group] if self[:group]
         catalog.add_resource resource
       end
       if group = setting.group and ! %w{root wheel}.include?(group) and catalog.resource(:group, group).nil?
         catalog.add_resource Puppet::Resource.new(:group, group, :parameters => {:ensure => :present})
       end
     end
   end
 
   # Yield each search source in turn.
   def each_source(environment)
     searchpath(environment).each do |source|
 
       # Modify the source as necessary.
       source = self.run_mode if source == :run_mode
       yield source
     end
   end
 
   # Return all settings that have associated hooks; this is so
   # we can call them after parsing the configuration file.
   def settings_with_hooks
     @config.values.find_all { |setting| setting.has_hook? }
   end
 
   # Extract extra setting information for files.
   def extract_fileinfo(string)
     result = {}
     value = string.sub(/\{\s*([^}]+)\s*\}/) do
       params = $1
       params.split(/\s*,\s*/).each do |str|
         if str =~ /^\s*(\w+)\s*=\s*([\w\d]+)\s*$/
           param, value = $1.intern, $2
           result[param] = value
           raise ArgumentError, "Invalid file option '#{param}'" unless [:owner, :mode, :group].include?(param)
 
           if param == :mode and value !~ /^\d+$/
             raise ArgumentError, "File modes must be numbers"
           end
         else
           raise ArgumentError, "Could not parse '#{string}'"
         end
       end
       ''
     end
     result[:value] = value.sub(/\s*$/, '')
     result
   end
 
   # Convert arguments into booleans, integers, or whatever.
   def munge_value(value)
     # Handle different data types correctly
     return case value
       when /^false$/i; false
       when /^true$/i; true
       when /^\d+$/i; Integer(value)
       when true; true
       when false; false
       else
         value.gsub(/^["']|["']$/,'').sub(/\s+$/, '')
     end
   end
 
   # This method just turns a file in to a hash of hashes.
   def parse_file(file)
     text = read_file(file)
 
     result = Hash.new { |names, name|
       names[name] = {}
     }
 
     count = 0
 
     # Default to 'main' for the section.
     section = :main
     result[section][:_meta] = {}
     text.split(/\n/).each do |line|
       count += 1
       case line
       when /^\s*\[(\w+)\]\s*$/
         section = $1.intern # Section names
         #disallow application_defaults in config file
         if section == :application_defaults
           raise Puppet::Error.new("Illegal section 'application_defaults' in config file", file, line)
         end
         # Add a meta section
         result[section][:_meta] ||= {}
       when /^\s*#/; next # Skip comments
       when /^\s*$/; next # Skip blanks
       when /^\s*(\w+)\s*=\s*(.*?)\s*$/ # settings
         var = $1.intern
 
         # We don't want to munge modes, because they're specified in octal, so we'll
         # just leave them as a String, since Puppet handles that case correctly.
         if var == :mode
           value = $2
         else
           value = munge_value($2)
         end
 
         # Check to see if this is a file argument and it has extra options
         begin
           if value.is_a?(String) and options = extract_fileinfo(value)
             value = options[:value]
             options.delete(:value)
             result[section][:_meta][var] = options
           end
           result[section][var] = value
         rescue Puppet::Error => detail
           detail.file = file
           detail.line = line
           raise
         end
       else
         error = Puppet::Error.new("Could not match line #{line}")
         error.file = file
         error.line = line
         raise error
       end
     end
 
     result
   end
 
   # Read the file in.
   def read_file(file)
     begin
       return File.read(file)
     rescue Errno::ENOENT
       raise ArgumentError, "No such file #{file}"
     rescue Errno::EACCES
       raise ArgumentError, "Permission denied to file #{file}"
     end
   end
 
   # Set file metadata.
   def set_metadata(meta)
     meta.each do |var, values|
       values.each do |param, value|
         @config[var].send(param.to_s + "=", value)
       end
     end
   end
 
   # Private method for internal test use only; allows to do a comprehensive clear of all settings between tests.
   #
   # @return nil
   def clear_everything_for_tests()
     @sync.synchronize do
       unsafe_clear(true, true)
+      @global_defaults_initialized = false
       @app_defaults_initialized = false
     end
   end
   private :clear_everything_for_tests
 
 end
diff --git a/spec/unit/application/apply_spec.rb b/spec/unit/application/apply_spec.rb
index 3c27314e4..54416dfc4 100755
--- a/spec/unit/application/apply_spec.rb
+++ b/spec/unit/application/apply_spec.rb
@@ -1,420 +1,419 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/apply'
 require 'puppet/file_bucket/dipper'
 require 'puppet/configurer'
 require 'fileutils'
 
 describe Puppet::Application::Apply do
   before :each do
     @apply = Puppet::Application[:apply]
     Puppet::Util::Log.stubs(:newdestination)
   end
 
   after :each do
     Puppet::Node::Facts.indirection.reset_terminus_class
     Puppet::Node::Facts.indirection.cache_class = nil
 
     Puppet::Node.indirection.reset_terminus_class
     Puppet::Node.indirection.cache_class = nil
   end
 
   [:debug,:loadclasses,:verbose,:use_nodes,:detailed_exitcodes,:catalog].each do |option|
     it "should declare handle_#{option} method" do
       @apply.should respond_to("handle_#{option}".to_sym)
     end
 
     it "should store argument value when calling handle_#{option}" do
       @apply.options.expects(:[]=).with(option, 'arg')
       @apply.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
   it "should set the code to the provided code when :execute is used" do
     @apply.options.expects(:[]=).with(:code, 'arg')
     @apply.send("handle_execute".to_sym, 'arg')
   end
 
   describe "when applying options" do
 
     it "should set the log destination with --logdest" do
       Puppet::Log.expects(:newdestination).with("console")
 
       @apply.handle_logdest("console")
     end
 
     it "should put the logset options to true" do
       @apply.options.expects(:[]=).with(:logset,true)
 
       @apply.handle_logdest("console")
     end
 
     it "should deprecate --apply" do
       Puppet.expects(:deprecation_warning).with do |arg|
         arg.match(/--apply is deprecated/)
       end
 
       command_line = Puppet::Util::CommandLine.new('puppet', ['apply', '--apply', 'catalog.json'])
       apply = Puppet::Application::Apply.new(command_line)
       apply.stubs(:run_command)
       apply.run
     end
   end
 
   describe "during setup" do
     before :each do
       Puppet::Log.stubs(:newdestination)
-      Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       STDIN.stubs(:read)
       Puppet::Transaction::Report.indirection.stubs(:cache_class=)
 
       @apply.options.stubs(:[]).with(any_parameters)
     end
 
     it "should set console as the log destination if logdest option wasn't provided" do
       Puppet::Log.expects(:newdestination).with(:console)
 
       @apply.setup
     end
 
     it "should set INT trap" do
       Signal.expects(:trap).with(:INT)
 
       @apply.setup
     end
 
     it "should set log level to debug if --debug was passed" do
       @apply.options.stubs(:[]).with(:debug).returns(true)
       @apply.setup
       Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @apply.options.stubs(:[]).with(:verbose).returns(true)
       @apply.setup
       Puppet::Log.level.should == :info
     end
 
     it "should print puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns  true
       Puppet.settings.expects(:print_configs).returns true
       expect { @apply.setup }.to exit_with 0
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
       expect { @apply.setup }.to exit_with 1
     end
 
     it "should tell the report handler to cache locally as yaml" do
       Puppet::Transaction::Report.indirection.expects(:cache_class=).with(:yaml)
 
       @apply.setup
     end
 
     it "should set pluginsource with no hostname" do
       @apply.app_defaults[:pluginsource].should == 'puppet:///plugins'
     end
 
     it "should set default_file_terminus to `file_server` to be local" do
       @apply.app_defaults[:default_file_terminus].should == 'file_server'
     end
   end
 
   describe "when executing" do
     it "should dispatch to 'apply' if it was called with 'apply'" do
       @apply.options[:catalog] = "foo"
 
       @apply.expects(:apply)
       @apply.run_command
     end
 
     it "should dispatch to main otherwise" do
       @apply.stubs(:options).returns({})
 
       @apply.expects(:main)
       @apply.run_command
     end
 
     describe "the main command" do
       include PuppetSpec::Files
 
       before :each do
         Puppet[:prerun_command] = ''
         Puppet[:postrun_command] = ''
 
         Puppet::Node::Facts.indirection.terminus_class = :memory
         Puppet::Node::Facts.indirection.cache_class = :memory
         Puppet::Node.indirection.terminus_class = :memory
         Puppet::Node.indirection.cache_class = :memory
 
         @facts = Puppet::Node::Facts.new(Puppet[:node_name_value])
         Puppet::Node::Facts.indirection.save(@facts)
 
         @node = Puppet::Node.new(Puppet[:node_name_value])
         Puppet::Node.indirection.save(@node)
 
         @catalog = Puppet::Resource::Catalog.new
         @catalog.stubs(:to_ral).returns(@catalog)
 
         Puppet::Resource::Catalog.indirection.stubs(:find).returns(@catalog)
 
         STDIN.stubs(:read)
 
         @transaction = Puppet::Transaction.new(@catalog)
         @catalog.stubs(:apply).returns(@transaction)
 
         Puppet::Util::Storage.stubs(:load)
         Puppet::Configurer.any_instance.stubs(:save_last_run_summary) # to prevent it from trying to write files
       end
 
       after :each do
         Puppet::Node::Facts.indirection.reset_terminus_class
         Puppet::Node::Facts.indirection.cache_class = nil
       end
 
       it "should set the code to run from --code" do
         @apply.options[:code] = "code to run"
         Puppet.expects(:[]=).with(:code,"code to run")
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should set the code to run from STDIN if no arguments" do
         @apply.command_line.stubs(:args).returns([])
         STDIN.stubs(:read).returns("code to run")
 
         Puppet.expects(:[]=).with(:code,"code to run")
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should set the manifest if a file is passed on command line and the file exists" do
         manifest = tmpfile('site.pp')
         FileUtils.touch(manifest)
         @apply.command_line.stubs(:args).returns([manifest])
 
         Puppet.expects(:[]=).with(:manifest,manifest)
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should raise an error if a file is passed on command line and the file does not exist" do
         noexist = tmpfile('noexist.pp')
         @apply.command_line.stubs(:args).returns([noexist])
         lambda { @apply.main }.should raise_error(RuntimeError, "Could not find file #{noexist}")
       end
 
       it "should set the manifest to the first file and warn other files will be skipped" do
         manifest = tmpfile('starwarsIV')
         FileUtils.touch(manifest)
 
         @apply.command_line.stubs(:args).returns([manifest, 'starwarsI', 'starwarsII'])
 
         Puppet.expects(:[]=).with(:manifest,manifest)
         expect { @apply.main }.to exit_with 0
 
         msg = @logs.find {|m| m.message =~ /Only one file can be applied per run/ }
         msg.message.should == 'Only one file can be applied per run.  Skipping starwarsI, starwarsII'
         msg.level.should == :warning
       end
 
       it "should raise an error if we can't find the node" do
         Puppet::Node.indirection.expects(:find).returns(nil)
 
         lambda { @apply.main }.should raise_error
       end
 
       it "should load custom classes if loadclasses" do
         @apply.options[:loadclasses] = true
         classfile = tmpfile('classfile')
         File.open(classfile, 'w') { |c| c.puts 'class' }
         Puppet[:classfile] = classfile
 
         @node.expects(:classes=).with(['class'])
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should compile the catalog" do
         Puppet::Resource::Catalog.indirection.expects(:find).returns(@catalog)
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should transform the catalog to ral" do
 
         @catalog.expects(:to_ral).returns(@catalog)
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should finalize the catalog" do
         @catalog.expects(:finalize)
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should call the prerun and postrun commands on a Configurer instance" do
         Puppet::Configurer.any_instance.expects(:execute_prerun_command).returns(true)
         Puppet::Configurer.any_instance.expects(:execute_postrun_command).returns(true)
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should apply the catalog" do
         @catalog.expects(:apply).returns(stub_everything('transaction'))
 
         expect { @apply.main }.to exit_with 0
       end
 
       it "should save the last run summary" do
         Puppet[:noop] = false
         report = Puppet::Transaction::Report.new("apply")
         Puppet::Transaction::Report.stubs(:new).returns(report)
 
         Puppet::Configurer.any_instance.expects(:save_last_run_summary).with(report)
         expect { @apply.main }.to exit_with 0
       end
 
       describe "when using node_name_fact" do
         before :each do
           @facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
           Puppet::Node::Facts.indirection.save(@facts)
           @node = Puppet::Node.new('other_node_name')
           Puppet::Node.indirection.save(@node)
           Puppet[:node_name_fact] = 'my_name_fact'
         end
 
         it "should set the facts name based on the node_name_fact" do
           expect { @apply.main }.to exit_with 0
           @facts.name.should == 'other_node_name'
         end
 
         it "should set the node_name_value based on the node_name_fact" do
           expect { @apply.main }.to exit_with 0
           Puppet[:node_name_value].should == 'other_node_name'
         end
 
         it "should merge in our node the loaded facts" do
           @facts.values.merge!('key' => 'value')
 
           expect { @apply.main }.to exit_with 0
 
           @node.parameters['key'].should == 'value'
         end
 
         it "should raise an error if we can't find the facts" do
           Puppet::Node::Facts.indirection.expects(:find).returns(nil)
 
           lambda { @apply.main }.should raise_error
         end
       end
 
       describe "with detailed_exitcodes" do
         before :each do
           @apply.options[:detailed_exitcodes] = true
         end
 
         it "should exit with report's computed exit status" do
           Puppet[:noop] = false
           Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
 
           expect { @apply.main }.to exit_with 666
         end
 
         it "should exit with report's computed exit status, even if --noop is set" do
           Puppet[:noop] = true
           Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
 
           expect { @apply.main }.to exit_with 666
         end
 
         it "should always exit with 0 if option is disabled" do
           Puppet[:noop] = false
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
 
           expect { @apply.main }.to exit_with 0
         end
 
         it "should always exit with 0 if --noop" do
           Puppet[:noop] = true
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
 
           expect { @apply.main }.to exit_with 0
         end
       end
     end
 
     describe "the 'apply' command" do
       # We want this memoized, and to be able to adjust the content, so we
       # have to do it ourselves.
       def temporary_catalog(content = '"something"')
         @tempfile = Tempfile.new('catalog.pson')
         @tempfile.write(content)
         @tempfile.close
         @tempfile.path
       end
 
       it "should read the catalog in from disk if a file name is provided" do
         @apply.options[:catalog] = temporary_catalog
         Puppet::Resource::Catalog.stubs(:convert_from).
           with(:pson,'"something"').returns(Puppet::Resource::Catalog.new)
         @apply.apply
       end
 
       it "should read the catalog in from stdin if '-' is provided" do
         @apply.options[:catalog] = "-"
         $stdin.expects(:read).returns '"something"'
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'"something"').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should deserialize the catalog from the default format" do
         @apply.options[:catalog] = temporary_catalog
         Puppet::Resource::Catalog.stubs(:default_format).returns :rot13_piglatin
         Puppet::Resource::Catalog.stubs(:convert_from).with(:rot13_piglatin,'"something"').returns Puppet::Resource::Catalog.new
         @apply.apply
       end
 
       it "should fail helpfully if deserializing fails" do
         @apply.options[:catalog] = temporary_catalog('something syntactically invalid')
         lambda { @apply.apply }.should raise_error(Puppet::Error)
       end
 
       it "should convert plain data structures into a catalog if deserialization does not do so" do
         @apply.options[:catalog] = temporary_catalog
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'"something"').returns({:foo => "bar"})
         Puppet::Resource::Catalog.expects(:pson_create).with({:foo => "bar"}).returns(Puppet::Resource::Catalog.new)
         @apply.apply
       end
 
       it "should convert the catalog to a RAL catalog and use a Configurer instance to apply it" do
         @apply.options[:catalog] = temporary_catalog
         catalog = Puppet::Resource::Catalog.new
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'"something"').returns catalog
         catalog.expects(:to_ral).returns "mycatalog"
 
         configurer = stub 'configurer'
         Puppet::Configurer.expects(:new).returns configurer
         configurer.expects(:run).
           with(:catalog => "mycatalog", :skip_plugin_download => true)
 
         @apply.apply
       end
     end
   end
 
   describe "apply_catalog" do
     it "should call the configurer with the catalog" do
       catalog = "I am a catalog"
       Puppet::Configurer.any_instance.expects(:run).
         with(:catalog => catalog, :skip_plugin_download => true)
       @apply.send(:apply_catalog, catalog)
     end
   end
 end
diff --git a/spec/unit/application/doc_spec.rb b/spec/unit/application/doc_spec.rb
index 58ee3e4ad..aa5a1eef6 100755
--- a/spec/unit/application/doc_spec.rb
+++ b/spec/unit/application/doc_spec.rb
@@ -1,338 +1,331 @@
 #!/usr/bin/env rspec
 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 a 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.options.expects(:[]=).with(:format, 'to_format')
 
       @doc.handle_format('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)
       lambda { @doc.handle_format('format') }
     end
 
     it "should store the mode if valid" do
       Puppet::Util::Reference.stubs(:modes).returns(stub('mode', :include? => true))
 
       @doc.options.expects(:[]=).with(:mode, :mode)
 
       @doc.handle_mode('mode')
     end
 
     it "should store the mode if :rdoc" do
       Puppet::Util::Reference.modes.stubs(:include?).with('rdoc').returns(false)
 
       @doc.options.expects(:[]=).with(:mode, :rdoc)
 
       @doc.handle_mode('rdoc')
     end
 
     it "should raise an error if the mode is not valid" do
       Puppet::Util::Reference.modes.stubs(:include?).with('unknown').returns(false)
       lambda { @doc.handle_mode('unknown') }
     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.options.expects(:[]=).with(:mode,:rdoc)
 
       @doc.setup
     end
 
     it "should call setup_rdoc in rdoc mode" do
       @doc.options.stubs(:[]).with(:mode).returns(:rdoc)
 
       @doc.expects(:setup_rdoc)
 
       @doc.setup
     end
 
     it "should call setup_reference if not rdoc" do
       @doc.options.stubs(:[]).with(:mode).returns(:test)
 
       @doc.expects(:setup_reference)
 
       @doc.setup
     end
 
     describe "in non-rdoc mode" do
 
       it "should get all non-dynamic reference if --all" do
         @doc.options.stubs(:[]).with(:all).returns(true)
         @doc.options.stubs(:[]).with(:references).returns([])
         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.options.stubs(:[]=).with(:references, [:static])
 
         @doc.setup_reference
       end
 
       it "should default to :type if no references" do
         @doc.options.stubs(:[]).with(:all).returns(false)
         array = stub 'array', :empty? => true
         @doc.options.stubs(:[]).with(:references).returns(array)
 
         array.expects(:<<).with(:type)
 
         @doc.setup_reference
       end
 
     end
 
     describe "in rdoc mode" do
 
       before :each do
         @doc.options.stubs(:[]).returns(false)
-        Puppet.stubs(:parse_config)
         Puppet::Util::Log.stubs(:newdestination)
       end
 
       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)
 
           File.expects(:expand_path).with("path")
 
           @doc.setup_rdoc
         end
 
         it "should expand --manifestdir if any" do
           @doc.unknown_args = [ { :opt => "--manifestdir", :arg => "path" } ]
           Puppet.settings.stubs(:handlearg)
 
           File.expects(:expand_path).with("path")
 
           @doc.setup_rdoc
         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
 
-      it "should parse puppet configuration" do
-        Puppet.expects(:parse_config)
-
-        @doc.setup_rdoc
-      end
-
       it "should set log level to debug if --debug" do
         @doc.options.stubs(:[]).with(:debug).returns(true)
         @doc.setup_rdoc
         Puppet::Util::Log.level.should == :debug
       end
 
       it "should set log level to info if --verbose" do
         @doc.options.stubs(:[]).with(:verbose).returns(true)
         @doc.setup_rdoc
         Puppet::Util::Log.level.should == :info
       end
 
       it "should set log destination to console if --verbose" do
         @doc.options.stubs(:[]).with(:verbose).returns(true)
 
         Puppet::Util::Log.expects(:newdestination).with(:console)
 
         @doc.setup_rdoc
       end
 
       it "should set log destination to console if --debug" do
         @doc.options.stubs(:[]).with(:debug).returns(true)
 
         Puppet::Util::Log.expects(:newdestination).with(:console)
 
         @doc.setup_rdoc
       end
 
     end
 
   end
 
   describe "when running" do
 
     describe "in rdoc mode" do
       before :each do
         @doc.manifest = false
         Puppet.stubs(:info)
         Puppet.stubs(:[]).with(:trace).returns(false)
         @env = stub 'env'
         Puppet::Node::Environment.stubs(:new).returns(@env)
         @env.stubs(:modulepath).returns(['modules'])
         @env.stubs(:[]).with(:manifest).returns('manifests/site.pp')
         Puppet.stubs(:[]).with(:modulepath).returns('modules')
         Puppet.stubs(:[]).with(:manifestdir).returns('manifests')
         @doc.options.stubs(:[]).with(:all).returns(false)
         @doc.options.stubs(:[]).with(:outputdir).returns('doc')
         @doc.options.stubs(:[]).with(:charset).returns(nil)
         Puppet.settings.stubs(:[]=).with(:document_all, false)
         Puppet.settings.stubs(:define_settings)
         Puppet::Util::RDoc.stubs(:rdoc)
         File.stubs(:expand_path).with('modules').returns('modules')
         File.stubs(:expand_path).with('manifests').returns('manifests')
         @doc.command_line.stubs(:args).returns([])
       end
 
       it "should set document_all on --all" do
         @doc.options.expects(:[]).with(:all).returns(true)
         Puppet.settings.expects(:[]=).with(:document_all, true)
 
         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
       end
 
       it "should call Puppet::Util::RDoc.rdoc with a charset if --charset has been provided" do
         @doc.options.expects(:[]).with(:charset).returns("utf-8")
         Puppet::Util::RDoc.expects(:rdoc).with('doc', ['modules','manifests'], "utf-8")
         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.expects(:[]).with(:outputdir).returns(false)
         Puppet::Util::RDoc.expects(:rdoc).with('doc', ['modules','manifests'], nil)
         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
       end
 
       it "should get modulepath and manifestdir values from the environment" do
         @env.expects(:modulepath).returns(['envmodules1','envmodules2'])
         @env.expects(:[]).with(:manifest).returns('envmanifests/site.pp')
 
         Puppet::Util::RDoc.expects(:rdoc).with('doc', ['envmodules1','envmodules2','envmanifests'], nil)
 
         expect { @doc.rdoc }.to exit_with 0
       end
     end
 
     describe "in the other modes" do
       it "should get reference in given format" do
         reference = stub 'reference'
         @doc.options.stubs(:[]).with(:mode).returns(:none)
         @doc.options.stubs(:[]).with(:references).returns([:ref])
         require 'puppet/util/reference'
         Puppet::Util::Reference.expects(:reference).with(:ref).returns(reference)
         @doc.options.stubs(:[]).with(:format).returns(: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/application/face_base_spec.rb b/spec/unit/application/face_base_spec.rb
index 5edac6cbb..97f9bb933 100755
--- a/spec/unit/application/face_base_spec.rb
+++ b/spec/unit/application/face_base_spec.rb
@@ -1,394 +1,387 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/application/face_base'
 require 'tmpdir'
 
 class Puppet::Application::FaceBase::Basetest < Puppet::Application::FaceBase
 end
 
 describe Puppet::Application::FaceBase do
   let :app do
     app = Puppet::Application::FaceBase::Basetest.new
     app.command_line.stubs(:subcommand_name).returns('subcommand')
     Puppet::Util::Log.stubs(:newdestination)
     app
   end
 
   describe "#find_global_settings_argument" do
     it "should not match --ca to --ca-location" do
       option = mock('ca option', :optparse_args => ["--ca"])
       Puppet.settings.expects(:each).yields(:ca, option)
 
       app.find_global_settings_argument("--ca-location").should be_nil
     end
   end
 
   describe "#parse_options" do
     before :each do
       app.command_line.stubs(:args).returns %w{}
     end
 
     describe "with just an action" do
       before :all do
         # We have to stub Signal.trap to avoid a crazy mess where we take
         # over signal handling and make it impossible to cancel the test
         # suite run.
         #
         # It would be nice to fix this elsewhere, but it is actually hard to
         # capture this in rspec 2.5 and all. :(  --daniel 2011-04-08
         Signal.stubs(:trap)
         app.command_line.stubs(:args).returns %w{foo}
         app.preinit
         app.parse_options
       end
 
       it "should set the face based on the type" do
         app.face.name.should == :basetest
       end
 
       it "should find the action" do
         app.action.should be
         app.action.name.should == :foo
       end
     end
 
     it "should stop if the first thing found is not an action" do
       app.command_line.stubs(:args).returns %w{banana count_args}
       expect { app.run }.to exit_with 1
       @logs.first.should_not be_nil
       @logs.first.message.should =~ /has no 'banana' action/
     end
 
     it "should use the default action if not given any arguments" do
       app.command_line.stubs(:args).returns []
       action = stub(:options => [], :render_as => nil)
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
       app.stubs(:main)
       app.run
       app.action.should == action
       app.arguments.should == [ { } ]
     end
 
     it "should use the default action if not given a valid one" do
       app.command_line.stubs(:args).returns %w{bar}
       action = stub(:options => [], :render_as => nil)
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
       app.stubs(:main)
       app.run
       app.action.should == action
       app.arguments.should == [ 'bar', { } ]
     end
 
     it "should have no action if not given a valid one and there is no default action" do
       app.command_line.stubs(:args).returns %w{bar}
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
       app.stubs(:main)
       expect { app.run }.to exit_with 1
       @logs.first.message.should =~ /has no 'bar' action./
     end
 
     [%w{something_I_cannot_do},
      %w{something_I_cannot_do argument}].each do |input|
       it "should report unknown actions nicely" do
         app.command_line.stubs(:args).returns input
         Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
         app.stubs(:main)
         expect { app.run }.to exit_with 1
         @logs.first.message.should =~ /has no 'something_I_cannot_do' action/
       end
     end
 
     [%w{something_I_cannot_do --unknown-option},
      %w{something_I_cannot_do argument --unknown-option}].each do |input|
       it "should report unknown actions even if there are unknown options" do
         app.command_line.stubs(:args).returns input
         Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
         app.stubs(:main)
         expect { app.run }.to exit_with 1
         @logs.first.message.should =~ /has no 'something_I_cannot_do' action/
       end
     end
 
     it "should report a sensible error when options with = fail" do
       app.command_line.stubs(:args).returns %w{--action=bar foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --action/
     end
 
     it "should fail if an action option is before the action" do
       app.command_line.stubs(:args).returns %w{--action foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --action/
     end
 
     it "should fail if an unknown option is before the action" do
       app.command_line.stubs(:args).returns %w{--bar foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --bar/
     end
 
     it "should fail if an unknown option is after the action" do
       app.command_line.stubs(:args).returns %w{foo --bar}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --bar/
     end
 
     it "should accept --bar as an argument to a mandatory option after action" do
       app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
       app.preinit
       app.parse_options
       app.action.name.should == :foo
       app.options.should == { :mandatory => "--bar" }
     end
 
     it "should accept --bar as an argument to a mandatory option before action" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
       app.preinit
       app.parse_options
       app.action.name.should == :foo
       app.options.should == { :mandatory => "--bar" }
     end
 
     it "should not skip when --foo=bar is given" do
       app.command_line.stubs(:args).returns %w{--mandatory=bar --bar foo}
       expect { app.preinit; app.parse_options }.
         to raise_error OptionParser::InvalidOption, /invalid option: --bar/
     end
 
     { "boolean options before" => %w{--trace foo},
       "boolean options after"  => %w{foo --trace}
     }.each do |name, args|
       it "should accept global boolean settings #{name} the action" do
         app.command_line.stubs(:args).returns args
-        app.command_line.send(:parse_global_options)
+        Puppet.settings.initialize_global_settings(args)
         app.preinit
         app.parse_options
         Puppet[:trace].should be_true
       end
     end
 
     { "before" => %w{--syslogfacility user1 foo},
       " after" => %w{foo --syslogfacility user1}
     }.each do |name, args|
       it "should accept global settings with arguments #{name} the action" do
         app.command_line.stubs(:args).returns args
-        app.command_line.send(:parse_global_options)
+        Puppet.settings.initialize_global_settings(args)
         app.preinit
         app.parse_options
         Puppet[:syslogfacility].should == "user1"
       end
     end
 
     it "should handle application-level options" do
       app.command_line.stubs(:args).returns %w{--verbose return_true}
-      app.command_line.send(:parse_global_options)
       app.preinit
       app.parse_options
       app.face.name.should == :basetest
     end
   end
 
   describe "#setup" do
     it "should remove the action name from the arguments" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
-      app.command_line.send(:parse_global_options)
       app.preinit
       app.parse_options
       app.setup
       app.arguments.should == [{ :mandatory => "--bar" }]
     end
 
     it "should pass positional arguments" do
-      app.command_line.stubs(:args).returns %w{--mandatory --bar foo bar baz quux}
-      app.command_line.send(:parse_global_options)
+      myargs = %w{--mandatory --bar foo bar baz quux}
+      app.command_line.stubs(:args).returns(myargs)
       app.preinit
       app.parse_options
       app.setup
       app.arguments.should == ['bar', 'baz', 'quux', { :mandatory => "--bar" }]
     end
   end
 
   describe "#main" do
     before :each do
       app.stubs(:puts)          # don't dump text to screen.
 
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.action    = app.face.get_action(:foo)
       app.arguments = ["myname", "myarg"]
     end
 
     it "should send the specified verb and name to the face" do
       app.face.expects(:foo).with(*app.arguments)
       expect { app.main }.to exit_with 0
     end
 
     it "should lookup help when it cannot do anything else" do
       app.action = nil
       Puppet::Face[:help, :current].expects(:help).with(:basetest)
       expect { app.main }.to exit_with 1
     end
 
     it "should use its render method to render any result" do
       app.expects(:render).with(app.arguments.length + 1, ["myname", "myarg"])
       expect { app.main }.to exit_with 0
     end
   end
 
   describe "error reporting" do
     before :each do
       app.stubs(:puts)          # don't dump text to screen.
 
       app.render_as = :json
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.arguments = [{}]      # we always have options in there...
     end
 
     it "should exit 0 when the action returns true" do
       app.action    = app.face.get_action :return_true
       expect { app.main }.to exit_with 0
     end
 
     it "should exit 0 when the action returns false" do
       app.action = app.face.get_action :return_false
       expect { app.main }.to exit_with 0
     end
 
     it "should exit 0 when the action returns nil" do
       app.action = app.face.get_action :return_nil
       expect { app.main }.to exit_with 0
     end
 
     it "should exit non-0 when the action raises" do
       app.action = app.face.get_action :return_raise
       expect { app.main }.not_to exit_with 0
     end
 
     it "should use the exit code set by the action" do
       app.action = app.face.get_action :with_specific_exit_code
       expect { app.main }.to exit_with 5
     end
   end
 
   describe "#render" do
     before :each do
       app.face      = Puppet::Face[:basetest, '0.0.1']
       app.action    = app.face.get_action(:foo)
     end
 
     context "default rendering" do
       before :each do app.setup end
 
       ["hello", 1, 1.0].each do |input|
         it "should just return a #{input.class.name}" do
           app.render(input, {}).should == input
         end
       end
 
       [[1, 2], ["one"], [{ 1 => 1 }]].each do |input|
         it "should render #{input.class} using JSON" do
           app.render(input, {}).should == input.to_pson.chomp
         end
       end
 
       it "should render a non-trivially-keyed Hash with using JSON" do
         hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
         app.render(hash, {}).should == hash.to_pson.chomp
       end
 
       it "should render a {String,Numeric}-keyed Hash into a table" do
         object = Object.new
         hash = { "one" => 1, "two" => [], "three" => {}, "four" => object,
           5 => 5, 6.0 => 6 }
 
         # Gotta love ASCII-betical sort order.  Hope your objects are better
         # structured for display than my test one is. --daniel 2011-04-18
         app.render(hash, {}).should == <<EOT
 5      5
 6.0    6
 four   #{object.to_pson.chomp}
 one    1
 three  {}
 two    []
 EOT
       end
 
       it "should render a hash nicely with a multi-line value" do
         pending "Moving to PSON rather than PP makes this unsupportable."
         hash = {
           "number" => { "1" => '1' * 40, "2" => '2' * 40, '3' => '3' * 40 },
           "text"   => { "a" => 'a' * 40, 'b' => 'b' * 40, 'c' => 'c' * 40 }
         }
         app.render(hash, {}).should == <<EOT
 number  {"1"=>"1111111111111111111111111111111111111111",
          "2"=>"2222222222222222222222222222222222222222",
          "3"=>"3333333333333333333333333333333333333333"}
 text    {"a"=>"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
          "b"=>"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
          "c"=>"cccccccccccccccccccccccccccccccccccccccc"}
 EOT
       end
 
       describe "when setting the rendering method" do
         after do
           # need to reset the when_rendering block so that other tests can set it later
           app.action.instance_variable_set("@when_rendering", {})
         end
 
         it "should invoke the action rendering hook while rendering" do
           app.action.set_rendering_method_for(:console, proc { |value| "bi-winning!" })
           app.render("bi-polar?", {}).should == "bi-winning!"
         end
 
         it "should invoke the action rendering hook with args and options while rendering" do
           app.action.instance_variable_set("@when_rendering", {})
           app.action.when_invoked = proc { |name, options| 'just need to match arity for rendering' }
           app.action.set_rendering_method_for(
             :console,
             proc { |value, name, options| "I'm #{name}, no wait, I'm #{options[:altername]}" }
           )
           app.render("bi-polar?", ['bob', {:altername => 'sue'}]).should == "I'm bob, no wait, I'm sue"
         end
       end
 
       it "should render JSON when asked for json" do
         app.render_as = :json
         json = app.render({ :one => 1, :two => 2 }, {})
         json.should =~ /"one":\s*1\b/
         json.should =~ /"two":\s*2\b/
         PSON.parse(json).should == { "one" => 1, "two" => 2 }
       end
     end
 
     it "should fail early if asked to render an invalid format" do
       app.command_line.stubs(:args).returns %w{--render-as interpretive-dance return_true}
-      app.command_line.send(:parse_global_options)
-
       # We shouldn't get here, thanks to the exception, and our expectation on
       # it, but this helps us fail if that slips up and all. --daniel 2011-04-27
       Puppet::Face[:help, :current].expects(:help).never
 
       Puppet.expects(:err).with("Could not parse application options: I don't know how to render 'interpretive-dance'")
 
       expect { app.run }.to exit_with 1
 
-      #expect {
-      #  expect { app.run }.to exit_with 1
-      #}.to have_printed(/I don't know how to render 'interpretive-dance'/)
     end
 
     it "should work if asked to render a NetworkHandler format" do
       app.command_line.stubs(:args).returns %w{count_args a b c --render-as yaml}
       expect {
         expect { app.run }.to exit_with 0
       }.to have_printed(/--- 3/)
     end
 
     it "should invoke when_rendering hook 's' when asked to render-as 's'" do
       app.command_line.stubs(:args).returns %w{with_s_rendering_hook --render-as s}
       app.action = app.face.get_action(:with_s_rendering_hook)
       expect {
         expect { app.run }.to exit_with 0
       }.to have_printed(/you invoked the 's' rendering hook/)
     end
   end
 end
diff --git a/spec/unit/application/filebucket_spec.rb b/spec/unit/application/filebucket_spec.rb
index f86886faa..30264a4d8 100755
--- a/spec/unit/application/filebucket_spec.rb
+++ b/spec/unit/application/filebucket_spec.rb
@@ -1,214 +1,206 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/filebucket'
 require 'puppet/file_bucket/dipper'
 
 describe Puppet::Application::Filebucket do
   before :each do
     @filebucket = Puppet::Application[:filebucket]
   end
 
   it "should declare a get command" do
     @filebucket.should respond_to(:get)
   end
 
   it "should declare a backup command" do
     @filebucket.should respond_to(:backup)
   end
 
   it "should declare a restore command" do
     @filebucket.should respond_to(:restore)
   end
 
   [:bucket, :debug, :local, :remote, :verbose].each do |option|
     it "should declare handle_#{option} method" do
       @filebucket.should respond_to("handle_#{option}".to_sym)
     end
 
     it "should store argument value when calling handle_#{option}" do
       @filebucket.options.expects(:[]=).with("#{option}".to_sym, 'arg')
       @filebucket.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
   describe "during setup" do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:settraps)
-      Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       @filebucket.options.stubs(:[]).with(any_parameters)
     end
 
 
     it "should set console as the log destination" do
       Puppet::Log.expects(:newdestination).with(:console)
 
       @filebucket.setup
     end
 
     it "should trap INT" do
       Signal.expects(:trap).with(:INT)
 
       @filebucket.setup
     end
 
     it "should set log level to debug if --debug was passed" do
       @filebucket.options.stubs(:[]).with(:debug).returns(true)
       @filebucket.setup
       Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @filebucket.options.stubs(:[]).with(:verbose).returns(true)
       @filebucket.setup
       Puppet::Log.level.should == :info
     end
 
-    it "should Parse puppet config" do
-      Puppet.expects(:parse_config)
-
-      @filebucket.setup
-    end
-
     it "should print puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
       Puppet.settings.expects(:print_configs).returns(true)
       expect { @filebucket.setup }.to exit_with 0
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
       expect { @filebucket.setup }.to exit_with 1
     end
 
     describe "with local bucket" do
 
       before :each do
         @filebucket.options.stubs(:[]).with(:local).returns(true)
       end
 
       it "should create a client with the default bucket if none passed" do
         Puppet.stubs(:[]).with(:bucketdir).returns("path")
 
         Puppet::FileBucket::Dipper.expects(:new).with { |h| h[:Path] == "path" }
 
         @filebucket.setup
       end
 
       it "should create a local Dipper with the given bucket" do
         @filebucket.options.stubs(:[]).with(:bucket).returns("path")
 
         Puppet::FileBucket::Dipper.expects(:new).with { |h| h[:Path] == "path" }
 
         @filebucket.setup
       end
 
     end
 
     describe "with remote bucket" do
 
       it "should create a remote Client to the configured server" do
         Puppet.stubs(:[]).with(:server).returns("puppet.reductivelabs.com")
 
         Puppet::FileBucket::Dipper.expects(:new).with { |h| h[:Server] == "puppet.reductivelabs.com" }
 
         @filebucket.setup
       end
 
     end
 
   end
 
   describe "when running" do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:settraps)
-      Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       @filebucket.options.stubs(:[]).with(any_parameters)
 
       @client = stub 'client'
       Puppet::FileBucket::Dipper.stubs(:new).returns(@client)
 
       @filebucket.setup
     end
 
     it "should use the first non-option parameter as the dispatch" do
       @filebucket.command_line.stubs(:args).returns(['get'])
 
       @filebucket.expects(:get)
 
       @filebucket.run_command
     end
 
     describe "the command get" do
 
       before :each do
         @filebucket.stubs(:print)
         @filebucket.stubs(:args).returns([])
       end
 
       it "should call the client getfile method" do
         @client.expects(:getfile)
 
         @filebucket.get
       end
 
       it "should call the client getfile method with the given md5" do
         md5="DEADBEEF"
         @filebucket.stubs(:args).returns([md5])
 
         @client.expects(:getfile).with(md5)
 
         @filebucket.get
       end
 
       it "should print the file content" do
         @client.stubs(:getfile).returns("content")
 
         @filebucket.expects(:print).returns("content")
 
         @filebucket.get
       end
 
     end
 
     describe "the command backup" do
       it "should fail if no arguments are specified" do
         @filebucket.stubs(:args).returns([])
         lambda { @filebucket.backup }.should raise_error
       end
 
       it "should call the client backup method for each given parameter" do
         @filebucket.stubs(:puts)
         FileTest.stubs(:exists?).returns(true)
         FileTest.stubs(:readable?).returns(true)
         @filebucket.stubs(:args).returns(["file1", "file2"])
 
         @client.expects(:backup).with("file1")
         @client.expects(:backup).with("file2")
 
         @filebucket.backup
       end
     end
 
     describe "the command restore" do
       it "should call the client getfile method with the given md5" do
         md5="DEADBEEF"
         file="testfile"
         @filebucket.stubs(:args).returns([file, md5])
 
         @client.expects(:restore).with(file,md5)
 
         @filebucket.restore
       end
     end
 
   end
 
 
 end
diff --git a/spec/unit/application/kick_spec.rb b/spec/unit/application/kick_spec.rb
index b60d11202..3acd92033 100755
--- a/spec/unit/application/kick_spec.rb
+++ b/spec/unit/application/kick_spec.rb
@@ -1,290 +1,283 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/kick'
 
 describe Puppet::Application::Kick, :if => Puppet.features.posix? do
 
   before :each do
     require 'puppet/util/ldap/connection'
     Puppet::Util::Ldap::Connection.stubs(:new).returns(stub_everything)
     @kick = Puppet::Application[:kick]
     Puppet::Util::Log.stubs(:newdestination)
   end
 
   describe ".new" do
     it "should take a command-line object as an argument" do
       command_line = stub_everything "command_line"
       lambda{ Puppet::Application::Kick.new( command_line ) }.should_not raise_error
     end
   end
 
   it "should declare a main command" do
     @kick.should respond_to(:main)
   end
 
   it "should declare a test command" do
     @kick.should respond_to(:test)
   end
 
   it "should declare a preinit block" do
     @kick.should respond_to(:preinit)
   end
 
   describe "during preinit" do
     before :each do
       @kick.stubs(:trap)
     end
 
     it "should catch INT and TERM" do
       @kick.stubs(:trap).with { |arg,block| arg == :INT or arg == :TERM }
 
       @kick.preinit
     end
 
     it "should set parallel option to 1" do
       @kick.preinit
 
       @kick.options[:parallel].should == 1
     end
 
     it "should set verbose by default" do
       @kick.preinit
 
       @kick.options[:verbose].should be_true
     end
 
     it "should set fqdn by default" do
       @kick.preinit
 
       @kick.options[:fqdn].should be_true
     end
 
     it "should set ignoreschedules to 'false'" do
       @kick.preinit
 
       @kick.options[:ignoreschedules].should be_false
     end
 
     it "should set foreground to 'false'" do
       @kick.preinit
 
       @kick.options[:foreground].should be_false
     end
   end
 
   describe "when applying options" do
 
     before do
       @kick.preinit
     end
 
     [:all, :foreground, :debug, :ping, :test].each do |option|
       it "should declare handle_#{option} method" do
         @kick.should respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
         @kick.options.expects(:[]=).with(option, 'arg')
         @kick.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should add to the host list with the host option" do
       @kick.handle_host('host')
 
       @kick.hosts.should == ['host']
     end
 
     it "should add to the tag list with the tag option" do
       @kick.handle_tag('tag')
 
       @kick.tags.should == ['tag']
     end
 
     it "should add to the class list with the class option" do
       @kick.handle_class('class')
 
       @kick.classes.should == ['class']
     end
   end
 
   describe "during setup" do
 
     before :each do
       @kick.classes = []
       @kick.tags = []
       @kick.hosts = []
       @kick.stubs(:trap)
       @kick.stubs(:puts)
-      Puppet.stubs(:parse_config)
 
       @kick.options.stubs(:[]).with(any_parameters)
     end
 
     it "should abort stating that kick is not supported on Windows" do
       Puppet.features.stubs(:microsoft_windows?).returns(true)
 
       expect { @kick.setup }.to raise_error(Puppet::Error, /Puppet kick is not supported on Microsoft Windows/)
     end
 
     it "should set log level to debug if --debug was passed" do
       @kick.options.stubs(:[]).with(:debug).returns(true)
       @kick.setup
       Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @kick.options.stubs(:[]).with(:verbose).returns(true)
       @kick.setup
       Puppet::Log.level.should == :info
     end
 
-    it "should Parse puppet config" do
-      Puppet.expects(:parse_config)
-
-      @kick.setup
-    end
-
     describe "when using the ldap node terminus" do
       before :each do
         Puppet.stubs(:[]).with(:node_terminus).returns("ldap")
       end
 
       it "should pass the fqdn option to search" do
         @kick.options.stubs(:[]).with(:fqdn).returns(:something)
         @kick.options.stubs(:[]).with(:all).returns(true)
         @kick.stubs(:puts)
 
         Puppet::Node.indirection.expects(:search).with("whatever",:fqdn => :something).returns([])
 
         @kick.setup
       end
 
       it "should search for all nodes if --all" do
         @kick.options.stubs(:[]).with(:all).returns(true)
         @kick.stubs(:puts)
 
         Puppet::Node.indirection.expects(:search).with("whatever",:fqdn => nil).returns([])
 
         @kick.setup
       end
 
       it "should search for nodes including given classes" do
         @kick.options.stubs(:[]).with(:all).returns(false)
         @kick.stubs(:puts)
         @kick.classes = ['class']
 
         Puppet::Node.indirection.expects(:search).with("whatever", :class => "class", :fqdn => nil).returns([])
 
         @kick.setup
       end
     end
 
     describe "when using regular nodes" do
       it "should fail if some classes have been specified" do
         $stderr.stubs(:puts)
         @kick.classes = ['class']
 
         expect { @kick.setup }.to exit_with 24
       end
     end
   end
 
   describe "when running" do
     before :each do
       @kick.stubs(:puts)
     end
 
     it "should dispatch to test if --test is used" do
       @kick.options.stubs(:[]).with(:test).returns(true)
 
       @kick.expects(:test)
       @kick.run_command
     end
 
     it "should dispatch to main if --test is not used" do
       @kick.options.stubs(:[]).with(:test).returns(false)
 
       @kick.expects(:main)
       @kick.run_command
     end
 
     describe "the test command" do
       it "should exit with exit code 0 " do
         expect { @kick.test }.to exit_with 0
       end
     end
 
     describe "the main command" do
       before :each do
         @kick.options.stubs(:[]).with(:parallel).returns(1)
         @kick.options.stubs(:[]).with(:ping).returns(false)
         @kick.options.stubs(:[]).with(:ignoreschedules).returns(false)
         @kick.options.stubs(:[]).with(:foreground).returns(false)
         @kick.options.stubs(:[]).with(:debug).returns(false)
         @kick.stubs(:print)
         @kick.preinit
         @kick.stubs(:parse_options)
         @kick.setup
         $stderr.stubs(:puts)
       end
 
       it "should create as much childs as --parallel" do
         @kick.options.stubs(:[]).with(:parallel).returns(3)
         @kick.hosts = ['host1', 'host2', 'host3']
         Process.stubs(:wait).returns(1).then.returns(2).then.returns(3).then.raises(Errno::ECHILD)
 
         @kick.expects(:safe_posix_fork).times(3).returns(1).then.returns(2).then.returns(3)
 
         expect { @kick.main }.to raise_error SystemExit
       end
 
       it "should delegate to run_for_host per host" do
         @kick.hosts = ['host1', 'host2']
         @kick.stubs(:safe_posix_fork).returns(1).yields
         Process.stubs(:wait).returns(1).then.raises(Errno::ECHILD)
 
         @kick.expects(:run_for_host).times(2)
 
         lambda { @kick.main }.should raise_error
       end
 
       describe "during call of run_for_host" do
         before do
           require 'puppet/run'
           options = {
             :background => true, :ignoreschedules => false, :tags => []
           }
           @kick.preinit
           @agent_run = Puppet::Run.new( options.dup )
           @agent_run.stubs(:status).returns("success")
 
           Puppet::Run.indirection.expects(:terminus_class=).with( :rest )
           Puppet::Run.expects(:new).with( options ).returns(@agent_run)
         end
 
         it "should call run on a Puppet::Run for the given host" do
           Puppet::Run.indirection.expects(:save).with(@agent_run, 'https://host:8139/production/run/host').returns(@agent_run)
 
           expect { @kick.run_for_host('host') }.to exit_with 0
         end
 
         it "should exit the child with 0 on success" do
           @agent_run.stubs(:status).returns("success")
           expect { @kick.run_for_host('host') }.to exit_with 0
         end
 
         it "should exit the child with 3 on running" do
           @agent_run.stubs(:status).returns("running")
           expect { @kick.run_for_host('host') }.to exit_with 3
         end
 
         it "should exit the child with 12 on unknown answer" do
           @agent_run.stubs(:status).returns("whatever")
           expect { @kick.run_for_host('host') }.to exit_with 12
         end
       end
     end
   end
 end
diff --git a/spec/unit/application/master_spec.rb b/spec/unit/application/master_spec.rb
index feeee7c8e..de9fecf6f 100755
--- a/spec/unit/application/master_spec.rb
+++ b/spec/unit/application/master_spec.rb
@@ -1,379 +1,377 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/master'
 require 'puppet/daemon'
 require 'puppet/network/server'
 
 describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windows? do
   before :each do
     @master = Puppet::Application[:master]
     @daemon = stub_everything 'daemon'
     Puppet::Daemon.stubs(:new).returns(@daemon)
     Puppet::Util::Log.stubs(:newdestination)
 
     Puppet::Node.indirection.stubs(:terminus_class=)
     Puppet::Node.indirection.stubs(:cache_class=)
     Puppet::Node::Facts.indirection.stubs(:terminus_class=)
     Puppet::Node::Facts.indirection.stubs(:cache_class=)
     Puppet::Transaction::Report.indirection.stubs(:terminus_class=)
     Puppet::Resource::Catalog.indirection.stubs(:terminus_class=)
     Puppet::SSL::Host.stubs(:ca_location=)
   end
 
   it "should operate in master run_mode" do
     @master.class.run_mode.name.should equal(:master)
   end
 
   it "should declare a main command" do
     @master.should respond_to(:main)
   end
 
   it "should declare a compile command" do
     @master.should respond_to(:compile)
   end
 
   it "should declare a preinit block" do
     @master.should respond_to(:preinit)
   end
 
   describe "during preinit" do
     before :each do
       @master.stubs(:trap)
     end
 
     it "should catch INT" do
       @master.stubs(:trap).with { |arg,block| arg == :INT }
 
       @master.preinit
     end
 
     it "should create a Puppet Daemon" do
       Puppet::Daemon.expects(:new).returns(@daemon)
 
       @master.preinit
     end
 
     it "should give ARGV to the Daemon" do
       argv = stub 'argv'
       ARGV.stubs(:dup).returns(argv)
       @daemon.expects(:argv=).with(argv)
 
       @master.preinit
     end
 
   end
 
   [:debug,:verbose].each do |option|
     it "should declare handle_#{option} method" do
       @master.should respond_to("handle_#{option}".to_sym)
     end
 
     it "should store argument value when calling handle_#{option}" do
       @master.options.expects(:[]=).with(option, 'arg')
       @master.send("handle_#{option}".to_sym, 'arg')
     end
   end
 
   describe "when applying options" do
     before do
       @master.command_line.stubs(:args).returns([])
     end
 
     it "should set the log destination with --logdest" do
       Puppet::Log.expects(:newdestination).with("console")
 
       @master.handle_logdest("console")
     end
 
     it "should put the setdest options to true" do
       @master.options.expects(:[]=).with(:setdest,true)
 
       @master.handle_logdest("console")
     end
 
     it "should parse the log destination from ARGV" do
       @master.command_line.stubs(:args).returns(%w{--logdest /my/file})
 
       Puppet::Util::Log.expects(:newdestination).with("/my/file")
 
       @master.parse_options
     end
 
     it "should support dns alt names from ARGV" do
-      @master.command_line.stubs(:args).returns(["--dns_alt_names", "foo,bar,baz"])
+      Puppet.settings.initialize_global_settings(["--dns_alt_names", "foo,bar,baz"])
 
-      @master.command_line.send(:parse_global_options)
-      Puppet.settings.parse
       @master.preinit
       @master.parse_options
 
       Puppet[:dns_alt_names].should == "foo,bar,baz"
     end
 
 
   end
 
   describe "during setup" do
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:settraps)
       Puppet::SSL::CertificateAuthority.stubs(:instance)
       Puppet::SSL::CertificateAuthority.stubs(:ca?)
       Puppet.settings.stubs(:use)
 
       @master.options.stubs(:[]).with(any_parameters)
     end
 
     it "should abort stating that the master is not supported on Windows" do
       Puppet.features.stubs(:microsoft_windows?).returns(true)
 
       expect { @master.setup }.to raise_error(Puppet::Error, /Puppet master is not supported on Microsoft Windows/)
     end
 
     it "should set log level to debug if --debug was passed" do
       @master.options.stubs(:[]).with(:debug).returns(true)
       @master.setup
       Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @master.options.stubs(:[]).with(:verbose).returns(true)
       @master.setup
       Puppet::Log.level.should == :info
     end
 
     it "should set console as the log destination if no --logdest and --daemonize" do
       @master.stubs(:[]).with(:daemonize).returns(:false)
 
       Puppet::Log.expects(:newdestination).with(:syslog)
 
       @master.setup
     end
 
     it "should set syslog as the log destination if no --logdest and not --daemonize" do
       Puppet::Log.expects(:newdestination).with(:syslog)
 
       @master.setup
     end
 
     it "should set syslog as the log destination if --rack" do
       @master.options.stubs(:[]).with(:rack).returns(:true)
 
       Puppet::Log.expects(:newdestination).with(:syslog)
 
       @master.setup
     end
 
     it "should print puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
       Puppet.settings.expects(:print_configs).returns(true)
       expect { @master.setup }.to exit_with 0
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
       expect { @master.setup }.to exit_with 1
     end
 
     it "should tell Puppet.settings to use :main,:ssl,:master and :metrics category" do
       Puppet.settings.expects(:use).with(:main,:master,:ssl,:metrics)
 
       @master.setup
     end
 
     describe "with no ca" do
 
       it "should set the ca_location to none" do
         Puppet::SSL::Host.expects(:ca_location=).with(:none)
 
         @master.setup
       end
 
     end
 
     describe "with a ca configured" do
 
       before :each do
         Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
       end
 
       it "should set the ca_location to local" do
         Puppet::SSL::Host.expects(:ca_location=).with(:local)
 
         @master.setup
       end
 
       it "should tell Puppet.settings to use :ca category" do
         Puppet.settings.expects(:use).with(:ca)
 
         @master.setup
       end
 
       it "should instantiate the CertificateAuthority singleton" do
         Puppet::SSL::CertificateAuthority.expects(:instance)
 
         @master.setup
       end
 
 
     end
 
   end
 
   describe "when running" do
     before do
       @master.preinit
     end
 
     it "should dispatch to compile if called with --compile" do
       @master.options[:node] = "foo"
       @master.expects(:compile)
       @master.run_command
     end
 
     it "should dispatch to main otherwise" do
       @master.options[:node] = nil
 
       @master.expects(:main)
       @master.run_command
     end
 
     describe "the compile command" do
       before do
         Puppet.stubs(:[]).with(:environment)
         Puppet.stubs(:[]).with(:manifest).returns("site.pp")
         Puppet.stubs(:err)
         @master.stubs(:jj)
         Puppet.features.stubs(:pson?).returns true
       end
 
       it "should fail if pson isn't available" do
         Puppet.features.expects(:pson?).returns false
         lambda { @master.compile }.should raise_error
       end
 
       it "should compile a catalog for the specified node" do
         @master.options[:node] = "foo"
         Puppet::Resource::Catalog.indirection.expects(:find).with("foo").returns Puppet::Resource::Catalog.new
         $stdout.stubs(:puts)
 
         expect { @master.compile }.to exit_with 0
       end
 
       it "should convert the catalog to a pure-resource catalog and use 'jj' to pretty-print the catalog" do
         catalog = Puppet::Resource::Catalog.new
         Puppet::Resource::Catalog.indirection.expects(:find).returns catalog
 
         catalog.expects(:to_resource).returns("rescat")
 
         @master.options[:node] = "foo"
         @master.expects(:jj).with("rescat")
 
         expect { @master.compile }.to exit_with 0
       end
 
       it "should exit with error code 30 if no catalog can be found" do
         @master.options[:node] = "foo"
         Puppet::Resource::Catalog.indirection.expects(:find).returns nil
         $stderr.expects(:puts)
         expect { @master.compile }.to exit_with 30
       end
 
       it "should exit with error code 30 if there's a failure" do
         @master.options[:node] = "foo"
         Puppet::Resource::Catalog.indirection.expects(:find).raises ArgumentError
         $stderr.expects(:puts)
         expect { @master.compile }.to exit_with 30
       end
     end
 
     describe "the main command" do
       before :each do
         @master.preinit
         @server = stub_everything 'server'
         Puppet::Network::Server.stubs(:new).returns(@server)
         @app = stub_everything 'app'
         Puppet::SSL::Host.stubs(:localhost)
         Puppet::SSL::CertificateAuthority.stubs(:ca?)
         Process.stubs(:uid).returns(1000)
         Puppet.stubs(:service)
         Puppet.stubs(:[])
         Puppet.stubs(:notice)
         Puppet.stubs(:start)
       end
 
       it "should create a Server" do
         Puppet::Network::Server.expects(:new)
 
         @master.main
       end
 
       it "should give the server to the daemon" do
         @daemon.expects(:server=).with(@server)
 
         @master.main
       end
 
       it "should generate a SSL cert for localhost" do
         Puppet::SSL::Host.expects(:localhost)
 
         @master.main
       end
 
       it "should make sure to *only* hit the CA for data" do
         Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(true)
 
         Puppet::SSL::Host.expects(:ca_location=).with(:only)
 
         @master.main
       end
 
       it "should drop privileges if running as root" do
         Puppet.features.stubs(:root?).returns true
 
         Puppet::Util.expects(:chuser)
 
         @master.main
       end
 
       it "should daemonize if needed" do
         Puppet.stubs(:[]).with(:daemonize).returns(true)
 
         @daemon.expects(:daemonize)
 
         @master.main
       end
 
       it "should start the service" do
         @daemon.expects(:start)
 
         @master.main
       end
 
       describe "with --rack", :if => Puppet.features.rack? do
         before do
           require 'puppet/network/http/rack'
           Puppet::Network::HTTP::Rack.stubs(:new).returns(@app)
         end
 
         it "it should not start a daemon" do
           @master.options.stubs(:[]).with(:rack).returns(:true)
 
           @daemon.expects(:start).never
 
           @master.main
         end
 
         it "it should return the app" do
           @master.options.stubs(:[]).with(:rack).returns(:true)
 
           app = @master.main
           app.should equal(@app)
         end
 
       end
 
     end
   end
 end
diff --git a/spec/unit/application/resource_spec.rb b/spec/unit/application/resource_spec.rb
index bc9474018..8cf9472d0 100755
--- a/spec/unit/application/resource_spec.rb
+++ b/spec/unit/application/resource_spec.rb
@@ -1,220 +1,214 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application/resource'
 
 describe Puppet::Application::Resource do
   include PuppetSpec::Files
   before :each do
     @resource_app = Puppet::Application[:resource]
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Resource.indirection.stubs(:terminus_class=)
   end
 
   describe "in preinit" do
     it "should init extra_params to empty array" do
       @resource_app.preinit
       @resource_app.extra_params.should == []
     end
 
     it "should load Facter facts" do
       Facter.expects(:loadfacts).once
       @resource_app.preinit
     end
   end
 
   describe "when handling options" do
     [:debug, :verbose, :edit].each do |option|
       it "should store argument value when calling handle_#{option}" do
         @resource_app.options.expects(:[]=).with(option, 'arg')
         @resource_app.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should set options[:host] to given host" do
       @resource_app.handle_host(:whatever)
       @resource_app.host.should == :whatever
     end
 
     it "should load an display all types with types option" do
       type1 = stub_everything 'type1', :name => :type1
       type2 = stub_everything 'type2', :name => :type2
       Puppet::Type.stubs(:loadall)
       Puppet::Type.stubs(:eachtype).multiple_yields(type1,type2)
       @resource_app.expects(:puts).with(['type1','type2'])
       expect { @resource_app.handle_types(nil) }.to exit_with 0
     end
 
     it "should add param to extra_params list" do
       @resource_app.extra_params = [ :param1 ]
       @resource_app.handle_param("whatever")
 
       @resource_app.extra_params.should == [ :param1, :whatever ]
     end
 
     it "should get a parameter in the printed data if extra_params are passed" do
       tty  = stub("tty",  :tty? => true )
       path = tmpfile('testfile')
       command_line = Puppet::Util::CommandLine.new("puppet", [ 'resource', 'file', path ], tty )
       @resource_app.stubs(:command_line).returns command_line
 
       # provider is a parameter that should always be available
       @resource_app.extra_params = [ :provider ]
 
       expect { @resource_app.main }.to have_printed /provider\s+=>/
     end
   end
 
   describe "during setup" do
     before :each do
       Puppet::Log.stubs(:newdestination)
-      Puppet.stubs(:parse_config)
     end
 
     it "should set console as the log destination" do
       Puppet::Log.expects(:newdestination).with(:console)
 
       @resource_app.setup
     end
 
     it "should set log level to debug if --debug was passed" do
       @resource_app.options.stubs(:[]).with(:debug).returns(true)
       @resource_app.setup
       Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @resource_app.options.stubs(:[]).with(:debug).returns(false)
       @resource_app.options.stubs(:[]).with(:verbose).returns(true)
       @resource_app.setup
       Puppet::Log.level.should == :info
     end
 
-    it "should Parse puppet config" do
-      Puppet.expects(:parse_config)
-
-      @resource_app.setup
-    end
   end
 
   describe "when running" do
     before :each do
       @type = stub_everything 'type', :properties => []
       @resource_app.command_line.stubs(:args).returns(['mytype'])
       Puppet::Type.stubs(:type).returns(@type)
 
       @res = stub_everything "resource"
       @res.stubs(:prune_parameters).returns(@res)
       @report = stub_everything "report"
     end
 
     it "should raise an error if no type is given" do
       @resource_app.command_line.stubs(:args).returns([])
       lambda { @resource_app.main }.should raise_error(RuntimeError, "You must specify the type to display")
     end
 
     it "should raise an error when editing a remote host" do
       @resource_app.options.stubs(:[]).with(:edit).returns(true)
       @resource_app.host = 'host'
 
       lambda { @resource_app.main }.should raise_error(RuntimeError, "You cannot edit a remote host")
     end
 
     it "should raise an error if the type is not found" do
       Puppet::Type.stubs(:type).returns(nil)
 
       lambda { @resource_app.main }.should raise_error(RuntimeError, 'Could not find type mytype')
     end
 
     describe "with a host" do
       before :each do
         @resource_app.stubs(:puts)
         @resource_app.host = 'host'
 
         Puppet::Resource.indirection.stubs(:find  ).never
         Puppet::Resource.indirection.stubs(:search).never
         Puppet::Resource.indirection.stubs(:save  ).never
       end
 
       it "should search for resources" do
         @resource_app.command_line.stubs(:args).returns(['type'])
         Puppet::Resource.indirection.expects(:search).with('https://host:8139/production/resources/type/', {}).returns([])
         @resource_app.main
       end
 
       it "should describe the given resource" do
         @resource_app.command_line.stubs(:args).returns(['type', 'name'])
         Puppet::Resource.indirection.expects(:find).with('https://host:8139/production/resources/type/name').returns(@res)
         @resource_app.main
       end
 
       it "should add given parameters to the object" do
         @resource_app.command_line.stubs(:args).returns(['type','name','param=temp'])
 
         Puppet::Resource.indirection.expects(:save).
           with(@res, 'https://host:8139/production/resources/type/name').
           returns([@res, @report])
         Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(@res)
 
         @resource_app.main
       end
     end
 
     describe "without a host" do
       before :each do
         @resource_app.stubs(:puts)
         @resource_app.host = nil
 
         Puppet::Resource.indirection.stubs(:find  ).never
         Puppet::Resource.indirection.stubs(:search).never
         Puppet::Resource.indirection.stubs(:save  ).never
       end
 
       it "should search for resources" do
         Puppet::Resource.indirection.expects(:search).with('mytype/', {}).returns([])
         @resource_app.main
       end
 
       it "should describe the given resource" do
         @resource_app.command_line.stubs(:args).returns(['type','name'])
         Puppet::Resource.indirection.expects(:find).with('type/name').returns(@res)
         @resource_app.main
       end
 
       it "should add given parameters to the object" do
         @resource_app.command_line.stubs(:args).returns(['type','name','param=temp'])
 
         Puppet::Resource.indirection.expects(:save).with(@res, 'type/name').returns([@res, @report])
         Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(@res)
 
         @resource_app.main
       end
     end
   end
 
   describe "when handling file type" do
     before :each do
       Facter.stubs(:loadfacts)
       @resource_app.preinit
     end
 
     it "should raise an exception if no file specified" do
       @resource_app.command_line.stubs(:args).returns(['file'])
 
       lambda { @resource_app.main }.should raise_error(RuntimeError, /Listing all file instances is not supported/)
     end
 
     it "should output a file resource when given a file path" do
       path = File.expand_path('/etc')
       res = Puppet::Type.type(:file).new(:path => path).to_resource
       Puppet::Resource.indirection.expects(:find).returns(res)
 
       @resource_app.command_line.stubs(:args).returns(['file', path])
       @resource_app.expects(:puts).with do |args|
         args.should =~ /file \{ '#{Regexp.escape(path)}'/m
       end
 
       @resource_app.main
     end
   end
 end
diff --git a/spec/unit/application_spec.rb b/spec/unit/application_spec.rb
index 0d78cb48b..e01fc4d83 100755
--- a/spec/unit/application_spec.rb
+++ b/spec/unit/application_spec.rb
@@ -1,602 +1,607 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/application'
 require 'puppet'
 require 'getoptlong'
 require 'timeout'
 
 describe Puppet::Application do
 
-  before do
+  before(:each) 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 "application defaults" do
     it "should fail if required app default values are missing" do
       @app.stubs(:app_defaults).returns({ :foo => 'bar' })
       Puppet.expects(:err).with(regexp_matches(/missing required app default setting/))
       expect {
         @app.run
       }.to exit_with 1
     end
   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" do
       expect { @klass.find("String") }.to exit_with 1
     end
 
     it "should exit if it can't find a class" do
       @klass.expects(:puts).with do |value|
         value =~ /Unable to find application 'ThisShallNeverEverEverExist'/ and
           value =~ /puppet\/application\/thisshallneverevereverexist/ and
           value =~ /no such file to load|cannot load such file/
       end
 
       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
 
 
 
   # These tests may look a little weird and repetative in its current state;
   #  it used to illustrate several ways that the run_mode could be changed
   #  at run time; there are fewer ways now, but it would still be nice to
   #  get to a point where it was entirely impossible.
   describe "when dealing with run_mode" do
 
     class TestApp < Puppet::Application
       run_mode :master
       def run_command
         # no-op
       end
     end
 
     it "should sadly and frighteningly allow run_mode to change at runtime via #initialize_app_defaults" do
       Puppet.features.stubs(:syslog?).returns(true)
       Puppet[:run_mode].should == :user
 
       expect {
         app = TestApp.new
         app.initialize_app_defaults
 
         Puppet[:run_mode].should == :master
       }.to_not raise_error
     end
 
     it "should sadly and frighteningly allow run_mode to change at runtime via #run" do
       expect {
         app = TestApp.new
         app.run
 
         app.class.run_mode.name.should == :master
 
         Puppet[:run_mode].should == :master
 
       }.should_not raise_error
 
     end
   end
 
 
   it "it should not allow initialize_app_defaults to be called multiple times" do
     app = Puppet::Application.new
     expect {
       app.initialize_app_defaults
     }.to_not raise_error
 
     expect {
       app.initialize_app_defaults
     }.to raise_error
   end
 
 
   it "should explode when an invalid run mode is set at runtime, for great victory" do
     class InvalidRunModeTestApp < Puppet::Application
       run_mode :abracadabra
       def run_command
         # no-op
       end
     end
 
     expect {
       app = InvalidRunModeTestApp.new
       app.initialize_app_defaults
     }.to raise_error
   end
 
   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 early in the life cycle" do
+    # Not proud of this, but the fact that we are stubbing init_app_defaults
+    #  below means that we will get errors if anyone tries to access any
+    #  settings that depend on app_defaults.  In general this whole test
+    #  seems to be testing too many implementation details rather than
+    #  functionality, but, hey.
+    Puppet[:route_file] = "/dev/null"
+
     startup_sequence = sequence('startup')
     @app.expects(:initialize_app_defaults).in_sequence(startup_sequence)
     Puppet::Util::Instrumentation.expects(:init).in_sequence(startup_sequence)
     @app.expects(:preinit).in_sequence(startup_sequence)
 
     expect { @app.run }.to exit_with(1)
   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' do
         Timeout::timeout(3) do  # if the signal doesn't fire, this causes failure.
 
           has_run = false
           old_handler = trap('HUP') { has_run = true }
 
           begin
             Puppet::Application.controlled_run do
               Puppet::Application.run_status = :restart_requested
             end
 
             # Ruby 1.9 uses a separate OS level thread to run the signal
             # handler, so we have to poll - ideally, in a way that will kick
             # the OS into running other threads - for a while.
             #
             # You can't just use the Ruby Thread yield thing either, because
             # that is just an OS hint, and Linux ... doesn't take that
             # seriously. --daniel 2012-03-22
             sleep 0.001 while not has_run
           ensure
             trap('HUP', old_handler)
           end
         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 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 transform boolean option to normal form for Puppet.settings" do
         @app.expects(:handle_unknown).with("--option", true)
         @app.send(:handlearg, "--[no-]option", true)
       end
 
       it "should transform boolean option to no- form for Puppet.settings" do
         @app.expects(:handle_unknown).with("--no-option", false)
         @app.send(:handlearg, "--[no-]option", false)
       end
 
     end
   end
 
   describe "when calling default setup" do
 
     before :each do
       @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(:setup_default)
 
       @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 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
       Puppet.expects(:err)
       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)
       Puppet.expects(:err)
       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)
       Puppet.expects(:err)
       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
diff --git a/spec/unit/util/command_line_spec.rb b/spec/unit/util/command_line_spec.rb
index 10d006eb9..f608c13ba 100755
--- a/spec/unit/util/command_line_spec.rb
+++ b/spec/unit/util/command_line_spec.rb
@@ -1,193 +1,143 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/face'
 require 'puppet/util/command_line'
 
 describe Puppet::Util::CommandLine do
   include PuppetSpec::Files
   before do
     @tty  = stub("tty",  :tty? => true )
     @pipe = stub("pipe", :tty? => false)
   end
 
   it "should pull off the first argument if it looks like a subcommand" do
     command_line = Puppet::Util::CommandLine.new("puppet", %w{ client --help whatever.pp }, @tty )
 
     command_line.subcommand_name.should == "client"
     command_line.args.should            == %w{ --help whatever.pp }
   end
 
   it "should return nil if the first argument looks like a .pp file" do
     command_line = Puppet::Util::CommandLine.new("puppet", %w{ whatever.pp }, @tty )
 
     command_line.subcommand_name.should == nil
     command_line.args.should            == %w{ whatever.pp }
   end
 
   it "should return nil if the first argument looks like a .rb file" do
     command_line = Puppet::Util::CommandLine.new("puppet", %w{ whatever.rb }, @tty )
 
     command_line.subcommand_name.should == nil
     command_line.args.should            == %w{ whatever.rb }
   end
 
   it "should return nil if the first argument looks like a flag" do
     command_line = Puppet::Util::CommandLine.new("puppet", %w{ --debug }, @tty )
 
     command_line.subcommand_name.should == nil
     command_line.args.should            == %w{ --debug }
   end
 
   it "should return nil if the first argument is -" do
     command_line = Puppet::Util::CommandLine.new("puppet", %w{ - }, @tty )
 
     command_line.subcommand_name.should == nil
     command_line.args.should            == %w{ - }
   end
 
   it "should return nil if the first argument is --help" do
     command_line = Puppet::Util::CommandLine.new("puppet", %w{ --help }, @tty )
 
     command_line.subcommand_name.should == nil
   end
 
 
   it "should return nil if there are no arguments on a tty" do
     command_line = Puppet::Util::CommandLine.new("puppet", [], @tty )
 
     command_line.subcommand_name.should == nil
     command_line.args.should            == []
   end
 
   it "should return nil if there are no arguments on a pipe" do
     command_line = Puppet::Util::CommandLine.new("puppet", [], @pipe )
 
     command_line.subcommand_name.should == nil
     command_line.args.should            == []
   end
 
-  # A lot of settings management stuff has moved into command_line.rb; we need to do a first pass over
-  #  all of the supplied command-line arguments before we attempt to determine what application or
-  #  face we're going to run, because we need to be able to load apps/faces from the libdir
-  describe "when dealing with settings" do
-    let(:command_line) { Puppet::Util::CommandLine.new( "foo", [], @tty ) }
-
-    it "should get options from Puppet.settings.optparse_addargs" do
-      Puppet.settings.expects(:optparse_addargs).returns([])
-
-      command_line.send(:parse_global_options)
-    end
-
-    it "should add Puppet.settings options to OptionParser" do
-      Puppet.settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option", :NONE]])
-      Puppet.settings.expects(:handlearg).with("--option", true)
-      command_line.stubs(:args).returns(["--option"])
-      command_line.send(:parse_global_options)
-    end
-
-    it "should not die if it sees an unrecognized option, because the app/face may handle it later" do
-      command_line.stubs(:args).returns(["--topuppet", "value"])
-      expect { command_line.send(:parse_global_options) } .to_not raise_error
-    end
-
-    it "should not pass an unrecognized option to Puppet.settings" do
-      command_line.stubs(:args).returns(["--topuppet", "value"])
-      Puppet.settings.expects(:handlearg).with("--topuppet", "value").never
-      expect { command_line.send(:parse_global_options) } .to_not raise_error
-    end
-
-    it "should pass valid puppet settings options to Puppet.settings even if they appear after an unrecognized option" do
-      Puppet.settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option", :NONE]])
-      Puppet.settings.expects(:handlearg).with("--option", true)
-      command_line.stubs(:args).returns(["--invalidoption", "--option"])
-      command_line.send(:parse_global_options)
-    end
-
-
-    it "should transform boolean option to normal form for Puppet.settings" do
-      Puppet.settings.expects(:handlearg).with("--option", true)
-      command_line.send(: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)
-      command_line.send(:handlearg, "--[no-]option", false)
-    end
-  end
-
-
   describe "when dealing with puppet commands" do
 
     it "should return the executable name if it is not puppet" do
       command_line = Puppet::Util::CommandLine.new("puppetmasterd", [], @tty )
 
       command_line.subcommand_name.should == "puppetmasterd"
     end
 
     it "should translate subcommand names into their legacy equivalent" do
       command_line = Puppet::Util::CommandLine.new("puppet", ["master"], @tty)
       command_line.legacy_executable_name.should == :puppetmasterd
     end
 
     it "should leave legacy command names alone" do
       command_line = Puppet::Util::CommandLine.new("puppetmasterd", [], @tty)
       command_line.legacy_executable_name.should == :puppetmasterd
     end
 
     describe "when the subcommand is not implemented" do
       it "should find and invoke an executable with a hyphenated name" do
         commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'], @tty)
         Puppet::Util.expects(:which).with('puppet-whatever').returns('/dev/null/puppet-whatever')
         commandline.expects(:exec).with('/dev/null/puppet-whatever', 'argument')
 
         commandline.execute
       end
 
       describe "and an external implementation cannot be found" do
         it "should abort and show the usage message" do
           commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'], @tty)
           Puppet::Util.expects(:which).with('puppet-whatever').returns(nil)
           commandline.expects(:exec).never
 
           expect {
             commandline.execute
           }.to have_printed(/Unknown Puppet subcommand 'whatever'/)
         end
       end
     end
     describe 'when loading commands' do
       before do
         @core_apps = %w{describe filebucket kick queue resource agent cert apply doc master}
         @command_line = Puppet::Util::CommandLine.new("foo", %w{ client --help whatever.pp }, @tty )
       end
       it "should expose available_subcommands as a class method" do
         @core_apps.each do |command|
           @command_line.available_subcommands.should include command
         end
       end
       it 'should be able to find all existing commands' do
         @core_apps.each do |command|
           @command_line.available_subcommands.should include command
         end
       end
       describe 'when multiple paths have applications' do
         before do
           @dir=tmpdir('command_line_plugin_test')
           @appdir="#{@dir}/puppet/application"
           FileUtils.mkdir_p(@appdir)
           FileUtils.touch("#{@appdir}/foo.rb")
           $LOAD_PATH.unshift(@dir) # WARNING: MUST MATCH THE AFTER ACTIONS!
         end
         it 'should be able to find commands from both paths' do
           found = @command_line.available_subcommands
           found.should include 'foo'
           @core_apps.each { |cmd| found.should include cmd }
         end
         after do
           $LOAD_PATH.shift        # WARNING: MUST MATCH THE BEFORE ACTIONS!
         end
       end
     end
   end
 end
diff --git a/spec/unit/util/settings_spec.rb b/spec/unit/util/settings_spec.rb
index d7fefa583..eb2696c89 100755
--- a/spec/unit/util/settings_spec.rb
+++ b/spec/unit/util/settings_spec.rb
@@ -1,1438 +1,1480 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'ostruct'
 
 describe Puppet::Util::Settings do
   include PuppetSpec::Files
 
   MAIN_CONFIG_FILE_DEFAULT_LOCATION = File.join(Puppet::Util::Settings.default_global_config_dir, "puppet.conf")
   USER_CONFIG_FILE_DEFAULT_LOCATION = File.join(Puppet::Util::Settings.default_user_config_dir, "puppet.conf")
 
   describe "when specifying defaults" do
     before do
       @settings = Puppet::Util::Settings.new
     end
 
     it "should start with no defined parameters" do
       @settings.params.length.should == 0
     end
 
     it "should not allow specification of default values associated with a section as an array" do
       expect {
         @settings.define_settings(:section, :myvalue => ["defaultval", "my description"])
       }.to raise_error
     end
 
     it "should not allow duplicate parameter specifications" do
       @settings.define_settings(:section, :myvalue => { :default => "a", :desc => "b" })
       lambda { @settings.define_settings(:section, :myvalue => { :default => "c", :desc => "d" }) }.should raise_error(ArgumentError)
     end
 
     it "should allow specification of default values associated with a section as a hash" do
       @settings.define_settings(:section, :myvalue => {:default => "defaultval", :desc => "my description"})
     end
 
     it "should consider defined parameters to be valid" do
       @settings.define_settings(:section, :myvalue => { :default => "defaultval", :desc => "my description" })
       @settings.valid?(:myvalue).should be_true
     end
 
     it "should require a description when defaults are specified with a hash" do
       lambda { @settings.define_settings(:section, :myvalue => {:default => "a value"}) }.should raise_error(ArgumentError)
     end
 
     it "should support specifying owner, group, and mode when specifying files" do
       @settings.define_settings(:section, :myvalue => {:type => :file, :default => "/some/file", :owner => "service", :mode => "boo", :group => "service", :desc => "whatever"})
     end
 
     it "should support specifying a short name" do
       @settings.define_settings(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"})
     end
 
     it "should support specifying the setting type" do
       @settings.define_settings(:section, :myvalue => {:default => "/w", :desc => "b", :type => :string})
       @settings.setting(:myvalue).should be_instance_of(Puppet::Util::Settings::StringSetting)
     end
 
     it "should fail if an invalid setting type is specified" do
       lambda { @settings.define_settings(:section, :myvalue => {:default => "w", :desc => "b", :type => :foo}) }.should raise_error(ArgumentError)
     end
 
     it "should fail when short names conflict" do
       @settings.define_settings(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"})
       lambda { @settings.define_settings(:section, :myvalue => {:default => "w", :desc => "b", :short => "m"}) }.should raise_error(ArgumentError)
     end
   end
 
 
   describe "when initializing application defaults do" do
     before do
       @settings = Puppet::Util::Settings.new
     end
 
     it "should fail if someone attempts to initialize app defaults more than once" do
       @settings.expects(:app_defaults_initialized?).returns(true)
       expect {
         @settings.initialize_app_defaults({})
       }.to raise_error(Puppet::DevError)
     end
 
     it "should fail if the app defaults hash is missing any required values" do
       expect {
         @settings.initialize_app_defaults({})
       }.to raise_error(Puppet::SettingsError)
     end
 
     # ultimately I'd like to stop treating "run_mode" as a normal setting, because it has so many special
     #  case behaviors / uses.  However, until that time... we need to make sure that our private run_mode=
     #  setter method gets properly called during app initialization.
     it "should call the hacky run mode setter method until we do a better job of separating run_mode" do
       app_defaults = {}
       Puppet::Util::Settings::REQUIRED_APP_SETTINGS.each do |key|
         app_defaults[key] = "foo"
       end
 
       @settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
       @settings.expects(:run_mode=).with("foo")
       @settings.initialize_app_defaults(app_defaults)
     end
   end
 
   describe "#call_hooks_deferred_to_application_initialization" do
     let (:good_default) { "yay" }
     let (:bad_default) { "$doesntexist" }
     before(:each) do
       @settings = Puppet::Util::Settings.new
     end
 
     describe "when ignoring dependency interpolation errors" do
       let(:options) { {:ignore_interpolation_dependency_errors => true} }
 
       describe "if interpolation error" do
         it "should not raise an error" do
           hook_values = []
           @settings.define_settings(:section, :badhook => {:default => bad_default, :desc => "boo", :call_hook => :on_initialize_and_write, :hook => lambda { |v| hook_values << v  }})
           expect do
             @settings.send(:call_hooks_deferred_to_application_initialization, options)
           end.to_not raise_error
         end
       end
       describe "if no interpolation error" do
         it "should not raise an error" do
           hook_values = []
           @settings.define_settings(:section, :goodhook => {:default => good_default, :desc => "boo", :call_hook => :on_initialize_and_write, :hook => lambda { |v| hook_values << v  }})
           expect do
             @settings.send(:call_hooks_deferred_to_application_initialization, options)
           end.to_not raise_error
         end
       end
     end
 
     describe "when not ignoring dependency interpolation errors" do
       [ {}, {:ignore_interpolation_dependency_errors => false}].each do |options|
         describe "if interpolation error" do
           it "should raise an error" do
             hook_values = []
             @settings.define_settings(:section, :badhook => {:default => bad_default, :desc => "boo", :call_hook => :on_initialize_and_write, :hook => lambda { |v| hook_values << v  }})
             expect do
               @settings.send(:call_hooks_deferred_to_application_initialization, options)
             end.to raise_error
           end
           it "should contain the setting name in error message" do
             hook_values = []
             @settings.define_settings(:section, :badhook => {:default => bad_default, :desc => "boo", :call_hook => :on_initialize_and_write, :hook => lambda { |v| hook_values << v  }})
             expect do
               @settings.send(:call_hooks_deferred_to_application_initialization, options)
             end.to raise_error Puppet::SettingsError, /badhook/
           end
         end
         describe "if no interpolation error" do
           it "should not raise an error" do
             hook_values = []
             @settings.define_settings(:section, :goodhook => {:default => good_default, :desc => "boo", :call_hook => :on_initialize_and_write, :hook => lambda { |v| hook_values << v  }})
             expect do
               @settings.send(:call_hooks_deferred_to_application_initialization, options)
             end.to_not raise_error
           end
         end
       end
     end
   end
 
   describe "when setting values" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.define_settings :main, :myval => { :default => "val", :desc => "desc" }
       @settings.define_settings :main, :bool => { :type => :boolean, :default => true, :desc => "desc" }
     end
 
     it "should provide a method for setting values from other objects" do
       @settings[:myval] = "something else"
       @settings[:myval].should == "something else"
     end
 
     it "should support a getopt-specific mechanism for setting values" do
       @settings.handlearg("--myval", "newval")
       @settings[:myval].should == "newval"
     end
 
     it "should support a getopt-specific mechanism for turning booleans off" do
       @settings[:bool] = true
       @settings.handlearg("--no-bool", "")
       @settings[:bool].should == false
     end
 
     it "should support a getopt-specific mechanism for turning booleans on" do
       # Turn it off first
       @settings[:bool] = false
       @settings.handlearg("--bool", "")
       @settings[:bool].should == true
     end
 
     it "should consider a cli setting with no argument to be a boolean" do
       # Turn it off first
       @settings[:bool] = false
       @settings.handlearg("--bool")
       @settings[:bool].should == true
     end
 
     it "should consider a cli setting with an empty string as an argument to be a boolean, if the setting itself is a boolean" do
       # Turn it off first
       @settings[:bool] = false
       @settings.handlearg("--bool", "")
       @settings[:bool].should == true
     end
 
     it "should consider a cli setting with an empty string as an argument to be an empty argument, if the setting itself is not a boolean" do
       @settings[:myval] = "bob"
       @settings.handlearg("--myval", "")
       @settings[:myval].should == ""
     end
 
     it "should consider a cli setting with a boolean as an argument to be a boolean" do
       # Turn it off first
       @settings[:bool] = false
       @settings.handlearg("--bool", "true")
       @settings[:bool].should == true
     end
 
     it "should not consider a cli setting of a non boolean with a boolean as an argument to be a boolean" do
       # Turn it off first
       @settings[:myval] = "bob"
       @settings.handlearg("--no-myval", "")
       @settings[:myval].should == ""
     end
 
     it "should flag string settings from the CLI" do
       @settings.handlearg("--myval", "12")
       @settings.set_by_cli?(:myval).should be_true
     end
 
     it "should flag bool settings from the CLI" do
       @settings[:bool] = false
       @settings.handlearg("--bool")
       @settings.set_by_cli?(:bool).should be_true
     end
 
     it "should not flag settings memory as from CLI" do
       @settings[:myval] = "12"
       @settings.set_by_cli?(:myval).should be_false
     end
     
     describe "setbycli" do
       it "should generate a deprecation warning" do
         Puppet.expects(:deprecation_warning)
         @settings.setting(:myval).setbycli = true
       end
       it "should set the value" do
         @settings[:myval] = "blah"
         @settings.setting(:myval).setbycli = true
         @settings.set_by_cli?(:myval).should be_true
       end
       it "should raise error if trying to unset value" do
         @settings.handlearg("--myval", "blah")
         expect do
           @settings.setting(:myval).setbycli = nil
         end.to raise_error ArgumentError, /unset/
       end
     end
 
     it "should clear the cache when setting getopt-specific values" do
       @settings.define_settings :mysection,
           :one => { :default => "whah", :desc => "yay" },
           :two => { :default => "$one yay", :desc => "bah" }
       @settings[:two].should == "whah yay"
       @settings.handlearg("--one", "else")
       @settings[:two].should == "else yay"
     end
 
     it "should not clear other values when setting getopt-specific values" do
       @settings[:myval] = "yay"
       @settings.handlearg("--no-bool", "")
       @settings[:myval].should == "yay"
     end
 
     it "should clear the list of used sections" do
       @settings.expects(:clearused)
       @settings[:myval] = "yay"
     end
 
     describe "call_hook" do
       Puppet::Util::Settings::StringSetting.available_call_hook_values.each do |val|
         describe "when :#{val}" do
           describe "and definition invalid" do
             it "should raise error if no hook defined" do
               expect do
                 @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => val})
               end.to raise_error ArgumentError, /no :hook/
             end
             it "should include the setting name in the error message" do
               expect do
                 @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => val})
               end.to raise_error ArgumentError, /for :hooker/
             end
           end
           describe "and definition valid" do
             before(:each) do
               hook_values = []
               @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => val, :hook => lambda { |v| hook_values << v  }})
             end
 
             it "should call the hook when value written" do
               @settings.setting(:hooker).expects(:handle).with("something").once
               @settings[:hooker] = "something"
             end
           end
         end
       end
 
       it "should have a default value of :on_write_only" do
         @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| hook_values << v  }})
         @settings.setting(:hooker).call_hook.should == :on_write_only
       end
 
       describe "when nil" do
         it "should generate a warning" do
           Puppet.expects(:warning)
           @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => nil, :hook => lambda { |v| hook_values << v  }})
         end
         it "should use default" do
           @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => nil, :hook => lambda { |v| hook_values << v  }})
           @settings.setting(:hooker).call_hook.should == :on_write_only
         end
       end
 
       describe "when invalid" do
         it "should raise an error" do
           expect do
             @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => :foo, :hook => lambda { |v| hook_values << v  }})
           end.to raise_error ArgumentError, /invalid.*call_hook/i
         end
       end
 
       describe "when :on_define_and_write" do
         it "should call the hook at definition" do
           hook_values = []
           @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => :on_define_and_write, :hook => lambda { |v| hook_values << v  }})
           @settings.setting(:hooker).call_hook.should == :on_define_and_write
           hook_values.should == %w{yay}
         end
       end
 
       describe "when :on_initialize_and_write" do
         before(:each) do
           @hook_values = []
           @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => :on_initialize_and_write, :hook => lambda { |v| @hook_values << v  }})
         end
 
         it "should not call the hook at definition" do
           @hook_values.should == []
           @hook_values.should_not == %w{yay}
         end
 
         it "should call the hook at initialization" do
           app_defaults = {}
           Puppet::Util::Settings::REQUIRED_APP_SETTINGS.each do |key|
             app_defaults[key] = "foo"
           end
           app_defaults[:run_mode] = :user
           @settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
 
           @settings.setting(:hooker).expects(:handle).with("yay").once
 
           @settings.initialize_app_defaults app_defaults
         end
       end
     end
 
     describe "call_on_define" do
       [true, false].each do |val|
         describe "to #{val}" do
           it "should generate a deprecation warning" do
             Puppet.expects(:deprecation_warning)
             values = []
             @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_on_define => val, :hook => lambda { |v| values << v }})
           end
 
           it "should should set call_hook" do
             values = []
             name = "hooker_#{val}".to_sym
             @settings.define_settings(:section, name => {:default => "yay", :desc => "boo", :call_on_define => val, :hook => lambda { |v| values << v }})
 
             @settings.setting(name).call_hook.should == :on_define_and_write if val
             @settings.setting(name).call_hook.should == :on_write_only unless val
           end
         end
       end
     end
 
     it "should call passed blocks when values are set" do
       values = []
       @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| values << v }})
       values.should == []
 
       @settings[:hooker] = "something"
       values.should == %w{something}
     end
 
     it "should call passed blocks when values are set via the command line" do
       values = []
       @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| values << v }})
       values.should == []
 
       @settings.handlearg("--hooker", "yay")
 
       values.should == %w{yay}
     end
 
     it "should provide an option to call passed blocks during definition" do
       values = []
       @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => :on_define_and_write, :hook => lambda { |v| values << v }})
       values.should == %w{yay}
     end
 
     it "should pass the fully interpolated value to the hook when called on definition" do
       values = []
       @settings.define_settings(:section, :one => { :default => "test", :desc => "a" })
       @settings.define_settings(:section, :hooker => {:default => "$one/yay", :desc => "boo", :call_hook => :on_define_and_write, :hook => lambda { |v| values << v }})
       values.should == %w{test/yay}
     end
 
     it "should munge values using the setting-specific methods" do
       @settings[:bool] = "false"
       @settings[:bool].should == false
     end
 
     it "should prefer cli values to values set in Ruby code" do
       @settings.handlearg("--myval", "cliarg")
       @settings[:myval] = "memarg"
       @settings[:myval].should == "cliarg"
     end
 
     it "should clear the list of environments" do
       Puppet::Node::Environment.expects(:clear).at_least(1)
       @settings[:myval] = "memarg"
     end
 
     it "should raise an error if we try to set a setting that hasn't been defined'" do
       lambda{
         @settings[:why_so_serious] = "foo"
       }.should raise_error(ArgumentError, /unknown configuration parameter/)
     end
 
     it "should raise an error if we try to set a setting that is read-only (which, really, all of our settings probably should be)" do
       @settings.define_settings(:section, :one => { :default => "test", :desc => "a" })
       @settings.expects(:read_only_settings).returns([:one])
 
       lambda{
         @settings[:one] = "foo"
       }.should raise_error(ArgumentError, /read-only/)
     end
 
     it "should warn and use [master] if we ask for [puppetmasterd]" do
       Puppet.expects(:deprecation_warning)
       @settings.set_value(:myval, "foo", :puppetmasterd)
 
       @settings.stubs(:run_mode).returns(:master)
       @settings.value(:myval).should == "foo"
     end
 
     it "should warn and use [agent] if we ask for [puppetd]" do
       Puppet.expects(:deprecation_warning)
       @settings.set_value(:myval, "foo", :puppetd)
 
       @settings.stubs(:run_mode).returns(:agent)
       @settings.value(:myval).should == "foo"
     end
   end
 
   describe "when returning values" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.define_settings :section,
           :config => { :type => :file, :default => "/my/file", :desc => "eh" },
           :one    => { :default => "ONE", :desc => "a" },
           :two    => { :default => "$one TWO", :desc => "b"},
           :three  => { :default => "$one $two THREE", :desc => "c"},
           :four   => { :default => "$two $three FOUR", :desc => "d"}
       FileTest.stubs(:exist?).returns true
     end
 
     describe "call_on_define" do
       it "should generate a deprecation warning" do
         Puppet.expects(:deprecation_warning)
         @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :hook => lambda { |v| hook_values << v  }})
         @settings.setting(:hooker).call_on_define
       end
 
       Puppet::Util::Settings::StringSetting.available_call_hook_values.each do |val|
         it "should match value for call_hook => :#{val}" do
           hook_values = []
           @settings.define_settings(:section, :hooker => {:default => "yay", :desc => "boo", :call_hook => val, :hook => lambda { |v| hook_values << v  }})
           @settings.setting(:hooker).call_on_define.should == @settings.setting(:hooker).call_hook_on_define?
         end
       end
     end
 
     it "should provide a mechanism for returning set values" do
       @settings[:one] = "other"
       @settings[:one].should == "other"
     end
 
     it "should interpolate default values for other parameters into returned parameter values" do
       @settings[:one].should == "ONE"
       @settings[:two].should == "ONE TWO"
       @settings[:three].should == "ONE ONE TWO THREE"
     end
 
     it "should interpolate default values that themselves need to be interpolated" do
       @settings[:four].should == "ONE TWO ONE ONE TWO THREE FOUR"
     end
 
     it "should provide a method for returning uninterpolated values" do
       @settings[:two] = "$one tw0"
       @settings.uninterpolated_value(:two).should  == "$one tw0"
       @settings.uninterpolated_value(:four).should == "$two $three FOUR"
     end
 
     it "should interpolate set values for other parameters into returned parameter values" do
       @settings[:one] = "on3"
       @settings[:two] = "$one tw0"
       @settings[:three] = "$one $two thr33"
       @settings[:four] = "$one $two $three f0ur"
       @settings[:one].should == "on3"
       @settings[:two].should == "on3 tw0"
       @settings[:three].should == "on3 on3 tw0 thr33"
       @settings[:four].should == "on3 on3 tw0 on3 on3 tw0 thr33 f0ur"
     end
 
     it "should not cache interpolated values such that stale information is returned" do
       @settings[:two].should == "ONE TWO"
       @settings[:one] = "one"
       @settings[:two].should == "one TWO"
     end
 
     it "should not cache values such that information from one environment is returned for another environment" do
       text = "[env1]\none = oneval\n[env2]\none = twoval\n"
       @settings.stubs(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
 
       @settings.value(:one, "env1").should == "oneval"
       @settings.value(:one, "env2").should == "twoval"
     end
 
     it "should have a run_mode that defaults to user" do
       @settings.run_mode.should == :user
     end
     describe "setbycli" do
       it "should generate a deprecation warning" do
         @settings.handlearg("--one", "blah")
         Puppet.expects(:deprecation_warning)
         @settings.setting(:one).setbycli
       end
       it "should be true" do
         @settings.handlearg("--one", "blah")
         @settings.setting(:one).setbycli.should be_true
       end
     end
   end
 
   describe "when choosing which value to return" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.define_settings :section,
         :config => { :type => :file, :default => "/my/file", :desc => "a" },
         :one => { :default => "ONE", :desc => "a" },
         :two => { :default => "TWO", :desc => "b" }
       FileTest.stubs(:exist?).returns true
       @settings.stubs(:run_mode).returns :mymode
     end
 
     it "should return default values if no values have been set" do
       @settings[:one].should == "ONE"
     end
 
     it "should return values set on the cli before values set in the configuration file" do
       text = "[main]\none = fileval\n"
       @settings.stubs(:read_file).returns(text)
       @settings.handlearg("--one", "clival")
-      @settings.parse
+      @settings.send(:parse_config_files)
 
       @settings[:one].should == "clival"
     end
 
     it "should return values set on the cli before values set in Ruby" do
       @settings[:one] = "rubyval"
       @settings.handlearg("--one", "clival")
       @settings[:one].should == "clival"
     end
 
     it "should return values set in the mode-specific section before values set in the main section" do
       text = "[main]\none = mainval\n[mymode]\none = modeval\n"
       @settings.stubs(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
 
       @settings[:one].should == "modeval"
     end
 
     it "should not return values outside of its search path" do
       text = "[other]\none = oval\n"
       file = "/some/file"
       @settings.stubs(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings[:one].should == "ONE"
     end
 
     it "should return values in a specified environment" do
       text = "[env]\none = envval\n"
       @settings.stubs(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings.value(:one, "env").should == "envval"
     end
 
     it 'should use the current environment for $environment' do
       @settings.define_settings :main, :myval => { :default => "$environment/foo", :desc => "mydocs" }
 
       @settings.value(:myval, "myenv").should == "myenv/foo"
     end
 
     it "should interpolate found values using the current environment" do
       text = "[main]\none = mainval\n[myname]\none = nameval\ntwo = $one/two\n"
       @settings.stubs(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
 
       @settings.value(:two, "myname").should == "nameval/two"
     end
 
     it "should return values in a specified environment before values in the main or name sections" do
       text = "[env]\none = envval\n[main]\none = mainval\n[myname]\none = nameval\n"
       @settings.stubs(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings.value(:one, "env").should == "envval"
     end
   end
 
 
   describe "when locating config files" do
     before do
       @settings = Puppet::Util::Settings.new
     end
 
     describe "when root" do
       it "should look for #{MAIN_CONFIG_FILE_DEFAULT_LOCATION} if config settings haven't been overridden'" do
         Puppet.features.stubs(:root?).returns(true)
         FileTest.expects(:exist?).with(MAIN_CONFIG_FILE_DEFAULT_LOCATION).returns(false)
         FileTest.expects(:exist?).with(USER_CONFIG_FILE_DEFAULT_LOCATION).never
 
-        @settings.parse()
+        @settings.send(:parse_config_files)
       end
     end
 
     describe "when not root" do
       it "should look for #{MAIN_CONFIG_FILE_DEFAULT_LOCATION} and #{USER_CONFIG_FILE_DEFAULT_LOCATION} if config settings haven't been overridden'" do
         Puppet.features.stubs(:root?).returns(false)
 
         seq = sequence "load config files"
         FileTest.expects(:exist?).with(MAIN_CONFIG_FILE_DEFAULT_LOCATION).returns(false).in_sequence(seq)
         FileTest.expects(:exist?).with(USER_CONFIG_FILE_DEFAULT_LOCATION).returns(false).in_sequence(seq)
 
-        @settings.parse()
+        @settings.send(:parse_config_files)
       end
     end
   end
 
   describe "when parsing its configuration" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.stubs(:service_user_available?).returns true
       @file = "/some/file"
       @settings.define_settings :section, :user => { :default => "suser", :desc => "doc" }, :group => { :default => "sgroup", :desc => "doc" }
       @settings.define_settings :section,
           :config => { :type => :file, :default => "/some/file", :desc => "eh" },
           :one => { :default => "ONE", :desc => "a" },
           :two => { :default => "$one TWO", :desc => "b" },
           :three => { :default => "$one $two THREE", :desc => "c" }
       @settings.stubs(:user_config_file).returns("/test/userconfigfile")
       FileTest.stubs(:exist?).with("/some/file").returns true
       FileTest.stubs(:exist?).with("/test/userconfigfile").returns false
     end
 
     it "should not ignore the report setting" do
       @settings.define_settings :section, :report => { :default => "false", :desc => "a" }
       # This is needed in order to make sure we pass on windows
       myfile = File.expand_path("/my/file")
       @settings[:config] = myfile
       text = <<-CONF
         [puppetd]
           report=true
       CONF
       FileTest.expects(:exist?).with(myfile).returns(true)
       @settings.expects(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings[:report].should be_true
     end
 
     it "should use its current ':config' value for the file to parse" do
       myfile = make_absolute("/my/file") # do not stub expand_path here, as this leads to a stack overflow, when mocha tries to use it
       @settings[:config] = myfile
 
       FileTest.expects(:exist?).with(myfile).returns(true)
 
       File.expects(:read).with(myfile).returns "[main]"
 
-      @settings.parse
+      @settings.send(:parse_config_files)
     end
 
     it "should not try to parse non-existent files" do
       FileTest.expects(:exist?).with("/some/file").returns false
 
       File.expects(:read).with("/some/file").never
 
-      @settings.parse
+      @settings.send(:parse_config_files)
     end
 
     it "should return values set in the configuration file" do
       text = "[main]
       one = fileval
       "
       @settings.expects(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings[:one].should == "fileval"
     end
 
     #484 - this should probably be in the regression area
     it "should not throw an exception on unknown parameters" do
       text = "[main]\nnosuchparam = mval\n"
       @settings.expects(:read_file).returns(text)
-      lambda { @settings.parse }.should_not raise_error
+      lambda { @settings.send(:parse_config_files) }.should_not raise_error
     end
 
     it "should convert booleans in the configuration file into Ruby booleans" do
       text = "[main]
       one = true
       two = false
       "
       @settings.expects(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings[:one].should == true
       @settings[:two].should == false
     end
 
     it "should convert integers in the configuration file into Ruby Integers" do
       text = "[main]
       one = 65
       "
       @settings.expects(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings[:one].should == 65
     end
 
     it "should support specifying all metadata (owner, group, mode) in the configuration file" do
       @settings.define_settings :section, :myfile => { :type => :file, :default => "/myfile", :desc => "a" }
 
       otherfile = make_absolute("/other/file")
       text = "[main]
       myfile = #{otherfile} {owner = service, group = service, mode = 644}
       "
       @settings.expects(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings[:myfile].should == otherfile
       @settings.metadata(:myfile).should == {:owner => "suser", :group => "sgroup", :mode => "644"}
     end
 
     it "should support specifying a single piece of metadata (owner, group, or mode) in the configuration file" do
       @settings.define_settings :section, :myfile => { :type => :file, :default => "/myfile", :desc => "a" }
 
       otherfile = make_absolute("/other/file")
       text = "[main]
       myfile = #{otherfile} {owner = service}
       "
       file = "/some/file"
       @settings.expects(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings[:myfile].should == otherfile
       @settings.metadata(:myfile).should == {:owner => "suser"}
     end
 
     it "should call hooks associated with values set in the configuration file" do
       values = []
       @settings.define_settings :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
 
       text = "[main]
       mysetting = setval
       "
       @settings.expects(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       values.should == ["setval"]
     end
 
     it "should not call the same hook for values set multiple times in the configuration file" do
       values = []
       @settings.define_settings :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
 
       text = "[user]
       mysetting = setval
       [main]
       mysetting = other
       "
       @settings.expects(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       values.should == ["setval"]
     end
 
     it "should pass the environment-specific value to the hook when one is available" do
       values = []
       @settings.define_settings :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
       @settings.define_settings :section, :environment => { :default => "yay", :desc => "a" }
       @settings.define_settings :section, :environments => { :default => "yay,foo", :desc => "a" }
 
       text = "[main]
       mysetting = setval
       [yay]
       mysetting = other
       "
       @settings.expects(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       values.should == ["other"]
     end
 
     it "should pass the interpolated value to the hook when one is available" do
       values = []
       @settings.define_settings :section, :base => {:default => "yay", :desc => "a", :hook => proc { |v| values << v }}
       @settings.define_settings :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
 
       text = "[main]
       mysetting = $base/setval
       "
       @settings.expects(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       values.should == ["yay/setval"]
     end
 
     it "should allow empty values" do
       @settings.define_settings :section, :myarg => { :default => "myfile", :desc => "a" }
 
       text = "[main]
       myarg =
       "
       @settings.stubs(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings[:myarg].should == ""
     end
 
     describe "and when reading a non-positive filetimeout value from the config file" do
       before do
         @settings.define_settings :foo, :filetimeout => { :default => 5, :desc => "eh" }
 
         somefile = "/some/file"
         text = "[main]
         filetimeout = -1
         "
         File.expects(:read).with(somefile).returns(text)
         File.expects(:expand_path).with(somefile).returns somefile
         @settings[:config] = somefile
       end
     end
 
   end
 
 
   describe "when there are multiple config files" do
     let(:main_config_text) { "[main]\none = main\ntwo = main2" }
     let(:user_config_text) { "[main]\none = user\n" }
     let(:seq) { sequence "config_file_sequence" }
 
     before do
       Puppet.features.stubs(:root?).returns(false)
       @settings = Puppet::Util::Settings.new
       @settings.define_settings(:section,
           { :one => { :default => "ONE", :desc => "a" },
             :two => { :default => "TWO", :desc => "b" }, })
       FileTest.expects(:exist?).with(MAIN_CONFIG_FILE_DEFAULT_LOCATION).returns(true).in_sequence(seq)
       @settings.expects(:read_file).with(MAIN_CONFIG_FILE_DEFAULT_LOCATION).returns(main_config_text).in_sequence(seq)
       FileTest.expects(:exist?).with(USER_CONFIG_FILE_DEFAULT_LOCATION).returns(true).in_sequence(seq)
       @settings.expects(:read_file).with(USER_CONFIG_FILE_DEFAULT_LOCATION).returns(user_config_text).in_sequence(seq)
     end
 
     it "should return values from the config file in the user's home dir before values set in the main configuration file" do
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings[:one].should == "user"
     end
 
     it "should return values from the main config file if they aren't overridden in the config file in the user's home dir" do
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings[:two].should == "main2"
     end
 
   end
 
   describe "when reparsing its configuration" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.define_settings :section,
           :config => { :type => :file, :default => "/test/file", :desc => "a" },
           :one => { :default => "ONE", :desc => "a" },
           :two => { :default => "$one TWO", :desc => "b" },
           :three => { :default => "$one $two THREE", :desc => "c" }
       FileTest.stubs(:exist?).with("/test/file").returns true
       FileTest.stubs(:exist?).with("/test/userconfigfile").returns false
       @settings.stubs(:user_config_file).returns("/test/userconfigfile")
     end
 
     it "should use a LoadedFile instance to determine if the file has changed" do
       file = mock 'file'
       Puppet::Util::LoadedFile.expects(:new).with("/test/file").returns file
 
       file.expects(:changed?)
 
       @settings.stubs(:parse)
-      @settings.reparse
+      @settings.reparse_config_files
     end
 
     it "should not create the LoadedFile instance and should not parse if the file does not exist" do
       FileTest.expects(:exist?).with("/test/file").returns false
       Puppet::Util::LoadedFile.expects(:new).never
 
-      @settings.expects(:parse).never
+      @settings.expects(:parse_config_files).never
 
-      @settings.reparse
+      @settings.reparse_config_files
     end
 
     it "should not reparse if the file has not changed" do
       file = mock 'file'
       Puppet::Util::LoadedFile.expects(:new).with("/test/file").returns file
 
       file.expects(:changed?).returns false
 
-      @settings.expects(:parse).never
+      @settings.expects(:parse_config_files).never
 
-      @settings.reparse
+      @settings.reparse_config_files
     end
 
     it "should reparse if the file has changed" do
       file = stub 'file', :file => "/test/file"
       Puppet::Util::LoadedFile.expects(:new).with("/test/file").returns file
 
       file.expects(:changed?).returns true
 
-      @settings.expects(:parse)
+      @settings.expects(:parse_config_files)
 
-      @settings.reparse
+      @settings.reparse_config_files
     end
 
     it "should replace in-memory values with on-file values" do
       # Init the value
       text = "[main]\none = disk-init\n"
       file = mock 'file'
       file.stubs(:changed?).returns(true)
       file.stubs(:file).returns("/test/file")
       @settings[:one] = "init"
       @settings.files = [file]
 
       # Now replace the value
       text = "[main]\none = disk-replace\n"
 
       # This is kinda ridiculous - the reason it parses twice is that
       # it goes to parse again when we ask for the value, because the
       # mock always says it should get reparsed.
       @settings.stubs(:read_file).returns(text)
-      @settings.reparse
+      @settings.reparse_config_files
       @settings[:one].should == "disk-replace"
     end
 
     it "should retain parameters set by cli when configuration files are reparsed" do
       @settings.handlearg("--one", "clival")
 
       text = "[main]\none = on-disk\n"
       @settings.stubs(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
 
       @settings[:one].should == "clival"
     end
 
     it "should remove in-memory values that are no longer set in the file" do
       # Init the value
       text = "[main]\none = disk-init\n"
       @settings.expects(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings[:one].should == "disk-init"
 
       # Now replace the value
       text = "[main]\ntwo = disk-replace\n"
       @settings.expects(:read_file).returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
 
       # The originally-overridden value should be replaced with the default
       @settings[:one].should == "ONE"
 
       # and we should now have the new value in memory
       @settings[:two].should == "disk-replace"
     end
 
     it "should retain in-memory values if the file has a syntax error" do
       # Init the value
       text = "[main]\none = initial-value\n"
       @settings.expects(:read_file).with("/test/file").returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
       @settings[:one].should == "initial-value"
 
       # Now replace the value with something bogus
       text = "[main]\nkenny = killed-by-what-follows\n1 is 2, blah blah florp\n"
       @settings.expects(:read_file).with("/test/file").returns(text)
-      @settings.parse
+      @settings.send(:parse_config_files)
 
       # The originally-overridden value should not be replaced with the default
       @settings[:one].should == "initial-value"
 
       # and we should not have the new value in memory
       @settings[:kenny].should be_nil
     end
   end
 
   it "should provide a method for creating a catalog of resources from its configuration" do
     Puppet::Util::Settings.new.should respond_to(:to_catalog)
   end
 
   describe "when creating a catalog" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.stubs(:service_user_available?).returns true
       @prefix = Puppet.features.posix? ? "" : "C:"
     end
 
     it "should add all file resources to the catalog if no sections have been specified" do
       @settings.define_settings :main,
           :maindir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a"},
           :seconddir => { :type => :directory, :default => @prefix+"/seconddir", :desc => "a"}
       @settings.define_settings :other,
           :otherdir => { :type => :directory, :default => @prefix+"/otherdir", :desc => "a" }
 
       catalog = @settings.to_catalog
 
       [@prefix+"/maindir", @prefix+"/seconddir", @prefix+"/otherdir"].each do |path|
         catalog.resource(:file, path).should be_instance_of(Puppet::Resource)
       end
     end
 
     it "should add only files in the specified sections if section names are provided" do
       @settings.define_settings :main, :maindir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a" }
       @settings.define_settings :other, :otherdir => { :type => :directory, :default => @prefix+"/otherdir", :desc => "a" }
       catalog = @settings.to_catalog(:main)
       catalog.resource(:file, @prefix+"/otherdir").should be_nil
       catalog.resource(:file, @prefix+"/maindir").should be_instance_of(Puppet::Resource)
     end
 
     it "should not try to add the same file twice" do
       @settings.define_settings :main, :maindir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a" }
       @settings.define_settings :other, :otherdir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a" }
       lambda { @settings.to_catalog }.should_not raise_error
     end
 
     it "should ignore files whose :to_resource method returns nil" do
       @settings.define_settings :main, :maindir => { :type => :directory, :default => @prefix+"/maindir", :desc => "a" }
       @settings.setting(:maindir).expects(:to_resource).returns nil
 
       Puppet::Resource::Catalog.any_instance.expects(:add_resource).never
       @settings.to_catalog
     end
 
     describe "on Microsoft Windows" do
       before :each do
         Puppet.features.stubs(:root?).returns true
         Puppet.features.stubs(:microsoft_windows?).returns true
 
         @settings.define_settings :foo,
             :mkusers => { :type => :boolean, :default => true, :desc => "e" },
             :user => { :default => "suser", :desc => "doc" },
             :group => { :default => "sgroup", :desc => "doc" }
         @settings.define_settings :other,
             :otherdir => { :type => :directory, :default => "/otherdir", :desc => "a", :owner => "service", :group => "service"}
 
         @catalog = @settings.to_catalog
       end
 
       it "it should not add users and groups to the catalog" do
         @catalog.resource(:user, "suser").should be_nil
         @catalog.resource(:group, "sgroup").should be_nil
       end
     end
 
     describe "when adding users and groups to the catalog" do
       before do
         Puppet.features.stubs(:root?).returns true
         Puppet.features.stubs(:microsoft_windows?).returns false
 
         @settings.define_settings :foo,
             :mkusers => { :type => :boolean, :default => true, :desc => "e" },
             :user => { :default => "suser", :desc => "doc" },
             :group => { :default => "sgroup", :desc => "doc" }
         @settings.define_settings :other, :otherdir => {:type => :directory, :default => "/otherdir", :desc => "a", :owner => "service", :group => "service"}
 
         @catalog = @settings.to_catalog
       end
 
       it "should add each specified user and group to the catalog if :mkusers is a valid setting, is enabled, and we're running as root" do
         @catalog.resource(:user, "suser").should be_instance_of(Puppet::Resource)
         @catalog.resource(:group, "sgroup").should be_instance_of(Puppet::Resource)
       end
 
       it "should only add users and groups to the catalog from specified sections" do
         @settings.define_settings :yay, :yaydir => { :type => :directory, :default => "/yaydir", :desc => "a", :owner => "service", :group => "service"}
         catalog = @settings.to_catalog(:other)
         catalog.resource(:user, "jane").should be_nil
         catalog.resource(:group, "billy").should be_nil
       end
 
       it "should not add users or groups to the catalog if :mkusers not running as root" do
         Puppet.features.stubs(:root?).returns false
 
         catalog = @settings.to_catalog
         catalog.resource(:user, "suser").should be_nil
         catalog.resource(:group, "sgroup").should be_nil
       end
 
       it "should not add users or groups to the catalog if :mkusers is not a valid setting" do
         Puppet.features.stubs(:root?).returns true
         settings = Puppet::Util::Settings.new
         settings.define_settings :other, :otherdir => {:type => :directory, :default => "/otherdir", :desc => "a", :owner => "service", :group => "service"}
 
         catalog = settings.to_catalog
         catalog.resource(:user, "suser").should be_nil
         catalog.resource(:group, "sgroup").should be_nil
       end
 
       it "should not add users or groups to the catalog if :mkusers is a valid setting but is disabled" do
         @settings[:mkusers] = false
 
         catalog = @settings.to_catalog
         catalog.resource(:user, "suser").should be_nil
         catalog.resource(:group, "sgroup").should be_nil
       end
 
       it "should not try to add users or groups to the catalog twice" do
         @settings.define_settings :yay, :yaydir => {:type => :directory, :default => "/yaydir", :desc => "a", :owner => "service", :group => "service"}
 
         # This would fail if users/groups were added twice
         lambda { @settings.to_catalog }.should_not raise_error
       end
 
       it "should set :ensure to :present on each created user and group" do
         @catalog.resource(:user, "suser")[:ensure].should == :present
         @catalog.resource(:group, "sgroup")[:ensure].should == :present
       end
 
       it "should set each created user's :gid to the service group" do
         @settings.to_catalog.resource(:user, "suser")[:gid].should == "sgroup"
       end
 
       it "should not attempt to manage the root user" do
         Puppet.features.stubs(:root?).returns true
         @settings.define_settings :foo, :foodir => {:type => :directory, :default => "/foodir", :desc => "a", :owner => "root", :group => "service"}
 
         @settings.to_catalog.resource(:user, "root").should be_nil
       end
     end
   end
 
   it "should be able to be converted to a manifest" do
     Puppet::Util::Settings.new.should respond_to(:to_manifest)
   end
 
   describe "when being converted to a manifest" do
     it "should produce a string with the code for each resource joined by two carriage returns" do
       @settings = Puppet::Util::Settings.new
       @settings.define_settings :main,
           :maindir => { :type => :directory, :default => "/maindir", :desc => "a"},
           :seconddir => { :type => :directory, :default => "/seconddir", :desc => "a"}
 
       main = stub 'main_resource', :ref => "File[/maindir]"
       main.expects(:to_manifest).returns "maindir"
       second = stub 'second_resource', :ref => "File[/seconddir]"
       second.expects(:to_manifest).returns "seconddir"
       @settings.setting(:maindir).expects(:to_resource).returns main
       @settings.setting(:seconddir).expects(:to_resource).returns second
 
       @settings.to_manifest.split("\n\n").sort.should == %w{maindir seconddir}
     end
   end
 
   describe "when using sections of the configuration to manage the local host" do
     before do
       @settings = Puppet::Util::Settings.new
       @settings.stubs(:service_user_available?).returns true
       @settings.define_settings :main, :noop => { :default => false, :desc => "", :type => :boolean }
       @settings.define_settings :main,
           :maindir => { :type => :directory, :default => "/maindir", :desc => "a" },
           :seconddir => { :type => :directory, :default => "/seconddir", :desc => "a"}
       @settings.define_settings :main, :user => { :default => "suser", :desc => "doc" }, :group => { :default => "sgroup", :desc => "doc" }
       @settings.define_settings :other, :otherdir => {:type => :directory, :default => "/otherdir", :desc => "a", :owner => "service", :group => "service", :mode => 0755}
       @settings.define_settings :third, :thirddir => { :type => :directory, :default => "/thirddir", :desc => "b"}
       @settings.define_settings :files, :myfile => {:type => :file, :default => "/myfile", :desc => "a", :mode => 0755}
     end
 
     it "should provide a method that writes files with the correct modes" do
       @settings.should respond_to(:write)
     end
 
     it "should provide a method that creates directories with the correct modes" do
       Puppet::Util::SUIDManager.expects(:asuser).with("suser", "sgroup").yields
       Dir.expects(:mkdir).with("/otherdir", 0755)
       @settings.mkdir(:otherdir)
     end
 
     it "should create a catalog with the specified sections" do
       @settings.expects(:to_catalog).with(:main, :other).returns Puppet::Resource::Catalog.new("foo")
       @settings.use(:main, :other)
     end
 
     it "should canonicalize the sections" do
       @settings.expects(:to_catalog).with(:main, :other).returns Puppet::Resource::Catalog.new("foo")
       @settings.use("main", "other")
     end
 
     it "should ignore sections that have already been used" do
       @settings.expects(:to_catalog).with(:main).returns Puppet::Resource::Catalog.new("foo")
       @settings.use(:main)
       @settings.expects(:to_catalog).with(:other).returns Puppet::Resource::Catalog.new("foo")
       @settings.use(:main, :other)
     end
 
     it "should ignore tags and schedules when creating files and directories"
 
     it "should be able to provide all of its parameters in a format compatible with GetOpt::Long" do
       pending "Not converted from test/unit yet"
     end
 
     it "should convert the created catalog to a RAL catalog" do
       @catalog = Puppet::Resource::Catalog.new("foo")
       @settings.expects(:to_catalog).with(:main).returns @catalog
 
       @catalog.expects(:to_ral).returns @catalog
       @settings.use(:main)
     end
 
     it "should specify that it is not managing a host catalog" do
       catalog = Puppet::Resource::Catalog.new("foo")
       catalog.expects(:apply)
       @settings.expects(:to_catalog).returns catalog
 
       catalog.stubs(:to_ral).returns catalog
 
       catalog.expects(:host_config=).with false
 
       @settings.use(:main)
     end
 
     it "should support a method for re-using all currently used sections" do
       @settings.expects(:to_catalog).with(:main, :third).times(2).returns Puppet::Resource::Catalog.new("foo")
 
       @settings.use(:main, :third)
       @settings.reuse
     end
 
     it "should fail with an appropriate message if any resources fail" do
       @catalog = Puppet::Resource::Catalog.new("foo")
       @catalog.stubs(:to_ral).returns @catalog
       @settings.expects(:to_catalog).returns @catalog
 
       @trans = mock("transaction")
       @catalog.expects(:apply).yields(@trans)
 
       @trans.expects(:any_failed?).returns(true)
 
       report = mock 'report'
       @trans.expects(:report).returns report
 
       log = mock 'log', :to_s => "My failure", :level => :err
       report.expects(:logs).returns [log]
 
       @settings.expects(:raise).with { |msg| msg.include?("My failure") }
       @settings.use(:whatever)
     end
   end
 
   describe "when dealing with printing configs" do
     before do
       @settings = Puppet::Util::Settings.new
       #these are the magic default values
       @settings.stubs(:value).with(:configprint).returns("")
       @settings.stubs(:value).with(:genconfig).returns(false)
       @settings.stubs(:value).with(:genmanifest).returns(false)
       @settings.stubs(:value).with(:environment).returns(nil)
     end
 
     describe "when checking print_config?" do
       it "should return false when the :configprint, :genconfig and :genmanifest are not set" do
         @settings.print_configs?.should be_false
       end
 
       it "should return true when :configprint has a value" do
         @settings.stubs(:value).with(:configprint).returns("something")
         @settings.print_configs?.should be_true
       end
 
       it "should return true when :genconfig has a value" do
         @settings.stubs(:value).with(:genconfig).returns(true)
         @settings.print_configs?.should be_true
       end
 
       it "should return true when :genmanifest has a value" do
         @settings.stubs(:value).with(:genmanifest).returns(true)
         @settings.print_configs?.should be_true
       end
     end
 
     describe "when printing configs" do
       describe "when :configprint has a value" do
         it "should call print_config_options" do
           @settings.stubs(:value).with(:configprint).returns("something")
           @settings.expects(:print_config_options)
           @settings.print_configs
         end
 
         it "should get the value of the option using the environment" do
           @settings.stubs(:value).with(:configprint).returns("something")
           @settings.stubs(:include?).with("something").returns(true)
           @settings.expects(:value).with(:environment).returns("env")
           @settings.expects(:value).with("something", "env").returns("foo")
           @settings.stubs(:puts).with("foo")
           @settings.print_configs
         end
 
         it "should print the value of the option" do
           @settings.stubs(:value).with(:configprint).returns("something")
           @settings.stubs(:include?).with("something").returns(true)
           @settings.stubs(:value).with("something", nil).returns("foo")
           @settings.expects(:puts).with("foo")
           @settings.print_configs
         end
 
         it "should print the value pairs if there are multiple options" do
           @settings.stubs(:value).with(:configprint).returns("bar,baz")
           @settings.stubs(:include?).with("bar").returns(true)
           @settings.stubs(:include?).with("baz").returns(true)
           @settings.stubs(:value).with("bar", nil).returns("foo")
           @settings.stubs(:value).with("baz", nil).returns("fud")
           @settings.expects(:puts).with("bar = foo")
           @settings.expects(:puts).with("baz = fud")
           @settings.print_configs
         end
 
         it "should print a whole bunch of stuff if :configprint = all"
 
         it "should return true after printing" do
           @settings.stubs(:value).with(:configprint).returns("something")
           @settings.stubs(:include?).with("something").returns(true)
           @settings.stubs(:value).with("something", nil).returns("foo")
           @settings.stubs(:puts).with("foo")
           @settings.print_configs.should be_true
         end
 
         it "should return false if a config param is not found" do
           @settings.stubs :puts
           @settings.stubs(:value).with(:configprint).returns("something")
           @settings.stubs(:include?).with("something").returns(false)
           @settings.print_configs.should be_false
         end
       end
 
       describe "when genconfig is true" do
         before do
           @settings.stubs :puts
         end
 
         it "should call to_config" do
           @settings.stubs(:value).with(:genconfig).returns(true)
           @settings.expects(:to_config)
           @settings.print_configs
         end
 
         it "should return true from print_configs" do
           @settings.stubs(:value).with(:genconfig).returns(true)
           @settings.stubs(:to_config)
           @settings.print_configs.should be_true
         end
       end
 
       describe "when genmanifest is true" do
         before do
           @settings.stubs :puts
         end
 
         it "should call to_config" do
           @settings.stubs(:value).with(:genmanifest).returns(true)
           @settings.expects(:to_manifest)
           @settings.print_configs
         end
 
         it "should return true from print_configs" do
           @settings.stubs(:value).with(:genmanifest).returns(true)
           @settings.stubs(:to_manifest)
           @settings.print_configs.should be_true
         end
       end
     end
   end
 
   describe "when determining if the service user is available" do
     it "should return false if there is no user setting" do
       Puppet::Util::Settings.new.should_not be_service_user_available
     end
 
     it "should return false if the user provider says the user is missing" do
       settings = Puppet::Util::Settings.new
       settings.define_settings :main, :user => { :default => "foo", :desc => "doc" }
 
       user = mock 'user'
       user.expects(:exists?).returns false
 
       Puppet::Type.type(:user).expects(:new).with { |args| args[:name] == "foo" }.returns user
 
       settings.should_not be_service_user_available
     end
 
     it "should return true if the user provider says the user is present" do
       settings = Puppet::Util::Settings.new
       settings.define_settings :main, :user => { :default => "foo", :desc => "doc" }
 
       user = mock 'user'
       user.expects(:exists?).returns true
 
       Puppet::Type.type(:user).expects(:new).with { |args| args[:name] == "foo" }.returns user
 
       settings.should be_service_user_available
     end
 
     it "should cache the result"
   end
 
   describe "#writesub" do
     it "should only pass valid arguments to File.open" do
       settings = Puppet::Util::Settings.new
       settings.stubs(:get_config_file_default).with(:privatekeydir).returns(OpenStruct.new(:mode => "750"))
 
       File.expects(:open).with("/path/to/keydir", "w", 750).returns true
       settings.writesub(:privatekeydir, "/path/to/keydir")
     end
   end
+
+
+  describe "when dealing with command-line options" do
+    let(:settings) { Puppet::Util::Settings.new }
+
+    it "should get options from Puppet.settings.optparse_addargs" do
+      settings.expects(:optparse_addargs).returns([])
+
+      settings.send(:parse_global_options, [])
+    end
+
+    it "should add options to OptionParser" do
+      settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option", :NONE]])
+      settings.expects(:handlearg).with("--option", true)
+      settings.send(:parse_global_options, ["--option"])
+    end
+
+    it "should not die if it sees an unrecognized option, because the app/face may handle it later" do
+      expect { settings.send(:parse_global_options, ["--topuppet", "value"]) } .to_not raise_error
+    end
+
+    it "should not pass an unrecognized option to handleargs" do
+      settings.expects(:handlearg).with("--topuppet", "value").never
+      expect { settings.send(:parse_global_options, ["--topuppet", "value"]) } .to_not raise_error
+    end
+
+    it "should pass valid puppet settings options to handlearg even if they appear after an unrecognized option" do
+      settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option", :NONE]])
+      settings.expects(:handlearg).with("--option", true)
+      settings.send(:parse_global_options, ["--invalidoption", "--option"])
+    end
+
+    it "should transform boolean option to normal form" do
+      Puppet::Util::Settings.clean_opt("--[no-]option", true).should == ["--option", true]
+    end
+
+    it "should transform boolean option to no- form" do
+      Puppet::Util::Settings.clean_opt("--[no-]option", false).should == ["--no-option", false]
+    end
+  end
+
+
 end