#2530: Add spotless check for formatting preferences

.github/workflows/spotless.yml

@@ -0,0 +1,21 @@
+name: Spotless
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  spotless-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Java
+        uses: actions/setup-java@v2
+        with:
+          distribution: 'zulu'
+          java-version: 11
+          cache: 'maven'
+      - name: Spotless check
+        run: mvn spotless:check

CONTRIBUTING.md

@@ -6,7 +6,8 @@ Thank you for your interest in contributing to AssertJ!
 We appreciate your effort and to make sure that your pull request is easy to review, we ask you to note the following guidelines including legal contributor agreement:
 
 * Use JDK 11 or newer to build the project
-* Use **[AssertJ code Eclipse formatting preferences](src/ide-support/assertj-eclipse-formatter.xml)** (for IntelliJ IDEA users, you can import it with the 'Eclipse Code Formatter' Plugin)
+* Use **[AssertJ code Eclipse formatting preferences](src/ide-support/assertj-eclipse-formatter.xml)** (for IntelliJ IDEA users, you can import it with the 'Eclipse Code Formatter' Plugin). 
+  You can also run `mvn spotless:apply` (to apply the formatting preferences) or `mvn spotless:check` (to check that your contribution adheres to them).
 * Write complete Javadocs for each assertion method and include a code example (succeeding and failing assertion(s)).
 * As we use JUnit 5, favor `package-private` visibility for both test classes and test methods.
 * Write one JUnit test class for each assertion method with the following naming convention: `<AssertClass>_<assertion>_Test`.

pom.xml

@@ -550,6 +550,23 @@
           <failWhenNoMutations>false</failWhenNoMutations>
         </configuration>
       </plugin>
+      <plugin>
+        <groupId>com.diffplug.spotless</groupId>
+        <artifactId>spotless-maven-plugin</artifactId>
+        <version>2.21.0</version>
+        <configuration>
+          <java>
+            <includes>
+              <include>src/main/java/**/*.java</include>
+              <include>src/test/java/**/*.java</include>
+            </includes>
+
+            <eclipse>
+              <file>${project.basedir}/src/ide-support/assertj-eclipse-formatter.xml</file>
+            </eclipse>
+          </java>
+        </configuration>
+      </plugin>
     </plugins>
   </build>
 

src/main/java/org/assertj/core/api/AbstractCompletableFutureAssert.java

