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|

10 files changed, 82 insertions, 57 deletions

diff --git a/lib/puppet/parser/functions/file.rb b/lib/puppet/parser/functions/file.rb
index 47b3f96e0..f78823d3a 100644
--- a/lib/puppet/parser/functions/file.rb
+++ b/lib/puppet/parser/functions/file.rb
@@ -1,5 +1,8 @@
 # Returns the contents of a file
-Puppet::Parser::Functions::newfunction(:file, :type => :rvalue,
+
+            Puppet::Parser::Functions::newfunction(
+                :file, :type => :rvalue,
+        
         :doc => "Return the contents of a file.  Multiple files
         can be passed, and the first file that exists will be read in.") do |vals|
             ret = nil
@@ -15,7 +18,6 @@ Puppet::Parser::Functions::newfunction(:file, :type => :rvalue,
             if ret
                 ret
             else
-                raise Puppet::ParseError, "Could not find any files from %s" %
-                    vals.join(", ")
+                raise Puppet::ParseError, "Could not find any files from %s" % vals.join(", ")
             end
 end
diff --git a/lib/puppet/parser/functions/fqdn_rand.rb b/lib/puppet/parser/functions/fqdn_rand.rb
index 9297539e3..27af2d7ca 100644
--- a/lib/puppet/parser/functions/fqdn_rand.rb
+++ b/lib/puppet/parser/functions/fqdn_rand.rb
@@ -1,6 +1,6 @@
 Puppet::Parser::Functions::newfunction(:fqdn_rand, :type => :rvalue, :doc =>
     "Generates random numbers based on the node's fqdn. The first argument
-    sets the range.  Additional (optional) arguments may be used to further 
+    sets the range.  Additional (optional) arguments may be used to further
     distinguish the seed.") do |args|
         require 'md5'
         max = args.shift
diff --git a/lib/puppet/parser/functions/inline_template.rb b/lib/puppet/parser/functions/inline_template.rb
index b9547cac7..fde8006b4 100644
--- a/lib/puppet/parser/functions/inline_template.rb
+++ b/lib/puppet/parser/functions/inline_template.rb
@@ -14,8 +14,7 @@ Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :doc
                 wrapper.result(string)
             rescue => detail
                 raise Puppet::ParseError,
-                    "Failed to parse inline template: %s" %
-                        [detail]
+                    "Failed to parse inline template: %s" % [detail]
             end
         end.join("")
 end
diff --git a/lib/puppet/parser/functions/regsubst.rb b/lib/puppet/parser/functions/regsubst.rb
index d02680862..c47c1654e 100644
--- a/lib/puppet/parser/functions/regsubst.rb
+++ b/lib/puppet/parser/functions/regsubst.rb
@@ -1,7 +1,10 @@
 module Puppet::Parser::Functions
-    newfunction(:regsubst, :type => :rvalue,
-                :doc => "
-                Perform regexp replacement on a string or array of strings.
+
+    newfunction(
+    :regsubst, :type => :rvalue,
+
+    :doc => "
+    Perform regexp replacement on a string or array of strings.
 
 - **Parameters** (in order):
 
@@ -20,10 +23,10 @@ module Puppet::Parser::Functions
 
 :lang:  Optional.  How to handle multibyte characters.  A single-character string with the following values:
 
-     - **N**         None
-     - **E**         EUC
-     - **S**         SJIS
-     - **U**         UTF-8
+    - **N**         None
+    - **E**         EUC
+    - **S**         SJIS
+    - **U**         UTF-8
 
 - **Examples**
 
@@ -37,8 +40,11 @@ Put angle brackets around each octet in the node's IP address::
 ") \
     do |args|
         unless args.length.between?(3, 5)
-            raise(Puppet::ParseError,
-                  "regsubst(): got #{args.length} arguments, expected 3 to 5")
+
+            raise(
+                Puppet::ParseError,
+
+                    "regsubst(): got #{args.length} arguments, expected 3 to 5")
         end
         target, regexp, replacement, flags, lang = args
         reflags = 0
@@ -48,8 +54,11 @@ Put angle brackets around each octet in the node's IP address::
         elsif flags.respond_to?(:split)
             flags = flags.split('')
         else
-            raise(Puppet::ParseError,
-                  "regsubst(): bad flags parameter #{flags.class}:`#{flags}'")
+
+            raise(
+                Puppet::ParseError,
+
+                    "regsubst(): bad flags parameter #{flags.class}:`#{flags}'")
         end
         flags.each do |f|
             case f
@@ -63,22 +72,28 @@ Put angle brackets around each octet in the node's IP address::
         begin
             re = Regexp.compile(regexp, reflags, lang)
         rescue RegexpError, TypeError
-            raise(Puppet::ParseError,
-                  "regsubst(): Bad regular expression `#{regexp}'")
+
+            raise(
+                Puppet::ParseError,
+
+                    "regsubst(): Bad regular expression `#{regexp}'")
         end
         if target.respond_to?(operation)
             # String parameter -> string result
             result = target.send(operation, re, replacement)
         elsif target.respond_to?(:collect) and
-                target.respond_to?(:all?) and
-                target.all? { |e| e.respond_to?(operation) }
+            target.respond_to?(:all?) and
+            target.all? { |e| e.respond_to?(operation) }
             # Array parameter -> array result
             result = target.collect { |e|
                 e.send(operation, re, replacement)
             }
         else
-            raise(Puppet::ParseError,
-                  "regsubst(): bad target #{target.class}:`#{target}'")
+
+            raise(
+                Puppet::ParseError,
+
+                    "regsubst(): bad target #{target.class}:`#{target}'")
         end
         return result
     end
diff --git a/lib/puppet/parser/functions/require.rb b/lib/puppet/parser/functions/require.rb
index a46999f05..45b89c77a 100644
--- a/lib/puppet/parser/functions/require.rb
+++ b/lib/puppet/parser/functions/require.rb
@@ -1,5 +1,8 @@
 # Requires the specified classes
-Puppet::Parser::Functions::newfunction(:require,
+
+    Puppet::Parser::Functions::newfunction(
+        :require,
+
         :doc =>"Evaluate one or more classes,  adding the required class as a dependency.
 
 The relationship metaparameters work well for specifying relationships
@@ -9,18 +12,18 @@ relationships between classes.  This function is a superset of the
 class depends on the required class.
 
 Warning: using require in place of include can lead to unwanted dependency cycles.
-  For instance the following manifest, with 'require' instead of 'include'
-  would produce a nasty dependence cycle, because notify imposes a before
-  between File[/foo] and Service[foo]::
-
-    class myservice {
-       service { foo: ensure => running }
-    }
-
-    class otherstuff {
-       include myservice
-       file { '/foo': notify => Service[foo] }
-    }
+    For instance the following manifest, with 'require' instead of 'include'
+    would produce a nasty dependence cycle, because notify imposes a before
+    between File[/foo] and Service[foo]::
+
+        class myservice {
+            service { foo: ensure => running }
+        }
+
+        class otherstuff {
+            include myservice
+            file { '/foo': notify => Service[foo] }
+        }
 
 Note that this function only works with clients 0.25 and later, and it will
 fail if used with earlier clients.
diff --git a/lib/puppet/parser/functions/sha1.rb b/lib/puppet/parser/functions/sha1.rb
index 09386a604..432825ee9 100644
--- a/lib/puppet/parser/functions/sha1.rb
+++ b/lib/puppet/parser/functions/sha1.rb
@@ -1,5 +1,4 @@
-Puppet::Parser::Functions::newfunction(:sha1, :type => :rvalue,
-        :doc => "Returns a SHA1 hash value from a provided string.") do |args|
+Puppet::Parser::Functions::newfunction(:sha1, :type => :rvalue, :doc => "Returns a SHA1 hash value from a provided string.") do |args|
             require 'sha1'
 
             Digest::SHA1.hexdigest(args[0])
diff --git a/lib/puppet/parser/functions/split.rb b/lib/puppet/parser/functions/split.rb
index 36dba7e68..405a5bc9a 100644
--- a/lib/puppet/parser/functions/split.rb
+++ b/lib/puppet/parser/functions/split.rb
@@ -1,14 +1,17 @@
 module Puppet::Parser::Functions
-    newfunction(:split, :type => :rvalue,
-      :doc => "\
+
+    newfunction(
+    :split, :type => :rvalue,
+
+        :doc => "\
 Split a string variable into an array using the specified split regexp.
 
-  Usage::
+    Usage::
 
-    $string     = 'v1.v2:v3.v4'
-    $array_var1 = split($string, ':')
-    $array_var2 = split($string, '[.]')
-    $array_var3 = split($string, '[.:]')
+        $string     = 'v1.v2:v3.v4'
+        $array_var1 = split($string, ':')
+        $array_var2 = split($string, '[.]')
+        $array_var3 = split($string, '[.:]')
 
 $array_var1 now holds the result ['v1.v2', 'v3.v4'],
 while $array_var2 holds ['v1', 'v2:v3', 'v4'], and
@@ -19,11 +22,10 @@ a regexp meta-character (.), and that needs protection.  A simple
 way to do that for a single character is to enclose it in square
 brackets.") do |args|
 
-     if args.length != 2
-         raise Puppet::ParseError, ("split(): wrong number of arguments" +
-				   " (#{args.length}; must be 2)")
-     end
+    if args.length != 2
+        raise Puppet::ParseError, ("split(): wrong number of arguments" + " (#{args.length}; must be 2)")
+    end
 
-     return args[0].split(Regexp.compile(args[1]))
+    return args[0].split(Regexp.compile(args[1]))
     end
 end
diff --git a/lib/puppet/parser/functions/sprintf.rb b/lib/puppet/parser/functions/sprintf.rb
index d84b1866a..4a53a9736 100644
--- a/lib/puppet/parser/functions/sprintf.rb
+++ b/lib/puppet/parser/functions/sprintf.rb
@@ -1,8 +1,11 @@
 module Puppet::Parser::Functions
-    newfunction(:sprintf, :type => :rvalue,
+
+    newfunction(
+    :sprintf, :type => :rvalue,
+
         :doc => "Perform printf-style formatting of text.
 
-                         The first parameter is format string describing how the rest of the parameters should be formatted.  See the documentation for the ``Kernel::sprintf()`` function in Ruby for all the details.") do |args|
+            The first parameter is format string describing how the rest of the parameters should be formatted.  See the documentation for the ``Kernel::sprintf()`` function in Ruby for all the details.") do |args|
         if args.length < 1
             raise Puppet::ParseError, 'sprintf() needs at least one argument'
         end
diff --git a/lib/puppet/parser/functions/template.rb b/lib/puppet/parser/functions/template.rb
index 34524e388..35c54c66a 100644
--- a/lib/puppet/parser/functions/template.rb
+++ b/lib/puppet/parser/functions/template.rb
@@ -1,7 +1,7 @@
 Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :doc =>
     "Evaluate a template and return its value.  See `the templating docs
-    <http://docs.puppetlabs.com/guides/templating.html>`_ for more information.  
-    Note that if multiple templates are specified, their output is all 
+    <http://docs.puppetlabs.com/guides/templating.html>`_ for more information.
+    Note that if multiple templates are specified, their output is all
     concatenated and returned as the output of the function.") do |vals|
         require 'erb'
 
@@ -16,8 +16,7 @@ Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :doc =>
                 wrapper.result
             rescue => detail
                 raise Puppet::ParseError,
-                    "Failed to parse template %s: %s" %
-                        [file, detail]
+                    "Failed to parse template %s: %s" % [file, detail]
             end
         end.join("")
 end
diff --git a/lib/puppet/parser/functions/versioncmp.rb b/lib/puppet/parser/functions/versioncmp.rb
index 9435655a7..b8d39af96 100644
--- a/lib/puppet/parser/functions/versioncmp.rb
+++ b/lib/puppet/parser/functions/versioncmp.rb
@@ -1,6 +1,9 @@
 require 'puppet/util/package'
 
-Puppet::Parser::Functions::newfunction(:versioncmp, :type => :rvalue, 
+
+            Puppet::Parser::Functions::newfunction(
+                :versioncmp, :type => :rvalue,
+        
     :doc => "Compares two versions
 
 Prototype::