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|

1 files changed, 541 insertions, 546 deletions

diff --git a/lib/puppet/external/nagios/parser.rb b/lib/puppet/external/nagios/parser.rb
index 498b0884e..deea9f3bc 100644
--- a/lib/puppet/external/nagios/parser.rb
+++ b/lib/puppet/external/nagios/parser.rb
@@ -25,433 +25,432 @@ self.class.module_eval <<'..end racc/parser.rb modeval..id5256434e8a', 'racc/par
 #
 
 unless defined?(NotImplementedError)
-  NotImplementedError = NotImplementError
+    NotImplementedError = NotImplementError
 end
 
 module Racc
-  class ParseError < StandardError; end
+    class ParseError < StandardError; end
 end
 unless defined?(::ParseError)
-  ParseError = Racc::ParseError
+    ParseError = Racc::ParseError
 end
 
 module Racc
 
-  unless defined?(Racc_No_Extentions)
-    Racc_No_Extentions = false
-  end
-
-  class Parser
-
-    Racc_Runtime_Version = '1.4.5'
-    Racc_Runtime_Revision = '$Revision: 1.7 $'.split[1]
-
-    Racc_Runtime_Core_Version_R = '1.4.5'
-    Racc_Runtime_Core_Revision_R = '$Revision: 1.7 $'.split[1]
-    begin
-      require 'racc/cparse'
-    # Racc_Runtime_Core_Version_C  = (defined in extention)
-      Racc_Runtime_Core_Revision_C = Racc_Runtime_Core_Id_C.split[2]
-      unless new.respond_to?(:_racc_do_parse_c, true)
-        raise LoadError, 'old cparse.so'
-      end
-      if Racc_No_Extentions
-        raise LoadError, 'selecting ruby version of racc runtime core'
-      end
-
-      Racc_Main_Parsing_Routine    = :_racc_do_parse_c
-      Racc_YY_Parse_Method         = :_racc_yyparse_c
-      Racc_Runtime_Core_Version    = Racc_Runtime_Core_Version_C
-      Racc_Runtime_Core_Revision   = Racc_Runtime_Core_Revision_C
-      Racc_Runtime_Type            = 'c'
-    rescue LoadError
-      Racc_Main_Parsing_Routine    = :_racc_do_parse_rb
-      Racc_YY_Parse_Method         = :_racc_yyparse_rb
-      Racc_Runtime_Core_Version    = Racc_Runtime_Core_Version_R
-      Racc_Runtime_Core_Revision   = Racc_Runtime_Core_Revision_R
-      Racc_Runtime_Type            = 'ruby'
+    unless defined?(Racc_No_Extentions)
+        Racc_No_Extentions = false
     end
 
-    def Parser.racc_runtime_type
-      Racc_Runtime_Type
-    end
+    class Parser
 
-    private
-
-    def _racc_setup
-      @yydebug = false unless self.class::Racc_debug_parser
-      @yydebug = false unless defined?(@yydebug)
-      if @yydebug
-        @racc_debug_out = $stderr unless defined?(@racc_debug_out)
-        @racc_debug_out ||= $stderr
-      end
-      arg = self.class::Racc_arg
-      arg[13] = true if arg.size < 14
-      arg
-    end
+        Racc_Runtime_Version = '1.4.5'
+        Racc_Runtime_Revision = '$Revision: 1.7 $'.split[1]
 
-    def _racc_init_sysvars
-      @racc_state  = [0]
-      @racc_tstack = []
-      @racc_vstack = []
+        Racc_Runtime_Core_Version_R = '1.4.5'
+        Racc_Runtime_Core_Revision_R = '$Revision: 1.7 $'.split[1]
+        begin
+            require 'racc/cparse'
+        # Racc_Runtime_Core_Version_C  = (defined in extention)
+            Racc_Runtime_Core_Revision_C = Racc_Runtime_Core_Id_C.split[2]
+            unless new.respond_to?(:_racc_do_parse_c, true)
+                raise LoadError, 'old cparse.so'
+            end
+            if Racc_No_Extentions
+                raise LoadError, 'selecting ruby version of racc runtime core'
+            end
 
-      @racc_t = nil
-      @racc_val = nil
+            Racc_Main_Parsing_Routine    = :_racc_do_parse_c
+            Racc_YY_Parse_Method         = :_racc_yyparse_c
+            Racc_Runtime_Core_Version    = Racc_Runtime_Core_Version_C
+            Racc_Runtime_Core_Revision   = Racc_Runtime_Core_Revision_C
+            Racc_Runtime_Type            = 'c'
+        rescue LoadError
+            Racc_Main_Parsing_Routine    = :_racc_do_parse_rb
+            Racc_YY_Parse_Method         = :_racc_yyparse_rb
+            Racc_Runtime_Core_Version    = Racc_Runtime_Core_Version_R
+            Racc_Runtime_Core_Revision   = Racc_Runtime_Core_Revision_R
+            Racc_Runtime_Type            = 'ruby'
+        end
 
