Ensured exit status is set on failure

examples/.idea/misc.xml

@@ -6,6 +6,7 @@
     <pattern value="com.example.ExampleBuild" method="dokkaHtml" />
     <pattern value="com.example.ExampleBuild" method="dokkaGfm" />
     <pattern value="com.example.ExampleBuild" method="dokkaJekyll" />
+    <pattern value="com.example.ExampleBuild" method="docs" />
   </component>
   <component name="PDMPlugin">
     <option name="customRuleSets">

examples/README.md

@@ -20,6 +20,8 @@
 ## Build the documentation with [Dokka](https://github.com/Kotlin/dokka)
 
 ```console
+./bld docs
+
 ./bld javadoc
 ./bld dokka-html
 ./bld dokka-gfm

examples/src/bld/java/com/example/ExampleBuild.java

@@ -68,6 +68,14 @@ public class ExampleBuild extends Project {
                 .execute();
     }
 
+    @BuildCommand(value = "docs", summary = "Generates all documentation")
+    public void docs() throws ExitStatusException, IOException, InterruptedException {
+        dokkaGfm();
+        dokkaHtml();
+        dokkaJekyll();
+        javadoc();
+    }
+
     @BuildCommand(value = "dokka-gfm", summary = "Generates documentation in GitHub flavored markdown format")
     public void dokkaGfm() throws ExitStatusException, IOException, InterruptedException {
         new DokkaOperation()

src/main/java/rife/bld/extension/DokkaOperation.java

@@ -21,9 +21,11 @@ import rife.bld.extension.dokka.LoggingLevel;
 import rife.bld.extension.dokka.OutputFormat;
 import rife.bld.extension.dokka.SourceSet;
 import rife.bld.operations.AbstractProcessOperation;
+import rife.bld.operations.exceptions.ExitStatusException;
 import rife.tools.StringUtils;
 
 import java.io.File;
+import java.io.IOException;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.logging.Level;
@@ -78,6 +80,8 @@ public class DokkaOperation extends AbstractProcessOperation<DokkaOperation> {
 
     /**
      * Returns the JARs contained in a given directory.
+     * <p>
+     * Sources and Javadoc JARs are ignored.
      *
      * @param directory the directory
      * @param regex     the regular expression to match
@@ -124,6 +128,18 @@ public class DokkaOperation extends AbstractProcessOperation<DokkaOperation> {
         return this;
     }
 
+    @Override
+    public void execute() throws IOException, InterruptedException, ExitStatusException {
+        if (project_ == null) {
+            if (LOGGER.isLoggable(Level.SEVERE) && !silent()) {
+                LOGGER.severe("A project must be specified.");
+            }
+            throw new ExitStatusException(ExitStatusException.EXIT_FAILURE);
+        } else {
+            super.execute();
+        }
+    }
+
     /**
      * Part of the {@link #execute execute} operation, constructs the command list to use for building the process.
      *
@@ -131,24 +147,21 @@ public class DokkaOperation extends AbstractProcessOperation<DokkaOperation> {
      */
     @Override
     protected List<String> executeConstructProcessCommandList() {
-        if (project_ == null) {
-            throw new IllegalArgumentException("A project must be specified.");
-        }
-
         final List<String> args = new ArrayList<>();
 
+        if (project_ != null) {
             // java
             args.add(javaTool());
 
-        var cli = getJarList(project_.libBldDirectory(), "^.*dokka-cli.*\\.jar$");
+            var jarList = getJarList(project_.libBldDirectory(), "^.*dokka-cli.*\\.jar$");
-
+            if (!jarList.isEmpty()) {
-        if (cli.size() != 1) {
+                // class path
-            throw new RuntimeException("The dokka-cli JAR could not be found.");
+                args.add("-cp");
+                args.add(jarList.stream().map(File::getAbsolutePath).collect(Collectors.joining(File.pathSeparator)));
             }
 
-        // -jar dokka-cli
+            // main class
-        args.add("-jar");
+            args.add("org.jetbrains.dokka.MainKt");
-        args.add(cli.get(0).getAbsolutePath());
 
             // -pluginClasspath
             if (!pluginsClasspath_.isEmpty()) {
@@ -262,6 +275,7 @@ public class DokkaOperation extends AbstractProcessOperation<DokkaOperation> {
             if (LOGGER.isLoggable(Level.FINE)) {
                 LOGGER.fine(String.join(" ", args));
             }
+        }
 
         return args;
     }

src/test/java/rife/bld/extension/DokkaOperationTest.java

@@ -16,11 +16,13 @@
 
 package rife.bld.extension;
 
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import rife.bld.blueprints.BaseProjectBlueprint;
 import rife.bld.extension.dokka.LoggingLevel;
 import rife.bld.extension.dokka.OutputFormat;
 import rife.bld.extension.dokka.SourceSet;
+import rife.bld.operations.exceptions.ExitStatusException;
 
 import java.io.File;
 import java.io.IOException;
@@ -29,11 +31,17 @@ import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.logging.ConsoleHandler;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 import java.util.stream.IntStream;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatCode;
 
 class DokkaOperationTest {
+    private static final File EXAMPLES = new File("examples");
     private static final String FILE_1 = "file1";
     private static final String FILE_2 = "file2";
     private static final String FILE_3 = "file3";
@@ -47,18 +55,28 @@ class DokkaOperationTest {
     private static final String PATH_3 = "path3";
     private static final String PATH_4 = "path4";
 
+    @BeforeAll
+    static void beforeAll() {
+        var level = Level.ALL;
+        var logger = Logger.getLogger("rife.bld.extension");
+        var consoleHandler = new ConsoleHandler();
+        consoleHandler.setLevel(level);
+        logger.addHandler(consoleHandler);
+        logger.setLevel(level);
+        logger.setUseParentHandlers(false);
+    }
+
     @Test
     void executeConstructProcessCommandListTest() throws IOException {
         var args = Files.readAllLines(Paths.get("src", "test", "resources", "dokka-args.txt"));
 
         assertThat(args).isNotEmpty();
 
-        var examples = new File("examples");
         var jsonConf = new File("config.json");
         var op = new DokkaOperation()
                 .delayTemplateSubstitution(true)
                 .failOnWarning(true)
-                .fromProject(new BaseProjectBlueprint(examples, "com.example", "Example"))
+                .fromProject(new BaseProjectBlueprint(EXAMPLES, "com.example", "Example"))
                 .globalLinks("s", "gLink1")
                 .globalLinks(Map.of("s2", "gLink2"))
                 .globalPackageOptions(OPTION_1, OPTION_2)
@@ -74,7 +92,7 @@ class DokkaOperationTest {
                 .moduleVersion("1.0")
                 .noSuppressObviousFunctions(true)
                 .offlineMode(true)
-                .outputDir(new File(examples, "build"))
+                .outputDir(new File(EXAMPLES, "build"))
                 .outputFormat(OutputFormat.JAVADOC)
                 .pluginConfigurations("name", "{\"json\"}")
                 .pluginConfigurations(Map.of("{\"name2\"}", "json2", "name3}", "{json3"))
@@ -107,10 +125,11 @@ class DokkaOperationTest {
             assertThat(found).as(p + " not found.").isTrue();
         }
 
-        var path = examples.getAbsolutePath();
+        var path = EXAMPLES.getAbsolutePath();
         var dokkaJar = "1.9.20.jar";
         var matches = List.of("java",
-                "-jar", path + "/lib/bld/dokka-cli-" + dokkaJar,
+                "-cp", path + "/lib/bld/dokka-cli-" + dokkaJar,
+                "org.jetbrains.dokka.MainKt",
                 "-pluginsClasspath", path + "/lib/bld/dokka-base-" + dokkaJar + ';' +
                         path + "/lib/bld/analysis-kotlin-descriptors-" + dokkaJar + ';' +
                         path + "/lib/bld/javadoc-plugin-" + dokkaJar + ';' +
@@ -146,4 +165,20 @@ class DokkaOperationTest {
             }
         });
     }
+
+    @Test
+    void executeNoProjectTest() {
+        var op = new DokkaOperation();
+        assertThatThrownBy(op::execute).isInstanceOf(ExitStatusException.class);
+    }
+
+    @Test
+    void executeTest() {
+        var op = new DokkaOperation()
+                .fromProject(
+                        new BaseProjectBlueprint(EXAMPLES, "com.example", "examples"))
+                .outputDir("build/javadoc")
+                .outputFormat(OutputFormat.JAVADOC);
+        assertThatCode(op::execute).doesNotThrowAnyException();
+    }
 }