Polish GroovyBeanDefinitionReader formatting

Consistent use of tabs and remove trailing whitespace.

Issue: SPR-7123

spring-beans-groovy/src/main/groovy/org/springframework/beans/factory/groovy/GroovyDynamicElementReader.groovy

@@ -45,53 +45,53 @@ class GroovyDynamicElementReader extends GroovyObjectSupport {
 	private boolean callAfterInvocation = true
 
 
-    public GroovyDynamicElementReader(String namespace, Map<String, String> namespaceMap,
-			  BeanDefinitionParserDelegate delegate, GroovyBeanDefinitionWrapper beanDefinition, boolean decorating) {
-        super();
+	public GroovyDynamicElementReader(String namespace, Map<String, String> namespaceMap,
+			BeanDefinitionParserDelegate delegate, GroovyBeanDefinitionWrapper beanDefinition, boolean decorating) {
+		super();
 		this.rootNamespace = namespace
-        this.xmlNamespaces = namespaceMap
-        this.delegate = delegate
+		this.xmlNamespaces = namespaceMap
+		this.delegate = delegate
 		this.beanDefinition = beanDefinition;
 		this.decorating = decorating;
-    }
+	}
 
 
-    @Override
-    public Object invokeMethod(String name, Object args) {
-        if (name.equals("doCall")) {
-            def callable = args[0]
-            callable.resolveStrategy = Closure.DELEGATE_FIRST
-            callable.delegate = this
-            def result = callable.call()
+	@Override
+	public Object invokeMethod(String name, Object args) {
+		if (name.equals("doCall")) {
+			def callable = args[0]
+			callable.resolveStrategy = Closure.DELEGATE_FIRST
+			callable.delegate = this
+			def result = callable.call()
 
 			if (this.callAfterInvocation) {
 				afterInvocation()
 				this.callAfterInvocation = false
 			}
-            return result
-        }
+			return result
+		}
 
-        else {
-            StreamingMarkupBuilder builder = new StreamingMarkupBuilder();
+		else {
+			StreamingMarkupBuilder builder = new StreamingMarkupBuilder();
 			def myNamespace = this.rootNamespace
-            def myNamespaces = this.xmlNamespaces
-
-            def callable = {
-                for (namespace in myNamespaces) {
-                    mkp.declareNamespace([(namespace.key):namespace.value])
-                }
-                if (args && (args[-1] instanceof Closure)) {
-                    args[-1].resolveStrategy = Closure.DELEGATE_FIRST
-                    args[-1].delegate = builder
-                }
-                delegate."$myNamespace"."$name"(*args)
-            }
-
-            callable.resolveStrategy = Closure.DELEGATE_FIRST
-            callable.delegate = builder
-            def writable = builder.bind(callable)
-            def sw = new StringWriter()
-            writable.writeTo(sw)
+			def myNamespaces = this.xmlNamespaces
+
+			def callable = {
+				for (namespace in myNamespaces) {
+					mkp.declareNamespace([(namespace.key):namespace.value])
+				}
+				if (args && (args[-1] instanceof Closure)) {
+					args[-1].resolveStrategy = Closure.DELEGATE_FIRST
+					args[-1].delegate = builder
+				}
+				delegate."$myNamespace"."$name"(*args)
+			}
+
+			callable.resolveStrategy = Closure.DELEGATE_FIRST
+			callable.delegate = builder
+			def writable = builder.bind(callable)
+			def sw = new StringWriter()
+			writable.writeTo(sw)
 
 			Element element = this.delegate.readerContext.readDocumentFromString(sw.toString()).documentElement
 			this.delegate.initDefaults(element)
@@ -106,13 +106,13 @@ class GroovyDynamicElementReader extends GroovyObjectSupport {
 					this.beanDefinition.setBeanDefinition(beanDefinition)
 				}
 			}
-            if (this.callAfterInvocation) {
-                afterInvocation()
+			if (this.callAfterInvocation) {
+				afterInvocation()
 				this.callAfterInvocation = false
-            }
-            return element
-        }
-    }
+			}
+			return element
+		}
+	}
 
 	/**
 	 * Hook that subclass or anonymous classes can overwrite to implement custom behavior

spring-beans-groovy/src/main/java/org/springframework/beans/factory/groovy/GroovyBeanDefinitionReader.java

@@ -132,7 +132,7 @@ public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader imp
 
 	private final Map <String, String> namespaces = new HashMap<String, String>();
 
-    private final Map<String, DeferredProperty> deferredProperties = new HashMap<String, DeferredProperty>();
+	private final Map<String, DeferredProperty> deferredProperties = new HashMap<String, DeferredProperty>();
 
 
 	/**
@@ -140,11 +140,11 @@ public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader imp
 	 * @param registry the BeanFactory to load bean definitions into,
 	 * in the form of a BeanDefinitionRegistry
 	 */
