Added basic config option inheritance

src/class_diagram/generators/plantuml/class_diagram_generator.cc

@@ -119,7 +119,7 @@ void generator::generate_alias(const enum_ &e, std::ostream &ostr) const
 void generator::generate(const class_ &c, std::ostream &ostr) const
 {
 
-    const auto &uns = m_config.using_namespace;
+    const auto &uns = m_config.using_namespace();
 
     std::string class_type{"class"};
     if (c.is_abstract())
@@ -154,7 +154,7 @@ void generator::generate(const class_ &c, std::ostream &ostr) const
             std::vector<std::string> params;
             std::transform(m.parameters().cbegin(), m.parameters().cend(),
                 std::back_inserter(params), [this](const auto &mp) {
-                    return mp.to_string(m_config.using_namespace);
+                    return mp.to_string(m_config.using_namespace());
                 });
             ostr << fmt::format("{}", fmt::join(params, ", "));
         }
@@ -238,7 +238,7 @@ void generator::generate(const class_ &c, std::ostream &ostr) const
         if (!m_config.should_include(m.scope()))
             continue;
 
-        if (!m_config.include_relations_also_as_members &&
+        if (!m_config.include_relations_also_as_members() &&
             rendered_relations.find(m.name()) != rendered_relations.end())
             continue;
 
@@ -310,10 +310,10 @@ void generator::generate(const enum_ &e, std::ostream &ostr) const
             destination = r.destination();
 
             relstr << m_model.to_alias(
-                          ns_relative(m_config.using_namespace, e.name()))
+                          ns_relative(m_config.using_namespace(), e.name()))
                    << " " << to_string(r.type()) << " "
                    << m_model.to_alias(
-                          ns_relative(m_config.using_namespace, destination));
+                          ns_relative(m_config.using_namespace(), destination));
 
             if (!r.label().empty())
                 relstr << " : " << r.label();
@@ -346,12 +346,12 @@ void generator::generate(std::ostream &ostr) const
 {
     ostr << "@startuml" << '\n';
 
-    for (const auto &b : m_config.puml.before) {
+    for (const auto &b : m_config.puml().before) {
         std::string note{b};
         std::tuple<std::string, size_t, size_t> alias_match;
         while (util::find_element_alias(note, alias_match)) {
             auto alias = m_model.to_alias(ns_relative(
-                m_config.using_namespace, std::get<0>(alias_match)));
+                m_config.using_namespace(), std::get<0>(alias_match)));
             note.replace(
                 std::get<1>(alias_match), std::get<2>(alias_match), alias);
         }
@@ -388,12 +388,12 @@ void generator::generate(std::ostream &ostr) const
         }
 
     // Process aliases in any of the puml directives
-    for (const auto &b : m_config.puml.after) {
+    for (const auto &b : m_config.puml().after) {
         std::string note{b};
         std::tuple<std::string, size_t, size_t> alias_match;
         while (util::find_element_alias(note, alias_match)) {
             auto alias = m_model.to_alias(ns_relative(
-                m_config.using_namespace, std::get<0>(alias_match)));
+                m_config.using_namespace(), std::get<0>(alias_match)));
             note.replace(
                 std::get<1>(alias_match), std::get<2>(alias_match), alias);
         }
