Replace FormatExceptionPolicyStrict with List<LintSuppresion>

Author: nedtwigg

lib/src/main/java/com/diffplug/spotless/FormatExceptionPolicyStrict.java

@@ -189,4 +189,28 @@ private static String msgFrom(String message) {
 	}
 
 	public static final int LINE_UNDEFINED = -1;
+
+	public void addWarningMessageTo(StringBuilder buffer, String stepName, boolean oneLine) {
+		if (lineStart == Lint.LINE_UNDEFINED) {
+			buffer.append("LINE_UNDEFINED");
+		} else {
+			buffer.append("L");
+			buffer.append(lineStart);
+			if (lineEnd != lineStart) {
+				buffer.append("-").append(lineEnd);
+			}
+		}
+		buffer.append(" ");
+		buffer.append(stepName).append("(").append(ruleId).append(") ");
+
+		int firstNewline = detail.indexOf('\n');
+		if (firstNewline == -1) {
+			buffer.append(detail);
+		} else if (oneLine) {
+			buffer.append(detail, 0, firstNewline);
+			buffer.append(" (...)");
+		} else {
+			buffer.append(detail);
+		}
+	}
 }

lib/src/main/java/com/diffplug/spotless/Lint.java

@@ -21,23 +21,15 @@
 import org.slf4j.LoggerFactory;
 
 class LintPolicy {
-	private static final Logger logger = LoggerFactory.getLogger(Formatter.class);
-
-	static void error(Throwable e, FormatterStep step, String relativePath) {
-		logger.error("Step '{}' found problem in '{}':\n{}", step.getName(), relativePath, e.getMessage(), e);
-	}
-
-	static void warning(Throwable e, FormatterStep step, String relativePath) {
-		logger.warn("Unable to apply step '{}' to '{}'", step.getName(), relativePath, e);
-	}
-
 	static void legacyBehavior(Formatter formatter, File file, ValuePerStep<Throwable> exceptionPerStep) {
 		for (int i = 0; i < formatter.getSteps().size(); ++i) {
 			Throwable exception = exceptionPerStep.get(i);
 			if (exception != null && exception != LintState.formatStepCausedNoChange()) {
-				LintPolicy.error(exception, formatter.getSteps().get(i), file.getName());
+				logger.error("Step '{}' found problem in '{}':\n{}", formatter.getSteps().get(i), file.getName(), exception.getMessage(), exception);
 				throw ThrowingEx.asRuntimeRethrowError(exception);
 			}
 		}
 	}
+
+	private static final Logger logger = LoggerFactory.getLogger(Formatter.class);
 }

lib/src/main/java/com/diffplug/spotless/LintPolicy.java

@@ -18,9 +18,9 @@
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
+import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Map;
 
 import javax.annotation.Nullable;
 
@@ -45,23 +45,49 @@ public boolean isClean() {
 		return dirtyState.isClean() && !isHasLints();
 	}
 
