Fix CI examples and formatting

Author: nficano

.github/workflows/ci.yml

@@ -53,6 +53,7 @@ jobs:
         uses: gradle/actions/wrapper-validation@v4
 
       - name: Check formatting (Spotless)
+        if: ${{ matrix.jdk == '21' }}
         run: ./gradlew spotlessCheck --no-daemon
 
       - name: Build

arcp-client/src/main/java/dev/arcp/client/ArcpClient.java

@@ -1,8 +1,8 @@
 package dev.arcp.client;
 
 import dev.arcp.core.credentials.Credential;
-import dev.arcp.core.events.EventBody;
 import dev.arcp.core.error.ArcpException;
+import dev.arcp.core.events.EventBody;
 import dev.arcp.core.ids.JobId;
 import dev.arcp.core.messages.JobAccepted;
 import dev.arcp.core.messages.JobResult;
@@ -14,21 +14,21 @@
 /** Client-side handle to one submitted job. */
 public interface JobHandle {
 
-    JobId jobId();
+  JobId jobId();
 
-    String resolvedAgent();
+  String resolvedAgent();
 
-    JobAccepted accepted();
+  JobAccepted accepted();
 
-    default Optional<List<Credential>> credentials() {
-        return Optional.ofNullable(accepted().credentials());
-    }
+  default Optional<List<Credential>> credentials() {
+    return Optional.ofNullable(accepted().credentials());
+  }
 
-    /** Hot publisher of {@link EventBody} for this job's {@code job.event} stream. */
-    Flow.Publisher<EventBody> events();
+  /** Hot publisher of {@link EventBody} for this job's {@code job.event} stream. */
+  Flow.Publisher<EventBody> events();
 
-    /** Completes with {@link JobResult} on success or fails with {@link ArcpException}. */
-    CompletableFuture<JobResult> result();
+  /** Completes with {@link JobResult} on success or fails with {@link ArcpException}. */
+  CompletableFuture<JobResult> result();
 
-    void cancel();
+  void cancel();
 }

arcp-client/src/main/java/dev/arcp/client/JobHandle.java

@@ -5,11 +5,11 @@
 import org.jspecify.annotations.Nullable;
 
 public record Page<T>(List<T> items, @Nullable String nextCursor) {
-    public static Page<JobSummary> empty() {
-        return new Page<>(List.of(), null);
-    }
+  public static Page<JobSummary> empty() {
+    return new Page<>(List.of(), null);
+  }
 
-    public boolean hasNext() {
-        return nextCursor != null;
-    }
+  public boolean hasNext() {
+    return nextCursor != null;
+  }
 }

arcp-client/src/main/java/dev/arcp/client/Page.java