-    public GroovyBeanDefinitionReader(BeanDefinitionRegistry registry) {
-        super(registry);
-        this.xmlBeanDefinitionReader = new XmlBeanDefinitionReader(registry);
+	public GroovyBeanDefinitionReader(BeanDefinitionRegistry registry) {
+		super(registry);
+		this.xmlBeanDefinitionReader = new XmlBeanDefinitionReader(registry);
 		this.xmlBeanDefinitionReader.setValidating(false);
-    }
+	}
 
 	/**
 	 * Create new GroovyBeanDefinitionReader based on the given XmlBeanDefinitionReader,
@@ -293,26 +293,26 @@ public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader imp
 	}
 
 	/**
-     * Defines an Spring namespace definition to use.
-     * @param definition the namespace definition
-     */
-    public void xmlns(Map<String, String> definition) {
-        if (!definition.isEmpty()) {
-            for (Map.Entry<String,String> entry : definition.entrySet()) {
-                String namespace = entry.getKey();
-                String uri = entry.getValue();
-                if (uri == null) {
-                    throw new IllegalArgumentException("Namespace definition must supply a non-null URI");
-                }
-                NamespaceHandler namespaceHandler = this.xmlBeanDefinitionReader.getNamespaceHandlerResolver().resolve(uri);
-                if (namespaceHandler == null) {
-                    throw new BeanDefinitionParsingException(new Problem("No namespace handler found for URI: " + uri,
+	 * Defines an Spring namespace definition to use.
+	 * @param definition the namespace definition
+	 */
+	public void xmlns(Map<String, String> definition) {
+		if (!definition.isEmpty()) {
+			for (Map.Entry<String,String> entry : definition.entrySet()) {
+				String namespace = entry.getKey();
+				String uri = entry.getValue();
+				if (uri == null) {
+					throw new IllegalArgumentException("Namespace definition must supply a non-null URI");
+				}
+				NamespaceHandler namespaceHandler = this.xmlBeanDefinitionReader.getNamespaceHandlerResolver().resolve(uri);
+				if (namespaceHandler == null) {
+					throw new BeanDefinitionParsingException(new Problem("No namespace handler found for URI: " + uri,
 							new Location(new DescriptiveResource(("Groovy")))));
-                }
-                this.namespaces.put(namespace, uri);
-            }
-        }
-    }
+				}
+				this.namespaces.put(namespace, uri);
+			}
+		}
+	}
 
 	/**
 	 * Imports Spring bean definitions from either XML or Groovy sources into the current bean builder instance.
@@ -335,15 +335,15 @@ public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader imp
 
 	// INTERNAL HANDLING OF GROOVY CLOSURES AND PROPERTIES
 
-    /**
+	/**
 	 * This method overrides method invocation to create beans for each method name that
 	 * takes a class argument
 	 */
 	public Object invokeMethod(String name, Object arg) {
-        Object[] args = (Object[])arg;
-        if ("beans".equals(name) && args.length == 1 && args[0] instanceof Closure) {
-            return beans((Closure) args[0]);
-        }
+		Object[] args = (Object[])arg;
+		if ("beans".equals(name) && args.length == 1 && args[0] instanceof Closure) {
+			return beans((Closure) args[0]);
+		}
 		else if ("ref".equals(name)) {
 			String refName;
 			if (args[0] == null)
@@ -363,13 +363,13 @@ public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader imp
 			}
 			return new RuntimeBeanReference(refName, parentRef);
 		}
-        else if (this.namespaces.containsKey(name) && args.length > 0 && (args[0] instanceof Closure)) {
-            GroovyDynamicElementReader reader = createDynamicElementReader(name);
-            reader.invokeMethod("doCall", args);
-        }
+		else if (this.namespaces.containsKey(name) && args.length > 0 && (args[0] instanceof Closure)) {
+			GroovyDynamicElementReader reader = createDynamicElementReader(name);
+			reader.invokeMethod("doCall", args);
+		}
 		else if (args.length > 0 && args[0] instanceof Closure) {
-            // abstract bean definition
-            return invokeBeanDefiningMethod(name, args);
+			// abstract bean definition
+			return invokeBeanDefiningMethod(name, args);
 		}
 		else if (args.length > 0 && (args[0] instanceof Class || args[0] instanceof RuntimeBeanReference || args[0] instanceof Map)) {
 			return invokeBeanDefiningMethod(name, args);
@@ -377,11 +377,11 @@ public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader imp
 		else if (args.length > 1 && args[args.length -1] instanceof Closure) {
 			return invokeBeanDefiningMethod(name, args);
 		}
-        MetaClass mc = DefaultGroovyMethods.getMetaClass(getRegistry());
-        if (!mc.respondsTo(getRegistry(), name, args).isEmpty()){
-            return mc.invokeMethod(getRegistry(), name, args);
-        }
-        return this;
+		MetaClass mc = DefaultGroovyMethods.getMetaClass(getRegistry());
+		if (!mc.respondsTo(getRegistry(), name, args).isEmpty()){
+			return mc.invokeMethod(getRegistry(), name, args);
+		}
+		return this;
 	}
 
 	private boolean addDeferredProperty(String property, Object newValue) {
@@ -431,13 +431,13 @@ public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader imp
 	 * @return the bean definition wrapper
 	 */
 	private GroovyBeanDefinitionWrapper invokeBeanDefiningMethod(String beanName, Object[] args) {
-        boolean hasClosureArgument = args[args.length - 1] instanceof Closure;
-        if (args[0] instanceof Class) {
-            Class beanClass = (args[0] instanceof Class ? (Class) args[0] : args[0].getClass());
-            if (args.length >= 1) {
-                if (hasClosureArgument) {
+		boolean hasClosureArgument = args[args.length - 1] instanceof Closure;
+		if (args[0] instanceof Class) {
+			Class beanClass = (args[0] instanceof Class ? (Class) args[0] : args[0].getClass());
+			if (args.length >= 1) {
+				if (hasClosureArgument) {
 					if (args.length-1 != 1) {
-                        this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(
+						this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(
 								beanName, beanClass, resolveConstructorArguments(args,1,args.length-1));
 					}
 					else {
@@ -456,77 +456,77 @@ public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader imp
 			this.currentBeanDefinition.getBeanDefinition().setFactoryBeanName(((RuntimeBeanReference) args[0]).getBeanName());
 		}
 		else if (args[0] instanceof Map) {
-            // named constructor arguments
-            if (args.length > 1 && args[1] instanceof Class) {
-                List constructorArgs = resolveConstructorArguments(args, 2, hasClosureArgument ? args.length-1 :  args.length);
-                this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName, (Class)args[1], constructorArgs);
-                Map namedArgs = (Map)args[0];
-                for (Object o : namedArgs.keySet()) {
-                    String propName = (String) o;
-                    setProperty(propName, namedArgs.get(propName));
-                }
-            }
-            // factory method syntax
-            else {
+			// named constructor arguments
+			if (args.length > 1 && args[1] instanceof Class) {
+				List constructorArgs = resolveConstructorArguments(args, 2, hasClosureArgument ? args.length-1 :  args.length);
+				this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName, (Class)args[1], constructorArgs);
+				Map namedArgs = (Map)args[0];
+				for (Object o : namedArgs.keySet()) {
+					String propName = (String) o;
+					setProperty(propName, namedArgs.get(propName));
+				}
+			}
+			// factory method syntax
+			else {
 				this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName);
-                //First arg is the map containing factoryBean : factoryMethod
-                Map.Entry factoryBeanEntry = (Map.Entry) ((Map) args[0]).entrySet().iterator().next();
-                // If we have a closure body, that will be the last argument.
-                // In between are the constructor args
-                int constructorArgsTest = hasClosureArgument?2:1;
-                // If we have more than this number of args, we have constructor args
-                if (args.length > constructorArgsTest){
-                    // factory-method requires args
-                    int endOfConstructArgs = (hasClosureArgument? args.length - 1 : args.length);
+				//First arg is the map containing factoryBean : factoryMethod
+				Map.Entry factoryBeanEntry = (Map.Entry) ((Map) args[0]).entrySet().iterator().next();
+				// If we have a closure body, that will be the last argument.
+				// In between are the constructor args
+				int constructorArgsTest = hasClosureArgument?2:1;
+				// If we have more than this number of args, we have constructor args
+				if (args.length > constructorArgsTest){
+					// factory-method requires args
+					int endOfConstructArgs = (hasClosureArgument? args.length - 1 : args.length);
 					this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName, null,
 							resolveConstructorArguments(args, 1, endOfConstructArgs));
-                }
+				}
 				else {
 					this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName);
-                }
+				}
 				this.currentBeanDefinition.getBeanDefinition().setFactoryBeanName(factoryBeanEntry.getKey().toString());
 				this.currentBeanDefinition.getBeanDefinition().setFactoryMethodName(factoryBeanEntry.getValue().toString());
-            }
+			}
 
-        }
-        else if (args[0] instanceof Closure) {
+		}
+		else if (args[0] instanceof Closure) {
 			this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName);
 			this.currentBeanDefinition.getBeanDefinition().setAbstract(true);
-        }
-        else {
-            List constructorArgs = resolveConstructorArguments(args, 0, hasClosureArgument ? args.length-1 : args.length);
-            currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName, null, constructorArgs);
-        }
+		}
+		else {
+			List constructorArgs = resolveConstructorArguments(args, 0, hasClosureArgument ? args.length-1 : args.length);
+			currentBeanDefinition = new GroovyBeanDefinitionWrapper(beanName, null, constructorArgs);
+		}
 
-        if (hasClosureArgument) {
+		if (hasClosureArgument) {
 			Closure callable = (Closure)args[args.length-1];
 			callable.setDelegate(this);
-            callable.setResolveStrategy(Closure.DELEGATE_FIRST);
-            callable.call(new Object[]{currentBeanDefinition});
+			callable.setResolveStrategy(Closure.DELEGATE_FIRST);
+			callable.call(new Object[]{currentBeanDefinition});
 		}
 
-        GroovyBeanDefinitionWrapper beanDefinition = currentBeanDefinition;
+		GroovyBeanDefinitionWrapper beanDefinition = currentBeanDefinition;
 		this.currentBeanDefinition = null;
 		beanDefinition.getBeanDefinition().setAttribute(GroovyBeanDefinitionWrapper.class.getName(), beanDefinition);
 		getRegistry().registerBeanDefinition(beanName, beanDefinition.getBeanDefinition());
 		return beanDefinition;
 	}
 
-    protected List<Object> resolveConstructorArguments(Object[] args, int start, int end) {
-        Object[] constructorArgs = Arrays.copyOfRange(args, start, end);
-        for (int i = 0; i < constructorArgs.length; i++) {
+	protected List<Object> resolveConstructorArguments(Object[] args, int start, int end) {
+		Object[] constructorArgs = Arrays.copyOfRange(args, start, end);
+		for (int i = 0; i < constructorArgs.length; i++) {
 			if (constructorArgs[i] instanceof GString) {
 				constructorArgs[i] = constructorArgs[i].toString();
 			}
-        	else if (constructorArgs[i] instanceof List) {
-        		constructorArgs[i] = manageListIfNecessary((List) constructorArgs[i]);
-        	}
+			else if (constructorArgs[i] instanceof List) {
+				constructorArgs[i] = manageListIfNecessary((List) constructorArgs[i]);
+			}
 			else if (constructorArgs[i] instanceof Map){
-        		constructorArgs[i] = manageMapIfNecessary((Map) constructorArgs[i]);
-        	}
-        }
-        return Arrays.asList(constructorArgs);
-    }
+				constructorArgs[i] = manageMapIfNecessary((Map) constructorArgs[i]);
+			}
+		}
+		return Arrays.asList(constructorArgs);
+	}
 
 	/**
 	 * Checks whether there are any {@link RuntimeBeanReference} inside the Map
@@ -578,39 +578,39 @@ public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader imp
 	 */
 	public void setProperty(String name, Object value) {
 		if (this.currentBeanDefinition != null) {
-            applyPropertyToBeanDefinition(name, value);
+			applyPropertyToBeanDefinition(name, value);
 		}
 	}
 
-    protected void applyPropertyToBeanDefinition(String name, Object value) {
-        if (value instanceof GString) {
+	protected void applyPropertyToBeanDefinition(String name, Object value) {
+		if (value instanceof GString) {
 			value = value.toString();
 		}
-        if (addDeferredProperty(name, value)) {
-            return;
-        }
-        else if (value instanceof Closure) {
-            GroovyBeanDefinitionWrapper current = this.currentBeanDefinition;
-            try {
-                Closure callable = (Closure) value;
-                Class parameterType = callable.getParameterTypes()[0];
-                if (parameterType.equals(Object.class)) {
+		if (addDeferredProperty(name, value)) {
+			return;
+		}
+		else if (value instanceof Closure) {
+			GroovyBeanDefinitionWrapper current = this.currentBeanDefinition;
+			try {
+				Closure callable = (Closure) value;
+				Class parameterType = callable.getParameterTypes()[0];
+				if (parameterType.equals(Object.class)) {
 					this.currentBeanDefinition = new GroovyBeanDefinitionWrapper("");
-                    callable.call(this.currentBeanDefinition);
-                }
-                else {
+					callable.call(this.currentBeanDefinition);
+				}
+				else {
 					this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(null, parameterType);
-                    callable.call((Object) null);
-                }
+					callable.call((Object) null);
+				}
 
-                value = this.currentBeanDefinition.getBeanDefinition();
-            }
-            finally {
+				value = this.currentBeanDefinition.getBeanDefinition();
+			}
+			finally {
 				this.currentBeanDefinition = current;
-            }
-        }
+			}
+		}
 		this.currentBeanDefinition.addProperty(name, value);
-    }
+	}
 
 	/**
 	 * This method overrides property retrieval in the scope of the GroovyBeanDefinitionReader to either:
@@ -624,9 +624,9 @@ public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader imp
 			return binding.getVariable(name);
 		}
 		else {
-            if (this.namespaces.containsKey(name)) {
-                return createDynamicElementReader(name);
-            }
+			if (this.namespaces.containsKey(name)) {
+				return createDynamicElementReader(name);
+			}
 			if (getRegistry().containsBeanDefinition(name)) {
 				GroovyBeanDefinitionWrapper beanDefinition = (GroovyBeanDefinitionWrapper)
 						getRegistry().getBeanDefinition(name).getAttribute(GroovyBeanDefinitionWrapper.class.getName());
@@ -660,22 +660,22 @@ public class GroovyBeanDefinitionReader extends AbstractBeanDefinitionReader imp
 		}
 	}
 
-    private GroovyDynamicElementReader createDynamicElementReader(String namespace) {
+	private GroovyDynamicElementReader createDynamicElementReader(String namespace) {
 		XmlReaderContext readerContext = this.xmlBeanDefinitionReader.createReaderContext(new DescriptiveResource("Groovy"));
 		BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext, getEnvironment());
 		boolean decorating = (this.currentBeanDefinition != null);
 		if (!decorating) {
 			this.currentBeanDefinition = new GroovyBeanDefinitionWrapper(namespace);
 		}
-        return new GroovyDynamicElementReader(namespace, this.namespaces, delegate, this.currentBeanDefinition, decorating) {
-            @Override
-            protected void afterInvocation() {
-                if (!this.decorating) {
-                    currentBeanDefinition = null;
-                }
-            }
-        };
-    }
+		return new GroovyDynamicElementReader(namespace, this.namespaces, delegate, this.currentBeanDefinition, decorating) {
+			@Override
+			protected void afterInvocation() {
+				if (!this.decorating) {
+					currentBeanDefinition = null;
+				}
+			}
+		};
+	}
 
 
 	/**

spring-beans-groovy/src/main/java/org/springframework/beans/factory/groovy/GroovyBeanDefinitionWrapper.java

@@ -50,7 +50,7 @@ class GroovyBeanDefinitionWrapper extends GroovyObjectSupport {
 	private static final String FACTORY_METHOD = "factoryMethod";
 	private static final String INIT_METHOD = "initMethod";
 	private static final String DESTROY_METHOD = "destroyMethod";
-    private static final String SINGLETON = "singleton";
+	private static final String SINGLETON = "singleton";
 
 	private static final List<String> dynamicProperties = new ArrayList<String>(8);
 
@@ -173,69 +173,69 @@ class GroovyBeanDefinitionWrapper extends GroovyObjectSupport {
 	}
 
 	public void setProperty(String property, Object newValue) {
-        if (PARENT.equals(property)) {
-            setParent(newValue);
-        }
-        else {
-            AbstractBeanDefinition bd = getBeanDefinition();
-            if (AUTOWIRE.equals(property)) {
-                if ("byName".equals(newValue)) {
-                    bd.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_NAME);
-                }
-                else if ("byType".equals(newValue)) {
-                    bd.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE);
-                }
+		if (PARENT.equals(property)) {
+			setParent(newValue);
+		}
+		else {
+			AbstractBeanDefinition bd = getBeanDefinition();
+			if (AUTOWIRE.equals(property)) {
+				if ("byName".equals(newValue)) {
+					bd.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_NAME);
+				}
+				else if ("byType".equals(newValue)) {
+					bd.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE);
+				}
 				else if ("constructor".equals(newValue)) {
 					bd.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
 				}
-                else if (Boolean.TRUE.equals(newValue)) {
-                    bd.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_NAME);
-                }
-            }
-            // constructorArgs
-            else if (CONSTRUCTOR_ARGS.equals(property) && newValue instanceof List) {
-                ConstructorArgumentValues cav = new ConstructorArgumentValues();
-                List args = (List) newValue;
+				else if (Boolean.TRUE.equals(newValue)) {
+					bd.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_NAME);
+				}
+			}
+			// constructorArgs
+			else if (CONSTRUCTOR_ARGS.equals(property) && newValue instanceof List) {
+				ConstructorArgumentValues cav = new ConstructorArgumentValues();
+				List args = (List) newValue;
 				for (Object arg : args) {
 					cav.addGenericArgumentValue(arg);
 				}
-                bd.setConstructorArgumentValues(cav);
-            }
-            // factoryBean
-            else if (FACTORY_BEAN.equals(property)) {
-                if (newValue != null) {
-                    bd.setFactoryBeanName(newValue.toString());
+				bd.setConstructorArgumentValues(cav);
+			}
+			// factoryBean
+			else if (FACTORY_BEAN.equals(property)) {
+				if (newValue != null) {
+					bd.setFactoryBeanName(newValue.toString());
 				}
-            }
-            // factoryMethod
-            else if (FACTORY_METHOD.equals(property)) {
-                if (newValue != null)
-                    bd.setFactoryMethodName(newValue.toString());
-            }
-            // initMethod
-            else if (INIT_METHOD.equals(property)) {
-                if (newValue != null) {
-                    bd.setInitMethodName(newValue.toString());
+			}
+			// factoryMethod
+			else if (FACTORY_METHOD.equals(property)) {
+				if (newValue != null)
+					bd.setFactoryMethodName(newValue.toString());
+			}
+			// initMethod
+			else if (INIT_METHOD.equals(property)) {
+				if (newValue != null) {
+					bd.setInitMethodName(newValue.toString());
 				}
-            }
+			}
 			// destroyMethod
 			else if (DESTROY_METHOD.equals(property)) {
 				if (newValue != null) {
 					bd.setDestroyMethodName(newValue.toString());
 				}
 			}
-            // singleton property
-            else if (SINGLETON.equals(property)) {
-                bd.setScope(Boolean.TRUE.equals(newValue) ?
+			// singleton property
+			else if (SINGLETON.equals(property)) {
+				bd.setScope(Boolean.TRUE.equals(newValue) ?
 						BeanDefinition.SCOPE_SINGLETON : BeanDefinition.SCOPE_PROTOTYPE);
-            }
-            else if (this.definitionWrapper.isWritableProperty(property)) {
+			}
+			else if (this.definitionWrapper.isWritableProperty(property)) {
 				this.definitionWrapper.setPropertyValue(property, newValue);
-            }
-            else {
-                super.setProperty(property, newValue);
-            }
-        }
+			}
+			else {
+				super.setProperty(property, newValue);
+			}
+		}
 	}
 
 }

spring-context/src/test/groovy/org/springframework/context/groovy/GroovyApplicationContextDynamicBeanPropertyTests.groovy

@@ -24,26 +24,26 @@ import org.springframework.context.support.GenericGroovyApplicationContext
  */
 class GroovyApplicationContextDynamicBeanPropertyTests extends GroovyTestCase {
 
-    void testAccessDynamicBeanProperties() {
-        def ctx = new GenericGroovyApplicationContext();
+	void testAccessDynamicBeanProperties() {
+		def ctx = new GenericGroovyApplicationContext();
 		ctx.reader.loadBeanDefinitions("org/springframework/context/groovy/applicationContext.groovy");
 		ctx.refresh()
 
-        def framework = ctx.framework
-        assertNotNull 'could not find framework bean', framework
-        assertEquals 'Grails', framework
-    }
+		def framework = ctx.framework
+		assertNotNull 'could not find framework bean', framework
+		assertEquals 'Grails', framework
+	}
 
-    void testAccessingNonExistentBeanViaDynamicProperty() {
+	void testAccessingNonExistentBeanViaDynamicProperty() {
 		def ctx = new GenericGroovyApplicationContext();
 		ctx.reader.loadBeanDefinitions("org/springframework/context/groovy/applicationContext.groovy");
 		ctx.refresh()
 
-        def err = shouldFail(NoSuchBeanDefinitionException) {
-            ctx.someNonExistentBean
-        }
+		def err = shouldFail(NoSuchBeanDefinitionException) {
+			ctx.someNonExistentBean
+		}
 
-        assertEquals "No bean named 'someNonExistentBean' is defined", err
-    }
+		assertEquals "No bean named 'someNonExistentBean' is defined", err
+	}
 
 }

spring-context/src/test/groovy/org/springframework/context/groovy/GroovyBeanDefinitionReaderTests.groovy

@@ -57,247 +57,247 @@ class GroovyBeanDefinitionReaderTests extends GroovyTestCase {
 		assertEquals "hello", foo
 	}
 
-    void testSingletonPropertyOnBeanDefinition() {
+	void testSingletonPropertyOnBeanDefinition() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
-        reader.beans {
-            singletonBean(Bean1) { bean ->
-                bean.singleton = true
-            }
-            nonSingletonBean(Bean1) { bean ->
-                bean.singleton = false
-            }
-            unSpecifiedScopeBean(Bean1)
-        }
-        appCtx.refresh()
-
-        assertTrue 'singletonBean should have been a singleton', appCtx.isSingleton('singletonBean')
-        assertFalse 'nonSingletonBean should not have been a singleton', appCtx.isSingleton('nonSingletonBean')
-        assertTrue 'unSpecifiedScopeBean should not have been a singleton', appCtx.isSingleton('unSpecifiedScopeBean')
-    }
-
-    void testInheritPropertiesFromAbstractBean() {
+		reader.beans {
+			singletonBean(Bean1) { bean ->
+				bean.singleton = true
+			}
+			nonSingletonBean(Bean1) { bean ->
+				bean.singleton = false
+			}
+			unSpecifiedScopeBean(Bean1)
+		}
+		appCtx.refresh()
+
+		assertTrue 'singletonBean should have been a singleton', appCtx.isSingleton('singletonBean')
+		assertFalse 'nonSingletonBean should not have been a singleton', appCtx.isSingleton('nonSingletonBean')
+		assertTrue 'unSpecifiedScopeBean should not have been a singleton', appCtx.isSingleton('unSpecifiedScopeBean')
+	}
+
+	void testInheritPropertiesFromAbstractBean() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
 
-        reader.beans {
-            myB(Bean1){
-                person = "wombat"
-            }
-
-            myAbstractA(Bean2){ bean ->
-                bean.'abstract' = true
-                age = 10
-                bean1 = myB
-            }
-            myConcreteB {  
-                it.parent = myAbstractA
-            }
-        }
-
-        appCtx.refresh()
-
-        def bean = appCtx.getBean("myConcreteB")
-        assertEquals 10, bean.age
-        assertNotNull bean.bean1
-    }
-
-    void testContextComponentScanSpringTag() {
+		reader.beans {
+			myB(Bean1){
+				person = "wombat"
+			}
+
+			myAbstractA(Bean2){ bean ->
+				bean.'abstract' = true
+				age = 10
+				bean1 = myB
+			}
+			myConcreteB {
+				it.parent = myAbstractA
+			}
+		}
+
+		appCtx.refresh()
+
+		def bean = appCtx.getBean("myConcreteB")
+		assertEquals 10, bean.age
+		assertNotNull bean.bean1
+	}
+
+	void testContextComponentScanSpringTag() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
 
-        reader.beans {
-            xmlns context:"http://www.springframework.org/schema/context"
+		reader.beans {
+			xmlns context:"http://www.springframework.org/schema/context"
 
-            context.'component-scan'( 'base-package' :" org.springframework.context.groovy" )
-        }
+			context.'component-scan'( 'base-package' :" org.springframework.context.groovy" )
+		}
 
-        appCtx.refresh()
+		appCtx.refresh()
 
-        def p = appCtx.getBean("person")
-        assertTrue(p instanceof AdvisedPerson)
-        assertNotNull p
-    }
+		def p = appCtx.getBean("person")
+		assertTrue(p instanceof AdvisedPerson)
+		assertNotNull p
+	}
 
