Refactored package_diagram generator to common base class template

src/class_diagram/generators/plantuml/class_diagram_generator.cc

@@ -22,8 +22,7 @@
 
 namespace clanguml::class_diagram::generators::plantuml {
 
-generator::generator(
-    clanguml::config::class_diagram &config, diagram_model &model)
+generator::generator(diagram_config &config, diagram_model &model)
     : common_generator<diagram_config, diagram_model>{config, model}
 {
 }
@@ -312,12 +311,6 @@ void generator::generate(std::ostream &ostr) const
     ostr << "@enduml" << '\n';
 }
 
-std::ostream &operator<<(std::ostream &os, const generator &g)
-{
-    g.generate(os);
-    return os;
-}
-
 clanguml::class_diagram::model::diagram generate(
     cppast::libclang_compilation_database &db, const std::string &name,
     clanguml::config::class_diagram &diagram)

src/class_diagram/generators/plantuml/class_diagram_generator.h

@@ -67,8 +67,6 @@ public:
     void generate(const enum_ &e, std::ostream &ostr) const;
 
     void generate(std::ostream &ostr) const override;
-
-    friend std::ostream &operator<<(std::ostream &os, const generator &g);
 };
 
 clanguml::class_diagram::model::diagram generate(

src/common/generators/plantuml/generator.h

@@ -45,6 +45,9 @@ public:
 
     virtual void generate(std::ostream &ostr) const = 0;
 
+    template <typename C, typename D>
+    friend std::ostream &operator<<(std::ostream &os, const generator<C, D> &g);
+
     void generate_config_layout_hints(std::ostream &ostr) const;
 
     void generate_plantuml_directives(
@@ -58,6 +61,13 @@ protected:
     DiagramType &m_model;
 };
 
+template <typename C, typename D>
+std::ostream &operator<<(std::ostream &os, const generator<C, D> &g)
+{
+    g.generate(os);
+    return os;
+}
+
 template <typename C, typename D>
 void generator<C, D>::generate_config_layout_hints(std::ostream &ostr) const
 {

src/package_diagram/generators/plantuml/package_diagram_generator.cc

@@ -22,61 +22,9 @@
 
 namespace clanguml::package_diagram::generators::plantuml {
 
-std::string relative_to(std::string n, std::string c)
+generator::generator(diagram_config &config, diagram_model &model)
+    : common_generator<diagram_config, diagram_model>{config, model}
 {
-    if (c.rfind(n) == std::string::npos)
-        return c;
-
-    return c.substr(n.size() + 2);
-}
-
-generator::generator(
-    clanguml::config::package_diagram &config, diagram_model &model)
-    : m_config(config)
-    , m_model(model)
-{
-}
-
-std::string generator::to_string(relationship_t r, std::string style) const
-{
-    switch (r) {
-    case relationship_t::kOwnership:
-    case relationship_t::kComposition:
-        return style.empty() ? "*--" : fmt::format("*-[{}]-", style);
-    case relationship_t::kAggregation:
-        return style.empty() ? "o--" : fmt::format("o-[{}]-", style);
-    case relationship_t::kContainment:
-        return style.empty() ? "--+" : fmt::format("-[{}]-+", style);
-    case relationship_t::kAssociation:
-        return style.empty() ? "-->" : fmt::format("-[{}]->", style);
-    case relationship_t::kInstantiation:
-        return style.empty() ? "..|>" : fmt::format(".[{}].|>", style);
-    case relationship_t::kFriendship:
-        return style.empty() ? "<.." : fmt::format("<.[{}].", style);
-    case relationship_t::kDependency:
-        return style.empty() ? "..>" : fmt::format(".[{}].>", style);
-    default:
-        return "";
-    }
-}
-
-std::string generator::name(relationship_t r) const
-{
-    switch (r) {
-    case relationship_t::kOwnership:
-    case relationship_t::kComposition:
-        return "composition";
-    case relationship_t::kAggregation:
-        return "aggregation";
-    case relationship_t::kContainment:
-        return "containment";
-    case relationship_t::kAssociation:
-        return "association";
-    case relationship_t::kDependency:
-        return "dependency";
-    default:
-        return "unknown";
-    }
 }
 
 void generator::generate_relationships(
@@ -109,31 +57,6 @@ void generator::generate_relationships(
     }
 }
 
-void generator::generate_config_layout_hints(std::ostream &ostr) const
-{
-    const auto &uns = m_config.using_namespace();
-
-    // Generate layout hints
-    for (const auto &[entity, hints] : m_config.layout()) {
-        for (const auto &hint : hints) {
-            std::stringstream hint_str;
-            try {
-                hint_str << m_model.to_alias(ns_relative(uns, entity))
-                         << " -[hidden]"
-                         << clanguml::config::to_string(hint.hint) << "- "
-                         << m_model.to_alias(ns_relative(uns, hint.entity))
-                         << '\n';
-                ostr << hint_str.str();
-            }
-            catch (error::uml_alias_missing &e) {
-                LOG_ERROR("=== Skipping layout hint from {} to {} due "
-                          "to: {}",
-                    entity, hint.entity, e.what());
-            }
-        }
-    }
-}
-
 void generator::generate(const package &p, std::ostream &ostr) const
 {
     const auto &uns = m_config.using_namespace();
@@ -157,35 +80,14 @@ void generator::generate(const package &p, std::ostream &ostr) const
 
     ostr << "}" << '\n';
 
-    //
-    // Process notes
-    //
-    for (auto decorator : p.decorators()) {
-        auto note = std::dynamic_pointer_cast<decorators::note>(decorator);
-        if (note && note->applies_to_diagram(m_config.name)) {
-            ostr << "note " << note->position << " of " << p.alias() << '\n'
-                 << note->text << '\n'
-                 << "end note\n";
-        }
-    }
+    generate_notes(ostr, p);
 }
 
 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) {
-        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)));
-            note.replace(
-                std::get<1>(alias_match), std::get<2>(alias_match), alias);
-        }
-        ostr << note << '\n';
-    }
+    generate_plantuml_directives(ostr, m_config.puml().before);
 
     if (m_config.should_include_entities("packages")) {
         for (const auto &p : m_model) {
@@ -202,28 +104,11 @@ void generator::generate(std::ostream &ostr) const
 
     generate_config_layout_hints(ostr);
 
-    // Process aliases in any of the puml directives
-    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)));
-            note.replace(
-                std::get<1>(alias_match), std::get<2>(alias_match), alias);
-        }
-        ostr << note << '\n';
-    }
+    generate_plantuml_directives(ostr, m_config.puml().after);
 
     ostr << "@enduml" << '\n';
 }
 
