Initial version of Spotless Maven plugin

plugin-gradle/src/test/java/com/diffplug/gradle/spotless/GradleIntegrationTest.java

@@ -37,6 +37,20 @@
 import com.diffplug.spotless.ResourceHarness;
 
 public class GradleIntegrationTest extends ResourceHarness {
+	/**
+	 * Each test gets its own temp folder, and we create a gradle
+	 * build there and run it.
+	 *
+	 * Because those test folders don't have a .gitattributes file,
+	 * git (on windows) will default to \r\n. So now if you read a
+	 * test file from the spotless test resources, and compare it
+	 * to a build result, the line endings won't match.
+	 *
+	 * By sticking this .gitattributes file into the test directory,
+	 * we ensure that the default Spotless line endings policy of
+	 * GIT_ATTRIBUTES will use \n, so that tests match the test
+	 * resources on win and linux.
+	 */
 	@Before
 	public void gitAttributes() throws IOException {
 		write(".gitattributes", "* text eol=lf");

plugin-maven/src/test/java/com/diffplug/gradle/spotless/EclipseFormatStepTest.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2016 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.gradle.spotless;
+
+import java.io.IOException;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Ignore;
+import org.junit.Test;
+
+/**
+ * This test is ignored because it doesn't work.
+ * To make it work, we'll need something like the following:
+ *
+ * build.gradle
+ *     task publishTestToLocalRepo()
+ *     test.dependsOn(publishTestToLocalRepo)
+ *
+ * Then in MavenIntegratonTest.POM_HEADER, set <pluginRepositories> appropriately
+ *
+ * Would also be good if we had mvnw setup, so that
+ * the test harness used mvnw to control the verison
+ * of maven that was used.
+ */
+@Ignore
+public class EclipseFormatStepTest extends MavenIntegrationTest {
+	@Test
+	public void testEclipse() throws IOException, InterruptedException {
+		// write the pom
+		writePomJavaSteps(
+				"<eclipse>",
+				"  <file>${basedir}/eclipse-fmt.xml</file>",
+				"  <version>4.7.1</version>",
+				"</eclipse>");
+		write("src/main/java/test.java", getTestResource("java/eclipse/format/JavaCodeUnformatted.test"));
+		mavenRunner().withArguments("spotless:apply").runNoError();
+
+		String actual = read("src/main/java/test.java");
+		Assertions.assertThat(actual).isEqualTo(getTestResource("java/eclipse/format/JavaCodeFormatted.test"));
+	}
+}

plugin-maven/src/test/java/com/diffplug/gradle/spotless/MavenIntegrationTest.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2016 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.gradle.spotless;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+import org.junit.Before;
+
+import com.diffplug.spotless.ResourceHarness;
+
+public class MavenIntegrationTest extends ResourceHarness {
+	/**
+	 * Each test gets its own temp folder, and we create a maven
+	 * build there and run it.
+	 *
+	 * Because those test folders don't have a .gitattributes file,
+	 * git on windows will default to \r\n. So now if you read a
+	 * test file from the spotless test resources, and compare it
+	 * to a build result, the line endings won't match.
+	 *
+	 * By sticking this .gitattributes file into the test directory,
+	 * we ensure that the default Spotless line endings policy of
+	 * GIT_ATTRIBUTES will use \n, so that tests match the test
+	 * resources on win and linux.
+	 */
+	@Before
+	public void gitAttributes() throws IOException {
+		write(".gitattributes", "* text eol=lf");
+	}
+
+	private static final String POM_HEADER = "" +
+			"<project>\n" +
+			"  <modelVersion>4.0.0</modelVersion>\n" +
+			"  <repositories>\n" +
+			"    <repository>\n" +
+			"      <id>central</id>\n" +
+			"      <name>Central Repository</name>\n" +
+			"      <url>http://repo.maven.apache.org/maven2</url>\n" +
+			"      <layout>default</layout>\n" +
+			"      <snapshots>\n" +
+			"        <enabled>false</enabled>\n" +
+			"      </snapshots>\n" +
+			"    </repository>\n" +
+			"  </repositories>\n" +
+			"  <pluginRepositories>\n" + // TODO: setup test so that the plugin gets compiled first, and put into this repository
+			"    <pluginRepository>\n" +
+			"      <id>central</id>\n" +
+			"      <name>Central Repository</name>\n" +
+			"      <url>http://repo.maven.apache.org/maven2</url>\n" +
+			"      <layout>default</layout>\n" +
+			"      <snapshots>\n" +
+			"        <enabled>false</enabled>\n" +
+			"      </snapshots>\n" +
+			"      <releases>\n" +
+			"        <updatePolicy>never</updatePolicy>\n" +
+			"      </releases>\n" +
+			"    </pluginRepository>\n" +
+			"  </pluginRepositories>\n" +
+			"  <build>\n" +
+			"    <plugins>\n" +
+			"      <plugin>\n" +
+			"        <groupId>com.diffplug.spotless</groupId>\n" +
+			"        <artifactId>spotless-maven-plugin</artifactId>\n" +
+			"        <version>+</version>\n" +
+			"        <configuration>\n";
+
+	private static final String POM_FOOTER = "" +
+			"        </configuration>\n" +
+			"      </plugin>\n" +
+			"    </plugins>\n" +
+			"  </build>\n" +
+			"</project>\n";
+
+	protected void writePomJavaSteps(String... steps) throws IOException {
+		write("pom.xml",
+				POM_HEADER,
+				"<java><steps>",
+				Arrays.stream(steps).collect(Collectors.joining("\n")),
+				"</steps></java>",
+				POM_FOOTER);
+	}
+
+	protected MavenRunner mavenRunner() throws IOException {
+		return MavenRunner.create()
+				.withProjectDir(rootFolder());
+	}
+}

plugin-maven/src/test/java/com/diffplug/gradle/spotless/MavenRunner.java

@@ -0,0 +1,155 @@
+/*
+ * Copyright 2016 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.gradle.spotless;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import org.assertj.core.api.Assertions;
+
+import com.diffplug.common.base.Throwables;
+
+/**
+ * Harness for running a maven build, same idea as the
+ * [GradleRunner from the gradle testkit](https://docs.gradle.org/current/javadoc/org/gradle/testkit/runner/GradleRunner.html).
+ */
+public class MavenRunner {
+	public static MavenRunner create() {
+		return new MavenRunner();
+	}
+
+	private MavenRunner() {}
+
+	private File projectDir;
+	private String[] args;
+
+	public MavenRunner withProjectDir(File projectDir) {
+		this.projectDir = Objects.requireNonNull(projectDir);
+		return this;
+	}
+
+	public MavenRunner withArguments(String... args) {
+		this.args = Objects.requireNonNull(args);
+		return this;
+	}
+
+	private Result run() throws IOException, InterruptedException {
+		Objects.requireNonNull(projectDir, "Need to call withProjectDir() first");
+		Objects.requireNonNull(args, "Need to call withArguments() first");
+		// run maven with the given args in the given directory
+		List<String> cmds = getPlatformCmds("mvn " + Arrays.stream(args).collect(Collectors.joining(" ")));
+		ProcessBuilder builder = new ProcessBuilder(cmds);
+		builder.directory(projectDir);
+		Process process = builder.start();
+		// slurp and return the stdout, stderr, and exitValue
+		Slurper output = new Slurper(process.getInputStream());
+		Slurper error = new Slurper(process.getErrorStream());
+		int exitValue = process.waitFor();
+		output.join();
+		error.join();
+		return new Result(exitValue, output.result(), error.result());
+	}
+
+	/** Runs the command and asserts that nothing was printed to stderr. */
+	public Result runNoError() throws IOException, InterruptedException {
+		Result result = run();
+		Assertions.assertThat(result.error()).isEmpty();
+		return result;
+	}
+
+	/** Runs the command and asserts that something was printed to stderr. */
+	public Result runHasError() throws IOException, InterruptedException {
+		Result result = run();
+		Assertions.assertThat(result.error()).isNotEmpty();
+		return result;
+	}
+
+	public static class Result {
+		private final int exitValue;
+		private final String output;
+		private final String error;
+
+		public Result(int exitValue, String output, String error) {
+			super();
+			this.exitValue = exitValue;
+			this.output = Objects.requireNonNull(output);
+			this.error = Objects.requireNonNull(error);
+		}
+
+		public int exitValue() {
+			return exitValue;
+		}
+
+		public String output() {
+			return output;
+		}
+
+		public String error() {
+			return error;
+		}
+	}
+
+	/** Prepends any arguments necessary to run a console command. */
+	private static List<String> getPlatformCmds(String cmd) {
+		if (isWin()) {
+			return Arrays.asList("cmd", "/c", cmd);
+		} else {
+			return Arrays.asList("/bin/sh", "-c", cmd);
+		}
+	}
+
+	private static boolean isWin() {
+		String os_name = System.getProperty("os.name").toLowerCase(Locale.getDefault());
+		return os_name.contains("win");
+	}
+
+	private static class Slurper extends Thread {
+		private final InputStream input;
+		private volatile String result;
+
+		Slurper(InputStream input) {
+			this.input = Objects.requireNonNull(input);
+			start();
+		}
+
+		@Override
+		public void run() {
+			try {
+				ByteArrayOutputStream output = new ByteArrayOutputStream();
+				byte[] buffer = new byte[1024];
+				int numRead;
+				while ((numRead = input.read(buffer)) != -1) {
+					output.write(buffer, 0, numRead);
+				}
+				result = output.toString(Charset.defaultCharset().name());
+			} catch (Exception e) {
+				result = Throwables.getStackTraceAsString(e);
+			}
+		}
+
+		public String result() {
+			return result;
+		}
+	}
+}

plugin-maven/src/test/resources/java/eclipse/format/JavaCodeFormatted.test

@@ -0,0 +1,5 @@
+public class Java {
+    public static void main(String[] args) {
+        System.out.println("hello");
+    }
+}

plugin-maven/src/test/resources/java/eclipse/format/JavaCodeUnformatted.test

@@ -0,0 +1,5 @@
+public class Java {
+public static void main(String[] args) {
+System.out.println("hello");
+}
+}