Fixed glob resolution with multiple threads

src/class_diagram/generators/plantuml/class_diagram_generator.cc

@@ -278,7 +278,7 @@ void generator::generate_relationships(
                 target_alias = m_model.to_alias(destination);
             }
             catch (...) {
-                LOG_ERROR("Failed to find alias to {}", destination);
+                LOG_DBG("Failed to find alias to {}", destination);
                 continue;
             }
 

src/common/generators/plantuml/generator.h

@@ -335,7 +335,8 @@ template <typename DiagramModel, typename DiagramConfig,
     typename DiagramVisitor>
 std::unique_ptr<DiagramModel> generate(
     const clang::tooling::CompilationDatabase &db, const std::string &name,
-    DiagramConfig &config, bool verbose = false)
+    DiagramConfig &config, const std::vector<std::string> &translation_units,
+    bool verbose = false)
 {
     LOG_INFO("Generating diagram {}.puml", name);
 
@@ -344,24 +345,19 @@ std::unique_ptr<DiagramModel> generate(
     diagram->set_filter(
         std::make_unique<model::diagram_filter>(*diagram, config));
 
-    // Get all translation units matching the glob from diagram
+    LOG_DBG("Found translation units for diagram {}: {}", name,
-    // configuration
+        fmt::join(translation_units, ", "));
-    std::vector<std::string> translation_units{};
-    for (const auto &g : config.glob()) {
-        LOG_DBG("Processing glob: {}", g);
-
-        const auto matches = glob::rglob(g);
-        std::copy(matches.begin(), matches.end(),
-            std::back_inserter(translation_units));
-    }
-
-    LOG_DBG("Found translation units: {}", fmt::join(translation_units, ", "));
 
     clang::tooling::ClangTool clang_tool(db, translation_units);
     auto action_factory =
         std::make_unique<diagram_action_visitor_factory<DiagramModel,
             DiagramConfig, DiagramVisitor>>(*diagram, config);
-    clang_tool.run(action_factory.get());
+
+    auto res = clang_tool.run(action_factory.get());
+
+    if (res != 0) {
+        throw std::runtime_error("Diagram " + name + " generation failed");
+    }
 
     diagram->set_complete(true);
 
@@ -455,5 +451,4 @@ template <typename C, typename D> void generator<C, D>::init_env()
         return res;
     });
 }
-
+}
-}

src/config/config.cc

@@ -17,6 +17,7 @@
  */
 
 #include "config.h"
+#include "glob/glob.hpp"
 
 #include <filesystem>
 
@@ -101,6 +102,22 @@ void inheritable_diagram_options::inherit(
     relative_to.override(parent.relative_to);
 }
 
