312 lines
8.0 KiB
C++
312 lines
8.0 KiB
C++
/**
|
|
* src/config/config.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.
|
|
*/
|
|
#include "config.h"
|
|
|
|
namespace clanguml {
|
|
namespace config {
|
|
|
|
config load(const std::string &config_file)
|
|
{
|
|
YAML::Node doc = YAML::LoadFile(config_file);
|
|
|
|
return doc.as<config>();
|
|
}
|
|
|
|
bool diagram::should_include_entities(const std::string &ent)
|
|
{
|
|
for (const auto &ex : exclude.entity_types) {
|
|
if (ent == ex)
|
|
return false;
|
|
}
|
|
|
|
if (include.entity_types.empty())
|
|
return true;
|
|
|
|
for (const auto &in : include.entity_types) {
|
|
if (ent == in)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool diagram::should_include_relationship(const std::string &rel)
|
|
{
|
|
for (const auto &ex : exclude.relationships) {
|
|
if (rel == ex)
|
|
return false;
|
|
}
|
|
|
|
if (include.relationships.empty())
|
|
return true;
|
|
|
|
for (const auto &in : include.relationships) {
|
|
if (rel == in)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool diagram::should_include(const std::string &name_) const
|
|
{
|
|
auto name = clanguml::util::unqualify(name_);
|
|
|
|
for (const auto &ex : exclude.namespaces) {
|
|
if (name.find(ex) == 0) {
|
|
spdlog::debug("Skipping from diagram: {}", name);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// If no inclusive namespaces are provided,
|
|
// allow all
|
|
if (include.namespaces.empty())
|
|
return true;
|
|
|
|
for (const auto &in : include.namespaces) {
|
|
if (name.find(in) == 0)
|
|
return true;
|
|
}
|
|
|
|
spdlog::debug("Skipping from diagram: {}", name);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool diagram::should_include(const model::class_diagram::scope_t scope) const
|
|
{
|
|
for (const auto &s : exclude.scopes) {
|
|
if (s == scope)
|
|
return false;
|
|
}
|
|
|
|
if (include.scopes.empty())
|
|
return true;
|
|
|
|
for (const auto &s : include.scopes) {
|
|
if (s == scope)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool class_diagram::has_class(std::string clazz)
|
|
{
|
|
for (const auto &c : classes) {
|
|
for (const auto &ns : using_namespace) {
|
|
std::string prefix{};
|
|
if (!ns.empty()) {
|
|
prefix = ns + "::";
|
|
}
|
|
if (prefix + c == clazz)
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
namespace YAML {
|
|
using clanguml::config::class_diagram;
|
|
using clanguml::config::config;
|
|
using clanguml::config::filter;
|
|
using clanguml::config::plantuml;
|
|
using clanguml::config::sequence_diagram;
|
|
using clanguml::config::source_location;
|
|
using clanguml::model::class_diagram::scope_t;
|
|
template <> struct convert<scope_t> {
|
|
static bool decode(const Node &node, scope_t &rhs)
|
|
{
|
|
if (node.as<std::string>() == "public")
|
|
rhs = scope_t::kPublic;
|
|
else if (node.as<std::string>() == "protected")
|
|
rhs = scope_t::kProtected;
|
|
else if (node.as<std::string>() == "private")
|
|
rhs = scope_t::kPrivate;
|
|
else
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <> struct convert<std::vector<source_location::variant>> {
|
|
static bool decode(
|
|
const Node &node, std::vector<source_location::variant> &rhs)
|
|
{
|
|
for (auto it = node.begin(); it != node.end(); ++it) {
|
|
const YAML::Node &n = *it;
|
|
if (n["usr"]) {
|
|
rhs.emplace_back(n["usr"].as<source_location::usr>());
|
|
}
|
|
else if (n["marker"]) {
|
|
rhs.emplace_back(n["marker"].as<source_location::marker>());
|
|
}
|
|
else if (n["file"] && n["line"]) {
|
|
rhs.emplace_back(std::make_pair(
|
|
n["file"].as<std::string>(), n["line"].as<int>()));
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <> struct convert<plantuml> {
|
|
static bool decode(const Node &node, plantuml &rhs)
|
|
{
|
|
if (node["before"])
|
|
rhs.before = node["before"].as<decltype(rhs.before)>();
|
|
|
|
if (node["after"])
|
|
rhs.after = node["after"].as<decltype(rhs.after)>();
|
|
return true;
|
|
}
|
|
};
|
|
|
|
//
|
|
// filter Yaml decoder
|
|
//
|
|
template <> struct convert<filter> {
|
|
static bool decode(const Node &node, filter &rhs)
|
|
{
|
|
if (node["namespaces"])
|
|
rhs.namespaces = node["namespaces"].as<decltype(rhs.namespaces)>();
|
|
|
|
if (node["relationships"])
|
|
rhs.relationships =
|
|
node["relationships"].as<decltype(rhs.relationships)>();
|
|
|
|
if (node["entity_types"])
|
|
rhs.entity_types =
|
|
node["entity_types"].as<decltype(rhs.entity_types)>();
|
|
|
|
if (node["scopes"])
|
|
rhs.scopes = node["scopes"].as<decltype(rhs.scopes)>();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <typename T> bool decode_diagram(const Node &node, T &rhs)
|
|
{
|
|
if (node["using_namespace"])
|
|
rhs.using_namespace =
|
|
node["using_namespace"].as<std::vector<std::string>>();
|
|
|
|
if (node["glob"])
|
|
rhs.glob = node["glob"].as<std::vector<std::string>>();
|
|
|
|
if (node["include"])
|
|
rhs.include = node["include"].as<decltype(rhs.include)>();
|
|
|
|
if (node["exclude"])
|
|
rhs.exclude = node["exclude"].as<decltype(rhs.exclude)>();
|
|
|
|
if (node["plantuml"])
|
|
rhs.puml = node["plantuml"].as<plantuml>();
|
|
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// class_diagram Yaml decoder
|
|
//
|
|
template <> struct convert<class_diagram> {
|
|
static bool decode(const Node &node, class_diagram &rhs)
|
|
{
|
|
if (!decode_diagram(node, rhs))
|
|
return false;
|
|
|
|
if (node["include_relations_also_as_members"])
|
|
rhs.include_relations_also_as_members =
|
|
node["include_relations_also_as_members"]
|
|
.as<decltype(rhs.include_relations_also_as_members)>();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
//
|
|
// sequence_diagram Yaml decoder
|
|
//
|
|
template <> struct convert<sequence_diagram> {
|
|
static bool decode(const Node &node, sequence_diagram &rhs)
|
|
{
|
|
if (!decode_diagram(node, rhs))
|
|
return false;
|
|
|
|
if (node["start_from"])
|
|
rhs.start_from = node["start_from"].as<decltype(rhs.start_from)>();
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
//
|
|
// config Yaml decoder
|
|
//
|
|
template <> struct convert<config> {
|
|
static bool decode(const Node &node, config &rhs)
|
|
{
|
|
if (node["glob"])
|
|
rhs.glob = node["glob"].as<std::vector<std::string>>();
|
|
|
|
if (node["output_directory"])
|
|
rhs.output_directory = node["output_directory"].as<std::string>();
|
|
|
|
if (node["compilation_database_dir"])
|
|
rhs.compilation_database_dir =
|
|
node["compilation_database_dir"].as<std::string>();
|
|
|
|
auto diagrams = node["diagrams"];
|
|
|
|
assert(diagrams.Type() == NodeType::Map);
|
|
|
|
for (const auto &d : diagrams) {
|
|
const auto diagram_type = d.second["type"].as<std::string>();
|
|
auto name = d.first.as<std::string>();
|
|
if (diagram_type == "class") {
|
|
rhs.diagrams[name] = std::make_shared<class_diagram>(
|
|
d.second.as<class_diagram>());
|
|
}
|
|
else if (diagram_type == "sequence") {
|
|
rhs.diagrams[name] = std::make_shared<sequence_diagram>(
|
|
d.second.as<sequence_diagram>());
|
|
}
|
|
else {
|
|
spdlog::warn(
|
|
"Diagrams of type {} are not supported at the moment... ",
|
|
diagram_type);
|
|
}
|
|
rhs.diagrams[name]->name = name;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
}
|