-      @racc_read_next = true
+        def Parser.racc_runtime_type
+            Racc_Runtime_Type
+        end
 
-      @racc_user_yyerror = false
-      @racc_error_status = 0
-    end
+        private
 
-    ###
-    ### do_parse
-    ###
+        def _racc_setup
+            @yydebug = false unless self.class::Racc_debug_parser
+            @yydebug = false unless defined?(@yydebug)
+            if @yydebug
+                @racc_debug_out = $stderr unless defined?(@racc_debug_out)
+                @racc_debug_out ||= $stderr
+            end
+            arg = self.class::Racc_arg
+            arg[13] = true if arg.size < 14
+            arg
+        end
 
-    def do_parse
-      __send__(Racc_Main_Parsing_Routine, _racc_setup(), false)
-    end
+        def _racc_init_sysvars
+            @racc_state  = [0]
+            @racc_tstack = []
+            @racc_vstack = []
 
-    def next_token
-      raise NotImplementedError, "#{self.class}\#next_token is not defined"
-    end
+            @racc_t = nil
+            @racc_val = nil
+
+            @racc_read_next = true
+
+            @racc_user_yyerror = false
+            @racc_error_status = 0
+        end
+
+        ###
+        ### do_parse
+        ###
+
+        def do_parse
+            __send__(Racc_Main_Parsing_Routine, _racc_setup(), false)
+        end
 
-    def _racc_do_parse_rb(arg, in_debug)
-      action_table, action_check, action_default, action_pointer,
-      goto_table,   goto_check,   goto_default,   goto_pointer,
-      nt_base,      reduce_table, token_table,    shift_n,
-      reduce_n,     use_result,   * = arg
-
-      _racc_init_sysvars
-      tok = act = i = nil
-      nerr = 0
-
-      catch(:racc_end_parse) {
-        while true
-          if i = action_pointer[@racc_state[-1]]
-            if @racc_read_next
-              if @racc_t != 0   # not EOF
-                tok, @racc_val = next_token()
-                unless tok      # EOF
-                  @racc_t = 0
+        def next_token
+            raise NotImplementedError, "#{self.class}\#next_token is not defined"
+        end
+
+        def _racc_do_parse_rb(arg, in_debug)
+            action_table, action_check, action_default, action_pointer,
+            goto_table,   goto_check,   goto_default,   goto_pointer,
+            nt_base,      reduce_table, token_table,    shift_n,
+            reduce_n,     use_result,   * = arg
+
+            _racc_init_sysvars
+            tok = act = i = nil
+            nerr = 0
+
+            catch(:racc_end_parse) {
+                while true
+                if i = action_pointer[@racc_state[-1]]
+                    if @racc_read_next
+                        if @racc_t != 0   # not EOF
+                            tok, @racc_val = next_token()
+                            unless tok      # EOF
+                                @racc_t = 0
+                            else
+                                @racc_t = (token_table[tok] or 1)   # error token
+                            end
+                            racc_read_token(@racc_t, tok, @racc_val) if @yydebug
+                            @racc_read_next = false
+                        end
+                    end
+                    i += @racc_t
+                    unless i >= 0 and
+                        act = action_table[i] and
+                        action_check[i] == @racc_state[-1]
+                        act = action_default[@racc_state[-1]]
+                    end
                 else
-                  @racc_t = (token_table[tok] or 1)   # error token
+                    act = action_default[@racc_state[-1]]
+                end
+                while act = _racc_evalact(act, arg)
+                    ;
                 end
-                racc_read_token(@racc_t, tok, @racc_val) if @yydebug
-                @racc_read_next = false
-              end
-            end
-            i += @racc_t
-            unless i >= 0 and
-                   act = action_table[i] and
-                   action_check[i] == @racc_state[-1]
-              act = action_default[@racc_state[-1]]
             end
-          else
-            act = action_default[@racc_state[-1]]
-          end
-          while act = _racc_evalact(act, arg)
-            ;
-          end
-        end
-      }
-    end
+            }
+        end
 
-    ###
-    ### yyparse
-    ###
+        ###
+        ### yyparse
+        ###
 
-    def yyparse(recv, mid)
-      __send__(Racc_YY_Parse_Method, recv, mid, _racc_setup(), true)
-    end
+        def yyparse(recv, mid)
+            __send__(Racc_YY_Parse_Method, recv, mid, _racc_setup(), true)
+        end
 
