Add GitHub Actions job for JavaDoc verification

pivovarit · pivovarit · commit 3b8de119174d · 2024-10-17T07:45:01.000+02:00
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -31,3 +31,19 @@ jobs:
       - name: Build with Maven
         run: mvn package
 
+  verify-javadoc:
+    runs-on: ubuntu-latest
+    name: Validate JavaDocs
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup JDK
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '23'
+          architecture: 'x64'
+          cache: 'maven'
+
+      - name: Validate JavaDocs
+        run: mvn -Pdoclint package -DskipTests=true
+
diff --git a/pom.xml b/pom.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
     <licenses>
         <license>
@@ -25,11 +26,12 @@
         <url>https://github.com/pivovarit/parallel-collectors</url>
         <connection>scm:git:git@github.com:pivovarit/parallel-collectors.git</connection>
         <developerConnection>scm:git:git@github.com:pivovarit/parallel-collectors.git</developerConnection>
-      <tag>HEAD</tag>
-  </scm>
+        <tag>HEAD</tag>
+    </scm>
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.javadoc.plugin.version>3.10.1</maven.javadoc.plugin.version>
         <junit.version>5.11.2</junit.version>
         <assertj.version>3.26.3</assertj.version>
         <awaitility.version>4.2.2</awaitility.version>
@@ -47,8 +49,7 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.13.0</version>
                 <configuration>
-                    <source>21</source>
-                    <target>21</target>
+                    <release>21</release>
                 </configuration>
             </plugin>
 
@@ -126,7 +127,7 @@
                     <plugin>
                         <groupId>org.apache.maven.plugins</groupId>
                         <artifactId>maven-javadoc-plugin</artifactId>
-                        <version>3.10.1</version>
+                        <version>${maven.javadoc.plugin.version}</version>
                         <executions>
                             <execution>
                                 <id>attach-javadocs</id>
@@ -247,6 +248,30 @@
                 </plugins>
             </build>
         </profile>
+        <profile>
+            <id>doclint</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-javadoc-plugin</artifactId>
+                        <version>${maven.javadoc.plugin.version}</version>
+                        <executions>
+                            <execution>
+                                <id>attach-javadocs</id>
+                                <goals>
+                                    <goal>jar</goal>
+                                </goals>
+                            </execution>
+                        </executions>
+                        <configuration>
+                            <failOnWarnings>true</failOnWarnings>
+                            <failOnError>true</failOnError>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
     </profiles>
 
     <dependencies>
diff --git a/src/main/java/com/pivovarit/collectors/ParallelCollectors.java b/src/main/java/com/pivovarit/collectors/ParallelCollectors.java
@@ -28,11 +28,11 @@ private ParallelCollectors() {
      *   .collect(parallel(i -> foo(i), toList()));
      * }</pre>
      *
-     * @param mapper      a transformation to be performed in parallel
-     * @param collector   the {@code Collector} describing the reduction
-     * @param <T>         the type of the collected elements
-     * @param <R>         the result returned by {@code mapper}
-     * @param <RR>        the reduction result {@code collector}
+     * @param mapper    a transformation to be performed in parallel
+     * @param collector the {@code Collector} describing the reduction
+     * @param <T>       the type of the collected elements
+     * @param <R>       the result returned by {@code mapper}
+     * @param <RR>      the reduction result {@code collector}
      *
      * @return a {@code Collector} which collects all processed elements into a user-provided mutable {@code Collection} in parallel
      *
@@ -106,12 +106,12 @@ private ParallelCollectors() {
      *   .collect(parallel(i -> foo(i), toList(), executor));
      * }</pre>
      *
-     * @param mapper      a transformation to be performed in parallel
-     * @param collector   the {@code Collector} describing the reduction
-     * @param executor    the {@code Executor} to use for asynchronous execution
-     * @param <T>         the type of the collected elements
-     * @param <R>         the result returned by {@code mapper}
-     * @param <RR>        the reduction result {@code collector}
+     * @param mapper    a transformation to be performed in parallel
+     * @param collector the {@code Collector} describing the reduction
+     * @param executor  the {@code Executor} to use for asynchronous execution
+     * @param <T>       the type of the collected elements
+     * @param <R>       the result returned by {@code mapper}
+     * @param <RR>      the reduction result {@code collector}
      *
      * @return a {@code Collector} which collects all processed elements into a user-provided mutable {@code Collection} in parallel
      *
