Allow exclusions of specific spring checks

Closes gh-200

Author: philwebb

README.adoc

@@ -212,6 +212,22 @@ Spring Framework manually formats code, where as Spring Boot uses automatic form
 Formatting and Checkstyle alone are not enough to produce truly consistent code.
 Here are some tips that we've found useful when developing Spring Boot.
 
+==== Excluding specific checks
+If you want most `SpringChecks` but need to exclude one or two, you can do something like this in your `checkstyle.xml`:
+
+[source,xml,indent=0]
+----
+	<?xml version="1.0"?>
+	<!DOCTYPE module PUBLIC
+    		"-//Checkstyle//DTD Checkstyle Configuration 1.3//EN"
+    		"https://checkstyle.org/dtds/configuration_1_3.dtd">
+	<module name="com.puppycrawl.tools.checkstyle.Checker">
+		<module name="io.spring.javaformat.checkstyle.SpringChecks">
+			<property name="excludes" value="com.puppycrawl.tools.checkstyle.checks.imports.AvoidStaticImportCheck" />
+		</module>
+	</module>
+----
+
 ==== Disabling formatting for blocks of code
 Some code isn't particularly amenable to automatic formatting.
 For example, Spring Security configurations often work better when manually formatted.

spring-javaformat/spring-javaformat-checkstyle/src/main/java/io/spring/javaformat/checkstyle/FilteredModuleFactory.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2017-2019 the original author or authors.
+ *
+ * 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
+ *
+ *      https://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 io.spring.javaformat.checkstyle;
+
+import java.util.Set;
+
+import com.puppycrawl.tools.checkstyle.ModuleFactory;
+import com.puppycrawl.tools.checkstyle.TreeWalkerAuditEvent;
+import com.puppycrawl.tools.checkstyle.TreeWalkerFilter;
+import com.puppycrawl.tools.checkstyle.api.AbstractCheck;
+import com.puppycrawl.tools.checkstyle.api.CheckstyleException;
+
+class FilteredModuleFactory implements ModuleFactory {
+
+	private final ModuleFactory moduleFactory;
+
+	private final Set<String> excludes;
+
+	FilteredModuleFactory(ModuleFactory moduleFactory, Set<String> excludes) {
+		this.moduleFactory = moduleFactory;
+		this.excludes = excludes;
+	}
+
+	@Override
+	public Object createModule(String name) throws CheckstyleException {
+		Object module = this.moduleFactory.createModule(name);
+		if (module instanceof AbstractCheck) {
+			module = filter((AbstractCheck) module);
+		}
+		return module;
+	}
+
+	private Object filter(AbstractCheck check) {
+		if (this.excludes != null && this.excludes.contains(check.getClass().getName())) {
+			return new FilteredCheck(check);
+		}
+		return check;
+	}
+
+	static class FilteredCheck implements TreeWalkerFilter {
+
+		private final AbstractCheck check;
+
+		FilteredCheck(AbstractCheck check) {
+			this.check = check;
+		}
+
+		@Override
+		public boolean accept(TreeWalkerAuditEvent treeWalkerAuditEvent) {
+			return true;
+		}
+
+	}
+
+}

spring-javaformat/spring-javaformat-checkstyle/src/main/java/io/spring/javaformat/checkstyle/SpringChecks.java

@@ -17,7 +17,9 @@
 package io.spring.javaformat.checkstyle;
 
 import java.io.File;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.Properties;
 import java.util.Set;
@@ -61,6 +63,8 @@ public class SpringChecks extends AbstractFileSetCheck implements ExternalResour
 
 	private String projectRootPackage = SpringImportOrderCheck.DEFAULT_PROJECT_ROOT_PACKAGE;
 
