Add simple JVM-based JSON formatter

Currenly, if consumers of Spotless want to format their JSON files, they
need to do this by adding `prettier`, which increases the dependencies a
project needs.

To simplify things for consumers, as documented in diffplug#850, we can provide
a JVM-based JSON formatter, using `org.json`'s JSON formatting.

To follow how we've done this with other formatters, we can retrieve
`org.json`'s JAR at runtime, and retrieve the classes via Reflection,
instead of adding this as a `lib-extra` project, with an explicit
dependency.

To validate this fully, we want a few straightforward JSON files to
validate before/after, but we can also use [a sample Cucumber JSON
report] as a much more complex example of what happens, which we've
removed any `data` objects from its source, so the files are smaller.

We also want our consumers to be able to configure the indentation size.

We're calling this a `simple` formatter as it doesn't allow much to be
configured other than the indentation size in spaces.

[a sample Cucumber JSON report]: https://github.com/damianszczepanik/cucumber-reporting/raw/master/src/test/resources/json/sample.json

lib/src/main/java/com/diffplug/spotless/json/JsonSimpleStep.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2021 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.json;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Objects;
+
+import com.diffplug.spotless.FormatterFunc;
+import com.diffplug.spotless.FormatterStep;
+import com.diffplug.spotless.JarState;
+import com.diffplug.spotless.Provisioner;
+
+/**
+ * Simple JSON formatter which reformats the file according to the org.json library's default pretty-printing, but has no ability to customise more than the indentation size.
+ */
+public final class JsonSimpleStep {
+	private static final String MAVEN_COORDINATE = "org.json:json:";
+	private static final String DEFAULT_VERSION = "20210307";
+
+	public static FormatterStep create(int indent, Provisioner provisioner) {
+		Objects.requireNonNull(provisioner, "provisioner cannot be null");
+		return FormatterStep.createLazy("json", () -> new State(indent, provisioner), State::toFormatter);
+	}
+
+	private static final class State implements Serializable {
+		private static final long serialVersionUID = 1L;
+
+		private final int indentSpaces;
+		private final JarState jarState;
+
+		private State(int indent, Provisioner provisioner) throws IOException {
+			this.indentSpaces = indent;
+			this.jarState = JarState.from(MAVEN_COORDINATE + DEFAULT_VERSION, provisioner);
+		}
+
+		FormatterFunc toFormatter() {
+			Method objectToString;
+			Method arrayToString;
+			Constructor<?> objectConstructor;
+			Constructor<?> arrayConstructor;
+			try {
+				ClassLoader classLoader = jarState.getClassLoader();
+				Class<?> jsonObject = classLoader.loadClass("org.json.JSONObject");
+				Class<?>[] constructorArguments = new Class[]{String.class};
+				objectConstructor = jsonObject.getConstructor(constructorArguments);
+				objectToString = jsonObject.getMethod("toString", int.class);
+
+				Class<?> jsonArray = classLoader.loadClass("org.json.JSONArray");
+				arrayConstructor = jsonArray.getConstructor(constructorArguments);
+				arrayToString = jsonArray.getMethod("toString", int.class);
+			} catch (ClassNotFoundException | NoSuchMethodException e) {
+				throw new IllegalStateException("There was a problem preparing org.json dependencies", e);
+			}
+
+			return s -> {
+				String prettyPrinted = null;
+				if (s.isEmpty()) {
+					prettyPrinted = s;
+				}
+				if (s.startsWith("{")) {
+					try {
+						Object parsed = objectConstructor.newInstance(s);
+						prettyPrinted = objectToString.invoke(parsed, indentSpaces) + "\n";
+					} catch (InvocationTargetException ignored) {
+						// ignore if we cannot convert to JSON string
+					}
+				}
+				if (s.startsWith("[")) {
+					try {
+						Object parsed = arrayConstructor.newInstance(s);
+						prettyPrinted = arrayToString.invoke(parsed, indentSpaces) + "\n";
+					} catch (InvocationTargetException ignored) {
+						// ignore if we cannot convert to JSON string
+					}
+				}
+
+				if (prettyPrinted == null) {
+					throw new AssertionError("Invalid JSON file provided");
+				}
+
+				return prettyPrinted;
+			};
+		}
+	}
+
+	private JsonSimpleStep() {
+		// cannot be directly instantiated
+	}
+}

lib/src/main/java/com/diffplug/spotless/json/package-info.java

@@ -0,0 +1,7 @@
+@ParametersAreNonnullByDefault
+@ReturnValuesAreNonnullByDefault
+package com.diffplug.spotless.extra.json.java;
+
+import javax.annotation.ParametersAreNonnullByDefault;
+
+import com.diffplug.spotless.annotations.ReturnValuesAreNonnullByDefault;