Reformat code

grails-async/core/src/main/groovy/grails/async/DelegateAsync.groovy

@@ -63,7 +63,8 @@ import org.codehaus.groovy.transform.GroovyASTTransformationClass
 @Documented
 @Retention(RetentionPolicy.SOURCE)
 @Target([ElementType.TYPE, ElementType.FIELD])
-@GroovyASTTransformationClass("org.grails.async.transform.internal.DelegateAsyncTransformation")
+@GroovyASTTransformationClass('org.grails.async.transform.internal.DelegateAsyncTransformation')
 @interface DelegateAsync {
+
     Class value() default DelegateAsync
 }

grails-async/core/src/main/groovy/grails/async/PromiseFactory.groovy

@@ -18,11 +18,11 @@
  */
 package grails.async
 
+import java.util.concurrent.TimeUnit
+
 import grails.async.decorator.PromiseDecorator
 import grails.async.decorator.PromiseDecoratorLookupStrategy
 
-import java.util.concurrent.TimeUnit
-
 /**
  * An interface capable of creating {@link Promise} instances. The {@link Promises} static methods use this
  * interface to create promises. The default Promise creation mechanism can be overridden by setting {@link Promises#setPromiseFactory(PromiseFactory)}

grails-async/core/src/main/groovy/grails/async/PromiseList.groovy

@@ -18,11 +18,11 @@
  */
 package grails.async
 
+import java.util.concurrent.TimeUnit
+
 import groovy.transform.AutoFinal
 import groovy.transform.CompileStatic
 
-import java.util.concurrent.TimeUnit
-
 /**
  * A list of promises
  *
@@ -138,7 +138,7 @@ class PromiseList<T> implements Promise<List<T>> {
 
     @Override
     boolean isDone() {
-        return promises.every {promise -> promise.isDone() }
+        return promises.every { promise -> promise.isDone() }
     }
 
     @Override

grails-async/core/src/main/groovy/grails/async/PromiseMap.groovy

@@ -18,11 +18,11 @@
  */
 package grails.async
 
+import java.util.concurrent.TimeUnit
+
 import groovy.transform.AutoFinal
 import groovy.transform.CompileStatic
 
-import java.util.concurrent.TimeUnit
-
 /**
  * A map-like structure for promises that allows waiting for all values in the map to be populated before
  * executing a callback
@@ -55,7 +55,7 @@ class PromiseMap<K,V> implements Promise<Map<K,V>> {
 
     @Override
     boolean isDone() {
-        return promisesKeys.keySet().every {it.isDone() }
+        return promisesKeys.keySet().every { it.isDone() }
     }
 
     @Override
@@ -213,7 +213,7 @@ class PromiseMap<K,V> implements Promise<Map<K,V>> {
     Map<K,V> get() throws Throwable {
         def promises = promises.values()
         Map<K,V> resultMap = [:]
-        for(Promise<V> promise : promises) {
+        for (Promise<V> promise : promises) {
             V value = promise.get()
             resultMap.put(promisesKeys.get(promise), value)
         }
@@ -232,7 +232,7 @@ class PromiseMap<K,V> implements Promise<Map<K,V>> {
         List<Promise<V>> promises = new ArrayList<Promise<V>>(promises.values())
         Promises.waitAll(promises, timeout, units)
         Map<K,V> resultMap = [:]
-        for(Promise<V> promise : promises) {
+        for (Promise<V> promise : promises) {
             V value = promise.get()
             resultMap.put(promisesKeys.get(promise), value)
         }
@@ -245,7 +245,7 @@ class PromiseMap<K,V> implements Promise<Map<K,V>> {
         Promises.onComplete(promises) { List<V> values ->
             Map<K,V> resultMap = [:]
             int i = 0
-            for(V value in values) {
+            for (V value in values) {
                 Promise<V> promise = promises[i]
                 K key = promisesKeys.get(promise)
                 resultMap.put(key, value)

grails-async/core/src/main/groovy/grails/async/Promises.groovy

@@ -18,12 +18,13 @@
  */
 package grails.async
 
-import grails.async.decorator.PromiseDecorator
+import java.util.concurrent.TimeUnit
+
 import groovy.transform.AutoFinal
 import groovy.transform.CompileStatic
-import org.grails.async.factory.PromiseFactoryBuilder
 
-import java.util.concurrent.TimeUnit
+import grails.async.decorator.PromiseDecorator
+import org.grails.async.factory.PromiseFactoryBuilder
 
 /**
  * Factory class for working with {@link Promise} instances
@@ -164,6 +165,6 @@ class Promises {
      * @see PromiseFactory#createBoundPromise(java.lang.Object)
      */
     static<T> Promise<T> createBoundPromise(T value) {
-       return getPromiseFactory().createBoundPromise(value)
+        return getPromiseFactory().createBoundPromise(value)
     }
 }

grails-async/core/src/main/groovy/grails/async/factory/AbstractPromiseFactory.groovy