+	private Set<String> excludes;
+
 	/**
 	 * Sets classLoader to load class.
 	 * @param classLoader class loader to resolve classes with.
@@ -79,18 +83,18 @@ public void setModuleFactory(ModuleFactory moduleFactory) {
 
 	@Override
 	public void finishLocalSetup() {
+		ModuleFactory moduleFactory = new FilteredModuleFactory(this.moduleFactory, this.excludes);
 		DefaultContext context = new DefaultContext();
 		context.add("classLoader", this.classLoader);
 		context.add("severity", getSeverity());
 		context.add("tabWidth", String.valueOf(getTabWidth()));
-		context.add("moduleFactory", this.moduleFactory);
+		context.add("moduleFactory", moduleFactory);
 		Properties properties = new Properties();
 		put(properties, "headerType", this.headerType);
 		put(properties, "headerCopyrightPattern", this.headerCopyrightPattern);
 		put(properties, "headerFile", this.headerFile);
 		put(properties, "projectRootPackage", this.projectRootPackage);
-		this.checks = new SpringConfigurationLoader(context, this.moduleFactory)
-				.load(new PropertiesExpander(properties));
+		this.checks = new SpringConfigurationLoader(context, moduleFactory).load(new PropertiesExpander(properties));
 	}
 
 	private void put(Properties properties, String name, Object value) {
@@ -153,4 +157,8 @@ public void setProjectRootPackage(String projectRootPackage) {
 		this.projectRootPackage = projectRootPackage;
 	}
 
+	public void setExcludes(String... excludes) {
+		this.excludes = new HashSet<>(Arrays.asList(excludes));
+	}
+
 }

spring-javaformat/spring-javaformat-checkstyle/src/test/java/io/spring/javaformat/checkstyle/SpringConfigurationLoaderTests.java

@@ -17,14 +17,18 @@
 package io.spring.javaformat.checkstyle;
 
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Properties;
+import java.util.Set;
 
 import com.puppycrawl.tools.checkstyle.DefaultContext;
 import com.puppycrawl.tools.checkstyle.ModuleFactory;
 import com.puppycrawl.tools.checkstyle.PackageObjectFactory;
 import com.puppycrawl.tools.checkstyle.PropertiesExpander;
 import com.puppycrawl.tools.checkstyle.PropertyResolver;
+import com.puppycrawl.tools.checkstyle.TreeWalker;
 import com.puppycrawl.tools.checkstyle.api.FileSetCheck;
+import org.assertj.core.extractor.Extractors;
 import org.junit.Test;
 
 import io.spring.javaformat.checkstyle.check.SpringHeaderCheck;
@@ -41,14 +45,34 @@ public class SpringConfigurationLoaderTests {
 
 	@Test
 	public void loadShouldLoadChecks() {
+		Collection<FileSetCheck> checks = load(null);
+		assertThat(checks).hasSize(3);
+		TreeWalker treeWalker = (TreeWalker) checks.toArray()[2];
+		Set<?> ordinaryChecks = (Set<?>) Extractors.byName("ordinaryChecks").extract(treeWalker);
+		assertThat(ordinaryChecks).hasSize(60);
+	}
+
+	@Test
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public void loadWithExcludeShouldExcludeChecks() {
+		Set<String> excludes = Collections
+				.singleton("com.puppycrawl.tools.checkstyle.checks.imports.AvoidStaticImportCheck");
+		Collection<FileSetCheck> checks = load(excludes);
+		assertThat(checks).hasSize(3);
+		TreeWalker treeWalker = (TreeWalker) checks.toArray()[2];
+		Set<?> ordinaryChecks = (Set<?>) Extractors.byName("ordinaryChecks").extract(treeWalker);
+		assertThat(ordinaryChecks).hasSize(59);
+	}
+
+	private Collection<FileSetCheck> load(Set<String> excludes) {
 		DefaultContext context = new DefaultContext();
-		context.add("moduleFactory",
-				new PackageObjectFactory(getClass().getPackage().getName(), getClass().getClassLoader()));
 		ModuleFactory moduleFactory = new PackageObjectFactory(getClass().getPackage().getName(),
 				getClass().getClassLoader());
+		moduleFactory = new FilteredModuleFactory(moduleFactory, excludes);
+		context.add("moduleFactory", moduleFactory);
 		Collection<FileSetCheck> checks = new SpringConfigurationLoader(context, moduleFactory)
 				.load(getPropertyResolver());
-		assertThat(checks).hasSize(3);
+		return checks;
 	}
 
 	private PropertyResolver getPropertyResolver() {