-	public Map<FormatterStep, List<Lint>> getLints(Formatter formatter) {
+	public LinkedHashMap<String, List<Lint>> getLintsByStep(Formatter formatter) {
 		if (lintsPerStep == null) {
 			throw new IllegalStateException("Check `isHasLints` first!");
 		}
 		if (lintsPerStep.size() != formatter.getSteps().size()) {
 			throw new IllegalStateException("LintState was created with a different formatter!");
 		}
-		Map<FormatterStep, List<Lint>> result = new LinkedHashMap<>();
+		LinkedHashMap<String, List<Lint>> result = new LinkedHashMap<>();
 		for (int i = 0; i < lintsPerStep.size(); i++) {
+			FormatterStep step = formatter.getSteps().get(i);
 			List<Lint> lints = lintsPerStep.get(i);
 			if (lints != null) {
-				result.put(formatter.getSteps().get(i), lints);
+				result.put(step.getName(), lints);
 			}
 		}
 		return result;
 	}
 
+	public void removeSuppressedLints(Formatter formatter, String relativePath, List<LintSuppression> suppressions) {
+		if (lintsPerStep == null) {
+			return;
+		}
+		for (int i = 0; i < lintsPerStep.size(); i++) {
+			FormatterStep step = formatter.getSteps().get(i);
+			List<Lint> lints = lintsPerStep.get(i);
+			if (lints != null) {
+				Iterator<Lint> iter = lints.iterator();
+				while (iter.hasNext()) {
+					Lint lint = iter.next();
+					for (LintSuppression suppression : suppressions) {
+						if (suppression.suppresses(relativePath, step, lint)) {
+							iter.remove();
+							break;
+						}
+					}
+				}
+				if (lints.isEmpty()) {
+					lintsPerStep.set(i, null);
+				}
+			}
+		}
+	}
+
 	public String asStringDetailed(File file, Formatter formatter) {
 		return asString(file, formatter, false);
 	}
@@ -81,27 +107,7 @@ private String asString(File file, Formatter formatter, boolean oneLine) {
 					FormatterStep step = formatter.getSteps().get(i);
 					for (Lint lint : lints) {
 						result.append(file.getName()).append(":");
-						if (lint.getLineStart() == Lint.LINE_UNDEFINED) {
-							result.append("LINE_UNDEFINED");
-						} else {
-							result.append("L");
-							result.append(lint.getLineStart());
-							if (lint.getLineEnd() != lint.getLineStart()) {
-								result.append("-").append(lint.getLineEnd());
-							}
-						}
-						result.append(" ");
-						result.append(step.getName()).append("(").append(lint.getRuleId()).append(") ");
-
-						int firstNewline = lint.getDetail().indexOf('\n');
-						if (firstNewline == -1) {
-							result.append(lint.getDetail());
-						} else if (oneLine) {
-							result.append(lint.getDetail(), 0, firstNewline);
-							result.append(" (...)");
-						} else {
-							result.append(lint.getDetail());
-						}
+						lint.addWarningMessageTo(result, step.getName(), oneLine);
 						result.append("\n");
 					}
 				}

lib/src/main/java/com/diffplug/spotless/LintState.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2024 DiffPlug
+ *
+ * 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.diffplug.spotless;
+
+import java.util.Objects;
+
+public class LintSuppression implements java.io.Serializable {
+	private static final long serialVersionUID = 1L;
+
+	private static final String ALL = "*";
+	private String file = ALL;
+	private String step = ALL;
+	private String shortCode = ALL;
+
+	public String getFile() {
+		return file;
+	}
+
+	public void setFile(String file) {
+		this.file = Objects.requireNonNull(file);
+	}
+
+	public String getStep() {
+		return step;
+	}
+
+	public void setStep(String step) {
+		this.step = Objects.requireNonNull(step);
+	}
+
+	public String getShortCode() {
+		return shortCode;
+	}
+
+	public void setShortCode(String shortCode) {
+		this.shortCode = Objects.requireNonNull(shortCode);
+	}
+
+	public boolean suppresses(String relativePath, FormatterStep step, Lint lint) {
+		return !allows(relativePath, step, lint);
+	}
+
+	private boolean allows(String relativePath, FormatterStep step, Lint lint) {
+		if (!file.equals(ALL) && !file.equals(relativePath)) {
+			return false;
+		}
+		if (!this.step.equals(ALL) && !this.step.equals(step.getName())) {
+			return false;
+		}
+		if (!this.shortCode.equals(ALL) && !this.shortCode.equals(lint.getRuleId())) {
+			return false;
+		}
+		return true;
+	}
+
+	public void ensureDoesNotSuppressAll() {
+		boolean suppressAll = file.equals(ALL) && step.equals(ALL) && shortCode.equals(ALL);
+		if (suppressAll) {
+			throw new IllegalArgumentException("You must specify a specific `file`, `step`, or `shortCode`.");
+		}
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o)
+			return true;
+		if (o == null || getClass() != o.getClass())
+			return false;
+		LintSuppression that = (LintSuppression) o;
+		return Objects.equals(file, that.file) && Objects.equals(step, that.step) && Objects.equals(shortCode, that.shortCode);
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(file, step, shortCode);
+	}
+
+	@Override
+	public String toString() {
+		return "LintSuppression{" +
+				"file='" + file + '\'' +
+				", step='" + step + '\'' +
+				", code='" + shortCode + '\'' +
+				'}';
+	}
+}

