matthias/clang-uml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial refactor to cppast

Browse Source
This commit is contained in:
Bartek Kryza
2021-03-24 01:02:28 +01:00
parent b95bf324c2
commit 5dc841d9e6
14 changed files with 589 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitmodules vendored
View File

@@ -1,3 +1,4 @@
[submodule "thirdparty/cppast"]
path = thirdparty/cppast
url = https://github.com/foonathan/cppast
url = https://github.com/bkryza/cppast
branch = handle-exposed-template-arguments

8
CMakeLists.txt
View File

@@ -15,6 +15,8 @@ set(CLANG_UML_INSTALL_BIN_DIR ${PROJECT_SOURCE_DIR}/bin)
set(UML_HEADERS_DIR ${PROJECT_SOURCE_DIR}/src/uml)
set(LLVM_PREFERRED_VERSION 11.0.0)
message(STATUS "Checking for spdlog...")
find_package(spdlog REQUIRED)
@@ -28,6 +30,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 ${LIBCLANG_CXXFLAGS}")
# Thirdparty sources
set(THIRDPARTY_HEADERS_DIR ${PROJECT_SOURCE_DIR}/thirdparty/)
add_subdirectory(thirdparty/cppast)
find_package(LLVM REQUIRED CONFIG)
set(CLANG_INCLUDE_DIRS "llvm/clang/include")
@@ -37,6 +40,9 @@ include_directories(${CLANG_UML_INSTALL_INCLUDE_DIR})
include_directories(${YAML_CPP_INCLUDE_DIR})
include_directories(${UML_HEADERS_DIR})
include_directories(${THIRDPARTY_HEADERS_DIR})
include_directories(${THIRDPARTY_HEADERS_DIR}/cppast/include)
include_directories(${THIRDPARTY_HEADERS_DIR}/cppast/external/type_safe/include)
include_directories(${THIRDPARTY_HEADERS_DIR}/cppast/external/type_safe/external/debug_assert)
include_directories(${PROJECT_SOURCE_DIR}/src/)
file(GLOB_RECURSE SOURCES src/*.cc include/*.h)
@@ -47,7 +53,7 @@ add_library(clang-umllib OBJECT ${SOURCES})
add_executable(clang-uml ${MAIN_SOURCE_FILE})
install(TARGETS clang-uml DESTINATION ${CLANG_UML_INSTALL_BIN_DIR})
target_link_libraries(clang-uml ${LIBCLANG_LIBRARIES} ${YAML_CPP_LIBRARIES} spdlog::spdlog clang-umllib)
target_link_libraries(clang-uml ${LIBCLANG_LIBRARIES} ${YAML_CPP_LIBRARIES} spdlog::spdlog cppast clang-umllib)
install(
FILES

2
Makefile
View File

@@ -21,7 +21,7 @@
# Specify preferred LLVM version for CMake
LLVM_VERSION ?= 11
.DEFAULT_GOAL := test
.DEFAULT_GOAL := debug
.PHONY: clean
clean:

61
src/cx/util.cc
View File

@@ -18,6 +18,8 @@
#include "cx/util.h"
#include <cppast/cpp_class.hpp>
#include <cppast/cpp_entity_kind.hpp>
#include <spdlog/spdlog.h>
namespace clanguml {
@@ -30,6 +32,65 @@ std::string to_string(CXString &&cxs)
clang_disposeString(cxs);
return r;
}
std::string full_name(const cppast::cpp_entity &e)
{
if (e.name().empty())
return "";
else if (cppast::is_parameter(e.kind()))
// parameters don't have a full name
return e.name();
std::string scopes;
for (auto cur = e.parent(); cur; cur = cur.value().parent())
// prepend each scope, if there is any
if (cur.value().kind() == cppast::cpp_entity_kind::namespace_t)
type_safe::with(cur.value().scope_name(),
[&](const cppast::cpp_scope_name &cur_scope) {
scopes = cur_scope.name() + "::" + scopes;
});
if (e.kind() == cppast::cpp_entity_kind::class_t) {
auto &c = static_cast<const cppast::cpp_class &>(e);
return scopes /*+ c.semantic_scope()*/ + c.name();
}
else if (e.kind() == cppast::cpp_entity_kind::class_template_t) {
return scopes;
}
else
return scopes + e.name();
}
std::string ns(const cppast::cpp_entity &e)
{
std::vector<std::string> res{};
auto it = e.parent();
while (it) {
if (it.value().kind() == cppast::cpp_entity_kind::namespace_t) {
res.push_back(it.value().name());
}
it = it.value().parent();
}
return fmt::format("{}", fmt::join(res.rbegin(), res.rend(), "::"));
}
std::string fully_prefixed(const cppast::cpp_entity &e)
{
std::vector<std::string> res{e.name()};
auto it = e.parent();
while (it) {
if (it.value().kind() == cppast::cpp_entity_kind::namespace_t) {
res.push_back(it.value().name());
}
it = it.value().parent();
}
return fmt::format("{}", fmt::join(res.rbegin(), res.rend(), "::"));
}
} // namespace util
} // namespace cx
} // namespace clanguml