@@ -419,7 +419,7 @@ clanguml::class_diagram::model::diagram generate(
     // Get all translation units matching the glob from diagram
     // configuration
     std::vector<std::string> translation_units{};
-    for (const auto &g : diagram.glob) {
+    for (const auto &g : diagram.glob()) {
         LOG_DBG("Processing glob: {}", g);
         const auto matches = glob::rglob(g);
         std::copy(matches.begin(), matches.end(),

src/class_diagram/visitor/translation_unit_visitor.cc

@@ -202,7 +202,7 @@ void translation_unit_visitor::process_enum_declaration(
         return;
     }
 
-    enum_ e{ctx.config().using_namespace};
+    enum_ e{ctx.config().using_namespace()};
     e.set_name(cx::util::full_name(ctx.get_namespace(), enm));
 
     if (enm.comment().has_value())
@@ -242,7 +242,7 @@ void translation_unit_visitor::process_class_declaration(
     const cppast::cpp_class &cls,
     type_safe::optional_ref<const cppast::cpp_template_specialization> tspec)
 {
-    class_ c{ctx.config().using_namespace};
+    class_ c{ctx.config().using_namespace()};
     c.is_struct(cls.class_kind() == cppast::cpp_class_kind::struct_t);
     c.set_name(cx::util::full_name(ctx.get_namespace(), cls));
 
@@ -1201,7 +1201,7 @@ class_ translation_unit_visitor::build_template_instantiation(
     const cppast::cpp_template_instantiation_type &t,
     std::optional<clanguml::class_diagram::model::class_ *> parent)
 {
-    class_ tinst{ctx.config().using_namespace};
+    class_ tinst{ctx.config().using_namespace()};
     std::string full_template_name;
 
     std::deque<std::tuple<std::string, int, bool>> template_base_params{};

src/config/config.cc

@@ -53,15 +53,15 @@ std::string to_string(const diagram_type t)
 
 bool diagram::should_include_entities(const std::string &ent)
 {
-    for (const auto &ex : exclude.entity_types) {
+    for (const auto &ex : exclude().entity_types) {
         if (ent == ex)
             return false;
     }
 
-    if (include.entity_types.empty())
+    if (include().entity_types.empty())
         return true;
 
-    for (const auto &in : include.entity_types) {
+    for (const auto &in : include().entity_types) {
         if (ent == in)
             return true;
     }
@@ -71,15 +71,15 @@ bool diagram::should_include_entities(const std::string &ent)
 
 bool diagram::should_include_relationship(const std::string &rel)
 {
-    for (const auto &ex : exclude.relationships) {
+    for (const auto &ex : exclude().relationships) {
         if (rel == ex)
             return false;
     }
 
-    if (include.relationships.empty())
+    if (include().relationships.empty())
         return true;
 
-    for (const auto &in : include.relationships) {
+    for (const auto &in : include().relationships) {
         if (rel == in)
             return true;
     }
@@ -91,7 +91,7 @@ bool diagram::should_include(const std::string &name_) const
 {
     auto name = clanguml::util::unqualify(name_);
 
-    for (const auto &ex : exclude.namespaces) {
+    for (const auto &ex : exclude().namespaces) {
         if (name.find(ex) == 0) {
             LOG_DBG("Skipping from diagram: {}", name);
             return false;
@@ -100,10 +100,10 @@ bool diagram::should_include(const std::string &name_) const
 
     // If no inclusive namespaces are provided,
     // allow all
-    if (include.namespaces.empty())
+    if (include().namespaces.empty())
         return true;
 
-    for (const auto &in : include.namespaces) {
+    for (const auto &in : include().namespaces) {
         if (name.find(in) == 0)
             return true;
     }
@@ -115,15 +115,15 @@ bool diagram::should_include(const std::string &name_) const
 
 bool diagram::should_include(const clanguml::common::model::scope_t scope) const
 {
-    for (const auto &s : exclude.scopes) {
+    for (const auto &s : exclude().scopes) {
         if (s == scope)
             return false;
     }
 
-    if (include.scopes.empty())
+    if (include().scopes.empty())
         return true;
 
-    for (const auto &s : include.scopes) {
+    for (const auto &s : include().scopes) {
         if (s == scope)
             return true;
     }
@@ -135,8 +135,8 @@ diagram_type class_diagram::type() const { return diagram_type::class_diagram; }
 
 bool class_diagram::has_class(std::string clazz)
 {
-    for (const auto &c : classes) {
+    for (const auto &c : classes()) {
-        for (const auto &ns : using_namespace) {
+        for (const auto &ns : using_namespace()) {
             std::string prefix{};
             if (!ns.empty()) {
                 prefix = ns + "::";
@@ -159,6 +159,16 @@ diagram_type package_diagram::type() const
     return diagram_type::package_diagram;
 }
 
+template <>
+void append_value<std::vector<std::string>>(
+    std::vector<std::string> &l, const std::vector<std::string> &r)
+{
+    l.insert(l.end(), r.begin(), r.end());
+}
+template <> void append_value<plantuml>(plantuml &l, const plantuml &r)
+{
+    l.append(r);
+}
 }
 }
 
@@ -171,6 +181,42 @@ using clanguml::config::package_diagram;
 using clanguml::config::plantuml;
 using clanguml::config::sequence_diagram;
 using clanguml::config::source_location;
+
+inline bool has_key(const YAML::Node &n, const std::string &key)
+{
+    assert(n.Type() == NodeType::Map);
+
+    return std::count_if(n.begin(), n.end(), [&key](auto &&n) {
+        return n.first.template as<std::string>() == key;
+    }) > 0;
+}
+
+template <typename T>
+void get_option(const Node &node, clanguml::config::option<T> &option)
+{
+    if (node[option.name])
+        option.append(node[option.name].template as<T>());
+}
+
+std::shared_ptr<clanguml::config::diagram> parse_diagram_config(const Node &d)
+{
+    const auto diagram_type = d["type"].as<std::string>();
+
+    if (diagram_type == "class") {
+        return std::make_shared<class_diagram>(d.as<class_diagram>());
+    }
+    else if (diagram_type == "sequence") {
+        return std::make_shared<sequence_diagram>(d.as<sequence_diagram>());
+    }
+    else if (diagram_type == "package") {
+        return std::make_shared<package_diagram>(d.as<package_diagram>());
+    }
+
+    LOG_WARN("Diagrams of type {} are not supported... ", diagram_type);
+
+    return {};
+}
+
 template <> struct convert<scope_t> {
     static bool decode(const Node &node, scope_t &rhs)
     {
@@ -264,21 +310,11 @@ template <> struct convert<filter> {
 
 template <typename T> bool decode_diagram(const Node &node, T &rhs)
 {
-    if (node["using_namespace"])
+    get_option(node, rhs.glob);
-        rhs.using_namespace =
+    get_option(node, rhs.using_namespace);
-            node["using_namespace"].as<std::vector<std::string>>();
+    get_option(node, rhs.include);
-
+    get_option(node, rhs.exclude);
-    if (node["glob"])
+    get_option(node, rhs.puml);
-        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;
 }
@@ -292,10 +328,8 @@ template <> struct convert<class_diagram> {
         if (!decode_diagram(node, rhs))
             return false;
 
-        if (node["include_relations_also_as_members"])
+        get_option(node, rhs.classes);
-            rhs.include_relations_also_as_members =
+        get_option(node, rhs.include_relations_also_as_members);
-                node["include_relations_also_as_members"]
-                    .as<decltype(rhs.include_relations_also_as_members)>();
 
         return true;
     }
@@ -310,9 +344,7 @@ template <> struct convert<sequence_diagram> {
         if (!decode_diagram(node, rhs))
             return false;
 
-        if (node["start_from"])
+        get_option(node, rhs.start_from);
-            rhs.start_from =
-                node["start_from"].as<std::vector<source_location>>();
 
         return true;
     }
@@ -331,49 +363,19 @@ template <> struct convert<package_diagram> {
     }
 };
 
-std::shared_ptr<clanguml::config::diagram> parse_diagram_config(const Node &d)
-{
-    const auto diagram_type = d["type"].as<std::string>();
-
-    if (diagram_type == "class") {
-        return std::make_shared<class_diagram>(d.as<class_diagram>());
-    }
-    else if (diagram_type == "sequence") {
-        return std::make_shared<sequence_diagram>(d.as<sequence_diagram>());
-    }
-    else if (diagram_type == "package") {
-        return std::make_shared<package_diagram>(d.as<package_diagram>());
-    }
-
-    LOG_WARN("Diagrams of type {} are not supported... ", diagram_type);
-
-    return {};
-}
-
-inline bool has_key(const YAML::Node &n, const std::string &key)
-{
-    assert(n.Type() == NodeType::Map);
-
-    return std::count_if(n.begin(), n.end(), [&key](auto &&n) {
-        return n.first.template as<std::string>() == key;
-    }) > 0;
-}
-
 //
 // config Yaml decoder
 //
 template <> struct convert<config> {
+
     static bool decode(const Node &node, config &rhs)
     {
-        if (node["glob"])
+        get_option(node, rhs.glob);
-            rhs.glob = node["glob"].as<std::vector<std::string>>();
+        get_option(node, rhs.using_namespace);
-
+        get_option(node, rhs.output_directory);
-        if (node["output_directory"])
+        get_option(node, rhs.compilation_database_dir);
-            rhs.output_directory = node["output_directory"].as<std::string>();
+        get_option(node, rhs.include_relations_also_as_members);
-
+        get_option(node, rhs.puml);
-        if (node["compilation_database_dir"])
-            rhs.compilation_database_dir =
-                node["compilation_database_dir"].as<std::string>();
 
         auto diagrams = node["diagrams"];
 
@@ -381,7 +383,7 @@ template <> struct convert<config> {
 
         for (const auto &d : diagrams) {
             auto name = d.first.as<std::string>();
-            std::shared_ptr<clanguml::config::diagram> diagram_config;
+            std::shared_ptr<clanguml::config::diagram> diagram_config{};
 
             if (has_key(d.second, "include!")) {
                 YAML::Node node =
@@ -395,6 +397,7 @@ template <> struct convert<config> {
 
             if (diagram_config) {
                 diagram_config->name = name;
+                diagram_config->inherit(rhs);
                 rhs.diagrams[name] = diagram_config;
             }
         }

src/config/config.h

@@ -37,6 +37,12 @@ namespace config {
 struct plantuml {
     std::vector<std::string> before;
     std::vector<std::string> after;
+
+    void append(const plantuml &r)
+    {
+        before.insert(before.end(), r.before.begin(), r.before.end());
+        after.insert(after.end(), r.after.begin(), r.after.end());
+    }
 };
 
 struct filter {
@@ -63,19 +69,84 @@ enum class diagram_type { class_diagram, sequence_diagram, package_diagram };
 
 std::string to_string(const diagram_type t);
 
-struct diagram {
+template <typename T> void append_value(T &l, const T &r) { l = r; }
+// template<> void append_value<bool>(bool &l, const bool&r) {l = r;}
+
+template <typename T> struct option {
+    option(const std::string &name_)
+        : name{name_}
+    {
+    }
+
+    option(const std::string &name_, const T &initial_value)
+        : name{name_}
+        , value{initial_value}
+        , has_value{true}
+    {
+    }
+
+    std::string name;
+
+    T value;
+    bool has_value{false};
+
+    void append(const T &r)
+    {
+        append_value(value, r);
+        has_value = true;
+    }
+
+    option<T> &operator+=(const T &r)
+    {
+        append_value(value, r);
+        has_value = true;
+        return *this;
+    }
+
+    T &operator()() { return value; }
+
+    const T &operator()() const { return value; }
+};
+
+struct inheritable_diagram_options {
+    option<std::vector<std::string>> glob{"glob"};
+    option<std::vector<std::string>> using_namespace{"using_namespace"};
+    option<bool> include_relations_also_as_members{
+        "include_relations_also_as_members", true};
+    option<filter> include{"include"};
+    option<filter> exclude{"exclude"};
+    option<plantuml> puml{"plantuml"};
+
+    void inherit(const inheritable_diagram_options &parent)
+    {
+        if (!glob.has_value && parent.glob.has_value)
+            glob.append(parent.glob());
+
+        if (!using_namespace.has_value && parent.using_namespace.has_value)
+            using_namespace.append(parent.using_namespace());
+
+        if (!include_relations_also_as_members.has_value &&
+            parent.include_relations_also_as_members.has_value)
+            include_relations_also_as_members.append(
+                parent.include_relations_also_as_members());
+
+        if (!include.has_value && parent.include.has_value)
+            include.append(parent.include());
+
+        if (!exclude.has_value && parent.exclude.has_value)
+            exclude.append(parent.exclude());
+
+        if (!puml.has_value && parent.puml.has_value)
+            puml.append(parent.puml());
+    }
+};
+
+struct diagram : public inheritable_diagram_options {
     virtual ~diagram() = default;
 
     virtual diagram_type type() const = 0;
 
     std::string name;
-    std::vector<std::string> glob;
-    std::vector<std::string> using_namespace;
-
-    filter include;
-    filter exclude;
-
-    plantuml puml;
 
     bool should_include_entities(const std::string &ent);
 
@@ -97,8 +168,7 @@ struct class_diagram : public diagram {
 
     diagram_type type() const override;
 
-    std::vector<std::string> classes;
+    option<std::vector<std::string>> classes{"classes"};
-    bool include_relations_also_as_members{true};
 
     bool has_class(std::string clazz);
 };
@@ -108,7 +178,7 @@ struct sequence_diagram : public diagram {
 
     diagram_type type() const override;
 
-    std::vector<source_location> start_from;
+    option<std::vector<source_location>> start_from{"start_from"};
 };
 
 struct package_diagram : public diagram {
@@ -117,12 +187,13 @@ struct package_diagram : public diagram {
     diagram_type type() const override;
 };
 
-struct config {
+struct config : public inheritable_diagram_options {
     // the glob list is additive and relative to the current
     // directory
-    std::vector<std::string> glob;
+    option<std::string> compilation_database_dir{
-    std::string compilation_database_dir{"."};
+        "compilation_database_dir", "."};
-    std::string output_directory{};
+    option<std::string> output_directory{"output_directory"};
+
     std::map<std::string, std::shared_ptr<diagram>> diagrams;
 };
 

src/main.cc

@@ -89,11 +89,11 @@ int main(int argc, const char *argv[])
     LOG_INFO("Loaded clang-uml config from {}", config_path);
 
     LOG_INFO("Loading compilation database from {} directory",
-        config.compilation_database_dir);
+        config.compilation_database_dir());
 
-    cppast::libclang_compilation_database db(config.compilation_database_dir);
+    cppast::libclang_compilation_database db(config.compilation_database_dir());
 
-    std::string od = config.output_directory;
+    auto od = config.output_directory();
     if (output_directory)
         od = output_directory.value();
 

src/package_diagram/generators/plantuml/package_diagram_generator.cc

@@ -82,7 +82,7 @@ std::string generator::name(relationship_t r) const
 void generator::generate_relationships(
     const package &p, std::ostream &ostr) const
 {
-    const auto &uns = m_config.using_namespace;
+    const auto &uns = m_config.using_namespace();
 
     // Generate this packages relationship
     if (m_config.should_include_relationship("dependency")) {
@@ -111,7 +111,7 @@ void generator::generate_relationships(
 
 void generator::generate(const package &p, std::ostream &ostr) const
 {
-    const auto uns = m_config.using_namespace;
+    const auto &uns = m_config.using_namespace();
 
     ostr << "package [" << p.name() << "] ";
     ostr << "as " << p.alias();
@@ -150,12 +150,12 @@ void generator::generate(std::ostream &ostr) const
     ostr << "@startuml" << '\n';
 
     // Process aliases in any of the puml directives
-    for (const auto &b : m_config.puml.before) {
+    for (const auto &b : m_config.puml().before) {
         std::string note{b};
         std::tuple<std::string, size_t, size_t> alias_match;
         while (util::find_element_alias(note, alias_match)) {
             auto alias = m_model.to_alias(ns_relative(
-                m_config.using_namespace, std::get<0>(alias_match)));
+                m_config.using_namespace(), std::get<0>(alias_match)));
             note.replace(
                 std::get<1>(alias_match), std::get<2>(alias_match), alias);
         }
@@ -176,12 +176,12 @@ void generator::generate(std::ostream &ostr) const
     }
 
     // Process aliases in any of the puml directives
-    for (const auto &b : m_config.puml.after) {
+    for (const auto &b : m_config.puml().after) {
         std::string note{b};
         std::tuple<std::string, size_t, size_t> alias_match;
         while (util::find_element_alias(note, alias_match)) {
             auto alias = m_model.to_alias(ns_relative(
-                m_config.using_namespace, std::get<0>(alias_match)));
+                m_config.using_namespace(), std::get<0>(alias_match)));
             note.replace(
                 std::get<1>(alias_match), std::get<2>(alias_match), alias);
         }
@@ -208,7 +208,7 @@ clanguml::package_diagram::model::diagram generate(
     // Get all translation units matching the glob from diagram
     // configuration
     std::vector<std::string> translation_units{};
-    for (const auto &g : diagram.glob) {
+    for (const auto &g : diagram.glob()) {
         LOG_DBG("Processing glob: {}", g);
         const auto matches = glob::rglob(g);
         std::copy(matches.begin(), matches.end(),

src/package_diagram/visitor/translation_unit_visitor.cc

@@ -94,12 +94,12 @@ void translation_unit_visitor::operator()(const cppast::cpp_entity &file)
                         auto package_path = package_parent;
                         package_path.push_back(e.name());
 
-                        auto usn =
+                        auto usn = util::split(
-                            util::split(ctx.config().using_namespace[0], "::");
+                            ctx.config().using_namespace()[0], "::");
 
                         if (!util::starts_with(usn, package_path)) {
                             auto p = std::make_unique<package>(
-                                ctx.config().using_namespace);
+                                ctx.config().using_namespace());
                             util::remove_prefix(package_path, usn);
                             util::remove_prefix(package_parent, usn);
 

src/sequence_diagram/generators/plantuml/sequence_diagram_generator.cc

@@ -59,8 +59,8 @@ std::string generator::to_string(message_t r) const
 
 void generator::generate_call(const message &m, std::ostream &ostr) const
 {
-    const auto from = ns_relative(m_config.using_namespace, m.from);
+    const auto from = ns_relative(m_config.using_namespace(), m.from);
-    const auto to = ns_relative(m_config.using_namespace, m.to);
+    const auto to = ns_relative(m_config.using_namespace(), m.to);
 
     ostr << '"' << from << "\" "
          << "->"
@@ -72,8 +72,8 @@ void generator::generate_return(const message &m, std::ostream &ostr) const
     // Add return activity only for messages between different actors and
     // only if the return type is different than void
     if ((m.from != m.to) && (m.return_type != "void")) {
-        const auto from = ns_relative(m_config.using_namespace, m.from);
+        const auto from = ns_relative(m_config.using_namespace(), m.from);
-        const auto to = ns_relative(m_config.using_namespace, m.to);
+        const auto to = ns_relative(m_config.using_namespace(), m.to);
 
         ostr << '"' << to << "\" "
              << "-->"
@@ -84,7 +84,7 @@ void generator::generate_return(const message &m, std::ostream &ostr) const
 void generator::generate_activity(const activity &a, std::ostream &ostr) const
 {
     for (const auto &m : a.messages) {
-        const auto to = ns_relative(m_config.using_namespace, m.to);
+        const auto to = ns_relative(m_config.using_namespace(), m.to);
         generate_call(m, ostr);
         ostr << "activate " << '"' << to << '"' << std::endl;
         if (m_model.sequences.find(m.to_usr) != m_model.sequences.end())
@@ -98,10 +98,10 @@ void generator::generate(std::ostream &ostr) const
 {
     ostr << "@startuml" << std::endl;
 
-    for (const auto &b : m_config.puml.before)
+    for (const auto &b : m_config.puml().before)
         ostr << b << std::endl;
 
-    for (const auto &sf : m_config.start_from) {
+    for (const auto &sf : m_config.start_from()) {
         if (sf.location_type == source_location::location_t::function) {
             std::uint_least64_t start_from;
             for (const auto &[k, v] : m_model.sequences) {
@@ -117,7 +117,7 @@ void generator::generate(std::ostream &ostr) const
             continue;
         }
     }
-    for (const auto &a : m_config.puml.after)
+    for (const auto &a : m_config.puml().after)
         ostr << a << std::endl;
 
     ostr << "@enduml" << std::endl;
@@ -147,7 +147,7 @@ clanguml::sequence_diagram::model::diagram generate(
     // Get all translation units matching the glob from diagram
     // configuration
     std::vector<std::string> translation_units{};
-    for (const auto &g : diagram.glob) {
+    for (const auto &g : diagram.glob()) {
         spdlog::debug("Processing glob: {}", g);
         const auto matches = glob::rglob(g);
         std::copy(matches.begin(), matches.end(),

tests/CMakeLists.txt

@@ -6,6 +6,7 @@ set(CMAKE_CXX_STANDARD 17)
 
 file(GLOB_RECURSE TEST_CASE_SOURCES t*/*.cc)
 file(GLOB_RECURSE TEST_CASE_CONFIGS t*/.clang-uml)
+file(GLOB_RECURSE TEST_CONFIG_YMLS test_config_data/*.yml)
 
 set(CLANG_UML_TEST_UTIL_SRC
     test_util.cc
@@ -31,6 +32,14 @@ set(CLANG_UML_TEST_DECORATOR_PARSER_HEADER
     catch.h
 )
 
+set(CLANG_UML_TEST_CONFIG_SRC
+        test_config.cc
+        ${TEST_UTIL_SOURCES}
+        )
+set(CLANG_UML_TEST_CONFIG_HEADER
+        catch.h
+        )
+
 add_executable(test_util
     ${CLANG_UML_TEST_UTIL_SRC}
     ${CLANG_UML_TEST_UTIL_HEADER})
@@ -51,6 +60,16 @@ target_link_libraries(test_decorator_parser
     ${YAML_CPP_LIBRARIES}
     spdlog::spdlog clang-umllib cppast)
 
+add_executable(test_config
+        ${CLANG_UML_TEST_CONFIG_SRC}
+        ${CLANG_UML_TEST_CONFIG_HEADER})
+
+target_link_libraries(test_config
+        PRIVATE
+        ${LIBCLANG_LIBRARIES}
+        ${YAML_CPP_LIBRARIES}
+        spdlog::spdlog clang-umllib cppast)
+
 add_executable(test_cases
     ${CLANG_UML_TEST_CASES_SRC}
     ${CLANG_UML_TEST_CASES_HEADER})
@@ -73,6 +92,19 @@ foreach(TEST_CASE_CONFIG ${TEST_CASE_CONFIGS})
         COPYONLY)
 endforeach()
 
+foreach(TEST_CONFIG_YML ${TEST_CONFIG_YMLS})
+    file(RELATIVE_PATH
+            TEST_CONFIG_YML_RELATIVE
+            ${CMAKE_CURRENT_SOURCE_DIR}
+            ${TEST_CONFIG_YML})
+    message(${TEST_CONFIG_YML_RELATIVE})
+    configure_file(
+            ${TEST_CONFIG_YML_RELATIVE}
+            ${TEST_CONFIG_YML_RELATIVE}
+            COPYONLY)
+endforeach()
+
 add_test(NAME test_util COMMAND test_util)
 add_test(NAME test_decorator_parser COMMAND test_decorator_parser)
+add_test(NAME test_config COMMAND test_config)
 add_test(NAME test_cases COMMAND test_cases)

tests/t00002/test_case.h

@@ -24,11 +24,11 @@ TEST_CASE("t00002", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00002_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
+    REQUIRE(diagram->include().namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
+    REQUIRE_THAT(diagram->include().namespaces,
         VectorContains(std::string{"clanguml::t00002"}));
 
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
+    REQUIRE(diagram->exclude().namespaces.size() == 0);
 
     REQUIRE(diagram->should_include("clanguml::t00002::A"));
     REQUIRE(!diagram->should_include("std::vector"));
@@ -56,5 +56,5 @@ TEST_CASE("t00002", "[test-case][class]")
     REQUIRE_THAT(puml, IsAssociation(_A("D"), _A("A"), "-as"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00003/test_case.h

@@ -24,11 +24,11 @@ TEST_CASE("t00003", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00003_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
+    REQUIRE(diagram->include().namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
+    REQUIRE_THAT(diagram->include().namespaces,
         VectorContains(std::string{"clanguml::t00003"}));
 
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
+    REQUIRE(diagram->exclude().namespaces.size() == 0);
 
     REQUIRE(diagram->should_include("clanguml::t00003::A"));
 
@@ -64,5 +64,5 @@ TEST_CASE("t00003", "[test-case][class]")
     REQUIRE_THAT(puml, (IsField<Private>("c", "int")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00004/test_case.h

@@ -24,11 +24,11 @@ TEST_CASE("t00004", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00004_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
+    REQUIRE(diagram->include().namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
+    REQUIRE_THAT(diagram->include().namespaces,
         VectorContains(std::string{"clanguml::t00004"}));
 
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
+    REQUIRE(diagram->exclude().namespaces.size() == 0);
 
     REQUIRE(diagram->should_include("clanguml::t00004::A"));
     REQUIRE(diagram->should_include("clanguml::t00004::A::AA"));
@@ -54,5 +54,5 @@ TEST_CASE("t00004", "[test-case][class]")
     REQUIRE_THAT(puml, (IsMethod<Public, Const>("foo2")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00005/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00005", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00005_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00005"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00005::A"));
     REQUIRE(diagram->should_include("clanguml::t00005::B"));
     REQUIRE(diagram->should_include("clanguml::t00005::C"));
@@ -74,5 +68,5 @@ TEST_CASE("t00005", "[test-case][class]")
     REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("K"), "+k"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00006/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00006", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00006_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00006"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00006::A"));
     REQUIRE(diagram->should_include("clanguml::t00006::B"));
     REQUIRE(diagram->should_include("clanguml::t00006::C"));
@@ -83,5 +77,5 @@ TEST_CASE("t00006", "[test-case][class]")
     REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("NNN"), "+ns"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00007/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00007", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00007_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00007"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00007::A"));
     REQUIRE(diagram->should_include("clanguml::t00007::B"));
     REQUIRE(diagram->should_include("clanguml::t00007::C"));
@@ -55,5 +49,5 @@ TEST_CASE("t00007", "[test-case][class]")
     REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("C"), "+c"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00008/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00008", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00008_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00008"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00008::A"));
     REQUIRE(diagram->should_include("clanguml::t00008::B"));
 
@@ -58,5 +52,5 @@ TEST_CASE("t00008", "[test-case][class]")
     REQUIRE_THAT(puml, (IsField<Public>("comparator", "CMP")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00009/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00009", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00009_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00009"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00009::A"));
     REQUIRE(diagram->should_include("clanguml::t00009::B"));
 
@@ -61,5 +55,5 @@ TEST_CASE("t00009", "[test-case][class]")
         IsAssociation(_A("B"), _A("A<std::vector<std::string>>"), "+avector"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00010/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00010", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00010_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00010"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00010::A"));
     REQUIRE(diagram->should_include("clanguml::t00010::B"));
 
@@ -56,5 +50,5 @@ TEST_CASE("t00010", "[test-case][class]")
     REQUIRE_THAT(puml, IsAggregation(_A("C"), _A("B<int>"), "+aintstring"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00011/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00011", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00011_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00011"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00011::A"));
     REQUIRE(diagram->should_include("clanguml::t00011::B"));
 
@@ -50,5 +44,5 @@ TEST_CASE("t00011", "[test-case][class]")
     // REQUIRE_THAT(puml, IsFriend(_A("A"), _A("D<T>")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00012/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00012", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00012_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00012"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00012::A"));
     REQUIRE(diagram->should_include("clanguml::t00012::B"));
 
@@ -53,5 +47,5 @@ TEST_CASE("t00012", "[test-case][class]")
                "std::vector<std::vector<std::vector<std::string>>>>,3,3,3>")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00013/test_case.h

@@ -24,11 +24,6 @@ TEST_CASE("t00013", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00013_class");
 
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00013"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00013::A"));
     REQUIRE(diagram->should_include("clanguml::t00013::B"));
     REQUIRE(diagram->should_include("ABCD::F"));
@@ -63,5 +58,5 @@ TEST_CASE("t00013", "[test-case][class]")
     REQUIRE_THAT(puml, IsDependency(_A("R"), _A("F<int>")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00014/test_case.h

@@ -24,11 +24,6 @@ TEST_CASE("t00014", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00014_class");
 
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00014"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 2);
-
     REQUIRE(diagram->should_include("clanguml::t00014::S"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -58,5 +53,5 @@ TEST_CASE("t00014", "[test-case][class]")
     REQUIRE_THAT(puml, IsAggregation(_A("R"), _A("B"), "+bs2"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00015/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00015", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00015_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00015"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00015::ns1::ns2::A"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -48,5 +42,5 @@ TEST_CASE("t00015", "[test-case][class]")
     REQUIRE_THAT(puml, IsClass(_A("ns3::B")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00016/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00016", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00016_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00016"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00016::is_numeric"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -57,5 +51,5 @@ TEST_CASE("t00016", "[test-case][class]")
         IsInstantiation(_A("is_numeric<>"), _A("is_numeric<unsigned char>")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00017/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00017", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00017_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00017"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00017::A"));
     REQUIRE(diagram->should_include("clanguml::t00017::B"));
     REQUIRE(diagram->should_include("clanguml::t00017::C"));
@@ -78,5 +72,5 @@ TEST_CASE("t00017", "[test-case][class]")
     REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("K"), "-k"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00018/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00018", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00018_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00018"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00018::widget"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -49,5 +43,5 @@ TEST_CASE("t00018", "[test-case][class]")
     REQUIRE_THAT(puml, IsDependency(_A("impl::widget"), _A("widget")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00019/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00019", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00019_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00019"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00019::Layer1"));
     REQUIRE(diagram->should_include("clanguml::t00019::Layer2"));
     REQUIRE(diagram->should_include("clanguml::t00019::Layer3"));
@@ -56,5 +50,5 @@ TEST_CASE("t00019", "[test-case][class]")
             _A("Layer2<Layer3<Base>>"), _A("Layer1<Layer2<Layer3<Base>>>")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00020/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00020", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00020_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00020"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00020::ProductA"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -52,5 +46,5 @@ TEST_CASE("t00020", "[test-case][class]")
     REQUIRE_THAT(puml, IsClass(_A("Factory2")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00021/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00021", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00021_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00021"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00021::Visitor"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -50,5 +44,5 @@ TEST_CASE("t00021", "[test-case][class]")
     REQUIRE_THAT(puml, IsClass(_A("Visitor3")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00022/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00022", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00022_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00022"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00022::A"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -46,5 +40,5 @@ TEST_CASE("t00022", "[test-case][class]")
     REQUIRE_THAT(puml, IsClass(_A("A2")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00023/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00023", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00023_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00023"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00023::Visitor"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -46,5 +40,5 @@ TEST_CASE("t00023", "[test-case][class]")
     REQUIRE_THAT(puml, IsClass(_A("StrategyB")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00024/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00024", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00024_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00024"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00024::A"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -50,5 +44,5 @@ TEST_CASE("t00024", "[test-case][class]")
     REQUIRE_THAT(puml, IsBaseClass(_A("Target"), _A("Proxy")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00025/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00025", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00025_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00025"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00025::A"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -56,5 +50,5 @@ TEST_CASE("t00025", "[test-case][class]")
         puml, !IsAggregation(_A("ProxyHolder"), _A("Target2"), "+proxy2"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00026/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00026", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00026_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00026"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00026::A"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -50,5 +44,5 @@ TEST_CASE("t00026", "[test-case][class]")
         IsInstantiation(_A("Caretaker<T>"), _A("Caretaker<std::string>")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00027/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00027", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00027_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00027"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00027::A"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -62,5 +56,5 @@ TEST_CASE("t00027", "[test-case][class]")
         puml, IsAggregation(_A("Window"), _A("Text<Color>"), "+description"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00028/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00028", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00028_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00028"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00028::A"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -63,5 +57,5 @@ note.)";
     REQUIRE_THAT(puml, HasNote(_A("R"), "right", "R class note."));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00029/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00029", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00029_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00029"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00029::A"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -61,5 +55,5 @@ TEST_CASE("t00029", "[test-case][class]")
     REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("G4"), "+g4"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00030/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00030", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00030_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00030"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00030::A"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -53,5 +47,5 @@ TEST_CASE("t00030", "[test-case][class]")
     REQUIRE_THAT(puml, IsAssociation(_A("R"), _A("D"), "+ddd", "", "1"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00031/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00031", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00031_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00031"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00031::A"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -61,5 +55,5 @@ TEST_CASE("t00031", "[test-case][class]")
             _A("R"), _A("D"), "+ddd", "#blue,plain,thickness=16"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00032/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00032", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00032_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00032"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00032::A"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -59,5 +53,5 @@ TEST_CASE("t00032", "[test-case][class]")
     REQUIRE_THAT(puml, IsBaseClass(_A("C"), _A("Overload<TBase,int,A,B,C>")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00033/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00033", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00033_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00033"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00033::A"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -62,5 +56,5 @@ TEST_CASE("t00033", "[test-case][class]")
         puml, IsInstantiation(_A("A<T>"), _A("A<B<std::unique_ptr<C<D>>>>")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t00034/test_case.h

@@ -24,12 +24,6 @@ TEST_CASE("t00034", "[test-case][class]")
 
     REQUIRE(diagram->name == "t00034_class");
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t00034"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 0);
-
     REQUIRE(diagram->should_include("clanguml::t00034::A"));
 
     auto model = generate_class_diagram(db, diagram);
@@ -54,5 +48,5 @@ TEST_CASE("t00034", "[test-case][class]")
         puml, IsInstantiation(_A("drop_void<T>"), _A("drop_void<Void>")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t20001/test_case.h

@@ -22,14 +22,6 @@ TEST_CASE("t20001", "[test-case][sequence]")
 
     auto diagram = config.diagrams["t20001_sequence"];
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t20001"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->exclude.namespaces,
-        VectorContains(std::string{"clanguml::t20001::detail"}));
-
     REQUIRE(diagram->should_include("clanguml::t20001::A"));
     REQUIRE(!diagram->should_include("clanguml::t20001::detail::C"));
     REQUIRE(!diagram->should_include("std::vector"));
@@ -52,5 +44,5 @@ TEST_CASE("t20001", "[test-case][sequence]")
     REQUIRE_THAT(puml, !HasCall("A", "detail::C", "add"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t20002/test_case.h

@@ -22,10 +22,6 @@ TEST_CASE("t20002", "[test-case][sequence]")
 
     auto diagram = config.diagrams["t20002_sequence"];
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t20002"}));
-
     REQUIRE(diagram->name == "t20002_sequence");
 
     auto model = generate_sequence_diagram(db, diagram);
@@ -42,5 +38,5 @@ TEST_CASE("t20002", "[test-case][sequence]")
     REQUIRE_THAT(puml, HasFunctionCall("m3", "m4"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t30001/test_case.h

@@ -22,14 +22,6 @@ TEST_CASE("t30001", "[test-case][package]")
 
     auto diagram = config.diagrams["t30001_package"];
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t30001"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->exclude.namespaces,
-        VectorContains(std::string{"clanguml::t30001::detail"}));
-
     REQUIRE(diagram->should_include("clanguml::t30001::A"));
     REQUIRE(!diagram->should_include("clanguml::t30001::detail::C"));
     REQUIRE(!diagram->should_include("std::vector"));
@@ -51,5 +43,5 @@ TEST_CASE("t30001", "[test-case][package]")
     REQUIRE_THAT(puml, IsPackage("AAA"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t30002/test_case.h

@@ -22,14 +22,6 @@ TEST_CASE("t30002", "[test-case][package]")
 
     auto diagram = config.diagrams["t30002_package"];
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t30002"}));
-
-    REQUIRE(diagram->exclude.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->exclude.namespaces,
-        VectorContains(std::string{"clanguml::t30002::detail"}));
-
     REQUIRE(diagram->should_include("clanguml::t30002::A"));
     REQUIRE(!diagram->should_include("clanguml::t30002::detail::C"));
     REQUIRE(!diagram->should_include("std::vector"));
@@ -74,5 +66,5 @@ TEST_CASE("t30002", "[test-case][package]")
     REQUIRE_THAT(puml, IsDependency(_A("BBB"), _A("A13")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t30003/test_case.h

@@ -22,10 +22,6 @@ TEST_CASE("t30003", "[test-case][package]")
 
     auto diagram = config.diagrams["t30003_package"];
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t30003"}));
-
     REQUIRE(diagram->should_include("clanguml::t30003::A"));
     REQUIRE(diagram->should_include("clanguml::t30003::C"));
     REQUIRE(!diagram->should_include("std::vector"));
@@ -52,5 +48,5 @@ TEST_CASE("t30003", "[test-case][package]")
     REQUIRE_THAT(puml, IsDeprecated(_A("ns3")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t30004/test_case.h

@@ -22,10 +22,6 @@ TEST_CASE("t30004", "[test-case][package]")
 
     auto diagram = config.diagrams["t30004_package"];
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t30004"}));
-
     REQUIRE(diagram->should_include("clanguml::t30004::A"));
     REQUIRE(diagram->should_include("clanguml::t30004::C"));
     REQUIRE(!diagram->should_include("std::vector"));
@@ -49,5 +45,5 @@ TEST_CASE("t30004", "[test-case][package]")
     REQUIRE_THAT(puml, IsPackage("EEE"));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t30005/test_case.h

@@ -22,10 +22,6 @@ TEST_CASE("t30005", "[test-case][package]")
 
     auto diagram = config.diagrams["t30005_package"];
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t30005"}));
-
     REQUIRE(diagram->should_include("clanguml::t30005::A"));
     REQUIRE(diagram->should_include("clanguml::t30005::C"));
     REQUIRE(!diagram->should_include("std::vector"));
@@ -50,5 +46,5 @@ TEST_CASE("t30005", "[test-case][package]")
     REQUIRE_THAT(puml, IsDependency(_A("CCC"), _A("AAA")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t30006/test_case.h

@@ -22,10 +22,6 @@ TEST_CASE("t30006", "[test-case][package]")
 
     auto diagram = config.diagrams["t30006_package"];
 
-    REQUIRE(diagram->include.namespaces.size() == 1);
-    REQUIRE_THAT(diagram->include.namespaces,
-        VectorContains(std::string{"clanguml::t30006"}));
-
     REQUIRE(diagram->should_include("clanguml::t30006::A"));
     REQUIRE(diagram->should_include("clanguml::t30006::C"));
     REQUIRE(!diagram->should_include("std::vector"));
@@ -50,5 +46,5 @@ TEST_CASE("t30006", "[test-case][package]")
     REQUIRE_THAT(puml, IsDependency(_A("A"), _A("C")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/t90000/test_case.h

@@ -36,5 +36,5 @@ TEST_CASE("t90000", "[test-case][config]")
     REQUIRE_THAT(puml, IsClass(_A("Boo")));
 
     save_puml(
-        "./" + config.output_directory + "/" + diagram->name + ".puml", puml);
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
 }

tests/test_cases.cc

@@ -24,7 +24,7 @@ load_config(const std::string &test_name)
 {
     auto config = clanguml::config::load(test_name + "/.clang-uml");
 
-    cppast::libclang_compilation_database db(config.compilation_database_dir);
+    cppast::libclang_compilation_database db(config.compilation_database_dir());
 
     return std::make_pair(std::move(config), std::move(db));
 }
@@ -35,7 +35,7 @@ std::pair<clanguml::config::config, compilation_database> load_config2(
     auto config = clanguml::config::load(test_name + "/.clang-uml");
 
     auto db = clanguml::cx::compilation_database::from_directory(
-        config.compilation_database_dir);
+        config.compilation_database_dir());
 
     return std::make_pair(std::move(config), std::move(db));
 }

tests/test_config.cc

@@ -0,0 +1,54 @@
+/**
+ * tests/test_config.cc
+ *
+ * Copyright (c) 2021-2022 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 "catch.h"
+
+#include "config/config.h"
+#include "util/util.h"
+
+TEST_CASE("Test config simple", "[unit-test]")
+{
+    auto cfg = clanguml::config::load("./test_config_data/simple.yml");
+
+    CHECK(cfg.diagrams.size() == 1);
+    auto &diagram = *cfg.diagrams["class_main"];
+    CHECK(diagram.type() == clanguml::config::diagram_type::class_diagram);
+    CHECK(diagram.glob().size() == 2);
+    CHECK(clanguml::util::contains(diagram.using_namespace(), "clanguml"));
+}
+
+TEST_CASE("Test config inherited", "[unit-test]")
+{
+    auto cfg = clanguml::config::load("./test_config_data/inherited.yml");
+
+    CHECK(cfg.diagrams.size() == 2);
+    auto &def = *cfg.diagrams["class_default"];
+    CHECK(def.type() == clanguml::config::diagram_type::class_diagram);
+    CHECK(def.glob().size() == 2);
+    CHECK(def.glob()[0] == "src/**/*.cc");
+    CHECK(def.glob()[1] == "src/**/*.h");
+    CHECK(clanguml::util::contains(def.using_namespace(), "clanguml"));
+
+    auto &cus = *cfg.diagrams["class_custom"];
+    CHECK(cus.type() == clanguml::config::diagram_type::class_diagram);
+    CHECK(cus.glob().size() == 1);
+    CHECK(cus.glob()[0] == "src/main.cc");
+    CHECK(clanguml::util::contains(cus.using_namespace(), "clanguml::ns1"));
+    CHECK(cus.include_relations_also_as_members());
+}

tests/test_config_data/inherited.yml

@@ -0,0 +1,24 @@
+compilation_database_dir: debug
+output_directory: output
+include_relations_also_as_members: false
+using_namespace:
+  - clanguml
+include:
+  namespaces:
+    - clanguml
+    - ABCD
+glob:
+  - src/**/*.cc
+  - src/**/*.h
+
+diagrams:
+  class_default:
+    type: class
+  class_custom:
+    type: class
+    using_namespace:
+      - clanguml::ns1
+    include_relations_also_as_members: true
+    glob:
+      - src/main.cc
+

tests/test_config_data/simple.yml

@@ -0,0 +1,14 @@
+compilation_database_dir: debug
+output_directory: output
+diagrams:
+  class_main:
+    type: class
+    glob:
+      - src/**/*.cc
+      - src/**/*.h
+    using_namespace:
+      - clanguml
+    include:
+      namespaces:
+        - clanguml
+        - ABCD