Added package dependencies and dependants filter

src/class_diagram/model/class.h

@@ -26,6 +26,8 @@
 #include "common/model/stylable_element.h"
 #include "type_alias.h"
 
+#include <type_safe/reference.hpp>
+
 #include <string>
 #include <vector>
 
@@ -90,3 +92,17 @@ private:
 };
 
 }
+
+namespace std {
+template <>
+struct hash<
+    type_safe::object_ref<const clanguml::class_diagram::model::class_>> {
+    std::size_t operator()(const type_safe::object_ref<
+        const clanguml::class_diagram::model::class_> &key) const
+    {
+        using clanguml::class_diagram::model::class_;
+
+        return std::hash<std::string>{}(key.get().full_name(false));
+    }
+};
+}

src/class_diagram/model/diagram.cc

@@ -192,3 +192,11 @@ std::string diagram::to_alias(const std::string &full_name) const
 }
 
 }
+
+namespace clanguml::common::model {
+template <>
+bool check_diagram_type<clanguml::class_diagram::model::diagram>(diagram_t t)
+{
+    return t == diagram_t::kClass;
+}
+}

src/class_diagram/model/diagram.h

@@ -83,17 +83,7 @@ private:
 };
 }
 
-namespace std {
+namespace clanguml::common::model {
-
 template <>
-struct hash<
+bool check_diagram_type<clanguml::class_diagram::model::diagram>(diagram_t t);
-    type_safe::object_ref<const clanguml::class_diagram::model::class_>> {
+}
-    std::size_t operator()(const type_safe::object_ref<
-        const clanguml::class_diagram::model::class_> &key) const
-    {
-        using clanguml::class_diagram::model::class_;
-
-        return std::hash<std::string>{}(key.get().full_name(false));
-    }
-};
-}

src/common/model/diagram.h

@@ -72,4 +72,5 @@ private:
     bool complete_{false};
 };
 
+template <typename DiagramT> bool check_diagram_type(diagram_t t);
 }

src/common/model/diagram_filter.cc

@@ -19,6 +19,8 @@
 #include "diagram_filter.h"
 
 #include "class_diagram/model/class.h"
+#include "common/model/package.h"
+#include "package_diagram/model/diagram.h"
 
 namespace clanguml::common::model {
 
@@ -38,6 +40,13 @@ view(const class_diagram::model::diagram &d)
     return d.enums();
 }
 
+template <>
+const std::vector<type_safe::object_ref<const common::model::package>> &view(
+    const package_diagram::model::diagram &d)
+{
+    return d.packages();
+}
+
 template <>
 const type_safe::optional_ref<const class_diagram::model::class_> get(
     const class_diagram::model::diagram &d, const std::string &full_name)
@@ -45,6 +54,13 @@ const type_safe::optional_ref<const class_diagram::model::class_> get(
     return d.get_class(full_name);
 }
 
+template <>
+const type_safe::optional_ref<const common::model::package> get(
+    const package_diagram::model::diagram &d, const std::string &full_name)
+{
+    return d.get_package(full_name);
+}
+
 }
 
 filter_visitor::filter_visitor(filter_t type)
@@ -357,17 +373,22 @@ void diagram_filter::init_filters(const config::diagram &c)
     if (c.include) {
         add_inclusive_filter(std::make_unique<namespace_filter>(
             filter_t::kInclusive, c.include().namespaces));
+
         add_inclusive_filter(std::make_unique<relationship_filter>(
             filter_t::kInclusive, c.include().relationships));
+
         add_inclusive_filter(std::make_unique<access_filter>(
             filter_t::kInclusive, c.include().access));
+
         add_inclusive_filter(std::make_unique<paths_filter>(
             filter_t::kInclusive, c.base_directory(), c.include().paths));
 
         // Include any of these matches even if one them does not match
         std::vector<std::unique_ptr<filter_visitor>> element_filters;
+
         element_filters.emplace_back(std::make_unique<element_filter>(
             filter_t::kInclusive, c.include().elements));
+
         element_filters.emplace_back(std::make_unique<subclass_filter>(
             filter_t::kInclusive, c.include().subclasses));
 
@@ -381,11 +402,21 @@ void diagram_filter::init_filters(const config::diagram &c)
                 class_diagram::model::class_>>(filter_t::kInclusive,
                 relationship_t::kDependency, c.include().dependants));
 