5
src/cx/util.h
View File

@@ -19,6 +19,7 @@
#include <clang-c/CXCompilationDatabase.h>
#include <clang-c/Index.h>
#include <cppast/cpp_entity.hpp>
#include <string>
@@ -38,6 +39,10 @@ namespace util {
*/
std::string to_string(CXString &&cxs);
std::string full_name(const cppast::cpp_entity &e);
std::string fully_prefixed(const cppast::cpp_entity &e);
} // namespace util
} // namespace cx
} // namespace clanguml

5
src/main.cc
View File

@@ -25,6 +25,7 @@
#include "uml/sequence_diagram_visitor.h"
#include <cli11/CLI11.hpp>
#include <cppast/libclang_parser.hpp>
#include <glob/glob.hpp>
#include <spdlog/spdlog.h>
@@ -73,6 +74,8 @@ int main(int argc, const char *argv[])
auto db =
compilation_database::from_directory(config.compilation_database_dir);
cppast::libclang_compilation_database db2(config.compilation_database_dir);
for (const auto &[name, diagram] : config.diagrams) {
using clanguml::config::class_diagram;
using clanguml::config::sequence_diagram;
@@ -83,7 +86,7 @@ int main(int argc, const char *argv[])
if (std::dynamic_pointer_cast<class_diagram>(diagram)) {
auto model = generators::class_diagram::generate(
db, name, dynamic_cast<class_diagram &>(*diagram));
db2, name, dynamic_cast<class_diagram &>(*diagram));
ofs << clanguml::generators::class_diagram::puml::generator(
dynamic_cast<clanguml::config::class_diagram &>(*diagram),

18
src/puml/class_diagram_generator.h
View File

@@ -23,6 +23,8 @@
#include "uml/class_diagram_visitor.h"
#include "util/util.h"
#include <cppast/libclang_parser.hpp>
#include <cppast/cpp_entity_index.hpp>
#include <glob/glob.hpp>
#include <filesystem>
@@ -267,7 +269,7 @@ std::ostream &operator<<(std::ostream &os, const generator &g)
}
clanguml::model::class_diagram::diagram generate(
clanguml::cx::compilation_database &db, const std::string &name,
cppast::libclang_compilation_database &db, const std::string &name,
clanguml::config::class_diagram &diagram)
{
spdlog::info("Generating diagram {}.puml", name);
@@ -276,7 +278,7 @@ clanguml::model::class_diagram::diagram generate(
// Get all translation units matching the glob from diagram
// configuration
std::vector<std::filesystem::path> translation_units{};
std::vector<std::string> translation_units{};
for (const auto &g : diagram.glob) {
spdlog::debug("Processing glob: {}", g);
const auto matches = glob::glob(g);
@@ -284,13 +286,20 @@ clanguml::model::class_diagram::diagram generate(
std::back_inserter(translation_units));
}
cppast::cpp_entity_index idx;
cppast::simple_file_parser<cppast::libclang_parser> parser{type_safe::ref(idx)};
// Process all matching translation units
clanguml::visitor::class_diagram::tu_visitor ctx(d, diagram);
cppast::parse_files(parser, translation_units, db);
for (auto &file : parser.files())
ctx(file);
/*
for (const auto &tu_path : translation_units) {
spdlog::debug("Processing translation unit: {}",
std::filesystem::canonical(tu_path).c_str());
auto tu = db.parse_translation_unit(tu_path);
auto cursor = clang_getTranslationUnitCursor(tu);
if (clang_Cursor_isNull(cursor)) {
@@ -309,6 +318,7 @@ clanguml::model::class_diagram::diagram generate(
clang_suspendTranslationUnit(tu);
}
*/
return d;
}

405
src/uml/class_diagram_visitor.cc
View File

@@ -17,6 +17,12 @@
*/
#include "class_diagram_visitor.h"
#include <cppast/cpp_array_type.hpp>
#include <cppast/cpp_entity_kind.hpp>
#include <cppast/cpp_member_function.hpp>
#include <cppast/cpp_member_variable.hpp>
#include <cppast/cpp_template.hpp>
#include <cppast/cpp_variable.hpp>
#include <spdlog/spdlog.h>
namespace clanguml {
@@ -35,6 +41,405 @@ using clanguml::model::class_diagram::method_parameter;
using clanguml::model::class_diagram::relationship_t;
using clanguml::model::class_diagram::scope_t;
namespace detail {
scope_t cpp_access_specifier_to_scope(cppast::cpp_access_specifier_kind as)
{
scope_t res = scope_t::kPublic;
switch (as) {
case cppast::cpp_access_specifier_kind::cpp_public:
res = scope_t::kPublic;
break;
case cppast::cpp_access_specifier_kind::cpp_private:
res = scope_t::kPrivate;
break;
case cppast::cpp_access_specifier_kind::cpp_protected:
res = scope_t::kProtected;
break;
default:
break;
}
return res;
}
}
void tu_visitor::operator()(const cppast::cpp_entity &file)
{
std::string prefix;
// visit each entity in the file
cppast::visit(file,
[&, this](const cppast::cpp_entity &e, cppast::visitor_info info) {
if (e.kind() == cppast::cpp_entity_kind::class_t) {
spdlog::debug("{}'{}' - {}", prefix,
cx::util::fully_prefixed(e), cppast::to_string(e.kind()));
auto &cls = static_cast<const cppast::cpp_class &>(e);
if (ctx.config.should_include(cx::util::fully_prefixed(cls)))
process_class_declaration(cls);
}
});
}
void tu_visitor::process_class_declaration(const cppast::cpp_class &cls)
{
class_ c;
c.usr = cx::util::full_name(cls);
c.is_struct = cls.class_kind() == cppast::cpp_class_kind::struct_t;
c.name = cx::util::full_name(cls);
cppast::cpp_access_specifier_kind last_access_specifier =
cppast::cpp_access_specifier_kind::cpp_private;
// Process class child entities
if (c.is_struct)
last_access_specifier = cppast::cpp_access_specifier_kind::cpp_public;
for (auto &child : cls) {
if (child.kind() == cppast::cpp_entity_kind::access_specifier_t) {
auto &as = static_cast<const cppast::cpp_access_specifier &>(child);
last_access_specifier = as.access_specifier();
}
else if (child.kind() == cppast::cpp_entity_kind::member_variable_t) {
auto &mv = static_cast<const cppast::cpp_member_variable &>(child);
process_field(mv, c, last_access_specifier);
}
else if (child.kind() == cppast::cpp_entity_kind::variable_t) {
auto &mv = static_cast<const cppast::cpp_variable &>(child);
process_static_field(mv, c, last_access_specifier);
}
else if (child.kind() == cppast::cpp_entity_kind::member_function_t) {
auto &mf = static_cast<const cppast::cpp_member_function &>(child);
process_method(mf, c, last_access_specifier);
}
else if (child.kind() == cppast::cpp_entity_kind::function_t) {
auto &mf = static_cast<const cppast::cpp_function &>(child);
process_static_method(mf, c, last_access_specifier);
}
else if (child.kind() == cppast::cpp_entity_kind::constructor_t) {
auto &mc = static_cast<const cppast::cpp_constructor &>(child);
process_constructor(mc, c, last_access_specifier);
}
else if (child.kind() == cppast::cpp_entity_kind::destructor_t) {
auto &mc = static_cast<const cppast::cpp_destructor &>(child);
process_destructor(mc, c, last_access_specifier);
}
}
// Process class bases
for (auto &base : cls.bases()) {
class_parent cp;
cp.name = clanguml::cx::util::fully_prefixed(base);
cp.is_virtual = base.is_virtual();
switch (base.access_specifier()) {
case cppast::cpp_access_specifier_kind::cpp_private:
cp.access = class_parent::access_t::kPrivate;
break;
case cppast::cpp_access_specifier_kind::cpp_public:
cp.access = class_parent::access_t::kPublic;
break;
case cppast::cpp_access_specifier_kind::cpp_protected:
cp.access = class_parent::access_t::kProtected;
break;
default:
cp.access = class_parent::access_t::kPublic;
}
c.bases.emplace_back(std::move(cp));
}
// Process class template arguments
if (cppast::is_templated(cls)) {
auto scope = cppast::cpp_scope_name(type_safe::ref(cls));
for (const auto &tp : scope.template_parameters()) {
if (tp.kind() ==
cppast::cpp_entity_kind::template_type_parameter_t) {
process_template_type_parameter(
static_cast<const cppast::cpp_template_type_parameter &>(
tp),
c);
}
else if (tp.kind() ==
cppast::cpp_entity_kind::non_type_template_parameter_t) {
process_template_nontype_parameter(
static_cast<
const cppast::cpp_non_type_template_parameter &>(tp),
c);
}
else if (tp.kind() ==
cppast::cpp_entity_kind::template_template_parameter_t) {
process_template_template_parameter(
static_cast<
const cppast::cpp_template_template_parameter &>(tp),
c);
}
}
}
ctx.d.add_class(std::move(c));
}
void tu_visitor::process_field(const cppast::cpp_member_variable &mv, class_ &c,
cppast::cpp_access_specifier_kind as)
{
class_member m;
m.name = mv.name();
m.type = cppast::to_string(mv.type());
m.scope = detail::cpp_access_specifier_to_scope(as);
m.is_static = false;
if (mv.type().kind() != cppast::cpp_type_kind::builtin_t) {
std::vector<std::pair<std::string, relationship_t>> relationships;
find_relationships(mv.type(), relationships);
for (const auto &[type, relationship_type] : relationships) {
if (relationship_type != relationship_t::kNone) {
class_relationship r;
r.destination = type;
r.type = relationship_type;
r.label = m.name;
c.relationships.emplace_back(std::move(r));
spdlog::debug("Added relationship to: {}", r.destination);
}
}
}
c.members.emplace_back(std::move(m));
}
void tu_visitor::process_static_field(const cppast::cpp_variable &mv, class_ &c,
cppast::cpp_access_specifier_kind as)
{
class_member m;
m.name = mv.name();
m.type = cppast::to_string(mv.type());
m.scope = detail::cpp_access_specifier_to_scope(as);
m.is_static = true;
c.members.emplace_back(std::move(m));
}
void tu_visitor::process_method(const cppast::cpp_member_function &mf,
class_ &c, cppast::cpp_access_specifier_kind as)
{
class_method m;
m.name = util::trim(mf.name());
m.type = cppast::to_string(mf.return_type());
m.is_pure_virtual = cppast::is_pure(mf.virtual_info());
m.is_virtual = cppast::is_virtual(mf.virtual_info());
m.is_const = cppast::is_const(mf.cv_qualifier());
m.is_defaulted = false; // cursor.is_method_defaulted();
m.is_static = false; // cppast::is_static(mf.storage_class());
m.scope = detail::cpp_access_specifier_to_scope(as);
for (auto &param : mf.parameters())
process_function_parameter(param, m);
c.methods.emplace_back(std::move(m));
}
void tu_visitor::process_static_method(const cppast::cpp_function &mf,
class_ &c, cppast::cpp_access_specifier_kind as)
{
class_method m;
m.name = util::trim(mf.name());
m.type = cppast::to_string(mf.return_type());
m.is_pure_virtual = false;
m.is_virtual = false;
m.is_const = false;
m.is_defaulted = false;
m.is_static = true;
m.scope = detail::cpp_access_specifier_to_scope(as);
for (auto &param : mf.parameters())
process_function_parameter(param, m);
c.methods.emplace_back(std::move(m));
}
void tu_visitor::process_constructor(const cppast::cpp_constructor &mf,
class_ &c, cppast::cpp_access_specifier_kind as)
{
class_method m;
m.name = util::trim(mf.name());
m.type = "void";
m.is_pure_virtual = false;
m.is_virtual = false;
m.is_const = false;
m.is_defaulted = false;
m.is_static = false;
m.scope = detail::cpp_access_specifier_to_scope(as);
for (auto &param : mf.parameters())
process_function_parameter(param, m);
c.methods.emplace_back(std::move(m));
}
void tu_visitor::process_destructor(const cppast::cpp_destructor &mf, class_ &c,
cppast::cpp_access_specifier_kind as)
{
class_method m;
m.name = util::trim(mf.name());
m.type = "void";
m.is_pure_virtual = false;
m.is_virtual = cppast::is_virtual(mf.virtual_info());
m.is_const = false;
m.is_defaulted = false;
m.is_static = false;
m.scope = detail::cpp_access_specifier_to_scope(as);
c.methods.emplace_back(std::move(m));
}
void tu_visitor::process_function_parameter(
const cppast::cpp_function_parameter &param, class_method &m)
{
method_parameter mp;
mp.name = param.name();
mp.type = cppast::to_string(param.type());
auto dv = param.default_value();
if (dv)
switch (dv.value().kind()) {
case cppast::cpp_expression_kind::literal_t:
mp.default_value =
static_cast<const cppast::cpp_literal_expression &>(
dv.value())
.value();
break;
case cppast::cpp_expression_kind::unexposed_t:
mp.default_value =
static_cast<const cppast::cpp_unexposed_expression &>(
dv.value())
.expression()
.as_string();
break;
default:
mp.default_value = "{}";
}
m.parameters.emplace_back(std::move(mp));
}
void tu_visitor::process_template_type_parameter(
const cppast::cpp_template_type_parameter &t, class_ &parent)
{
class_template ct;
ct.type = "";
ct.default_value = "";
ct.is_variadic = t.is_variadic();
ct.name = t.name();
if (ct.is_variadic)
ct.name += "...";
parent.templates.emplace_back(std::move(ct));
}
void tu_visitor::process_template_nontype_parameter(
const cppast::cpp_non_type_template_parameter &t, class_ &parent)
{
class_template ct;
ct.type = cppast::to_string(t.type());
ct.name = t.name();
ct.default_value = "";
ct.is_variadic = t.is_variadic();
if (ct.is_variadic)
ct.name += "...";
parent.templates.emplace_back(std::move(ct));
}
void tu_visitor::process_template_template_parameter(
const cppast::cpp_template_template_parameter &t, class_ &parent)
{
class_template ct;
ct.type = "";
ct.name = t.name() + "<>";
ct.default_value = "";
parent.templates.emplace_back(std::move(ct));
}
void tu_visitor::find_relationships(const cppast::cpp_type &t_,
std::vector<std::pair<std::string, relationship_t>> &relationships,
relationship_t relationship_hint)
{
relationship_t relationship_type = relationship_hint;
const auto &t = cppast::remove_cv(t_);
if (t.kind() == cppast::cpp_type_kind::array_t) {
auto &a = static_cast<const cppast::cpp_array_type &>(t);
find_relationships(
a.value_type(), relationships, relationship_t::kComposition);
return;
}
auto name = cppast::to_string(t);
if (t.kind() == cppast::cpp_type_kind::template_instantiation_t) {
class_relationship r;
auto &tinst =
static_cast<const cppast::cpp_template_instantiation_type &>(t);
if (!tinst.arguments_exposed()) {
spdlog::debug(
"Template instantiation {} has no exposed arguments", name);
return;
}
const auto &args = tinst.arguments().value();
if (name.find("std::unique_ptr") == 0) {
find_relationships(args[0u].type().value(), relationships,
relationship_t::kComposition);
}
else if (name.find("std::shared_ptr") == 0) {
find_relationships(args[0u].type().value(), relationships,
relationship_t::kAssociation);
}
else if (name.find("std::weak_ptr") == 0) {
find_relationships(args[0u].type().value(), relationships,
relationship_t::kAssociation);
}
else if (name.find("std::vector") == 0) {
find_relationships(args[0u].type().value(), relationships,
relationship_t::kAggregation);
}
else {
for (const auto &arg : args) {
find_relationships(
arg.type().value(), relationships, relationship_type);
}
}
}
else if (t.kind() == cppast::cpp_type_kind::user_defined_t) {
if (relationship_type != relationship_t::kNone)
relationships.emplace_back(cppast::to_string(t), relationship_hint);
else
relationships.emplace_back(
cppast::to_string(t), relationship_t::kComposition);
}
else if (t.kind() == cppast::cpp_type_kind::pointer_t) {
auto &p = static_cast<const cppast::cpp_pointer_type &>(t);
find_relationships(
p.pointee(), relationships, relationship_t::kAssociation);
}
else if (t.kind() == cppast::cpp_type_kind::reference_t) {
auto &r = static_cast<const cppast::cpp_reference_type &>(t);
auto rt = relationship_t::kAssociation;
if (r.reference_kind() == cppast::cpp_reference::cpp_ref_rvalue) {
rt = relationship_t::kComposition;
}
find_relationships(r.referee(), relationships, rt);
}
}
//
// ============== OLD CODE =======================
//
enum CXChildVisitResult visit_if_cursor_valid(
cx::cursor cursor, std::function<enum CXChildVisitResult(cx::cursor)> f)
{

66
src/uml/class_diagram_visitor.h
View File

@@ -23,6 +23,11 @@
#include <clang-c/CXCompilationDatabase.h>
#include <clang-c/Index.h>
#include <cppast/cpp_member_function.hpp>
#include <cppast/cpp_member_variable.hpp>
#include <cppast/cpp_template_parameter.hpp>
#include <cppast/cpp_type.hpp>
#include <cppast/visitor.hpp>
#include <functional>
#include <memory>
@@ -58,6 +63,67 @@ template <typename T> struct element_visitor_context {
clanguml::model::class_diagram::diagram &d;
};
class tu_visitor {
public:
tu_visitor(clanguml::model::class_diagram::diagram &d_,
const clanguml::config::class_diagram &config_)
: ctx{d_, config_}
{
}
void operator()(const cppast::cpp_entity &file);
void process_class_declaration(const cppast::cpp_class &cls);
void process_field(const cppast::cpp_member_variable &mv,
clanguml::model::class_diagram::class_ &c,
cppast::cpp_access_specifier_kind as);
void process_static_field(const cppast::cpp_variable &mv,
clanguml::model::class_diagram::class_ &c,
cppast::cpp_access_specifier_kind as);
void process_method(const cppast::cpp_member_function &mf,
clanguml::model::class_diagram::class_ &c,
cppast::cpp_access_specifier_kind as);
void process_static_method(const cppast::cpp_function &mf,
clanguml::model::class_diagram::class_ &c,
cppast::cpp_access_specifier_kind as);
void process_constructor(const cppast::cpp_constructor &mf,
clanguml::model::class_diagram::class_ &c,
cppast::cpp_access_specifier_kind as);
void process_destructor(const cppast::cpp_destructor &mf,
clanguml::model::class_diagram::class_ &c,
cppast::cpp_access_specifier_kind as);
void process_function_parameter(const cppast::cpp_function_parameter &param,
clanguml::model::class_diagram::class_method &m);
void find_relationships(const cppast::cpp_type &t,
std::vector<std::pair<std::string,
clanguml::model::class_diagram::relationship_t>> &relationships,
clanguml::model::class_diagram::relationship_t relationship_hint =
clanguml::model::class_diagram::relationship_t::kNone);
void process_template_type_parameter(
const cppast::cpp_template_type_parameter &t,
clanguml::model::class_diagram::class_ &parent);
void process_template_nontype_parameter(
const cppast::cpp_non_type_template_parameter &t,
clanguml::model::class_diagram::class_ &parent);
void process_template_template_parameter(
const cppast::cpp_template_template_parameter &t,
clanguml::model::class_diagram::class_ &parent);
private:
tu_context ctx;
};
// Visitors
enum CXChildVisitResult visit_if_cursor_valid(

4
tests/CMakeLists.txt
View File

@@ -31,7 +31,7 @@ target_link_libraries(test_util
PRIVATE
${LIBCLANG_LIBRARIES}
${YAML_CPP_LIBRARIES}
spdlog::spdlog clang-umllib)
spdlog::spdlog clang-umllib cppast)
add_executable(test_cases
@@ -42,7 +42,7 @@ target_link_libraries(test_cases
PRIVATE
${LIBCLANG_LIBRARIES}
${YAML_CPP_LIBRARIES}
spdlog::spdlog clang-umllib)
spdlog::spdlog clang-umllib cppast)
foreach(TEST_CASE_CONFIG ${TEST_CASE_CONFIGS})
file(RELATIVE_PATH

2
tests/t00003/test_case.h
View File

@@ -56,7 +56,7 @@ TEST_CASE("t00003", "[test-case][class]")
REQUIRE_THAT(puml, IsField(Public("int public_member")));
REQUIRE_THAT(puml, IsField(Protected("int protected_member")));
REQUIRE_THAT(puml, IsField(Private("int private_member")));
REQUIRE_THAT(puml, IsField(Static(Public("unsigned long auto_member"))));
REQUIRE_THAT(puml, IsField(Static(Public("unsigned long const auto_member"))));
REQUIRE_THAT(puml, IsField(Private("int a")));
REQUIRE_THAT(puml, IsField(Private("int b")));

4
tests/t00005/test_case.h
View File

@@ -58,8 +58,8 @@ TEST_CASE("t00005", "[test-case][class]")
REQUIRE_THAT(puml, IsClass(_A("R")));
REQUIRE_THAT(puml, IsField(Public("int some_int")));
REQUIRE_THAT(puml, IsField(Public("int * some_int_pointer")));
REQUIRE_THAT(puml, IsField(Public("int ** some_int_pointer_pointer")));
REQUIRE_THAT(puml, IsField(Public("int* some_int_pointer")));
REQUIRE_THAT(puml, IsField(Public("int** some_int_pointer_pointer")));
REQUIRE_THAT(puml, IsComposition(_A("R"), _A("A"), "a"));
REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("B"), "b"));

19
tests/test_cases.cc
View File

@@ -19,7 +19,20 @@
#include <spdlog/spdlog.h>
std::pair<clanguml::config::config, compilation_database> load_config(
std::pair<clanguml::config::config, cppast::libclang_compilation_database>
load_config(const std::string &test_name)
{
auto config = clanguml::config::load(test_name + "/.clanguml");
// auto db = clanguml::cx::compilation_database::from_directory(
// config.compilation_database_dir);
cppast::libclang_compilation_database db(config.compilation_database_dir);
return std::make_pair(std::move(config), std::move(db));
}
std::pair<clanguml::config::config, compilation_database> load_config2(
const std::string &test_name)
{
auto config = clanguml::config::load(test_name + "/.clanguml");
@@ -42,7 +55,7 @@ clanguml::model::sequence_diagram::diagram generate_sequence_diagram(
}
clanguml::model::class_diagram::diagram generate_class_diagram(
compilation_database &db,
cppast::libclang_compilation_database &db,
std::shared_ptr<clanguml::config::diagram> diagram)
{
auto diagram_model =
@@ -134,7 +147,7 @@ using clanguml::test::matchers::Static;
//
// Sequence diagram tests
//
#include "t20001/test_case.h"
//#include "t20001/test_case.h"
//
// Other tests (e.g. configuration file)

4
tests/test_cases.h
View File

@@ -43,7 +43,9 @@ using Catch::Matchers::VectorContains;
using clanguml::cx::compilation_database;
using namespace clanguml::util;
std::pair<clanguml::config::config, compilation_database> load_config(
std::pair<clanguml::config::config, cppast::libclang_compilation_database>
load_config(const std::string &test_name);
std::pair<clanguml::config::config, compilation_database> load_config2(
const std::string &test_name);
clanguml::model::sequence_diagram::diagram generate_sequence_diagram(