Don't write locks if both the locks and props change

gradle-consistent-versions-idea-plugin/src/main/java/com/palantir/gradle/versions/intellij/DebouncingAsyncFileListener.java

@@ -23,63 +23,44 @@
 import com.intellij.util.SingleAlarm;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.LinkedBlockingQueue;
 import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public final class DebouncingAsyncFileListener implements AsyncFileListener, Disposable {
+public final class DebouncingAsyncFileListener implements AsyncFileListener {
     private static final Logger log = LoggerFactory.getLogger(DebouncingAsyncFileListener.class);
 
     private final AsyncFileListener delegate;
     private final SingleAlarm alarm;
-    private final Object lock = new Object();
+    private final LinkedBlockingQueue<VFileEvent> bufferedEvents = new LinkedBlockingQueue<>();
 
-    private final List<VFileEvent> bufferedEvents = new ArrayList<>();
-    private boolean isDisposed = false;
-
-    DebouncingAsyncFileListener(AsyncFileListener delegate, int debounceDelayMillis) {
+    DebouncingAsyncFileListener(AsyncFileListener delegate, int debounceDelayMillis, Disposable parentDisposable) {
         this.delegate = delegate;
-        this.alarm = new SingleAlarm(this::processEvents, debounceDelayMillis, this, Alarm.ThreadToUse.POOLED_THREAD);
+        this.alarm = new SingleAlarm(
+                this::processEvents, debounceDelayMillis, parentDisposable, Alarm.ThreadToUse.POOLED_THREAD);
     }
 
     @Nullable
     @Override
     public ChangeApplier prepareChange(List<? extends VFileEvent> events) {
-        synchronized (lock) {
-            if (isDisposed) {
-                return null;
-            }
-            log.debug("Received events: {}", events);
-            bufferedEvents.addAll(events);
-            alarm.request();
-        }
+        log.debug("Received events: {}", events);
+        bufferedEvents.addAll(events);
+        alarm.request();
         return null;
     }
 
     private void processEvents() {
-        List<VFileEvent> eventsToProcess;
-        synchronized (lock) {
-            if (isDisposed) {
-                return;
-            }
-            eventsToProcess = new ArrayList<>(bufferedEvents);
-            bufferedEvents.clear();
+        List<VFileEvent> eventsToProcess = new ArrayList<>();
+        int drained = bufferedEvents.drainTo(eventsToProcess);
+        if (drained == 0) {
+            return;
         }
+
         log.debug("Processing debounced events: {}", eventsToProcess);
         AsyncFileListener.ChangeApplier applier = delegate.prepareChange(eventsToProcess);
         if (applier != null) {
             applier.afterVfsChange();
         }
     }
-
-    @Override
-    public void dispose() {
-        synchronized (lock) {
-            if (isDisposed) {
-                return;
-            }
-            isDisposed = true;
-            alarm.cancelAllRequests();
-        }
-    }
 }

gradle-consistent-versions-idea-plugin/src/main/java/com/palantir/gradle/versions/intellij/FilteringAsyncFileListener.java

@@ -0,0 +1,57 @@
+/*
+ * (c) Copyright 2024 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.palantir.gradle.versions.intellij;
+
+import com.intellij.openapi.vfs.AsyncFileListener;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.newvfs.events.VFileEvent;
+import java.util.List;
+import java.util.function.Predicate;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class FilteringAsyncFileListener implements AsyncFileListener {
+    private static final Logger log = LoggerFactory.getLogger(FilteringAsyncFileListener.class);
+
+    private final AsyncFileListener delegate;
+    private final Predicate<VirtualFile> filter;
+
+    FilteringAsyncFileListener(AsyncFileListener delegate, Predicate<VirtualFile> filter) {
+        this.delegate = delegate;
+        this.filter = filter;
+    }
+
+    @Nullable
+    @Override
+    public final ChangeApplier prepareChange(List<? extends VFileEvent> events) {
+        List<? extends VFileEvent> filteredEvents = events.stream()
+                .filter(event -> {
+                    VirtualFile file = event.getFile();
+                    return file != null && filter.test(file);
+                })
+                .toList();
+
+        log.debug("Events after filtering {}", filteredEvents);
+
+        if (filteredEvents.isEmpty()) {
+            return null;
+        }
+
+        return delegate.prepareChange(filteredEvents);
+    }
+}

gradle-consistent-versions-idea-plugin/src/main/java/com/palantir/gradle/versions/intellij/VersionPropsListenerRegistrar.java

@@ -16,22 +16,35 @@
 
 package com.palantir.gradle.versions.intellij;
 
+import com.intellij.openapi.Disposable;
 import com.intellij.openapi.vfs.AsyncFileListener;
+import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.newvfs.events.VFileEvent;
 import java.util.List;
+import java.util.function.Predicate;
 import org.jetbrains.annotations.Nullable;
 
-public final class VersionPropsListenerRegistrar implements AsyncFileListener {
+public final class VersionPropsListenerRegistrar implements AsyncFileListener, Disposable {
 
-    private final DebouncingAsyncFileListener debouncedListener;
+    private final FilteringAsyncFileListener changeListener;
 
     VersionPropsListenerRegistrar() {
-        this.debouncedListener = new DebouncingAsyncFileListener(new VersionPropsFileListener(), 250);
+
+        Predicate<VirtualFile> filter = virtualFile -> {
+            String fileName = virtualFile.getName();
+            return "versions.props".equals(fileName) || "versions.lock".equals(fileName);
+        };
+
+        this.changeListener = new FilteringAsyncFileListener(
+                new DebouncingAsyncFileListener(new VersionPropsFileListener(), 250, this), filter);
     }
 
     @Nullable
     @Override
     public ChangeApplier prepareChange(List<? extends VFileEvent> events) {
-        return debouncedListener.prepareChange(events);
+        return changeListener.prepareChange(events);
     }
+
+    @Override
+    public void dispose() {}
 }