Code formatters should be easily pluggable

Author: reda-alaoui

.github/workflows/ci.yml

@@ -1,6 +1,6 @@
 name: CI
 
-on: [push]
+on: [ push ]
 
 jobs:
   build:
@@ -12,6 +12,6 @@ jobs:
         uses: actions/setup-java@v2
         with:
           java-version: '17'
-          distribution: 'adopt'
+          distribution: 'temurin'
       - name: Build with Maven
-        run: mvn --batch-mode verify
+        run: ./mvnw --batch-mode clean verify

.mvn/wrapper/.gitignore

@@ -0,0 +1 @@
+maven-wrapper.jar

.mvn/wrapper/maven-wrapper.properties

@@ -0,0 +1,18 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.1/apache-maven-3.8.1-bin.zip
+wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.1.1/maven-wrapper-3.1.1.jar

README.md

@@ -3,15 +3,20 @@
 
 # Git Code Format Maven Plugin
 
-A maven plugin that automatically deploys [google-java-format](https://github.com/google/google-java-format) code formatter as a `pre-commit` git hook.
+A maven plugin that automatically deploys code formatters as `pre-commit` git hook.
 On commit, the hook will automatically format staged java files.
 
-### Breaking changes between 2.x and 3.x
+# Breaking changes between 3.x and 4.x
+
+* `Google Java Format` is not enabled by default anymore. `com.cosium.code:google-java-format` must be added as a dependency to the plugin to keep using it.
+* `Google Java Format` options declaration structure has changed. You will need to migrate any eventual existing declaration to the new structure described by [the google-java-format-options chapter](#google-java-format-options) .
+
+# Breaking changes between 2.x and 3.x
 
 * [#64](https://github.com/Cosium/git-code-format-maven-plugin/issues/64) `google-java-format 1.8` [dropped support for java 8](https://github.com/google/google-java-format/releases/tag/google-java-format-1.8).
   The minimum supported runtime version for the plugin is JDK 11. i.e. Maven must run on JDK 11+ while the target project can still be built and run using JDK 8.
 
-### Breaking changes between 1.x and 2.x
+# Breaking changes between 1.x and 2.x
 
 * [#37](https://github.com/Cosium/git-code-format-maven-plugin/issues/37) To prevent conflicts with other plugins all keys are now 
 prefixed with `gcf`. e.g. `-DglobPattern=**/*` becomes `-Dgcf.globPattern=**/*`
@@ -21,7 +26,7 @@ the plugin was renamed to `git-code-format-maven-plugin`. Its new coordinates ar
 
 `1.x` documentation can be found [here](https://github.com/Cosium/git-code-format-maven-plugin/blob/1.39/README.md)
 
-### Automatic code format and validation activation
+# Automatic code format and validation activation
 
 Add this to your maven project **root** pom.xml :
 
@@ -49,24 +54,34 @@ Add this to your maven project **root** pom.xml :
           </goals>
         </execution>
       </executions>
+      <dependencies>
+        <!-- Enable https://github.com/google/google-java-format -->
+        <dependency>
+          <groupId>com.cosium.code</groupId>
+          <artifactId>google-java-format</artifactId>
+          <version>${git-code-format-maven-plugin.version}</version>
+        </dependency>
+      </dependencies>
     </plugin>
   </plugins>
 </build>
 ```
 
-### Manual code formatting
+# Manual code formatting
 
 ```console
 mvn git-code-format:format-code -Dgcf.globPattern=**/*
 ```
 
-### Manual code format validation
+# Manual code format validation
 
 ```console
 mvn git-code-format:validate-code-format -Dgcf.globPattern=**/*
 ```
 
-### Google Java Format options
+# Google Java Format
+
+## Google Java Format options
 
 The plugin allows you to tweak Google Java Format options :
 
@@ -80,13 +95,16 @@ The plugin allows you to tweak Google Java Format options :
       <executions>
         <!-- ... -->
       </executions>
+      <dependencies>
+        <!-- ... -->
+      </dependencies>        
       <configuration>
-        <googleJavaFormatOptions>
-          <aosp>false</aosp>
-          <fixImportsOnly>false</fixImportsOnly>
-          <skipSortingImports>false</skipSortingImports>
-          <skipRemovingUnusedImports>false</skipRemovingUnusedImports>
-        </googleJavaFormatOptions>
+        <formatterOptions>
+          <googleJavaFormat.aosp>false</googleJavaFormat.aosp>
+          <googleJavaFormat.fixImportsOnly>false</googleJavaFormat.fixImportsOnly>
+          <googleJavaFormat.skipSortingImports>false</googleJavaFormat.skipSortingImports>
+          <googleJavaFormat.skipRemovingUnusedImports>false</googleJavaFormat.skipRemovingUnusedImports>
+        </formatterOptions>
       </configuration>
     </plugin>
   </plugins>
@@ -106,7 +124,7 @@ Documentation from the google-java-format CLI tool :
   Do not remove unused imports. Imports will still be sorted.
 ```
 
-### JDK 16+ peculiarities
+## JDK 16+ peculiarities
 
 Since google-java-format uses JDK internal apis, if you need to run the plugin with JDK 16+, you must pass some additional arguments to the JVM.
 Those are described at https://github.com/google/google-java-format/releases/tag/v1.10.0.  
@@ -117,23 +135,71 @@ Thanks to https://maven.apache.org/configure.html#mvn-jvm-config-file, you shoul
 --add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED
 ```
 
-### Frequently asked questions
+# Custom code formatter
+
+Thanks to its code formatter SPI, this plugin can execute any code formatter.
+
+## How to
+
+Note that you can take inspiration from the `google-java-format` module of this project.
+
+1. Implement `com.cosium.code.format_spi.CodeFormatterFactory`. This interface is provided by `com.cosium.code:git-code-format-maven-plugin-spi`.
+2. Add your `com.cosium.code.format_spi.CodeFormatterFactory` implementation canonical name in `META-INF/services/com.cosium.code.format_spi.CodeFormatterFactory`.
+3. Pack this in a jar that you declare as a dependency in this plugin declaration.
+
+## Example of usage
+
+Suppose: 
+- the chosen `configurationId` (declared by `com.cosium.code.format_spi.CodeFormatterFactory#configurationId()`) is `aqme`
+- the formatter dependency is `com.aqme.formatter:formatter:1.0`
+
+A plugin declaration making use of this custom code formatter would look like this:
+
+```xml
+<build>
+  <plugins>
+    <plugin>
+      <groupId>com.cosium.code</groupId>
+      <artifactId>git-code-format-maven-plugin</artifactId>
+      <version>${git-code-format-maven-plugin.version}</version>
+      <executions>
+        <!-- ... -->
+      </executions>
+      <dependencies>
+        <dependency>
+          <groupId>com.aqme.formatter</groupId>
+          <artifactId>formatter</artifactId>
+          <version>1.0</version>
+        </dependency>
+      </dependencies>
+      <configuration>
+        <formatterOptions>
+          <aqme.option1>false</aqme.option1>
+          <aqme.option2>foo</aqme.option2>
+        </formatterOptions>
+      </configuration>
+    </plugin>
+  </plugins>
+</build>
+```
+
+# Frequently asked questions
 
-#### If I have a multi-module project, do I need to install anything in the sub-projects?
+## If I have a multi-module project, do I need to install anything in the sub-projects?
 You only need to put the plugin in your *root* project pom.xml. By default all submodules will be handled.
 
-#### Do I need to run mvn initialize or is that a stage that happens automatically when I run mvn compile or mvn test?
+## Do I need to run mvn initialize or is that a stage that happens automatically when I run mvn compile or mvn test?
 `initialize` is the first phase of the Maven lifecycle. Any goal that you perform (e.g. `compile` or `test`) will automatically trigger `initialize` and thus trigger the git pre-commit hook installation.
 
-#### I'm not noticing anything happening.
+## I'm not noticing anything happening.
 If after setting up the plugin in your pom, you just executed a maven goal, the only expected output is a pre-commit hook installed in your `.git/hooks` directory. To trigger the automatic formatting, you have to perform a commit of a modified java file.
 You can also manually [format](#manual-code-formatting) or [validate](#manual-code-format-validation) any file.
 
-#### I'd like to skip code formatting in a child project 
+## I'd like to skip code formatting in a child project 
 I inherit an enterprise parent pom, which I cannot modify, with formatting plugin specified, and I need to turn off formatting for my group's project.
 Either use add a ```<skip>true</skip>``` configuration in the inheriting project or set the ```gcf.skip``` property to true.
 
-### How the hook works
+# How the hook works
 
 On the `initialize` maven phase, `git-code-format:install-hooks` installs a git `pre-commit` hook that looks like this :
 ```bash
@@ -147,9 +213,9 @@ set -e
 "${env.M2_HOME}/bin/mvn" -f "${project.basedir}/pom.xml" git-code-format:on-pre-commit
 ```
 
-On `pre-commit` git phase, the hook triggers the `git-code-format:on-pre-commit` which formats the code of the modified java files using `google-java-format`.
+On `pre-commit` git phase, the hook triggers the `git-code-format:on-pre-commit` which formats the code of the modified java files.
 
-### Advanced pre-commit pipeline hook
+# Advanced pre-commit pipeline hook
 If you wish to modify the output of the pre-commit hook, you can set the `preCommitHookPipeline` configuration.
 
 To completely ignore the hook output, you could use the following configuration:

core/.gitignore

@@ -1 +1 @@
-target
+/target

core/pom.xml

@@ -5,7 +5,7 @@
   <parent>
     <groupId>com.cosium.code</groupId>
     <artifactId>git-code-format-maven-plugin-parent</artifactId>
-    <version>3.6-SNAPSHOT</version>
+    <version>4.0-SNAPSHOT</version>
   </parent>
 
   <artifactId>git-code-format-maven-plugin</artifactId>
@@ -14,6 +14,12 @@
   <name>Git Code Format Maven Plugin</name>
 
   <dependencies>
+    <dependency>
+      <groupId>${project.groupId}</groupId>
+      <artifactId>git-code-format-maven-plugin-spi</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+
     <dependency>
       <groupId>commons-io</groupId>
       <artifactId>commons-io</artifactId>
@@ -92,8 +98,20 @@
         <version>2.22.2</version>
         <configuration>
           <trimStackTrace>false</trimStackTrace>
-          <argLine>@{argLine} --add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</argLine>
+          <argLine>@{argLine} --add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED --add-exports
+            jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED --add-exports
+            jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED --add-exports
+            jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED --add-exports
+            jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED
+          </argLine>
         </configuration>
+        <dependencies>
+          <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>google-java-format</artifactId>
+            <version>${project.version}</version>
+          </dependency>
+        </dependencies>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>

core/src/main/java/com/cosium/code/format/AbstractFormatMojo.java

@@ -13,9 +13,7 @@
 import org.apache.maven.plugins.annotations.Parameter;
 
 /**
- * Created on 16/01/18.
- *
- * @author Reda.Housni-Alaoui
+ * @author Réda Housni Alaoui
  */
 public abstract class AbstractFormatMojo extends AbstractModuleMavenGitCodeFormatMojo {
 

core/src/main/java/com/cosium/code/format/AbstractMavenGitCodeFormatMojo.java

@@ -1,19 +1,19 @@
 package com.cosium.code.format;
 
-import static java.util.Optional.ofNullable;
-
-import com.cosium.code.format.formatter.CodeFormatter;
+import com.cosium.code.format.formatter.CodeFormatterConfigurationFactory;
 import com.cosium.code.format.formatter.CodeFormatters;
-import com.cosium.code.format.formatter.GoogleJavaFormatter;
+import com.cosium.code.format_spi.CodeFormatter;
+import com.cosium.code.format_spi.CodeFormatterFactory;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
-import java.util.function.Supplier;
+import java.util.Map;
+import java.util.ServiceLoader;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import org.apache.commons.lang3.StringUtils;
@@ -24,34 +24,19 @@
 import org.eclipse.jgit.storage.file.FileRepositoryBuilder;
 
 /**
- * Created on 01/11/17.
- *
- * @author Reda.Housni-Alaoui
+ * @author Réda Housni Alaoui
  */
 public abstract class AbstractMavenGitCodeFormatMojo extends AbstractMojo {
 
   protected static final String HOOKS_DIR = "hooks";
 
-  private final Supplier<List<CodeFormatter>> codeFormatters;
-
   @Parameter(readonly = true, defaultValue = "${project}")
   private MavenProject currentProject;
 
-  @Parameter private MavenGoogleJavaFormatOptions googleJavaFormatOptions;
-
   @Parameter(defaultValue = "${project.build.sourceEncoding}")
   private String sourceEncoding;
 
-  public AbstractMavenGitCodeFormatMojo() {
-    codeFormatters =
-        () ->
-            Collections.singletonList(
-                new GoogleJavaFormatter(
-                    ofNullable(googleJavaFormatOptions)
-                        .orElseGet(MavenGoogleJavaFormatOptions::new)
-                        .toFormatterOptions(),
-                    sourceEncoding));
-  }
+  @Parameter private Map<String, String> formatterOptions;
 
   protected final Repository gitRepository() {
     Repository gitRepository;
@@ -91,7 +76,24 @@ protected final String artifactId() {
   }
 
   protected final CodeFormatters codeFormatters() {
-    return new CodeFormatters(codeFormatters.get());
+    return new CodeFormatters(createCodeFormatters());
+  }
+
+  private List<CodeFormatter> createCodeFormatters() {
+
+    List<CodeFormatterFactory> formatterFactories = new ArrayList<>();
+    ServiceLoader.load(CodeFormatterFactory.class).forEach(formatterFactories::add);
+
+    CodeFormatterConfigurationFactory formatterConfigurationFactory =
+        new CodeFormatterConfigurationFactory(formatterOptions);
+
+    return formatterFactories.stream()
+        .map(
+            codeFormatterFactory ->
+                codeFormatterFactory.build(
+                    formatterConfigurationFactory.build(codeFormatterFactory.configurationId()),
+                    sourceEncoding))
+        .collect(Collectors.toList());
   }
 
   protected final boolean isExecutionRoot() {