@@ -405,6 +405,7 @@ private ObjectAssert<RESULT> internalSucceedsWithin(Duration timeout) {
   protected ObjectAssert<RESULT> newObjectAssert(RESULT objectUnderTest) {
     return new ObjectAssert<>(objectUnderTest);
   }
+
   /**
    * Waits if necessary for at most the given time for this future to complete, and then returns its result for further assertions.
    * <p>

src/main/java/org/assertj/core/api/AbstractMatcherAssert.java

@@ -17,14 +17,13 @@
 import java.util.regex.Matcher;
 import org.assertj.core.internal.Failures;
 
-
 /**
  * Assertions for {@link java.util.regex.Matcher}
  *
  * @author Jiashu Zhang
  */
 public abstract class AbstractMatcherAssert<SELF extends AbstractMatcherAssert<SELF>> extends
-  AbstractAssert<SELF, Matcher> {
+    AbstractAssert<SELF, Matcher> {
 
   protected AbstractMatcherAssert(Matcher actual, Class<?> selfType) {
     super(actual, selfType);

src/main/java/org/assertj/core/api/AbstractOffsetDateTimeAssert.java

@@ -446,7 +446,6 @@ public SELF isEqualTo(String dateTimeAsString) {
     return isEqualTo(parse(dateTimeAsString));
   }
 
-
   /**
    * Verifies that the actual {@code OffsetDateTime} is not equal to the given value according to the comparator in use.
    * <p>

src/main/java/org/assertj/core/api/AbstractOptionalDoubleAssert.java

@@ -77,7 +77,7 @@ public SELF isPresent() {
   public SELF isNotPresent() {
     return isEmpty();
   }
-  
+
   /**
    * Verifies that the actual {@link java.util.OptionalDouble} is empty.
    * <p>
@@ -203,7 +203,8 @@ public SELF hasValueCloseTo(Double expectedValue, Percentage percentage) {
     try {
       doubles.assertIsCloseToPercentage(info, actual.getAsDouble(), expectedValue, percentage);
     } catch (AssertionError assertionError) {
-      throwAssertionError(shouldHaveValueCloseToPercentage(actual, expectedValue, percentage, abs(expectedValue - actual.getAsDouble())));
+      throwAssertionError(shouldHaveValueCloseToPercentage(actual, expectedValue, percentage,
+                                                           abs(expectedValue - actual.getAsDouble())));
     }
     return myself;
   }

src/main/java/org/assertj/core/api/AbstractOptionalIntAssert.java

@@ -72,7 +72,7 @@ public SELF isPresent() {
   public SELF isNotPresent() {
     return isEmpty();
   }
-  
+
   /**
    * Verifies that the actual {@link java.util.OptionalInt} is empty.
    * <p>

src/main/java/org/assertj/core/api/Assertions.java

@@ -169,7 +169,6 @@ public static <T> PredicateAssert<T> assertThat(Predicate<T> actual) {
     return AssertionsForInterfaceTypes.assertThat(actual);
   }
 
-
   /**
    * Create assertion for {@link Predicate}.
    * <p>
@@ -1567,7 +1566,8 @@ public static IOException catchIOException(ThrowingCallable shouldRaiseIOExcepti
    * @since 3.22.0
    */
   public static ReflectiveOperationException catchReflectiveOperationException(ThrowingCallable shouldRaiseReflectiveOperationException) {
-    return AssertionsForClassTypes.catchThrowableOfType(shouldRaiseReflectiveOperationException, ReflectiveOperationException.class);
+    return AssertionsForClassTypes.catchThrowableOfType(shouldRaiseReflectiveOperationException,
+                                                        ReflectiveOperationException.class);
   }
 
   /**
@@ -1709,7 +1709,7 @@ public static ThrowableTypeAssert<IllegalStateException> assertThatIllegalStateE
    *
    * @since 3.23.0
    */
-  public static ThrowableTypeAssert<Exception> assertThatException(){
+  public static ThrowableTypeAssert<Exception> assertThatException() {
     return assertThatExceptionOfType(Exception.class);
   }
 
@@ -1720,7 +1720,7 @@ public static ThrowableTypeAssert<Exception> assertThatException(){
    *
    * @since 3.23.0
    */
-  public static ThrowableTypeAssert<RuntimeException> assertThatRuntimeException(){
+  public static ThrowableTypeAssert<RuntimeException> assertThatRuntimeException() {
     return assertThatExceptionOfType(RuntimeException.class);
   }
 
@@ -1731,7 +1731,7 @@ public static ThrowableTypeAssert<RuntimeException> assertThatRuntimeException()
    *
    * @since 3.23.0
    */
-  public static ThrowableTypeAssert<ReflectiveOperationException> assertThatReflectiveOperationException(){
+  public static ThrowableTypeAssert<ReflectiveOperationException> assertThatReflectiveOperationException() {
     return assertThatExceptionOfType(ReflectiveOperationException.class);
   }
 
@@ -1742,7 +1742,7 @@ public static ThrowableTypeAssert<ReflectiveOperationException> assertThatReflec
    *
    * @since 3.23.0
    */
-  public static ThrowableTypeAssert<IndexOutOfBoundsException> assertThatIndexOutOfBoundsException(){
+  public static ThrowableTypeAssert<IndexOutOfBoundsException> assertThatIndexOutOfBoundsException() {
     return assertThatExceptionOfType(IndexOutOfBoundsException.class);
   }
 

src/main/java/org/assertj/core/api/AssumptionExceptionFactory.java

@@ -31,7 +31,7 @@ static RuntimeException assumptionNotMet(AssertionError assertionError) throws R
     Class<?> assumptionExceptionClass = preferredAssumptionException.getAssumptionExceptionClass();
     return buildAssumptionException(assumptionExceptionClass, assertionError);
   }
-  
+
   @VisibleForTesting
   public static PreferredAssumptionException getPreferredAssumptionException() {
     return preferredAssumptionException;

src/main/java/org/assertj/core/api/AtomicBooleanAssert.java

@@ -93,7 +93,8 @@ public AtomicBooleanAssert usingComparator(Comparator<? super AtomicBoolean> cus
    */
   @Override
   @Deprecated
-  public AtomicBooleanAssert usingComparator(Comparator<? super AtomicBoolean> customComparator, String customComparatorDescription) {
+  public AtomicBooleanAssert usingComparator(Comparator<? super AtomicBoolean> customComparator,
+                                             String customComparatorDescription) {
     throw new UnsupportedOperationException("custom Comparator is not supported for AtomicBoolean comparison");
   }
 

src/main/java/org/assertj/core/api/AtomicIntegerAssert.java

@@ -387,7 +387,8 @@ public AtomicIntegerAssert usingComparator(Comparator<? super AtomicInteger> cus
 
   @Override
   @CheckReturnValue
-  public AtomicIntegerAssert usingComparator(Comparator<? super AtomicInteger> customComparator, String customComparatorDescription) {
+  public AtomicIntegerAssert usingComparator(Comparator<? super AtomicInteger> customComparator,
+                                             String customComparatorDescription) {
     integers = new Integers(new ComparatorBasedComparisonStrategy(customComparator, customComparatorDescription));
     return super.usingComparator(customComparator, customComparatorDescription);
   }

src/main/java/org/assertj/core/api/AtomicIntegerFieldUpdaterAssert.java

@@ -12,7 +12,6 @@
  */
 package org.assertj.core.api;
 
-
 import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 
 /**
@@ -25,12 +24,13 @@
  * @author epeee
  * @since 2.7.0 / 3.7.0
  */
-public class AtomicIntegerFieldUpdaterAssert<OBJECT> extends AbstractAtomicFieldUpdaterAssert<AtomicIntegerFieldUpdaterAssert<OBJECT>, Integer, AtomicIntegerFieldUpdater<OBJECT>, OBJECT> {
+public class AtomicIntegerFieldUpdaterAssert<OBJECT> extends
+    AbstractAtomicFieldUpdaterAssert<AtomicIntegerFieldUpdaterAssert<OBJECT>, Integer, AtomicIntegerFieldUpdater<OBJECT>, OBJECT> {
 
   public AtomicIntegerFieldUpdaterAssert(AtomicIntegerFieldUpdater<OBJECT> actual) {
     super(actual, AtomicIntegerFieldUpdaterAssert.class, false);
   }
-  
+
   /**
    * Verifies that the actual atomic field updater contains the given value at the given object.
    * <p>

src/main/java/org/assertj/core/api/AtomicLongFieldUpdaterAssert.java

@@ -12,7 +12,6 @@
  */
 package org.assertj.core.api;
 
-
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
 
 /**
@@ -25,7 +24,8 @@
  * @author epeee
  * @since 2.7.0 / 3.7.0
  */
-public class AtomicLongFieldUpdaterAssert<OBJECT> extends AbstractAtomicFieldUpdaterAssert<AtomicLongFieldUpdaterAssert<OBJECT>, Long, AtomicLongFieldUpdater<OBJECT>, OBJECT> {
+public class AtomicLongFieldUpdaterAssert<OBJECT>
+    extends AbstractAtomicFieldUpdaterAssert<AtomicLongFieldUpdaterAssert<OBJECT>, Long, AtomicLongFieldUpdater<OBJECT>, OBJECT> {
 
   public AtomicLongFieldUpdaterAssert(AtomicLongFieldUpdater<OBJECT> actual) {
     super(actual, AtomicLongFieldUpdaterAssert.class, false);

src/main/java/org/assertj/core/api/AtomicMarkableReferenceAssert.java

@@ -53,7 +53,7 @@ public AtomicMarkableReferenceAssert(AtomicMarkableReference<VALUE> actual) {
   public AtomicMarkableReferenceAssert<VALUE> hasReference(VALUE expectedValue) {
     return super.hasReference(expectedValue);
   }
-  
+
   @Override
   protected VALUE getReference() {
     return actual.getReference();

src/main/java/org/assertj/core/api/AtomicReferenceArrayAssert.java

@@ -1095,7 +1095,6 @@ public AtomicReferenceArrayAssert<T> hasExactlyElementsOfTypes(Class<?>... expec
     return myself;
   }
 
-
   /**
    * Verifies that the actual AtomicReferenceArray does not contain the given object at the given index.
    * <p>

src/main/java/org/assertj/core/api/AtomicReferenceFieldUpdaterAssert.java

@@ -12,7 +12,6 @@
  */
 package org.assertj.core.api;
 
-
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 
 /**
@@ -26,7 +25,8 @@
  * @author epeee
  * @since 2.7.0 / 3.7.0
  */
-public class AtomicReferenceFieldUpdaterAssert<FIELD, OBJECT> extends AbstractAtomicFieldUpdaterAssert<AtomicReferenceFieldUpdaterAssert<FIELD, OBJECT>, FIELD, AtomicReferenceFieldUpdater<OBJECT, FIELD>, OBJECT> {
+public class AtomicReferenceFieldUpdaterAssert<FIELD, OBJECT> extends
+    AbstractAtomicFieldUpdaterAssert<AtomicReferenceFieldUpdaterAssert<FIELD, OBJECT>, FIELD, AtomicReferenceFieldUpdater<OBJECT, FIELD>, OBJECT> {
 
   public AtomicReferenceFieldUpdaterAssert(AtomicReferenceFieldUpdater<OBJECT, FIELD> actual) {
     super(actual, AtomicReferenceFieldUpdaterAssert.class, true);
@@ -57,7 +57,7 @@ public AtomicReferenceFieldUpdaterAssert(AtomicReferenceFieldUpdater<OBJECT, FIE
   public AtomicReferenceFieldUpdaterAssert<FIELD, OBJECT> hasValue(FIELD expectedValue, OBJECT obj) {
     return super.hasValue(expectedValue, obj);
   }
-  
+
   @Override
   protected FIELD getActualValue(OBJECT obj) {
     return actual.get(obj);

src/main/java/org/assertj/core/api/AtomicStampedReferenceAssert.java

@@ -12,7 +12,6 @@
  */
 package org.assertj.core.api;
 
-
 import static org.assertj.core.error.ShouldHaveStamp.shouldHaveStamp;
 
 import java.util.concurrent.atomic.AtomicStampedReference;
@@ -26,7 +25,8 @@
  * @author epeee
  * @since 2.7.0 / 3.7.0
  */
-public class AtomicStampedReferenceAssert<VALUE> extends AbstractAtomicReferenceAssert<AtomicStampedReferenceAssert<VALUE>, VALUE, AtomicStampedReference<VALUE>> {
+public class AtomicStampedReferenceAssert<VALUE>
+    extends AbstractAtomicReferenceAssert<AtomicStampedReferenceAssert<VALUE>, VALUE, AtomicStampedReference<VALUE>> {
 
   public AtomicStampedReferenceAssert(AtomicStampedReference<VALUE> actual) {
     super(actual, AtomicStampedReferenceAssert.class);
@@ -52,7 +52,7 @@ public AtomicStampedReferenceAssert(AtomicStampedReference<VALUE> actual) {
   public AtomicStampedReferenceAssert<VALUE> hasReference(VALUE expectedValue) {
     return super.hasReference(expectedValue);
   }
-  
+
   @Override
   protected VALUE getReference() {
     return actual.getReference();
@@ -72,7 +72,7 @@ protected VALUE getReference() {
    * @return this assertion object.
    * @since 2.7.0 / 3.7.0
    */
-  public AtomicStampedReferenceAssert<VALUE> hasStamp(int expectedStamp){
+  public AtomicStampedReferenceAssert<VALUE> hasStamp(int expectedStamp) {
     int timestamp = actual.getStamp();
     if (timestamp != expectedStamp) throwAssertionError(shouldHaveStamp(actual, expectedStamp));
     return this;

src/main/java/org/assertj/core/api/BDDAssertions.java

@@ -2058,7 +2058,8 @@ public static IOException catchIOException(ThrowingCallable shouldRaiseIOExcepti
    * @since 3.22.0
    */
   public static ReflectiveOperationException catchReflectiveOperationException(ThrowingCallable shouldRaiseReflectiveOperationException) {
-    return AssertionsForClassTypes.catchThrowableOfType(shouldRaiseReflectiveOperationException, ReflectiveOperationException.class);
+    return AssertionsForClassTypes.catchThrowableOfType(shouldRaiseReflectiveOperationException,
+                                                        ReflectiveOperationException.class);
   }
 
   /**

src/main/java/org/assertj/core/api/BDDSoftAssertionsProvider.java

@@ -128,7 +128,6 @@ default MatcherAssert then(Matcher actual) {
     return proxy(MatcherAssert.class, Matcher.class, actual);
   }
 
-
   /**
   * Creates a new instance of <code>{@link LocalDateAssert}</code>.
   *

src/main/java/org/assertj/core/api/BigDecimalAssert.java

@@ -14,7 +14,6 @@
 
 import java.math.BigDecimal;
 
-
 /**
  * Assertion methods for {@link BigDecimal}s.
  * <p>

src/main/java/org/assertj/core/api/BooleanArrayAssert.java

@@ -12,7 +12,6 @@
  */
 package org.assertj.core.api;
 
-
 /**
  * Assertion methods for arrays of {@code boolean}s.
  * <p>

src/main/java/org/assertj/core/api/Byte2DArrayAssert.java

@@ -235,7 +235,6 @@ public Byte2DArrayAssert hasNumberOfRows(int expected) {
     return myself;
   }
 
-
   /**
    * Verifies that the actual {@code byte[][]} has the same dimensions as the given array.
    * <p>

src/main/java/org/assertj/core/api/ByteArrayAssert.java

@@ -12,7 +12,6 @@
  */
 package org.assertj.core.api;
 
-
 /**
  * Assertion methods for arrays of {@code byte}s.
  * <p>

src/main/java/org/assertj/core/api/CharArrayAssert.java

@@ -12,7 +12,6 @@
  */
 package org.assertj.core.api;
 
-
 /**
  * Assertion methods for arrays of {@code char}s.
  * <p>

src/main/java/org/assertj/core/api/ClassAssert.java

@@ -26,5 +26,5 @@ public class ClassAssert extends AbstractClassAssert<ClassAssert> {
   public ClassAssert(Class<?> actual) {
     super(actual, ClassAssert.class);
   }
-  
+
 }

src/main/java/org/assertj/core/api/ClassBasedNavigableIterableAssert.java

@@ -37,7 +37,6 @@ ClassBasedNavigableIterableAssert<?, ACTUAL, ELEMENT, ELEMENT_ASSERT> assertThat
 
 // @format:on
 
-
   public ClassBasedNavigableIterableAssert(ACTUAL actual, Class<?> selfType, Class<ELEMENT_ASSERT> assertClass) {
     super(actual, selfType);
     this.assertClass = assertClass;