-std::ostream &operator<<(std::ostream &os, const generator &g)
-{
-    g.generate(os);
-    return os;
-}
-
 clanguml::package_diagram::model::diagram generate(
     cppast::libclang_compilation_database &db, const std::string &name,
     clanguml::config::package_diagram &diagram)

src/package_diagram/generators/plantuml/package_diagram_generator.h

@@ -17,6 +17,7 @@
  */
 #pragma once
 
+#include "common/generators/plantuml/generator.h"
 #include "common/model/relationship.h"
 #include "config/config.h"
 #include "cx/compilation_database.h"
@@ -39,38 +40,29 @@ namespace package_diagram {
 namespace generators {
 namespace plantuml {
 
-using diagram_config = clanguml::package_diagram::model::diagram;
+using diagram_config = clanguml::config::package_diagram;
 using diagram_model = clanguml::package_diagram::model::diagram;
+
+template <typename C, typename D>
+using common_generator =
+    clanguml::common::generators::plantuml::generator<C, D>;
+
 using clanguml::common::model::relationship_t;
 using clanguml::common::model::scope_t;
 using clanguml::package_diagram::model::package;
 using namespace clanguml::util;
 
-std::string relative_to(std::string n, std::string c);
-
-class generator {
+class generator : public common_generator<diagram_config, diagram_model> {
 public:
-    generator(clanguml::config::package_diagram &config, diagram_model &model);
-
-    std::string to_string(relationship_t r, std::string style = "") const;
-
-    std::string name(relationship_t r) const;
+    generator(diagram_config &config, diagram_model &model);
 
     void generate_alias(const package &c, std::ostream &ostr) const;
 
     void generate_relationships(const package &p, std::ostream &ostr) const;
 
-    void generate_config_layout_hints(std::ostream &ostr) const;
-
     void generate(const package &e, std::ostream &ostr) const;
 
     void generate(std::ostream &ostr) const;
-
-    friend std::ostream &operator<<(std::ostream &os, const generator &g);
-
-private:
-    clanguml::config::package_diagram &m_config;
-    diagram_model &m_model;
 };
 
 clanguml::package_diagram::model::diagram generate(