-    void testUseSpringNamespaceAsMethod() {
+	void testUseSpringNamespaceAsMethod() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
 
-        reader.beans {
-            xmlns aop:"http://www.springframework.org/schema/aop"
-
-            fred(AdvisedPerson) {
-                name = "Fred"
-                age = 45
-            }
-            birthdayCardSenderAspect(BirthdayCardSender)
+		reader.beans {
+			xmlns aop:"http://www.springframework.org/schema/aop"
 
-            aop {
-                config("proxy-target-class":true) {
-                    aspect( id:"sendBirthdayCard",ref:"birthdayCardSenderAspect" ) {
-                        after method:"onBirthday", pointcut: "execution(void org.springframework.context.groovy.AdvisedPerson.birthday()) and this(person)"
-                    }
-                }
-            }
-        }
+			fred(AdvisedPerson) {
+				name = "Fred"
+				age = 45
+			}
+			birthdayCardSenderAspect(BirthdayCardSender)
+
+			aop {
+				config("proxy-target-class":true) {
+					aspect( id:"sendBirthdayCard",ref:"birthdayCardSenderAspect" ) {
+						after method:"onBirthday", pointcut: "execution(void org.springframework.context.groovy.AdvisedPerson.birthday()) and this(person)"
+					}
+				}
+			}
+		}
 
-        appCtx.refresh()
+		appCtx.refresh()
 
-        def fred = appCtx.getBean("fred")
-        assertTrue (fred instanceof SpringProxy)
-        fred.birthday()
+		def fred = appCtx.getBean("fred")
+		assertTrue (fred instanceof SpringProxy)
+		fred.birthday()
 
-        BirthdayCardSender birthDaySender = appCtx.getBean("birthdayCardSenderAspect")
+		BirthdayCardSender birthDaySender = appCtx.getBean("birthdayCardSenderAspect")
 
-        assertEquals 1, birthDaySender.peopleSentCards.size()
-        assertEquals "Fred", birthDaySender.peopleSentCards[0].name
-    }
+		assertEquals 1, birthDaySender.peopleSentCards.size()
+		assertEquals "Fred", birthDaySender.peopleSentCards[0].name
+	}
 