-    def _racc_yyparse_rb(recv, mid, arg, c_debug)
-      action_table, action_check, action_default, action_pointer,
-      goto_table,   goto_check,   goto_default,   goto_pointer,
-      nt_base,      reduce_table, token_table,    shift_n,
-      reduce_n,     use_result,   * = arg
-
-      _racc_init_sysvars
-      tok = nil
-      act = nil
-      i = nil
-      nerr = 0
-
-      catch(:racc_end_parse) {
-        until i = action_pointer[@racc_state[-1]]
-          while act = _racc_evalact(action_default[@racc_state[-1]], arg)
-            ;
-          end
-        end
-        recv.__send__(mid) do |tok, val|
-          unless tok
-            @racc_t = 0
-          else
-            @racc_t = (token_table[tok] or 1)   # error token
-          end
-          @racc_val = val
-          @racc_read_next = false
-
-          i += @racc_t
-          unless i >= 0 and
-                 act = action_table[i] and
-                 action_check[i] == @racc_state[-1]
-            act = action_default[@racc_state[-1]]
-          end
-          while act = _racc_evalact(act, arg)
-            ;
-          end
-
-          while not (i = action_pointer[@racc_state[-1]]) or
-                not @racc_read_next or
-                @racc_t == 0   # $
-            unless i and i += @racc_t and
-                   i >= 0 and
-                   act = action_table[i] and
-                   action_check[i] == @racc_state[-1]
-              act = action_default[@racc_state[-1]]
+        def _racc_yyparse_rb(recv, mid, arg, c_debug)
+            action_table, action_check, action_default, action_pointer,
+            goto_table,   goto_check,   goto_default,   goto_pointer,
+            nt_base,      reduce_table, token_table,    shift_n,
+            reduce_n,     use_result,   * = arg
+
+            _racc_init_sysvars
+            tok = nil
+            act = nil
+            i = nil
+            nerr = 0
+
+            catch(:racc_end_parse) {
+                until i = action_pointer[@racc_state[-1]]
+                while act = _racc_evalact(action_default[@racc_state[-1]], arg)
+                    ;
+                end
             end
-            while act = _racc_evalact(act, arg)
-              ;
+            recv.__send__(mid) do |tok, val|
+                unless tok
+                    @racc_t = 0
+                else
+                    @racc_t = (token_table[tok] or 1)   # error token
+                end
+                @racc_val = val
+                @racc_read_next = false
+
+                i += @racc_t
+                unless i >= 0 and
+                    act = action_table[i] and
+                    action_check[i] == @racc_state[-1]
+                    act = action_default[@racc_state[-1]]
+                end
+                while act = _racc_evalact(act, arg)
+                    ;
+                end
+
+                while not (i = action_pointer[@racc_state[-1]]) or
+                    not @racc_read_next or
+                    @racc_t == 0   # $
+                    unless i and i += @racc_t and
+                        i >= 0 and
+                        act = action_table[i] and
+                        action_check[i] == @racc_state[-1]
+                    act = action_default[@racc_state[-1]]
+                end
+                while act = _racc_evalact(act, arg)
+                    ;
+                end
+                end
             end
-          end
+            }
         end
-      }
-    end
-
-    ###
-    ### common
-    ###
 
-    def _racc_evalact(act, arg)
-      action_table, action_check, action_default, action_pointer,
-      goto_table,   goto_check,   goto_default,   goto_pointer,
-      nt_base,      reduce_table, token_table,    shift_n,
-      reduce_n,     use_result,   * = arg
-      nerr = 0   # tmp
+        ###
+        ### common
+        ###
+
+        def _racc_evalact(act, arg)
+            action_table, action_check, action_default, action_pointer,
+            goto_table,   goto_check,   goto_default,   goto_pointer,
+            nt_base,      reduce_table, token_table,    shift_n,
+            reduce_n,     use_result,   * = arg
+            nerr = 0   # tmp
+
+            if act > 0 and act < shift_n
+                #
+                # shift
+                #
+                if @racc_error_status > 0
+                    @racc_error_status -= 1 unless @racc_t == 1   # error token
+                end
+                @racc_vstack.push @racc_val
+                @racc_state.push act
+                @racc_read_next = true
+                if @yydebug
+                    @racc_tstack.push @racc_t
+                    racc_shift @racc_t, @racc_tstack, @racc_vstack
+                end
 
-      if act > 0 and act < shift_n
-        #
-        # shift
-        #
-        if @racc_error_status > 0
-          @racc_error_status -= 1 unless @racc_t == 1   # error token
-        end
-        @racc_vstack.push @racc_val
-        @racc_state.push act
-        @racc_read_next = true
-        if @yydebug
-          @racc_tstack.push @racc_t
-          racc_shift @racc_t, @racc_tstack, @racc_vstack
-        end
+            elsif act < 0 and act > -reduce_n
+                #
+                # reduce
+                #
+                code = catch(:racc_jump) {
+                    @racc_state.push _racc_do_reduce(arg, act)
+                    false
+                }
+                if code
+                    case code
+                    when 1 # yyerror
+                        @racc_user_yyerror = true   # user_yyerror
+                        return -reduce_n
+                    when 2 # yyaccept
+                        return shift_n
+                    else
+                        raise '[Racc Bug] unknown jump code'
+                    end
+                end
 