+        element_filters.emplace_back(std::make_unique<tree_element_filter<
+                package_diagram::model::diagram, common::model::package>>(
+            filter_t::kInclusive, relationship_t::kDependency,
+            c.include().dependants));
+
         element_filters.emplace_back(
             std::make_unique<tree_element_filter<class_diagram::model::diagram,
                 class_diagram::model::class_>>(filter_t::kInclusive,
                 relationship_t::kDependency, c.include().dependencies, true));
 
+        element_filters.emplace_back(std::make_unique<tree_element_filter<
+                package_diagram::model::diagram, common::model::package>>(
+            filter_t::kInclusive, relationship_t::kDependency,
+            c.include().dependencies, true));
+
         element_filters.emplace_back(std::make_unique<context_filter>(
             filter_t::kInclusive, c.include().context));
 
@@ -397,28 +428,47 @@ void diagram_filter::init_filters(const config::diagram &c)
     if (c.exclude) {
         add_exclusive_filter(std::make_unique<namespace_filter>(
             filter_t::kExclusive, c.exclude().namespaces));
+
         add_exclusive_filter(std::make_unique<paths_filter>(
             filter_t::kExclusive, c.base_directory(), c.exclude().paths));
+
         add_exclusive_filter(std::make_unique<element_filter>(
             filter_t::kExclusive, c.exclude().elements));
+
         add_exclusive_filter(std::make_unique<relationship_filter>(
             filter_t::kExclusive, c.exclude().relationships));
+
         add_exclusive_filter(std::make_unique<access_filter>(
             filter_t::kExclusive, c.exclude().access));
+
         add_exclusive_filter(std::make_unique<subclass_filter>(
             filter_t::kExclusive, c.exclude().subclasses));
+
         add_exclusive_filter(
             std::make_unique<tree_element_filter<class_diagram::model::diagram,
                 class_diagram::model::class_>>(filter_t::kExclusive,
                 relationship_t::kInstantiation, c.exclude().specializations));
+
         add_exclusive_filter(
             std::make_unique<tree_element_filter<class_diagram::model::diagram,
                 class_diagram::model::class_>>(filter_t::kExclusive,
                 relationship_t::kDependency, c.exclude().dependants));
+
+        add_exclusive_filter(std::make_unique<tree_element_filter<
+                package_diagram::model::diagram, common::model::package>>(
+            filter_t::kExclusive, relationship_t::kDependency,
+            c.exclude().dependants));
+
         add_exclusive_filter(
             std::make_unique<tree_element_filter<class_diagram::model::diagram,
                 class_diagram::model::class_>>(filter_t::kExclusive,
                 relationship_t::kDependency, c.exclude().dependencies, true));
+
+        add_exclusive_filter(std::make_unique<tree_element_filter<
+                package_diagram::model::diagram, common::model::package>>(
+            filter_t::kExclusive, relationship_t::kDependency,
+            c.exclude().dependencies, true));
+
         add_exclusive_filter(std::make_unique<context_filter>(
             filter_t::kExclusive, c.exclude().context));
     }

src/common/model/diagram_filter.h

