Code smell: Two space indentation

Replaced 106806 occurances of ^( +)(.*$) with

The ruby community almost universally (i.e. everyone but Luke, Markus, and the other eleven people
who learned ruby in the 1900s) uses two-space indentation.

3 Examples:

    The code:
        end

        # Tell getopt which arguments are valid
        def test_get_getopt_args
            element = Setting.new :name => "foo", :desc => "anything", :settings => Puppet::Util::Settings.new
            assert_equal([["--foo", GetoptLong::REQUIRED_ARGUMENT]], element.getopt_args, "Did not produce appropriate getopt args")

    becomes:
        end

        # Tell getopt which arguments are valid
        def test_get_getopt_args
          element = Setting.new :name => "foo", :desc => "anything", :settings => Puppet::Util::Settings.new
          assert_equal([["--foo", GetoptLong::REQUIRED_ARGUMENT]], element.getopt_args, "Did not produce appropriate getopt args")

    The code:
            assert_equal(str, val)

            assert_instance_of(Float, result)

        end

        # Now test it with a passed object
    becomes:
          assert_equal(str, val)

          assert_instance_of(Float, result)

        end

        # Now test it with a passed object
    The code:
        end

        assert_nothing_raised do
            klass[:Yay] = "boo"
            klass["Cool"] = :yayness
        end

    becomes:
        end

        assert_nothing_raised do
          klass[:Yay] = "boo"
          klass["Cool"] = :yayness
        end

1 files changed, 411 insertions, 411 deletions

diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index 17b05baab..85980722c 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -10,484 +10,484 @@ require 'puppet/resource/type_collection_helper'
 # Maintain a graph of scopes, along with a bunch of data
 # about the individual catalog we're compiling.
 class Puppet::Parser::Compiler
-    include Puppet::Util
-    include Puppet::Util::Errors
-    include Puppet::Resource::TypeCollectionHelper
-
-    def self.compile(node)
-        new(node).compile.to_resource
-    rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        raise Puppet::Error, "#{detail} on node #{node.name}"
-    end
-
-    attr_reader :node, :facts, :collections, :catalog, :node_scope, :resources, :relationships
+  include Puppet::Util
+  include Puppet::Util::Errors
+  include Puppet::Resource::TypeCollectionHelper
 
-    # Add a collection to the global list.
-    def add_collection(coll)
-        @collections << coll
-    end
-
-    def add_relationship(dep)
-        @relationships << dep
-    end
+  def self.compile(node)
+    new(node).compile.to_resource
+  rescue => detail
+    puts detail.backtrace if Puppet[:trace]
+    raise Puppet::Error, "#{detail} on node #{node.name}"
+  end
 
-    # Store a resource override.
-    def add_override(override)
-        # If possible, merge the override in immediately.
-        if resource = @catalog.resource(override.ref)
-            resource.merge(override)
-        else
-            # Otherwise, store the override for later; these
-            # get evaluated in Resource#finish.
-            @resource_overrides[override.ref] << override
-        end
-    end
+  attr_reader :node, :facts, :collections, :catalog, :node_scope, :resources, :relationships
 
-    # Store a resource in our resource table.
-    def add_resource(scope, resource)
-        @resources << resource
+  # Add a collection to the global list.
+  def add_collection(coll)
+    @collections << coll
+  end
 
-        # Note that this will fail if the resource is not unique.
-        @catalog.add_resource(resource)
+  def add_relationship(dep)
+    @relationships << dep
+  end
 
-        set_container_resource(scope, resource)
+  # Store a resource override.
+  def add_override(override)
+    # If possible, merge the override in immediately.
+    if resource = @catalog.resource(override.ref)
+      resource.merge(override)
+    else
+      # Otherwise, store the override for later; these
+      # get evaluated in Resource#finish.
+      @resource_overrides[override.ref] << override
     end
+  end
 
