feat: support CMAKE_ROOT

Author: alandefreitas

src/lib/Lib/CMakeExecution.cpp

@@ -24,7 +24,16 @@ namespace {
 Expected<std::string>
 getCmakePath()
 {
-    llvm::ErrorOr<std::string> const path = llvm::sys::findProgramByName("cmake");
+    llvm::ErrorOr<std::string> path = llvm::sys::findProgramByName("cmake");
+    if (!path)
+    {
+        char const* const cmakeRootPath = std::getenv("CMAKE_ROOT");
+        if (cmakeRootPath != nullptr)
+        {
+            std::string cmakeBinPath = files::appendPath(cmakeRootPath, "bin");
+            path = llvm::sys::findProgramByName("cmake", {cmakeBinPath, cmakeRootPath});
+        }
+    }
     MRDOCS_CHECK(path, "CMake executable not found");
     std::optional<llvm::StringRef> const redirects[] = {llvm::StringRef(), llvm::StringRef(), llvm::StringRef()};
     std::vector<llvm::StringRef> const args = {*path, "--version"};
@@ -452,20 +461,15 @@ executeCmakeExportCompileCommands(llvm::StringRef projectPath, llvm::StringRef c
     MRDOCS_CHECK(llvm::sys::fs::exists(projectPath), "Project path does not exist");
     MRDOCS_TRY(auto const cmakePath, getCmakePath());
 
-    ScopedTempFile const errorPath("cmake-error", "txt");
-    MRDOCS_CHECK(errorPath, "Failed to create temporary file");
-
-    std::optional<llvm::StringRef> const redirects[] = {llvm::StringRef(), llvm::StringRef(), errorPath.path()};
+    std::array<std::optional<llvm::StringRef>, 3> const redirects = {std::nullopt, std::nullopt, std::nullopt};
     std::vector<llvm::StringRef> args = {cmakePath, "-S", projectPath, "-B", buildDir, "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"};
 
     auto const additionalArgs = parseBashArgs(cmakeArgs.str());
     MRDOCS_TRY(pushCMakeArgs(cmakePath, args, additionalArgs));
 
     int const result = llvm::sys::ExecuteAndWait(cmakePath, args, std::nullopt, redirects);
     if (result != 0) {
-        auto bufferOrError = llvm::MemoryBuffer::getFile(errorPath.path());
-        MRDOCS_CHECK(bufferOrError, "CMake execution failed (no error output available)");
-        return Unexpected(Error("CMake execution failed: \n" + bufferOrError.get()->getBuffer().str()));
+        return Unexpected(Error("CMake execution failed"));
     }
 
     llvm::SmallString<128> compileCommandsPath(buildDir);

src/tool/GenerateAction.cpp

@@ -67,7 +67,9 @@ generateCompileCommandsFile(llvm::StringRef inputPath, llvm::StringRef cmakeArgs
     auto const fileName = files::getFileName(inputPath);
     if (fileName == "CMakeLists.txt")
     {
-        return executeCmakeExportCompileCommands(files::getParentDir(inputPath), cmakeArgs, buildDir);
+        std::string cmakeSourceDir = files::getParentDir(inputPath);
+        return executeCmakeExportCompileCommands(
+            cmakeSourceDir, cmakeArgs, buildDir);
     }
 
     // --------------------------------------------------------------
@@ -85,47 +87,59 @@ generateCompileCommandsFile(llvm::StringRef inputPath, llvm::StringRef cmakeArgs
 
 
 Expected<void>
-DoGenerateAction(std::string_view execPath, char const** argv)
+DoGenerateAction(
+    std::string const& configPath,
+    Config::Settings::ReferenceDirectories const& dirs,
+    char const** argv)
 {
     // --------------------------------------------------------------
     //
     // Load configuration
     //
     // --------------------------------------------------------------
     Config::Settings publicSettings;
-    MRDOCS_TRY(toolArgs.apply(publicSettings, execPath, argv));
-    ThreadPool threadPool(toolArgs.concurrency);
+    MRDOCS_TRY(Config::Settings::load_file(publicSettings, configPath, dirs));
+    MRDOCS_TRY(toolArgs.apply(publicSettings, dirs, argv));
+    MRDOCS_TRY(publicSettings.normalize(dirs));
+    ThreadPool threadPool(publicSettings.concurrency);
     MRDOCS_TRY(
         std::shared_ptr<ConfigImpl const> config,
-        loadConfigFile(publicSettings, nullptr, threadPool));
+        ConfigImpl::load(publicSettings, dirs, threadPool));
 
     // --------------------------------------------------------------
     //
     // Load generator
     //
     // --------------------------------------------------------------
-    auto const& settings = config->settings();
+    auto& settings = config->settings();
     MRDOCS_TRY(
         Generator const& generator,
-        getGenerators().find(settings.generate),
+        getGenerators().find(to_string(settings.generate)),
         formatError(
             "the Generator \"{}\" was not found",
-            config->settings().generate));
+            to_string(config->settings().generate)));
 
     // --------------------------------------------------------------
     //
     // Find or generate the compile_commands.json
     //
     // --------------------------------------------------------------
+    std::string compilationDatabasePath = settings.compilationDatabase;
+    if (compilationDatabasePath.empty())
+    {
+        std::string c = files::appendPath(settings.sourceRoot, "CMakeLists.txt");
+        if (files::exists(c)) {
+            compilationDatabasePath = c;
+        }
+    }
     MRDOCS_CHECK(
-        settings.compilationDatabase,
+        compilationDatabasePath,
         "The compilation database path argument is missing");
     ScopedTempDirectory tempDir("mrdocs");
+    std::string buildPath = files::appendPath(tempDir.path(), "build");
     Expected<std::string> const compileCommandsPathExp =
         generateCompileCommandsFile(
-            settings.compilationDatabase,
-            settings.cmake,
-            files::appendPath(tempDir.path(), "build"));
+            compilationDatabasePath, settings.cmake, buildPath);
     if (!compileCommandsPathExp)
     {
         report::error(
@@ -142,21 +156,27 @@ DoGenerateAction(std::string_view execPath, char const** argv)
     std::string compileCommandsPath = files::normalizePath(*compileCommandsPathExp);
     MRDOCS_TRY(compileCommandsPath, files::makeAbsolute(compileCommandsPath));
     std::string errorMessage;
-    MRDOCS_TRY_MSG(
-        auto& compileCommands,
+    std::unique_ptr<clang::tooling::JSONCompilationDatabase>
+        jsonDatabasePtr =
         tooling::JSONCompilationDatabase::loadFromFile(
             compileCommandsPath,
             errorMessage,
-            tooling::JSONCommandLineSyntax::AutoDetect),
-        std::move(errorMessage));
+            tooling::JSONCommandLineSyntax::AutoDetect);
+    if (!jsonDatabasePtr)
+    {
+        return Unexpected(formatError(
+            "Failed to load compilation database: {}", errorMessage));
+    }
+    clang::tooling::JSONCompilationDatabase& jsonDatabase = *jsonDatabasePtr;
 
-    // Custom compilation database that converts relative paths to absolute
-    auto const defaultIncludePaths = getCompilersDefaultIncludeDir(compileCommands);
+    // Custom compilation database that applies settings from the configuration
+    auto const defaultIncludePaths = getCompilersDefaultIncludeDir(
+        jsonDatabase);
     auto compileCommandsDir = files::getParentDir(compileCommandsPath);
-    MRDOCS_ASSERT(files::isDirsy(compileCommandsDir));
     MrDocsCompilationDatabase compilationDatabase(
         compileCommandsDir,
-        compileCommands, config,
+        jsonDatabase,
+        config,
         defaultIncludePaths);
 
     // --------------------------------------------------------------
@@ -187,6 +207,13 @@ DoGenerateAction(std::string_view execPath, char const** argv)
             (*config)->configDir));
     report::info("Generating docs\n");
     MRDOCS_TRY(generator.build(absOutput, *corpus));
+
+    // --------------------------------------------------------------
+    //
+    // Clean temp files
+    //
+    // --------------------------------------------------------------
+
     return {};
 }