Changed indentation to be more consistent with style guide (4 spaces per level)

21 files changed, 1067 insertions, 1067 deletions

diff --git a/lib/puppet/external/dot.rb b/lib/puppet/external/dot.rb
index caeee21ca..fcd5c6a85 100644
--- a/lib/puppet/external/dot.rb
+++ b/lib/puppet/external/dot.rb
@@ -8,319 +8,319 @@
 
 module DOT
     
-  # These glogal vars are used to make nice graph source.
+    # These glogal vars are used to make nice graph source.
 
-  $tab  = '    '
-  $tab2 = $tab * 2
+    $tab  = '    '
+    $tab2 = $tab * 2
     
-  # if we don't like 4 spaces, we can change it any time
+    # if we don't like 4 spaces, we can change it any time
 
-  def change_tab (t)
-    $tab  = t
-    $tab2 = t * 2
-  end
+    def change_tab (t)
+        $tab  = t
+        $tab2 = t * 2
+    end
     
-  # options for node declaration
-
-  NODE_OPTS = [
-    # attributes due to
-    # http://www.graphviz.org/Documentation/dotguide.pdf
-    # March, 26, 2005
-    'bottomlabel', # auxiliary label for nodes of shape M*
-    'color', # default: black; node shape color
-    'comment', # any string (format-dependent)
-    'distortion', # default: 0.0; node distortion for shape=polygon
-    'fillcolor', # default: lightgrey/black; node fill color
-    'fixedsize', # default: false; label text has no affect on node size
-    'fontcolor', # default: black; type face color
-    'fontname', # default: Times-Roman; font family
-    'fontsize', #default: 14; point size of label
-    'group', # name of node�s group
-    'height', # default: .5; height in inches
-    'label', # default: node name; any string
-    'layer', # default: overlay range; all, id or id:id
-    'orientation', # dafault: 0.0; node rotation angle
-    'peripheries', # shape-dependent number of node boundaries
-    'regular', # default:  false; force polygon to be regular
-    'shape', # default: ellipse; node shape; see Section 2.1 and Appendix E
-    'shapefile', # external EPSF or SVG custom shape file
-    'sides', # default: 4; number of sides for shape=polygon
-    'skew' , # default: 0.0; skewing of node for shape=polygon
-    'style', # graphics options, e.g. bold, dotted, filled; cf. Section 2.3
-    'toplabel', # auxiliary label for nodes of shape M*
-    'URL', # URL associated with node (format-dependent)
-    'width', # default: .75; width in inches
-    'z', #default: 0.0; z coordinate for VRML output
-
-    # maintained for backward compatibility or rdot internal
-    'bgcolor',
-    'rank'
-  ]
+    # options for node declaration
+
+    NODE_OPTS = [
+        # attributes due to
+        # http://www.graphviz.org/Documentation/dotguide.pdf
+        # March, 26, 2005
+        'bottomlabel', # auxiliary label for nodes of shape M*
+        'color',       # default: black; node shape color
+        'comment',     # any string (format-dependent)
+        'distortion',  # default: 0.0; node distortion for shape=polygon
+        'fillcolor',   # default: lightgrey/black; node fill color
+        'fixedsize',   # default: false; label text has no affect on node size
+        'fontcolor',   # default: black; type face color
+        'fontname',    # default: Times-Roman; font family
+        'fontsize',    # default: 14; point size of label
+        'group',       # name of node�s group
+        'height',      # default: .5; height in inches
+        'label',       # default: node name; any string
+        'layer',       # default: overlay range; all, id or id:id
+        'orientation', # dafault: 0.0; node rotation angle
+        'peripheries', # shape-dependent number of node boundaries
+        'regular',     # default:  false; force polygon to be regular
+        'shape',       # default: ellipse; node shape; see Section 2.1 and Appendix E
+        'shapefile',   # external EPSF or SVG custom shape file
+        'sides',       # default: 4; number of sides for shape=polygon
+        'skew' ,       # default: 0.0; skewing of node for shape=polygon
+        'style',       # graphics options, e.g. bold, dotted, filled; cf. Section 2.3
+        'toplabel',    # auxiliary label for nodes of shape M*
+        'URL',         # URL associated with node (format-dependent)
+        'width',       # default: .75; width in inches
+        'z',           # default: 0.0; z coordinate for VRML output
+
+        # maintained for backward compatibility or rdot internal
+        'bgcolor',
+        'rank'
+    ]
     
-  # options for edge declaration
-
-  EDGE_OPTS = [
-    'arrowhead', # default: normal; style of arrowhead at head end
-    'arrowsize', # default: 1.0; scaling factor for arrowheads
-    'arrowtail', # default: normal; style of arrowhead at tail end
-    'color', # default: black; edge stroke color
-    'comment', # any string (format-dependent)
-    'constraint', # default: true use edge to affect node ranking
-    'decorate', # if set, draws a line connecting labels with their edges
-    'dir', # default: forward; forward, back, both, or none
-    'fontcolor', # default: black type face color
-    'fontname', # default: Times-Roman; font family
-    'fontsize', # default: 14; point size of label
-    'headlabel', # label placed near head of edge
-    'headport', # n,ne,e,se,s,sw,w,nw
-    'headURL', # URL attached to head label if output format is ismap
-    'label', # edge label
-    'labelangle', # default: -25.0; angle in degrees which head or tail label is rotated off edge
-    'labeldistance', # default: 1.0; scaling factor for distance of head or tail label from node
-    'labelfloat', # default: false; lessen constraints on edge label placement
-    'labelfontcolor', # default: black; type face color for head and tail labels
-    'labelfontname', # default: Times-Roman; font family for head and tail labels
-    'labelfontsize', # default: 14 point size for head and tail labels
-    'layer', # default: overlay range; all, id or id:id
-    'lhead', # name of cluster to use as head of edge
-    'ltail', # name of cluster to use as tail of edge
-    'minlen', # default: 1 minimum rank distance between head and tail
-    'samehead', # tag for head node; edge heads with the same tag are merged onto the same port
-    'sametail', # tag for tail node; edge tails with the same tag are merged onto the same port
-    'style', # graphics options, e.g. bold, dotted, filled; cf. Section 2.3
-    'taillabel', # label placed near tail of edge
-    'tailport', # n,ne,e,se,s,sw,w,nw
-    'tailURL', # URL attached to tail label if output format is ismap
-    'weight', # default: 1; integer cost of stretching an edge
-
-    # maintained for backward compatibility or rdot internal
-    'id'
-  ]
+    # options for edge declaration
+
+    EDGE_OPTS = [
+        'arrowhead',      # default: normal; style of arrowhead at head end
+        'arrowsize',      # default: 1.0; scaling factor for arrowheads
+        'arrowtail',      # default: normal; style of arrowhead at tail end
+        'color',          # default: black; edge stroke color
+        'comment',        # any string (format-dependent)
+        'constraint',     # default: true use edge to affect node ranking
+        'decorate',       # if set, draws a line connecting labels with their edges
+        'dir',            # default: forward; forward, back, both, or none
+        'fontcolor',      # default: black type face color
+        'fontname',       # default: Times-Roman; font family
+        'fontsize',       # default: 14; point size of label
+        'headlabel',      # label placed near head of edge
+        'headport',       # n,ne,e,se,s,sw,w,nw
+        'headURL',        # URL attached to head label if output format is ismap
+        'label',          # edge label
+        'labelangle',     # default: -25.0; angle in degrees which head or tail label is rotated off edge
+        'labeldistance',  # default: 1.0; scaling factor for distance of head or tail label from node
+        'labelfloat',     # default: false; lessen constraints on edge label placement
+        'labelfontcolor', # default: black; type face color for head and tail labels
+        'labelfontname',  # default: Times-Roman; font family for head and tail labels
+        'labelfontsize',  # default: 14 point size for head and tail labels
+        'layer',          # default: overlay range; all, id or id:id
+        'lhead',          # name of cluster to use as head of edge
+        'ltail',          # name of cluster to use as tail of edge
+        'minlen',         # default: 1 minimum rank distance between head and tail
+        'samehead',       # tag for head node; edge heads with the same tag are merged onto the same port
+        'sametail',       # tag for tail node; edge tails with the same tag are merged onto the same port
+        'style',          # graphics options, e.g. bold, dotted, filled; cf. Section 2.3
+        'taillabel',      # label placed near tail of edge
+        'tailport',       # n,ne,e,se,s,sw,w,nw
+        'tailURL',        # URL attached to tail label if output format is ismap
+        'weight',         # default: 1; integer cost of stretching an edge
+
+        # maintained for backward compatibility or rdot internal
+        'id'
+    ]
     
-  # options for graph declaration
-
-  GRAPH_OPTS = [
-    'bgcolor',
-    'center', 'clusterrank', 'color', 'concentrate',
-    'fontcolor', 'fontname', 'fontsize',
-    'label', 'layerseq',
-    'margin', 'mclimit',
-    'nodesep', 'nslimit',
-    'ordering', 'orientation',
-    'page',
-    'rank', 'rankdir', 'ranksep', 'ratio',
-    'size'
-  ]
+    # options for graph declaration
+
+    GRAPH_OPTS = [
+        'bgcolor',
+        'center', 'clusterrank', 'color', 'concentrate',
+        'fontcolor', 'fontname', 'fontsize',
+        'label', 'layerseq',
+        'margin', 'mclimit',
+        'nodesep', 'nslimit',
+        'ordering', 'orientation',
+        'page',
+        'rank', 'rankdir', 'ranksep', 'ratio',
+        'size'
+    ]
     
-  # a root class for any element in dot notation
+    # a root class for any element in dot notation
 
-  class DOTSimpleElement
+    class DOTSimpleElement
 
-    attr_accessor :name
+        attr_accessor :name
 
-    def initialize (params = {})
-      @label = params['name'] ? params['name'] : ''
-    end
+        def initialize (params = {})
+            @label = params['name'] ? params['name'] : ''
+        end
 
-    def to_s
-      @name
+        def to_s
+            @name
+        end
     end
-  end
     
-  # an element that has options ( node, edge, or graph )
-
-  class DOTElement < DOTSimpleElement
-
-    # attr_reader :parent
-    attr_accessor :name, :options
-
-    def initialize (params = {}, option_list = [])
-      super(params)
-      @name   = params['name']   ? params['name']   : nil 
-      @parent = params['parent'] ? params['parent'] : nil
-      @options = {}
-      option_list.each{ |i|
-        @options[i] = params[i] if params[i]
-      }
-      @options['label'] ||= @name if @name != 'node'
-    end
-        
-    def each_option
-      @options.each{ |i| yield i }
-    end
+    # an element that has options ( node, edge, or graph )
 