@@ -125,14 +125,17 @@ struct tree_element_filter : public filter_visitor {
 
     tvl::value_t match(const diagram &d, const element &e) const override
     {
-        if (roots_.empty())
-            return {};
-
         // This filter should only be run on the completely generated diagram
         // model by visitor
         if (!d.complete())
             return {};
 
+        if (!check_diagram_type<DiagramT>(d.type()))
+            return {};
+
+        if (roots_.empty())
+            return {};
+
         const auto &cd = dynamic_cast<const DiagramT &>(d);
 
         // Calculate the set of matching elements
@@ -146,14 +149,10 @@ struct tree_element_filter : public filter_visitor {
             return false;
 
         // Now check if the e element is contained in the calculated set
-        const auto &e_full_name = e.full_name(false);
+        return std::any_of(matching_elements_.begin(), matching_elements_.end(),
-        bool res =
+            [&e](const auto &te) {
-            std::find_if(matching_elements_.begin(), matching_elements_.end(),
+                return te->full_name(false) == e.full_name(false);
-                [&e_full_name](const auto &te) {
+            });
-                    return te->full_name(false) == e_full_name;
-                }) != matching_elements_.end();
-
-        return res;
     }
 
 private:
@@ -207,6 +206,27 @@ private:
             }
         }
 
+        if constexpr (std::is_same_v<ElementT, common::model::package>) {
+            if (type() == filter_t::kInclusive) {
+                // For package diagrams, add also all parents of matching
+                // packages
+                decltype(matching_elements_) parents;
+                util::for_each(matching_elements_,
+                    [this, &cd, &parents](const auto &package) {
+                        auto parent_path = package.get().path();
+                        auto parent = cd.get_package(parent_path.to_string());
+                        while (parent.has_value()) {
+                            parents.emplace(type_safe::ref(parent.value()));
+                            parent = cd.get_package(
+                                parent.value().path().to_string());
+                        }
+                    });
+
+                matching_elements_.insert(
+                    std::begin(parents), std::end(parents));
+            }
+        }
+
         initialized_ = true;
     }
 

src/common/model/enums.cc

