fix: linting

Author: federicorispo

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/GraphQLQueryInvoker.java

@@ -50,12 +50,13 @@ public static class Builder {
 
     private Supplier<ExecutionStrategyProvider> getExecutionStrategyProvider =
         DefaultExecutionStrategyProvider::new;
-    private Supplier<Instrumentation> getInstrumentation = () -> SimplePerformantInstrumentation.INSTANCE;
+    private Supplier<Instrumentation> getInstrumentation =
+        () -> SimplePerformantInstrumentation.INSTANCE;
     private Supplier<PreparsedDocumentProvider> getPreparsedDocumentProvider =
         () -> NoOpPreparsedDocumentProvider.INSTANCE;
     private Supplier<DataLoaderDispatcherInstrumentationOptions>
         dataLoaderDispatcherInstrumentationOptionsSupplier =
-        DataLoaderDispatcherInstrumentationOptions::newOptions;
+            DataLoaderDispatcherInstrumentationOptions::newOptions;
 
     public Builder withExecutionStrategyProvider(ExecutionStrategyProvider provider) {
       return withExecutionStrategyProvider(() -> provider);

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/config/GraphQLBuilder.java

@@ -20,7 +20,8 @@ public class GraphQLBuilder {
       () -> NoOpPreparsedDocumentProvider.INSTANCE;
 
   @Getter
-  private Supplier<Instrumentation> instrumentationSupplier = () -> SimplePerformantInstrumentation.INSTANCE;
+  private Supplier<Instrumentation> instrumentationSupplier =
+      () -> SimplePerformantInstrumentation.INSTANCE;
 
   private Supplier<GraphQLBuilderConfigurer> graphQLBuilderConfigurerSupplier = () -> builder -> {};
 

graphql-java-kickstart/src/main/java/graphql/kickstart/execution/instrumentation/ConfigurableDispatchInstrumentation.java

@@ -35,9 +35,7 @@ public class ConfigurableDispatchInstrumentation extends DataLoaderDispatcherIns
 
   private final Function<DataLoaderRegistry, TrackingApproach> approachFunction;
 
-  /**
-   * Creates a DataLoaderDispatcherInstrumentation with the default options
-   */
+  /** Creates a DataLoaderDispatcherInstrumentation with the default options */
   public ConfigurableDispatchInstrumentation(
       Function<DataLoaderRegistry, TrackingApproach> approachFunction) {
     this(DataLoaderDispatcherInstrumentationOptions.newOptions(), approachFunction);
@@ -48,7 +46,8 @@ public ConfigurableDispatchInstrumentation(
    *
    * @param options the options to control the behaviour
    */
-  public ConfigurableDispatchInstrumentation(DataLoaderDispatcherInstrumentationOptions options,
+  public ConfigurableDispatchInstrumentation(
+      DataLoaderDispatcherInstrumentationOptions options,
       Function<DataLoaderRegistry, TrackingApproach> approachFunction) {
     this.options = options;
     this.approachFunction = approachFunction;
@@ -60,27 +59,29 @@ public InstrumentationState createState(InstrumentationCreateStateParameters par
     return new DataLoaderDispatcherInstrumentationState(
         registry,
         approachFunction.apply(registry),
-        parameters.getExecutionInput().getExecutionId()
-    );
+        parameters.getExecutionInput().getExecutionId());
   }
 
   @Override
-  public DataFetcher<?> instrumentDataFetcher(DataFetcher<?> dataFetcher,
-      InstrumentationFieldFetchParameters parameters, InstrumentationState instrumentationState) {
-    DataLoaderDispatcherInstrumentationState state = InstrumentationState.ofState(
-        instrumentationState);
+  public DataFetcher<?> instrumentDataFetcher(
+      DataFetcher<?> dataFetcher,
+      InstrumentationFieldFetchParameters parameters,
+      InstrumentationState instrumentationState) {
+    DataLoaderDispatcherInstrumentationState state =
+        InstrumentationState.ofState(instrumentationState);
     if (state.isAggressivelyBatching()) {
       return dataFetcher;
     }
     //
     // currently only AsyncExecutionStrategy with DataLoader and hence this allows us to "dispatch"
     // on every object if it's not using aggressive batching for other execution strategies
     // which allows them to work if used.
-    return (DataFetcher<Object>) environment -> {
-      Object obj = dataFetcher.get(environment);
-      doImmediatelyDispatch(state);
-      return obj;
-    };
+    return (DataFetcher<Object>)
+        environment -> {
+          Object obj = dataFetcher.get(environment);
+          doImmediatelyDispatch(state);
+          return obj;
+        };
   }
 
   private void doImmediatelyDispatch(DataLoaderDispatcherInstrumentationState state) {
@@ -92,8 +93,8 @@ public InstrumentationContext<ExecutionResult> beginExecuteOperation(
       InstrumentationExecuteOperationParameters parameters,
       InstrumentationState instrumentationState) {
     if (!isDataLoaderCompatible(parameters.getExecutionContext())) {
-      DataLoaderDispatcherInstrumentationState state = InstrumentationState.ofState(
-          instrumentationState);
+      DataLoaderDispatcherInstrumentationState state =
+          InstrumentationState.ofState(instrumentationState);
       state.setAggressivelyBatching(false);
     }
     return SimpleInstrumentationContext.noOp();
@@ -117,8 +118,8 @@ private boolean isDataLoaderCompatible(ExecutionContext executionContext) {
   public ExecutionStrategyInstrumentationContext beginExecutionStrategy(
       InstrumentationExecutionStrategyParameters parameters,
       InstrumentationState instrumentationState) {
-    DataLoaderDispatcherInstrumentationState state = InstrumentationState.ofState(
-        instrumentationState);
+    DataLoaderDispatcherInstrumentationState state =
+        InstrumentationState.ofState(instrumentationState);
     //
     // if there are no data loaders, there is nothing to do
     //
@@ -141,8 +142,8 @@ public void onCompleted(ExecutionResult result, Throwable t) {
   @Override
   public InstrumentationContext<Object> beginFieldFetch(
       InstrumentationFieldFetchParameters parameters, InstrumentationState instrumentationState) {
-    DataLoaderDispatcherInstrumentationState state = InstrumentationState.ofState(
-        instrumentationState);
+    DataLoaderDispatcherInstrumentationState state =
+        InstrumentationState.ofState(instrumentationState);
     //
     // if there are no data loaders, there is nothing to do
     //
@@ -154,25 +155,26 @@ public InstrumentationContext<Object> beginFieldFetch(
 
   @Override
   public CompletableFuture<ExecutionResult> instrumentExecutionResult(
-      ExecutionResult executionResult, InstrumentationExecutionParameters parameters,
+      ExecutionResult executionResult,
+      InstrumentationExecutionParameters parameters,
       InstrumentationState instrumentationState) {
-    DataLoaderDispatcherInstrumentationState state = InstrumentationState.ofState(
-        instrumentationState);
+    DataLoaderDispatcherInstrumentationState state =
+        InstrumentationState.ofState(instrumentationState);
     state.getApproach().removeTracking(parameters.getExecutionInput().getExecutionId());
     if (!options.isIncludeStatistics()) {
       return CompletableFuture.completedFuture(executionResult);
     } else {
       Map<Object, Object> currentExt = executionResult.getExtensions();
-      Map<Object, Object> statsMap = new LinkedHashMap<>(
-          currentExt == null ? Collections.emptyMap() : currentExt);
+      Map<Object, Object> statsMap =
+          new LinkedHashMap<>(currentExt == null ? Collections.emptyMap() : currentExt);
       Map<Object, Object> dataLoaderStats = buildStatisticsMap(state);
       statsMap.put("dataloader", dataLoaderStats);
 
       log.debug("Data loader stats : {}", dataLoaderStats);
 
       return CompletableFuture.completedFuture(
-          new ExecutionResultImpl(executionResult.getData(), executionResult.getErrors(),
-              statsMap));
+          new ExecutionResultImpl(
+              executionResult.getData(), executionResult.getErrors(), statsMap));
     }
   }