-    void testUseTwoSpringNamespaces() {
+	void testUseTwoSpringNamespaces() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
-        TestScope scope = new TestScope()
-        appCtx.getBeanFactory().registerScope("test", scope)
+		TestScope scope = new TestScope()
+		appCtx.getBeanFactory().registerScope("test", scope)
 
-        reader.beans {
-            xmlns aop:"http://www.springframework.org/schema/aop"
-            xmlns util:"http://www.springframework.org/schema/util"
-            scopedList(ArrayList) { bean ->
-                bean.scope = "test"
-                aop.'scoped-proxy'()
-            }
-            util.list(id: 'foo') {
-                value 'one'
-                value 'two'
-            }
+		reader.beans {
+			xmlns aop:"http://www.springframework.org/schema/aop"
+			xmlns util:"http://www.springframework.org/schema/util"
+			scopedList(ArrayList) { bean ->
+				bean.scope = "test"
+				aop.'scoped-proxy'()
+			}
+			util.list(id: 'foo') {
+				value 'one'
+				value 'two'
+			}
 		}
-        appCtx.refresh()
+		appCtx.refresh()
 
-        assert ['one', 'two'] == appCtx.getBean("foo")
+		assert ['one', 'two'] == appCtx.getBean("foo")
 
-        assertNotNull appCtx.getBean("scopedList")
-        assertNotNull appCtx.getBean("scopedList").size()
-        assertNotNull appCtx.getBean("scopedList").size()
+		assertNotNull appCtx.getBean("scopedList")
+		assertNotNull appCtx.getBean("scopedList").size()
+		assertNotNull appCtx.getBean("scopedList").size()
 
-        // should only be true because bean not initialized until proxy called
-        assertEquals 2, scope.instanceCount
+		// should only be true because bean not initialized until proxy called
+		assertEquals 2, scope.instanceCount
 
 		appCtx = new GenericApplicationContext()
 		reader = new GroovyBeanDefinitionReader(appCtx)
-        appCtx.getBeanFactory().registerScope("test", scope)
-
-        reader.beans {
-            xmlns aop:"http://www.springframework.org/schema/aop",
-                  util:"http://www.springframework.org/schema/util"
-            scopedList(ArrayList) { bean ->
-                bean.scope = "test"
-                aop.'scoped-proxy'()
-            }
-            util.list(id: 'foo') {
-                value 'one'
-                value 'two'
-            }
-        }
-        appCtx.refresh()
-        
-        assert ['one', 'two'] == appCtx.getBean("foo")
-
-        assertNotNull appCtx.getBean("scopedList")
-        assertNotNull appCtx.getBean("scopedList").size()
-        assertNotNull appCtx.getBean("scopedList").size()
-
-        // should only be true because bean not initialized until proxy called
-        assertEquals 4, scope.instanceCount
-    }
-
-    void testSpringAopSupport() {
+		appCtx.getBeanFactory().registerScope("test", scope)
+
+		reader.beans {
+			xmlns aop:"http://www.springframework.org/schema/aop",
+				  util:"http://www.springframework.org/schema/util"
+			scopedList(ArrayList) { bean ->
+				bean.scope = "test"
+				aop.'scoped-proxy'()
+			}
+			util.list(id: 'foo') {
+				value 'one'
+				value 'two'
+			}
+		}
+		appCtx.refresh()
+
+		assert ['one', 'two'] == appCtx.getBean("foo")
+
+		assertNotNull appCtx.getBean("scopedList")
+		assertNotNull appCtx.getBean("scopedList").size()
+		assertNotNull appCtx.getBean("scopedList").size()
+
+		// should only be true because bean not initialized until proxy called
+		assertEquals 4, scope.instanceCount
+	}
+
+	void testSpringAopSupport() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
 
-        reader.beans {
-            xmlns aop:"http://www.springframework.org/schema/aop"
+		reader.beans {
+			xmlns aop:"http://www.springframework.org/schema/aop"
 
-            fred(AdvisedPerson) {
-                name = "Fred"
-                age = 45
-            }
-            birthdayCardSenderAspect(BirthdayCardSender)
+			fred(AdvisedPerson) {
+				name = "Fred"
+				age = 45
+			}
+			birthdayCardSenderAspect(BirthdayCardSender)
 
-            aop.config("proxy-target-class":true) {
-                aspect( id:"sendBirthdayCard",ref:"birthdayCardSenderAspect" ) {
-                    after method:"onBirthday", pointcut: "execution(void org.springframework.context.groovy.AdvisedPerson.birthday()) and this(person)"
-                }                
-            }
-        }
+			aop.config("proxy-target-class":true) {
+				aspect( id:"sendBirthdayCard",ref:"birthdayCardSenderAspect" ) {
+					after method:"onBirthday", pointcut: "execution(void org.springframework.context.groovy.AdvisedPerson.birthday()) and this(person)"
+				}
+			}
+		}
 
-        appCtx.refresh()
+		appCtx.refresh()
 
-        def fred = appCtx.getBean("fred")
-        assertTrue (fred instanceof SpringProxy)
-        fred.birthday()
+		def fred = appCtx.getBean("fred")
+		assertTrue (fred instanceof SpringProxy)
+		fred.birthday()
 
-        BirthdayCardSender birthDaySender = appCtx.getBean("birthdayCardSenderAspect")
+		BirthdayCardSender birthDaySender = appCtx.getBean("birthdayCardSenderAspect")
 
-        assertEquals 1, birthDaySender.peopleSentCards.size()
-        assertEquals "Fred", birthDaySender.peopleSentCards[0].name
-    }
+		assertEquals 1, birthDaySender.peopleSentCards.size()
+		assertEquals "Fred", birthDaySender.peopleSentCards[0].name
+	}
 