@@ -1,5 +1,5 @@
 /**
- * src/class_diagram/model/enums.cc
+ * src/common/model/enums.cc
  *
  * Copyright (c) 2021-2022 Bartek Kryza <bkryza@gmail.com>
  *
@@ -74,4 +74,21 @@ std::string to_string(message_t r)
         assert(false);
     }
 }
+
+std::string to_string(const diagram_t t)
+{
+    switch (t) {
+    case diagram_t::kClass:
+        return "class";
+    case diagram_t::kSequence:
+        return "sequence";
+    case diagram_t::kPackage:
+        return "package";
+    case diagram_t::kInclude:
+        return "include";
+    default:
+        assert(false);
+    }
+}
+
 }

src/common/model/enums.h

@@ -1,5 +1,5 @@
 /**
- * src/class_diagram/model/enums.h
+ * src/common/model/enums.h
  *
  * Copyright (c) 2021-2022 Bartek Kryza <bkryza@gmail.com>
  *
@@ -21,7 +21,7 @@
 
 namespace clanguml::common::model {
 
-enum class diagram_t { kClass, kSequence, kPackage };
+enum class diagram_t { kClass, kSequence, kPackage, kInclude };
 
 enum class access_t { kPublic, kProtected, kPrivate };
 
@@ -47,4 +47,6 @@ std::string to_string(access_t r);
 
 std::string to_string(message_t r);
 
+std::string to_string(diagram_t r);
+
 }

src/common/model/package.cc

@@ -1,5 +1,5 @@
 /**
- * src/common/model/class.h
+ * src/common/model/package.cc
  *
  * Copyright (c) 2021-2022 Bartek Kryza <bkryza@gmail.com>
  *
@@ -18,8 +18,6 @@
 
 #include "package.h"
 
-#include "util/util.h"
-
 #include <sstream>
 
 namespace clanguml::common::model {
@@ -35,11 +33,11 @@ std::string package::full_name(bool relative) const
         return res.to_string();
     }
 
-    return (get_namespace().relative_to(using_namespace()) | name())
+    return (get_namespace() | name()).to_string();
-        .to_string();
 }
 
 bool package::is_deprecated() const { return is_deprecated_; }
 
 void package::set_deprecated(bool deprecated) { is_deprecated_ = deprecated; }
+
 }

src/common/model/package.h

@@ -1,5 +1,5 @@
 /**
- * src/package_diagram/model/class.h
+ * src/common/model/package.h
  *
  * Copyright (c) 2021-2022 Bartek Kryza <bkryza@gmail.com>
  *
@@ -54,3 +54,17 @@ private:
     bool is_deprecated_{false};
 };
 }
+
+namespace std {
+template <>
+struct hash<type_safe::object_ref<const clanguml::common::model::package>> {
+    std::size_t operator()(
+        const type_safe::object_ref<const clanguml::common::model::package>
+            &key) const
+    {
+        using clanguml::common::model::package;
+
+        return std::hash<std::string>{}(key.get().full_name(false));
+    }
+};
+}

src/common/model/relationship.cc

@@ -1,5 +1,5 @@
 /**
- * src/common/model/class_relationship.cc
+ * src/common/model/relationship.cc
  *
  * Copyright (c) 2021-2022 Bartek Kryza <bkryza@gmail.com>
  *

src/common/model/stylable_element.cc

@@ -1,5 +1,5 @@
 /**
- * src/class_diagram/model/stylable_element.cc
+ * src/common/model/stylable_element.cc
  *
  * Copyright (c) 2021-2022 Bartek Kryza <bkryza@gmail.com>
  *

src/common/model/stylable_element.h

@@ -1,5 +1,5 @@
 /**
- * src/class_diagram/model/stylable_element.h
+ * src/common/model/stylable_element.h
  *
  * Copyright (c) 2021-2022 Bartek Kryza <bkryza@gmail.com>
  *

src/config/config.cc

@@ -60,22 +60,6 @@ config load(const std::string &config_file)
     }
 }
 
-std::string to_string(const diagram_type t)
-{
-    switch (t) {
-    case diagram_type::class_diagram:
-        return "class";
-    case diagram_type::sequence_diagram:
-        return "sequence";
-    case diagram_type::package_diagram:
-        return "package";
-    case diagram_type::include_diagram:
-        return "include";
-    default:
-        assert(false);
-    }
-}
-
 std::string to_string(const hint_t t)
 {
     switch (t) {
@@ -115,7 +99,10 @@ void inheritable_diagram_options::inherit(
     relative_to.override(parent.relative_to);
 }
 
-diagram_type class_diagram::type() const { return diagram_type::class_diagram; }
+common::model::diagram_t class_diagram::type() const
+{
+    return common::model::diagram_t::kClass;
+}
 
 bool class_diagram::has_class(std::string clazz)
 {
@@ -133,19 +120,19 @@ bool class_diagram::has_class(std::string clazz)
     return false;
 }
 
-diagram_type sequence_diagram::type() const
+common::model::diagram_t sequence_diagram::type() const
 {
-    return diagram_type::sequence_diagram;
+    return common::model::diagram_t::kSequence;
 }
 
-diagram_type package_diagram::type() const
+common::model::diagram_t package_diagram::type() const
 {
-    return diagram_type::package_diagram;
+    return common::model::diagram_t::kPackage;
 }
 
-diagram_type include_diagram::type() const
+common::model::diagram_t include_diagram::type() const
 {
-    return diagram_type::include_diagram;
+    return common::model::diagram_t::kInclude;
 }
 
 template <>

src/config/config.h

@@ -35,13 +35,6 @@
 namespace clanguml {
 namespace config {
 
-enum class diagram_type {
-    class_diagram,
-    sequence_diagram,
-    package_diagram,
-    include_diagram
-};
-
 enum class method_arguments { full, abbreviated, none };
 
 struct plantuml {
@@ -102,7 +95,6 @@ struct git_config {
     std::string toplevel;
 };
 
-std::string to_string(const diagram_type t);
 std::string to_string(const hint_t t);
 
 struct inheritable_diagram_options {
@@ -127,7 +119,7 @@ struct inheritable_diagram_options {
 struct diagram : public inheritable_diagram_options {
     virtual ~diagram() = default;
 
-    virtual diagram_type type() const = 0;
+    virtual common::model::diagram_t type() const = 0;
 
     std::string name;
 };
@@ -141,7 +133,7 @@ struct source_location {
 struct class_diagram : public diagram {
     virtual ~class_diagram() = default;
 
-    diagram_type type() const override;
+    common::model::diagram_t type() const override;
 
     option<std::vector<std::string>> classes{"classes"};
     option<layout_hints> layout{"layout"};
@@ -152,7 +144,7 @@ struct class_diagram : public diagram {
 struct sequence_diagram : public diagram {
     virtual ~sequence_diagram() = default;
 
-    diagram_type type() const override;
+    common::model::diagram_t type() const override;
 
     option<std::vector<source_location>> start_from{"start_from"};
 };
@@ -160,7 +152,7 @@ struct sequence_diagram : public diagram {
 struct package_diagram : public diagram {
     virtual ~package_diagram() = default;
 
-    diagram_type type() const override;
+    common::model::diagram_t type() const override;
 
     option<layout_hints> layout{"layout"};
 };
@@ -168,7 +160,7 @@ struct package_diagram : public diagram {
 struct include_diagram : public diagram {
     virtual ~include_diagram() = default;
 
-    diagram_type type() const override;
+    common::model::diagram_t type() const override;
 
     option<layout_hints> layout{"layout"};
 };

src/include_diagram/model/diagram.cc

@@ -95,3 +95,11 @@ std::string diagram::to_alias(const std::string &full_name) const
 }
 
 }
+
+namespace clanguml::common::model {
+template <>
+bool check_diagram_type<clanguml::include_diagram::model::diagram>(diagram_t t)
+{
+    return t == diagram_t::kInclude;
+}
+}

src/include_diagram/model/diagram.h

@@ -57,3 +57,8 @@ private:
         files_;
 };
 }
+
+namespace clanguml::common::model {
+template <>
+bool check_diagram_type<clanguml::include_diagram::model::diagram>(diagram_t t);
+}

src/main.cc

@@ -130,8 +130,8 @@ void generate_diagram(const std::string &od, const std::string &name,
     std::shared_ptr<clanguml::config::diagram> diagram,
     const cppast::libclang_compilation_database &db, bool verbose)
 {
+    using clanguml::common::model::diagram_t;
     using clanguml::config::class_diagram;
-    using clanguml::config::diagram_type;
     using clanguml::config::include_diagram;
     using clanguml::config::package_diagram;
     using clanguml::config::sequence_diagram;
@@ -140,7 +140,7 @@ void generate_diagram(const std::string &od, const std::string &name,
     std::ofstream ofs;
     ofs.open(path, std::ofstream::out | std::ofstream::trunc);
 
-    if (diagram->type() == diagram_type::class_diagram) {
+    if (diagram->type() == diagram_t::kClass) {
         using diagram_config = class_diagram;
         using diagram_model = clanguml::class_diagram::model::diagram;
         using diagram_visitor =
@@ -154,7 +154,7 @@ void generate_diagram(const std::string &od, const std::string &name,
         ofs << clanguml::class_diagram::generators::plantuml::generator(
             dynamic_cast<diagram_config &>(*diagram), *model);
     }
-    else if (diagram->type() == diagram_type::sequence_diagram) {
+    else if (diagram->type() == diagram_t::kSequence) {
         using diagram_config = sequence_diagram;
         using diagram_model = clanguml::sequence_diagram::model::diagram;
         using diagram_visitor =
@@ -169,7 +169,7 @@ void generate_diagram(const std::string &od, const std::string &name,
             dynamic_cast<clanguml::config::sequence_diagram &>(*diagram),
             *model);
     }
-    else if (diagram->type() == diagram_type::package_diagram) {
+    else if (diagram->type() == diagram_t::kPackage) {
         using diagram_config = package_diagram;
         using diagram_model = clanguml::package_diagram::model::diagram;
         using diagram_visitor =
@@ -183,7 +183,7 @@ void generate_diagram(const std::string &od, const std::string &name,
         ofs << clanguml::package_diagram::generators::plantuml::generator(
             dynamic_cast<diagram_config &>(*diagram), *model);
     }
-    else if (diagram->type() == diagram_type::include_diagram) {
+    else if (diagram->type() == diagram_t::kInclude) {
         using diagram_config = include_diagram;
         using diagram_model = clanguml::include_diagram::model::diagram;
         using diagram_visitor =

src/package_diagram/generators/plantuml/package_diagram_generator.cc

@@ -85,7 +85,8 @@ void generator::generate(const package &p, std::ostream &ostr) const
     }
 
     for (const auto &subpackage : p) {
-        generate(dynamic_cast<const package &>(*subpackage), ostr);
+        if (m_model.should_include(dynamic_cast<package &>(*subpackage)))
+            generate(dynamic_cast<const package &>(*subpackage), ostr);
     }
 
     if (!uns.starts_with(p.full_name(false))) {
@@ -102,14 +103,14 @@ void generator::generate(std::ostream &ostr) const
     generate_plantuml_directives(ostr, m_config.puml().before);
 
     for (const auto &p : m_model) {
-        generate(dynamic_cast<package &>(*p), ostr);
+        if (m_model.should_include(dynamic_cast<package &>(*p)))
-        ostr << '\n';
+            generate(dynamic_cast<package &>(*p), ostr);
     }
 
     // Process package relationships
     for (const auto &p : m_model) {
-        generate_relationships(dynamic_cast<package &>(*p), ostr);
+        if (m_model.should_include(dynamic_cast<package &>(*p)))
-        ostr << '\n';
+            generate_relationships(dynamic_cast<package &>(*p), ostr);
     }
 
     generate_config_layout_hints(ostr);

src/package_diagram/model/diagram.cc

@@ -28,6 +28,12 @@ common::model::diagram_t diagram::type() const
     return common::model::diagram_t::kPackage;
 }
 
+const std::vector<type_safe::object_ref<const common::model::package>> &
+diagram::packages() const
+{
+    return packages_;
+}
+
 void diagram::add_package(std::unique_ptr<common::model::package> &&p)
 {
     LOG_DBG("Adding package: {}, {}", p->name(), p->full_name(true));
@@ -43,7 +49,8 @@ type_safe::optional_ref<const common::model::package> diagram::get_package(
     const std::string &name) const
 {
     for (const auto &p : packages_) {
-        if (p.get().full_name(false) == name) {
+        auto p_full_name = p.get().full_name(false);
+        if (p_full_name == name) {
             return {p};
         }
     }
@@ -76,3 +83,11 @@ std::string diagram::to_alias(const std::string &full_name) const
     return package.value().alias();
 }
 }
+
+namespace clanguml::common::model {
+template <>
+bool check_diagram_type<clanguml::package_diagram::model::diagram>(diagram_t t)
+{
+    return t == diagram_t::kPackage;
+}
+}

src/package_diagram/model/diagram.h

@@ -41,6 +41,9 @@ public:
 
     common::model::diagram_t type() const override;
 
+    const std::vector<type_safe::object_ref<const common::model::package>> &
+    packages() const;
+
     type_safe::optional_ref<const common::model::diagram_element> get(
         const std::string &full_name) const;
 
@@ -56,3 +59,8 @@ private:
         packages_;
 };
 }
+
+namespace clanguml::common::model {
+template <>
+bool check_diagram_type<clanguml::package_diagram::model::diagram>(diagram_t t);
+}

src/sequence_diagram/model/diagram.cc

@@ -40,3 +40,11 @@ std::string diagram::to_alias(const std::string &full_name) const
 }
 
 }
+
+namespace clanguml::common::model {
+template <>
+bool check_diagram_type<clanguml::sequence_diagram::model::diagram>(diagram_t t)
+{
+    return t == diagram_t::kSequence;
+}
+}

src/sequence_diagram/model/diagram.h

@@ -47,3 +47,9 @@ public:
 };
 
 }
+
+namespace clanguml::common::model {
+template <>
+bool check_diagram_type<clanguml::sequence_diagram::model::diagram>(
+    diagram_t t);
+}

tests/t30008/.clang-uml

@@ -0,0 +1,17 @@
+compilation_database_dir: ..
+output_directory: puml
+diagrams:
+  t30008_package:
+    type: package
+    glob:
+      - ../../tests/t30008/t30008.cc
+    include:
+      dependants:
+        - clanguml::t30008::dependants::A
+      dependencies:
+        - clanguml::t30008::dependencies::F
+    using_namespace:
+      - clanguml::t30008
+    plantuml:
+      before:
+        - "' t30008 test package diagram"

tests/t30008/t30008.cc

@@ -0,0 +1,45 @@
+namespace clanguml {
+namespace t30008 {
+
+namespace dependants {
+namespace X {
+}
+namespace A {
+struct AA {
+};
+}
+namespace B {
+struct BB {
+    A::AA *aa;
+};
+}
+namespace C {
+struct CC {
+    B::BB *bb;
+};
+}
+
+} // namespace dependants
+
+namespace dependencies {
+namespace Y {
+}
+
+namespace D {
+struct DD {
+};
+}
+namespace E {
+struct EE {
+    D::DD *dd;
+};
+}
+namespace F {
+struct FF {
+    E::EE *ee;
+};
+}
+} // namespace dependencies
+
+} // namespace t30008
+} // namespace clanguml

tests/t30008/test_case.h

@@ -0,0 +1,55 @@
+/**
+ * tests/t30008/test_case.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.
+ */
+
+TEST_CASE("t30008", "[test-case][package]")
+{
+    auto [config, db] = load_config("t30008");
+
+    auto diagram = config.diagrams["t30008_package"];
+
+    REQUIRE(diagram->name == "t30008_package");
+
+    auto model = generate_package_diagram(db, diagram);
+
+    REQUIRE(model->name() == "t30008_package");
+
+    auto puml = generate_package_puml(diagram, *model);
+    AliasMatcher _A(puml);
+
+    REQUIRE_THAT(puml, StartsWith("@startuml"));
+    REQUIRE_THAT(puml, EndsWith("@enduml\n"));
+
+    REQUIRE_THAT(puml, IsPackage("A"));
+    REQUIRE_THAT(puml, IsPackage("B"));
+    REQUIRE_THAT(puml, IsPackage("C"));
+    REQUIRE_THAT(puml, !IsPackage("X"));
+
+    REQUIRE_THAT(puml, IsDependency(_A("B"), _A("A")));
+    REQUIRE_THAT(puml, IsDependency(_A("C"), _A("B")));
+
+    REQUIRE_THAT(puml, IsPackage("D"));
+    REQUIRE_THAT(puml, IsPackage("E"));
+    REQUIRE_THAT(puml, IsPackage("F"));
+    REQUIRE_THAT(puml, !IsPackage("Y"));
+
+    REQUIRE_THAT(puml, IsDependency(_A("E"), _A("D")));
+    REQUIRE_THAT(puml, IsDependency(_A("F"), _A("E")));
+
+    save_puml(
+        "./" + config.output_directory() + "/" + diagram->name + ".puml", puml);
+}

