puppet 0.25.5 → 2.6.0

data/ext/pure_ruby_dsl/dsl_test.rb

@@ -0,0 +1,7 @@
+hostclass "foobar" do
+  notify "this is a test", "loglevel" => "warning"
+end
+
+node "default" do
+  acquire "foobar"
+end

data/ext/regexp_nodes/regexp_nodes.rb

@@ -2,7 +2,7 @@
 
 # = Synopsis
 # This is an external node classifier script, after
-# http://puppetlabs.com/trac/puppet/wiki/ExternalNodes
+# http://docs.puppetlabs.com/guides/external_nodes.html
 #
 # = Usage
 # regexp_nodes.rb <host>
@@ -54,158 +54,158 @@ $LOG.level = Logger::DEBUG
 WORKINGDIR = Dir.pwd
 
 # This class holds all the methods for creating and accessing the properties
-# of an external node. There are really only two public methods: initialize()
-# and a special version of to_yaml()
+# of an external node. There are really only two public methods: initialize
+# and a special version of to_yaml
 
 class ExternalNode
-    # Make these instance variables get/set-able with eponymous methods
-    attr_accessor :classes, :parameters, :hostname
-
-    # initialize() takes three arguments:
-    # hostname:: usually passed in via ARGV[0] but it could be anything
-    # classdir:: directory under WORKINGDIR to look for files named after
-    # classes
-    # parameterdir:: directory under WORKINGDIR to look for directories to set
-    # parameters
-    def initialize(hostname, classdir = 'classes/', parameterdir = 'parameters/')
-        # instance variables that contain the lists of classes and parameters
-        @hostname
-        @classes = Set.new ["baseclass"]
-        @parameters = Hash.new("unknown")    # sets a default value of "unknown"
-
-        self.parse_argv(hostname)
-        self.match_classes(WORKINGDIR + "/" + classdir)
-        self.match_parameters(WORKINGDIR + "/" + parameterdir)
+  # Make these instance variables get/set-able with eponymous methods
+  attr_accessor :classes, :parameters, :hostname
+
+  # initialize takes three arguments:
+  # hostname:: usually passed in via ARGV[0] but it could be anything
+  # classdir:: directory under WORKINGDIR to look for files named after
+  # classes
+  # parameterdir:: directory under WORKINGDIR to look for directories to set
+  # parameters
+  def initialize(hostname, classdir = 'classes/', parameterdir = 'parameters/')
+    # instance variables that contain the lists of classes and parameters
+    @hostname
+    @classes = Set.new ["baseclass"]
+    @parameters = Hash.new("unknown")    # sets a default value of "unknown"
+
+    self.parse_argv(hostname)
+    self.match_classes(WORKINGDIR + "/#{classdir}")
+    self.match_parameters(WORKINGDIR + "/#{parameterdir}")
+  end
+
+  # private method called by initialize which sanity-checks our hostname.
+  # good candidate for overriding in a subclass if you need different checks
+  def parse_argv(hostname)
+    if hostname =~ /^([-\w]+?)\.([-\w\.]+)/    # non-greedy up to the first . is hostname
+      @hostname = $1
+    elsif hostname =~ /^([-\w]+)$/       # sometimes puppet's @name is just a name
+      @hostname = hostname
+    else
+      $LOG.fatal("didn't receive parsable hostname, got: [#{hostname}]")
+      exit(1)
     end
-
-    # private method called by initialize() which sanity-checks our hostname.
-    # good candidate for overriding in a subclass if you need different checks
-    def parse_argv(hostname)
-        if hostname =~ /^([-\w]+?)\.([-\w\.]+)/    # non-greedy up to the first . is hostname
-            @hostname = $1
-        elsif hostname =~ /^([-\w]+)$/       # sometimes puppet's @name is just a name
-            @hostname = hostname
-        else
-            $LOG.fatal("didn't receive parsable hostname, got: [#{hostname}]")
-            exit(1)
-        end
+  end
+
+  # to_yaml massages a copy of the object and outputs clean yaml so we don't
+  # feed weird things back to puppet []<
+  def to_yaml
+    classes = self.classes.to_a
+    if self.parameters.empty? # otherwise to_yaml prints "parameters: {}"
+      parameters = nil
+    else
+      parameters = self.parameters
     end