+std::vector<std::string> diagram::get_translation_units(
+    const std::filesystem::path &root_directory) const
+{
+    std::vector<std::string> translation_units{};
+
+    for (const auto &g : glob()) {
+        const auto matches = glob::glob(g, root_directory);
+        for (const auto &match : matches) {
+            const auto path = root_directory / match;
+            translation_units.emplace_back(path.string());
+        }
+    }
+
+    return translation_units;
+}
+
 common::model::diagram_t class_diagram::type() const
 {
     return common::model::diagram_t::kClass;

src/config/config.h

@@ -147,6 +147,9 @@ struct diagram : public inheritable_diagram_options {
 
     virtual common::model::diagram_t type() const = 0;
 
+    std::vector<std::string> get_translation_units(
+        const std::filesystem::path &root_directory) const;
+
     std::string name;
 };
 

src/include_diagram/visitor/translation_unit_visitor.cc

@@ -73,7 +73,7 @@ void translation_unit_visitor::include_visitor::InclusionDirective(
         visited_.find(include_path.string()) != visited_.end())
         return;
 
-    LOG_INFO("Processing include file {} in file {}", include_path.string(),
+    LOG_DBG("Processing include file {} in file {}", include_path.string(),
         current_file.string());
 
     visited_.emplace(include_path.string());

src/main.cc

@@ -47,7 +47,8 @@ bool check_output_directory(const std::string &dir);
 
 void generate_diagram(const std::string &od, const std::string &name,
     std::shared_ptr<clanguml::config::diagram> diagram,
-    const clang::tooling::CompilationDatabase &db, bool verbose);
+    const clang::tooling::CompilationDatabase &db,
+    const std::vector<std::string> &translation_units, bool verbose);
 
 int main(int argc, const char *argv[])
 {
@@ -105,17 +106,6 @@ int main(int argc, const char *argv[])
     LOG_INFO("Loading compilation database from {} directory",
         config.compilation_database_dir());
 
-    std::string err{};
-
-    auto db = clang::tooling::CompilationDatabase::autoDetectFromDirectory(
-        config.compilation_database_dir(), err);
-
-    if (!err.empty()) {
-        LOG_ERROR("Failed to load compilation database from {}",
-            config.compilation_database_dir());
-        return 1;
-    }
-
     auto od = config.output_directory();
     if (output_directory)
         od = output_directory.value();
@@ -126,15 +116,78 @@ int main(int argc, const char *argv[])
     util::thread_pool_executor generator_executor{thread_count};
     std::vector<std::future<void>> futs;
 
+    std::string err{};
+    auto db = clang::tooling::CompilationDatabase::autoDetectFromDirectory(
+        config.compilation_database_dir(), err);
+
+    if (!err.empty()) {
+        LOG_ERROR("Failed to load compilation database from {}",
+            config.compilation_database_dir());
+        return 1;
+    }
+
+    const auto compilation_database_files = db->getAllFiles();
+
+    const auto current_directory = std::filesystem::current_path();
+
+    std::map<std::string /* diagram name */,
+        std::vector<std::string> /*translation units*/>
+        translation_units_map;
+
+    // We have to generate the translation units list for each diagram before
+    // scheduling tasks, because std::filesystem::current_path cannot be trusted
+    // with multiple threads
     for (const auto &[name, diagram] : config.diagrams) {
         // If there are any specific diagram names provided on the command line,
         // and this diagram is not in that list - skip it
         if (!diagram_names.empty() && !util::contains(diagram_names, name))
             continue;
 
+        // Get all translation units matching the glob from diagram
+        // configuration
+        std::vector<std::string> translation_units =
+            diagram->get_translation_units(current_directory);
+
+        std::vector<std::string> valid_translation_units{};
+        std::copy_if(compilation_database_files.begin(),
+            compilation_database_files.end(),
+            std::back_inserter(valid_translation_units),
+            [&translation_units](const auto &tu) {
+                return std::find(translation_units.begin(),
+                           translation_units.end(),
+                           tu) != translation_units.end();
+            });
+
+        translation_units_map[name] = std::move(valid_translation_units);
+    }
+
+    for (const auto &[name, diagram] : config.diagrams) {
+        // If there are any specific diagram names provided on the command line,
+        // and this diagram is not in that list - skip it
+        if (!diagram_names.empty() && !util::contains(diagram_names, name))
+            continue;
+
+        const auto& valid_translation_units = translation_units_map[name];
+
+        if (valid_translation_units.empty()) {
+            LOG_ERROR(
+                "Diagram {} generation failed: no translation units found",
+                name);
+            continue;
+        }
+
         futs.emplace_back(generator_executor.add(
-            [&od, &name = name, &diagram = diagram, &db = db, verbose]() {
+            [&od, &name = name, &diagram = diagram, &config = config,
-                generate_diagram(od, name, diagram, *db, verbose);
+                db = std::ref(*db),
+                translation_units = std::move(valid_translation_units),
+                verbose]() {
+                try {
+                    generate_diagram(
+                        od, name, diagram, db, translation_units, verbose);
+                }
+                catch (std::runtime_error &e) {
+                    LOG_ERROR(e.what());
+                }
             }));
     }
 
@@ -147,7 +200,8 @@ int main(int argc, const char *argv[])
 
 void generate_diagram(const std::string &od, const std::string &name,
     std::shared_ptr<clanguml::config::diagram> diagram,
-    const clang::tooling::CompilationDatabase &db, bool verbose)
+    const clang::tooling::CompilationDatabase &db,
+    const std::vector<std::string> &translation_units, bool verbose)
 {
     using clanguml::common::model::diagram_t;
     using clanguml::config::class_diagram;
@@ -168,7 +222,8 @@ void generate_diagram(const std::string &od, const std::string &name,
         auto model =
             clanguml::common::generators::plantuml::generate<diagram_model,
                 diagram_config, diagram_visitor>(db, diagram->name,
-                dynamic_cast<diagram_config &>(*diagram), verbose);
+                dynamic_cast<diagram_config &>(*diagram), translation_units,
+                verbose);
 
         ofs << clanguml::class_diagram::generators::plantuml::generator(
             dynamic_cast<diagram_config &>(*diagram), *model);
@@ -182,7 +237,8 @@ void generate_diagram(const std::string &od, const std::string &name,
         auto model =
             clanguml::common::generators::plantuml::generate<diagram_model,
                 diagram_config, diagram_visitor>(db, diagram->name,
-                dynamic_cast<diagram_config &>(*diagram), verbose);
+                dynamic_cast<diagram_config &>(*diagram), translation_units,
+                verbose);
 
         ofs << clanguml::sequence_diagram::generators::plantuml::generator(
             dynamic_cast<clanguml::config::sequence_diagram &>(*diagram),
@@ -197,7 +253,8 @@ void generate_diagram(const std::string &od, const std::string &name,
         auto model =
             clanguml::common::generators::plantuml::generate<diagram_model,
                 diagram_config, diagram_visitor>(db, diagram->name,
-                dynamic_cast<diagram_config &>(*diagram), verbose);
+                dynamic_cast<diagram_config &>(*diagram), translation_units,
+                verbose);
 
         ofs << clanguml::package_diagram::generators::plantuml::generator(
             dynamic_cast<diagram_config &>(*diagram), *model);
@@ -211,7 +268,8 @@ void generate_diagram(const std::string &od, const std::string &name,
         auto model =
             clanguml::common::generators::plantuml::generate<diagram_model,
                 diagram_config, diagram_visitor>(db, diagram->name,
-                dynamic_cast<diagram_config &>(*diagram), verbose);
+                dynamic_cast<diagram_config &>(*diagram), translation_units,
+                verbose);
 
         ofs << clanguml::include_diagram::generators::plantuml::generator(
             dynamic_cast<diagram_config &>(*diagram), *model);

tests/test_cases.cc

@@ -60,7 +60,8 @@ generate_sequence_diagram(clang::tooling::CompilationDatabase &db,
 
     auto model = clanguml::common::generators::plantuml::generate<diagram_model,
         diagram_config, diagram_visitor>(db, diagram->name,
-        dynamic_cast<clanguml::config::sequence_diagram &>(*diagram));
+        dynamic_cast<clanguml::config::sequence_diagram &>(*diagram),
+        diagram->get_translation_units(std::filesystem::current_path()));
 
     return model;
 }
@@ -77,8 +78,9 @@ std::unique_ptr<clanguml::class_diagram::model::diagram> generate_class_diagram(
     inject_diagram_options(diagram);
 
     auto model = clanguml::common::generators::plantuml::generate<diagram_model,
-        diagram_config, diagram_visitor>(
+        diagram_config, diagram_visitor>(db, diagram->name,
-        db, diagram->name, dynamic_cast<diagram_config &>(*diagram));
+        dynamic_cast<diagram_config &>(*diagram),
+        diagram->get_translation_units(std::filesystem::current_path()));
 
     return model;
 }
@@ -95,8 +97,9 @@ generate_package_diagram(clang::tooling::CompilationDatabase &db,
     inject_diagram_options(diagram);
 
     return clanguml::common::generators::plantuml::generate<diagram_model,
-        diagram_config, diagram_visitor>(
+        diagram_config, diagram_visitor>(db, diagram->name,
-        db, diagram->name, dynamic_cast<diagram_config &>(*diagram));
+        dynamic_cast<diagram_config &>(*diagram),
+        diagram->get_translation_units(std::filesystem::current_path()));
 }
 
 std::unique_ptr<clanguml::include_diagram::model::diagram>
@@ -111,8 +114,9 @@ generate_include_diagram(clang::tooling::CompilationDatabase &db,
     inject_diagram_options(diagram);
 
     return clanguml::common::generators::plantuml::generate<diagram_model,
-        diagram_config, diagram_visitor>(
+        diagram_config, diagram_visitor>(db, diagram->name,
-        db, diagram->name, dynamic_cast<diagram_config &>(*diagram));
+        dynamic_cast<diagram_config &>(*diagram),
+        diagram->get_translation_units(std::filesystem::current_path()));
 }
 
 std::string generate_sequence_puml(