-    # Add our container edge.  If we're a class, then we get treated specially - we can
-    # control the stage that the class is applied in.  Otherwise, we just
-    # get added to our parent container.
-    def set_container_resource(scope, resource)
-        return if resource.type.to_s.downcase == "stage"
-
-        if resource.type.to_s.downcase != "class"
-            raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage" if resource[:stage]
-            return @catalog.add_edge(scope.resource, resource)
-        end
-
-        unless stage = @catalog.resource(:stage, resource[:stage] || :main)
-            raise ArgumentError, "Could not find stage #{resource[:stage] || :main} specified by #{resource}"
-        end
+  # Store a resource in our resource table.
+  def add_resource(scope, resource)
+    @resources << resource
 
-        @catalog.add_edge(stage, resource)
-    end
+    # Note that this will fail if the resource is not unique.
+    @catalog.add_resource(resource)
 
-    private :set_container_resource
+    set_container_resource(scope, resource)
+  end
 
-    # Do we use nodes found in the code, vs. the external node sources?
-    def ast_nodes?
-        known_resource_types.nodes?
-    end
+  # Add our container edge.  If we're a class, then we get treated specially - we can
+  # control the stage that the class is applied in.  Otherwise, we just
+  # get added to our parent container.
+  def set_container_resource(scope, resource)
+    return if resource.type.to_s.downcase == "stage"
 
-    # Store the fact that we've evaluated a class
-    def add_class(name)
-        @catalog.add_class(name) unless name == ""
+    if resource.type.to_s.downcase != "class"
+      raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage" if resource[:stage]
+      return @catalog.add_edge(scope.resource, resource)
     end
 
-
-    # Return a list of all of the defined classes.
-    def classlist
-        @catalog.classes
+    unless stage = @catalog.resource(:stage, resource[:stage] || :main)
+      raise ArgumentError, "Could not find stage #{resource[:stage] || :main} specified by #{resource}"
     end
 
-    # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
-    # This is the main entry into our catalog.
-    def compile
-        # Set the client's parameters into the top scope.
-        set_node_parameters
-        create_settings_scope
+    @catalog.add_edge(stage, resource)
+  end
 
-        evaluate_main
+  private :set_container_resource
+
+  # Do we use nodes found in the code, vs. the external node sources?
+  def ast_nodes?
+    known_resource_types.nodes?
+  end
 
-        evaluate_ast_node
+  # Store the fact that we've evaluated a class
+  def add_class(name)
+    @catalog.add_class(name) unless name == ""
+  end
 
-        evaluate_node_classes
 
-        evaluate_generators
+  # Return a list of all of the defined classes.
+  def classlist
+    @catalog.classes
+  end
+
+  # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
+  # This is the main entry into our catalog.
+  def compile
+    # Set the client's parameters into the top scope.
+    set_node_parameters
+    create_settings_scope
+
+    evaluate_main
+
+    evaluate_ast_node
+
+    evaluate_node_classes
+
+    evaluate_generators
+
+    finish
+
+    fail_on_unevaluated
+
+    @catalog
+  end
+
+  # LAK:FIXME There are no tests for this.
+  def delete_collection(coll)
+    @collections.delete(coll) if @collections.include?(coll)
+  end
 
-        finish
-
-        fail_on_unevaluated
-
-        @catalog
+  # Return the node's environment.
+  def environment
+    unless defined?(@environment)
+      @environment = (node.environment and node.environment != "") ? node.environment : nil
     end
+    Puppet::Node::Environment.current = @environment
+    @environment
+  end
 
-    # LAK:FIXME There are no tests for this.
-    def delete_collection(coll)
-        @collections.delete(coll) if @collections.include?(coll)
-    end
+  # Evaluate all of the classes specified by the node.
+  def evaluate_node_classes
+    evaluate_classes(@node.classes, topscope)
+  end
 
-    # Return the node's environment.
-    def environment
-        unless defined?(@environment)
-            @environment = (node.environment and node.environment != "") ? node.environment : nil
-        end
-        Puppet::Node::Environment.current = @environment
-        @environment
-    end
+  # Evaluate each specified class in turn.  If there are any classes we can't
+  # find, just tag the catalog and move on.  This method really just
+  # creates resource objects that point back to the classes, and then the
+  # resources are themselves evaluated later in the process.
+  def evaluate_classes(classes, scope, lazy_evaluate = true)
+    raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
+    found = []
+    classes.each do |name|
+      # If we can find the class, then make a resource that will evaluate it.
+      if klass = scope.find_hostclass(name)
+        found << name and next if scope.class_scope(klass)
 