@@ -18,18 +18,19 @@
  */
 package grails.async.factory
 
+import java.util.concurrent.ConcurrentLinkedQueue
+
+import groovy.transform.AutoFinal
+import groovy.transform.CompileStatic
+
 import grails.async.Promise
 import grails.async.PromiseFactory
 import grails.async.PromiseList
 import grails.async.PromiseMap
 import grails.async.decorator.PromiseDecorator
 import grails.async.decorator.PromiseDecoratorLookupStrategy
-import groovy.transform.AutoFinal
-import groovy.transform.CompileStatic
 import org.grails.async.factory.BoundPromise
 
-import java.util.concurrent.ConcurrentLinkedQueue
-
 /**
  * Abstract implementation of the {@link grails.async.PromiseFactory} interface, subclasses should extend
  * this class to obtain common generic functionality
@@ -59,13 +60,13 @@ abstract class AbstractPromiseFactory implements PromiseFactory {
     }
 
     <T> Closure<T> applyDecorators(Closure<T> closure, List<PromiseDecorator> decorators) {
-        List<PromiseDecorator> allDecorators = decorators != null ? new ArrayList<PromiseDecorator>(decorators): new ArrayList<PromiseDecorator>()
+        List<PromiseDecorator> allDecorators = decorators != null ? new ArrayList<PromiseDecorator>(decorators) : new ArrayList<PromiseDecorator>()
         for (PromiseDecoratorLookupStrategy lookupStrategy : lookupStrategies) {
             allDecorators.addAll(lookupStrategy.findDecorators())
         }
         def decoratedClosure = closure
         if (!allDecorators.empty) {
-            for(PromiseDecorator decorator : allDecorators) {
+            for (PromiseDecorator decorator : allDecorators) {
                 decoratedClosure = decorator.decorate(decoratedClosure)
             }
         }
@@ -76,7 +77,7 @@ abstract class AbstractPromiseFactory implements PromiseFactory {
      * @see PromiseFactory#createPromise(java.util.List)
      */
     <T> Promise<List<T>> createPromise(List<Closure<T>> closures) {
-        return createPromise(closures,null)
+        return createPromise(closures, null)
     }
 
     /**
@@ -99,7 +100,7 @@ abstract class AbstractPromiseFactory implements PromiseFactory {
      */
     <T> Promise<List<T>> createPromise(Promise<T>... promises) {
         PromiseList<T> promiseList = new PromiseList<>()
-        for(Promise<T> promise : promises) {
+        for (Promise<T> promise : promises) {
             promiseList.add(promise)
         }
         return promiseList
@@ -133,7 +134,7 @@ abstract class AbstractPromiseFactory implements PromiseFactory {
     }
 
     protected <T> Promise<T> createPromiseInternal(Closure<T> closure) {
-       return createPromise(closure)
+        return createPromise(closure)
     }
 
     /**

grails-async/core/src/main/groovy/org/grails/async/factory/BoundPromise.groovy

@@ -18,10 +18,11 @@
  */
 package org.grails.async.factory
 
-import grails.async.Promise
+import java.util.concurrent.TimeUnit
+
 import groovy.transform.CompileStatic
 
-import java.util.concurrent.TimeUnit
+import grails.async.Promise
 
 /**
  * A bound promise is a promise which is already resolved and doesn't require any asynchronous processing to calculate the value

grails-async/core/src/main/groovy/org/grails/async/factory/PromiseFactoryBuilder.groovy

@@ -20,7 +20,6 @@
 package org.grails.async.factory
 
 import grails.async.PromiseFactory
-import grails.async.Promises
 import groovy.transform.CompileStatic
 import groovy.util.logging.Slf4j
 import org.grails.async.factory.future.CachedThreadPoolPromiseFactory
@@ -43,13 +42,13 @@ class PromiseFactoryBuilder {
         List<PromiseFactory> promiseFactories = ServiceLoader.load(PromiseFactory).toList()
 
         PromiseFactory promiseFactory
-        if(promiseFactories.isEmpty()) {
-            log.debug 'No PromiseFactory implementation found. Using default ExecutorService promise factory.'
+        if (promiseFactories.isEmpty()) {
+            log.debug('No PromiseFactory implementation found. Using default ExecutorService promise factory.')
             promiseFactory = new CachedThreadPoolPromiseFactory()
         }
         else {
             promiseFactory = promiseFactories.first()
-            log.debug 'Found PromiseFactory implementation to use [{}]', promiseFactory
+            log.debug('Found PromiseFactory implementation to use [{}]', promiseFactory)
         }
 
         return promiseFactory

grails-async/core/src/main/groovy/org/grails/async/factory/SynchronousPromise.groovy

@@ -18,10 +18,11 @@
  */
 package org.grails.async.factory
 
-import grails.async.Promise
+import java.util.concurrent.TimeUnit
+
 import groovy.transform.CompileStatic
 
-import java.util.concurrent.TimeUnit
+import grails.async.Promise
 
 /**
  * A promise that executes synchronously, in the same thread as the creator

grails-async/core/src/main/groovy/org/grails/async/factory/SynchronousPromiseFactory.groovy

@@ -18,13 +18,14 @@
  */
 package org.grails.async.factory
 
-import grails.async.Promise
-import grails.async.PromiseList
-import grails.async.factory.AbstractPromiseFactory
+import java.util.concurrent.TimeUnit
+
 import groovy.transform.AutoFinal
 import groovy.transform.CompileStatic
 
-import java.util.concurrent.TimeUnit
+import grails.async.Promise
+import grails.async.PromiseList
+import grails.async.factory.AbstractPromiseFactory
 
 /**
  * A {@link grails.async.PromiseFactory} implementation that constructors promises that execute synchronously.
@@ -54,7 +55,7 @@ class SynchronousPromiseFactory extends AbstractPromiseFactory {
             promise = new SynchronousPromise<T>(closures[0])
         } else {
             def promiseList = new PromiseList()
-            for(p in closures) {
+            for (p in closures) {
                 promiseList << p
             }
             promise = promiseList

grails-async/core/src/main/groovy/org/grails/async/factory/future/CachedThreadPoolPromiseFactory.groovy

@@ -19,15 +19,22 @@
 
 package org.grails.async.factory.future
 
-import grails.async.Promise
-import grails.async.PromiseList
-import grails.async.factory.AbstractPromiseFactory
+import java.util.concurrent.Callable
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.RunnableFuture
+import java.util.concurrent.SynchronousQueue
+import java.util.concurrent.ThreadPoolExecutor
+import java.util.concurrent.TimeUnit
+
 import groovy.transform.AutoFinal
 import groovy.transform.CompileStatic
-import org.grails.async.factory.BoundPromise
 
 import jakarta.annotation.PreDestroy
-import java.util.concurrent.*
+
+import grails.async.Promise
+import grails.async.PromiseList
+import grails.async.factory.AbstractPromiseFactory
+import org.grails.async.factory.BoundPromise
 
 /**
  * A promise factory that uses an ExecutorService by default

grails-async/core/src/main/groovy/org/grails/async/factory/future/ExecutorPromiseFactory.groovy

@@ -19,14 +19,14 @@
 
 package org.grails.async.factory.future
 
-import grails.async.PromiseFactory
-
 import java.util.concurrent.ExecutorService
 
+import grails.async.PromiseFactory
+
 /**
  * Interface for classes that are both a PromiseFactory and an ExecutorService
  *
  * @author Graeme Rocher
  * @since 3.3
  */
-interface ExecutorPromiseFactory extends PromiseFactory, ExecutorService {}
+interface ExecutorPromiseFactory extends PromiseFactory, ExecutorService {}

grails-async/core/src/main/groovy/org/grails/async/factory/future/FutureTaskChildPromise.groovy

@@ -19,18 +19,18 @@
 
 package org.grails.async.factory.future
 
-import grails.async.Promise
-import grails.async.PromiseFactory
-import groovy.transform.AutoFinal
-import groovy.transform.CompileStatic
-import groovy.transform.PackageScope
-import org.grails.async.factory.BoundPromise
-
 import java.util.concurrent.ConcurrentLinkedQueue
 import java.util.concurrent.ExecutionException
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.TimeoutException
-import java.util.concurrent.locks.ReentrantLock
+
+import groovy.transform.AutoFinal
+import groovy.transform.CompileStatic
+import groovy.transform.PackageScope
+
+import grails.async.Promise
+import grails.async.PromiseFactory
+import org.grails.async.factory.BoundPromise
 
 /**
  * A child promise of a {@link FutureTaskPromise}
@@ -54,7 +54,7 @@ class FutureTaskChildPromise<T> implements Promise<T> {
 
     FutureTaskChildPromise(PromiseFactory promiseFactory, Promise<T> parent, Closure<T> callable) {
         this.parent = parent
-        this.callable = promiseFactory.applyDecorators(callable,null)
+        this.callable = promiseFactory.applyDecorators(callable, null)
         this.promiseFactory = promiseFactory
     }
 

grails-async/core/src/main/groovy/org/grails/async/factory/future/FutureTaskPromise.groovy

@@ -19,19 +19,20 @@
 
 package org.grails.async.factory.future
 
-import grails.async.Promise
-import grails.async.PromiseFactory
-import groovy.transform.AutoFinal
-import groovy.transform.CompileStatic
-import org.grails.async.factory.BoundPromise
-
 import java.util.concurrent.Callable
 import java.util.concurrent.ConcurrentLinkedQueue
 import java.util.concurrent.ExecutionException
 import java.util.concurrent.FutureTask
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.TimeoutException
 
+import groovy.transform.AutoFinal
+import groovy.transform.CompileStatic
+
+import grails.async.Promise
+import grails.async.PromiseFactory
+import org.grails.async.factory.BoundPromise
+
 /**
  * A Promise that is a {@link FutureTask}
  *