-    void testSpringScopedProxyBean() {
+	void testSpringScopedProxyBean() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
 
-        TestScope scope = new TestScope()
-        appCtx.getBeanFactory().registerScope("test", scope)
-        reader.beans {
-            xmlns aop:"http://www.springframework.org/schema/aop"
-            scopedList(ArrayList) { bean ->
-                bean.scope = "test"
-                aop.'scoped-proxy'()
-            }
-        }
-        appCtx.refresh()
-
-        assertNotNull appCtx.getBean("scopedList")
-        assertNotNull appCtx.getBean("scopedList").size()
-        assertNotNull appCtx.getBean("scopedList").size()
-
-        // should only be true because bean not initialized until proxy called
-        assertEquals 2, scope.instanceCount
-    }
-
-    void testSpringNamespaceBean() {
+		TestScope scope = new TestScope()
+		appCtx.getBeanFactory().registerScope("test", scope)
+		reader.beans {
+			xmlns aop:"http://www.springframework.org/schema/aop"
+			scopedList(ArrayList) { bean ->
+				bean.scope = "test"
+				aop.'scoped-proxy'()
+			}
+		}
+		appCtx.refresh()
+
+		assertNotNull appCtx.getBean("scopedList")
+		assertNotNull appCtx.getBean("scopedList").size()
+		assertNotNull appCtx.getBean("scopedList").size()
+
+		// should only be true because bean not initialized until proxy called
+		assertEquals 2, scope.instanceCount
+	}
+
+	void testSpringNamespaceBean() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
-        reader.beans {
-            xmlns util: 'http://www.springframework.org/schema/util'
-            util.list(id: 'foo') {
-                value 'one'
-                value 'two'
-            }
-        }
+		reader.beans {
+			xmlns util: 'http://www.springframework.org/schema/util'
+			util.list(id: 'foo') {
+				value 'one'
+				value 'two'
+			}
+		}
 		appCtx.refresh()
 