tests/test_cases.cc

@@ -242,6 +242,7 @@ using namespace clanguml::test::matchers;
 #include "t30005/test_case.h"
 #include "t30006/test_case.h"
 #include "t30007/test_case.h"
+#include "t30008/test_case.h"
 
 //
 // Include diagram tests

tests/test_cases.yaml

@@ -124,7 +124,7 @@ test_cases:
       title: Specialization class template diagram filter test
       description:
     - name: t00043
-      title: Dependants and dependencies diagram filter test
+      title: Dependants and dependencies class diagram filter test
       description:
   Sequence diagrams:
     - name: t20001
@@ -155,6 +155,9 @@ test_cases:
     - name: t30007
       title: Package diagram layout hints test case
       description:
+    - name: t30008
+      title: Dependants and dependencies package diagram filter test
+      description:
   Include diagrams:
     - name: t40001
       title: Basic include graph diagram test case

tests/test_config.cc

@@ -28,7 +28,7 @@ TEST_CASE("Test config simple", "[unit-test]")
 
     CHECK(cfg.diagrams.size() == 1);
     auto &diagram = *cfg.diagrams["class_main"];
-    CHECK(diagram.type() == clanguml::config::diagram_type::class_diagram);
+    CHECK(diagram.type() == clanguml::common::model::diagram_t::kClass);
     CHECK(diagram.glob().size() == 2);
     CHECK(clanguml::util::contains(diagram.using_namespace(), "clanguml"));
     CHECK(diagram.generate_method_arguments() ==
@@ -47,7 +47,7 @@ TEST_CASE("Test config inherited", "[unit-test]")
 
     CHECK(cfg.diagrams.size() == 2);
     auto &def = *cfg.diagrams["class_default"];
-    CHECK(def.type() == clanguml::config::diagram_type::class_diagram);
+    CHECK(def.type() == clanguml::common::model::diagram_t::kClass);
     CHECK(def.glob().size() == 2);
     CHECK(def.glob()[0] == "src/**/*.cc");
     CHECK(def.glob()[1] == "src/**/*.h");
@@ -56,7 +56,7 @@ TEST_CASE("Test config inherited", "[unit-test]")
     CHECK(def.generate_links == false);
 
     auto &cus = *cfg.diagrams["class_custom"];
-    CHECK(cus.type() == clanguml::config::diagram_type::class_diagram);
+    CHECK(cus.type() == clanguml::common::model::diagram_t::kClass);
     CHECK(cus.glob().size() == 1);
     CHECK(cus.glob()[0] == "src/main.cc");
     CHECK(cus.using_namespace().starts_with({"clanguml::ns1"}));
@@ -71,7 +71,7 @@ TEST_CASE("Test config includes", "[unit-test]")
 
     CHECK(cfg.diagrams.size() == 2);
     auto &def = *cfg.diagrams["class_1"];
-    CHECK(def.type() == clanguml::config::diagram_type::class_diagram);
+    CHECK(def.type() == clanguml::common::model::diagram_t::kClass);
     CHECK(def.glob().size() == 2);
     CHECK(def.glob()[0] == "src/**/*.cc");
     CHECK(def.glob()[1] == "src/**/*.h");
@@ -80,7 +80,7 @@ TEST_CASE("Test config includes", "[unit-test]")
         clanguml::config::method_arguments::none);
 
     auto &cus = *cfg.diagrams["class_2"];