@@ -135,9 +135,9 @@ private ParallelCollectors() {
      *   .collect(parallel(i -> foo()));
      * }</pre>
      *
-     * @param mapper      a transformation to be performed in parallel
-     * @param <T>         the type of the collected elements
-     * @param <R>         the result returned by {@code mapper}
+     * @param mapper a transformation to be performed in parallel
+     * @param <T>    the type of the collected elements
+     * @param <R>    the result returned by {@code mapper}
      *
      * @return a {@code Collector} which collects all processed elements into a {@code Stream} in parallel
      *
@@ -162,6 +162,7 @@ private ParallelCollectors() {
      * }</pre>
      *
      * @param mapper      a transformation to be performed in parallel
+     * @param parallelism the max parallelism level
      * @param <T>         the type of the collected elements
      * @param <R>         the result returned by {@code mapper}
      *
@@ -215,10 +216,10 @@ private ParallelCollectors() {
      *   .collect(parallel(i -> foo(), executor));
      * }</pre>
      *
-     * @param mapper      a transformation to be performed in parallel
-     * @param executor    the {@code Executor} to use for asynchronous execution
-     * @param <T>         the type of the collected elements
-     * @param <R>         the result returned by {@code mapper}
+     * @param mapper   a transformation to be performed in parallel
+     * @param executor the {@code Executor} to use for asynchronous execution
+     * @param <T>      the type of the collected elements
+     * @param <R>      the result returned by {@code mapper}
      *
      * @return a {@code Collector} which collects all processed elements into a {@code Stream} in parallel
      *
@@ -242,9 +243,9 @@ private ParallelCollectors() {
      *   .forEach(System.out::println);
      * }</pre>
      *
-     * @param mapper      a transformation to be performed in parallel
-     * @param <T>         the type of the collected elements
-     * @param <R>         the result returned by {@code mapper}
+     * @param mapper a transformation to be performed in parallel
+     * @param <T>    the type of the collected elements
+     * @param <R>    the result returned by {@code mapper}
      *
      * @return a {@code Collector} which collects all processed elements into a {@code Stream} in parallel
      *
@@ -295,10 +296,10 @@ private ParallelCollectors() {
      *   .forEach(System.out::println);
      * }</pre>
      *
-     * @param mapper      a transformation to be performed in parallel
-     * @param executor    the {@code Executor} to use for asynchronous execution
-     * @param <T>         the type of the collected elements
-     * @param <R>         the result returned by {@code mapper}
+     * @param mapper   a transformation to be performed in parallel
+     * @param executor the {@code Executor} to use for asynchronous execution
+     * @param <T>      the type of the collected elements
+     * @param <R>      the result returned by {@code mapper}
      *
      * @return a {@code Collector} which collects all processed elements into a {@code Stream} in parallel
      *
@@ -350,9 +351,9 @@ private ParallelCollectors() {
      *   .forEach(System.out::println);
      * }</pre>
      *
-     * @param mapper      a transformation to be performed in parallel
-     * @param <T>         the type of the collected elements
-     * @param <R>         the result returned by {@code mapper}
+     * @param mapper a transformation to be performed in parallel
+     * @param <T>    the type of the collected elements
+     * @param <R>    the result returned by {@code mapper}
      *
      * @return a {@code Collector} which collects all processed elements into a {@code Stream} in parallel
      *
@@ -403,10 +404,10 @@ private ParallelCollectors() {
      *   .forEach(System.out::println);
      * }</pre>
      *
-     * @param mapper      a transformation to be performed in parallel
-     * @param executor    the {@code Executor} to use for asynchronous execution
-     * @param <T>         the type of the collected elements
-     * @param <R>         the result returned by {@code mapper}
+     * @param mapper   a transformation to be performed in parallel
+     * @param executor the {@code Executor} to use for asynchronous execution
+     * @param <T>      the type of the collected elements
+     * @param <R>      the result returned by {@code mapper}
      *
      * @return a {@code Collector} which collects all processed elements into a {@code Stream} in parallel
      *
diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
@@ -1,3 +1,6 @@
+/**
+ * Parallel Collectors is a toolkit that eases parallel collection processing in Java using Stream API without the limitations imposed by standard Parallel Streams
+ */
 module parallel.collectors {
     exports com.pivovarit.collectors;
 }

Original file line number	Diff line number	Diff line change
`@@ -28,11 +28,11 @@ private ParallelCollectors() {`
`28`	`28`	`* .collect(parallel(i -> foo(i), toList()));`
`29`	`29`	`* }</pre>`
`30`	`30`	`*`
`31`		`- * @param mapper a transformation to be performed in parallel`
`32`		`- * @param collector the {@code Collector} describing the reduction`
`33`		`- * @param <T> the type of the collected elements`
`34`		`- * @param <R> the result returned by {@code mapper}`
`35`		`- * @param <RR> the reduction result {@code collector}`
	`31`	`+ * @param mapper a transformation to be performed in parallel`
	`32`	`+ * @param collector the {@code Collector} describing the reduction`
	`33`	`+ * @param <T> the type of the collected elements`
	`34`	`+ * @param <R> the result returned by {@code mapper}`
	`35`	`+ * @param <RR> the reduction result {@code collector}`
`36`	`36`	`*`
`37`	`37`	`* @return a {@code Collector} which collects all processed elements into a user-provided mutable {@code Collection} in parallel`
`38`	`38`	`*`
`@@ -106,12 +106,12 @@ private ParallelCollectors() {`
`106`	`106`	`* .collect(parallel(i -> foo(i), toList(), executor));`
`107`	`107`	`* }</pre>`
`108`	`108`	`*`
`109`		`- * @param mapper a transformation to be performed in parallel`
`110`		`- * @param collector the {@code Collector} describing the reduction`
`111`		`- * @param executor the {@code Executor} to use for asynchronous execution`
`112`		`- * @param <T> the type of the collected elements`
`113`		`- * @param <R> the result returned by {@code mapper}`
`114`		`- * @param <RR> the reduction result {@code collector}`
	`109`	`+ * @param mapper a transformation to be performed in parallel`
	`110`	`+ * @param collector the {@code Collector} describing the reduction`
	`111`	`+ * @param executor the {@code Executor} to use for asynchronous execution`
	`112`	`+ * @param <T> the type of the collected elements`
	`113`	`+ * @param <R> the result returned by {@code mapper}`
	`114`	`+ * @param <RR> the reduction result {@code collector}`
`115`	`115`	`*`
`116`	`116`	`* @return a {@code Collector} which collects all processed elements into a user-provided mutable {@code Collection} in parallel`
`117`	`117`	`*`
`@@ -135,9 +135,9 @@ private ParallelCollectors() {`
`135`	`135`	`* .collect(parallel(i -> foo()));`
`136`	`136`	`* }</pre>`
`137`	`137`	`*`
`138`		`- * @param mapper a transformation to be performed in parallel`
`139`		`- * @param <T> the type of the collected elements`
`140`		`- * @param <R> the result returned by {@code mapper}`
	`138`	`+ * @param mapper a transformation to be performed in parallel`
	`139`	`+ * @param <T> the type of the collected elements`
	`140`	`+ * @param <R> the result returned by {@code mapper}`
`141`	`141`	`*`
`142`	`142`	`* @return a {@code Collector} which collects all processed elements into a {@code Stream} in parallel`
`143`	`143`	`*`
`@@ -162,6 +162,7 @@ private ParallelCollectors() {`
`162`	`162`	`* }</pre>`
`163`	`163`	`*`
`164`	`164`	`* @param mapper a transformation to be performed in parallel`
	`165`	`+ * @param parallelism the max parallelism level`
`165`	`166`	`* @param <T> the type of the collected elements`
`166`	`167`	`* @param <R> the result returned by {@code mapper}`
`167`	`168`	`*`
`@@ -215,10 +216,10 @@ private ParallelCollectors() {`
`215`	`216`	`* .collect(parallel(i -> foo(), executor));`
`216`	`217`	`* }</pre>`
`217`	`218`	`*`
`218`		`- * @param mapper a transformation to be performed in parallel`
`219`		`- * @param executor the {@code Executor} to use for asynchronous execution`
`220`		`- * @param <T> the type of the collected elements`
`221`		`- * @param <R> the result returned by {@code mapper}`
	`219`	`+ * @param mapper a transformation to be performed in parallel`
	`220`	`+ * @param executor the {@code Executor} to use for asynchronous execution`
	`221`	`+ * @param <T> the type of the collected elements`
	`222`	`+ * @param <R> the result returned by {@code mapper}`
