Added support for nested classes and enums

src/cx/cursor.h

@@ -69,15 +69,33 @@ public:
         return spelling() == "void";
     }
 
+    /**
+     * @brief Return fully qualified cursor spelling
+     *
+     * This method generates a fully qualified name for the cursor by
+     * traversing the namespaces upwards.
+     *
+     * TODO: Add caching of this value.
+     *
+     * @return Fully qualified cursor spelling
+     */
     std::string fully_qualified() const
     {
         std::list<std::string> res;
         cursor iterator{m_cursor};
+        if (iterator.spelling().empty())
+            return {};
+
+        int limit = 100;
         while (iterator.kind() != CXCursor_TranslationUnit) {
             auto name = iterator.spelling();
             if (!name.empty())
                 res.push_front(iterator.spelling());
             iterator = iterator.semantic_parent();
+            if (limit-- == 0)
+                throw std::runtime_error(fmt::format(
+                    "Generating fully qualified name for '{}' failed at: '{}'",
+                    spelling(), fmt::join(res, "::")));
         }
 
         return fmt::format("{}", fmt::join(res, "::"));

src/puml/class_diagram_generator.h

@@ -99,7 +99,8 @@ public:
         else
             ostr << "class ";
 
-        ostr << c.name << " {" << std::endl;
+        ostr << namespace_relative(m_config.using_namespace, c.name) << " {"
+             << std::endl;
 
         //
         // Process methods
@@ -148,18 +149,20 @@ public:
         }
 
         for (const auto &r : c.relationships) {
-            // only add UML relationships to classes in the diagram
+            ostr << namespace_relative(m_config.using_namespace, c.name) << " "
-            if (m_config.has_class(r.destination))
+                 << to_string(r.type) << " "
-                ostr << c.name << " " << to_string(r.type) << " "
+                 << namespace_relative(m_config.using_namespace, r.destination);
-                     << namespace_relative(
+            if (!r.label.empty())
-                            m_config.using_namespace, r.destination)
+                ostr << " : " << r.label;
-                     << " : " << r.label << std::endl;
+
+            ostr << std::endl;
         }
     }
 
     void generate(const enum_ &e, std::ostream &ostr) const
     {
-        ostr << "Enum " << e.name << " {" << std::endl;
+        ostr << "Enum " << namespace_relative(m_config.using_namespace, e.name)
+             << " {" << std::endl;
 
         for (const auto &enum_constant : e.constants) {
             ostr << enum_constant << std::endl;
@@ -235,7 +238,7 @@ clanguml::model::class_diagram::diagram generate(
         spdlog::debug("Cursor name: {}",
             clang_getCString(clang_getCursorDisplayName(cursor)));
 
-        clanguml::visitor::class_diagram::tu_context ctx(d);
+        clanguml::visitor::class_diagram::tu_context ctx(d, diagram);
         auto res = clang_visitChildren(cursor,
             clanguml::visitor::class_diagram::translation_unit_visitor, &ctx);
         spdlog::debug("Processing result: {}", res);

src/uml/class_diagram_visitor.h

@@ -42,33 +42,26 @@ using clanguml::model::class_diagram::enum_;
 using clanguml::model::class_diagram::relationship_t;
 using clanguml::model::class_diagram::scope_t;
 
-template <typename T> struct element_visitor_context {
-    element_visitor_context(T &e)
-        : element(e)
-    {
-    }
-    CXCursorKind current_cursor_kind;
-    std::vector<std::string> namespace_;
-
-    T &element;
-};
-
-struct class_visitor_context : element_visitor_context<class_> {
-    class_visitor_context(class_ &c)
-        : element_visitor_context<class_>(c)
-    {
-    }
-    scope_t scope;
-};
-
 struct tu_context {
-    tu_context(diagram &d_)
+    tu_context(diagram &d_, const clanguml::config::class_diagram &config_)
         : d{d_}
+        , config{config_}
     {
     }
 
     std::vector<std::string> namespace_;
     class_diagram::diagram &d;
+    const clanguml::config::class_diagram &config;
+};
+
+template <typename T> struct element_visitor_context {
+    element_visitor_context(T &e)
+        : element(e)
+    {
+    }
+    tu_context *ctx;
+
+    T &element;
 };
 
 enum CXChildVisitResult visit_if_cursor_valid(
@@ -113,22 +106,22 @@ scope_t cx_access_specifier_to_scope(CX_CXXAccessSpecifier as)
 static enum CXChildVisitResult enum_visitor(
     CXCursor cx_cursor, CXCursor cx_parent, CXClientData client_data)
 {
-    auto e = (struct enum_ *)client_data;
+    auto ctx = (element_visitor_context<enum_> *)client_data;
 
     cx::cursor cursor{std::move(cx_cursor)};
     cx::cursor parent{std::move(cx_parent)};
 
-    spdlog::info("Visiting enum {}: {} - {}:{}", e->name, cursor.spelling(),
+    spdlog::info("Visiting enum {}: {} - {}:{}", ctx->element.name,
-        cursor.kind());
+        cursor.spelling(), cursor.kind());
 
     enum CXChildVisitResult ret = CXChildVisit_Break;
     switch (cursor.kind()) {
         case CXCursor_EnumConstantDecl:
-            visit_if_cursor_valid(cursor, [e](cx::cursor cursor) {
+            visit_if_cursor_valid(cursor, [ctx](cx::cursor cursor) {
-                spdlog::info(
+                spdlog::info("Adding enum constant {}::{}", ctx->element.name,
-                    "Adding enum constant {}::{}", e->name, cursor.spelling());
+                    cursor.spelling());
 
-                e->constants.emplace_back(cursor.spelling());
+                ctx->element.constants.emplace_back(cursor.spelling());
             });
 
             ret = CXChildVisit_Continue;
@@ -144,25 +137,94 @@ static enum CXChildVisitResult enum_visitor(
 static enum CXChildVisitResult class_visitor(
     CXCursor cx_cursor, CXCursor cx_parent, CXClientData client_data)
 {
-    auto c = (struct class_ *)client_data;
+    auto ctx = (element_visitor_context<class_> *)client_data;
 
     cx::cursor cursor{std::move(cx_cursor)};
     cx::cursor parent{std::move(cx_parent)};
 
     std::string cursor_name_str = cursor.spelling();
 
-    spdlog::info("Visiting {}: {} - {}:{}", c->is_struct ? "struct" : "class",
+    spdlog::info("Visiting {}: {} - {}:{}",
-        c->name, cursor_name_str, cursor.kind());
+        ctx->element.is_struct ? "struct" : "class", ctx->element.name,
+        cursor_name_str, cursor.kind());
+
+    auto &config = ctx->ctx->config;
 
     enum CXChildVisitResult ret = CXChildVisit_Break;
     bool is_constructor{false};
     bool is_destructor{false};
+    bool is_struct{false};
+    bool is_vardecl{false};
     switch (cursor.kind()) {
+        case CXCursor_StructDecl:
+            is_struct = true;
+        case CXCursor_ClassDecl:
+        case CXCursor_ClassTemplate:
+            if (!config.should_include(cursor.fully_qualified())) {
+                ret = CXChildVisit_Continue;
+                break;
+            }
+
+            visit_if_cursor_valid(cursor, [ctx, is_struct](cx::cursor cursor) {
+                class_ c{};
+                c.is_struct = is_struct;
+                c.name = cursor.fully_qualified();
+                c.namespace_ = ctx->ctx->namespace_;
+
+                auto class_ctx = element_visitor_context<class_>(c);
+                class_ctx.ctx = ctx->ctx;
+
+                clang_visitChildren(cursor.get(), class_visitor, &class_ctx);
+
+                class_relationship containment;
+                containment.type = relationship_t::kContainment;
+                containment.destination = c.name;
+                ctx->element.relationships.emplace_back(std::move(containment));
+
+                spdlog::info(
+                    "Added relationship {} +-- {}", ctx->element.name, c.name);
+
+                ctx->ctx->d.classes.emplace_back(std::move(c));
+            });
+            break;
+        case CXCursor_EnumDecl:
+            if (!config.should_include(cursor.fully_qualified())) {
+                ret = CXChildVisit_Continue;
+                break;
+            }
+
+            visit_if_cursor_valid(cursor, [ctx, is_struct](cx::cursor cursor) {
+                enum_ e{};
+                e.name = cursor.fully_qualified();
+                e.namespace_ = ctx->ctx->namespace_;
+
+                auto enum_ctx = element_visitor_context<enum_>(e);
+                enum_ctx.ctx = ctx->ctx;
+
+                clang_visitChildren(cursor.get(), enum_visitor, &enum_ctx);
+
+                class_relationship containment;
+                containment.type = relationship_t::kContainment;
+                containment.destination = e.name;
+                ctx->element.relationships.emplace_back(std::move(containment));
+
+                spdlog::info(
+                    "Added relationship {} +-- {}", ctx->element.name, e.name);
+
+                ctx->ctx->d.enums.emplace_back(std::move(e));
+            });
+            ret = CXChildVisit_Continue;
+            break;
         case CXCursor_CXXMethod:
         case CXCursor_Constructor:
         case CXCursor_Destructor:
         case CXCursor_FunctionTemplate: {
-            visit_if_cursor_valid(cursor, [c](cx::cursor cursor) {
+            if (!config.should_include(cursor.fully_qualified())) {
+                ret = CXChildVisit_Continue;
+                break;
+            }
+
+            visit_if_cursor_valid(cursor, [ctx](cx::cursor cursor) {
                 class_method m;
                 m.name = cursor.spelling();
                 m.type = cursor.type().result_type().spelling();
@@ -174,99 +236,116 @@ static enum CXChildVisitResult class_visitor(
                 m.scope =
                     cx_access_specifier_to_scope(cursor.cxxaccess_specifier());
 
-                spdlog::info("Adding method {} {}::{}()", m.type, c->name,
+                spdlog::info("Adding method {} {}::{}()", m.type,
-                    cursor.spelling());
+                    ctx->element.name, cursor.spelling());
 
-                c->methods.emplace_back(std::move(m));
+                ctx->element.methods.emplace_back(std::move(m));
             });
             ret = CXChildVisit_Continue;
             break;
         }
         case CXCursor_VarDecl:
+            is_vardecl = true;
         case CXCursor_FieldDecl: {
-            visit_if_cursor_valid(cursor, [c](cx::cursor cursor) {
+            visit_if_cursor_valid(
-                auto t = cursor.type();
+                cursor, [ctx, &config, is_vardecl](cx::cursor cursor) {
-                class_member m;
+                    auto t = cursor.type();
-                m.name = cursor.spelling();
+                    class_member m;
-                m.type = cursor.type().spelling();
+                    m.name = cursor.spelling();
-                m.scope =
+                    m.type = cursor.type().spelling();
-                    cx_access_specifier_to_scope(cursor.cxxaccess_specifier());
+                    m.scope = cx_access_specifier_to_scope(
-                m.is_static = cursor.is_static();
+                        cursor.cxxaccess_specifier());
+                    m.is_static = cursor.is_static();
 
-                spdlog::info("Adding member {} {}::{}", m.type, c->name,
+                    spdlog::info("Adding member {} {}::{}", m.type,
-                    cursor.spelling());
+                        ctx->element.name, cursor.spelling());
 
-                relationship_t relationship_type = relationship_t::kOwnership;
+                    relationship_t relationship_type =
+                        relationship_t::kOwnership;
 
-                // Parse the field declaration to determine the relationship
+                    // Parse the field declaration to determine the relationship
-                // type
+                    // type
-                if (!t.is_pod()) {
+                    // Skip:
-                    while (true) {
+                    //  - POD
-                        if (t.kind() == CXType_Pointer) {
+                    //  - function variables
-                            relationship_type = relationship_t::kAssociation;
+                    if (!t.is_pod() && !is_vardecl &&
-                            t = t.pointee_type();
+                        config.should_include(cursor.type().spelling())) {
-                            continue;
+                        while (true) {
-                        }
+                            if (t.kind() == CXType_Pointer) {
-                        else if (t.kind() == CXType_LValueReference) {
+                                relationship_type =
-                            relationship_type = relationship_t::kAggregation;
+                                    relationship_t::kAssociation;
-                            t = t.pointee_type();
+                                t = t.pointee_type();
-                            continue;
+                                continue;
-                        }
+                            }
-                        else if (t.kind() == CXType_RValueReference) {
+                            else if (t.kind() == CXType_LValueReference) {
-                            relationship_type = relationship_t::kAssociation;
+                                relationship_type =
-                            t = t.pointee_type();
+                                    relationship_t::kAggregation;
-                            continue;
+                                t = t.pointee_type();
-                        }
+                                continue;
-                        else {
+                            }
-                            spdlog::error("UNKNOWN CXTYPE: {}", t.kind());
+                            else if (t.kind() == CXType_RValueReference) {
-                            class_relationship r;
+                                relationship_type =
-                            auto template_argument_count =
+                                    relationship_t::kAssociation;
-                                t.template_arguments_count();
+                                t = t.pointee_type();
-                            std::string name = t.spelling();
+                                continue;
-
-                            if (template_argument_count > 0) {
-                                std::vector<cx::type> template_arguments;
-                                for (int i = 0; i < template_argument_count;
-                                     i++) {
-                                    auto tt = t.template_argument_type(i);
-                                    template_arguments.push_back(tt);
-                                }
-
-                                if (name.rfind("vector") == 0 ||
-                                    name.rfind("std::vector") == 0) {
-                                    r.type = relationship_t::kAggregation;
-                                    r.destination =
-                                        template_arguments[0].spelling();
-                                }
-                                if (name.rfind("map") == 0 ||
-                                    name.rfind("std::map") == 0) {
-                                    r.type = relationship_t::kAggregation;
-                                    r.destination =
-                                        template_arguments[1].spelling();
-                                }
-                                r.label = m.name;
-                                c->relationships.emplace_back(std::move(r));
                             }
                             else {
-                                r.destination = name;
+                                spdlog::error("UNKNOWN CXTYPE: {}", t.kind());
-                                r.type = relationship_type;
+                                class_relationship r;
-                                r.label = m.name;
+                                auto template_argument_count =
-                                c->relationships.emplace_back(std::move(r));
+                                    t.template_arguments_count();
+                                std::string name = t.spelling();
+
+                                if (template_argument_count > 0) {
+                                    std::vector<cx::type> template_arguments;
+                                    for (int i = 0; i < template_argument_count;
+                                         i++) {
+                                        auto tt = t.template_argument_type(i);
+                                        template_arguments.push_back(tt);
+                                    }
+
+                                    if (name.rfind("vector") == 0 ||
+                                        name.rfind("std::vector") == 0) {
+                                        r.type = relationship_t::kAggregation;
+                                        r.destination =
+                                            template_arguments[0].spelling();
+                                    }
+                                    if (name.rfind("map") == 0 ||
+                                        name.rfind("std::map") == 0) {
+                                        r.type = relationship_t::kAggregation;
+                                        r.destination =
+                                            template_arguments[1].spelling();
+                                    }
+                                    r.label = m.name;
+                                    ctx->element.relationships.emplace_back(
+                                        std::move(r));
+                                }
+                                else {
+                                    r.destination = name;
+                                    r.type = relationship_type;
+                                    r.label = m.name;
+                                    ctx->element.relationships.emplace_back(
+                                        std::move(r));
+                                }
+
+                                spdlog::debug("Adding relationship to: {}",
+                                    r.destination);
                             }
-
+                            break;
-                            spdlog::debug(
-                                "Adding relationship to: {}", r.destination);
                         }
-                        break;
                     }
-                }
 
-                c->members.emplace_back(std::move(m));
+                    ctx->element.members.emplace_back(std::move(m));
-            });
+                });
             ret = CXChildVisit_Continue;
             break;
         }
         case CXCursor_CXXBaseSpecifier: {
+            if (!config.should_include(cursor.referenced().fully_qualified())) {
+                ret = CXChildVisit_Continue;
+                break;
+            }
+
             auto ref_cursor = cursor.referenced();
             auto display_name = ref_cursor.referenced().spelling();
 
@@ -292,7 +371,7 @@ static enum CXChildVisitResult class_visitor(
                     cp.access = class_parent::access_t::kPublic;
             }
 
-            c->bases.emplace_back(std::move(cp));
+            ctx->element.bases.emplace_back(std::move(cp));
 
             ret = CXChildVisit_Continue;
             break;
@@ -319,7 +398,6 @@ static enum CXChildVisitResult translation_unit_visitor(
         return CXChildVisit_Continue;
     }
     std::string cursor_name_str = cursor.spelling();
-
     spdlog::debug("Visiting cursor: {}", cursor_name_str);
 
     bool is_struct{false};
@@ -336,16 +414,23 @@ static enum CXChildVisitResult translation_unit_visitor(
         case CXCursor_ClassDecl: {
             spdlog::debug("Found class or class template declaration: {}",
                 cursor_name_str);
+            if (!ctx->config.should_include(cursor.fully_qualified())) {
+                ret = CXChildVisit_Continue;
+                break;
+            }
 
             scope = scope_t::kPublic;
 
             visit_if_cursor_valid(cursor, [ctx, is_struct](cx::cursor cursor) {
                 class_ c{};
                 c.is_struct = is_struct;
-                c.name = cursor.spelling();
+                c.name = cursor.fully_qualified();
                 c.namespace_ = ctx->namespace_;
 
-                clang_visitChildren(cursor.get(), class_visitor, &c);
+                auto class_ctx = element_visitor_context<class_>(c);
+                class_ctx.ctx = ctx;
+
+                clang_visitChildren(cursor.get(), class_visitor, &class_ctx);
 
                 ctx->d.classes.emplace_back(std::move(c));
             });
@@ -355,13 +440,20 @@ static enum CXChildVisitResult translation_unit_visitor(
         }
         case CXCursor_EnumDecl: {
             spdlog::debug("Found enum declaration: {}", cursor_name_str);
+            if (!ctx->config.should_include(cursor.fully_qualified())) {
+                ret = CXChildVisit_Continue;
+                break;
+            }
 
             visit_if_cursor_valid(cursor, [ctx, is_struct](cx::cursor cursor) {
                 enum_ e{};
-                e.name = cursor.spelling();
+                e.name = cursor.fully_qualified();
                 e.namespace_ = ctx->namespace_;
 
-                clang_visitChildren(cursor.get(), enum_visitor, &e);
+                auto enum_ctx = element_visitor_context<enum_>(e);
+                enum_ctx.ctx = ctx;
+
+                clang_visitChildren(cursor.get(), enum_visitor, &enum_ctx);
 
                 ctx->d.enums.emplace_back(std::move(e));
             });

tests/CMakeLists.txt

@@ -9,6 +9,7 @@ set(CLANG_UML_TEST_CASES_SRC
     t00001/t00001.cc
     t00002/t00002.cc
     t00003/t00003.cc
+    t00004/t00004.cc
 )
 set(CLANG_UML_TEST_CASES_HEADER
     catch.h
@@ -27,5 +28,6 @@ target_link_libraries(test_cases
 configure_file(t00001/.clanguml t00001/.clanguml COPYONLY)
 configure_file(t00002/.clanguml t00002/.clanguml COPYONLY)
 configure_file(t00003/.clanguml t00003/.clanguml COPYONLY)
+configure_file(t00004/.clanguml t00004/.clanguml COPYONLY)
 
 add_test(NAME test_cases COMMAND test_cases)

tests/t00004/.clanguml

@@ -0,0 +1,17 @@
+compilation_database_dir: ..
+output_directory: puml
+diagrams:
+  t00004_class:
+    type: class
+    glob:
+      - ../../tests/t00004/t00004.cc
+    using_namespace:
+      - clanguml::t00004
+    include:
+      namespaces:
+        - clanguml::t00004
+    plantuml:
+      before:
+        - "' t00004 test class members"
+      after:
+        - 'note over "A": A class'

tests/t00004/t00004.cc

@@ -0,0 +1,17 @@
+namespace clanguml {
+namespace t00004 {
+
+class A {
+public:
+    class AA {
+    public:
+        enum class Lights { Green, Yellow, Red };
+
+        class AAA {
+        };
+    };
+
+    void foo() const {}
+};
+}
+}

tests/test_cases.cc

@@ -1,3 +1,20 @@
+/**
+ * tests/test_cases.cc
+ *
+ * Copyright (c) 2021 Bartek Kryza <bkryza@gmail.com>
+ *
+ * Licensed 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.
+ */
 #define CATCH_CONFIG_MAIN
 
 #include "config/config.h"
@@ -204,7 +221,43 @@ TEST_CASE("Test t00003", "[unit-test]")
     REQUIRE_THAT(puml, Contains("-int a"));
     REQUIRE_THAT(puml, Contains("-int b"));
     REQUIRE_THAT(puml, Contains("-int c"));
-    REQUIRE_THAT(puml, Contains("{static} +int static_int"));
+
+    save_puml(
+        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+}
+
+TEST_CASE("Test t00004", "[unit-test]")
+{
+    spdlog::set_level(spdlog::level::debug);
+
+    auto [config, db] = load_config("t00004");
+
+    auto diagram = config.diagrams["t00004_class"];
+
+    REQUIRE(diagram->name == "t00004_class");
+
+    REQUIRE(diagram->include.namespaces.size() == 1);
+    REQUIRE_THAT(diagram->include.namespaces,
+        VectorContains(std::string{"clanguml::t00004"}));
+
+    REQUIRE(diagram->exclude.namespaces.size() == 0);
+
+    REQUIRE(diagram->should_include("clanguml::t00004::A"));
+    REQUIRE(diagram->should_include("clanguml::t00004::A::AA"));
+    REQUIRE(diagram->should_include("clanguml::t00004::A:::AAA"));
+
+    auto model = generate_class_diagram(db, diagram);
+
+    REQUIRE(model.name == "t00004_class");
+
+    auto puml = generate_class_puml(diagram, model);
+
+    REQUIRE_THAT(puml, StartsWith("@startuml"));
+    REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+    REQUIRE_THAT(puml, Contains("class A"));
+    REQUIRE_THAT(puml, Contains("A +-- A::AA"));
+    REQUIRE_THAT(puml, Contains("A::AA +-- A::AA::AAA"));
+    REQUIRE_THAT(puml, Contains("A::AA +-- A::AA::Lights"));
 
     save_puml(
         "./" + config.output_directory + "/" + diagram->name + ".puml", puml);