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

2 files changed, 124 insertions, 124 deletions

diff --git a/lib/puppet/dsl/resource_api.rb b/lib/puppet/dsl/resource_api.rb
index 3e56a5543..9aa1ea07a 100644
--- a/lib/puppet/dsl/resource_api.rb
+++ b/lib/puppet/dsl/resource_api.rb
@@ -4,117 +4,117 @@
 require 'puppet/resource/type_collection_helper'
 
 class Puppet::DSL::ResourceAPI
-    include Puppet::Resource::TypeCollectionHelper
+  include Puppet::Resource::TypeCollectionHelper
 
-    FUNCTION_MAP = {:acquire => :include}
+  FUNCTION_MAP = {:acquire => :include}
 
-    attr_reader :scope, :resource, :block
+  attr_reader :scope, :resource, :block
 
-    def environment
-        scope.environment
-    end
+  def environment
+    scope.environment
+  end
 
-    def evaluate
-        set_instance_variables
-        instance_eval(&block)
-    end
+  def evaluate
+    set_instance_variables
+    instance_eval(&block)
+  end
 
-    def initialize(resource, scope, block)
-        @scope = scope
-        @resource = resource
-        @block = block
-    end
+  def initialize(resource, scope, block)
+    @scope = scope
+    @resource = resource
+    @block = block
+  end
 
-    # Try to convert a missing method into a resource type or a function.
-    def method_missing(name, *args)
-        raise "MethodMissing loop when searching for #{name} with #{args.inspect}" if searching_for_method?
-        @searching_for_method = true
-        return create_resource(name, args[0], args[1]) if valid_type?(name)
+  # Try to convert a missing method into a resource type or a function.
+  def method_missing(name, *args)
+    raise "MethodMissing loop when searching for #{name} with #{args.inspect}" if searching_for_method?
+    @searching_for_method = true
+    return create_resource(name, args[0], args[1]) if valid_type?(name)
 
-        name = map_function(name)
+    name = map_function(name)
 
-        return call_function(name, args) if Puppet::Parser::Functions.function(name)
+    return call_function(name, args) if Puppet::Parser::Functions.function(name)
 
-        super
-    ensure
-        @searching_for_method = true
-    end
+    super
+  ensure
+    @searching_for_method = true
+  end
 
-    def set_instance_variables
-        resource.eachparam do |param|
-            instance_variable_set("@#{param.name}", param.value)
-        end
-        @title = resource.title
-        @name ||= resource.title
+  def set_instance_variables
+    resource.eachparam do |param|
+      instance_variable_set("@#{param.name}", param.value)
     end
-
-    def create_resource(type, names, arguments = nil)
-        names = [names] unless names.is_a?(Array)
-
-        arguments ||= {}
-        raise ArgumentError, "Resource arguments must be provided as a hash" unless arguments.is_a?(Hash)
-
-        names.collect do |name|
-            resource = Puppet::Parser::Resource.new(type, name, :scope => scope)
-            arguments.each do |param, value|
-                resource[param] = value
-            end
-
-            resource.exported = true if exporting?
-            resource.virtual = true if virtualizing?
-            scope.compiler.add_resource(scope, resource)
-            resource
-        end
+    @title = resource.title
+    @name ||= resource.title
+  end
+
+  def create_resource(type, names, arguments = nil)
+    names = [names] unless names.is_a?(Array)
+
+    arguments ||= {}
+    raise ArgumentError, "Resource arguments must be provided as a hash" unless arguments.is_a?(Hash)
+
+    names.collect do |name|
+      resource = Puppet::Parser::Resource.new(type, name, :scope => scope)
+      arguments.each do |param, value|
+        resource[param] = value
+      end
+
+      resource.exported = true if exporting?
+      resource.virtual = true if virtualizing?
+      scope.compiler.add_resource(scope, resource)
+      resource
     end
+  end
 
-    def call_function(name, args)
-        return false unless method = Puppet::Parser::Functions.function(name)
-        scope.send(method, *args)
-    end
-
-    def export(resources = nil, &block)
-        if resources
-            resources.each { |resource| resource.exported = true }
-            return resources
-        end
-        @exporting = true
-        instance_eval(&block)
-    ensure
-        @exporting = false
-    end
+  def call_function(name, args)
+    return false unless method = Puppet::Parser::Functions.function(name)
+    scope.send(method, *args)
+  end
 