-    # Evaluate all of the classes specified by the node.
-    def evaluate_node_classes
-        evaluate_classes(@node.classes, topscope)
-    end
-
-    # Evaluate each specified class in turn.  If there are any classes we can't
-    # find, just tag the catalog and move on.  This method really just
-    # creates resource objects that point back to the classes, and then the
-    # resources are themselves evaluated later in the process.
-    def evaluate_classes(classes, scope, lazy_evaluate = true)
-        raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
-        found = []
-        classes.each do |name|
-            # If we can find the class, then make a resource that will evaluate it.
-            if klass = scope.find_hostclass(name)
-                found << name and next if scope.class_scope(klass)
-
-                resource = klass.mk_plain_resource(scope)
-
-                # If they've disabled lazy evaluation (which the :include function does),
-                # then evaluate our resource immediately.
-                resource.evaluate unless lazy_evaluate
-                found << name
-            else
-                Puppet.info "Could not find class #{name} for #{node.name}"
-                @catalog.tag(name)
-            end
-        end
-        found
-    end
-
-    def evaluate_relationships
-        @relationships.each { |rel| rel.evaluate(catalog) }
-    end
+        resource = klass.mk_plain_resource(scope)
 
-    # Return a resource by either its ref or its type and title.
-    def findresource(*args)
-        @catalog.resource(*args)
+        # If they've disabled lazy evaluation (which the :include function does),
+        # then evaluate our resource immediately.
+        resource.evaluate unless lazy_evaluate
+        found << name
+      else
+        Puppet.info "Could not find class #{name} for #{node.name}"
+        @catalog.tag(name)
+      end
     end
-
-    def initialize(node, options = {})
-        @node = node
-
-        options.each do |param, value|
-            begin
-                send(param.to_s + "=", value)
-            rescue NoMethodError
-                raise ArgumentError, "Compiler objects do not accept #{param}"
-            end
+    found
+  end
+
+  def evaluate_relationships
+    @relationships.each { |rel| rel.evaluate(catalog) }
+  end
+
+  # Return a resource by either its ref or its type and title.
+  def findresource(*args)
+    @catalog.resource(*args)
+  end
+
+  def initialize(node, options = {})
+    @node = node
+
+    options.each do |param, value|
+      begin
+        send(param.to_s + "=", value)
+      rescue NoMethodError
+        raise ArgumentError, "Compiler objects do not accept #{param}"
+      end
+    end
+
+    initvars
+  end
+
+  # Create a new scope, with either a specified parent scope or
+  # using the top scope.
+  def newscope(parent, options = {})
+    parent ||= topscope
+    options[:compiler] = self
+    scope = Puppet::Parser::Scope.new(options)
+    scope.parent = parent
+    scope
+  end
+
+  # Return any overrides for the given resource.
+  def resource_overrides(resource)
+    @resource_overrides[resource.ref]
+  end
+
+  # The top scope is usually the top-level scope, but if we're using AST nodes,
+  # then it is instead the node's scope.
+  def topscope
+    node_scope || @topscope
+  end
+
+  private
+
+  # If ast nodes are enabled, then see if we can find and evaluate one.
+  def evaluate_ast_node
+    return unless ast_nodes?
+
+    # Now see if we can find the node.
+    astnode = nil
+    @node.names.each do |name|
+      break if astnode = known_resource_types.node(name.to_s.downcase)
+    end
+
+    unless (astnode ||= known_resource_types.node("default"))
+      raise Puppet::ParseError, "Could not find default node or by name with '#{node.names.join(", ")}'"
+    end
+
+    # Create a resource to model this node, and then add it to the list
+    # of resources.
+    resource = astnode.mk_plain_resource(topscope)
+
+    resource.evaluate
+
+    # Now set the node scope appropriately, so that :topscope can
+    # behave differently.
+    @node_scope = topscope.class_scope(astnode)
+  end
+
+  # Evaluate our collections and return true if anything returned an object.
+  # The 'true' is used to continue a loop, so it's important.
+  def evaluate_collections
+    return false if @collections.empty?
+
+    found_something = false
+    exceptwrap do
+      # We have to iterate over a dup of the array because
+      # collections can delete themselves from the list, which
+      # changes its length and causes some collections to get missed.
+      @collections.dup.each do |collection|
+        found_something = true if collection.evaluate
+      end
+    end
+
+    found_something
+  end
+
+  # Make sure all of our resources have been evaluated into native resources.
+  # We return true if any resources have, so that we know to continue the
+  # evaluate_generators loop.
+  def evaluate_definitions
+    exceptwrap do
+      if ary = unevaluated_resources
+        evaluated = false
+        ary.each do |resource|
+          if not resource.virtual?
+            resource.evaluate
+            evaluated = true
+          end
         end
