Code smell: Inconsistent indentation and related formatting issues

* Replaced 163 occurances of

      defined\? +([@a-zA-Z_.0-9?=]+)

  with

      defined?(\1)

  This makes detecting subsequent patterns easier.

  3 Examples:

      The code:
          if ! defined? @parse_config
      becomes:
          if ! defined?(@parse_config)
      The code:
          return @option_parser if defined? @option_parser
      becomes:
          return @option_parser if defined?(@option_parser)
      The code:
          if defined? @local and @local
      becomes:
          if defined?(@local) and @local

* Eliminate trailing spaces.

  Replaced 428 occurances of ^(.*?) +$ with \1

  1 file was skipped.

      test/ral/providers/host/parsed.rb because 0

* Replace leading tabs with an appropriate number of spaces.

  Replaced 306 occurances of ^(\t+)(.*) with

  Tabs are not consistently expanded in all environments.

* Don't arbitrarily wrap on sprintf (%) operator.

  Replaced 143 occurances of

      (.*['"] *%)
       +(.*)

  with

  Splitting the line does nothing to aid clarity and hinders further refactorings.

  3 Examples:

      The code:
          raise Puppet::Error, "Cannot create %s: basedir %s is a file" %
              [dir, File.join(path)]
      becomes:
          raise Puppet::Error, "Cannot create %s: basedir %s is a file" % [dir, File.join(path)]
      The code:
          Puppet.err "Will not start without authorization file %s" %
              Puppet[:authconfig]
      becomes:
          Puppet.err "Will not start without authorization file %s" % Puppet[:authconfig]
      The code:
          $stderr.puts "Could not find host for PID %s with status %s" %
              [pid, $?.exitstatus]
      becomes:
          $stderr.puts "Could not find host for PID %s with status %s" % [pid, $?.exitstatus]

* Don't break short arrays/parameter list in two.

  Replaced 228 occurances of

      (.*)
       +(.*)

  with

  3 Examples:

      The code:
          puts @format.wrap(type.provider(prov).doc,
                            :indent => 4, :scrub => true)
      becomes:
          puts @format.wrap(type.provider(prov).doc, :indent => 4, :scrub => true)
      The code:
          assert(FileTest.exists?(daily),
              "Did not make daily graph for %s" % type)
      becomes:
          assert(FileTest.exists?(daily), "Did not make daily graph for %s" % type)
      The code:
          assert(prov.target_object(:first).read !~ /^notdisk/,
              "Did not remove thing from disk")
      becomes:
          assert(prov.target_object(:first).read !~ /^notdisk/, "Did not remove thing from disk")

* If arguments must wrap, treat them all equally

  Replaced 510 occurances of

      lines ending in things like ...(foo, or ...(bar(1,3),

  with

      \1
          \2

  3 Examples:

      The code:
          midscope.to_hash(false),
      becomes:
          assert_equal(
      The code:
          botscope.to_hash(true),
      becomes:
          # bottomscope, then checking that we see the right stuff.
      The code:
          :path => link,
      becomes:

* Replaced 4516 occurances of ^( *)(.*) with

  The present code base is supposed to use four-space indentation.  In some places we failed
  to maintain that standard.  These should be fixed regardless of the 2 vs. 4 space question.

  15 Examples:

      The code:

          def run_comp(cmd)
             puts cmd
             results = []
             old_sync = $stdout.sync
             $stdout.sync = true
             line = []
             begin
                open("| #{cmd}", "r") do |f|
                  until f.eof? do
                    c = f.getc
      becomes:

          def run_comp(cmd)
              puts cmd
              results = []
              old_sync = $stdout.sync
              $stdout.sync = true
              line = []
              begin
                  open("| #{cmd}", "r") do |f|
                      until f.eof? do
                          c = f.getc
      The code:
                              s.gsub!(/.{4}/n, '\\\\u\&')
                            }
              string.force_encoding(Encoding::UTF_8)
              string
            rescue Iconv::Failure => e
              raise GeneratorError, "Caught #{e.class}: #{e}"
            end
          else
            def utf8_to_pson(string) # :nodoc:
              string = string.gsub(/["\\\x0-\x1f]/) { MAP[$&] }
              string.gsub!(/(
      becomes:
                                      s.gsub!(/.{4}/n, '\\\\u\&')
                                  }
                  string.force_encoding(Encoding::UTF_8)
                  string
              rescue Iconv::Failure => e
                  raise GeneratorError, "Caught #{e.class}: #{e}"
              end
          else
              def utf8_to_pson(string) # :nodoc:
                  string = string.gsub(/["\\\x0-\x1f]/) { MAP[$&] }
                  string.gsub!(/(
      The code:
              end
          }

          rvalues:      rvalue
                      | rvalues comma rvalue {
              if val[0].instance_of?(AST::ASTArray)
                  result = val[0].push(val[2])
              else
                  result = ast AST::ASTArray, :children => [val[0],val[2]]
              end
          }
      becomes:
              end
          }

          rvalues:      rvalue
              | rvalues comma rvalue {
                  if val[0].instance_of?(AST::ASTArray)
                  result = val[0].push(val[2])
              else
                  result = ast AST::ASTArray, :children => [val[0],val[2]]
              end
          }
      The code:
          #passwdproc = proc { @password }

                      keytext = @key.export(

              OpenSSL::Cipher::DES.new(:EDE3, :CBC),

              @password
          )
          File.open(@keyfile, "w", 0400) { |f|
              f << keytext
          }
      becomes:
          #        passwdproc = proc { @password }

              keytext = @key.export(

                  OpenSSL::Cipher::DES.new(:EDE3, :CBC),

                  @password
                  )
                  File.open(@keyfile, "w", 0400) { |f|
                      f << keytext
                  }
      The code:
          end

          def to_manifest
              "%s { '%s':\n%s\n}" % [self.type.to_s, self.name,
                   @params.collect { |p, v|
                       if v.is_a? Array
                           "    #{p} => [\'#{v.join("','")}\']"
                       else
                           "    #{p} => \'#{v}\'"
                       end
                   }.join(",\n")
      becomes:
          end

          def to_manifest
              "%s { '%s':\n%s\n}" % [self.type.to_s, self.name,
                  @params.collect { |p, v|
                      if v.is_a? Array
                          "    #{p} => [\'#{v.join("','")}\']"
                      else
                          "    #{p} => \'#{v}\'"
                      end
                  }.join(",\n")
      The code:
          via the augeas tool.

           Requires:
             - augeas to be installed (http://www.augeas.net)
             - ruby-augeas bindings

           Sample usage with a string::

              augeas{\"test1\" :
                     context => \"/files/etc/sysconfig/firstboot\",
                     changes => \"set RUN_FIRSTBOOT YES\",
      becomes:
          via the augeas tool.

          Requires:
              - augeas to be installed (http://www.augeas.net)
              - ruby-augeas bindings

          Sample usage with a string::

              augeas{\"test1\" :
                  context => \"/files/etc/sysconfig/firstboot\",
                  changes => \"set RUN_FIRSTBOOT YES\",
      The code:
              names.should_not be_include("root")
          end

          describe "when generating a purgeable resource" do
              it "should be included in the generated resources" do
                  Puppet::Type.type(:host).stubs(:instances).returns [@purgeable_resource]
                  @resources.generate.collect { |r| r.ref }.should include(@purgeable_resource.ref)
              end
          end

          describe "when the instance's do not have an ensure property" do
      becomes:
              names.should_not be_include("root")
          end

          describe "when generating a purgeable resource" do
              it "should be included in the generated resources" do
                  Puppet::Type.type(:host).stubs(:instances).returns [@purgeable_resource]
                  @resources.generate.collect { |r| r.ref }.should include(@purgeable_resource.ref)
              end
          end

          describe "when the instance's do not have an ensure property" do
      The code:
          describe "when the instance's do not have an ensure property" do
              it "should not be included in the generated resources" do
                  @no_ensure_resource = Puppet::Type.type(:exec).new(:name => '/usr/bin/env echo')
                  Puppet::Type.type(:host).stubs(:instances).returns [@no_ensure_resource]
                  @resources.generate.collect { |r| r.ref }.should_not include(@no_ensure_resource.ref)
              end
          end

          describe "when the instance's ensure property does not accept absent" do
              it "should not be included in the generated resources" do
                  @no_absent_resource = Puppet::Type.type(:service).new(:name => 'foobar')
      becomes:
          describe "when the instance's do not have an ensure property" do
              it "should not be included in the generated resources" do
                  @no_ensure_resource = Puppet::Type.type(:exec).new(:name => '/usr/bin/env echo')
                  Puppet::Type.type(:host).stubs(:instances).returns [@no_ensure_resource]
                  @resources.generate.collect { |r| r.ref }.should_not include(@no_ensure_resource.ref)
              end
          end

          describe "when the instance's ensure property does not accept absent" do
              it "should not be included in the generated resources" do
                  @no_absent_resource = Puppet::Type.type(:service).new(:name => 'foobar')
      The code:
          func = nil
          assert_nothing_raised do

                          func = Puppet::Parser::AST::Function.new(

                  :name => "template",
                  :ftype => :rvalue,

                  :arguments => AST::ASTArray.new(
                      :children => [stringobj(template)]
                  )
      becomes:
          func = nil
          assert_nothing_raised do

              func = Puppet::Parser::AST::Function.new(

                  :name => "template",
                  :ftype => :rvalue,

                  :arguments => AST::ASTArray.new(
                      :children => [stringobj(template)]
                  )
      The code:

                  assert(
              @store.allowed?("hostname.madstop.com", "192.168.1.50"),

          "hostname not allowed")

                  assert(
              ! @store.allowed?("name.sub.madstop.com", "192.168.0.50"),

          "subname name allowed")
      becomes:

          assert(
              @store.allowed?("hostname.madstop.com", "192.168.1.50"),

          "hostname not allowed")

              assert(
                  ! @store.allowed?("name.sub.madstop.com", "192.168.0.50"),

          "subname name allowed")
      The code:

          assert_nothing_raised {

                          server = Puppet::Network::Handler.fileserver.new(

                  :Local => true,

                  :Config => false
              )
          }

      becomes:

          assert_nothing_raised {

              server = Puppet::Network::Handler.fileserver.new(

                  :Local => true,

                  :Config => false
              )
          }

      The code:
               'yay',
                                               { :failonfail => false,
                                                 :uid => @user.uid,

                                                 :gid => @user.gid }
                                             ).returns('output')

          output = Puppet::Util::SUIDManager.run_and_capture 'yay',
                                                             @user.uid,
                                                             @user.gid
      becomes:
                  'yay',
                      { :failonfail => false,
                          :uid => @user.uid,

                          :gid => @user.gid }
                              ).returns('output')

          output = Puppet::Util::SUIDManager.run_and_capture 'yay',
              @user.uid,
              @user.gid
      The code:
                      ).times(1)
          pkg.provider.expects(
                          :aptget

                                  ).with(

                          '-y',
                          '-q',
                          'remove',

                          'faff'
      becomes:
                      ).times(1)
          pkg.provider.expects(
              :aptget

                  ).with(

                      '-y',
                      '-q',
                      'remove',

                      'faff'
      The code:
          johnny one two
          billy three four\n"

                  # Just parse and generate, to make sure it's isomorphic.
                  assert_nothing_raised do
                      assert_equal(text, @parser.to_file(@parser.parse(text)),
                          "parsing was not isomorphic")
                  end
              end

              def test_valid_attrs
      becomes:
          johnny one two
          billy three four\n"

          #         Just parse and generate, to make sure it's isomorphic.
          assert_nothing_raised do
              assert_equal(text, @parser.to_file(@parser.parse(text)),
                  "parsing was not isomorphic")
                  end
              end

              def test_valid_attrs
      The code:
                  "testing",
                              :onboolean => [true, "An on bool"],

                              :string => ["a string", "A string arg"]
                              )
          result = []
          should = []
          assert_nothing_raised("Add args failed") do
              @config.addargs(result)
          end
          @config.each do |name, element|
      becomes:
                  "testing",
                      :onboolean => [true, "An on bool"],

                      :string => ["a string", "A string arg"]
                      )
          result = []
          should = []
          assert_nothing_raised("Add args failed") do
              @config.addargs(result)
          end
          @config.each do |name, element|

5 files changed, 52 insertions, 40 deletions

diff --git a/ext/extlookup.rb b/ext/extlookup.rb
index b0978ef12..b9ebc43c8 100644
--- a/ext/extlookup.rb
+++ b/ext/extlookup.rb
@@ -1,10 +1,10 @@
-# Puppet External Data Sources 
+# Puppet External Data Sources
 #
 # This is a parser function to read data from external files, this version
 # uses CSV files but the concept can easily be adjust for databases, yaml
 # or any other queryable data source.
 #
-# The object of this is to make it obvious when it's being used, rather than 
+# The object of this is to make it obvious when it's being used, rather than
 # magically loading data in when an module is loaded I prefer to look at the code
 # and see statements like:
 #
@@ -34,7 +34,7 @@
 #
 # Now create the following data files in /etc/puppet/manifests/extdata
 #
-# domain_myclient.com.csv: 
+# domain_myclient.com.csv:
 #    snmp_contact,John Doe <john@myclient.com>
 #    root_contact,support@%{domain}
 #    client_trusted_ips,192.168.1.130,192.168.10.0/24
@@ -48,7 +48,7 @@
 #
 #    $snmp_contact = extlookup("snmp_contact")
 #
-# The obove code shows some other features, you can use any fact or variable that 
+# The obove code shows some other features, you can use any fact or variable that
 # is in scope by simply using %{varname} in your data files, you can return arrays
 # by just having multiple values in the csv after the initial variable name.
 #
@@ -57,8 +57,8 @@
 # in empty values etc.  You can however specify a default value:
 #
 #    $ntp_servers = extlookup("ntp_servers", "1.${country}.pool.ntp.org")
-# 
-# In this case it will default to "1.${country}.pool.ntp.org" if nothing is defined in 
+#
+# In this case it will default to "1.${country}.pool.ntp.org" if nothing is defined in
 # any data file.
 #
 # You can also specify an additional data file to search first before any others at use
@@ -78,7 +78,7 @@
 #
 # For further help contact Volcane on #puppet
 require 'csv'
- 
+
 module Puppet::Parser::Functions
     newfunction(:extlookup, :type => :rvalue) do |args|
         key = args[0]
@@ -110,12 +110,12 @@ module Puppet::Parser::Functions
 
             extlookup_precedence << prec
         end
-    
+
 
         datafiles = Array.new
 
         # if we got a custom data file, put it first in the array of search files
-        if datafile != "" 
+        if datafile != ""
             if File.exists?(extlookup_datadir + "/#{datafile}.csv")
                 datafiles << extlookup_datadir + "/#{datafile}.csv"
             end
@@ -135,14 +135,14 @@ module Puppet::Parser::Functions
                     result = CSV.read(file).find_all do |r|
                         r[0] == key
                     end
-    
+
 
                     # return just the single result if theres just one,
                     # else take all the fields in the csv and build an array
                     if result.length > 0
                         if result[0].length == 2
                             val = result[0][1].to_s
-                            
+
                             # parse %{}'s in the CSV into local variables using lookupvar()
                             while val =~ /%\{(.+?)\}/
                                 val.gsub!(/%\{#{$1}\}/, lookupvar($1))
@@ -152,7 +152,7 @@ module Puppet::Parser::Functions
                         elsif result[0].length > 1
                             length = result[0].length
                             cells = result[0][1,length]
-    
+
                             # Individual cells in a CSV result are a weird data type and throws
                             # puppets yaml parsing, so just map it all to plain old strings
                             desired = cells.map do |c|
@@ -172,7 +172,7 @@ module Puppet::Parser::Functions
         # don't accidently return nil's and such rather throw a parse error
         if desired == "_ExtUNSET_" && default == "_ExtUNSET_"
             raise Puppet::ParseError, "No match found for '#{key}' in any data file during extlookup()"
-        else 
+        else
             desired = default if desired == "_ExtUNSET_"
         end
 
diff --git a/ext/nagios/check_puppet.rb b/ext/nagios/check_puppet.rb
index c569566ad..5d448b6fc 100755
--- a/ext/nagios/check_puppet.rb
+++ b/ext/nagios/check_puppet.rb
@@ -20,26 +20,35 @@ class CheckPuppet
         o.set_summary_indent('  ')
         o.banner =    "Usage: #{script_name} [OPTIONS]"
         o.define_head "The check_puppet Nagios plug-in checks that specified " +
-                  "Puppet process is running and the state file is no " +
-                  "older than specified interval."
-                  o.separator   ""
-                  o.separator   "Mandatory arguments to long options are mandatory for " +
-                  "short options too."
-
-                  o.on("-s", "--statefile=statefile", String, "The state file",
-         "Default: #{OPTIONS[:statefile]}") { |OPTIONS[:statefile]| }
-         o.on("-p", "--process=processname", String, "The process to check",
-         "Default: #{OPTIONS[:process]}")   { |OPTIONS[:process]| }
-         o.on("-i", "--interval=value", Integer,
-         "Default: #{OPTIONS[:interval]} minutes")  { |OPTIONS[:interval]| }
-
-         o.separator ""
-         o.on_tail("-h", "--help", "Show this help message.") do
-             puts o
-             exit
-         end
-
-         o.parse!(ARGV)
+            "Puppet process is running and the state file is no " +
+            "older than specified interval."
+            o.separator   ""
+            o.separator   "Mandatory arguments to long options are mandatory for " +
+            "short options too."
+
+
+                o.on(
+                    "-s", "--statefile=statefile", String, "The state file",
+
+        "Default: #{OPTIONS[:statefile]}") { |OPTIONS[:statefile]| }
+
+            o.on(
+                "-p", "--process=processname", String, "The process to check",
+
+        "Default: #{OPTIONS[:process]}")   { |OPTIONS[:process]| }
+
+            o.on(
+                "-i", "--interval=value", Integer,
+
+        "Default: #{OPTIONS[:interval]} minutes")  { |OPTIONS[:interval]| }
+
+        o.separator ""
+        o.on_tail("-h", "--help", "Show this help message.") do
+            puts o
+            exit
+        end
+
+        o.parse!(ARGV)
     end
 
     def check_proc
diff --git a/ext/puppetlisten/puppetrun.rb b/ext/puppetlisten/puppetrun.rb
index 600ab1038..192016c8d 100755
--- a/ext/puppetlisten/puppetrun.rb
+++ b/ext/puppetlisten/puppetrun.rb
@@ -31,7 +31,7 @@ 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)
+#                        closed in SSLSocket#close. (default: false)
 while (line = ssl.gets)
     puts line
 end
diff --git a/ext/puppetstoredconfigclean.rb b/ext/puppetstoredconfigclean.rb
index 1b4aabd0f..6f4aa7230 100644
--- a/ext/puppetstoredconfigclean.rb
+++ b/ext/puppetstoredconfigclean.rb
@@ -17,10 +17,13 @@ def printusage(error_code)
     exit(error_code)
 end
 
-opts = GetoptLong.new(
+
+            opts = GetoptLong.new(
+                
         [ "--config",     "-c",   GetoptLong::REQUIRED_ARGUMENT ],
         [ "--help",        "-h",   GetoptLong::NO_ARGUMENT ],
         [ "--usage",       "-u",   GetoptLong::NO_ARGUMENT ],
+        
         [ "--version",     "-v",   GetoptLong::NO_ARGUMENT ]
 )
 
diff --git a/ext/regexp_nodes/regexp_nodes.rb b/ext/regexp_nodes/regexp_nodes.rb
index a9e7ed6a9..377b13053 100644
--- a/ext/regexp_nodes/regexp_nodes.rb
+++ b/ext/regexp_nodes/regexp_nodes.rb
@@ -96,9 +96,9 @@ class ExternalNode
     def to_yaml
         classes = self.classes.to_a
         if self.parameters.empty? # otherwise to_yaml prints "parameters: {}"
-             parameters = nil
+            parameters = nil
         else
-             parameters = self.parameters
+            parameters = self.parameters
         end
         ({ 'classes' => classes, 'parameters' => parameters}).to_yaml
     end
@@ -164,7 +164,7 @@ class ExternalNode
             next if File.basename(filepath) =~ /^\./     # skip over dotfiles
 
             next unless File.directory?(filepath) and
-                        File.readable?(filepath)        # skip over non-directories
+                File.readable?(filepath)        # skip over non-directories
 
             $LOG.debug "Considering contents of #{filepath}"
 
@@ -175,8 +175,8 @@ class ExternalNode
                     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}")
+                    @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}