-        assert ['one', 'two'] == appCtx.getBean('foo')
-    }
+		assert ['one', 'two'] == appCtx.getBean('foo')
+	}
 
-    void testNamedArgumentConstructor() {
+	void testNamedArgumentConstructor() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
-        reader.beans {
-            holyGrail(HolyGrailQuest)
-            knights(KnightOfTheRoundTable, "Camelot", leader:"lancelot", quest: holyGrail)
-        }
-        appCtx.refresh()
+		reader.beans {
+			holyGrail(HolyGrailQuest)
+			knights(KnightOfTheRoundTable, "Camelot", leader:"lancelot", quest: holyGrail)
+		}
+		appCtx.refresh()
 
-        KnightOfTheRoundTable knights = appCtx.getBean("knights")
-        HolyGrailQuest quest = appCtx.getBean("holyGrail")
+		KnightOfTheRoundTable knights = appCtx.getBean("knights")
+		HolyGrailQuest quest = appCtx.getBean("holyGrail")
 
-        assertEquals "Camelot", knights.name
-        assertEquals "lancelot", knights.leader
-        assertEquals quest, knights.quest
-    }
+		assertEquals "Camelot", knights.name
+		assertEquals "lancelot", knights.leader
+		assertEquals quest, knights.quest
+	}
 