-
-        initvars
-    end
-
-    # Create a new scope, with either a specified parent scope or
-    # using the top scope.
-    def newscope(parent, options = {})
-        parent ||= topscope
-        options[:compiler] = self
-        scope = Puppet::Parser::Scope.new(options)
-        scope.parent = parent
-        scope
-    end
-
-    # Return any overrides for the given resource.
-    def resource_overrides(resource)
-        @resource_overrides[resource.ref]
-    end
-
-    # The top scope is usually the top-level scope, but if we're using AST nodes,
-    # then it is instead the node's scope.
-    def topscope
-        node_scope || @topscope
-    end
-
-    private
-
-    # If ast nodes are enabled, then see if we can find and evaluate one.
-    def evaluate_ast_node
-        return unless ast_nodes?
-
-        # Now see if we can find the node.
-        astnode = nil
-        @node.names.each do |name|
-            break if astnode = known_resource_types.node(name.to_s.downcase)
-        end
-
-        unless (astnode ||= known_resource_types.node("default"))
-            raise Puppet::ParseError, "Could not find default node or by name with '#{node.names.join(", ")}'"
+        # If we evaluated, let the loop know.
+        return evaluated
+      else
+        return false
+      end
+    end
+  end
+
+  # Iterate over collections and resources until we're sure that the whole
+  # compile is evaluated.  This is necessary because both collections
+  # and defined resources can generate new resources, which themselves could
+  # be defined resources.
+  def evaluate_generators
+    count = 0
+    loop do
+      done = true
+
+      # Call collections first, then definitions.
+      done = false if evaluate_collections
+      done = false if evaluate_definitions
+      break if done
+
+      count += 1
+
+      if count > 1000
+        raise Puppet::ParseError, "Somehow looped more than 1000 times while evaluating host catalog"
+      end
+    end
+  end
+
+  # Find and evaluate our main object, if possible.
+  def evaluate_main
+    @main = known_resource_types.find_hostclass([""], "") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
+    @topscope.source = @main
+    @main_resource = Puppet::Parser::Resource.new("class", :main, :scope => @topscope, :source => @main)
+    @topscope.resource = @main_resource
+
+    @resources << @main_resource
+    @catalog.add_resource(@main_resource)
+
+    set_container_resource(@topscope, @main_resource)
+
+    @main_resource.evaluate
+  end
+
+  # Make sure the entire catalog is evaluated.
+  def fail_on_unevaluated
+    fail_on_unevaluated_overrides
+    fail_on_unevaluated_resource_collections
+  end
+
+  # If there are any resource overrides remaining, then we could
+  # not find the resource they were supposed to override, so we
+  # want to throw an exception.
+  def fail_on_unevaluated_overrides
+    remaining = []
+    @resource_overrides.each do |name, overrides|
+      remaining += overrides
+    end
+
+    unless remaining.empty?
+      fail Puppet::ParseError,
+        "Could not find resource(s) %s for overriding" % remaining.collect { |o|
+          o.ref
+        }.join(", ")
+    end
+  end
+
+  # Make sure we don't have any remaining collections that specifically
+  # look for resources, because we want to consider those to be
+  # parse errors.
+  def fail_on_unevaluated_resource_collections
+    remaining = []
+    @collections.each do |coll|
+      # We're only interested in the 'resource' collections,
+      # which result from direct calls of 'realize'.  Anything
+      # else is allowed not to return resources.
+      # Collect all of them, so we have a useful error.
+      if r = coll.resources
+        if r.is_a?(Array)
+          remaining += r
+        else
+          remaining << r
         end