-    def each_option_pair
-      @options.each_pair{ |key, val| yield key, val }
-    end
+    class DOTElement < DOTSimpleElement
+
+        # attr_reader :parent
+        attr_accessor :name, :options
+
+        def initialize (params = {}, option_list = [])
+            super(params)
+            @name   = params['name']   ? params['name']   : nil
+            @parent = params['parent'] ? params['parent'] : nil
+            @options = {}
+            option_list.each{ |i|
+                @options[i] = params[i] if params[i]
+            }
+            @options['label'] ||= @name if @name != 'node'
+        end
+
+        def each_option
+            @options.each{ |i| yield i }
+        end
+
+        def each_option_pair
+            @options.each_pair{ |key, val| yield key, val }
+        end
 
-    #def parent=( thing )
-    #    @parent.delete( self ) if defined?( @parent ) and @parent
-    #    @parent = thing
-    #end
+        #def parent=( thing )
+        #    @parent.delete( self ) if defined?( @parent ) and @parent
+        #    @parent = thing
+        #end
 
-  end
+    end
     
     
-  # This is used when we build nodes that have shape=record
-  # ports don't have options :)
+    # This is used when we build nodes that have shape=record
+    # ports don't have options :)
 
-  class DOTPort < DOTSimpleElement
+    class DOTPort < DOTSimpleElement
 
-    attr_accessor :label
-        
-    def initialize (params = {})
-      super(params)
-      @name = params['label'] ? params['label'] : ''
-    end
+        attr_accessor :label
 
-    def to_s
-      ( @name && @name != "" ? "<#{@name}>" : "" ) + "#{@label}"
+        def initialize (params = {})
+            super(params)
+            @name = params['label'] ? params['label'] : ''
+        end
+
+        def to_s
+            ( @name && @name != "" ? "<#{@name}>" : "" ) + "#{@label}"
+        end
     end
-  end
     
-  # node element
+    # node element
 
-  class DOTNode < DOTElement
+    class DOTNode < DOTElement
 
-    @ports
+        @ports
 
-    def initialize (params = {}, option_list = NODE_OPTS)
-      super(params, option_list)
-      @ports = params['ports'] ? params['ports'] : []
-    end
+        def initialize (params = {}, option_list = NODE_OPTS)
+            super(params, option_list)
+            @ports = params['ports'] ? params['ports'] : []
+        end
 
-    def each_port
-      @ports.each { |i| yield i }
-    end
+        def each_port
+            @ports.each { |i| yield i }
+        end
 
-    def << (thing)
-      @ports << thing
-    end
+        def << (thing)
+            @ports << thing
+        end
 
-    def push (thing)
-      @ports.push(thing)
-    end
+        def push (thing)
+            @ports.push(thing)
+        end
 
-    def pop
-      @ports.pop
-    end
+        def pop
+            @ports.pop
+        end
 
-    def to_s (t = '')
+        def to_s (t = '')
 
-      # This code is totally incomprehensible; it needs to be replaced!
+            # This code is totally incomprehensible; it needs to be replaced!
 
-      label = @options['shape'] != 'record' && @ports.length == 0 ?
-                @options['label'] ? 
-                    t + $tab + "label = \"#{@options['label']}\"\n" :
-                    '' :
-                t + $tab + 'label = "' + " \\\n" +
-                t + $tab2 + "#{@options['label']}| \\\n" +
-                @ports.collect{ |i|
-                    t + $tab2 + i.to_s
-                }.join( "| \\\n" ) + " \\\n" +
-                t + $tab + '"' + "\n"
-            
-            t + "#{@name} [\n" +
-            @options.to_a.collect{ |i|
-                i[1] && i[0] != 'label' ? 
-                    t + $tab + "#{i[0]} = #{i[1]}" : nil
-            }.compact.join( ",\n" ) + ( label != '' ? ",\n" : "\n" ) + 
-            label +
-            t + "]\n" 
-      end
+            label = @options['shape'] != 'record' && @ports.length == 0 ?
+                    @options['label'] ?
+                        t + $tab + "label = \"#{@options['label']}\"\n" :
+                        '' :
+                    t + $tab + 'label = "' + " \\\n" +
+                    t + $tab2 + "#{@options['label']}| \\\n" +
+                    @ports.collect{ |i|
+                        t + $tab2 + i.to_s
+                    }.join( "| \\\n" ) + " \\\n" +
+                    t + $tab + '"' + "\n"
 
-  end # class DOTNode
+                t + "#{@name} [\n" +
+                @options.to_a.collect{ |i|
+                    i[1] && i[0] != 'label' ?
+                        t + $tab + "#{i[0]} = #{i[1]}" : nil
+                }.compact.join( ",\n" ) + ( label != '' ? ",\n" : "\n" ) +
+                label +
+                t + "]\n"
+        end
 
-  # A subgraph element is the same to graph, but has another header in dot
-  # notation.
+    end # class DOTNode
 
-  class DOTSubgraph < DOTElement
+    # A subgraph element is the same to graph, but has another header in dot
+    # notation.
 
-    @nodes
-    @dot_string
+    class DOTSubgraph < DOTElement
 
-    def initialize (params = {}, option_list = GRAPH_OPTS)
-      super(params, option_list)
-      @nodes      = params['nodes'] ? params['nodes'] : []
-      @dot_string = 'graph'
-    end
+        @nodes
+        @dot_string
 
-    def each_node
-      @nodes.each{ |i| yield i }
-    end
+        def initialize (params = {}, option_list = GRAPH_OPTS)
+            super(params, option_list)
+            @nodes      = params['nodes'] ? params['nodes'] : []
+            @dot_string = 'graph'
+        end
 
-    def << (thing)
-      @nodes << thing
-    end
-       
-    def push (thing)
-      @nodes.push( thing )
-    end
+        def each_node
+            @nodes.each{ |i| yield i }
+        end
 
-    def pop
-      @nodes.pop
-    end
+        def << (thing)
+            @nodes << thing
+        end
 
-    def to_s (t = '')
-      hdr = t + "#{@dot_string} #{@name} {\n"
+        def push (thing)
+            @nodes.push( thing )
+        end
 
-      options = @options.to_a.collect{ |name, val|
-        val && name != 'label' ? 
-          t + $tab + "#{name} = #{val}" : 
-          name ? t + $tab + "#{name} = \"#{val}\"" : nil
-      }.compact.join( "\n" ) + "\n"
+        def pop
+            @nodes.pop
+        end
 
-      nodes = @nodes.collect{ |i|
-        i.to_s( t + $tab )
-      }.join( "\n" ) + "\n" 
-      hdr + options + nodes + t + "}\n"
-    end
+        def to_s (t = '')
+            hdr = t + "#{@dot_string} #{@name} {\n"
 
-  end # class DOTSubgraph
+            options = @options.to_a.collect{ |name, val|
+                val && name != 'label' ?
+                    t + $tab + "#{name} = #{val}" :
+                    name ? t + $tab + "#{name} = \"#{val}\"" : nil
+            }.compact.join( "\n" ) + "\n"
 
-  # This is a graph.
+            nodes = @nodes.collect{ |i|
+                i.to_s( t + $tab )
+            }.join( "\n" ) + "\n"
+            hdr + options + nodes + t + "}\n"
+        end
 
-  class DOTDigraph < DOTSubgraph
+    end # class DOTSubgraph
+
+    # This is a graph.
+
+    class DOTDigraph < DOTSubgraph
 
     def initialize (params = {}, option_list = GRAPH_OPTS)
-      super(params, option_list)
-      @dot_string = 'digraph'
+        super(params, option_list)
+        @dot_string = 'digraph'
     end
 
-  end # class DOTDigraph
+    end # class DOTDigraph
 
-  # This is an edge.
+    # This is an edge.
 
-  class DOTEdge < DOTElement
+    class DOTEdge < DOTElement
 
-    attr_accessor :from, :to
+        attr_accessor :from, :to
 
-    def initialize (params = {}, option_list = EDGE_OPTS)
-      super(params, option_list)
-      @from = params['from'] ? params['from'] : nil
-      @to   = params['to'] ? params['to'] : nil
-    end
+        def initialize (params = {}, option_list = EDGE_OPTS)
+            super(params, option_list)
+            @from = params['from'] ? params['from'] : nil
+            @to   = params['to'] ? params['to'] : nil
+        end
        
-    def edge_link
-      '--'
-    end
-
-    def to_s (t = '')
-      t + "#{@from} #{edge_link} #{to} [\n" +
-          @options.to_a.collect{ |i|
-            i[1] && i[0] != 'label' ? 
-              t + $tab + "#{i[0]} = #{i[1]}" : 
-              i[1] ? t + $tab + "#{i[0]} = \"#{i[1]}\"" : nil
-          }.compact.join( "\n" ) + "\n" + t + "]\n"
-    end
-
-  end # class DOTEdge
+        def edge_link
+            '--'
+        end
+
+        def to_s (t = '')
+            t + "#{@from} #{edge_link} #{to} [\n" +
+                @options.to_a.collect{ |i|
+                    i[1] && i[0] != 'label' ?
+                        t + $tab + "#{i[0]} = #{i[1]}" :
+                        i[1] ? t + $tab + "#{i[0]} = \"#{i[1]}\"" : nil
+                }.compact.join( "\n" ) + "\n" + t + "]\n"
+        end
+
+    end # class DOTEdge
           
-  class DOTDirectedEdge < DOTEdge
+    class DOTDirectedEdge < DOTEdge
 
-    def edge_link
-      '->'
-    end
+        def edge_link
+            '->'
+        end
 
-  end                           # class DOTDirectedEdge
-end                             # module DOT
+    end # class DOTDirectedEdge
+end # module DOT
diff --git a/lib/puppet/external/event-loop/better-definers.rb b/lib/puppet/external/event-loop/better-definers.rb
index 0af37da62..09e33fdb5 100644
--- a/lib/puppet/external/event-loop/better-definers.rb
+++ b/lib/puppet/external/event-loop/better-definers.rb
@@ -18,350 +18,350 @@
 # Boston, MA 02110-1301, USA.
 
 class Symbol