lib/src/main/java/com/diffplug/spotless/LintSuppression.java

@@ -49,11 +49,11 @@
 import org.gradle.util.GradleVersion;
 
 import com.diffplug.common.base.Preconditions;
-import com.diffplug.spotless.FormatExceptionPolicyStrict;
 import com.diffplug.spotless.FormatterFunc;
 import com.diffplug.spotless.FormatterStep;
 import com.diffplug.spotless.LazyForwardingEquality;
 import com.diffplug.spotless.LineEnding;
+import com.diffplug.spotless.LintSuppression;
 import com.diffplug.spotless.OnMatch;
 import com.diffplug.spotless.Provisioner;
 import com.diffplug.spotless.SerializedFunction;
@@ -168,16 +168,25 @@ public void setEncoding(Charset charset) {
 		encoding = requireNonNull(charset);
 	}
 
-	final FormatExceptionPolicyStrict exceptionPolicy = new FormatExceptionPolicyStrict();
+	final List<LintSuppression> lintSuppressions = new ArrayList<>();
+
+	public void suppressLintsFor(Action<LintSuppression> lintSuppression) {
+		LintSuppression suppression = new LintSuppression();
+		lintSuppression.execute(suppression);
+		suppression.ensureDoesNotSuppressAll();
+		lintSuppressions.add(suppression);
+	}
 
 	/** Ignores errors in the given step. */
+	@Deprecated
 	public void ignoreErrorForStep(String stepName) {
-		exceptionPolicy.excludeStep(requireNonNull(stepName));
+		suppressLintsFor(it -> it.setStep(stepName));
 	}
 
 	/** Ignores errors for the given relative path. */
+	@Deprecated
 	public void ignoreErrorForPath(String relativePath) {
-		exceptionPolicy.excludePath(requireNonNull(relativePath));
+		suppressLintsFor(it -> it.setFile(relativePath));
 	}
 
 	/**
@@ -996,7 +1005,7 @@ public void toggleOffOnDisable() {
 	/** Sets up a format task according to the values in this extension. */
 	protected void setupTask(SpotlessTask task) {
 		task.setEncoding(getEncoding().name());
-		task.setExceptionPolicy(exceptionPolicy);
+		task.setLintSuppressions(lintSuppressions);
 		FileCollection totalTarget = targetExclude == null ? target : target.minus(targetExclude);
 		task.setTarget(totalTarget);
 		List<FormatterStep> steps;

plugin-gradle/src/main/java/com/diffplug/gradle/spotless/FormatExtension.java

@@ -20,6 +20,7 @@
 import java.nio.file.Files;
 import java.nio.file.StandardCopyOption;
 
+import org.gradle.api.GradleException;
 import org.gradle.api.file.ConfigurableFileTree;
 import org.gradle.api.file.FileVisitDetails;
 import org.gradle.api.file.FileVisitor;
@@ -30,7 +31,8 @@ public abstract class SpotlessApply extends SpotlessTaskService.ClientTask {
 	public void performAction() {
 		getTaskService().get().registerApplyAlreadyRan(this);
 		ConfigurableFileTree cleanFiles = getConfigCacheWorkaround().fileTree().from(getSpotlessCleanDirectory().get());
-		if (cleanFiles.isEmpty()) {
+		ConfigurableFileTree lintsFiles = getConfigCacheWorkaround().fileTree().from(getSpotlessLintsDirectory().get());
+		if (cleanFiles.isEmpty() && lintsFiles.isEmpty()) {
 			getState().setDidWork(sourceDidWork());
 		} else {
 			cleanFiles.visit(new FileVisitor() {
@@ -51,6 +53,10 @@ public void visitFile(FileVisitDetails fileVisitDetails) {
 					}
 				}
 			});
+			if (!lintsFiles.isEmpty()) {
+				boolean detailed = false;
+				throw new GradleException(super.allLintsErrorMsgDetailed(lintsFiles, detailed));
+			}
 		}
 	}
 }