-      elsif act < 0 and act > -reduce_n
-        #
-        # reduce
-        #
-        code = catch(:racc_jump) {
-          @racc_state.push _racc_do_reduce(arg, act)
-          false
-        }
-        if code
-          case code
-          when 1 # yyerror
-            @racc_user_yyerror = true   # user_yyerror
-            return -reduce_n
-          when 2 # yyaccept
-            return shift_n
-          else
-            raise '[Racc Bug] unknown jump code'
-          end
-        end
-
-      elsif act == shift_n
-        #
-        # accept
-        #
-        racc_accept if @yydebug
-        throw :racc_end_parse, @racc_vstack[0]
+            elsif act == shift_n
+                #
+                # accept
+                #
+                racc_accept if @yydebug
+                throw :racc_end_parse, @racc_vstack[0]
+
+            elsif act == -reduce_n
+                #
+                # error
+                #
+                case @racc_error_status
+                when 0
+                    unless arg[21]    # user_yyerror
+                        nerr += 1
+                        on_error @racc_t, @racc_val, @racc_vstack
+                    end
+                when 3
+                    if @racc_t == 0   # is $
+                        throw :racc_end_parse, nil
+                    end
+                    @racc_read_next = true
+                end
+                @racc_user_yyerror = false
+                @racc_error_status = 3
+                while true
+                    if i = action_pointer[@racc_state[-1]]
+                        i += 1   # error token
+                        if  i >= 0 and
+                            (act = action_table[i]) and
+                            action_check[i] == @racc_state[-1]
+                            break
+                        end
+                    end
+                    throw :racc_end_parse, nil if @racc_state.size <= 1
+                    @racc_state.pop
+                    @racc_vstack.pop
+                    if @yydebug
+                        @racc_tstack.pop
+                        racc_e_pop @racc_state, @racc_tstack, @racc_vstack
+                    end
+                end
+                return act
 
-      elsif act == -reduce_n
-        #
-        # error
-        #
-        case @racc_error_status
-        when 0
-          unless arg[21]    # user_yyerror
-            nerr += 1
-            on_error @racc_t, @racc_val, @racc_vstack
-          end
-        when 3
-          if @racc_t == 0   # is $
-            throw :racc_end_parse, nil
-          end
-          @racc_read_next = true
-        end
-        @racc_user_yyerror = false
-        @racc_error_status = 3
-        while true
-          if i = action_pointer[@racc_state[-1]]
-            i += 1   # error token
-            if  i >= 0 and
-                (act = action_table[i]) and
-                action_check[i] == @racc_state[-1]
-              break
+            else
+                raise "[Racc Bug] unknown action #{act.inspect}"
             end
-          end
-          throw :racc_end_parse, nil if @racc_state.size <= 1
-          @racc_state.pop
-          @racc_vstack.pop
-          if @yydebug
-            @racc_tstack.pop
-            racc_e_pop @racc_state, @racc_tstack, @racc_vstack
-          end
+
+            racc_next_state(@racc_state[-1], @racc_state) if @yydebug
+
+            nil
         end
-        return act
 
-      else
-        raise "[Racc Bug] unknown action #{act.inspect}"
-      end
+        def _racc_do_reduce(arg, act)
+            action_table, action_check, action_default, action_pointer,
+            goto_table,   goto_check,   goto_default,   goto_pointer,
+            nt_base,      reduce_table, token_table,    shift_n,
+            reduce_n,     use_result,   * = arg
+            state = @racc_state
+            vstack = @racc_vstack
+            tstack = @racc_tstack
+
+            i = act * -3
+            len       = reduce_table[i]
+            reduce_to = reduce_table[i+1]
+            method_id = reduce_table[i+2]
+            void_array = []
+
+            tmp_t = tstack[-len, len] if @yydebug
+            tmp_v = vstack[-len, len]
+            tstack[-len, len] = void_array if @yydebug
+            vstack[-len, len] = void_array
+            state[-len, len]  = void_array
+
+            # tstack must be updated AFTER method call
+            if use_result
+                vstack.push __send__(method_id, tmp_v, vstack, tmp_v[0])
+            else
+                vstack.push __send__(method_id, tmp_v, vstack)
+            end
+            tstack.push reduce_to
+
+            racc_reduce(tmp_t, reduce_to, tstack, vstack) if @yydebug
 
-      racc_next_state(@racc_state[-1], @racc_state) if @yydebug
+            k1 = reduce_to - nt_base
+            if i = goto_pointer[k1]
+                i += state[-1]
+                if i >= 0 and (curstate = goto_table[i]) and goto_check[i] == k1
+                    return curstate
+                end
+            end
+            goto_default[k1]
+        end
 
-      nil
-    end
+        def on_error(t, val, vstack)
+            raise ParseError, sprintf("\nparse error on value %s (%s)", val.inspect, token_to_str(t) || '?')
+        end
 