-  def predicate?
-    to_s.include? "?" end
-  def imperative?
-    to_s.include? "!" end
-  def writer?
-    to_s.include? "=" end
-
-  def punctuated?
-    predicate? or imperative? or writer? end
-  def without_punctuation
-    to_s.delete("?!=").to_sym end
-
-  def predicate
-    without_punctuation.to_s + "?" end
-  def imperative
-    without_punctuation.to_s + "!" end
-  def writer
-    without_punctuation.to_s + "=" end
+    def predicate?
+        to_s.include? "?" end
+    def imperative?
+        to_s.include? "!" end
+    def writer?
+        to_s.include? "=" end
+
+    def punctuated?
+        predicate? or imperative? or writer? end
+    def without_punctuation
+        to_s.delete("?!=").to_sym end
+
+    def predicate
+        without_punctuation.to_s + "?" end
+    def imperative
+        without_punctuation.to_s + "!" end
+    def writer
+        without_punctuation.to_s + "=" end
 end
 
 class Hash
-  def collect! (&block)
-    replace Hash[*collect(&block).flatten]
-  end
+    def collect! (&block)
+        replace Hash[*collect(&block).flatten]
+    end
 
-  def flatten
-    to_a.flatten
-  end
+    def flatten
+        to_a.flatten
+    end
 end
 
 module Kernel
-  def returning (value)
-    yield value ; value
-  end
+    def returning (value)
+        yield value ; value
+    end
 end
 
 class Module
-  def define_hard_aliases (name_pairs)
-    for new_aliases, existing_name in name_pairs do
-      new_aliases.kind_of? Array or new_aliases = [new_aliases]
-      for new_alias in new_aliases do
-        alias_method(new_alias, existing_name)
-      end
+    def define_hard_aliases (name_pairs)
+        for new_aliases, existing_name in name_pairs do
+            new_aliases.kind_of? Array or new_aliases = [new_aliases]
+            for new_alias in new_aliases do
+                alias_method(new_alias, existing_name)
+            end
+        end
     end