-
-        # Create a resource to model this node, and then add it to the list
-        # of resources.
-        resource = astnode.mk_plain_resource(topscope)
-
-        resource.evaluate
-
-        # Now set the node scope appropriately, so that :topscope can
-        # behave differently.
-        @node_scope = topscope.class_scope(astnode)
+      end
     end
 
-    # Evaluate our collections and return true if anything returned an object.
-    # The 'true' is used to continue a loop, so it's important.
-    def evaluate_collections
-        return false if @collections.empty?
-
-        found_something = false
-        exceptwrap do
-            # We have to iterate over a dup of the array because
-            # collections can delete themselves from the list, which
-            # changes its length and causes some collections to get missed.
-            @collections.dup.each do |collection|
-                found_something = true if collection.evaluate
-            end
-        end
+    raise Puppet::ParseError, "Failed to realize virtual resources #{remaining.join(', ')}" unless remaining.empty?
+  end
 
-        found_something
-    end
+  # Make sure all of our resources and such have done any last work
+  # necessary.
+  def finish
+    evaluate_relationships
 
-    # Make sure all of our resources have been evaluated into native resources.
-    # We return true if any resources have, so that we know to continue the
-    # evaluate_generators loop.
-    def evaluate_definitions
-        exceptwrap do
-            if ary = unevaluated_resources
-                evaluated = false
-                ary.each do |resource|
-                    if not resource.virtual?
-                        resource.evaluate
-                        evaluated = true
-                    end
-                end
-                # If we evaluated, let the loop know.
-                return evaluated
-            else
-                return false
-            end
+    resources.each do |resource|
+      # Add in any resource overrides.
+      if overrides = resource_overrides(resource)
+        overrides.each do |over|
+          resource.merge(over)
         end
-    end
 
-    # Iterate over collections and resources until we're sure that the whole
-    # compile is evaluated.  This is necessary because both collections
-    # and defined resources can generate new resources, which themselves could
-    # be defined resources.
-    def evaluate_generators
-        count = 0
-        loop do
-            done = true
-
-            # Call collections first, then definitions.
-            done = false if evaluate_collections
-            done = false if evaluate_definitions
-            break if done
-
-            count += 1
-
-            if count > 1000
-                raise Puppet::ParseError, "Somehow looped more than 1000 times while evaluating host catalog"
-            end
-        end
-    end
-
-    # Find and evaluate our main object, if possible.
-    def evaluate_main
-        @main = known_resource_types.find_hostclass([""], "") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
-        @topscope.source = @main
-        @main_resource = Puppet::Parser::Resource.new("class", :main, :scope => @topscope, :source => @main)
-        @topscope.resource = @main_resource
-
-        @resources << @main_resource
-        @catalog.add_resource(@main_resource)
+        # Remove the overrides, so that the configuration knows there
+        # are none left.
+        overrides.clear
+      end
 
-        set_container_resource(@topscope, @main_resource)
-
-        @main_resource.evaluate
+      resource.finish if resource.respond_to?(:finish)
     end
 
-    # Make sure the entire catalog is evaluated.
-    def fail_on_unevaluated
-        fail_on_unevaluated_overrides
-        fail_on_unevaluated_resource_collections
-    end
+    add_resource_metaparams
+  end
 
-    # If there are any resource overrides remaining, then we could
-    # not find the resource they were supposed to override, so we
-    # want to throw an exception.
-    def fail_on_unevaluated_overrides
-        remaining = []
-        @resource_overrides.each do |name, overrides|
-            remaining += overrides
-        end
-
-        unless remaining.empty?
-            fail Puppet::ParseError,
-                "Could not find resource(s) %s for overriding" % remaining.collect { |o|
-                    o.ref
-                }.join(", ")
-        end
+  def add_resource_metaparams
+    unless main = catalog.resource(:class, :main)
+      raise "Couldn't find main"
     end
 