-    def _racc_do_reduce(arg, act)
-      action_table, action_check, action_default, action_pointer,
-      goto_table,   goto_check,   goto_default,   goto_pointer,
-      nt_base,      reduce_table, token_table,    shift_n,
-      reduce_n,     use_result,   * = arg
-      state = @racc_state
-      vstack = @racc_vstack
-      tstack = @racc_tstack
-
-      i = act * -3
-      len       = reduce_table[i]
-      reduce_to = reduce_table[i+1]
-      method_id = reduce_table[i+2]
-      void_array = []
-
-      tmp_t = tstack[-len, len] if @yydebug
-      tmp_v = vstack[-len, len]
-      tstack[-len, len] = void_array if @yydebug
-      vstack[-len, len] = void_array
-      state[-len, len]  = void_array
-
-      # tstack must be updated AFTER method call
-      if use_result
-        vstack.push __send__(method_id, tmp_v, vstack, tmp_v[0])
-      else
-        vstack.push __send__(method_id, tmp_v, vstack)
-      end
-      tstack.push reduce_to
-
-      racc_reduce(tmp_t, reduce_to, tstack, vstack) if @yydebug
-
-      k1 = reduce_to - nt_base
-      if i = goto_pointer[k1]
-        i += state[-1]
-        if i >= 0 and (curstate = goto_table[i]) and goto_check[i] == k1
-          return curstate
-        end
-      end
-      goto_default[k1]
-    end
+        def yyerror
+            throw :racc_jump, 1
+        end
 
-    def on_error(t, val, vstack)
-      raise ParseError, sprintf("\nparse error on value %s (%s)",
-                                val.inspect, token_to_str(t) || '?')
-    end
+        def yyaccept
+            throw :racc_jump, 2
+        end
 
-    def yyerror
-      throw :racc_jump, 1
-    end
+        def yyerrok
+            @racc_error_status = 0
+        end
 
-    def yyaccept
-      throw :racc_jump, 2
-    end
+        #
+        # for debugging output
+        #
 
-    def yyerrok
-      @racc_error_status = 0
-    end
+        def racc_read_token(t, tok, val)
+            @racc_debug_out.print 'read    '
+            @racc_debug_out.print tok.inspect, '(', racc_token2str(t), ') '
+            @racc_debug_out.puts val.inspect
+            @racc_debug_out.puts
+        end
 
-    #
-    # for debugging output
-    #
+        def racc_shift(tok, tstack, vstack)
+            @racc_debug_out.puts "shift   #{racc_token2str tok}"
+            racc_print_stacks tstack, vstack
+            @racc_debug_out.puts
+        end
 
-    def racc_read_token(t, tok, val)
-      @racc_debug_out.print 'read    '
-      @racc_debug_out.print tok.inspect, '(', racc_token2str(t), ') '
-      @racc_debug_out.puts val.inspect
-      @racc_debug_out.puts
-    end
+        def racc_reduce(toks, sim, tstack, vstack)
+            out = @racc_debug_out
+            out.print 'reduce '
+            if toks.empty?
+                out.print ' <none>'
+            else
+                toks.each {|t| out.print ' ', racc_token2str(t) }
+            end
+            out.puts " --> #{racc_token2str(sim)}"
 
-    def racc_shift(tok, tstack, vstack)
-      @racc_debug_out.puts "shift   #{racc_token2str tok}"
-      racc_print_stacks tstack, vstack
-      @racc_debug_out.puts
-    end
+            racc_print_stacks tstack, vstack
+            @racc_debug_out.puts
+        end
 
-    def racc_reduce(toks, sim, tstack, vstack)
-      out = @racc_debug_out
-      out.print 'reduce '
-      if toks.empty?
-        out.print ' <none>'
-      else
-        toks.each {|t| out.print ' ', racc_token2str(t) }
-      end
-      out.puts " --> #{racc_token2str(sim)}"
-
-      racc_print_stacks tstack, vstack
-      @racc_debug_out.puts
-    end
+        def racc_accept
+            @racc_debug_out.puts 'accept'
+            @racc_debug_out.puts
+        end
 
-    def racc_accept
-      @racc_debug_out.puts 'accept'
-      @racc_debug_out.puts
-    end
+        def racc_e_pop(state, tstack, vstack)
+            @racc_debug_out.puts 'error recovering mode: pop token'
+            racc_print_states state
+            racc_print_stacks tstack, vstack
+            @racc_debug_out.puts
+        end
 
-    def racc_e_pop(state, tstack, vstack)
-      @racc_debug_out.puts 'error recovering mode: pop token'
-      racc_print_states state
-      racc_print_stacks tstack, vstack
-      @racc_debug_out.puts
-    end
+        def racc_next_state(curstate, state)
+            @racc_debug_out.puts  "goto    #{curstate}"
+            racc_print_states state
+            @racc_debug_out.puts
+        end
 