-    def virtual(resources = nil, &block)
-        if resources
-            resources.each { |resource| resource.virtual = true }
-            return resources
-        end
-        @virtualizing = true
-        instance_eval(&block)
-    ensure
-        @virtualizing = false
+  def export(resources = nil, &block)
+    if resources
+      resources.each { |resource| resource.exported = true }
+      return resources
     end
-
-    def valid_type?(name)
-        return true if [:class, :node].include?(name)
-        return true if Puppet::Type.type(name)
-        return(known_resource_types.definition(name) ? true : false)
-    end
-
-    private
-
-    def exporting?
-        @exporting
-    end
-
-    def map_function(name)
-        FUNCTION_MAP[name] || name
-    end
-
-    def searching_for_method?
-        @searching_for_method
-    end
-
-    def virtualizing?
-        @virtualizing
+    @exporting = true
+    instance_eval(&block)
+  ensure
+    @exporting = false
+  end
+
+  def virtual(resources = nil, &block)
+    if resources
+      resources.each { |resource| resource.virtual = true }
+      return resources
     end
+    @virtualizing = true
+    instance_eval(&block)
+  ensure
+    @virtualizing = false
+  end
+
+  def valid_type?(name)
+    return true if [:class, :node].include?(name)
+    return true if Puppet::Type.type(name)
+    return(known_resource_types.definition(name) ? true : false)
+  end
+
+  private
+
+  def exporting?
+    @exporting
+  end
+
+  def map_function(name)
+    FUNCTION_MAP[name] || name
+  end
+
+  def searching_for_method?
+    @searching_for_method
+  end
+
+  def virtualizing?
+    @virtualizing
+  end
 end
diff --git a/lib/puppet/dsl/resource_type_api.rb b/lib/puppet/dsl/resource_type_api.rb
index ba489680d..487aab99d 100644
--- a/lib/puppet/dsl/resource_type_api.rb
+++ b/lib/puppet/dsl/resource_type_api.rb
@@ -1,40 +1,40 @@
 require 'puppet/resource/type'
 
 module Puppet::DSL::ResourceTypeAPI
-    def define(name, *args, &block)
-        result = mk_resource_type(:definition, name, Hash.new, block)
-        result.set_arguments(munge_type_arguments(args))
-        result
-    end
+  def define(name, *args, &block)
+    result = mk_resource_type(:definition, name, Hash.new, block)
+    result.set_arguments(munge_type_arguments(args))
+    result
+  end
 
-    def hostclass(name, options = {}, &block)
-        mk_resource_type(:hostclass, name, options, block)
-    end
+  def hostclass(name, options = {}, &block)
+    mk_resource_type(:hostclass, name, options, block)
+  end
 
-    def node(name, options = {}, &block)
-        mk_resource_type(:node, name, options, block)
-    end
+  def node(name, options = {}, &block)
+    mk_resource_type(:node, name, options, block)
+  end
 
-    private
+  private
 
-    def mk_resource_type(type, name, options, code)
-        klass = Puppet::Resource::Type.new(type, name, options)
+  def mk_resource_type(type, name, options, code)
+    klass = Puppet::Resource::Type.new(type, name, options)
 
-        klass.ruby_code = code if code
+    klass.ruby_code = code if code
 
-        Puppet::Node::Environment.new.known_resource_types.add klass
+    Puppet::Node::Environment.new.known_resource_types.add klass
 
-        klass
-    end
+    klass
+  end
 
-    def munge_type_arguments(args)
-        args.inject([]) do |result, item|
-            if item.is_a?(Hash)
-                item.each { |p, v| result << [p, v] }
-            else
-                result << item
-            end
-            result
-        end
+  def munge_type_arguments(args)
+    args.inject([]) do |result, item|
+      if item.is_a?(Hash)
+        item.each { |p, v| result << [p, v] }
+      else
+        result << item
+      end
+      result
     end
+  end
 end