-
-    # to_yaml massages a copy of the object and outputs clean yaml so we don't
-    # feed weird things back to puppet []<
-    def to_yaml
-        classes = self.classes.to_a
-        if self.parameters.empty? # otherwise to_yaml prints "parameters: {}"
-             parameters = nil
-        else
-             parameters = self.parameters
-        end
-        ({ 'classes' => classes, 'parameters' => parameters}).to_yaml
+    ({ 'classes' => classes, 'parameters' => parameters}).to_yaml
+  end
+
+  # Private method that expects an absolute path to a file and a string to
+  # match - it returns true if the string was matched by any of the lines in
+  # the file
+  def matched_in_patternfile?(filepath, matchthis)
+
+    patternlist = []
+
+    begin
+      open(filepath).each { |l|
+        pattern = %r{#{l.chomp!}}
+        patternlist <<  pattern
+        $LOG.debug("appending [#{pattern}] to patternlist for [#{filepath}]")
+      }
+    rescue Exception
+      $LOG.fatal("Problem reading #{filepath}: #{$ERROR_INFO}")
+      exit(1)
     end
 
-    # Private method that expects an absolute path to a file and a string to
-    # match - it returns true if the string was matched by any of the lines in
-    # the file
-    def matched_in_patternfile?(filepath, matchthis)
-
-        patternlist = []
-
-        begin
-            open(filepath).each { |l|
-                pattern = %r{#{l.chomp!}}
-                patternlist <<  pattern
-                $LOG.debug("appending [#{pattern}] to patternlist for [#{filepath}]")
-            }
-        rescue Exception
-            $LOG.fatal("Problem reading #{filepath}: #{$!}")
-            exit(1)
-        end
+    $LOG.debug("list of patterns for #{filepath}: #{patternlist}")
 
-        $LOG.debug("list of patterns for #{filepath}: #{patternlist}")
+    if matchthis =~ Regexp.union(patternlist)
+      $LOG.debug("matched #{$~.to_s} in #{matchthis}, returning true")
+      return true
 
-        if matchthis =~ Regexp.union(patternlist)
-            $LOG.debug("matched #{$~.to_s} in #{matchthis}, returning true")
-            return true
+    else    # hostname didn't match anything in patternlist
+      $LOG.debug("#{matchthis} unmatched, returning false")
+      return nil
+    end
 
-        else    # hostname didn't match anything in patternlist
-            $LOG.debug("#{matchthis} unmatched, returning false")
-            return nil
+  end
+
+  # private method - takes a path to look for files, iterates through all
+  # readable, regular files it finds, and matches this instance's @hostname
+  # against each line; if any match, the class will be set for this node.
+  def match_classes(fullpath)
+    Dir.foreach(fullpath) do |patternfile|
+      filepath = "#{fullpath}/#{patternfile}"
+      next unless File.file?(filepath) and
+        File.readable?(filepath)
+      $LOG.debug("Attempting to match [#{@hostname}] in [#{filepath}]")
+      if matched_in_patternfile?(filepath,@hostname)
+        @classes << patternfile.to_s
+        $LOG.debug("Appended #{patternfile.to_s} to classes instance variable")
+      end
+    end
+  end
+
+  # Parameters are handled slightly differently; we make another level of
+  # directories to get the parameter name, then use the names of the files
+  # contained in there for the values of those parameters.
+  #
+  # ex: cat /var/lib/puppet/bin/parameters/environment/production
+  # ^prodweb
+  # would set parameters["environment"] = "production" for prodweb001
+  def match_parameters(fullpath)
+    Dir.foreach(fullpath) do |parametername|
+
+      filepath = "#{fullpath}/#{parametername}"
+      next if File.basename(filepath) =~ /^\./     # skip over dotfiles
+
+      next unless File.directory?(filepath) and
+        File.readable?(filepath)        # skip over non-directories
+
+      $LOG.debug "Considering contents of #{filepath}"
+
+      Dir.foreach("#{filepath}") do |patternfile|
+        secondlevel = "#{filepath}/#{patternfile}"
+        $LOG.debug "Found parameters patternfile at #{secondlevel}"
+        next unless File.file?(secondlevel) and
+          File.readable?(secondlevel)
+        $LOG.debug("Attempting to match [#{@hostname}] in [#{secondlevel}]")
+        if matched_in_patternfile?(secondlevel, @hostname)
+          @parameters[ parametername.to_s ] = patternfile.to_s
+          $LOG.debug("Set @parameters[#{parametername.to_s}] = #{patternfile.to_s}")
         end
+      end
+    end
+  end
 
-    end # def
-
-    # private method - takes a path to look for files, iterates through all
-    # readable, regular files it finds, and matches this instance's @hostname
-    # against each line; if any match, the class will be set for this node.
-    def match_classes(fullpath)
-        Dir.foreach(fullpath) do |patternfile|
-            filepath = "#{fullpath}/#{patternfile}"
-            next unless File.file?(filepath) and
-                File.readable?(filepath)
-            $LOG.debug("Attempting to match [#{@hostname}] in [#{filepath}]")
-            if matched_in_patternfile?(filepath,@hostname)
-                @classes << patternfile.to_s
-                $LOG.debug("Appended #{patternfile.to_s} to classes instance variable")
-            end # if
-        end # Dir.foreach
-    end # def
-
-    # Parameters are handled slightly differently; we make another level of
-    # directories to get the parameter name, then use the names of the files
-    # contained in there for the values of those parameters.
-    #
-    # ex: cat /var/lib/puppet/bin/parameters/environment/production
-    # ^prodweb
-    # would set parameters["environment"] = "production" for prodweb001
-    def match_parameters(fullpath)
-        Dir.foreach(fullpath) do |parametername|
-
-            filepath = "#{fullpath}/#{parametername}"
-            next if File.basename(filepath) =~ /^\./     # skip over dotfiles
-
-            next unless File.directory?(filepath) and
-                        File.readable?(filepath)        # skip over non-directories
-
-            $LOG.debug "Considering contents of #{filepath}"
-
-            Dir.foreach("#{filepath}") do |patternfile|
-                secondlevel = "#{filepath}/#{patternfile}"
-                $LOG.debug "Found parameters patternfile at #{secondlevel}"
-                next unless File.file?(secondlevel) and
-                    File.readable?(secondlevel)
-                $LOG.debug("Attempting to match [#{@hostname}] in [#{secondlevel}]")
-                if matched_in_patternfile?(secondlevel, @hostname)
-                     @parameters[ parametername.to_s ] = patternfile.to_s
-                     $LOG.debug("Set @parameters[#{parametername.to_s}] = #{patternfile.to_s}")
-                end # if
-            end # Dir.foreach #{filepath}
-        end # Dir.foreach #{fullpath}
-    end # def
-
-end # Class
+end
 
 # Logic for local hacks that don't fit neatly into the autoloading model can
 # happen as we initialize a subclass
 class MyExternalNode < ExternalNode
 
-    def initialize(hostname, classdir = 'classes/', parameterdir = 'parameters/')
+  def initialize(hostname, classdir = 'classes/', parameterdir = 'parameters/')
 
-        super
+    super
 
-        # Set "hostclass" parameter based on hostname,
-        # stripped of leading environment prefix and numeric suffix
-        if @hostname =~ /^(\w*?)-?(\D+)(\d{2,3})$/
-            match = Regexp.last_match
+    # Set "hostclass" parameter based on hostname,
+    # stripped of leading environment prefix and numeric suffix
+    if @hostname =~ /^(\w*?)-?(\D+)(\d{2,3})$/
+      match = Regexp.last_match
 
-            hostclass = match[2]
-            $LOG.debug("matched hostclass #{hostclass}")
-            @parameters[ "hostclass" ] = hostclass
-        else
-            $LOG.debug("hostclass couldn't figure out class from #{@hostname}")
-        end # if
-    end # def
+      hostclass = match[2]
+      $LOG.debug("matched hostclass #{hostclass}")
+      @parameters[ "hostclass" ] = hostclass
+    else
+      $LOG.debug("hostclass couldn't figure out class from #{@hostname}")
+    end
+  end
 
-end # Class
+end
 
 
 # Here we begin actual execution by calling methods defined above

data/ext/yaml_nodes.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/ruby
+#
+# = Synopsis
+#
+# Use YAML files to provide external node support.
+#
+# = Usage
+#
+#   yaml-nodes <host>
+#
+# = Description
+#
+# This is a simple example external node script.  It allows you to maintain your
+# node information in yaml files, and it will find a given node's file and produce
+# it on stdout.  It has simple inheritance, in that a node can specify a parent
+# node, and the node will inherit that parent's classes and parameters.
+#
+# = Options
+#
+# help::
+#   Print this help message
+#
+# yamldir::
+#   Specify where the yaml is found.  Defaults to 'yaml' in the current directory.
+#
+# = Author
+#
+# Luke Kanies
+#
+# = Copyright
+#
+# Copyright (c) 2009 Puppet Labs, Inc.
+# Licensed under the GPL2
+
+require 'yaml'
+require 'optparse'
+
+BASEDIR = Dir.chdir(File.dirname(__FILE__) + "/..") { Dir.getwd }
+
+options = {:yamldir => File.join(BASEDIR, "yaml")}
+OptionParser.new do |opts|
+  opts.banner = "Usage: yaml-nodes [options] <host>"
+
+  opts.on("-y dir", "--yamldir dir", "Specify the directory with the YAML files") do |arg|
+    raise "YAML directory #{arg} does not exist or is not a directory" unless FileTest.directory?(arg)
+    options[:yamldir] = arg
+  end
+
+  opts.on("-h", "--help", "Print this help") do
+    puts opts.help
+    exit(0)
+  end
+end.parse!
+
+# Read in a pure yaml representation of our node.
+def read_node(node)
+  nodefile = File.join(YAMLDIR, "#{node}.yaml")
+  if FileTest.exist?(nodefile)
+    return YAML.load_file(nodefile)
+  else
+    raise "Could not find information for #{node}"
+  end
+end
+
+node = ARGV[0]
+
+info = read_node(node)
+
+# Iterate over any provided parents, merging in there information.
+parents_seen = []
+while parent = info["parent"]
+  raise "Found inheritance loop with parent #{parent}" if parents_seen.include?(parent)
+
+  parents_seen << parent
+
+  info.delete("parent")
+
+  parent_info = read_node(parent)
+
+  # Include any parent classes in our list.
+  if pclasses = parent_info["classes"]
+    info["classes"] += pclasses
+    info["classes"].uniq!
+  end
+
+  # And inherit parameters from our parent, while preferring our own values.
+  if pparams = parent_info["parameters"]
+    # When using Hash#merge, the hash being merged in wins, and we
+    # want the subnode parameters to be the parent node parameters.
+    info["parameters"] = pparams.merge(info["parameters"])
+  end
+
+  # Copy over any parent node name.
+  if pparent = parent_info["parent"]
+    info["parent"] = pparent
+  end
+end
+
+puts YAML.dump(info)

data/install.rb

@@ -22,7 +22,7 @@
 # 2) Build Rdoc documentation from all files in bin/ (excluding .bat and .cmd),
 #    all .rb files in lib/, ./README, ./ChangeLog, and ./Install.
 # 3) Build ri documentation from all files in bin/ (excluding .bat and .cmd),
-#    and all .rb files in lib/. This is disabled by default on Win32.
+#    and all .rb files in lib/. This is disabled by default on Microsoft Windows.
 # 4) Install commands from bin/ into the Ruby bin directory. On Windows, if a
 #    if a corresponding batch file (.bat or .cmd) exists in the bin directory,
 #    it will be copied over as well. Otherwise, a batch file (always .bat) will
@@ -46,23 +46,23 @@ require 'optparse'
 require 'ostruct'
 
 begin
-    require 'rdoc/rdoc'
-    $haverdoc = true
+  require 'rdoc/rdoc'
+  $haverdoc = true
 rescue LoadError
-    puts "Missing rdoc; skipping documentation"
-    $haverdoc = false
+  puts "Missing rdoc; skipping documentation"
+  $haverdoc = false
 end
 
 begin
-    if $haverdoc
-       rst2man = %x{which rst2man.py}
-       $haveman = true
-    else
-       $haveman = false
-    end
-rescue
-    puts "Missing rst2man; skipping man page creation"
+  if $haverdoc
+    rst2man = %x{which rst2man.py}
+    $haveman = true
+  else
     $haveman = false
+  end
+rescue
+  puts "Missing rst2man; skipping man page creation"
+  $haveman = false
 end
 
 PREREQS = %w{openssl facter xmlrpc/client xmlrpc/server cgi}
@@ -71,20 +71,20 @@ MIN_FACTER_VERSION = 1.5
 InstallOptions = OpenStruct.new
 
 def glob(list)
-    g = list.map { |i| Dir.glob(i) }
-    g.flatten!
-    g.compact!
-    g.reject! { |e| e =~ /\.svn/ }
-    g
+  g = list.map { |i| Dir.glob(i) }
+  g.flatten!
+  g.compact!
+  g.reject! { |e| e =~ /\.svn/ }
+  g
 end
 
 # Set these values to what you want installed.
 sbins = glob(%w{sbin/*})
 bins  = glob(%w{bin/*})
 rdoc  = glob(%w{bin/* sbin/* lib/**/*.rb README README-library CHANGELOG TODO Install}).reject { |e| e=~ /\.(bat|cmd)$/ }
-ri    = glob(%w(bin/*.rb sbin/* lib/**/*.rb)).reject { |e| e=~ /\.(bat|cmd)$/ }
+ri    = glob(%w{bin/*.rb sbin/* lib/**/*.rb}).reject { |e| e=~ /\.(bat|cmd)$/ }
 man   = glob(%w{man/man[0-9]/*})
-libs  = glob(%w{lib/**/*.rb lib/**/*.py})
+libs  = glob(%w{lib/**/*.rb lib/**/*.py lib/puppet/util/command_line/*})
 tests = glob(%w{test/**/*.rb})
 
 def do_bins(bins, target, strip = 's?bin/')
@@ -131,23 +131,23 @@ end
 
 # Verify that all of the prereqs are installed
 def check_prereqs
-    PREREQS.each { |pre|
-        begin
-            require pre
-            if pre == "facter"
-              # to_f isn't quite exact for strings like "1.5.1" but is good
-              # enough for this purpose.
-              facter_version = Facter.version.to_f
-              if facter_version < MIN_FACTER_VERSION
-                puts "Facter version: %s; minimum required: %s; cannot install" % [facter_version, MIN_FACTER_VERSION]
-                exit -1
-              end
-            end
-        rescue LoadError
-            puts "Could not load %s; cannot install" % pre
-            exit -1
+  PREREQS.each { |pre|
+    begin
+      require pre
+      if pre == "facter"
+        # to_f isn't quite exact for strings like "1.5.1" but is good
+        # enough for this purpose.
+        facter_version = Facter.version.to_f
+        if facter_version < MIN_FACTER_VERSION
+          puts "Facter version: #{facter_version}; minimum required: #{MIN_FACTER_VERSION}; cannot install"
+          exit -1
         end
-    }
+      end
+    rescue LoadError
+      puts "Could not load #{pre}; cannot install"
+      exit -1
+    end
+  }
 end
 
 ##
@@ -156,36 +156,32 @@ end
 def prepare_installation
   # Only try to do docs if we're sure they have rdoc
   if $haverdoc
-      InstallOptions.rdoc  = true
-      if RUBY_PLATFORM == "i386-mswin32"
-        InstallOptions.ri  = false
-      else
-        InstallOptions.ri  = true
-      end
+    InstallOptions.rdoc  = true
+    InstallOptions.ri  = RUBY_PLATFORM != "i386-mswin32"
   else
-      InstallOptions.rdoc  = false
-      InstallOptions.ri  = false
+    InstallOptions.rdoc  = false
+    InstallOptions.ri  = false
   end
 
 
   if $haveman
-      InstallOptions.man = true
-      if RUBY_PLATFORM == "i386-mswin32"
-        InstallOptions.man  = false
-      end
+    InstallOptions.man = true
+    if RUBY_PLATFORM == "i386-mswin32"
+      InstallOptions.man  = false
+    end
   else
-      InstallOptions.man = false
+    InstallOptions.man = false
   end
 
   InstallOptions.tests = true
 
   if $haveman
-      InstallOptions.man = true
-      if RUBY_PLATFORM == "i386-mswin32"
-        InstallOptions.man  = false
-      end
+    InstallOptions.man = true
+    if RUBY_PLATFORM == "i386-mswin32"
+      InstallOptions.man  = false
+    end
   else
-      InstallOptions.man = false
+    InstallOptions.man = false
   end
 
   ARGV.options do |opts|
@@ -270,7 +266,7 @@ def prepare_installation
   else
     sitelibdir = Config::CONFIG["sitelibdir"]
     if sitelibdir.nil?
-      sitelibdir = $:.find { |x| x =~ /site_ruby/ }
+      sitelibdir = $LOAD_PATH.find { |x| x =~ /site_ruby/ }
       if sitelibdir.nil?
         sitelibdir = File.join(libdir, "site_ruby")
       elsif sitelibdir !~ Regexp.quote(version)
@@ -323,77 +319,74 @@ end
 # Build the rdoc documentation. Also, try to build the RI documentation.
 #
 def build_rdoc(files)
-    return unless $haverdoc
-    begin
-        r = RDoc::RDoc.new
-        r.document(["--main", "README", "--title",
-            "Puppet -- Site Configuration Management", "--line-numbers"] + files)
-    rescue RDoc::RDocError => e
-        $stderr.puts e.message
-    rescue Exception => e
-        $stderr.puts "Couldn't build RDoc documentation\n#{e.message}"
-    end
+  return unless $haverdoc
+  begin
+    r = RDoc::RDoc.new
+    r.document(["--main", "README", "--title", "Puppet -- Site Configuration Management", "--line-numbers"] + files)
+  rescue RDoc::RDocError => e
+    $stderr.puts e.message
+  rescue Exception => e
+    $stderr.puts "Couldn't build RDoc documentation\n#{e.message}"
+  end
 end
 
 def build_ri(files)
-    return unless $haverdoc
-    begin
-        ri = RDoc::RDoc.new
-        #ri.document(["--ri-site", "--merge"] + files)
-        ri.document(["--ri-site"] + files)
-    rescue RDoc::RDocError => e
-        $stderr.puts e.message
-    rescue Exception => e
-        $stderr.puts "Couldn't build Ri documentation\n#{e.message}"
-        $stderr.puts "Continuing with install..."
-    end
+  return unless $haverdoc
+  begin
+    ri = RDoc::RDoc.new
+    #ri.document(["--ri-site", "--merge"] + files)
+    ri.document(["--ri-site"] + files)
+  rescue RDoc::RDocError => e
+    $stderr.puts e.message
+  rescue Exception => e
+    $stderr.puts "Couldn't build Ri documentation\n#{e.message}"
+    $stderr.puts "Continuing with install..."
+  end
 end
 
 def build_man(bins, sbins)
-    return unless $haveman
-    begin
-        # Locate rst2man
-        rst2man = %x{which rst2man.py}
-        rst2man.chomp!
-        # Create puppet.conf.5 man page
-        %x{bin/puppetdoc --reference configuration > ./puppet.conf.rst}
-        %x{#{rst2man} ./puppet.conf.rst ./man/man5/puppet.conf.5}
-        File.unlink("./puppet.conf.rst")
-
-        # Create binary man pages
-        binary = bins + sbins 
-        binary.each do |bin|
-          b = bin.gsub( /(bin|sbin)\//, "")
-          %x{#{bin} --help > ./#{b}.rst}
-          %x{#{rst2man} ./#{b}.rst ./man/man8/#{b}.8}
-          File.unlink("./#{b}.rst")
-        end
-    
-rescue SystemCallError
-        $stderr.puts "Couldn't build man pages: " + $!
-        $stderr.puts "Continuing with install..."
+  return unless $haveman
+  begin
+    # Locate rst2man
+    rst2man = %x{which rst2man.py}
+    rst2man.chomp!
+    # Create puppet.conf.5 man page
+    %x{bin/puppetdoc --reference configuration > ./puppet.conf.rst}
+    %x{#{rst2man} ./puppet.conf.rst ./man/man5/puppet.conf.5}
+    File.unlink("./puppet.conf.rst")
+
+    # Create binary man pages
+    binary = bins + sbins
+    binary.each do |bin|
+      b = bin.gsub( /(bin|sbin)\//, "")
+      %x{#{bin} --help > ./#{b}.rst}
+      %x{#{rst2man} ./#{b}.rst ./man/man8/#{b}.8}
+      File.unlink("./#{b}.rst")
     end
+
+rescue SystemCallError
+  $stderr.puts "Couldn't build man pages: " + $ERROR_INFO
+  $stderr.puts "Continuing with install..."
+  end
 end
 
 def run_tests(test_list)
-    begin
-        require 'test/unit/ui/console/testrunner'
-        $:.unshift "lib"
-        test_list.each do |test|
-            next if File.directory?(test)
-            require test
-        end
+    require 'test/unit/ui/console/testrunner'
+    $LOAD_PATH.unshift "lib"
+    test_list.each do |test|
+      next if File.directory?(test)
+      require test
+    end
 
-        tests = []
-        ObjectSpace.each_object { |o| tests << o if o.kind_of?(Class) }
-        tests.delete_if { |o| !o.ancestors.include?(Test::Unit::TestCase) }
-        tests.delete_if { |o| o == Test::Unit::TestCase }
+    tests = []
+    ObjectSpace.each_object { |o| tests << o if o.kind_of?(Class) }
+    tests.delete_if { |o| !o.ancestors.include?(Test::Unit::TestCase) }
+    tests.delete_if { |o| o == Test::Unit::TestCase }
 
-        tests.each { |test| Test::Unit::UI::Console::TestRunner.run(test) }
-        $:.shift
-    rescue LoadError
-        puts "Missing testrunner library; skipping tests"
-    end
+    tests.each { |test| Test::Unit::UI::Console::TestRunner.run(test) }
+    $LOAD_PATH.shift
+rescue LoadError
+    puts "Missing testrunner library; skipping tests"
 end
 
 ##
@@ -419,10 +412,8 @@ def install_binfile(from, op_file, target)
       ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
       op.puts "#!#{ruby}"
       contents = ip.readlines
-      if contents[0] =~ /^#!/
-          contents.shift
-      end
-      op.write contents.join()
+      contents.shift if contents[0] =~ /^#!/
+      op.write contents.join
     end
   end