RDF Formatter Contribution

CHANGES.md

@@ -10,9 +10,10 @@ This document is intended for Spotless developers.
 We adhere to the [keepachangelog](https://keepachangelog.com/en/1.0.0/) format (starting after version `1.27.0`).
 
 ## [Unreleased]
+### Added
+* Support for `rdf` ([#2261](https://github.com/diffplug/spotless/pull/2261))
 ### Changed
 * Support configuring the Equo P2 cache. ([#2238](https://github.com/diffplug/spotless/pull/2238))
-
 * Add explicit support for JSONC / CSS via biome, via the file extensions `.css` and `.jsonc`. 
  ([#2259](https://github.com/diffplug/spotless/pull/2259))
 

README.md

@@ -103,6 +103,7 @@ lib('npm.TsFmtFormatterStep') +'{{yes}} | {{yes}}
 lib('pom.SortPomStep') +'{{yes}} | {{yes}} | {{no}} | {{no}} |',
 lib('protobuf.BufStep') +'{{yes}} | {{no}} | {{no}} | {{no}} |',
 lib('python.BlackStep') +'{{yes}} | {{no}} | {{no}} | {{no}} |',
+lib('rdf.RdfFormatterStep') +'{{no}} | {{yes}} | {{no}} | {{no}} |',
 lib('scala.ScalaFmtStep') +'{{yes}} | {{yes}} | {{yes}} | {{no}} |',
 lib('shell.ShfmtStep') +'{{yes}} | {{yes}} | {{no}} | {{no}} |',
 lib('sql.DBeaverSQLFormatterStep') +'{{yes}} | {{yes}} | {{yes}} | {{no}} |',
@@ -157,6 +158,7 @@ lib('yaml.JacksonYamlStep') +'{{yes}} | {{yes}}
 | [`pom.SortPomStep`](lib/src/main/java/com/diffplug/spotless/pom/SortPomStep.java) | :+1: | :+1: | :white_large_square: | :white_large_square: |
 | [`protobuf.BufStep`](lib/src/main/java/com/diffplug/spotless/protobuf/BufStep.java) | :+1: | :white_large_square: | :white_large_square: | :white_large_square: |
 | [`python.BlackStep`](lib/src/main/java/com/diffplug/spotless/python/BlackStep.java) | :+1: | :white_large_square: | :white_large_square: | :white_large_square: |
+| [`rdf.RdfFormatterStep`](lib/src/main/java/com/diffplug/spotless/rdf/RdfFormatterStep.java) | :white_large_square: | :+1: | :white_large_square: | :white_large_square: |
 | [`scala.ScalaFmtStep`](lib/src/main/java/com/diffplug/spotless/scala/ScalaFmtStep.java) | :+1: | :+1: | :+1: | :white_large_square: |
 | [`shell.ShfmtStep`](lib/src/main/java/com/diffplug/spotless/shell/ShfmtStep.java) | :+1: | :+1: | :white_large_square: | :white_large_square: |
 | [`sql.DBeaverSQLFormatterStep`](lib/src/main/java/com/diffplug/spotless/sql/DBeaverSQLFormatterStep.java) | :+1: | :+1: | :+1: | :white_large_square: |

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

@@ -165,7 +165,6 @@ public boolean isClean(File file) throws IOException {
 
 String raw = new String(Files.readAllBytes(file.toPath()), encoding);
 String unix = LineEnding.toUnix(raw);
-
 // check the newlines (we can find these problems without even running the steps)
 int totalNewLines = (int) unix.codePoints().filter(val -> val == '\n').count();
 int windowsNewLines = raw.length() - unix.length();
@@ -181,7 +180,6 @@ public boolean isClean(File file) throws IOException {
 
 // check the other formats
 String formatted = compute(unix, file);
-
 // return true iff the formatted string equals the unix one
 return formatted.equals(unix);
 }

lib/src/main/java/com/diffplug/spotless/rdf/RdfFormatterConfig.java

@@ -0,0 +1,106 @@
+/*
+ * 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.rdf;
+
+import java.io.Serializable;
+import java.util.Objects;
+
+public class RdfFormatterConfig implements Serializable {
+private static final long serialVersionUID = 1L;
+private boolean failOnWarning = true;
+private String turtleFormatterVersion = RdfFormatterStep.LATEST_TURTLE_FORMATTER_VERSION;
+private boolean verify = true;
+
+public RdfFormatterConfig() {}
+
+public void setFailOnWarning(boolean failOnWarning) {
+this.failOnWarning = failOnWarning;
+}
+
+public boolean isFailOnWarning() {
+return failOnWarning;
+}
+
+public boolean isVerify() {
+return verify;
+}
+
+public void setVerify(boolean verify) {
+this.verify = verify;
+}
+
+public static Builder builder() {
+return new Builder();
+}
+
+public String getTurtleFormatterVersion() {
+return turtleFormatterVersion;
+}
+
+public void setTurtleFormatterVersion(String turtleFormatterVersion) {
+this.turtleFormatterVersion = turtleFormatterVersion;
+}
+
+public static class Builder {
+RdfFormatterConfig config = new RdfFormatterConfig();
+
+public Builder() {}
+
+public Builder failOnWarning() {
+return this.failOnWarning(true);
+}
+
+public Builder failOnWarning(boolean fail) {
+this.config.setFailOnWarning(fail);
+return this;
+}
+
+public Builder turtleFormatterVersion(String version) {
+this.config.turtleFormatterVersion = version;
+return this;
+}
+
+public Builder verify(boolean verify) {
+this.config.verify = verify;
+return this;
+}
+
+public Builder verify() {
+this.config.verify = true;
+return this;
+}
+
+public RdfFormatterConfig build() {
+return config;
+}
+}
+
+@Override
+public boolean equals(Object o) {
+if (this == o)
+return true;
+if (!(o instanceof RdfFormatterConfig))
+return false;
+RdfFormatterConfig that = (RdfFormatterConfig) o;
+return isFailOnWarning() == that.isFailOnWarning()
+&& Objects.equals(turtleFormatterVersion, that.turtleFormatterVersion);
+}
+
+@Override
+public int hashCode() {
+return Objects.hash(isFailOnWarning(), turtleFormatterVersion);
+}
+}

lib/src/main/java/com/diffplug/spotless/rdf/RdfFormatterFunc.java

@@ -0,0 +1,165 @@
+/*
+ * 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.rdf;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import com.diffplug.spotless.FormatterFunc;
+import com.diffplug.spotless.LineEnding;
+
+public class RdfFormatterFunc implements FormatterFunc {
+private static final Set<String> TURTLE_EXTENSIONS = Set.of("ttl", "turtle");
+private static final Set<String> TRIG_EXTENSIONS = Set.of("trig");
+private static final Set<String> NTRIPLES_EXTENSIONS = Set.of("n-triples", "ntriples", "nt");
+private static final Set<String> NQUADS_EXTENSIONS = Set.of("n-quads", "nquads", "nq");
+
+private final RdfFormatterStep.State state;
+private final ReflectionHelper reflectionHelper;
+
+public RdfFormatterFunc(RdfFormatterStep.State state)
+throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+this.state = state;
+this.reflectionHelper = new ReflectionHelper(state);
+}
+
+@Override
+public String apply(String input) throws Exception {
+throw new UnsupportedOperationException("We need to know the filename so we can guess the RDF format. Use apply(String, File) instead!");
+}
+
+@Override
+public String apply(String rawUnix, File file) throws Exception {
+String filename = file.getName().toLowerCase(Locale.US);
+int lastDot = filename.lastIndexOf('.');
+if (lastDot < 0) {
+throw new IllegalArgumentException(
+String.format("File %s has no file extension, cannot determine RDF format", file.getAbsolutePath()));
+}
+if (lastDot + 1 >= filename.length()) {
+throw new IllegalArgumentException(
+String.format("File %s has no file extension, cannot determine RDF format", file.getAbsolutePath()));
+}
+String extension = filename.substring(lastDot + 1);
+
+try {
+if (TURTLE_EXTENSIONS.contains(extension)) {
+return formatTurtle(rawUnix, file, reflectionHelper);
+}
+if (TRIG_EXTENSIONS.contains(extension)) {
+return formatTrig(rawUnix, file);
+}
+if (NTRIPLES_EXTENSIONS.contains(extension)) {
+return formatNTriples(rawUnix, file);
+}
+if (NQUADS_EXTENSIONS.contains(extension)) {
+return formatNQuads(rawUnix, file);
+}
+throw new IllegalArgumentException(String.format("Cannot handle file with extension %s", extension));
+} catch (InvocationTargetException e) {
+throw new RuntimeException("Error formatting file " + file.getPath(), e.getCause());
+} catch (Exception e) {
+throw new RuntimeException("Error formatting file " + file.getPath(), e);
+}
+}
+
+private String formatNQuads(String rawUnix, File file) {
+throw new UnsupportedOperationException("NQUADS formatting not supported yet");
+}
+
+private String formatNTriples(String rawUnix, File file) {
+throw new UnsupportedOperationException("NTRIPLES formatting not supported yet");
+}
+
+private String formatTrig(String rawUnix, File file) {
+throw new UnsupportedOperationException("TRIG formatting not supported yet");
+}
+
+private String formatTurtle(String rawUnix, File file, ReflectionHelper reflectionHelper)
+throws NoSuchMethodException, InvocationTargetException, IllegalAccessException,
+NoSuchFieldException, InstantiationException {
+String formatted;
+Object lang = reflectionHelper.getLang("TTL");
+formatted = reflectionHelper.formatWithTurtleFormatter(rawUnix);
+if (state.getConfig().isVerify()) {
+veryfyResult(rawUnix, file, reflectionHelper, lang, formatted);
+}
+return LineEnding.toUnix(formatted);
+}
+
+private static void veryfyResult(String rawUnix, File file, ReflectionHelper reflectionHelper, Object lang,
+String formatted) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+Object modelBefore = reflectionHelper.parseToModel(rawUnix, file, lang);
+Object modelAfter = reflectionHelper.parseToModel(formatted, file, lang);
+if (!reflectionHelper.areModelsIsomorphic(modelBefore, modelAfter)) {
+long beforeSize = reflectionHelper.modelSize(modelBefore);
+long afterSize = reflectionHelper.modelSize(modelAfter);
+String diffResult;
+if (beforeSize != afterSize) {
+diffResult = String.format("< %,d triples", beforeSize);
+diffResult += String.format("> %,d triples", afterSize);
+} else {
+diffResult = calculateDiff(reflectionHelper, modelBefore, modelAfter);
+}
+throw new IllegalStateException(
+"Formatted RDF is not isomorphic with original, which means that formatting changed the data.\n"
++ "This could be a bug in the formatting system leading to data corruption and should be reported. \n"
++ "If you are not scared to lose data, you can disable this check by setting the config option 'verify' to 'false'"
++ "\n\nDiff:\n"
++ diffResult);
+}
+}
+
+private static String calculateDiff(ReflectionHelper reflectionHelper, Object modelBefore, Object modelAfter)
+throws InvocationTargetException, IllegalAccessException {
+String diffResult;
+Object graphBefore = reflectionHelper.getGraph(modelBefore);
+Object graphAfter = reflectionHelper.getGraph(modelAfter);
+
+List<Object> onlyInBeforeContent = reflectionHelper.streamGraph(graphBefore)
+.filter(triple -> {
+try {
+return !reflectionHelper.graphContainsSameTerm(graphAfter, triple);
+} catch (InvocationTargetException | IllegalAccessException e) {
+throw new RuntimeException(e);
+}
+})
+.collect(Collectors.toList());
+
+List<Object> onlyInAfterContent = reflectionHelper.streamGraph(graphAfter)
+.filter(triple -> {
+try {
+return !reflectionHelper.graphContainsSameTerm(graphBefore, triple);
+} catch (InvocationTargetException | IllegalAccessException e) {
+throw new RuntimeException(e);
+}
+})
+.collect(Collectors.toList());
+if (!(onlyInBeforeContent.isEmpty() && onlyInAfterContent.isEmpty())) {
+diffResult = onlyInBeforeContent.stream().map(s -> String.format("< %s", s))
+.collect(Collectors.joining("\n"));
+diffResult += "\n" + onlyInAfterContent.stream().map(s -> String.format("> %s", s)).collect(Collectors.joining("\n"));
+} else {
+diffResult = "'before' and 'after' content differs, but we don't know why. This is probably a bug.";
+}
+return diffResult;
+}
+
+}