-    def racc_next_state(curstate, state)
-      @racc_debug_out.puts  "goto    #{curstate}"
-      racc_print_states state
-      @racc_debug_out.puts
-    end
+        def racc_print_stacks(t, v)
+            out = @racc_debug_out
+            out.print '        ['
+            t.each_index do |i|
+                out.print ' (', racc_token2str(t[i]), ' ', v[i].inspect, ')'
+            end
+            out.puts ' ]'
+        end
 
-    def racc_print_stacks(t, v)
-      out = @racc_debug_out
-      out.print '        ['
-      t.each_index do |i|
-        out.print ' (', racc_token2str(t[i]), ' ', v[i].inspect, ')'
-      end
-      out.puts ' ]'
-    end
+        def racc_print_states(s)
+            out = @racc_debug_out
+            out.print '        ['
+            s.each {|st| out.print ' ', st }
+            out.puts ' ]'
+        end
 
-    def racc_print_states(s)
-      out = @racc_debug_out
-      out.print '        ['
-      s.each {|st| out.print ' ', st }
-      out.puts ' ]'
-    end
+        def racc_token2str(tok)
+            self.class::Racc_token_to_s_table[tok] or
+                raise "[Racc Bug] can't convert token #{tok} to string"
+        end
 
-    def racc_token2str(tok)
-      self.class::Racc_token_to_s_table[tok] or
-          raise "[Racc Bug] can't convert token #{tok} to string"
-    end
+        def token_to_str(t)
+            self.class::Racc_token_to_s_table[t]
+        end
 
-    def token_to_str(t)
-      self.class::Racc_token_to_s_table[t]
     end
 
-  end
-
 end
 ..end racc/parser.rb modeval..id5256434e8a
 end
@@ -460,68 +459,68 @@ end
 
 module Nagios
 
-  class Parser < Racc::Parser
+    class Parser < Racc::Parser
 
 module_eval <<'..end grammar.ry modeval..idcb2ea30b34', 'grammar.ry', 57
 
 class ::Nagios::Parser::SyntaxError < RuntimeError; end
 
 def parse(src)
-	@src = src
+    @src = src
 
-	# state variables
-	@invar = false
-	@inobject = false
-	@done = false
+    # state variables
+    @invar = false
+    @inobject = false
+    @done = false
 
-	@line = 0
-	@yydebug = true
+    @line = 0
+    @yydebug = true
 
     do_parse
 end
 
 # The lexer.  Very simple.
 def token