-    # Make sure we don't have any remaining collections that specifically
-    # look for resources, because we want to consider those to be
-    # parse errors.
-    def fail_on_unevaluated_resource_collections
-        remaining = []
-        @collections.each do |coll|
-            # We're only interested in the 'resource' collections,
-            # which result from direct calls of 'realize'.  Anything
-            # else is allowed not to return resources.
-            # Collect all of them, so we have a useful error.
-            if r = coll.resources
-                if r.is_a?(Array)
-                    remaining += r
-                else
-                    remaining << r
-                end
-            end
-        end
-
-        raise Puppet::ParseError, "Failed to realize virtual resources #{remaining.join(', ')}" unless remaining.empty?
+    names = []
+    Puppet::Type.eachmetaparam do |name|
+      next if Puppet::Parser::Resource.relationship_parameter?(name)
+      names << name
     end
 
-    # Make sure all of our resources and such have done any last work
-    # necessary.
-    def finish
-        evaluate_relationships
-
-        resources.each do |resource|
-            # Add in any resource overrides.
-            if overrides = resource_overrides(resource)
-                overrides.each do |over|
-                    resource.merge(over)
-                end
-
-                # Remove the overrides, so that the configuration knows there
-                # are none left.
-                overrides.clear
-            end
-
-            resource.finish if resource.respond_to?(:finish)
+    data = {}
+    catalog.walk(main, :out) do |source, target|
+      if source_data = data[source] || metaparams_as_data(source, names)
+        # only store anything in the data hash if we've actually got
+        # data
+        data[source] ||= source_data
+        source_data.each do |param, value|
+          target[param] = value if target[param].nil?
         end
+        data[target] = source_data.merge(metaparams_as_data(target, names))
+      end
 
-        add_resource_metaparams
+      target.tag(*(source.tags))
     end
+  end
 
-    def add_resource_metaparams
-        unless main = catalog.resource(:class, :main)
-            raise "Couldn't find main"
-        end
-
-        names = []
-        Puppet::Type.eachmetaparam do |name|
-            next if Puppet::Parser::Resource.relationship_parameter?(name)
-            names << name
-        end
-
-        data = {}
-        catalog.walk(main, :out) do |source, target|
-            if source_data = data[source] || metaparams_as_data(source, names)
-                # only store anything in the data hash if we've actually got
-                # data
-                data[source] ||= source_data
-                source_data.each do |param, value|
-                    target[param] = value if target[param].nil?
-                end
-                data[target] = source_data.merge(metaparams_as_data(target, names))
-            end
-
-            target.tag(*(source.tags))
-        end
+  def metaparams_as_data(resource, params)
+    data = nil
+    params.each do |param|
+      unless resource[param].nil?
+        # Because we could be creating a hash for every resource,
+        # and we actually probably don't often have any data here at all,
+        # we're optimizing a bit by only creating a hash if there's
+        # any data to put in it.
+        data ||= {}
+        data[param] = resource[param]
+      end
     end
+    data
+  end
 
-    def metaparams_as_data(resource, params)
-        data = nil
-        params.each do |param|
-            unless resource[param].nil?
-                # Because we could be creating a hash for every resource,
-                # and we actually probably don't often have any data here at all,
-                # we're optimizing a bit by only creating a hash if there's
-                # any data to put in it.
-                data ||= {}
-                data[param] = resource[param]
-            end
-        end
-        data
-    end
+  # Set up all of our internal variables.
+  def initvars
+    # The list of objects that will available for export.
+    @exported_resources = {}
 
-    # Set up all of our internal variables.
-    def initvars
-        # The list of objects that will available for export.
-        @exported_resources = {}
+    # The list of overrides.  This is used to cache overrides on objects
+    # that don't exist yet.  We store an array of each override.
+    @resource_overrides = Hash.new do |overs, ref|
+      overs[ref] = []
+    end
 
-        # The list of overrides.  This is used to cache overrides on objects
-        # that don't exist yet.  We store an array of each override.
-        @resource_overrides = Hash.new do |overs, ref|
-            overs[ref] = []
-        end
+    # The list of collections that have been created.  This is a global list,
+    # but they each refer back to the scope that created them.
+    @collections = []
 
