Merge pull request #154 from xdev-software/develop

Release

Author: AB-xdev

CHANGELOG.md

@@ -1,3 +1,11 @@
+## 1.3.0
+* Make it possible to run processors asynchronously #130
+  * This way the UI should be more responsive when processing a lot of files
+  * May break processors that interact with the UI e.g. when showing dialogs
+* Don't process files during project load #145
+  * This should cause less race conditions due to partial project initialization
+  * Only active on IntelliJ < 2024.3 as [the underlying problem was fixed in IntelliJ 2024.3](https://github.com/JetBrains/intellij-community/commit/765caa71175d0a67a54836cf840fae829da590d9)
+
 ## 1.2.4
 * Dropped support for IntelliJ versions < 2024.2
 * Removed deprecated code that was only required for older IDE versions

USAGE.md

@@ -32,6 +32,7 @@ You can quickly toggle the plugin activation by using the "Enable Save Action" a
 | Activate save actions on shortcut  | Enable / disable the plugin on shortcut, by default "CTRL + SHIFT + S" (configured in "File > Keymaps > Main menu > Code > Save Actions")
 | Activate save actions on batch     | Enable / disable the plugin on batch, by using "Code > Save Actions > Execute on multiple files"
 | No action if compile errors        | Enable / disable no action if there are compile errors. Applied to each file individually
+| Process files asynchronously       | Enable / disable if files should be processed asynchronously. Enabling it will result in less UI hangs but may break if a processor needs the UI.
 
 ### Global
 
@@ -132,3 +133,21 @@ Some things to note when using other plugins with the Save Actions plugin:
 
 - **idea.log**: The log file the save actions plugin writes in. It contains debug information, prefixed with `software.xdev.saveactions.SaveActionManager`. If you are using default locations, it would be in `~/.IntelliJIdeaVERSION/system/log/idea.log`.
 - **saveactions_settings.xml**: The settings file is saved by project in the `.idea` folder. That file can be committed in git thus shared in your development team. If you are using the default locations, it would be in `~/IdeaProjects/PROJECT_NAME/.idea/saveactions_settings.xml`
+
+## Troubleshooting of common problems
+
+### "Conflicting component name 'SaveActionSettings': class ``com.dubreuia.model.Storage`` and class ``software.xdev.saveactions.model.Storage``"
+
+The problem only happens when the [old/deprecated/forked plugin](https://github.com/dubreuia/intellij-plugin-save-actions) plugin is also installed.
+
+You can fix this by uninstalling the deprecated plugin.
+
+### "AWT events are not allowed inside write action" occurs when applying Save Actions
+
+This usually indicates that some action causes a UI dialog to show up.<br/>However as the actions are run in the background the dialog can't be shown and the crash occurs.
+
+You can work around this problem by finding out what causes the dialog (e.g. by trying to temporarily disabling Save Actions and saving the files normally) and stop it from being displayed.
+
+### "Execute Save Actions on multiple files" is not working
+
+Make sure that you enabled "Activate save actions on batch" in the settings.

gradle.properties

@@ -2,7 +2,7 @@
 pluginGroup=software.xdev.saveactions
 pluginName=Save Actions X
 # SemVer format -> https://semver.org
-pluginVersion=1.2.5-SNAPSHOT
+pluginVersion=1.3.0-SNAPSHOT
 # IntelliJ Platform Properties -> https://plugins.jetbrains.com/docs/intellij/tools-gradle-intellij-plugin.html#configuration-intellij-extension
 platformType=IC
 platformVersion=2024.2.2

src/main/java/software/xdev/saveactions/core/component/Engine.java

@@ -6,20 +6,27 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
 
 import org.jetbrains.annotations.NotNull;
 
+import com.intellij.openapi.application.ReadAction;
+import com.intellij.openapi.application.WriteAction;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.progress.ProgressIndicator;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.roots.ProjectRootManager;
+import com.intellij.openapi.util.ThrowableComputable;
 import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiFile;
+import com.intellij.util.ApplicationKt;
 import com.intellij.util.PsiErrorElementUtil;
+import com.intellij.util.ThrowableRunnable;
 
 import software.xdev.saveactions.core.ExecutionMode;
 import software.xdev.saveactions.core.service.SaveActionsService;
@@ -62,7 +69,9 @@ public Engine(
 		this.mode = mode;
 	}
 
-	public void processPsiFilesIfNecessary()
+	public void processPsiFilesIfNecessary(
+		@NotNull final ProgressIndicator indicator,
+		final boolean async)
 	{
 		if(this.psiFiles == null)
 		{
@@ -73,36 +82,112 @@ public void processPsiFilesIfNecessary()
 			LOGGER.info(String.format("Action \"%s\" not enabled on %s", this.activation.getText(), this.project));
 			return;
 		}
+		
+		indicator.setIndeterminate(true);
+		final Set<PsiFile> psiFilesEligible = this.getEligiblePsiFiles(indicator, async);
+		if(psiFilesEligible.isEmpty())
+		{
+			LOGGER.info("No files are eligible");
+			return;
+		}
+		
+		final List<SaveCommand> processorsEligible = this.getEligibleProcessors(indicator, psiFilesEligible);
+		if(processorsEligible.isEmpty())
+		{
+			LOGGER.info("No processors are eligible");
+			return;
+		}
+		
+		this.flushPsiFiles(indicator, async, psiFilesEligible);
+		
+		this.execute(indicator, processorsEligible, psiFilesEligible);
+	}
+	
+	private Set<PsiFile> getEligiblePsiFiles(final @NotNull ProgressIndicator indicator, final boolean async)
+	{
 		LOGGER.info(String.format("Processing %s files %s mode %s", this.project, this.psiFiles, this.mode));
-		final Set<PsiFile> psiFilesEligible = this.psiFiles.stream()
-			.filter(psiFile -> this.isPsiFileEligible(this.project, psiFile))
-			.collect(toSet());
+		indicator.checkCanceled();
+		indicator.setText2("Collecting files to process");
+		
+		final ThrowableComputable<Set<PsiFile>, RuntimeException> psiFilesEligibleFunc =
+			() -> this.psiFiles.stream()
+				.filter(psiFile -> this.isPsiFileEligible(this.project, psiFile))
+				.collect(toSet());
+		final Set<PsiFile> psiFilesEligible = async
+			? ReadAction.compute(psiFilesEligibleFunc)
+			: psiFilesEligibleFunc.compute();
 		LOGGER.info(String.format("Valid files %s", psiFilesEligible));
-		this.processPsiFiles(this.project, psiFilesEligible, this.mode);
+		return psiFilesEligible;
 	}
 
-	private void processPsiFiles(final Project project, final Set<PsiFile> psiFiles, final ExecutionMode mode)
+	private @NotNull List<SaveCommand> getEligibleProcessors(
+		final @NotNull ProgressIndicator indicator,
+		final Set<PsiFile> psiFilesEligible)
 	{
-		if(psiFiles.isEmpty())
-		{
-			return;
-		}
 		LOGGER.info(String.format("Start processors (%d)", this.processors.size()));
+		indicator.checkCanceled();
+		indicator.setText2("Collecting processors");
+		
 		final List<SaveCommand> processorsEligible = this.processors.stream()
-			.map(processor -> processor.getSaveCommand(project, psiFiles))
+			.map(processor -> processor.getSaveCommand(this.project, psiFilesEligible))
 			.filter(command -> this.storage.isEnabled(command.getAction()))
-			.filter(command -> command.getModes().contains(mode))
+			.filter(command -> command.getModes().contains(this.mode))
 			.toList();
 		LOGGER.info(String.format("Filtered processors %s", processorsEligible));
-		if(!processorsEligible.isEmpty())
+		return processorsEligible;
+	}
+	
+	private void flushPsiFiles(
+		final @NotNull ProgressIndicator indicator,
+		final boolean async,
+		final Set<PsiFile> psiFilesEligible)
+	{
+		LOGGER.info(String.format("Flushing files (%d)", psiFilesEligible.size()));
+		indicator.checkCanceled();
+		indicator.setText2("Flushing files");
+		
+		final ThrowableRunnable<RuntimeException> flushFilesFunc = () -> {
+			final PsiDocumentManager psiDocumentManager = PsiDocumentManager.getInstance(this.project);
+			psiFilesEligible.forEach(psiFile -> this.commitDocumentAndSave(psiFile, psiDocumentManager));
+		};
+		if(async)
+		{
+			ApplicationKt.getApplication().invokeAndWait(() -> WriteAction.run(flushFilesFunc));
+		}
+		else
 		{
-			final PsiDocumentManager psiDocumentManager = PsiDocumentManager.getInstance(project);
-			psiFiles.forEach(psiFile -> this.commitDocumentAndSave(psiFile, psiDocumentManager));
+			flushFilesFunc.run();
 		}
-		final List<SimpleEntry<Action, Result<ResultCode>>> results = processorsEligible.stream()
+	}
+	
+	private void execute(
+		final @NotNull ProgressIndicator indicator,
+		final List<SaveCommand> processorsEligible,
+		final Set<PsiFile> psiFilesEligible)
+	{
+		indicator.checkCanceled();
+		indicator.setIndeterminate(false);
+		indicator.setFraction(0d);
+		
+		final List<SaveCommand> saveCommands = processorsEligible.stream()
 			.filter(Objects::nonNull)
-			.peek(command -> LOGGER.info(String.format("Execute command %s on %d files", command, psiFiles.size())))
-			.map(command -> new SimpleEntry<>(command.getAction(), command.execute()))
+			.toList();
+		
+		final AtomicInteger executedCount = new AtomicInteger();
+		final List<SimpleEntry<Action, Result<ResultCode>>> results = saveCommands.stream()
+			.map(command -> {
+				LOGGER.info(String.format("Execute command %s on %d files", command, psiFilesEligible.size()));
+				
+				indicator.checkCanceled();
+				indicator.setText2("Executing '" + command.getAction().getText() + "'");
+				
+				final SimpleEntry<Action, Result<ResultCode>> entry =
+					new SimpleEntry<>(command.getAction(), command.execute());
+				
+				indicator.setFraction((double)executedCount.incrementAndGet() / saveCommands.size());
+				
+				return entry;
+			})
 			.toList();
 		LOGGER.info(String.format("Exit engine with results %s", results.stream()
 			.map(entry -> entry.getKey() + ":" + entry.getValue())

src/main/java/software/xdev/saveactions/core/listener/SaveActionsDocumentManagerListener.java

@@ -5,7 +5,9 @@
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
+import com.intellij.openapi.application.ApplicationInfo;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
@@ -40,6 +42,13 @@ public void beforeAllDocumentsSaving()
 	{
 		LOGGER.debug(
 			"[+] Start SaveActionsDocumentManagerListener#beforeAllDocumentsSaving, " + this.project.getName());
+		
+		if(REQUIRES_PROJECT_LOAD_IGNORE_WORKAROUND && isInvokedFromProjectLoadBefore243())
+		{
+			LOGGER.debug("Ignoring due to PROJECT_LOAD_IGNORE_WORKAROUND");
+			return;
+		}
+		
 		final List<Document> unsavedDocuments = Arrays.asList(FileDocumentManager.getInstance().getUnsavedDocuments());
 		if(!unsavedDocuments.isEmpty())
 		{
@@ -74,4 +83,38 @@ private synchronized void initPsiDocManager()
 			this.psiDocumentManager = PsiDocumentManager.getInstance(this.project);
 		}
 	}
+	
+	// region PROJECT_LOAD_IGNORE_WORKAROUND
+	// https://github.com/xdev-software/intellij-plugin-save-actions/issues/145
+	private static final boolean REQUIRES_PROJECT_LOAD_IGNORE_WORKAROUND =
+		determineIfRequiresProjectLoadIgnoreWorkaround();
+	
+	@SuppressWarnings("checkstyle:MagicNumber")
+	static boolean determineIfRequiresProjectLoadIgnoreWorkaround()
+	{
+		try
+		{
+			// Problem was fixed in 2024.3
+			return ApplicationInfo.getInstance().getBuild().getBaselineVersion() < 243;
+		}
+		catch(final Exception ex)
+		{
+			LOGGER.warn("Failed to determine IDE version", ex);
+			return false;
+		}
+	}
+	
+	@SuppressWarnings("checkstyle:MagicNumber")
+	static boolean isInvokedFromProjectLoadBefore243()
+	{
+		// The invoking method ProjectSettingsTracker$submitSettingsFilesRefresh is usually at index 17 and 18
+		return Stream.of(Thread.currentThread().getStackTrace())
+			.map(StackTraceElement::getClassName)
+			.skip(16)
+			.limit(5)
+			.anyMatch(s -> s.startsWith(
+				"com.intellij.openapi.externalSystem.autoimport.ProjectSettingsTracker$submitSettingsFilesRefresh"));
+	}
+	
+	// endregion
 }

src/main/java/software/xdev/saveactions/core/service/SaveActionsService.java

@@ -18,7 +18,6 @@
  */
 public interface SaveActionsService
 {
-	
 	void guardedProcessPsiFiles(Project project, Set<PsiFile> psiFiles, Action activation, ExecutionMode mode);
 
 	boolean isJavaAvailable();

src/main/java/software/xdev/saveactions/core/service/impl/AbstractSaveActionsService.java

@@ -12,19 +12,26 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.stream.Stream;
 
+import org.jetbrains.annotations.NotNull;
+
 import com.intellij.openapi.actionSystem.ex.QuickList;
 import com.intellij.openapi.actionSystem.ex.QuickListsManager;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.progress.EmptyProgressIndicator;
+import com.intellij.openapi.progress.ProgressIndicator;
+import com.intellij.openapi.progress.Task;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
 
 import software.xdev.saveactions.core.ExecutionMode;
 import software.xdev.saveactions.core.component.Engine;
 import software.xdev.saveactions.core.service.SaveActionsService;
 import software.xdev.saveactions.model.Action;
+import software.xdev.saveactions.model.Storage;
 import software.xdev.saveactions.model.StorageFactory;
 import software.xdev.saveactions.processors.Processor;
 
@@ -34,8 +41,8 @@
  * implementations by default.
  * <p>
  * The main method is {@link #guardedProcessPsiFiles(Project, Set, Action, ExecutionMode)} and will delegate to
- * {@link Engine#processPsiFilesIfNecessary()}. The method will check if the file needs to be processed and uses the
- * processors to apply the modifications.
+ * {@link Engine#processPsiFilesIfNecessary(ProgressIndicator, boolean)} ()}.
+ * The method will check if the file needs to be processed and uses the processors to apply the modifications.
  * <p>
  * The psi files are ide wide, that means they are shared between projects (and editor windows), so we need to check if
  * the file is physically in that project before reformatting, or else the file is formatted twice and intellij will ask
@@ -52,6 +59,8 @@ abstract class AbstractSaveActionsService implements SaveActionsService
 	private final boolean javaAvailable;
 	private final boolean compilingAvailable;
 
+	private final ReentrantLock guardedProcessPsiFilesLock = new ReentrantLock();
+	
 	protected AbstractSaveActionsService(final StorageFactory storageFactory)
 	{
 		LOGGER.info("Save Actions Service \"" + this.getClass().getSimpleName() + "\" initialized.");
@@ -62,7 +71,7 @@ protected AbstractSaveActionsService(final StorageFactory storageFactory)
 	}
 
 	@Override
-	public synchronized void guardedProcessPsiFiles(
+	public void guardedProcessPsiFiles(
 		final Project project,
 		final Set<PsiFile> psiFiles,
 		final Action activation,
@@ -73,10 +82,49 @@ public synchronized void guardedProcessPsiFiles(
 			LOGGER.info("Application is closing, stopping invocation");
 			return;
 		}
+		
+		final Storage storage = this.storageFactory.getStorage(project);
 		final Engine engine = new Engine(
-			this.storageFactory.getStorage(project), this.processors, project, psiFiles, activation,
+			storage,
+			this.processors,
+			project,
+			psiFiles,
+			activation,
 			mode);
-		engine.processPsiFilesIfNecessary();
+		
+		final boolean applyAsync = storage.getActions().contains(Action.processAsync);
+		if(applyAsync)
+		{
+			new Task.Backgroundable(project, "Applying Save Actions", true)
+			{
+				@Override
+				public void run(@NotNull final ProgressIndicator indicator)
+				{
+					AbstractSaveActionsService.this.processPsiFilesIfNecessaryWithLock(engine, indicator);
+				}
+			}.queue();
+			return;
+		}
+		
+		this.processPsiFilesIfNecessaryWithLock(engine, null);
+	}
+	
+	private void processPsiFilesIfNecessaryWithLock(final Engine engine, final ProgressIndicator indicator)
+	{
+		LOGGER.trace("Getting lock");
+		this.guardedProcessPsiFilesLock.lock();
+		LOGGER.trace("Got lock");
+		try
+		{
+			engine.processPsiFilesIfNecessary(
+				indicator != null ? indicator : new EmptyProgressIndicator(),
+				indicator != null);
+		}
+		finally
+		{
+			this.guardedProcessPsiFilesLock.unlock();
+			LOGGER.trace("Released lock");
+		}
 	}
 
 	@Override