-	@src.sub!(/\A\n/,'')
-	if $&
-		@line += 1
-		return [ :RETURN, "\n" ]
-	end
-
-	if @done
-		return nil
-	end
-	yytext = String.new
-
-
-	# remove comments from this line
-	@src.sub!(/\A[ \t]*;.*\n/,"\n")
-	if $&
-		return [:INLINECOMMENT, ""]
-	end
-
-	@src.sub!(/\A#.*\n/,"\n")
-	if $&
-		return [:COMMENT, ""]
-	end
-
-	@src.sub!(/#.*/,'')
-
-	if @src.length == 0
-		@done = true
-		return [false, '$']
-	end
-
-	if @invar
-		@src.sub!(/\A[ \t]+/,'')
-		@src.sub!(/\A([^;\n]+)(\n|;)/,'\2')
-		if $1
-			yytext += $1
-		end
-		@invar = false
-		return [:VALUE, yytext]
-	else
-		@src.sub!(/\A[\t ]*(\S+)([\t ]*|$)/,'')
+    @src.sub!(/\A\n/,'')
+    if $&
+        @line += 1
+        return [ :RETURN, "\n" ]
+        end
+
+        if @done
+            return nil
+        end
+        yytext = String.new
+
+
+        # remove comments from this line
+        @src.sub!(/\A[ \t]*;.*\n/,"\n")
+        if $&
+            return [:INLINECOMMENT, ""]
+        end
+
+        @src.sub!(/\A#.*\n/,"\n")
+        if $&
+            return [:COMMENT, ""]
+        end
+
+        @src.sub!(/#.*/,'')
+
+        if @src.length == 0
+            @done = true
+            return [false, '$']
+        end
+
+        if @invar
+            @src.sub!(/\A[ \t]+/,'')
+            @src.sub!(/\A([^;\n]+)(\n|;)/,'\2')
+            if $1
+                yytext += $1
+                end
+                @invar = false
+                return [:VALUE, yytext]
+        else
+            @src.sub!(/\A[\t ]*(\S+)([\t ]*|$)/,'')
         if $1
             yytext = $1
             case yytext
@@ -561,11 +560,11 @@ def token
                 end
             end
         end
-	end
+        end
 end
 
 def next_token
-	token
+    token
 end
 
 def yydebug
@@ -577,109 +576,105 @@ def yywrap
 end
 
 def on_error(token, value, vstack )
-	msg = ""
-	unless value.nil?
-		msg = "line #{@line}: syntax error at '#{value}'"
-	else
-		msg = "line #{@line}: syntax error at '#{token}'"
-	end
-	unless @src.size > 0
-		msg = "line #{@line}: Unexpected end of file"
-	end
-	if token == '$end'.intern
-		puts "okay, this is silly"
-	else
-		raise ::Nagios::Parser::SyntaxError, msg
-	end
+    msg = ""
+    unless value.nil?
+        msg = "line #{@line}: syntax error at '#{value}'"
+        else
+            msg = "line #{@line}: syntax error at '#{token}'"
+        end
+        unless @src.size > 0
+            msg = "line #{@line}: Unexpected end of file"
+        end
+        if token == '$end'.intern
+            puts "okay, this is silly"
+        else
+            raise ::Nagios::Parser::SyntaxError, msg
+        end
 end
 ..end grammar.ry modeval..idcb2ea30b34
 
 ##### racc 1.4.5 generates ###
 
 racc_reduce_table = [
- 0, 0, :racc_error,
- 1, 13, :_reduce_1,
- 2, 13, :_reduce_2,
- 1, 14, :_reduce_3,
- 1, 14, :_reduce_4,
- 1, 14, :_reduce_none,
- 2, 16, :_reduce_6,
- 6, 15, :_reduce_7,
- 1, 17, :_reduce_none,
- 2, 17, :_reduce_9,
- 4, 18, :_reduce_10,
- 1, 20, :_reduce_none,
- 2, 20, :_reduce_none,
- 0, 19, :_reduce_none,
- 1, 19, :_reduce_none ]
+    0, 0, :racc_error,
+    1, 13, :_reduce_1,
+    2, 13, :_reduce_2,
+    1, 14, :_reduce_3,
+    1, 14, :_reduce_4,
+    1, 14, :_reduce_none,
+    2, 16, :_reduce_6,
+    6, 15, :_reduce_7,
+    1, 17, :_reduce_none,
+    2, 17, :_reduce_9,
+    4, 18, :_reduce_10,
+    1, 20, :_reduce_none,
+    2, 20, :_reduce_none,
+    0, 19, :_reduce_none,
+    1, 19, :_reduce_none ]
 
 racc_reduce_n = 15
 
 racc_shift_n = 26
 
 racc_action_table = [
-     9,    15,     1,    20,     1,    14,    12,    13,    11,     6,
-     7,     6,     7,    15,    18,     8,    21,    23,    25 ]
+    9,    15,     1,    20,     1,    14,    12,    13,    11,     6,
+    7,     6,     7,    15,    18,     8,    21,    23,    25 ]
 
 racc_action_check = [
-     2,    16,     2,    16,     0,    12,     8,     9,     7,     2,
-     2,     0,     0,    14,    15,     1,    18,    22,    24 ]
+    2,    16,     2,    16,     0,    12,     8,     9,     7,     2,
+    2,     0,     0,    14,    15,     1,    18,    22,    24 ]
 
 racc_action_pointer = [
-     2,    12,     0,   nil,   nil,   nil,   nil,    -1,     0,     7,
-   nil,   nil,    -4,   nil,     8,     6,    -4,   nil,     5,   nil,
-   nil,   nil,     8,   nil,     9,   nil ]
+    2,    12,     0,   nil,   nil,   nil,   nil,    -1,     0,     7,
+    nil,   nil,    -4,   nil,     8,     6,    -4,   nil,     5,   nil,
+    nil,   nil,     8,   nil,     9,   nil ]
 
 racc_action_default = [
-   -15,   -15,   -15,    -1,    -3,    -5,    -4,   -15,   -15,   -15,
+    -15,   -15,   -15,    -1,    -3,    -5,    -4,   -15,   -15,   -15,
     -2,    -6,   -15,    26,   -15,   -15,   -15,    -8,   -13,    -9,
     -7,   -14,   -15,   -11,   -10,   -12 ]
 
-racc_goto_table = [
-    17,     3,    19,    10,     2,    16,    22,    24 ]
+racc_goto_table = [ 17,     3,    19,    10,     2,    16,    22,    24 ]
 
-racc_goto_check = [
-     6,     2,     6,     2,     1,     5,     7,     8 ]
+racc_goto_check = [ 6,     2,     6,     2,     1,     5,     7,     8 ]
 
-racc_goto_pointer = [
-   nil,     4,     1,   nil,   nil,    -9,   -14,   -12,   -15 ]
+racc_goto_pointer = [ nil,     4,     1,   nil,   nil,    -9,   -14,   -12,   -15 ]
 
