cli: Add lint subcommand

Author: neptuwunium

cli/CMakeLists.txt

@@ -13,6 +13,7 @@ set(PLCLI_SOURCES
         source/subcommands/run.cpp
         source/subcommands/docs.cpp
         source/subcommands/info.cpp
+        source/subcommands/lint.cpp
 )
 
 if (LIBPL_BUILD_CLI_AS_EXECUTABLE)

cli/include/pl/cli/helpers/utils.hpp

@@ -7,6 +7,12 @@
 
 namespace pl::cli {
 
+    void configureRuntime(
+            PatternLanguage &runtime,
+            const std::vector<std::fs::path> &includePaths,
+            const std::vector<std::string> &defines,
+            bool allowDangerousFunctions);
+
     void executePattern(
             PatternLanguage &runtime,
             wolv::io::File &inputFilePath,
@@ -15,4 +21,5 @@ namespace pl::cli {
             const std::vector<std::string> &defines,
             bool allowDangerousFunctions,
             u64 baseAddress);
-}
+
+}

cli/source/helpers/utils.cpp

@@ -26,14 +26,11 @@ namespace pl::cli {
         return result;
     }
 
-    void executePattern(
+    void configureRuntime(
             PatternLanguage &runtime,
-            wolv::io::File &inputFile,
-            wolv::io::File &patternFile,
             const std::vector<std::fs::path> &includePaths,
             const std::vector<std::string> &defines,
-            bool allowDangerousFunctions,
-            u64 baseAddress) {
+            bool allowDangerousFunctions) {
 
         runtime.setDangerousFunctionCallHandler([&]() {
             return allowDangerousFunctions;
@@ -43,6 +40,18 @@ namespace pl::cli {
 
         for (const auto &define : defines)
             runtime.addDefine(define);
+    }
+
+    void executePattern(
+            PatternLanguage &runtime,
+            wolv::io::File &inputFile,
+            wolv::io::File &patternFile,
+            const std::vector<std::fs::path> &includePaths,
+            const std::vector<std::string> &defines,
+            bool allowDangerousFunctions,
+            u64 baseAddress) {
+
+        configureRuntime(runtime, includePaths, defines, allowDangerousFunctions);
 
         if (inputFile.isValid()) {
             // Include baseAddress as a copy to prevent it from going out of scope in the lambda

cli/source/main.cpp

@@ -16,6 +16,7 @@ namespace pl::cli {
         void addRunSubcommand(CLI::App *app);
         void addDocsSubcommand(CLI::App *app);
         void addInfoSubcommand(CLI::App *app);
+        void addLintSubcommand(CLI::App *app);
 
     }
 
@@ -30,6 +31,7 @@ namespace pl::cli {
         sub::addRunSubcommand(&app);
         sub::addDocsSubcommand(&app);
         sub::addInfoSubcommand(&app);
+        sub::addLintSubcommand(&app);
 
         // Print help message if not enough arguments were provided
         if (args.size() == 0) {
@@ -76,4 +78,4 @@ namespace pl::cli {
 
         return pl::cli::executeCommandLineInterface(args);
     }
-#endif
+#endif

cli/source/subcommands/lint.cpp

@@ -0,0 +1,78 @@
+#include <pl/pattern_language.hpp>
+#include <pl/formatters.hpp>
+#include <wolv/io/file.hpp>
+
+#include <pl/cli/helpers/utils.hpp>
+
+#include <CLI/CLI.hpp>
+#include <CLI/App.hpp>
+#include <fmt/format.h>
+
+#include <nlohmann/json.hpp>
+
+namespace pl::cli::sub {
+
+    void addLintSubcommand(CLI::App *app) {
+        static std::fs::path patternFilePath;
+        static std::vector<std::fs::path> includePaths;
+        static std::vector<std::string> defines;
+
+        static bool allowDangerousFunctions = false;
+        static bool outputJson = false;
+
+        auto subcommand = app->add_subcommand("lint", "Compiles the given pattern");
+
+        // Add command line arguments
+        subcommand->add_option("-p,--pattern,PATTERN_FILE", patternFilePath, "Pattern file")->required()->check(CLI::ExistingFile);
+        subcommand->add_option("-I,--includes", includePaths, "Include file paths")->take_all()->check(CLI::ExistingDirectory);
+        subcommand->add_option("-D,--define", defines, "Define a preprocessor macro")->take_all();
+        subcommand->add_flag("-d,--dangerous", allowDangerousFunctions, "Allow dangerous functions")->default_val(false);
+        subcommand->add_flag("-j,--json", outputJson, "Output JSON instead of text")->default_val(false);
+
+        subcommand->callback([] {
+            // Open pattern file
+            wolv::io::File patternFile(patternFilePath, wolv::io::File::Mode::Read);
+            if (!patternFile.isValid()) {
+                ::fmt::print("Failed to open file '{}'\n", patternFilePath.string());
+                std::exit(EXIT_FAILURE);
+            }
+
+            // Create and configure Pattern Language runtime
+            pl::PatternLanguage runtime;
+
+            pl::cli::configureRuntime(runtime, includePaths, defines, allowDangerousFunctions);
+
+            const auto code = patternFile.readString();
+            const auto source = wolv::util::toUTF8String(patternFile.getPath());
+            auto _ = runtime.parseString(code, source);
+            
+            auto compileErrors = runtime.getCompileErrors();
+            ::nlohmann::json errors = ::nlohmann::json::array();
+            if (compileErrors.size() > 0) {
+                for (const auto &error : compileErrors) {
+                    if (outputJson) {
+                        ::nlohmann::json obj;
+                        obj["message"] = error.getMessage();
+                        obj["description"] = error.getDescription();
+                        
+                        ::nlohmann::json loc;
+                        const auto &location = error.getLocation();
+                        loc["line"] = location.line;
+                        loc["column"] = location.column;
+                        loc["source"] = location.source->source;
+                        obj["location"] = loc;
+
+                        errors.emplace_back(obj);
+                    } else {
+                        ::fmt::print("{}\n", error.format());
+                    }
+                }
+            }
+            
+            if(outputJson) {
+                ::fmt::print("{}\n", errors.dump());
+            }
+        });
+    }
+
+}