-        # The list of collections that have been created.  This is a global list,
-        # but they each refer back to the scope that created them.
-        @collections = []
+    # The list of relationships to evaluate.
+    @relationships = []
 
-        # The list of relationships to evaluate.
-        @relationships = []
+    # For maintaining the relationship between scopes and their resources.
+    @catalog = Puppet::Resource::Catalog.new(@node.name)
+    @catalog.version = known_resource_types.version
 
-        # For maintaining the relationship between scopes and their resources.
-        @catalog = Puppet::Resource::Catalog.new(@node.name)
-        @catalog.version = known_resource_types.version
+    # Create our initial scope and a resource that will evaluate main.
+    @topscope = Puppet::Parser::Scope.new(:compiler => self)
 
-        # Create our initial scope and a resource that will evaluate main.
-        @topscope = Puppet::Parser::Scope.new(:compiler => self)
+    @main_stage_resource = Puppet::Parser::Resource.new("stage", :main, :scope => @topscope)
+    @catalog.add_resource(@main_stage_resource)
 
-        @main_stage_resource = Puppet::Parser::Resource.new("stage", :main, :scope => @topscope)
-        @catalog.add_resource(@main_stage_resource)
+    # local resource array to maintain resource ordering
+    @resources = []
 
-        # local resource array to maintain resource ordering
-        @resources = []
+    # Make sure any external node classes are in our class list
+    @catalog.add_class(*@node.classes)
+  end
 
-        # Make sure any external node classes are in our class list
-        @catalog.add_class(*@node.classes)
+  # Set the node's parameters into the top-scope as variables.
+  def set_node_parameters
+    node.parameters.each do |param, value|
+      @topscope.setvar(param, value)
     end
 
-    # Set the node's parameters into the top-scope as variables.
-    def set_node_parameters
-        node.parameters.each do |param, value|
-            @topscope.setvar(param, value)
-        end
+    # These might be nil.
+    catalog.client_version = node.parameters["clientversion"]
+    catalog.server_version = node.parameters["serverversion"]
+  end
 
-        # These might be nil.
-        catalog.client_version = node.parameters["clientversion"]
-        catalog.server_version = node.parameters["serverversion"]
+  def create_settings_scope
+    unless settings_type = environment.known_resource_types.hostclass("settings")
+      settings_type = Puppet::Resource::Type.new :hostclass, "settings"
+      environment.known_resource_types.add(settings_type)
     end
 
-    def create_settings_scope
-        unless settings_type = environment.known_resource_types.hostclass("settings")
-            settings_type = Puppet::Resource::Type.new :hostclass, "settings"
-            environment.known_resource_types.add(settings_type)
-        end
+    settings_resource = Puppet::Parser::Resource.new("class", "settings", :scope => @topscope)
+    settings_type.evaluate_code(settings_resource)
 
-        settings_resource = Puppet::Parser::Resource.new("class", "settings", :scope => @topscope)
-        settings_type.evaluate_code(settings_resource)
+    @catalog.add_resource(settings_resource)
 
-        @catalog.add_resource(settings_resource)
+    scope = @topscope.class_scope(settings_type)
 
-        scope = @topscope.class_scope(settings_type)
-
-        Puppet.settings.each do |name, setting|
-            next if name.to_s == "name"
-            scope.setvar name.to_s, environment[name]
-        end
+    Puppet.settings.each do |name, setting|
+      next if name.to_s == "name"
+      scope.setvar name.to_s, environment[name]
     end
+  end
 
-    # Return an array of all of the unevaluated resources.  These will be definitions,
-    # which need to get evaluated into native resources.
-    def unevaluated_resources
-        ary = resources.reject { |resource| resource.builtin? or resource.evaluated?  }
+  # Return an array of all of the unevaluated resources.  These will be definitions,
+  # which need to get evaluated into native resources.
+  def unevaluated_resources
+    ary = resources.reject { |resource| resource.builtin? or resource.evaluated?  }
 
-        if ary.empty?
-            return nil
-        else
-            return ary
-        end
+    if ary.empty?
+      return nil
+    else
+      return ary
     end
+  end
 end