diff --git a/lib/puppet/provider/service/launchd.rb b/lib/puppet/provider/service/launchd.rb
index 07c549a8b..9d813bd5a 100644
--- a/lib/puppet/provider/service/launchd.rb
+++ b/lib/puppet/provider/service/launchd.rb
@@ -1,266 +1,266 @@
 require 'facter/util/plist'
 
 Puppet::Type.type(:service).provide :launchd, :parent => :base do
   desc "launchd service management framework.
 
   This provider manages jobs with launchd, which is the default service framework for
   Mac OS X and is potentially available for use on other platforms.
 
   See:
   
   * http://developer.apple.com/macosx/launchd.html
   * http://launchd.macosforge.org/
 
   This provider reads plists out of the following directories:
   
   * /System/Library/LaunchDaemons
   * /System/Library/LaunchAgents
   * /Library/LaunchDaemons
   * /Library/LaunchAgents
 
   ...and builds up a list of services based upon each plist's \"Label\" entry.
 
   This provider supports:
   
   * ensure => running/stopped,
   * enable => true/false
   * status
   * restart
 
   Here is how the Puppet states correspond to launchd states:
   
   * stopped --- job unloaded
   * started --- job loaded
   * enabled --- 'Disable' removed from job plist file
   * disabled --- 'Disable' added to job plist file
 
   Note that this allows you to do something launchctl can't do, which is to
   be in a state of \"stopped/enabled\ or \"running/disabled\".
 
   "
 
   commands :launchctl => "/bin/launchctl"
   commands :sw_vers => "/usr/bin/sw_vers"
   commands :plutil => "/usr/bin/plutil"
 
   defaultfor :operatingsystem => :darwin
   confine :operatingsystem => :darwin
 
   has_feature :enableable
 
   Launchd_Paths = ["/Library/LaunchAgents",
     "/Library/LaunchDaemons",
     "/System/Library/LaunchAgents",
     "/System/Library/LaunchDaemons",]
 
   Launchd_Overrides = "/var/db/launchd.db/com.apple.launchd/overrides.plist"
 
 
   # Read a plist, whether its format is XML or in Apple's "binary1"
   # format.
   def self.read_plist(path)
     Plist::parse_xml(plutil('-convert', 'xml1', '-o', '/dev/stdout', path))
   end
 
   # returns a label => path map for either all jobs, or just a single
   # job if the label is specified
   def self.jobsearch(label=nil)
     label_to_path_map = {}
     Launchd_Paths.each do |path|
       if FileTest.exists?(path)
         Dir.entries(path).each do |f|
           next if f =~ /^\..*$/
           next if FileTest.directory?(f)
           fullpath = File.join(path, f)
           if FileTest.file?(fullpath) and job = read_plist(fullpath) and job.has_key?("Label")
             if job["Label"] == label
               return { label => fullpath }
             else
               label_to_path_map[job["Label"]] = fullpath
             end
           end
         end
       end
     end
 
     # if we didn't find the job above and we should have, error.
     raise Puppet::Error.new("Unable to find launchd plist for job: #{label}") if label
     # if returning all jobs
     label_to_path_map
   end
 
 
   def self.instances
     jobs = self.jobsearch
     jobs.keys.collect do |job|
       new(:name => job, :provider => :launchd, :path => jobs[job])
     end
   end
 
 
   def self.get_macosx_version_major
     return @macosx_version_major if defined?(@macosx_version_major)
     begin
       # Make sure we've loaded all of the facts
       Facter.loadfacts
 
       if Facter.value(:macosx_productversion_major)
         product_version_major = Facter.value(:macosx_productversion_major)
       else
         # TODO: remove this code chunk once we require Facter 1.5.5 or higher.
         Puppet.warning("DEPRECATION WARNING: Future versions of the launchd provider will require Facter 1.5.5 or newer.")
         product_version = Facter.value(:macosx_productversion)
         fail("Could not determine OS X version from Facter") if product_version.nil?
         product_version_major = product_version.scan(/(\d+)\.(\d+)./).join(".")
       end
       fail("#{product_version_major} is not supported by the launchd provider") if %w{10.0 10.1 10.2 10.3}.include?(product_version_major)
       @macosx_version_major = product_version_major
       return @macosx_version_major
     rescue Puppet::ExecutionFailure => detail
       fail("Could not determine OS X version: #{detail}")
     end
   end
 
 
   # finds the path for a given label and returns the path and parsed plist
   # as an array of [path, plist]. Note plist is really a Hash here.
   def plist_from_label(label)
     job = self.class.jobsearch(label)
     job_path = job[label]
     if FileTest.file?(job_path)
       job_plist = self.class.read_plist(job_path)
     else
       raise Puppet::Error.new("Unable to parse launchd plist at path: #{job_path}")
     end
     [job_path, job_plist]
   end
 
 
   def status
     # launchctl list <jobname> exits zero if the job is loaded
     # and non-zero if it isn't. Simple way to check... but is only
     # available on OS X 10.5 unfortunately, so we grab the whole list
     # and check if our resource is included. The output formats differ
     # between 10.4 and 10.5, thus the necessity for splitting
     begin
       output = launchctl :list
       raise Puppet::Error.new("launchctl list failed to return any data.") if output.nil?
       output.split("\n").each do |j|
         return :running if j.split(/\s/).last == resource[:name]
       end
       return :stopped
     rescue Puppet::ExecutionFailure
       raise Puppet::Error.new("Unable to determine status of #{resource[:name]}")
     end
   end
 
 
   # start the service. To get to a state of running/enabled, we need to
   # conditionally enable at load, then disable by modifying the plist file
   # directly.
   def start
     job_path, job_plist = plist_from_label(resource[:name])
     did_enable_job = false
     cmds = []
     cmds << :launchctl << :load
     if self.enabled? == :false  # launchctl won't load disabled jobs
       cmds << "-w"
       did_enable_job = true
     end
     cmds << job_path
     begin
       execute(cmds)
     rescue Puppet::ExecutionFailure
       raise Puppet::Error.new("Unable to start service: #{resource[:name]} at path: #{job_path}")
     end
     # As load -w clears the Disabled flag, we need to add it in after
     self.disable if did_enable_job and resource[:enable] == :false
   end
 
 
   def stop
     job_path, job_plist = plist_from_label(resource[:name])
     did_disable_job = false
     cmds = []
     cmds << :launchctl << :unload
     if self.enabled? == :true # keepalive jobs can't be stopped without disabling
       cmds << "-w"
       did_disable_job = true
     end
     cmds << job_path
     begin
       execute(cmds)
     rescue Puppet::ExecutionFailure
       raise Puppet::Error.new("Unable to stop service: #{resource[:name]} at path: #{job_path}")
     end
     # As unload -w sets the Disabled flag, we need to add it in after
     self.enable if did_disable_job and resource[:enable] == :true
   end
 
 
   # launchd jobs are enabled by default. They are only disabled if the key
   # "Disabled" is set to true, but it can also be set to false to enable it.
   # In 10.6, the Disabled key in the job plist is consulted, but only if there
   # is no entry in the global overrides plist.
   # We need to draw a distinction between undefined, true and false for both
   # locations where the Disabled flag can be defined.
   def enabled?
     job_plist_disabled = nil
     overrides_disabled = nil
 
     job_path, job_plist = plist_from_label(resource[:name])
     job_plist_disabled = job_plist["Disabled"] if job_plist.has_key?("Disabled")
 