-racc_goto_default = [
-   nil,   nil,   nil,     4,     5,   nil,   nil,   nil,   nil ]
+racc_goto_default = [ nil,   nil,   nil,     4,     5,   nil,   nil,   nil,   nil ]
 
 racc_token_table = {
- false => 0,
- Object.new => 1,
- :DEFINE => 2,
- :NAME => 3,
- :STRING => 4,
- :PARAM => 5,
- :LCURLY => 6,
- :RCURLY => 7,
- :VALUE => 8,
- :RETURN => 9,
- :COMMENT => 10,
- :INLINECOMMENT => 11 }
+    false => 0,
+    Object.new => 1,
+    :DEFINE => 2,
+    :NAME => 3,
+    :STRING => 4,
+    :PARAM => 5,
+    :LCURLY => 6,
+    :RCURLY => 7,
+    :VALUE => 8,
+    :RETURN => 9,
+    :COMMENT => 10,
+    :INLINECOMMENT => 11 }
 
 racc_use_result_var = true
 
 racc_nt_base = 12
 
 Racc_arg = [
- racc_action_table,
- racc_action_check,
- racc_action_default,
- racc_action_pointer,
- racc_goto_table,
- racc_goto_check,
- racc_goto_default,
- racc_goto_pointer,
- racc_nt_base,
- racc_reduce_table,
- racc_token_table,
- racc_shift_n,
- racc_reduce_n,
- racc_use_result_var ]
+    racc_action_table,
+    racc_action_check,
+    racc_action_default,
+    racc_action_pointer,
+    racc_goto_table,
+    racc_goto_check,
+    racc_goto_default,
+    racc_goto_pointer,
+    racc_nt_base,
+    racc_reduce_table,
+    racc_token_table,
+    racc_shift_n,
+    racc_reduce_n,
+    racc_use_result_var ]
 
 Racc_token_to_s_table = [
 '$end',
@@ -708,91 +703,91 @@ Racc_debug_parser = false
 
 ##### racc system variables end #####
 
- # reduce 0 omitted
+# reduce 0 omitted
 
 module_eval <<'.,.,', 'grammar.ry', 6
-  def _reduce_1( val, _values, result )
- return val[0] if val[0]
-   result
-  end
+    def _reduce_1( val, _values, result )
+return val[0] if val[0]
+    result
+end
 .,.,
 
 module_eval <<'.,.,', 'grammar.ry', 18
-  def _reduce_2( val, _values, result )
-		if val[1].nil?
-			result = val[0]
-		else
-			if val[0].nil?
-				result = val[1]
-			else
-				result = [ val[0], val[1] ].flatten
-			end
-		end
-   result
-  end
+    def _reduce_2( val, _values, result )
+        if val[1].nil?
+            result = val[0]
+                else
+                    if val[0].nil?
+                        result = val[1]
+                            else
+                                result = [ val[0], val[1] ].flatten
+                            end
+                    end
+    result
+    end
 .,.,
 
 module_eval <<'.,.,', 'grammar.ry', 20
-  def _reduce_3( val, _values, result )
- result = [val[0]]
-   result
-  end
+    def _reduce_3( val, _values, result )
+result = [val[0]]
+    result
+end
 .,.,
 
 module_eval <<'.,.,', 'grammar.ry', 21
-  def _reduce_4( val, _values, result )
- result = nil
-   result
-  end
+    def _reduce_4( val, _values, result )
+result = nil
+    result
+end
 .,.,
 
- # reduce 5 omitted
+# reduce 5 omitted
 
 module_eval <<'.,.,', 'grammar.ry', 25
-  def _reduce_6( val, _values, result )
- result = nil
-   result
-  end
+    def _reduce_6( val, _values, result )
+result = nil
+    result
+end
 .,.,
 
 module_eval <<'.,.,', 'grammar.ry', 31
-  def _reduce_7( val, _values, result )
-		result = Nagios::Base.create(val[1],val[4])
-   result
-  end
+    def _reduce_7( val, _values, result )
+        result = Nagios::Base.create(val[1],val[4])
+    result
+    end
 .,.,
 
- # reduce 8 omitted
+# reduce 8 omitted
 
 module_eval <<'.,.,', 'grammar.ry', 40
-  def _reduce_9( val, _values, result )
-		val[1].each {|p,v|
-			val[0][p] = v
-		}
-		result = val[0]
-   result
-  end
+    def _reduce_9( val, _values, result )
+        val[1].each {|p,v|
+            val[0][p] = v
+                }
+                result = val[0]
+    result
+    end
 .,.,
 
 module_eval <<'.,.,', 'grammar.ry', 42
-  def _reduce_10( val, _values, result )
- result = {val[0],val[1]}
-   result
-  end
+    def _reduce_10( val, _values, result )
+result = {val[0],val[1]}
+    result
+end
 .,.,
 
- # reduce 11 omitted
+# reduce 11 omitted
 
- # reduce 12 omitted
+# reduce 12 omitted
 
- # reduce 13 omitted
+# reduce 13 omitted
 
- # reduce 14 omitted
+# reduce 14 omitted
 
- def _reduce_none( val, _values, result )
-  result
- end
+def _reduce_none( val, _values, result )
+    result
+end
 
-  end   # class Parser
+    end   # class Parser
 
 end   # module Nagios