-    void testAbstractBeanDefinition() {
+	void testAbstractBeanDefinition() {
 		def appCtx = new GenericGroovyApplicationContext()
 		appCtx.reader.beans {
 			abstractBean {
@@ -317,9 +317,9 @@ class GroovyBeanDefinitionReaderTests extends GroovyTestCase {
 			appCtx.abstractBean
 		}
 		assertEquals "Lancelot", knights.leader
-    }
+	}
 
-    void testAbstractBeanDefinitionWithClass() {
+	void testAbstractBeanDefinitionWithClass() {
 		def appCtx = new GenericGroovyApplicationContext()
 		appCtx.reader.beans {
 			abstractBean(KnightOfTheRoundTable) { bean ->
@@ -340,30 +340,30 @@ class GroovyBeanDefinitionReaderTests extends GroovyTestCase {
 		def knights = appCtx.knights
 		assert knights
 		assertEquals "Lancelot", knights.leader
-    }
+	}
 
-    void testScopes() {
+	void testScopes() {
 		def appCtx = new GenericGroovyApplicationContext()
 		appCtx.reader.beans {
-            myBean(ScopeTest) { bean ->
-                bean.scope = "prototype"
-            }
-            myBean2(ScopeTest)
-        }
-        appCtx.refresh()
+			myBean(ScopeTest) { bean ->
+				bean.scope = "prototype"
+			}
+			myBean2(ScopeTest)
+		}
+		appCtx.refresh()
 
-        def b1 = appCtx.myBean
-        def b2 = appCtx.myBean
+		def b1 = appCtx.myBean
+		def b2 = appCtx.myBean
 
-        assert b1 != b2
+		assert b1 != b2
 
-        b1 = appCtx.myBean2
-        b2 = appCtx.myBean2
+		b1 = appCtx.myBean2
+		b2 = appCtx.myBean2
 
-        assertEquals b1, b2
-    }
+		assertEquals b1, b2
+	}
 
-    void testSimpleBean() {
+	void testSimpleBean() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
 		reader.beans {
@@ -430,10 +430,10 @@ class GroovyBeanDefinitionReaderTests extends GroovyTestCase {
 			marge(Bean2) {
 				person = "marge"
 				bean1 =  { Bean1 b ->
-				     	    person = "homer"
-						    age = 45
-						    props = [overweight:true, height:"1.8m"]
-						    children = ["bart", "lisa"] }
+							 person = "homer"
+							age = 45
+							props = [overweight:true, height:"1.8m"]
+							children = ["bart", "lisa"] }
 				children = [bart, lisa]
 			}
 		}
@@ -558,7 +558,7 @@ class GroovyBeanDefinitionReaderTests extends GroovyTestCase {
 				age = 45
 			}
 			marge(Bean4) { bean ->
-			    bean.factoryMethod = "getInstance"
+				bean.factoryMethod = "getInstance"
 				person = "marge"
 			}
 		}
@@ -600,28 +600,28 @@ class GroovyBeanDefinitionReaderTests extends GroovyTestCase {
 		assert "mcBain", appCtx.getBean("mcBain").person
 	}
 
-    void testGetBeanDefinitions() {
+	void testGetBeanDefinitions() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
-        reader.beans {
-            jeff(Bean1) {
-                person = 'jeff'
-            }
-            graeme(Bean1) {
-                person = 'graeme'
-            }
-            guillaume(Bean1) {
-                person = 'guillaume'
-            }
-        }
+		reader.beans {
+			jeff(Bean1) {
+				person = 'jeff'
+			}
+			graeme(Bean1) {
+				person = 'graeme'
+			}
+			guillaume(Bean1) {
+				person = 'guillaume'
+			}
+		}
 
 		junit.framework.TestCase.assertEquals 'beanDefinitions was the wrong size', 3, reader.registry.beanDefinitionCount
-        assertNotNull 'beanDefinitions did not contain jeff', reader.registry.getBeanDefinition('jeff')
-        assertNotNull 'beanDefinitions did not contain guillaume', reader.registry.getBeanDefinition('guillaume')
-        assertNotNull 'beanDefinitions did not contain graeme', reader.registry.getBeanDefinition('graeme')
-    }
+		assertNotNull 'beanDefinitions did not contain jeff', reader.registry.getBeanDefinition('jeff')
+		assertNotNull 'beanDefinitions did not contain guillaume', reader.registry.getBeanDefinition('guillaume')
+		assertNotNull 'beanDefinitions did not contain graeme', reader.registry.getBeanDefinition('graeme')
+	}
 
-    void testBeanWithFactoryBean() {
+	void testBeanWithFactoryBean() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
 		reader.beans {
@@ -679,11 +679,11 @@ class GroovyBeanDefinitionReaderTests extends GroovyTestCase {
 		def reader = new GroovyBeanDefinitionReader(appCtx)
 
 		reader.beans {
-		 quest(HolyGrailQuest) 
+		quest(HolyGrailQuest)
 
-		 knight(KnightOfTheRoundTable, "Bedivere") {
-		   quest = ref("quest")
-		 }
+		knight(KnightOfTheRoundTable, "Bedivere") {
+		quest = ref("quest")
+		}
 		}
 
 		appCtx.refresh()
@@ -692,43 +692,43 @@ class GroovyBeanDefinitionReaderTests extends GroovyTestCase {
 		knight.embarkOnQuest()
 	}
 
-    void testAbstractBeanSpecifyingClass() {
+	void testAbstractBeanSpecifyingClass() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
 
-        reader.beans {
-            abstractKnight(KnightOfTheRoundTable) { bean ->
-                bean.'abstract' = true
-                leader = "King Arthur"
-            }
+		reader.beans {
+			abstractKnight(KnightOfTheRoundTable) { bean ->
+				bean.'abstract' = true
+				leader = "King Arthur"
+			}
 
-            lancelot("lancelot") { bean ->
-                bean.parent = ref("abstractKnight")
-            }
+			lancelot("lancelot") { bean ->
+				bean.parent = ref("abstractKnight")
+			}
 
-            abstractPerson(Bean1) { bean ->
-                bean.'abstract'=true
-                age = 45
-            }
-            homerBean { bean ->
-                bean.parent = ref("abstractPerson")
-                person = "homer"
-            }
-        }
+			abstractPerson(Bean1) { bean ->
+				bean.'abstract'=true
+				age = 45
+			}
+			homerBean { bean ->
+				bean.parent = ref("abstractPerson")
+				person = "homer"
+			}
+		}
 		appCtx.refresh()
 
-        def lancelot = appCtx.getBean("lancelot")
-        assertEquals "King Arthur", lancelot.leader
-        assertEquals "lancelot", lancelot.name
+		def lancelot = appCtx.getBean("lancelot")
+		assertEquals "King Arthur", lancelot.leader
+		assertEquals "lancelot", lancelot.name
 
-        def homerBean = appCtx.getBean("homerBean")
+		def homerBean = appCtx.getBean("homerBean")
 
-        assertEquals 45, homerBean.age
-        assertEquals "homer", homerBean.person 
-    }
+		assertEquals 45, homerBean.age
+		assertEquals "homer", homerBean.person
+	}
 
 	void testGroovyBeanDefinitionReaderWithScript() {
-        def script = '''
+		def script = '''
 def appCtx = new org.springframework.context.support.GenericGroovyApplicationContext()
 appCtx.reader.beans {
 quest(org.springframework.context.groovy.HolyGrailQuest) {}
@@ -737,38 +737,38 @@ knight(org.springframework.context.groovy.KnightOfTheRoundTable, "Bedivere") { q
 }
 appCtx.refresh()
 return appCtx
- '''                                                                                
-        def appCtx = new GroovyShell().evaluate(script)
+'''
+		def appCtx = new GroovyShell().evaluate(script)
 
-        def knight = appCtx.getBean('knight')
-        knight.embarkOnQuest()
-    }
+		def knight = appCtx.getBean('knight')
+		knight.embarkOnQuest()
+	}
 
-    // test for GRAILS-5057
-    void testRegisterBeans() {
+	// test for GRAILS-5057
+	void testRegisterBeans() {
 		def appCtx = new GenericApplicationContext()
-        def reader = new GroovyBeanDefinitionReader(appCtx)
+		def reader = new GroovyBeanDefinitionReader(appCtx)
 
-        reader.beans {
-           personA(AdvisedPerson) {
-               name = "Bob"
-           }
-        }
+		reader.beans {
+		   personA(AdvisedPerson) {
+			   name = "Bob"
+		   }
+		}
 
 		appCtx.refresh()
-        assertEquals "Bob", appCtx.getBean("personA").name
+		assertEquals "Bob", appCtx.getBean("personA").name
 
 		appCtx = new GenericApplicationContext()
-        reader = new GroovyBeanDefinitionReader(appCtx)
-        reader.beans {
-            personA(AdvisedPerson) {
-                name = "Fred"
-            }
-        }
+		reader = new GroovyBeanDefinitionReader(appCtx)
+		reader.beans {
+			personA(AdvisedPerson) {
+				name = "Fred"
+			}
+		}
 
 		appCtx.refresh()
-        assertEquals "Fred", appCtx.getBean("personA").name
-    }
+		assertEquals "Fred", appCtx.getBean("personA").name
+	}
 
 	void testListOfBeansAsConstructorArg() {
 		def appCtx = new GenericApplicationContext()
@@ -815,80 +815,80 @@ return appCtx
 		assertEquals "bart", beanWithMap.peopleByName.bart.person
 	}
 
-    void testAnonymousInnerBeanViaBeanMethod() {
+	void testAnonymousInnerBeanViaBeanMethod() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
-        reader.beans {
-            bart(Bean1) {
-                person = "bart"
-                age = 11
-            }
-            lisa(Bean1) {
-                person = "lisa"
-                age = 9
-            }
-            marge(Bean2) {
-                person = "marge"
-                bean1 =  bean(Bean1) {
-                    person = "homer"
-                    age = 45
-                    props = [overweight:true, height:"1.8m"]
-                    children = ["bart", "lisa"]
-                }
-                children = [bart, lisa]
-            }
-        }
-		appCtx.refresh()
-
-        def marge = appCtx.getBean("marge")
-        assertEquals "homer", marge.bean1.person
-    }
-
-    void testAnonymousInnerBeanViaBeanMethodWithConstructorArgs() {
+		reader.beans {
+			bart(Bean1) {
+				person = "bart"
+				age = 11
+			}
+			lisa(Bean1) {
+				person = "lisa"
+				age = 9
+			}
+			marge(Bean2) {
+				person = "marge"
+				bean1 =  bean(Bean1) {
+					person = "homer"
+					age = 45
+					props = [overweight:true, height:"1.8m"]
+					children = ["bart", "lisa"]
+				}
+				children = [bart, lisa]
+			}
+		}
+		appCtx.refresh()
+
+		def marge = appCtx.getBean("marge")
+		assertEquals "homer", marge.bean1.person
+	}
+
+	void testAnonymousInnerBeanViaBeanMethodWithConstructorArgs() {
 		def appCtx = new GenericApplicationContext()
 		def reader = new GroovyBeanDefinitionReader(appCtx)
-        reader.beans {
-            bart(Bean1) {
-                person = "bart"
-                age = 11
-            }
-            lisa(Bean1) {
-                person = "lisa"
-                age = 9
-            }
-            marge(Bean2) {
-                person = "marge"
-                bean3 =  bean(Bean3, "homer", lisa) {
-                    person = "homer"
-                    age = 45
-                }
-                children = [bart, lisa]
-            }
-        }
-		appCtx.refresh()
-
-        def marge = appCtx.getBean("marge")
-
-        assertEquals "homer", marge.bean3.person
-        assertEquals "lisa", marge.bean3.bean1.person
-    }
+		reader.beans {
+			bart(Bean1) {
+				person = "bart"
+				age = 11
+			}
+			lisa(Bean1) {
+				person = "lisa"
+				age = 9
+			}
+			marge(Bean2) {
+				person = "marge"
+				bean3 =  bean(Bean3, "homer", lisa) {
+					person = "homer"
+					age = 45
+				}
+				children = [bart, lisa]
+			}
+		}
+		appCtx.refresh()
+
+		def marge = appCtx.getBean("marge")
+
+		assertEquals "homer", marge.bean3.person
+		assertEquals "lisa", marge.bean3.bean1.person
+	}
 
 }
 
 class HolyGrailQuest {
-	   void start() { println "lets begin" }
+	void start() { println "lets begin" }
 }
 class KnightOfTheRoundTable {
-   String name
-   String leader
-   KnightOfTheRoundTable(String n) {
-      this.name = n
-   }
-   HolyGrailQuest quest
-
-   void embarkOnQuest() {
-       quest.start()
-   }
+String name
+String leader
+KnightOfTheRoundTable(String n) {
+	  this.name = n
+}
+HolyGrailQuest quest
+
+void embarkOnQuest() {
+	   quest.start()
+}
 }
 
 // simple bean
@@ -900,7 +900,7 @@ class Bean1 {
 }
 // bean referencing other bean
 class Bean2 {
-    int age
+	int age
 	String person
 	Bean1 bean1
 	Bean3 bean3
@@ -928,17 +928,17 @@ class Bean4 {
 }
 // bean with List-valued constructor arg
 class Bean5 {
-    Bean5(List<Bean1> people) {
-        this.people = people
-    }
-    List<Bean1> people
+	Bean5(List<Bean1> people) {
+		this.people = people
+	}
+	List<Bean1> people
 }
 // bean with Map-valued constructor arg
 class Bean6 {
-    Bean6(Map<String, Bean1> peopleByName) {
-        this.peopleByName = peopleByName
-    }
-    Map<String, Bean1> peopleByName
+	Bean6(Map<String, Bean1> peopleByName) {
+		this.peopleByName = peopleByName
+	}
+	Map<String, Bean1> peopleByName
 }
 // a factory bean
 class Bean1Factory {
@@ -949,44 +949,44 @@ class Bean1Factory {
 class ScopeTest {}
 class TestScope implements Scope {
 
-    int instanceCount
+	int instanceCount
 
 
-    public Object remove(String name) {
-         // do nothing
-    }
+	public Object remove(String name) {
+		 // do nothing
+	}
 
-    public void registerDestructionCallback(String name, Runnable callback) {
-    }
+	public void registerDestructionCallback(String name, Runnable callback) {
+	}
 
-    public String getConversationId() {
-        return "mock"
-    }
+	public String getConversationId() {
+		return "mock"
+	}
 
-    public Object get(String name, ObjectFactory<?> objectFactory) {
-        instanceCount++
-        objectFactory.getObject()
+	public Object get(String name, ObjectFactory<?> objectFactory) {
+		instanceCount++
+		objectFactory.getObject()
 
-    }
+	}
 
-    public Object resolveContextualObject(String s) {
-        return null;  // noop
-    }
+	public Object resolveContextualObject(String s) {
+		return null;  // noop
+	}
 }
 class BirthdayCardSender {
-   List peopleSentCards = []
-   public void onBirthday(AdvisedPerson person) {
-      peopleSentCards << person
-   }
+List peopleSentCards = []
+public void onBirthday(AdvisedPerson person) {
+	  peopleSentCards << person
+}
 }
 @Component(value = "person")
 public class AdvisedPerson {
- int age;
- String name;
+int age;
+String name;
 
- public void birthday() {
-      ++age;
- }
+public void birthday() {
+	  ++age;
+}
 }
 
 class SomeClass {

spring-context/src/test/java/org/springframework/context/groovy/GroovyApplicationContextTests.java

@@ -35,32 +35,32 @@ public class GroovyApplicationContextTests extends TestCase {
 		assertEquals("Grails", framework);
 	}
 
-    public void testLoadingMultipleConfigFiles() {
+	public void testLoadingMultipleConfigFiles() {
 		GenericGroovyApplicationContext ctx = new GenericGroovyApplicationContext(
 				"org/springframework/context/groovy/applicationContext2.groovy",
 				"org/springframework/context/groovy/applicationContext.groovy");
 
-        Object framework = ctx.getBean("framework");
-        assertNotNull("could not find framework bean", framework);
-        assertEquals("Grails", framework);
+		Object framework = ctx.getBean("framework");
+		assertNotNull("could not find framework bean", framework);
+		assertEquals("Grails", framework);
 
-        Object company = ctx.getBean("company");
-        assertNotNull("could not find company bean", company);
-        assertEquals("SpringSource", company);
-    }
+		Object company = ctx.getBean("company");
+		assertNotNull("could not find company bean", company);
+		assertEquals("SpringSource", company);
+	}
 
-    public void testLoadingMultipleConfigFilesWithRelativeClass() {
+	public void testLoadingMultipleConfigFilesWithRelativeClass() {
 		GenericGroovyApplicationContext ctx = new GenericGroovyApplicationContext();
 		ctx.load(GroovyApplicationContextTests.class, "applicationContext2.groovy", "applicationContext.groovy");
 		ctx.refresh();
 
-        Object framework = ctx.getBean("framework");
-        assertNotNull("could not find framework bean", framework);
-        assertEquals("Grails", framework);
+		Object framework = ctx.getBean("framework");
+		assertNotNull("could not find framework bean", framework);
+		assertEquals("Grails", framework);
 
-        Object company = ctx.getBean("company");
-        assertNotNull("could not find company bean", company);
-        assertEquals("SpringSource", company);
-    }
+		Object company = ctx.getBean("company");
+		assertNotNull("could not find company bean", company);
+		assertEquals("SpringSource", company);
+	}
 
 }