-    if self.class.get_macosx_version_major == "10.6":
+    if self.class.get_macosx_version_major == "10.6"
       if FileTest.file?(Launchd_Overrides) and overrides = self.class.read_plist(Launchd_Overrides)
         if overrides.has_key?(resource[:name])
           overrides_disabled = overrides[resource[:name]]["Disabled"] if overrides[resource[:name]].has_key?("Disabled")
         end
       end
     end
 
     if overrides_disabled.nil?
       if job_plist_disabled.nil? or job_plist_disabled == false
         return :true
       end
     elsif overrides_disabled == false
       return :true
     end
     :false
   end
 
 
   # enable and disable are a bit hacky. We write out the plist with the appropriate value
   # rather than dealing with launchctl as it is unable to change the Disabled flag
   # without actually loading/unloading the job.
   # In 10.6 we need to write out a disabled key to the global overrides plist, in earlier
   # versions this is stored in the job plist itself.
   def enable
     if self.class.get_macosx_version_major == "10.6"
       overrides = self.class.read_plist(Launchd_Overrides)
       overrides[resource[:name]] = { "Disabled" => false }
       Plist::Emit.save_plist(overrides, Launchd_Overrides)
     else
       job_path, job_plist = plist_from_label(resource[:name])
       if self.enabled? == :false
         job_plist.delete("Disabled")
         Plist::Emit.save_plist(job_plist, job_path)
       end
     end
   end
 
 
   def disable
     if self.class.get_macosx_version_major == "10.6"
       overrides = self.class.read_plist(Launchd_Overrides)
       overrides[resource[:name]] = { "Disabled" => true }
       Plist::Emit.save_plist(overrides, Launchd_Overrides)
     else
       job_path, job_plist = plist_from_label(resource[:name])
       job_plist["Disabled"] = true
       Plist::Emit.save_plist(job_plist, job_path)
     end
   end
 
 
 end