@@ -10,113 +10,113 @@
 import java.util.concurrent.locks.ReentrantLock;
 
 /**
- * Multicast {@link Flow.Publisher} that buffers every emission and replays the
- * buffer to each newly attached subscriber before forwarding live deliveries.
- * Used by {@link JobHandle#events()} so callers subscribing after a job has
- * already emitted still see the full event history.
+ * Multicast {@link Flow.Publisher} that buffers every emission and replays the buffer to each newly
+ * attached subscriber before forwarding live deliveries. Used by {@link JobHandle#events()} so
+ * callers subscribing after a job has already emitted still see the full event history.
  */
 final class ReplayingPublisher<T> implements Flow.Publisher<T> {
 
-    private final List<T> buffer = new CopyOnWriteArrayList<>();
-    private final SubmissionPublisher<T> live;
-    private final ReentrantLock lock = new ReentrantLock();
-    private volatile boolean closed;
+  private final List<T> buffer = new CopyOnWriteArrayList<>();
+  private final SubmissionPublisher<T> live;
+  private final ReentrantLock lock = new ReentrantLock();
+  private volatile boolean closed;
 
-    ReplayingPublisher() {
-        this.live = new SubmissionPublisher<>(
-                Executors.newVirtualThreadPerTaskExecutor(), 1024);
-    }
+  ReplayingPublisher() {
+    this.live = new SubmissionPublisher<>(Executors.newVirtualThreadPerTaskExecutor(), 1024);
+  }
 
-    // Lock spans live.submit so concurrent producers preserve buffer/live order;
-    // back-pressure blocking on a full submission queue therefore stalls peers.
-    void submit(T item) {
-        lock.lock();
-        try {
-            buffer.add(item);
-            live.submit(item);
-        } finally {
-            lock.unlock();
-        }
+  // Lock spans live.submit so concurrent producers preserve buffer/live order;
+  // back-pressure blocking on a full submission queue therefore stalls peers.
+  void submit(T item) {
+    lock.lock();
+    try {
+      buffer.add(item);
+      live.submit(item);
+    } finally {
+      lock.unlock();
     }
+  }
 
-    void close() {
-        lock.lock();
-        try {
-            if (closed) {
-                return;
-            }
-            closed = true;
-            live.close();
-        } finally {
-            lock.unlock();
-        }
+  void close() {
+    lock.lock();
+    try {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      live.close();
+    } finally {
+      lock.unlock();
     }
+  }
 
-    @Override
-    public void subscribe(Flow.Subscriber<? super T> downstream) {
-        final List<T> snapshot;
-        final boolean wasClosed;
-        AtomicBoolean cancelled = new AtomicBoolean(false);
+  @Override
+  public void subscribe(Flow.Subscriber<? super T> downstream) {
+    final List<T> snapshot;
+    final boolean wasClosed;
+    AtomicBoolean cancelled = new AtomicBoolean(false);
 
-        // Hold the publisher lock while snapshotting AND attaching to live so
-        // no submit() can interleave between the two and produce a gap.
-        lock.lock();
-        try {
-            snapshot = new ArrayList<>(buffer);
-            wasClosed = closed;
-            if (!wasClosed) {
-                live.subscribe(new Flow.Subscriber<T>() {
-                    @Override
-                    public void onSubscribe(Flow.Subscription s) {
-                        s.request(Long.MAX_VALUE);
-                    }
+    // Hold the publisher lock while snapshotting AND attaching to live so
+    // no submit() can interleave between the two and produce a gap.
+    lock.lock();
+    try {
+      snapshot = new ArrayList<>(buffer);
+      wasClosed = closed;
+      if (!wasClosed) {
+        live.subscribe(
+            new Flow.Subscriber<T>() {
+              @Override
+              public void onSubscribe(Flow.Subscription s) {
+                s.request(Long.MAX_VALUE);
+              }
 
-                    @Override
-                    public void onNext(T item) {
-                        if (!cancelled.get()) {
-                            downstream.onNext(item);
-                        }
-                    }
+              @Override
+              public void onNext(T item) {
+                if (!cancelled.get()) {
+                  downstream.onNext(item);
+                }
+              }
 
-                    @Override
-                    public void onError(Throwable throwable) {
-                        if (!cancelled.get()) {
-                            downstream.onError(throwable);
-                        }
-                    }
+              @Override
+              public void onError(Throwable throwable) {
+                if (!cancelled.get()) {
+                  downstream.onError(throwable);
+                }
+              }
 
-                    @Override
-                    public void onComplete() {
-                        if (!cancelled.get()) {
-                            downstream.onComplete();
-                        }
-                    }
-                });
-            }
-        } finally {
-            lock.unlock();
-        }
+              @Override
+              public void onComplete() {
+                if (!cancelled.get()) {
+                  downstream.onComplete();
+                }
+              }
+            });
+      }
+    } finally {
+      lock.unlock();
+    }
 
-        downstream.onSubscribe(new Flow.Subscription() {
-            @Override
-            public void request(long n) {
-                // Replay is delivered eagerly below; live items honor the
-                // forwarder's request(MAX_VALUE).
-            }
+    downstream.onSubscribe(
+        new Flow.Subscription() {
+          @Override
+          public void request(long n) {
+            // Replay is delivered eagerly below; live items honor the
+            // forwarder's request(MAX_VALUE).
+          }
 
-            @Override
-            public void cancel() {
-                cancelled.set(true);
-            }
+          @Override
+          public void cancel() {
+            cancelled.set(true);
+          }
         });
-        for (T item : snapshot) {
-            if (cancelled.get()) {
-                return;
-            }
-            downstream.onNext(item);
-        }
-        if (wasClosed) {
-            downstream.onComplete();
-        }
+    for (T item : snapshot) {
+      if (cancelled.get()) {
+        return;
+      }
+      downstream.onNext(item);
+    }
+    if (wasClosed) {
+      downstream.onComplete();
     }
+  }
 }