-  end
-
-  def define_soft_aliases (name_pairs)
-    for new_aliases, existing_name in name_pairs do
-      new_aliases.kind_of? Array or new_aliases = [new_aliases]
-      for new_alias in new_aliases do
-        class_eval %{def #{new_alias}(*args, &block)
-                       #{existing_name}(*args, &block) end}
-      end
+
+    def define_soft_aliases (name_pairs)
+        for new_aliases, existing_name in name_pairs do
+            new_aliases.kind_of? Array or new_aliases = [new_aliases]
+            for new_alias in new_aliases do
+                class_eval %{def #{new_alias}(*args, &block)
+                            #{existing_name}(*args, &block) end}
+            end
+        end
     end
-  end
-
-  define_soft_aliases \
-    :define_hard_alias => :define_hard_aliases,
-    :define_soft_alias => :define_soft_aliases
-
-  # This method lets you define predicates like :foo?,
-  # which will be defined to return the value of @foo.
-  def define_readers (*names)
-    for name in names.map { |x| x.to_sym } do
-      if name.punctuated?
-        # There's no way to define an efficient reader whose
-        # name is different from the instance variable.
-        class_eval %{def #{name} ; @#{name.without_punctuation} end}
-      else
-        # Use `attr_reader' to define an efficient method.
-        attr_reader(name)
-      end
+
+    define_soft_aliases \
+        :define_hard_alias => :define_hard_aliases,
+        :define_soft_alias => :define_soft_aliases
+
+    # This method lets you define predicates like :foo?,
+    # which will be defined to return the value of @foo.
+    def define_readers (*names)
+        for name in names.map { |x| x.to_sym } do
+            if name.punctuated?
+                # There's no way to define an efficient reader whose
+                # name is different from the instance variable.
+                class_eval %{def #{name} ; @#{name.without_punctuation} end}
+            else
+                # Use `attr_reader' to define an efficient method.
+                attr_reader(name)
+            end
+        end
     end
-  end
-
-  def writer_defined? (name)
-    method_defined? name.to_sym.writer
-  end
-
-  # If you pass a predicate symbol :foo? to this method, it'll first
-  # define a regular writer method :foo, without a question mark.
-  # Then it'll define an imperative writer method :foo! as a shorthand
-  # for setting the property to true.
-  def define_writers (*names, &body)
-    for name in names.map { |x| x.to_sym } do
-      if block_given?
-        define_method(name.writer, &body)
-      else
-        attr_writer(name.without_punctuation)
-      end
-      if name.predicate?
-        class_eval %{def #{name.imperative}
-                       self.#{name.writer} true end}
-      end
+
+    def writer_defined? (name)
+        method_defined? name.to_sym.writer
     end
-  end
 
-  define_soft_aliases \
-    :define_reader => :define_readers,
-    :define_writer => :define_writers
+    # If you pass a predicate symbol :foo? to this method, it'll first
+    # define a regular writer method :foo, without a question mark.
+    # Then it'll define an imperative writer method :foo! as a shorthand
+    # for setting the property to true.
+    def define_writers (*names, &body)
+        for name in names.map { |x| x.to_sym } do
+            if block_given?
+                define_method(name.writer, &body)
+            else
+                attr_writer(name.without_punctuation)
+            end
+            if name.predicate?
+                class_eval %{def #{name.imperative}
+                           self.#{name.writer} true end}
+            end
+        end
+    end
 
-  # We don't need a singular alias for `define_accessors',
-  # because it always defines at least two methods.
+    define_soft_aliases \
+        :define_reader => :define_readers,
+        :define_writer => :define_writers
 
-  def define_accessors (*names)
-    define_readers(*names)
-    define_writers(*names)
-  end
+    # We don't need a singular alias for `define_accessors',
+    # because it always defines at least two methods.
 
-  def define_opposite_readers (name_pairs)
-    name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }
-    for opposite_name, name in name_pairs do
-      define_reader(name) unless method_defined? name
-      class_eval %{def #{opposite_name} ; not #{name} end}
+    def define_accessors (*names)
+        define_readers(*names)
+        define_writers(*names)
     end
-  end
-
-  def define_opposite_writers (name_pairs)
-    name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }
-    for opposite_name, name in name_pairs do
-      define_writer(name) unless writer_defined? name
-      class_eval %{def #{opposite_name.writer} x
-                     self.#{name.writer} !x end} 
-      class_eval %{def #{opposite_name.imperative}
-                     self.#{name.writer} false end}
+
+    def define_opposite_readers (name_pairs)
+        name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }
+        for opposite_name, name in name_pairs do
+            define_reader(name) unless method_defined? name
+            class_eval %{def #{opposite_name} ; not #{name} end}
+        end
     end
-  end
 
-  define_soft_aliases \
-    :define_opposite_reader => :define_opposite_readers,
-    :define_opposite_writer => :define_opposite_writers
+    def define_opposite_writers (name_pairs)
+        name_pairs.collect! { |k, v| [k.to_sym, v.to_sym] }
+        for opposite_name, name in name_pairs do
+            define_writer(name) unless writer_defined? name
+            class_eval %{def #{opposite_name.writer} x
+                         self.#{name.writer} !x end}
+            class_eval %{def #{opposite_name.imperative}
+                         self.#{name.writer} false end}
+        end
+    end
+
+    define_soft_aliases \
+        :define_opposite_reader => :define_opposite_readers,
+        :define_opposite_writer => :define_opposite_writers
 
-  def define_opposite_accessors (name_pairs)
-    define_opposite_readers name_pairs
-    define_opposite_writers name_pairs
-  end
+    def define_opposite_accessors (name_pairs)
+        define_opposite_readers name_pairs
+        define_opposite_writers name_pairs
+    end
 
-  def define_reader_with_opposite (name_pair, &body)
-    name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }
-    define_method(name, &body)
-    define_opposite_reader(opposite_name => name)
-  end
+    def define_reader_with_opposite (name_pair, &body)
+        name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }
+        define_method(name, &body)
+        define_opposite_reader(opposite_name => name)
+    end
 
-  def define_writer_with_opposite (name_pair, &body)
-    name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }
-    define_writer(name, &body)
-    define_opposite_writer(opposite_name => name)
-  end
+    def define_writer_with_opposite (name_pair, &body)
+        name, opposite_name = name_pair.flatten.collect { |x| x.to_sym }
+        define_writer(name, &body)
+        define_opposite_writer(opposite_name => name)
+    end
 
   public :define_method
 
-  def define_methods (*names, &body)
-    names.each { |name| define_method(name, &body) }
-  end
+    def define_methods (*names, &body)
+        names.each { |name| define_method(name, &body) }
+    end
   
-  def define_private_methods (*names, &body)
-    define_methods(*names, &body)
-    names.each { |name| private name }
-  end
-
-  def define_protected_methods (*names, &body)
-    define_methods(*names, &body)
-    names.each { |name| protected name }
-  end
-
-  def define_private_method (name, &body)
-    define_method(name, &body)
-    private name
-  end
-
-  def define_protected_method (name, &body)
-    define_method(name, &body)
-    protected name
-  end
+    def define_private_methods (*names, &body)
+        define_methods(*names, &body)
+        names.each { |name| private name }
+    end
+
+    def define_protected_methods (*names, &body)
+        define_methods(*names, &body)
+        names.each { |name| protected name }
+    end
+
+    def define_private_method (name, &body)
+        define_method(name, &body)
+        private name
+    end
+
+    def define_protected_method (name, &body)
+        define_method(name, &body)
+        protected name
+    end
 end
 
 class ImmutableAttributeError < StandardError
-  def initialize (attribute=nil, message=nil)
-    super message
-    @attribute = attribute
-  end
-
-  define_accessors :attribute
-
-  def to_s
-    if @attribute and @message
-      "cannot change the value of `#@attribute': #@message"
-    elsif @attribute
-      "cannot change the value of `#@attribute'"
-    elsif @message
-      "cannot change the value of attribute: #@message"
-    else
-      "cannot change the value of attribute"
+    def initialize (attribute=nil, message=nil)
+        super message
+        @attribute = attribute
+    end
+
+    define_accessors :attribute
+
+    def to_s
+        if @attribute and @message
+            "cannot change the value of `#@attribute': #@message"
+        elsif @attribute
+            "cannot change the value of `#@attribute'"
+        elsif @message
+            "cannot change the value of attribute: #@message"
+        else
+            "cannot change the value of attribute"
+        end
     end
-  end
 end
 
 class Module
-  # Guard each of the specified attributes by replacing the writer
-  # method with a proxy that asks the supplied block before proceeding
-  # with the change.
-  #
-  # If it's okay to change the attribute, the block should return
-  # either nil or the symbol :mutable.  If it isn't okay, the block
-  # should return a string saying why the attribute can't be changed.
-  # If you don't want to provide a reason, you can have the block
-  # return just the symbol :immutable.
-  def guard_writers(*names, &predicate)
-    for name in names.map { |x| x.to_sym } do
-      define_hard_alias("__unguarded_#{name.writer}" => name.writer)
-      define_method(name.writer) do |new_value|
-        case result = predicate.call
-        when :mutable, nil
-          __send__("__unguarded_#{name.writer}", new_value)
-        when :immutable
-          raise ImmutableAttributeError.new(name)
-        else
-          raise ImmutableAttributeError.new(name, result)
+    # Guard each of the specified attributes by replacing the writer
+    # method with a proxy that asks the supplied block before proceeding
+    # with the change.
+    #
+    # If it's okay to change the attribute, the block should return
+    # either nil or the symbol :mutable.  If it isn't okay, the block
+    # should return a string saying why the attribute can't be changed.
+    # If you don't want to provide a reason, you can have the block
+    # return just the symbol :immutable.
+    def guard_writers(*names, &predicate)
+        for name in names.map { |x| x.to_sym } do
+            define_hard_alias("__unguarded_#{name.writer}" => name.writer)
+            define_method(name.writer) do |new_value|
+                case result = predicate.call
+                when :mutable, nil
+                    __send__("__unguarded_#{name.writer}", new_value)
+                when :immutable
+                    raise ImmutableAttributeError.new(name)
+                else
+                    raise ImmutableAttributeError.new(name, result)
+                end
+            end
         end
-      end
     end
-  end
 
-  def define_guarded_writers (*names, &block)
-    define_writers(*names)
-    guard_writers(*names, &block)
-  end
+    def define_guarded_writers (*names, &block)
+        define_writers(*names)
+        guard_writers(*names, &block)
+    end
 
-  define_soft_alias :guard_writer => :guard_writers
-  define_soft_alias :define_guarded_writer => :define_guarded_writers
+    define_soft_alias :guard_writer => :guard_writers
+    define_soft_alias :define_guarded_writer => :define_guarded_writers
 end
 
 if __FILE__ == $0
-  require "test/unit"
-
-  class DefineAccessorsTest < Test::Unit::TestCase
-    def setup
-      @X = Class.new
-      @Y = Class.new @X
-      @x = @X.new
-      @y = @Y.new
-    end
+    require "test/unit"
+
+    class DefineAccessorsTest < Test::Unit::TestCase
+        def setup
+            @X = Class.new
+            @Y = Class.new @X
+            @x = @X.new
+            @y = @Y.new
+        end
 
-    def test_define_hard_aliases
-      @X.define_method(:foo) { 123 }
-      @X.define_method(:baz) { 321 }
-      @X.define_hard_aliases :bar => :foo, :quux => :baz
-      assert_equal @x.foo, 123
-      assert_equal @x.bar, 123
-      assert_equal @y.foo, 123
-      assert_equal @y.bar, 123
-      assert_equal @x.baz, 321
-      assert_equal @x.quux, 321
-      assert_equal @y.baz, 321
-      assert_equal @y.quux, 321
-      @Y.define_method(:foo) { 456 }
-      assert_equal @y.foo, 456
-      assert_equal @y.bar, 123
-      @Y.define_method(:quux) { 654 }
-      assert_equal @y.baz, 321
-      assert_equal @y.quux, 654
-    end
+        def test_define_hard_aliases
+            @X.define_method(:foo) { 123 }
+            @X.define_method(:baz) { 321 }
+            @X.define_hard_aliases :bar => :foo, :quux => :baz
+            assert_equal @x.foo, 123
+            assert_equal @x.bar, 123
+            assert_equal @y.foo, 123
+            assert_equal @y.bar, 123
+            assert_equal @x.baz, 321
+            assert_equal @x.quux, 321
+            assert_equal @y.baz, 321
+            assert_equal @y.quux, 321
+            @Y.define_method(:foo) { 456 }
+            assert_equal @y.foo, 456
+            assert_equal @y.bar, 123
+            @Y.define_method(:quux) { 654 }
+            assert_equal @y.baz, 321
+            assert_equal @y.quux, 654
+        end
     
-    def test_define_soft_aliases
-      @X.define_method(:foo) { 123 }
-      @X.define_method(:baz) { 321 }
-      @X.define_soft_aliases :bar => :foo, :quux => :baz
-      assert_equal @x.foo, 123
-      assert_equal @x.bar, 123
-      assert_equal @y.foo, 123
-      assert_equal @y.bar, 123
-      assert_equal @x.baz, 321
-      assert_equal @x.quux, 321
-      assert_equal @y.baz, 321
-      assert_equal @y.quux, 321
-      @Y.define_method(:foo) { 456 }
-      assert_equal @y.foo, @y.bar, 456
-      @Y.define_method(:quux) { 654 }
-      assert_equal @y.baz, 321
-      assert_equal @y.quux, 654
-    end
+        def test_define_soft_aliases
+            @X.define_method(:foo) { 123 }
+            @X.define_method(:baz) { 321 }
+            @X.define_soft_aliases :bar => :foo, :quux => :baz
+            assert_equal @x.foo, 123
+            assert_equal @x.bar, 123
+            assert_equal @y.foo, 123
+            assert_equal @y.bar, 123
+            assert_equal @x.baz, 321
+            assert_equal @x.quux, 321
+            assert_equal @y.baz, 321
+            assert_equal @y.quux, 321
+            @Y.define_method(:foo) { 456 }
+            assert_equal @y.foo, @y.bar, 456
+            @Y.define_method(:quux) { 654 }
+            assert_equal @y.baz, 321
+            assert_equal @y.quux, 654
+        end
 
-    def test_define_readers
-      @X.define_readers :foo, :bar
-      assert !@x.respond_to?(:foo=)
-      assert !@x.respond_to?(:bar=)
-      @x.instance_eval { @foo = 123 ; @bar = 456 }
-      assert_equal @x.foo, 123
-      assert_equal @x.bar, 456
-      @X.define_readers :baz?, :quux?
-      assert !@x.respond_to?(:baz=)
-      assert !@x.respond_to?(:quux=)
-      @x.instance_eval { @baz = false ; @quux = true }
-      assert !@x.baz?
-      assert @x.quux?
-    end
+        def test_define_readers
+            @X.define_readers :foo, :bar
+            assert !@x.respond_to?(:foo=)
+            assert !@x.respond_to?(:bar=)
+            @x.instance_eval { @foo = 123 ; @bar = 456 }
+            assert_equal @x.foo, 123
+            assert_equal @x.bar, 456
+            @X.define_readers :baz?, :quux?
+            assert !@x.respond_to?(:baz=)
+            assert !@x.respond_to?(:quux=)
+            @x.instance_eval { @baz = false ; @quux = true }
+            assert !@x.baz?
+            assert @x.quux?
+        end
 
-    def test_define_writers
-      assert !@X.writer_defined?(:foo)
-      assert !@X.writer_defined?(:bar)
-      @X.define_writers :foo, :bar
-      assert @X.writer_defined?(:foo)
-      assert @X.writer_defined?(:bar)
-      assert @X.writer_defined?(:foo=)
-      assert @X.writer_defined?(:bar=)
-      assert @X.writer_defined?(:foo?)
-      assert @X.writer_defined?(:bar?)
-      assert !@x.respond_to?(:foo)
-      assert !@x.respond_to?(:bar)
-      @x.foo = 123
-      @x.bar = 456
-      assert_equal @x.instance_eval { @foo }, 123
-      assert_equal @x.instance_eval { @bar }, 456
-      @X.define_writers :baz?, :quux?
-      assert !@x.respond_to?(:baz?)
-      assert !@x.respond_to?(:quux?)
-      @x.baz = true
-      @x.quux = false
-      assert_equal @x.instance_eval { @baz }, true
-      assert_equal @x.instance_eval { @quux }, false
-    end
+        def test_define_writers
+            assert !@X.writer_defined?(:foo)
+            assert !@X.writer_defined?(:bar)
+            @X.define_writers :foo, :bar
+            assert @X.writer_defined?(:foo)
+            assert @X.writer_defined?(:bar)
+            assert @X.writer_defined?(:foo=)
+            assert @X.writer_defined?(:bar=)
+            assert @X.writer_defined?(:foo?)
+            assert @X.writer_defined?(:bar?)
+            assert !@x.respond_to?(:foo)
+            assert !@x.respond_to?(:bar)
+            @x.foo = 123
+            @x.bar = 456
+            assert_equal @x.instance_eval { @foo }, 123
+            assert_equal @x.instance_eval { @bar }, 456
+            @X.define_writers :baz?, :quux?
+            assert !@x.respond_to?(:baz?)
+            assert !@x.respond_to?(:quux?)
+            @x.baz = true
+            @x.quux = false
+            assert_equal @x.instance_eval { @baz }, true
+            assert_equal @x.instance_eval { @quux }, false
+        end
 
-    def test_define_accessors
-      @X.define_accessors :foo, :bar
-      @x.foo = 123 ; @x.bar = 456
-      assert_equal @x.foo, 123
-      assert_equal @x.bar, 456
-    end
+        def test_define_accessors
+            @X.define_accessors :foo, :bar
+            @x.foo = 123 ; @x.bar = 456
+            assert_equal @x.foo, 123
+            assert_equal @x.bar, 456
+        end
 
-    def test_define_opposite_readers
-      @X.define_opposite_readers :foo? => :bar?, :baz? => :quux?
-      assert !@x.respond_to?(:foo=)
-      assert !@x.respond_to?(:bar=)
-      assert !@x.respond_to?(:baz=)
-      assert !@x.respond_to?(:quux=)
-      @x.instance_eval { @bar = true ; @quux = false }
-      assert !@x.foo?
-      assert @x.bar?
-      assert @x.baz?
-      assert !@x.quux?
-    end
+        def test_define_opposite_readers
+            @X.define_opposite_readers :foo? => :bar?, :baz? => :quux?
+            assert !@x.respond_to?(:foo=)
+            assert !@x.respond_to?(:bar=)
+            assert !@x.respond_to?(:baz=)
+            assert !@x.respond_to?(:quux=)
+            @x.instance_eval { @bar = true ; @quux = false }
+            assert !@x.foo?
+            assert @x.bar?
+            assert @x.baz?
+            assert !@x.quux?
+        end
 
-    def test_define_opposite_writers
-      @X.define_opposite_writers :foo? => :bar?, :baz => :quux
+        def test_define_opposite_writers
+            @X.define_opposite_writers :foo? => :bar?, :baz => :quux
+        end
     end
-  end
 end
diff --git a/lib/puppet/external/event-loop/event-loop.rb b/lib/puppet/external/event-loop/event-loop.rb
index 17a520ead..75febab80 100644
--- a/lib/puppet/external/event-loop/event-loop.rb
+++ b/lib/puppet/external/event-loop/event-loop.rb
@@ -23,337 +23,337 @@ require "puppet/external/event-loop/signal-system"
 require "fcntl"
 
 class EventLoop
-  include SignalEmitter
-
-  IO_STATES = [:readable, :writable, :exceptional]
-
-  class << self
-    def default ; @default ||= new end
-    def default= x ; @default = x end
-
-    def current
-      Thread.current["event-loop::current"] || default end
-    def current= x
-      Thread.current["event-loop::current"] = x end
-
-    def with_current (new)
-      if current == new
-        yield
-      else
-        begin
-          old = self.current
-          self.current = new
-          yield
-        ensure
-          self.current = old
+    include SignalEmitter
+
+    IO_STATES = [:readable, :writable, :exceptional]
+
+    class << self
+        def default ; @default ||= new end
+        def default= x ; @default = x end
+
+        def current
+            Thread.current["event-loop::current"] || default end
+        def current= x
+            Thread.current["event-loop::current"] = x end
+
+        def with_current (new)
+            if current == new
+                yield
+            else
+                begin
+                    old = self.current
+                    self.current = new
+                    yield
+                ensure
+                    self.current = old
+                end
+            end
+        end
+
+        def method_missing (name, *args, &block)
+            if current.respond_to? name
+                current.__send__(name, *args, &block)
+            else
+                super
+            end
         end
-      end
     end
 
-    def method_missing (name, *args, &block)
-      if current.respond_to? name
-        current.__send__(name, *args, &block)
-      else
-        super
-      end
+    define_signals :before_sleep, :after_sleep
+
+    def initialize
+        @running = false
+        @awake = false
+        @wakeup_time = nil
+        @timers = []
+
+        @io_arrays = [[], [], []]
+        @ios = Hash.new do |h, k| raise ArgumentError,
+            "invalid IO event: #{k}", caller(2) end
+        IO_STATES.each_with_index { |x, i| @ios[x] = @io_arrays[i] }
+
+        @notify_src, @notify_snk = IO.pipe
+
+        # prevent file descriptor leaks
+        @notify_src.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+        @notify_snk.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+        @notify_src.will_block = false
+        @notify_snk.will_block = false
+
+        # Each time a byte is sent through the notification pipe
+        # we need to read it, or IO.select will keep returning.
+        monitor_io(@notify_src, :readable)
+        @notify_src.extend(Watchable)
+        @notify_src.on_readable do
+            begin
+                @notify_src.sysread(256)
+            rescue Errno::EAGAIN
+                # The pipe wasn't readable after all.
+            end
+        end
     end
-  end
-
-  define_signals :before_sleep, :after_sleep
-
-  def initialize
-    @running = false
-    @awake = false
-    @wakeup_time = nil
-    @timers = []
-
-    @io_arrays = [[], [], []]
-    @ios = Hash.new do |h, k| raise ArgumentError,
-      "invalid IO event: #{k}", caller(2) end
-    IO_STATES.each_with_index { |x, i| @ios[x] = @io_arrays[i] }
-
-    @notify_src, @notify_snk = IO.pipe
-
-    # prevent file descriptor leaks
-    @notify_src.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-    @notify_snk.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-
-    @notify_src.will_block = false
-    @notify_snk.will_block = false
-
-    # Each time a byte is sent through the notification pipe
-    # we need to read it, or IO.select will keep returning.
-    monitor_io(@notify_src, :readable)
-    @notify_src.extend(Watchable)
-    @notify_src.on_readable do
-      begin
-        @notify_src.sysread(256)
-      rescue Errno::EAGAIN
-        # The pipe wasn't readable after all.
-      end
+
+    define_opposite_accessors \
+        :stopped?  => :running?,
+        :sleeping? => :awake?
+
+    def run
+        if block_given?
+            thread = Thread.new { run }
+            yield ; quit ; thread.join
+        else
+            running!
+            iterate while running?
+        end
+    ensure
+        quit
     end
-  end
-
-  define_opposite_accessors \
-    :stopped?  => :running?,
-    :sleeping? => :awake?
-
-  def run
-    if block_given?
-      thread = Thread.new { run }
-      yield ; quit ; thread.join
-    else
-      running!
-      iterate while running?
+
+    def iterate (user_timeout=nil)
+        t1, t2 = user_timeout, max_timeout
+        timeout = t1 && t2 ? [t1, t2].min : t1 || t2
+        select(timeout).zip(IO_STATES) do |ios, state|
+            ios.each { |x| x.signal(state) } if ios
+        end
     end
-  ensure
-    quit
-  end
-
-  def iterate (user_timeout=nil)
-    t1, t2 = user_timeout, max_timeout
-    timeout = t1 && t2 ? [t1, t2].min : t1 || t2
-    select(timeout).zip(IO_STATES) do |ios, state|
-      ios.each { |x| x.signal(state) } if ios
+
+  private
+
+    def select (timeout)
+        @wakeup_time = timeout ? Time.now + timeout : nil
+        # puts "waiting: #{timeout} seconds"
+        signal :before_sleep ; sleeping!
+        IO.select(*@io_arrays + [timeout]) || []
+    ensure
+        awake! ; signal :after_sleep
+        @timers.each { |x| x.sound_alarm if x.ready? }
     end
-  end
-
- private
-
-  def select (timeout)
-    @wakeup_time = timeout ? Time.now + timeout : nil
-    # puts "waiting: #{timeout} seconds"
-    signal :before_sleep ; sleeping!
-    IO.select(*@io_arrays + [timeout]) || []
-  ensure
-    awake! ; signal :after_sleep
-    @timers.each { |x| x.sound_alarm if x.ready? }
-  end
-
- public
-
-  def quit ; stopped! ; wake_up ; self end
-
-  def monitoring_io? (io, event)
-    @ios[event].include? io end
-  def monitoring_timer? (timer)
-    @timers.include? timer end
-
-  def monitor_io (io, *events)
-    for event in events do
-      unless monitoring_io?(io, event)
-        @ios[event] << io ; wake_up
-      end
+
+  public
+
+    def quit ; stopped! ; wake_up ; self end
+
+    def monitoring_io? (io, event)
+        @ios[event].include? io end
+    def monitoring_timer? (timer)
+        @timers.include? timer end
+
+    def monitor_io (io, *events)
+        for event in events do
+            unless monitoring_io?(io, event)
+                @ios[event] << io ; wake_up
+            end
+        end
     end
-  end
 
-  def monitor_timer (timer)
-    unless monitoring_timer? timer
-      @timers << timer
+    def monitor_timer (timer)
+        unless monitoring_timer? timer
+            @timers << timer
+        end
     end
-  end
 
-  def check_timer (timer)
-    wake_up if timer.end_time < @wakeup_time
-  end
+    def check_timer (timer)
+        wake_up if timer.end_time < @wakeup_time
+    end
 
-  def ignore_io (io, *events)
-    events = IO_STATES if events.empty?
-    for event in events do
-      wake_up if @ios[event].delete(io)
+    def ignore_io (io, *events)
+        events = IO_STATES if events.empty?
+        for event in events do
+            wake_up if @ios[event].delete(io)
+        end
     end
-  end
 
-  def ignore_timer (timer)
-    # Don't need to wake up for this.
-    @timers.delete(timer)
-  end
+    def ignore_timer (timer)
+        # Don't need to wake up for this.
+        @timers.delete(timer)
+    end
 
-  def max_timeout
-    return nil if @timers.empty?
-    [@timers.collect { |x| x.time_left }.min, 0].max
-  end
+    def max_timeout
+        return nil if @timers.empty?
+        [@timers.collect { |x| x.time_left }.min, 0].max
+    end
 
-  def wake_up
-    @notify_snk.write('.') if sleeping?
-  end
+    def wake_up
+        @notify_snk.write('.') if sleeping?
+    end
 end
 
 class Symbol
-  def io_state?
-    EventLoop::IO_STATES.include? self
-  end
+    def io_state?
+        EventLoop::IO_STATES.include? self
+    end
 end
 
 module EventLoop::Watchable
-  include SignalEmitter
+    include SignalEmitter
 
-  define_signals :readable, :writable, :exceptional
+    define_signals :readable, :writable, :exceptional
 
-  def monitor_events (*events)
-    EventLoop.monitor_io(self, *events) end
-  def ignore_events (*events)
-    EventLoop.ignore_io(self, *events) end
+    def monitor_events (*events)
+        EventLoop.monitor_io(self, *events) end
+    def ignore_events (*events)
+        EventLoop.ignore_io(self, *events) end
 
-  define_soft_aliases \
-    :monitor_event => :monitor_events,
-    :ignore_event  => :ignore_events
+    define_soft_aliases \
+        :monitor_event => :monitor_events,
+        :ignore_event  => :ignore_events
 
-  def close ; super
-    ignore_events end
-  def close_read ; super
-    ignore_event :readable end
-  def close_write ; super
-    ignore_event :writable end
+    def close ; super
+        ignore_events end
+    def close_read ; super
+        ignore_event :readable end
+    def close_write ; super
+        ignore_event :writable end
 
-  module Automatic
-    include EventLoop::Watchable
+    module Automatic
+        include EventLoop::Watchable
 
-    def add_signal_handler (name, &handler) super
-      monitor_event(name) if name.io_state?
-    end
+        def add_signal_handler (name, &handler) super
+            monitor_event(name) if name.io_state?
+        end
 
-    def remove_signal_handler (name, handler) super
-      if @signal_handlers[name].empty?
-        ignore_event(name) if name.io_state?
-      end
+        def remove_signal_handler (name, handler) super
+            if @signal_handlers[name].empty?
+                ignore_event(name) if name.io_state?
+            end
+        end
     end
-  end
 end
 
 class IO
-  def on_readable &block
-    extend EventLoop::Watchable::Automatic
-    on_readable(&block)
-  end
-
-  def on_writable &block
-    extend EventLoop::Watchable::Automatic
-    on_writable(&block)
-  end
-
-  def on_exceptional &block
-    extend EventLoop::Watchable::Automatic
-    on_exceptional(&block)
-  end
-
-  def will_block?
-    require "fcntl"
-    fcntl(Fcntl::F_GETFL, 0) & Fcntl::O_NONBLOCK == 0
-  end
-
-  def will_block= (wants_blocking)
-    require "fcntl"
-    flags = fcntl(Fcntl::F_GETFL, 0)
-    if wants_blocking
-      flags &= ~Fcntl::O_NONBLOCK
-    else
-      flags |= Fcntl::O_NONBLOCK
+    def on_readable &block
+        extend EventLoop::Watchable::Automatic
+        on_readable(&block)
+    end
+
+    def on_writable &block
+        extend EventLoop::Watchable::Automatic
+        on_writable(&block)
+    end
+
+    def on_exceptional &block
+        extend EventLoop::Watchable::Automatic
+        on_exceptional(&block)
+    end
+
+    def will_block?
+        require "fcntl"
+        fcntl(Fcntl::F_GETFL, 0) & Fcntl::O_NONBLOCK == 0
+    end
+
+    def will_block= (wants_blocking)
+        require "fcntl"
+        flags = fcntl(Fcntl::F_GETFL, 0)
+        if wants_blocking
+            flags &= ~Fcntl::O_NONBLOCK
+        else
+            flags |= Fcntl::O_NONBLOCK
+        end
+        fcntl(Fcntl::F_SETFL, flags)
     end
-    fcntl(Fcntl::F_SETFL, flags)
-  end
 end
 
 class EventLoop::Timer
-  include SignalEmitter
+    include SignalEmitter
 
-  DEFAULT_INTERVAL = 0.0
-  DEFAULT_TOLERANCE = 0.001
+    DEFAULT_INTERVAL = 0.0
+    DEFAULT_TOLERANCE = 0.001
 
-  def initialize (options={}, &handler)
-    @running = false
-    @start_time = nil
+    def initialize (options={}, &handler)
+        @running = false
+        @start_time = nil
 
-    if options.kind_of? Numeric
-      options = { :interval => options }
-    end
+        if options.kind_of? Numeric
+            options = { :interval => options }
+        end
+
+        if options[:interval]
+            @interval = options[:interval].to_f
+        else
+            @interval = DEFAULT_INTERVAL
+        end
 
-    if options[:interval]
-      @interval = options[:interval].to_f
-    else
-      @interval = DEFAULT_INTERVAL
+        if options[:tolerance]
+            @tolerance = options[:tolerance].to_f
+        elsif DEFAULT_TOLERANCE < @interval
+            @tolerance = DEFAULT_TOLERANCE
+        else
+            @tolerance = 0.0
+        end
+
+        @event_loop = options[:event_loop] || EventLoop.current
+
+        if block_given?
+            add_signal_handler(:alarm, &handler)
+            start unless options[:start?] == false
+        else
+            start if options[:start?]
+        end
     end
 
-    if options[:tolerance]
-      @tolerance = options[:tolerance].to_f
-    elsif DEFAULT_TOLERANCE < @interval
-      @tolerance = DEFAULT_TOLERANCE
-    else
-      @tolerance = 0.0
+    define_readers :interval, :tolerance
+    define_signal :alarm
+
+    def stopped? ; @start_time == nil end
+    def running? ; @start_time != nil end
+
+    def interval= (new_interval)
+        old_interval = @interval
+        @interval = new_interval
+        if new_interval < old_interval
+            @event_loop.check_timer(self)
+        end
     end
 
-    @event_loop = options[:event_loop] || EventLoop.current
+    def end_time
+        @start_time + @interval end
+    def time_left
+        end_time - Time.now end
+    def ready?
+        time_left <= @tolerance end
 
-    if block_given?
-      add_signal_handler(:alarm, &handler)
-      start unless options[:start?] == false
-    else
-      start if options[:start?]
+    def restart
+        @start_time = Time.now
     end
-  end
 
-  define_readers :interval, :tolerance
-  define_signal :alarm
+    def sound_alarm
+        signal :alarm
+        restart if running?
+    end
 
-  def stopped? ; @start_time == nil end
-  def running? ; @start_time != nil end
+    def start
+        @start_time = Time.now
+        @event_loop.monitor_timer(self)
+    end
 
-  def interval= (new_interval)
-    old_interval = @interval
-    @interval = new_interval
-    if new_interval < old_interval
-      @event_loop.check_timer(self)
+    def stop
+        @start_time = nil
+        @event_loop.ignore_timer(self)
     end
-  end
-
-  def end_time
-    @start_time + @interval end
-  def time_left
-    end_time - Time.now end
-  def ready?
-    time_left <= @tolerance end
-
-  def restart
-    @start_time = Time.now
-  end
-
-  def sound_alarm
-    signal :alarm
-    restart if running?
-  end
-
-  def start
-    @start_time = Time.now
-    @event_loop.monitor_timer(self)
-  end
-
-  def stop
-    @start_time = nil
-    @event_loop.ignore_timer(self)
-  end
 end
 
 if __FILE__ == $0
-  require "test/unit"
+    require "test/unit"
 
-  class TimerTest < Test::Unit::TestCase
-    def setup
-      @timer = EventLoop::Timer.new(:interval => 0.001)
-    end
+    class TimerTest < Test::Unit::TestCase
+        def setup
+            @timer = EventLoop::Timer.new(:interval => 0.001)
+        end
 
-    def test_timer
-      @timer.on_alarm do
-        puts "[#{@timer.time_left} seconds left after alarm]"
-        EventLoop.quit
-      end
-      8.times do
-        t0 = Time.now
-        @timer.start ; EventLoop.run
-        t1 = Time.now
-        assert(t1 - t0 > @timer.interval - @timer.tolerance)
-      end
+        def test_timer
+            @timer.on_alarm do
+                puts "[#{@timer.time_left} seconds left after alarm]"
+                EventLoop.quit
+            end
+            8.times do
+                t0 = Time.now
+                @timer.start ; EventLoop.run
+                t1 = Time.now
+                assert(t1 - t0 > @timer.interval - @timer.tolerance)
+            end
+        end
     end
-  end
 end
 
 ## event-loop.rb ends here.
diff --git a/lib/puppet/external/event-loop/signal-system.rb b/lib/puppet/external/event-loop/signal-system.rb
index 2ca61e2ee..07feb9bf0 100644
--- a/lib/puppet/external/event-loop/signal-system.rb
+++ b/lib/puppet/external/event-loop/signal-system.rb
@@ -20,86 +20,86 @@
 require "puppet/external/event-loop/better-definers"
 
 module SignalEmitterModule
-  def self.extended (object)
-    if object.kind_of? Module and not object < SignalEmitter
-      if object.respond_to? :fcall
-        # This is the way to call private methods
-        # in Ruby 1.9 as of November 16.
-        object.fcall :include, SignalEmitter
-      else
-        object.__send__ :include, SignalEmitter
-      end
-    end
-  end
-
-  def define_signal (name, slot=:before, &body)
-    # Can't use `define_method' and take a block pre-1.9.
-    class_eval %{ def on_#{name} &block
+    def self.extended (object)
+        if object.kind_of? Module and not object < SignalEmitter
+            if object.respond_to? :fcall
+                # This is the way to call private methods
+                # in Ruby 1.9 as of November 16.
+                object.fcall :include, SignalEmitter
+            else
+                object.__send__ :include, SignalEmitter
+            end
+        end
+    end
+
+    def define_signal (name, slot=:before, &body)
+        # Can't use `define_method' and take a block pre-1.9.
+        class_eval %{ def on_#{name} &block
                     add_signal_handler(:#{name}, &block) end }
-    define_signal_handler(name, :before, &lambda {|*a|})
-    define_signal_handler(name, :after, &lambda {|*a|})
-    define_signal_handler(name, slot, &body) if block_given?
-  end
-
-  def define_signals (*names, &body)
-    names.each { |x| define_signal(x, &body) }
-  end
-
-  def define_signal_handler (name, slot=:before, &body)
-    case slot
-    when :before
-      define_protected_method "handle_#{name}", &body
-    when :after
-      define_protected_method "after_handle_#{name}", &body
-    else
-      raise ArgumentError, "invalid slot `#{slot.inspect}'; " +
-        "should be `:before' or `:after'", caller(1)
-    end
-  end
+        define_signal_handler(name, :before, &lambda {|*a|})
+        define_signal_handler(name, :after, &lambda {|*a|})
+        define_signal_handler(name, slot, &body) if block_given?
+    end
+
+    def define_signals (*names, &body)
+        names.each { |x| define_signal(x, &body) }
+    end
+
+    def define_signal_handler (name, slot=:before, &body)
+        case slot
+        when :before
+            define_protected_method "handle_#{name}", &body
+        when :after
+            define_protected_method "after_handle_#{name}", &body
+        else
+            raise ArgumentError, "invalid slot `#{slot.inspect}'; " +
+                "should be `:before' or `:after'", caller(1)
+        end
+    end
 end
 
 # This is an old name for the same thing.
 SignalEmitterClass = SignalEmitterModule
 
 module SignalEmitter
-  def self.included (includer)
-    if not includer.kind_of? SignalEmitterClass
-      includer.extend SignalEmitterClass
-    end
-  end
-
-  def __maybe_initialize_signal_emitter
-    @signal_handlers ||= Hash.new { |h, k| h[k] = Array.new }
-    @allow_dynamic_signals ||= false
-  end
-
-  define_accessors :allow_dynamic_signals?
-
-  def add_signal_handler (name, &handler)
-    __maybe_initialize_signal_emitter
-    @signal_handlers[name] << handler
-    return handler
-  end
-
-  define_soft_aliases [:on, :on_signal] => :add_signal_handler
-
-  def remove_signal_handler (name, handler)
-    __maybe_initialize_signal_emitter
-    @signal_handlers[name].delete(handler)
-  end
-
-  def __signal__ (name, *args, &block)
-    __maybe_initialize_signal_emitter
-    respond_to? "on_#{name}" or allow_dynamic_signals? or
-      fail "undefined signal `#{name}' for #{self}:#{self.class}"
-    __send__("handle_#{name}", *args, &block) if
-      respond_to? "handle_#{name}"
-    @signal_handlers[name].each { |x| x.call(*args, &block) }
-    __send__("after_handle_#{name}", *args, &block) if
-      respond_to? "after_handle_#{name}"
-  end
-
-  define_soft_alias :signal => :__signal__
+    def self.included (includer)
+        if not includer.kind_of? SignalEmitterClass
+            includer.extend SignalEmitterClass
+        end
+    end
+
+    def __maybe_initialize_signal_emitter
+        @signal_handlers ||= Hash.new { |h, k| h[k] = Array.new }
+        @allow_dynamic_signals ||= false
+    end
+
+    define_accessors :allow_dynamic_signals?
+
+    def add_signal_handler (name, &handler)
+        __maybe_initialize_signal_emitter
+        @signal_handlers[name] << handler
+        return handler
+    end
+
+    define_soft_aliases [:on, :on_signal] => :add_signal_handler
+
+    def remove_signal_handler (name, handler)
+        __maybe_initialize_signal_emitter
+        @signal_handlers[name].delete(handler)
+    end
+
+    def __signal__ (name, *args, &block)
+        __maybe_initialize_signal_emitter
+        respond_to? "on_#{name}" or allow_dynamic_signals? or
+        fail "undefined signal `#{name}' for #{self}:#{self.class}"
+        __send__("handle_#{name}", *args, &block) if
+            respond_to? "handle_#{name}"
+        @signal_handlers[name].each { |x| x.call(*args, &block) }
+        __send__("after_handle_#{name}", *args, &block) if
+            respond_to? "after_handle_#{name}"
+    end
+
+    define_soft_alias :signal => :__signal__
 end
 
 # This module is indended to be a convenience mixin to be used by
@@ -113,108 +113,108 @@ end
 # XXX: This has not seen much use, and I'd like to provide a
 #      better solution for the problem in the future.
 module SignalObserver
-  def __maybe_initialize_signal_observer
-    @observed_signals ||= Hash.new do |signals, object|
-      signals[object] = Hash.new do |handlers, name|
-        handlers[name] = Array.new
-      end
-    end
-  end
-
-  def observe_signal (subject, name, &handler)
-    __maybe_initialize_signal_observer
-    @observed_signals[subject][name] << handler
-    subject.add_signal_handler(name, &handler)
-  end
-
-  def map_signals (source, pairs={})
-    pairs.each do |src_name, dst_name|
-      observe_signal(source, src_name) do |*args|
-        __signal__(dst_name, *args)
-      end
-    end
-  end
-
-  def absorb_signals (subject, *names)
-    names.each do |name|
-      observe_signal(subject, name) do |*args|
-        __signal__(name, *args)
-      end
-    end
-  end
-
-  define_soft_aliases \
-    :map_signal    => :map_signals,
-    :absorb_signal => :absorb_signals
-
-  def ignore_signal (subject, name)
-    __maybe_initialize_signal_observer
-    __ignore_signal_1(subject, name)
-    @observed_signals.delete(subject) if
-      @observed_signals[subject].empty?
-  end
-
-  def ignore_signals (subject, *names)
-    __maybe_initialize_signal_observer
-    names = @observed_signals[subject] if names.empty?
-    names.each { |x| __ignore_signal_1(subject, x) }
-  end
-
- private
-
-  def __ignore_signal_1(subject, name)
-    @observed_signals[subject][name].each do |handler|
-      subject.remove_signal_handler(name, handler) end
-    @observed_signals[subject].delete(name)
-  end
-end
+    def __maybe_initialize_signal_observer
+        @observed_signals ||= Hash.new do |signals, object|
+            signals[object] = Hash.new do |handlers, name|
+                handlers[name] = Array.new
+            end
+        end
+    end
 
-if __FILE__ == $0
-  require "test/unit"
-  class SignalEmitterTest < Test::Unit::TestCase
-    class X
-      include SignalEmitter
-      define_signal :foo
+    def observe_signal (subject, name, &handler)
+        __maybe_initialize_signal_observer
+        @observed_signals[subject][name] << handler
+        subject.add_signal_handler(name, &handler)
     end
 
-    def setup
-      @x = X.new
+    def map_signals (source, pairs={})
+        pairs.each do |src_name, dst_name|
+            observe_signal(source, src_name) do |*args|
+                __signal__(dst_name, *args)
+            end
+        end
     end
 
-    def test_on_signal
-      moomin = 0
-      @x.on_signal(:foo) { moomin = 1 }
-      @x.signal :foo
-      assert moomin == 1
+    def absorb_signals (subject, *names)
+        names.each do |name|
+            observe_signal(subject, name) do |*args|
+                __signal__(name, *args)
+            end
+        end
     end
 
-    def test_on_foo
-      moomin = 0
-      @x.on_foo { moomin = 1 }
-      @x.signal :foo
-      assert moomin == 1
+    define_soft_aliases \
+        :map_signal    => :map_signals,
+        :absorb_signal => :absorb_signals
+
+    def ignore_signal (subject, name)
+        __maybe_initialize_signal_observer
+        __ignore_signal_1(subject, name)
+        @observed_signals.delete(subject) if
+            @observed_signals[subject].empty?
     end
 
-    def test_multiple_on_signal
-      moomin = 0
-      @x.on_signal(:foo) { moomin += 1 }
-      @x.on_signal(:foo) { moomin += 2 }
-      @x.on_signal(:foo) { moomin += 4 }
-      @x.on_signal(:foo) { moomin += 8 }
-      @x.signal :foo
-      assert moomin == 15
+    def ignore_signals (subject, *names)
+        __maybe_initialize_signal_observer
+        names = @observed_signals[subject] if names.empty?
+        names.each { |x| __ignore_signal_1(subject, x) }
     end
 
-    def test_multiple_on_foo
-      moomin = 0
-      @x.on_foo { moomin += 1 }
-      @x.on_foo { moomin += 2 }
-      @x.on_foo { moomin += 4 }
-      @x.on_foo { moomin += 8 }
-      @x.signal :foo
-      assert moomin == 15
+  private
+
+    def __ignore_signal_1(subject, name)
+        @observed_signals[subject][name].each do |handler|
+            subject.remove_signal_handler(name, handler) end
+        @observed_signals[subject].delete(name)
+    end
+end
+
+if __FILE__ == $0
+    require "test/unit"
+    class SignalEmitterTest < Test::Unit::TestCase
+        class X
+            include SignalEmitter
+            define_signal :foo
+        end
+
+        def setup
+            @x = X.new
+        end
+
+        def test_on_signal
+            moomin = 0
+            @x.on_signal(:foo) { moomin = 1 }
+            @x.signal :foo
+            assert moomin == 1
+        end
+
+        def test_on_foo
+            moomin = 0
+            @x.on_foo { moomin = 1 }
+            @x.signal :foo
+            assert moomin == 1
+        end
+
+        def test_multiple_on_signal
+            moomin = 0
+            @x.on_signal(:foo) { moomin += 1 }
+            @x.on_signal(:foo) { moomin += 2 }
+            @x.on_signal(:foo) { moomin += 4 }
+            @x.on_signal(:foo) { moomin += 8 }
+            @x.signal :foo
+            assert moomin == 15
+        end
+
+        def test_multiple_on_foo
+            moomin = 0
+            @x.on_foo { moomin += 1 }
+            @x.on_foo { moomin += 2 }
+            @x.on_foo { moomin += 4 }
+            @x.on_foo { moomin += 8 }
+            @x.signal :foo
+            assert moomin == 15
+        end
     end
-  end
 end
 
 ## application-signals.rb ends here.
diff --git a/lib/puppet/parser/functions/split.rb b/lib/puppet/parser/functions/split.rb
index cfb3ab59e..8932bfe38 100644
--- a/lib/puppet/parser/functions/split.rb
+++ b/lib/puppet/parser/functions/split.rb
@@ -1,6 +1,6 @@
 module Puppet::Parser::Functions
-  newfunction(:split, :type => :rvalue, 
-      :doc => "Split a string variable into an array using the specified split character.
+    newfunction(:split, :type => :rvalue,
+                :doc => "Split a string variable into an array using the specified split character.
 
 Usage::
 
@@ -8,6 +8,6 @@ Usage::
     $array_var = split($string, ',')
 
 $array_var holds the result ['value1', 'value2']") do |args|
-    return args[0].split(args[1])
-  end
+        return args[0].split(args[1])
+    end
 end
diff --git a/lib/puppet/provider/group/directoryservice.rb b/lib/puppet/provider/group/directoryservice.rb
index fd89698ce..63c100a58 100644
--- a/lib/puppet/provider/group/directoryservice.rb
+++ b/lib/puppet/provider/group/directoryservice.rb
@@ -17,7 +17,7 @@ require 'puppet/provider/nameservice/directoryservice'
 Puppet::Type.type(:group).provide :directoryservice, :parent => Puppet::Provider::NameService::DirectoryService do
     desc "Group management using DirectoryService on OS X.
 
-  "
+    "
         
     commands :dscl => "/usr/bin/dscl"
     confine :operatingsystem => :darwin
diff --git a/lib/puppet/provider/group/groupadd.rb b/lib/puppet/provider/group/groupadd.rb
index ccd631a75..65c3a5008 100644
--- a/lib/puppet/provider/group/groupadd.rb
+++ b/lib/puppet/provider/group/groupadd.rb
@@ -5,7 +5,7 @@ Puppet::Type.type(:group).provide :groupadd, :parent => Puppet::Provider::NameSe
 
     The default for most platforms
 
-  "
+    "
 
     commands :add => "groupadd", :delete => "groupdel", :modify => "groupmod"
 
diff --git a/lib/puppet/provider/group/ldap.rb b/lib/puppet/provider/group/ldap.rb
index 5a41065f0..94d61f5fb 100644
--- a/lib/puppet/provider/group/ldap.rb
+++ b/lib/puppet/provider/group/ldap.rb
@@ -12,7 +12,7 @@ Puppet::Type.type(:group).provide :ldap, :parent => Puppet::Provider::Ldap do
     not specify one, but it is a potentially expensive operation, as it
     iterates across all existing groups to pick the appropriate next one.
 
-  "
+    "
 
     confine :true => Puppet.features.ldap?, :false => (Puppet[:ldapuser] == "")
 
diff --git a/lib/puppet/provider/group/netinfo.rb b/lib/puppet/provider/group/netinfo.rb
index 4b8fc5f9e..8402e38bb 100644
--- a/lib/puppet/provider/group/netinfo.rb
+++ b/lib/puppet/provider/group/netinfo.rb
@@ -8,7 +8,7 @@ require 'puppet/provider/nameservice/netinfo'
 Puppet::Type.type(:group).provide :netinfo, :parent => Puppet::Provider::NameService::NetInfo do
     desc "Group management using NetInfo.
 
-  "
+    "
     commands :nireport => "nireport", :niutil => "niutil"
 
 end
diff --git a/lib/puppet/provider/group/pw.rb b/lib/puppet/provider/group/pw.rb
index 4c7ba795e..39fb23800 100644
--- a/lib/puppet/provider/group/pw.rb
+++ b/lib/puppet/provider/group/pw.rb
@@ -5,7 +5,7 @@ Puppet::Type.type(:group).provide :pw, :parent => Puppet::Provider::NameService:
 
     Only works on FreeBSD.
 
-  "
+    "
 
     commands :pw => "/usr/sbin/pw"
     defaultfor :operatingsystem => :freebsd
diff --git a/lib/puppet/provider/host/netinfo.rb b/lib/puppet/provider/host/netinfo.rb
index 55294958c..534b06a8e 100644
--- a/lib/puppet/provider/host/netinfo.rb
+++ b/lib/puppet/provider/host/netinfo.rb
@@ -8,7 +8,7 @@ Puppet::Type.type(:host).provide :netinfo, :parent => Puppet::Provider::NameServ
 
     This provider is highly experimental and is known not to work currently.
 
-  "
+    "
     commands :nireport => "nireport", :niutil => "niutil"
     commands :mountcmd => "mount", :umount => "umount", :df => "df"
 
diff --git a/lib/puppet/provider/macauthorization/macauthorization.rb b/lib/puppet/provider/macauthorization/macauthorization.rb
index fce158e2a..759540cc0 100644
--- a/lib/puppet/provider/macauthorization/macauthorization.rb
+++ b/lib/puppet/provider/macauthorization/macauthorization.rb
@@ -7,7 +7,7 @@ Puppet::Type.type(:macauthorization).provide :macauthorization, :parent => Puppe
 
     desc "Manage Mac OS X authorization database rules and rights.
 
-  "
+    "
 
     commands :security => "/usr/bin/security"
     commands :sw_vers => "/usr/bin/sw_vers"
diff --git a/lib/puppet/provider/mcx/mcxcontent.rb b/lib/puppet/provider/mcx/mcxcontent.rb
index 1fea60ca0..b899aa108 100644
--- a/lib/puppet/provider/mcx/mcxcontent.rb
+++ b/lib/puppet/provider/mcx/mcxcontent.rb
@@ -23,16 +23,16 @@ Puppet::Type.type(:mcx).provide :mcxcontent, :parent => Puppet::Provider do
 
     desc "MCX Settings management using DirectoryService on OS X.
 
-  This provider manages the entire MCXSettings attribute available
-  to some directory services nodes.  This management is 'all or nothing'
-  in that discrete application domain key value pairs are not managed
-  by this provider.
+    This provider manages the entire MCXSettings attribute available
+    to some directory services nodes.  This management is 'all or nothing'
+    in that discrete application domain key value pairs are not managed
+    by this provider.
 
-  It is recommended to use WorkGroup Manager to configure Users, Groups,
-  Computers, or ComputerLists, then use 'ralsh mcx' to generate a puppet
-  manifest from the resulting configuration.
+    It is recommended to use WorkGroup Manager to configure Users, Groups,
+    Computers, or ComputerLists, then use 'ralsh mcx' to generate a puppet
+    manifest from the resulting configuration.
 
-  Original Author: Jeff McCune (mccune.jeff@gmail.com)
+    Original Author: Jeff McCune (mccune.jeff@gmail.com)
 
 "
 
diff --git a/lib/puppet/provider/service/base.rb b/lib/puppet/provider/service/base.rb
index 2f456886a..462dd897d 100755
--- a/lib/puppet/provider/service/base.rb
+++ b/lib/puppet/provider/service/base.rb
@@ -7,7 +7,7 @@ Puppet::Type.type(:service).provide :base do
     service.  It is preferable to specify start, stop, and status commands,
     akin to how you would do so using ``init``.
 
-  "
+    "
 
     commands :kill => "kill"
 
diff --git a/lib/puppet/provider/service/daemontools.rb b/lib/puppet/provider/service/daemontools.rb
index e5b55012b..67520da06 100644
--- a/lib/puppet/provider/service/daemontools.rb
+++ b/lib/puppet/provider/service/daemontools.rb
@@ -37,7 +37,7 @@ Puppet::Type.type(:service).provide :daemontools, :parent => :base do
     If a service has ensure => \"stopped\", it will only down the service, not
     remove the /path/to/service link.
 
-  """
+    """
 
     commands :svc  => "/usr/bin/svc", :svstat => "/usr/bin/svstat"
 
@@ -87,16 +87,16 @@ Puppet::Type.type(:service).provide :daemontools, :parent => :base do
 
     # find the service dir on this node
     def servicedir
-      unless defined?(@servicedir) and @servicedir
-        ["/service", "/etc/service","/var/lib/svscan"].each do |path|
-            if FileTest.exist?(path)
-                @servicedir = path
-                break
+        unless defined?(@servicedir) and @servicedir
+            ["/service", "/etc/service","/var/lib/svscan"].each do |path|
+                if FileTest.exist?(path)
+                    @servicedir = path
+                    break
+                end
             end
+            raise "Could not find service directory" unless @servicedir
         end
-        raise "Could not find service directory" unless @servicedir
-      end
-      @servicedir
+        @servicedir
     end
 
     # returns the full path of this service when enabled
diff --git a/lib/puppet/provider/service/debian.rb b/lib/puppet/provider/service/debian.rb
index 48d509871..8527ae036 100755
--- a/lib/puppet/provider/service/debian.rb
+++ b/lib/puppet/provider/service/debian.rb
@@ -6,7 +6,7 @@ Puppet::Type.type(:service).provide :debian, :parent => :init do
     The only difference is that this supports service enabling and disabling
     via ``update-rc.d``.
 
-  "
+    "
 
     commands :update => "/usr/sbin/update-rc.d"
     defaultfor :operatingsystem => [:debian, :ubuntu]
diff --git a/lib/puppet/provider/service/gentoo.rb b/lib/puppet/provider/service/gentoo.rb
index 95d5b3a25..bf9c3a173 100644
--- a/lib/puppet/provider/service/gentoo.rb
+++ b/lib/puppet/provider/service/gentoo.rb
@@ -5,7 +5,7 @@ Puppet::Type.type(:service).provide :gentoo, :parent => :init do
 
     Uses ``rc-update`` for service enabling and disabling.
 
-  "
+    "
 
     commands :update => "/sbin/rc-update"
 
diff --git a/lib/puppet/provider/service/launchd.rb b/lib/puppet/provider/service/launchd.rb
index 64b61ff85..ee0dac6a5 100644
--- a/lib/puppet/provider/service/launchd.rb
+++ b/lib/puppet/provider/service/launchd.rb
@@ -34,7 +34,7 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     Note that this allows you to do something launchctl can't do, which is to
     be in a state of \"stopped/enabled\ or \"running/disabled\".
 
-  "
+    "
 
     commands :launchctl => "/bin/launchctl"
     
@@ -52,31 +52,31 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
     # returns a label => path map for either all jobs, or just a single
     # job if the label is specified
     def self.jobsearch(label=nil)
-       label_to_path_map = {}
-       Launchd_Paths.each do |path|
-           if FileTest.exists?(path)
-               Dir.entries(path).each do |f|
-                   next if f =~ /^\..*$/
-                   next if FileTest.directory?(f)
-                   fullpath = File.join(path, f)
-                   job = Plist::parse_xml(fullpath)
-                   if job and job.has_key?("Label")
-                       if job["Label"] == label
-                           return { label => fullpath }
-                       else
-                           label_to_path_map[job["Label"]] = fullpath
-                       end
-                   end
-               end
-           end
-       end
-       
-       # if we didn't find the job above and we should have, error.
-       if label
-           raise Puppet::Error.new("Unable to find launchd plist for job: #{label}")
-       end
-       # if returning all jobs
-       label_to_path_map
+        label_to_path_map = {}
+        Launchd_Paths.each do |path|
+            if FileTest.exists?(path)
+                Dir.entries(path).each do |f|
+                    next if f =~ /^\..*$/
+                    next if FileTest.directory?(f)
+                    fullpath = File.join(path, f)
+                    job = Plist::parse_xml(fullpath)
+                    if job and job.has_key?("Label")
+                        if job["Label"] == label
+                            return { label => fullpath }
+                        else
+                            label_to_path_map[job["Label"]] = fullpath
+                        end
+                    end
+                end
+            end
+        end
+
+        # if we didn't find the job above and we should have, error.
+        if label
+            raise Puppet::Error.new("Unable to find launchd plist for job: #{label}")
+        end
+        # if returning all jobs
+        label_to_path_map
     end
 
 
diff --git a/lib/puppet/provider/service/redhat.rb b/lib/puppet/provider/service/redhat.rb
index 02ff96b2a..aec49a583 100755
--- a/lib/puppet/provider/service/redhat.rb
+++ b/lib/puppet/provider/service/redhat.rb
@@ -5,7 +5,7 @@ Puppet::Type.type(:service).provide :redhat, :parent => :init do
 
     Uses ``chkconfig`` for service enabling and disabling.
 
-  "
+    "
 
     commands :chkconfig => "/sbin/chkconfig", :service => "/sbin/service"
  
@@ -54,22 +54,22 @@ Puppet::Type.type(:service).provide :redhat, :parent => :init do
  
     def restart
         if @resource[:hasrestart] == :true
-              service(@resource[:name], "restart")
+            service(@resource[:name], "restart")
         else
-           super
+            super
         end
     end
 
     def status
         if @resource[:hasstatus] == :true
-              begin 
-                  service(@resource[:name], "status")
-                  return :running
-              rescue 
-                  return :stopped
-              end 
+            begin
+                service(@resource[:name], "status")
+                return :running
+            rescue
+                return :stopped
+            end
         else
-           super
+            super
         end
     end
 
diff --git a/lib/puppet/provider/service/runit.rb b/lib/puppet/provider/service/runit.rb
index 1bd954207..0deeb0f22 100644
--- a/lib/puppet/provider/service/runit.rb
+++ b/lib/puppet/provider/service/runit.rb
@@ -54,16 +54,16 @@ Puppet::Type.type(:service).provide :runit, :parent => :daemontools do
 
     # find the service dir on this node
     def servicedir
-      unless defined?(@servicedir) and @servicedir
-        ["/service", "/etc/service","/var/service"].each do |path|
-            if FileTest.exist?(path)
-                @servicedir = path
-                break
+        unless defined?(@servicedir) and @servicedir
+            ["/service", "/etc/service","/var/service"].each do |path|
+                if FileTest.exist?(path)
+                    @servicedir = path
+                    break
+                end
             end
+            raise "Could not find service directory" unless @servicedir
         end
-        raise "Could not find service directory" unless @servicedir
-      end
-      @servicedir
+        @servicedir
     end
 
     def restartcmd
diff --git a/lib/puppet/provider/service/smf.rb b/lib/puppet/provider/service/smf.rb
index 83c99f21a..7cdebe53d 100755
--- a/lib/puppet/provider/service/smf.rb
+++ b/lib/puppet/provider/service/smf.rb
@@ -9,7 +9,7 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
     By specifying manifest => \"/path/to/service.xml\", the SMF manifest will
     be imported if it does not exist.
 
-  "
+    "
 
     defaultfor :operatingsystem => :solaris
 
@@ -29,7 +29,7 @@ Puppet::Type.type(:service).provide :smf, :parent => :base do
             end
         rescue Puppet::ExecutionFailure => detail
             raise Puppet::Error.new( "Cannot config %s to enable it: %s" % [ self.service, detail ] )
-         end
+        end
     end
 
     def enable