diff --git a/lib/puppet/rails.rb b/lib/puppet/rails.rb
index 74805bb6f..f74e63f20 100644
--- a/lib/puppet/rails.rb
+++ b/lib/puppet/rails.rb
@@ -1,132 +1,132 @@
 # Load the appropriate libraries, or set a class indicating they aren't available
 
 require 'facter'
 require 'puppet'
 require 'logger'
 
 module Puppet::Rails
   TIME_DEBUG = true
 
   def self.connect
     # This global init does not work for testing, because we remove
     # the state dir on every test.
     return if ActiveRecord::Base.connected?
 
     Puppet.settings.use(:main, :rails, :master)
 
     ActiveRecord::Base.logger = Logger.new(Puppet[:railslog])
     begin
       loglevel = Logger.const_get(Puppet[:rails_loglevel].upcase)
       ActiveRecord::Base.logger.level = loglevel
     rescue => detail
       Puppet.warning "'#{Puppet[:rails_loglevel]}' is not a valid Rails log level; using debug"
       ActiveRecord::Base.logger.level = Logger::DEBUG
     end
 
     # As of ActiveRecord 2.2 allow_concurrency has been deprecated and no longer has any effect.
     ActiveRecord::Base.allow_concurrency = true if Puppet::Util.activerecord_version < 2.2
 
     ActiveRecord::Base.verify_active_connections!
 
     begin
       args = database_arguments
       Puppet.info "Connecting to #{args[:adapter]} database: #{args[:database]}"
       ActiveRecord::Base.establish_connection(args)
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       raise Puppet::Error, "Could not connect to database: #{detail}"
     end
   end
 
   # The arguments for initializing the database connection.
   def self.database_arguments
     adapter = Puppet[:dbadapter]
 
     args = {:adapter => adapter, :log_level => Puppet[:rails_loglevel]}
 
     case adapter
     when "sqlite3"
       args[:database] = Puppet[:dblocation]
     when "mysql", "postgresql"
       args[:host]     = Puppet[:dbserver] unless Puppet[:dbserver].to_s.empty?
       args[:port]     = Puppet[:dbport] unless Puppet[:dbport].to_s.empty?
       args[:username] = Puppet[:dbuser] unless Puppet[:dbuser].to_s.empty?
       args[:password] = Puppet[:dbpassword] unless Puppet[:dbpassword].to_s.empty?
       args[:pool]     = Puppet[:dbconnections].to_i unless Puppet[:dbconnections].to_i <= 0
       args[:database] = Puppet[:dbname]
       args[:reconnect]= true
 
       socket          = Puppet[:dbsocket]
       args[:socket]   = socket unless socket.to_s.empty?
-    when "oracle_enhanced":
+    when "oracle_enhanced"
       args[:database] = Puppet[:dbname] unless Puppet[:dbname].to_s.empty?
       args[:username] = Puppet[:dbuser] unless Puppet[:dbuser].to_s.empty?
       args[:password] = Puppet[:dbpassword] unless Puppet[:dbpassword].to_s.empty?
       args[:pool]     = Puppet[:dbconnections].to_i unless Puppet[:dbconnections].to_i <= 0
     else
       raise ArgumentError, "Invalid db adapter #{adapter}"
     end
     args
   end
 
   # Set up our database connection.  It'd be nice to have a "use" system
   # that could make callbacks.
   def self.init
     raise Puppet::DevError, "No activerecord, cannot init Puppet::Rails" unless Puppet.features.rails?
 
     connect
 
     unless ActiveRecord::Base.connection.tables.include?("resources")
       require 'puppet/rails/database/schema'
       Puppet::Rails::Schema.init
     end
 
     migrate if Puppet[:dbmigrate]
   end
 
   # Migrate to the latest db schema.
   def self.migrate
     dbdir = nil
     $LOAD_PATH.each { |d|
       tmp = File.join(d, "puppet/rails/database")
       if FileTest.directory?(tmp)
         dbdir = tmp
         break
       end
     }
 
     raise Puppet::Error, "Could not find Puppet::Rails database dir" unless dbdir
 
     raise Puppet::Error, "Database has problems, can't migrate." unless ActiveRecord::Base.connection.tables.include?("resources")
 
     Puppet.notice "Migrating"
 
     begin
       ActiveRecord::Migrator.migrate(dbdir)
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       raise Puppet::Error, "Could not migrate database: #{detail}"
     end
   end
 
   # Tear down the database.  Mostly only used during testing.
   def self.teardown
     raise Puppet::DevError, "No activerecord, cannot init Puppet::Rails" unless Puppet.features.rails?
 
     Puppet.settings.use(:master, :rails)
 
     begin
       ActiveRecord::Base.establish_connection(database_arguments)
     rescue => detail
       puts detail.backtrace if Puppet[:trace]
       raise Puppet::Error, "Could not connect to database: #{detail}"
     end
 
     ActiveRecord::Base.connection.tables.each do |t|
       ActiveRecord::Base.connection.drop_table t
     end
   end
 end
 
 require 'puppet/rails/host' if Puppet.features.rails?