Tool integration with spi

cli/ballerina-cli/src/main/java/io/ballerina/cli/cmd/BuildCommand.java

@@ -24,6 +24,7 @@
 import io.ballerina.cli.task.CreateExecutableTask;
 import io.ballerina.cli.task.DumpBuildTimeTask;
 import io.ballerina.cli.task.ResolveMavenDependenciesTask;
+import io.ballerina.cli.task.RunBallerinaPreBuildToolsTask;
 import io.ballerina.cli.utils.BuildTime;
 import io.ballerina.cli.utils.FileUtils;
 import io.ballerina.projects.BuildOptions;
@@ -176,6 +177,9 @@ public BuildCommand() {
             hidden = true)
     private Boolean exportComponentModel;
 
+    @CommandLine.Option(names = "--x", description = "",
+            hidden = true)
+    private String x;
     @CommandLine.Option(names = "--enable-cache", description = "enable caches for the compilation", hidden = true)
     private Boolean enableCache;
 
@@ -277,6 +281,7 @@ public void execute() {
         TaskExecutor taskExecutor = new TaskExecutor.TaskBuilder()
                 // clean the target directory(projects only)
                 .addTask(new CleanTargetDirTask(isPackageModified, buildOptions.enableCache()), isSingleFileBuild)
+                .addTask(new RunBallerinaPreBuildToolsTask(outStream))
                 // resolve maven dependencies in Ballerina.toml
                 .addTask(new ResolveMavenDependenciesTask(outStream))
                 // compile the modules

cli/ballerina-cli/src/main/java/io/ballerina/cli/cmd/CleanCommand.java

@@ -42,8 +42,9 @@
 public class CleanCommand implements BLauncherCmd {
     private final PrintStream outStream;
     private final Path projectPath;
+    private Path generatedDir;
     private boolean exitWhenFinish;
-    
+
     @CommandLine.Option(names = {"--help", "-h"}, hidden = true)
     private boolean helpFlag;
 
@@ -62,9 +63,9 @@ public CleanCommand() {
         this.exitWhenFinish = true;
     }
 
-    public CleanCommand(Path projectPath, boolean exitWhenFinish, Path targetDir) {
+    public CleanCommand(Path projectPath, PrintStream printStream, boolean exitWhenFinish, Path targetDir) {
         this.projectPath = projectPath;
-        this.outStream =  System.out;
+        this.outStream =  printStream;
         this.exitWhenFinish = exitWhenFinish;
         this.targetDir = targetDir;
     }
@@ -93,18 +94,40 @@ public void execute() {
             CommandUtil.printError(this.outStream,
                     "provided target directory '" + this.targetDir + "' does not exist.",
                     null, false);
+        } else if (!Files.isDirectory(this.targetDir)) {
+            CommandUtil.printError(this.outStream,
+                    "provided target path '" + this.targetDir + "' is not a directory.",
+                    null, false);
+        } else {
+            ProjectUtils.deleteDirectory(this.targetDir);
+            this.outStream.println("Successfully deleted '" + this.targetDir + "'.");
+        }
+
+        //delete the generated directory
+        try {
+            Project project = BuildProject.load(this.projectPath);
+            this.generatedDir = project.sourceRoot().resolve(ProjectConstants.GENERATED_MODULES_ROOT);
+        } catch (ProjectException e) {
+            CommandUtil.printError(this.outStream, e.getMessage(), null, false);
             CommandUtil.exitError(this.exitWhenFinish);
             return;
         }
-        if (!Files.isDirectory(this.targetDir)) {
+        if (Files.notExists(this.generatedDir)) {
             CommandUtil.printError(this.outStream,
-                    "provided target path '" + this.targetDir + "' is not a directory.",
+                    "generated directory '" + this.generatedDir + "' does not exist.",
+                    null, false);
+            CommandUtil.exitError(this.exitWhenFinish);
+            return;
+        }
+        if (!Files.isDirectory(this.generatedDir)) {
+            CommandUtil.printError(this.outStream,
+                    "generated path is not a directory.",
                     null, false);
             CommandUtil.exitError(this.exitWhenFinish);
             return;
         }
-        ProjectUtils.deleteDirectory(this.targetDir);
-        this.outStream.println("Successfully deleted '" + this.targetDir + "'.");
+        ProjectUtils.deleteDirectory(this.generatedDir);
+        this.outStream.println("Successfully deleted '" + this.generatedDir + "'.");
     }
 
     @Override

cli/ballerina-cli/src/main/java/io/ballerina/cli/launcher/LauncherUtils.java

@@ -125,6 +125,7 @@ static String generateCommandHelp(String commandName, Map<String, CommandLine> s
     }
 
     private static void generateCommandDescription(CommandLine command, StringBuilder stringBuilder) {
+
         String commandName = command.getCommandName();
         BLauncherCmd bLauncherCmd = (BLauncherCmd) command.getCommandSpec().userObject();
         CommandLine.Command annotation = bLauncherCmd.getClass().getAnnotation(CommandLine.Command.class);

cli/ballerina-cli/src/main/java/io/ballerina/cli/launcher/Main.java

@@ -89,6 +89,7 @@ private static Optional<BLauncherCmd> getInvokedCmd(String... args) {
 
             for (BLauncherCmd bCmd : bCmds) {
                 cmdParser.addSubcommand(bCmd.getName(), bCmd);
+//                cmdParser.setDefaultValueProvider(new SimpleDefaultProvider());
                 bCmd.setParentCmdParser(cmdParser);
             }
 
@@ -436,3 +437,4 @@ public void setParentCmdParser(CommandLine parentCmdParser) {
         }
     }
 }
+

cli/ballerina-cli/src/main/java/io/ballerina/cli/task/RunBallerinaPreBuildToolsTask.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2023, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
+ *
+ * WSO2 Inc. 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
+ *
+ *   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 io.ballerina.cli.task;
+
+import io.ballerina.cli.tool.BuildToolRunner;
+import io.ballerina.cli.utils.FileUtils;
+import io.ballerina.projects.Project;
+import io.ballerina.projects.ProjectException;
+import io.ballerina.projects.ToolContext;
+import io.ballerina.tools.diagnostics.Diagnostic;
+import io.ballerina.tools.diagnostics.DiagnosticSeverity;
+
+import java.io.IOException;
+import java.io.PrintStream;
+import java.util.Collection;
+import java.util.List;
+import java.util.ServiceLoader;
+
+import static io.ballerina.cli.launcher.LauncherUtils.createLauncherException;
+import static io.ballerina.projects.PackageManifest.Tool;
+
+/**
+ * Run .
+ */
+public class RunBallerinaPreBuildToolsTask implements Task {
+
+    private final PrintStream outStream;
+
+    public RunBallerinaPreBuildToolsTask(PrintStream out) {
+        this.outStream = out;
+    }
+
+    @Override
+    public void execute(Project project) {
+        Collection<Diagnostic> toolDiagnostics = project.currentPackage().manifest().diagnostics().diagnostics();
+        boolean hasTomlErrors = false;
+        for (Diagnostic d: toolDiagnostics) {
+            if (d.diagnosticInfo().severity().equals(DiagnosticSeverity.ERROR)) {
+                System.out.println(d);
+                hasTomlErrors = true;
+            }
+        }
+        if (hasTomlErrors) {
+            throw createLauncherException("Ballerina toml validation for pre build tool execution contains errors");
+        }
+        List<Tool> tools = project.currentPackage().manifest().tools();
+        ServiceLoader<BuildToolRunner> buildRunners = ServiceLoader.load(BuildToolRunner.class);
+        for (Tool tool : tools) {
+            try {
+                String commandName = tool.getType();
+                BuildToolRunner targetTool = null;
+                for (BuildToolRunner buildRunner : buildRunners) {
+                    if (buildRunner.getToolName().equals(commandName)) {
+                        targetTool = buildRunner;
+                        break;
+                    }
+                }
+                if (targetTool != null) {
+                    try {
+                        if (tool.getOptionsToml() != null) {
+                            boolean hasErrors = FileUtils.validateToml(tool.getOptionsToml(), tool.getType());
+                            if (hasErrors) {
+                                throw new ProjectException(
+                                    "Ballerina toml validation for pre build tool execution contains errors");
+                            }
+                        }
+                    } catch (IOException e) {
+                        outStream.println("WARNING: Skipping the validation of tool options due to : " +
+                            e.getMessage());
+                    }
+                    ToolContext toolContext = ToolContext.from(tool, project.currentPackage());
+                    targetTool.executeTool(toolContext);
+                    boolean hasToolErrors = false;
+                    for (Diagnostic d : targetTool.diagnostics()) {
+                        outStream.println(d);
+                        if (d.diagnosticInfo().severity().equals(DiagnosticSeverity.ERROR)) {
+                            hasToolErrors = true;
+                        }
+                    }
+                    if (hasToolErrors) {
+                        throw new ProjectException("Pre build tool " + tool.getType() + " execution contains errors");
+                    }
+                } else {
+                    // TODO: Install tool if not found
+                    outStream.println("Command not found: " + commandName);
+                }
+            } catch (ProjectException e) {
+                throw createLauncherException(e.getMessage());
+            }
+        }
+
+    }
+
+}

cli/ballerina-cli/src/main/java/io/ballerina/cli/tool/BuildToolRunner.java

@@ -0,0 +1,14 @@
+package io.ballerina.cli.tool;
+
+import io.ballerina.projects.ToolContext;
+import io.ballerina.tools.diagnostics.Diagnostic;
+
+import java.util.List;
+
+public interface BuildToolRunner {
+    void executeTool(ToolContext toolContext);
+
+    String getToolName();
+
+    List<Diagnostic> diagnostics();
+}

cli/ballerina-cli/src/main/java/io/ballerina/cli/utils/FileUtils.java

@@ -18,6 +18,18 @@
 
 package io.ballerina.cli.utils;
 
+import io.ballerina.toml.api.Toml;
+import io.ballerina.toml.validator.TomlValidator;
+import io.ballerina.toml.validator.schema.Schema;
+import io.ballerina.tools.diagnostics.Diagnostic;
+import io.ballerina.tools.diagnostics.DiagnosticSeverity;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Path;
 import java.util.Optional;
 
@@ -88,4 +100,43 @@ private static int indexOfLastSeparator(String filename) {
             return Math.max(lastUnixPos, lastWindowsPos);
         }
     }
+
+    public static String readSchema(String toolName) throws IOException {
+        String schemaFilePath = toolName + "-options-schema.json";
+        InputStream inputStream = io.ballerina.projects.util.FileUtils.class.getClassLoader().getResourceAsStream(schemaFilePath);
+
+        if (inputStream == null) {
+            throw new FileNotFoundException("Schema file for tool options inputStream not found: " + schemaFilePath);
+        }
+        StringBuilder sb = new StringBuilder();
+        try (
+                InputStreamReader inputStreamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
+                BufferedReader br = new BufferedReader(inputStreamReader);
+        ) {
+            String content;
+            while ((content = br.readLine()) != null) {
+                if (sb.length() > 0) {
+                    sb.append('\n');
+                }
+                sb.append(content);
+            }
+        }
+
+        return sb.toString();
+    }
+
+    public static boolean validateToml(Toml optionsToml, String toolName) throws IOException {
+        boolean hasErrors = false;
+        Schema schema = Schema.from(FileUtils.readSchema(toolName));
+        TomlValidator tomlValidator = new TomlValidator(schema);
+        tomlValidator.validate(optionsToml);
+        for (Diagnostic d : optionsToml.diagnostics()) {
+            System.out.println(d);
+            if (d.diagnosticInfo().severity().equals(DiagnosticSeverity.ERROR)) {
+                hasErrors = true;
+            }
+        }
+        return hasErrors;
+    }
+
 }

cli/ballerina-cli/src/main/java/module-info.java

@@ -4,6 +4,7 @@
     exports io.ballerina.cli.launcher;
     exports io.ballerina.cli.utils;
     exports io.ballerina.cli.cmd;
+    exports io.ballerina.cli.tool;
 
     requires io.ballerina.runtime;
     requires io.ballerina.lang;