`222`	`223`	`*`
`223`	`224`	`* @return a {@code Collector} which collects all processed elements into a {@code Stream} in parallel`
`224`	`225`	`*`
`@@ -242,9 +243,9 @@ private ParallelCollectors() {`
`242`	`243`	`* .forEach(System.out::println);`
`243`	`244`	`* }</pre>`
`244`	`245`	`*`
`245`		`- * @param mapper a transformation to be performed in parallel`
`246`		`- * @param <T> the type of the collected elements`
`247`		`- * @param <R> the result returned by {@code mapper}`
	`246`	`+ * @param mapper a transformation to be performed in parallel`
	`247`	`+ * @param <T> the type of the collected elements`
	`248`	`+ * @param <R> the result returned by {@code mapper}`
`248`	`249`	`*`
`249`	`250`	`* @return a {@code Collector} which collects all processed elements into a {@code Stream} in parallel`
`250`	`251`	`*`
`@@ -295,10 +296,10 @@ private ParallelCollectors() {`
`295`	`296`	`* .forEach(System.out::println);`
`296`	`297`	`* }</pre>`
`297`	`298`	`*`
`298`		`- * @param mapper a transformation to be performed in parallel`
`299`		`- * @param executor the {@code Executor} to use for asynchronous execution`
`300`		`- * @param <T> the type of the collected elements`
`301`		`- * @param <R> the result returned by {@code mapper}`
	`299`	`+ * @param mapper a transformation to be performed in parallel`
	`300`	`+ * @param executor the {@code Executor} to use for asynchronous execution`
	`301`	`+ * @param <T> the type of the collected elements`
	`302`	`+ * @param <R> the result returned by {@code mapper}`
`302`	`303`	`*`
`303`	`304`	`* @return a {@code Collector} which collects all processed elements into a {@code Stream} in parallel`
`304`	`305`	`*`
`@@ -350,9 +351,9 @@ private ParallelCollectors() {`
`350`	`351`	`* .forEach(System.out::println);`
`351`	`352`	`* }</pre>`
`352`	`353`	`*`
`353`		`- * @param mapper a transformation to be performed in parallel`
`354`		`- * @param <T> the type of the collected elements`
`355`		`- * @param <R> the result returned by {@code mapper}`
	`354`	`+ * @param mapper a transformation to be performed in parallel`
	`355`	`+ * @param <T> the type of the collected elements`
	`356`	`+ * @param <R> the result returned by {@code mapper}`
`356`	`357`	`*`
`357`	`358`	`* @return a {@code Collector} which collects all processed elements into a {@code Stream} in parallel`
`358`	`359`	`*`
`@@ -403,10 +404,10 @@ private ParallelCollectors() {`
`403`	`404`	`* .forEach(System.out::println);`
`404`	`405`	`* }</pre>`
`405`	`406`	`*`
`406`		`- * @param mapper a transformation to be performed in parallel`
`407`		`- * @param executor the {@code Executor} to use for asynchronous execution`
`408`		`- * @param <T> the type of the collected elements`
`409`		`- * @param <R> the result returned by {@code mapper}`
	`407`	`+ * @param mapper a transformation to be performed in parallel`
	`408`	`+ * @param executor the {@code Executor} to use for asynchronous execution`
	`409`	`+ * @param <T> the type of the collected elements`
	`410`	`+ * @param <R> the result returned by {@code mapper}`
`410`	`411`	`*`
`411`	`412`	`* @return a {@code Collector} which collects all processed elements into a {@code Stream} in parallel`
`412`	`413`	`*`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,6 @@`
	`1`	`+/**`
	`2`	`+ * Parallel Collectors is a toolkit that eases parallel collection processing in Java using Stream API without the limitations imposed by standard Parallel Streams`
	`3`	`+ */`
`1`	`4`	`module parallel.collectors {`
`2`	`5`	`exports com.pivovarit.collectors;`
`3`	`6`	`}`