-    CHECK(cus.type() == clanguml::config::diagram_type::class_diagram);
+    CHECK(cus.type() == clanguml::common::model::diagram_t::kClass);
     CHECK(cus.glob().size() == 1);
     CHECK(cus.glob()[0] == "src/main.cc");
     CHECK(cus.using_namespace().starts_with({"clanguml::ns1"}));
@@ -99,7 +99,7 @@ TEST_CASE("Test config layout", "[unit-test]")
         *cfg.diagrams["class_main"]);
 
     auto check_layout = [](const auto &diagram,
-                            const clanguml::config::diagram_type type) {
+                            const clanguml::common::model::diagram_t type) {
         CHECK(diagram.type() == type);
 
         CHECK(diagram.layout().at("ABCD").size() == 2);
@@ -123,9 +123,9 @@ TEST_CASE("Test config layout", "[unit-test]")
 
     check_layout(static_cast<clanguml::config::class_diagram &>(
                      *cfg.diagrams["class_main"]),
-        clanguml::config::diagram_type::class_diagram);
+        clanguml::common::model::diagram_t::kClass);
 
     check_layout(static_cast<clanguml::config::package_diagram &>(
                      *cfg.diagrams["package_main"]),
-        clanguml::config::diagram_type::package_diagram);
+        clanguml::common::model::diagram_t::kPackage);
 }