0.6.1
C++ to UML diagram generator based on Clang
Loading...
Searching...
No Matches
yaml_decoders.cc
Go to the documentation of this file.
1/**
2 * @file src/config/yaml_decoders.cc
3 *
4 * Copyright (c) 2021-2025 Bartek Kryza <bkryza@gmail.com>
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19#include "config.h"
20#include "diagram_templates.h"
21#include "schema.h"
22#include "util/error.h"
23
24#define MIROIR_IMPLEMENTATION
25#define MIROIR_YAMLCPP_SPECIALIZATION
26#include <miroir/miroir.hpp>
27
28namespace clanguml::error {
29
30std::string to_string(miroir::ErrorType et)
31{
32 switch (et) {
33 case miroir::ErrorType::NodeNotFound:
34 return "NodeNotFound";
35 case miroir::ErrorType::InvalidValueType:
36 return "InvalidValueType";
37 case miroir::ErrorType::InvalidValue:
38 return "InvalidValue";
39 case miroir::ErrorType::MissingKeyWithType:
40 return "MissingKeyWithType";
41 case miroir::ErrorType::UndefinedNode:
42 return "UndefinedNode";
43 default:
44 return "";
45 }
46}
47
48void print(std::ostream &ostr, const config_schema_error &e,
49 logging::logger_type_t logger_type)
50{
51 if (logger_type == logging::logger_type_t::text) {
52 ostr << "ERROR: Invalid schema:\n";
53 for (const auto &schema_error : e.errors) {
54 std::cout << " - " << schema_error.description() << '\n';
55 }
56 }
57 else {
58 inja::json j;
59 j["valid"] = false;
60 j["errors"] = inja::json::array();
61 for (const auto &schema_error : e.errors) {
62 inja::json je;
63 je["path"] = schema_error.path;
64 je["error_type"] = to_string(schema_error.type);
65 je["description"] = schema_error.description();
66 j["errors"].emplace_back(std::move(je));
67 }
68 ostr << j.dump();
69 }
70}
71} // namespace clanguml::error
72
73namespace YAML {
74using clanguml::common::namespace_or_regex;
75using clanguml::common::string_or_regex;
76using clanguml::common::model::access_t;
77using clanguml::common::model::module_access_t;
78using clanguml::common::model::relationship_t;
79using clanguml::config::callee_type;
80using clanguml::config::class_diagram;
81using clanguml::config::config;
82using clanguml::config::context_config;
83using clanguml::config::context_direction_t;
84using clanguml::config::diagram_template;
85using clanguml::config::element_filter_t;
86using clanguml::config::filter;
87using clanguml::config::generate_links_config;
88using clanguml::config::git_config;
89using clanguml::config::glob_t;
90using clanguml::config::graphml;
91using clanguml::config::hint_t;
92using clanguml::config::include_diagram;
93using clanguml::config::layout_hint;
94using clanguml::config::location_t;
95using clanguml::config::member_order_t;
96using clanguml::config::mermaid;
97using clanguml::config::method_arguments;
98using clanguml::config::method_type;
99using clanguml::config::package_diagram;
100using clanguml::config::package_type_t;
101using clanguml::config::plantuml;
102using clanguml::config::relationship_hint_t;
103using clanguml::config::sequence_diagram;
104using clanguml::config::source_location;
105
106inline bool has_key(const YAML::Node &n, const std::string &key)
107{
108 assert(n.Type() == NodeType::Map);
109
110 return std::count_if(n.begin(), n.end(), [&key](auto &&n) {
111 return n.first.template as<std::string>() == key;
112 }) > 0;
113}
114
115template <typename T>
116void get_option(const Node &node, clanguml::config::option<T> &option)
117{
118 if (node[option.name])
119 option.set(node[option.name].template as<T>());
120
121 for (const auto &alt_name : option.alternate_names)
122 if (node[alt_name]) {
123 option.set(node[alt_name].template as<T>());
124 break;
125 }
126}
127
128template <typename T>
129void get_option(
130 const Node &node, clanguml::config::option<T> &option, T default_override)
131{
132 get_option(node, option);
133
134 if (!option.is_declared)
135 option.set(default_override);
136}
137
138template <>
139void get_option<clanguml::common::model::namespace_>(const Node &node,
140 clanguml::config::option<clanguml::common::model::namespace_> &option)
141{
142 if (node[option.name]) {
143 if (node[option.name].Type() == NodeType::Scalar)
144 option.set({node[option.name].template as<std::string>()});
145 else if (node[option.name].Type() == NodeType::Sequence)
146 option.set(
147 {node[option.name].template as<std::vector<std::string>>()[0]});
148 else
149 throw std::runtime_error("Invalid using_namespace value");
150 }
151}
152
153template <>
154void get_option<method_arguments>(
155 const Node &node, clanguml::config::option<method_arguments> &option)
156{
157 if (node[option.name]) {
158 const auto &val = node[option.name].as<std::string>();
159 if (val == "full")
160 option.set(method_arguments::full);
161 else if (val == "abbreviated")
162 option.set(method_arguments::abbreviated);
163 else if (val == "none")
164 option.set(method_arguments::none);
165 else
166 throw std::runtime_error(
167 "Invalid generate_method_arguments value: " + val);
168 }
169}
170
171template <>
172void get_option<member_order_t>(
173 const Node &node, clanguml::config::option<member_order_t> &option)
174{
175 if (node[option.name]) {
176 const auto &val = node[option.name].as<std::string>();
177 if (val == "as_is")
178 option.set(member_order_t::as_is);
179 else if (val == "lexical")
180 option.set(member_order_t::lexical);
181 else
182 throw std::runtime_error("Invalid member_order value: " + val);
183 }
184}
185
186template <>
187void get_option<package_type_t>(
188 const Node &node, clanguml::config::option<package_type_t> &option)
189{
190 if (node[option.name]) {
191 const auto &val = node[option.name].as<std::string>();
192 if (val == "namespace")
193 option.set(package_type_t::kNamespace);
194 else if (val == "directory")
195 option.set(package_type_t::kDirectory);
196 else if (val == "module")
197 option.set(package_type_t::kModule);
198 else
199 throw std::runtime_error(
200 "Invalid generate_method_arguments value: " + val);
201 }
202}
203
204template <>
205void get_option<clanguml::config::comment_parser_t>(const Node &node,
206 clanguml::config::option<clanguml::config::comment_parser_t> &option)
207{
208 if (node[option.name]) {
209 const auto &val = node[option.name].as<std::string>();
210 if (val == "plain")
211 option.set(clanguml::config::comment_parser_t::plain);
212 else if (val == "clang")
213 option.set(clanguml::config::comment_parser_t::clang);
214 else
215 throw std::runtime_error("Invalid comment_parser value: " + val);
216 }
217}
218
219template <>
220void get_option<clanguml::config::filter_mode_t>(const Node &node,
221 clanguml::config::option<clanguml::config::filter_mode_t> &option)
222{
223 if (node[option.name]) {
224 const auto &val = node[option.name].as<std::string>();
225 if (val == "basic")
226 option.set(clanguml::config::filter_mode_t::basic);
227 else if (val == "advanced")
228 option.set(clanguml::config::filter_mode_t::advanced);
229 else
230 throw std::runtime_error("Invalid comment_parser value: " + val);
231 }
232}
233
234template <>
235void get_option<std::map<std::string, clanguml::config::diagram_template>>(
236 const Node &node,
237 clanguml::config::option<
238 std::map<std::string, clanguml::config::diagram_template>> &option)
239{
240 if (!node[option.name]) {
241 return;
242 }
243
244 if (node[option.name].IsMap() && node[option.name]["include!"]) {
245 auto parent_path = node["__parent_path"].as<std::string>();
246
247 // Load templates from file
248 auto include_path = std::filesystem::path{parent_path};
249 include_path /= node[option.name]["include!"].as<std::string>();
250
251 YAML::Node included_node = YAML::LoadFile(include_path.string());
252
253 option.set(
254 included_node.as<
255 std::map<std::string, clanguml::config::diagram_template>>());
256 }
257 else
258 option.set(node[option.name]
259 .as<std::map<std::string,
260 clanguml::config::diagram_template>>());
261}
262
263std::shared_ptr<clanguml::config::diagram> parse_diagram_config(const Node &d)
264{
265 const auto diagram_type = d["type"].as<std::string>();
266
267 if (diagram_type == "class") {
268 return std::make_shared<class_diagram>(d.as<class_diagram>());
269 }
270 if (diagram_type == "sequence") {
271 return std::make_shared<sequence_diagram>(d.as<sequence_diagram>());
272 }
273 if (diagram_type == "package") {
274 return std::make_shared<package_diagram>(d.as<package_diagram>());
275 }
276 if (diagram_type == "include") {
277 return std::make_shared<include_diagram>(d.as<include_diagram>());
278 }
279
280 LOG_ERROR("Diagrams of type {} are not supported... ", diagram_type);
281
282 return {};
283}
284
285//
286// config std::filesystem::path decoder
287//
288template <> struct convert<std::filesystem::path> {
289 static bool decode(const Node &node, std::filesystem::path &rhs)
290 {
291 if (!node.IsScalar())
292 return false;
293
294 rhs = std::filesystem::path{node.as<std::string>()};
295
296 return true;
297 }
298};
299
300//
301// config access_t decoder
302//
303template <> struct convert<access_t> {
304 static bool decode(const Node &node, access_t &rhs)
305 {
306 if (node.as<std::string>() == "public")
307 rhs = access_t::kPublic;
308 else if (node.as<std::string>() == "protected")
309 rhs = access_t::kProtected;
310 else if (node.as<std::string>() == "private")
311 rhs = access_t::kPrivate;
312 else
313 return false;
314
315 return true;
316 }
317};
318
319//
320// config module_access_t decoder
321//
322template <> struct convert<module_access_t> {
323 static bool decode(const Node &node, module_access_t &rhs)
324 {
325 if (node.as<std::string>() == "public")
326 rhs = module_access_t::kPublic;
327 else if (node.as<std::string>() == "private")
328 rhs = module_access_t::kPrivate;
329 else
330 return false;
331
332 return true;
333 }
334};
335
336//
337// config context_direction_t decoder
338//
339template <> struct convert<context_direction_t> {
340 static bool decode(const Node &node, context_direction_t &rhs)
341 {
342 if (node.as<std::string>() == "inward")
343 rhs = context_direction_t::inward;
344 else if (node.as<std::string>() == "outward")
345 rhs = context_direction_t::outward;
346 else if (node.as<std::string>() == "any")
347 rhs = context_direction_t::any;
348 else
349 return false;
350
351 return true;
352 }
353};
354
355//
356// config method_type decoder
357//
358template <> struct convert<method_type> {
359 static bool decode(const Node &node, method_type &rhs)
360 {
361 const auto &val = node.as<std::string>();
362 if (val == to_string(method_type::constructor))
363 rhs = method_type::constructor;
364 else if (val == to_string(method_type::destructor))
365 rhs = method_type::destructor;
366 else if (val == to_string(method_type::assignment))
367 rhs = method_type::assignment;
368 else if (val == to_string(method_type::operator_))
369 rhs = method_type::operator_;
370 else if (val == to_string(method_type::defaulted))
371 rhs = method_type::defaulted;
372 else if (val == to_string(method_type::deleted))
373 rhs = method_type::deleted;
374 else if (val == to_string(method_type::static_))
375 rhs = method_type::static_;
376 else
377 return false;
378
379 return true;
380 }
381};
382
383//
384// config callee_type decoder
385//
386template <> struct convert<callee_type> {
387 static bool decode(const Node &node, callee_type &rhs)
388 {
389 const auto &val = node.as<std::string>();
390 if (val == to_string(callee_type::constructor))
391 rhs = callee_type::constructor;
392 else if (val == to_string(callee_type::assignment))
393 rhs = callee_type::assignment;
394 else if (val == to_string(callee_type::operator_))
395 rhs = callee_type::operator_;
396 else if (val == to_string(callee_type::defaulted))
397 rhs = callee_type::defaulted;
398 else if (val == to_string(callee_type::static_))
399 rhs = callee_type::static_;
400 else if (val == to_string(callee_type::function))
401 rhs = callee_type::function;
402 else if (val == to_string(callee_type::function_template))
403 rhs = callee_type::function_template;
404 else if (val == to_string(callee_type::method))
405 rhs = callee_type::method;
406 else if (val == to_string(callee_type::lambda))
407 rhs = callee_type::lambda;
408 else if (val == to_string(callee_type::cuda_kernel))
409 rhs = callee_type::cuda_kernel;
410 else if (val == to_string(callee_type::cuda_device))
411 rhs = callee_type::cuda_device;
412 else
413 return false;
414
415 return true;
416 }
417};
418
419//
420// config relationship_t decoder
421//
422template <> struct convert<relationship_t> {
423 static bool decode(const Node &node, relationship_t &rhs)
424 {
425 assert(node.Type() == NodeType::Scalar);
426
427 auto relationship_name = node.as<std::string>();
428 if (relationship_name == "extension" ||
429 relationship_name == "inheritance") {
430 rhs = relationship_t::kExtension;
431 }
432 else if (relationship_name == "composition") {
433 rhs = relationship_t::kComposition;
434 }
435 else if (relationship_name == "aggregation") {
436 rhs = relationship_t::kAggregation;
437 }
438 else if (relationship_name == "containment") {
439 rhs = relationship_t::kContainment;
440 }
441 else if (relationship_name == "ownership") {
442 rhs = relationship_t::kOwnership;
443 }
444 else if (relationship_name == "association") {
445 rhs = relationship_t::kAssociation;
446 }
447 else if (relationship_name == "instantiation") {
448 rhs = relationship_t::kInstantiation;
449 }
450 else if (relationship_name == "friendship") {
451 rhs = relationship_t::kFriendship;
452 }
453 else if (relationship_name == "dependency") {
454 rhs = relationship_t::kDependency;
455 }
456 else if (relationship_name == "none") {
457 rhs = relationship_t::kNone;
458 }
459 else
460 return false;
461
462 return true;
463 }
464};
465
466template <> struct convert<std::vector<source_location>> {
467 static bool decode(const Node &node, std::vector<source_location> &rhs)
468 {
469 for (auto it = node.begin(); it != node.end(); ++it) {
470 const YAML::Node &n = *it;
471 if (n["marker"]) {
472 source_location loc;
473 loc.location_type = location_t::marker;
474 loc.location = n["marker"].as<std::string>();
475 rhs.emplace_back(std::move(loc));
476 }
477 else if (n["file"] && n["line"]) {
478 source_location loc;
479 loc.location_type = location_t::fileline;
480 loc.location = n["file"].as<std::string>() + ":" +
481 n["line"].as<std::string>();
482 rhs.emplace_back(std::move(loc));
483 }
484 else if (n["function"]) {
485 source_location loc;
486 loc.location_type = location_t::function;
487 loc.location = n["function"].as<decltype(loc.location)>();
488 rhs.emplace_back(std::move(loc));
489 }
490 else {
491 return false;
492 }
493 }
494
495 return true;
496 }
497};
498
499template <> struct convert<plantuml> {
500 static bool decode(const Node &node, plantuml &rhs)
501 {
502 if (node["before"])
503 rhs.before = node["before"].as<decltype(rhs.before)>();
504
505 if (node["after"])
506 rhs.after = node["after"].as<decltype(rhs.after)>();
507
508 if (node["cmd"])
509 rhs.cmd = node["cmd"].as<decltype(rhs.cmd)>();
510
511 if (node["style"])
512 rhs.style = node["style"].as<decltype(rhs.style)>();
513
514 return true;
515 }
516};
517
518template <> struct convert<mermaid> {
519 static bool decode(const Node &node, mermaid &rhs)
520 {
521 if (node["before"])
522 rhs.before = node["before"].as<decltype(rhs.before)>();
523
524 if (node["after"])
525 rhs.after = node["after"].as<decltype(rhs.after)>();
526
527 if (node["cmd"])
528 rhs.cmd = node["cmd"].as<decltype(rhs.cmd)>();
529
530 return true;
531 }
532};
533
534template <> struct convert<graphml> {
535 static bool decode(const Node &node, graphml &rhs)
536 {
537 if (node["notes"])
538 rhs.notes = node["notes"].as<decltype(rhs.notes)>();
539
540 return true;
541 }
542};
543
544template <> struct convert<string_or_regex> {
545 static bool decode(const Node &node, string_or_regex &rhs)
546 {
547 using namespace std::string_literals;
548 if (node.IsMap()) {
549 auto pattern = node["r"].as<std::string>();
550 auto rx = std::regex(pattern);
551 rhs = string_or_regex{std::move(rx), std::move(pattern)};
552 }
553 else {
554 rhs = string_or_regex{node.as<std::string>()};
555 }
556
557 return true;
558 }
559};
560
561template <> struct convert<context_config> {
562 static bool decode(const Node &node, context_config &rhs)
563 {
564 using namespace std::string_literals;
565 if (node.IsMap() && has_key(node, "match")) {
566 const auto &match = node["match"];
567 rhs.radius = match["radius"].as<unsigned>();
568 rhs.pattern = match["pattern"].as<string_or_regex>();
569 if (has_key(match, "direction"))
570 rhs.direction = match["direction"].as<context_direction_t>();
571 if (has_key(match, "relationships"))
572 rhs.relationships =
573 match["relationships"].as<std::vector<relationship_t>>();
574 }
575 else {
576 rhs.radius = 1;
577 rhs.pattern = node.as<string_or_regex>();
578 }
579
580 return true;
581 }
582};
583
584template <> struct convert<namespace_or_regex> {
585 static bool decode(const Node &node, namespace_or_regex &rhs)
586 {
587 using namespace std::string_literals;
588 if (node.IsMap()) {
589 auto pattern = node["r"].as<std::string>();
590 auto rx = std::regex(pattern);
591 rhs = namespace_or_regex{std::move(rx), std::move(pattern)};
592 }
593 else {
594 rhs = namespace_or_regex{node.as<std::string>()};
595 }
596
597 return true;
598 }
599};
600
601template <> struct convert<element_filter_t> {
602 static bool decode(const Node &node, element_filter_t &rhs)
603 {
604 using namespace std::string_literals;
605 if (node.IsMap()) {
606 if (has_key(node, "r")) {
607 rhs.type = element_filter_t::filtered_type::any;
608 auto pattern = node["r"].as<std::string>();
609 auto rx = std::regex(pattern);
610 rhs.name = string_or_regex(std::move(rx), std::move(pattern));
611 }
612 else if (has_key(node, "type")) {
613 rhs.type = element_filter_t::filtered_type::any;
614 if (node["type"].as<std::string>() == "class")
615 rhs.type = element_filter_t::filtered_type::class_;
616 else if (node["type"].as<std::string>() == "enum")
617 rhs.type = element_filter_t::filtered_type::enum_;
618 else if (node["type"].as<std::string>() == "function")
619 rhs.type = element_filter_t::filtered_type::function;
620 else if (node["type"].as<std::string>() == "method")
621 rhs.type = element_filter_t::filtered_type::method;
622 else if (node["type"].as<std::string>() == "member")
623 rhs.type = element_filter_t::filtered_type::member;
624 else if (node["type"].as<std::string>() == "concept")
625 rhs.type = element_filter_t::filtered_type::concept_;
626 else if (node["type"].as<std::string>() == "package")
627 rhs.type = element_filter_t::filtered_type::package;
628 else if (node["type"].as<std::string>() == "function_template")
629 rhs.type =
630 element_filter_t::filtered_type::function_template;
631 else if (node["type"].as<std::string>() == "objc_method")
632 rhs.type = element_filter_t::filtered_type::objc_method;
633 else if (node["type"].as<std::string>() == "objc_member")
634 rhs.type = element_filter_t::filtered_type::objc_member;
635 else if (node["type"].as<std::string>() == "objc_protocol")
636 rhs.type = element_filter_t::filtered_type::objc_protocol;
637 else if (node["type"].as<std::string>() == "objc_category")
638 rhs.type = element_filter_t::filtered_type::objc_category;
639 else if (node["type"].as<std::string>() == "objc_interface")
640 rhs.type = element_filter_t::filtered_type::objc_interface;
641 auto name = node["name"];
642 if (name.IsMap() && has_key(name, "r")) {
643 auto pattern = name["r"].as<std::string>();
644 auto rx = std::regex(pattern);
645 rhs.name =
646 string_or_regex(std::move(rx), std::move(pattern));
647 }
648 else
649 rhs.name = name.as<std::string>();
650 }
651 }
652 else {
653 rhs.type = element_filter_t::filtered_type::any;
654 rhs.name = string_or_regex{node.as<std::string>()};
655 }
656
657 return true;
658 }
659};
660
661//
662// filter Yaml decoder
663//
664template <> struct convert<filter> {
665 static bool decode(const Node &node, filter &rhs)
666 {
667 if (node["anyof"]) {
668 rhs.anyof = std::make_unique<filter>(node["anyof"].as<filter>());
669 }
670
671 if (node["allof"]) {
672 rhs.allof = std::make_unique<filter>(node["allof"].as<filter>());
673 }
674
675 if (node["namespaces"]) {
676 auto namespace_list =
677 node["namespaces"].as<decltype(rhs.namespaces)>();
678 for (const auto &ns : namespace_list)
679 rhs.namespaces.push_back({ns});
680 }
681
682 if (node["modules"]) {
683 auto module_list = node["modules"].as<decltype(rhs.modules)>();
684 for (const auto &ns : module_list)
685 rhs.modules.push_back({ns});
686 }
687
688 if (node["module_access"])
689 rhs.module_access =
690 node["module_access"].as<decltype(rhs.module_access)>();
691
692 if (node["relationships"])
693 rhs.relationships =
694 node["relationships"].as<decltype(rhs.relationships)>();
695
696 if (node["elements"])
697 rhs.elements = node["elements"].as<decltype(rhs.elements)>();
698
699 if (node["element_types"])
700 rhs.element_types =
701 node["element_types"].as<decltype(rhs.element_types)>();
702
703 if (node["method_types"])
704 rhs.method_types =
705 node["method_types"].as<decltype(rhs.method_types)>();
706
707 if (node["access"])
708 rhs.access = node["access"].as<decltype(rhs.access)>();
709
710 if (node["subclasses"])
711 rhs.subclasses = node["subclasses"].as<decltype(rhs.subclasses)>();
712
713 if (node["parents"])
714 rhs.parents = node["parents"].as<decltype(rhs.parents)>();
715
716 if (node["specializations"])
717 rhs.specializations =
718 node["specializations"].as<decltype(rhs.specializations)>();
719
720 if (node["dependants"])
721 rhs.dependants = node["dependants"].as<decltype(rhs.dependants)>();
722
723 if (node["dependencies"])
724 rhs.dependencies =
725 node["dependencies"].as<decltype(rhs.dependencies)>();
726
727 if (node["context"])
728 rhs.context = node["context"].as<decltype(rhs.context)>();
729
730 if (node["paths"])
731 rhs.paths = node["paths"].as<decltype(rhs.paths)>();
732
733 if (node["callee_types"])
734 rhs.callee_types =
735 node["callee_types"].as<decltype(rhs.callee_types)>();
736
737 return true;
738 }
739};
740
741//
742// generate_links_config Yaml decoder
743//
744template <> struct convert<generate_links_config> {
745 static bool decode(const Node &node, generate_links_config &rhs)
746 {
747 if (node["link"]) {
748 if (node["link"].IsMap())
749 rhs.link = node["link"].as<decltype(rhs.link)>();
750 else
751 rhs.link.emplace(".", node["link"].as<std::string>());
752 }
753
754 if (node["tooltip"]) {
755 if (node["tooltip"].IsMap())
756 rhs.tooltip = node["tooltip"].as<decltype(rhs.tooltip)>();
757 else
758 rhs.tooltip.emplace(".", node["tooltip"].as<std::string>());
759 }
760
761 return true;
762 }
763};
764
765//
766// git_config Yaml decoder
767//
768template <> struct convert<git_config> {
769 static bool decode(const Node &node, git_config &rhs)
770 {
771 if (node["branch"])
772 rhs.branch = node["branch"].as<decltype(rhs.branch)>();
773
774 if (node["revision"])
775 rhs.revision = node["revision"].as<decltype(rhs.revision)>();
776
777 if (node["commit"])
778 rhs.commit = node["commit"].as<decltype(rhs.commit)>();
779
780 if (node["toplevel"])
781 rhs.toplevel = node["toplevel"].as<decltype(rhs.toplevel)>();
782
783 return true;
784 }
785};
786
787template <typename T> bool decode_diagram(const Node &node, T &rhs)
788{
789 // Decode options common for all diagrams
790 get_option(node, rhs.glob);
791 get_option(node, rhs.using_namespace);
792 get_option(node, rhs.using_module);
793 get_option(node, rhs.filter_mode);
794 get_option(node, rhs.include_system_headers);
795 get_option(node, rhs.include);
796 get_option(node, rhs.exclude);
797 get_option(node, rhs.puml);
798 get_option(node, rhs.mermaid);
799 get_option(node, rhs.graphml);
800 get_option(node, rhs.git);
801 get_option(node, rhs.generate_links);
802 get_option(node, rhs.type_aliases);
803 get_option(node, rhs.comment_parser);
804 get_option(node, rhs.debug_mode);
805 get_option(node, rhs.generate_metadata);
806 get_option(node, rhs.title);
807 get_option(node, rhs.get_relative_to());
808 get_option(node, rhs.user_data);
809
810 return true;
811}
812
813//
814// class_diagram Yaml decoder
815//
816template <> struct convert<class_diagram> {
817 static bool decode(const Node &node, class_diagram &rhs)
818 {
819 if (!decode_diagram(node, rhs))
820 return false;
821
822 get_option(node, rhs.layout);
823 get_option(node, rhs.include_relations_also_as_members);
824 get_option(node, rhs.generate_method_arguments);
825 get_option(node, rhs.generate_concept_requirements);
826 get_option(node, rhs.group_methods);
827 get_option(node, rhs.member_order);
828 get_option(node, rhs.generate_packages);
829 get_option(node, rhs.package_type);
830 get_option(node, rhs.generate_template_argument_dependencies);
831 get_option(node, rhs.skip_redundant_dependencies);
832 get_option(node, rhs.relationship_hints);
833 get_option(node, rhs.type_aliases);
834
835 get_option(node, rhs.get_relative_to());
836
837 rhs.initialize_relationship_hints();
838 rhs.initialize_type_aliases();
839
840 return true;
841 }
842};
843
844//
845// sequence_diagram Yaml decoder
846//
847template <> struct convert<sequence_diagram> {
848 static bool decode(const Node &node, sequence_diagram &rhs)
849 {
850 if (!decode_diagram(node, rhs))
851 return false;
852
853 get_option(node, rhs.from);
854 get_option(node, rhs.from_to);
855 get_option(node, rhs.to);
856 get_option(node, rhs.combine_free_functions_into_file_participants);
857 get_option(node, rhs.inline_lambda_messages);
858 get_option(node, rhs.generate_return_types);
859 get_option(node, rhs.generate_return_values);
860 get_option(node, rhs.generate_condition_statements);
861 get_option(node, rhs.participants_order);
862 get_option(node, rhs.generate_method_arguments);
863 get_option(node, rhs.generate_message_comments);
864 get_option(node, rhs.fold_repeated_activities);
865 get_option(node, rhs.message_comment_width);
866 get_option(node, rhs.message_name_width);
867 get_option(node, rhs.type_aliases);
868
869 get_option(node, rhs.get_relative_to());
870
871 rhs.initialize_type_aliases();
872
873 return true;
874 }
875};
876
877//
878// package_diagram Yaml decoder
879//
880template <> struct convert<package_diagram> {
881 static bool decode(const Node &node, package_diagram &rhs)
882 {
883 if (!decode_diagram(node, rhs))
884 return false;
885
886 get_option(node, rhs.layout);
887 get_option(node, rhs.package_type);
888
889 get_option(node, rhs.get_relative_to());
890
891 return true;
892 }
893};
894
895//
896// include_diagram Yaml decoder
897//
898template <> struct convert<include_diagram> {
899 static bool decode(const Node &node, include_diagram &rhs)
900 {
901 if (!decode_diagram(node, rhs))
902 return false;
903
904 get_option(node, rhs.layout);
905 get_option(node, rhs.generate_system_headers);
906 get_option(node, rhs.generate_packages, true);
907
908 get_option(node, rhs.get_relative_to());
909
910 return true;
911 }
912};
913
914//
915// layout_hint Yaml decoder
916//
917template <> struct convert<glob_t> {
918 static bool decode(const Node &node, glob_t &rhs)
919 {
920 if (node.Type() == NodeType::Sequence) {
921 rhs.include = node.as<std::vector<string_or_regex>>();
922 return true;
923 }
924
925 if (node.Type() == NodeType::Map) {
926 if (has_key(node, "include"))
927 rhs.include =
928 node["include"].as<std::vector<string_or_regex>>();
929 if (has_key(node, "exclude"))
930 rhs.exclude =
931 node["exclude"].as<std::vector<string_or_regex>>();
932 return true;
933 }
934
935 return false;
936 }
937};
938
939//
940// layout_hint Yaml decoder
941//
942template <> struct convert<layout_hint> {
943 static bool decode(const Node &node, layout_hint &rhs)
944 {
945 assert(node.Type() == NodeType::Map);
946
947 if (node["up"]) {
948 rhs.hint = hint_t::up;
949 rhs.entity = node["up"].as<std::string>();
950 }
951 else if (node["down"]) {
952 rhs.hint = hint_t::down;
953 rhs.entity = node["down"].as<std::string>();
954 }
955 else if (node["left"]) {
956 rhs.hint = hint_t::left;
957 rhs.entity = node["left"].as<std::string>();
958 }
959 else if (node["right"]) {
960 rhs.hint = hint_t::right;
961 rhs.entity = node["right"].as<std::string>();
962 }
963 else if (node["together"]) {
964 rhs.hint = hint_t::together;
965 rhs.entity = node["together"].as<std::vector<std::string>>();
966 }
967 else if (node["row"]) {
968 rhs.hint = hint_t::row;
969 rhs.entity = node["row"].as<std::vector<std::string>>();
970 }
971 else if (node["column"]) {
972 rhs.hint = hint_t::column;
973 rhs.entity = node["column"].as<std::vector<std::string>>();
974 }
975 else
976 return false;
977
978 return true;
979 }
980};
981
982//
983// relationship_hint_t Yaml decoder
984//
985template <> struct convert<relationship_hint_t> {
986 static bool decode(const Node &node, relationship_hint_t &rhs)
987 {
988 assert(node.Type() == NodeType::Map || node.Type() == NodeType::Scalar);
989
990 if (node.Type() == NodeType::Scalar) {
991 // This will be default relationship hint for all arguments
992 // of this template (useful for instance for tuples)
993 rhs.default_hint = node.as<relationship_t>();
994 }
995 else {
996 for (const auto &it : node) {
997 auto key = it.first.as<std::string>();
998 if (key == "default") {
999 rhs.default_hint = node["default"].as<relationship_t>();
1000 }
1001 else {
1002 try {
1003 auto index = stoul(key);
1004 rhs.argument_hints[index] =
1005 it.second.as<relationship_t>();
1006 }
1007 catch (std::exception &e) {
1008 return false;
1009 }
1010 }
1011 }
1012 }
1013
1014 return true;
1015 }
1016};
1017
1018//
1019// diagram_template Yaml decoder
1020//
1021template <> struct convert<diagram_template> {
1022 static bool decode(const Node &node, diagram_template &rhs)
1023 {
1024 assert(node.Type() == NodeType::Map);
1025
1026 rhs.type = clanguml::common::model::from_string(
1027 node["type"].as<std::string>());
1028 rhs.jinja_template = node["template"].as<std::string>();
1029 rhs.description = node["description"].as<std::string>();
1030
1031 return true;
1032 }
1033};
1034
1035//
1036// config Yaml decoder
1037//
1038template <> struct convert<config> {
1039 static bool decode(const Node &node, config &rhs)
1040 {
1041 get_option(node, rhs.glob);
1042 get_option(node, rhs.using_namespace);
1043 get_option(node, rhs.using_module);
1044 get_option(node, rhs.filter_mode);
1045 get_option(node, rhs.output_directory);
1046 get_option(node, rhs.query_driver);
1047 get_option(node, rhs.allow_empty_diagrams);
1048 get_option(node, rhs.compilation_database_dir);
1049 get_option(node, rhs.add_compile_flags);
1050 get_option(node, rhs.remove_compile_flags);
1051 get_option(node, rhs.include_relations_also_as_members);
1052 get_option(node, rhs.puml);
1053 get_option(node, rhs.mermaid);
1054 get_option(node, rhs.graphml);
1055 get_option(node, rhs.generate_method_arguments);
1056 get_option(node, rhs.generate_concept_requirements);
1057 get_option(node, rhs.generate_packages);
1058 get_option(node, rhs.package_type);
1059 get_option(node, rhs.generate_template_argument_dependencies);
1060 get_option(node, rhs.skip_redundant_dependencies);
1061 get_option(node, rhs.generate_links);
1062 get_option(node, rhs.generate_system_headers);
1063 get_option(node, rhs.git);
1064 get_option(node, rhs.comment_parser);
1065 get_option(node, rhs.debug_mode);
1066 get_option(node, rhs.generate_metadata);
1067 get_option(node, rhs.combine_free_functions_into_file_participants);
1068 get_option(node, rhs.inline_lambda_messages);
1069 get_option(node, rhs.generate_return_types);
1070 get_option(node, rhs.generate_return_values);
1071 get_option(node, rhs.generate_condition_statements);
1072 get_option(node, rhs.generate_message_comments);
1073 get_option(node, rhs.fold_repeated_activities);
1074 get_option(node, rhs.message_comment_width);
1075 get_option(node, rhs.message_name_width);
1076 get_option(node, rhs.type_aliases);
1077 get_option(node, rhs.user_data);
1078
1079 rhs.base_directory.set(node["__parent_path"].as<std::string>());
1080 get_option(node, rhs.get_relative_to());
1081
1082 get_option(node, rhs.diagram_templates);
1083
1084 auto diagrams = node["diagrams"];
1085
1086 for (auto d : diagrams) {
1087 auto name = d.first.as<std::string>();
1088 std::shared_ptr<clanguml::config::diagram> diagram_config{};
1089 auto parent_path = node["__parent_path"].as<std::string>();
1090 d.second.force_insert("__parent_path", parent_path);
1091
1092 diagram_config = parse_diagram_config(d.second);
1093 if (diagram_config) {
1094 diagram_config->name = name;
1095 rhs.diagrams[name] = diagram_config;
1096 }
1097 else {
1098 return false;
1099 }
1100 }
1101
1102 return true;
1103 }
1104};
1105
1106template <> struct convert<inja::json> {
1107 static bool parse_scalar(const YAML::Node &node, inja::json &rhs)
1108 {
1109 int i{};
1110 double d{};
1111 bool b{};
1112 std::string s;
1113
1114 if (YAML::convert<int>::decode(node, i)) {
1115 rhs = i;
1116 return true;
1117 }
1118 if (YAML::convert<double>::decode(node, d)) {
1119 rhs = d;
1120 return true;
1121 }
1122 if (YAML::convert<bool>::decode(node, b)) {
1123 rhs = b;
1124 return true;
1125 }
1126 if (YAML::convert<std::string>::decode(node, s)) {
1127 rhs = s;
1128 return true;
1129 }
1130
1131 return false;
1132 }
1133
1134 static bool decode(const Node &node, inja::json &rhs)
1135 {
1136 switch (node.Type()) {
1137 case YAML::NodeType::Null:
1138 break;
1139 case YAML::NodeType::Scalar:
1140 parse_scalar(node, rhs);
1141 break;
1142 case YAML::NodeType::Sequence:
1143 for (auto &&array_element : node)
1144 rhs.emplace_back(array_element.as<inja::json>());
1145 break;
1146 case YAML::NodeType::Map:
1147 for (auto &&it : node)
1148 rhs[it.first.as<std::string>()] = it.second.as<inja::json>();
1149 break;
1150 default:
1151 break;
1152 }
1153 return true;
1154 }
1155};
1156} // namespace YAML
1157
1158namespace clanguml::config {
1159
1160void config::initialize_diagram_templates()
1161{
1162 const auto &predefined_templates_str = get_predefined_diagram_templates();
1163
1164 YAML::Node predefined_templates = YAML::Load(predefined_templates_str);
1165
1166 if (!diagram_templates) {
1167 diagram_templates.set({});
1168 }
1169
1170 diagram_templates().merge(
1171 predefined_templates.as<std::map<std::string, diagram_template>>());
1172}
1173
1174void config::inherit()
1175{
1176 for (auto &[name, diagram] : diagrams) {
1177 diagram->inherit(*this);
1178
1179 assert(diagram->get_relative_to().has_value);
1180 }
1181}
1182
1183namespace {
1184void resolve_option_path(YAML::Node &doc, const std::string &option_name)
1185{
1186 std::filesystem::path relative_to_path{
1187 doc["relative_to"].as<std::string>()};
1188
1189 relative_to_path = weakly_canonical(relative_to_path);
1190
1191 std::filesystem::path option_path{doc[option_name].as<std::string>()};
1192
1193 if (option_path.is_absolute())
1194 return;
1195
1196 option_path = relative_to_path / option_path;
1197 option_path = option_path.lexically_normal();
1198 option_path.make_preferred();
1199
1200 doc[option_name] = option_path.string();
1201}
1202} // namespace
1203
1204config load(const std::string &config_file, bool inherit,
1205 std::optional<bool> paths_relative_to_pwd, std::optional<bool> no_metadata,
1206 bool validate)
1207{
1208 try {
1209 auto schema = YAML::Load(clanguml::config::schema_str);
1210 auto schema_validator = miroir::Validator<YAML::Node>(schema);
1211
1212 YAML::Node doc;
1213 std::filesystem::path config_file_path{};
1214
1215 if (config_file == "-") {
1216 std::istreambuf_iterator<char> stdin_stream_begin{std::cin};
1217 std::istreambuf_iterator<char> stdin_stream_end{};
1218 std::string stdin_stream_str{stdin_stream_begin, stdin_stream_end};
1219
1220 doc = YAML::Load(stdin_stream_str);
1221 }
1222 else {
1223 doc = YAML::LoadFile(config_file);
1224 }
1225
1226 // Store the parent path of the config_file to properly resolve
1227 // relative paths in config file
1228 if (has_key(doc, "__parent_path"))
1229 doc.remove("__parent_path");
1230 if (config_file == "-") {
1231 config_file_path = std::filesystem::current_path();
1232 doc.force_insert("__parent_path", config_file_path.string());
1233 }
1234 else {
1235 config_file_path =
1236 canonical(absolute(std::filesystem::path{config_file}));
1237 doc.force_insert(
1238 "__parent_path", config_file_path.parent_path().string());
1239 }
1240
1241 LOG_DBG("Effective config file path is {}", config_file_path.string());
1242
1243 //
1244 // If no relative_to path is specified in the config, make all paths
1245 // resolvable against the parent directory of the .clang-uml config
1246 // file, or against the $PWD if it was specified so in the command
1247 // line
1248 //
1249 if (!doc["relative_to"]) {
1250 bool paths_relative_to_config_file = true;
1251
1252 if (doc["paths_relative_to_config_file"] &&
1253 !doc["paths_relative_to_config_file"].as<bool>())
1254 paths_relative_to_config_file = false;
1255
1256 if (paths_relative_to_pwd && *paths_relative_to_pwd)
1257 paths_relative_to_config_file = false;
1258
1259 if (paths_relative_to_config_file)
1260 doc["relative_to"] = config_file_path.parent_path().string();
1261 else
1262 doc["relative_to"] = std::filesystem::current_path().string();
1263 }
1264
1265 if (no_metadata.has_value()) {
1266 doc["generate_metadata"] = !no_metadata.value();
1267 }
1268
1269 //
1270 // Resolve common path-like config options relative to `relative_to`
1271 //
1272 if (!doc["output_directory"]) {
1273 doc["output_directory"] = ".";
1274 }
1275 resolve_option_path(doc, "output_directory");
1276
1277 if (!doc["compilation_database_dir"]) {
1278 doc["compilation_database_dir"] = ".";
1279 }
1280 resolve_option_path(doc, "compilation_database_dir");
1281
1282 // If the current directory is also a git repository,
1283 // load some config values, which can be included in the
1284 // generated diagrams
1285 if (util::is_git_repository() && !doc["git"]) {
1286 YAML::Node git_config{YAML::NodeType::Map};
1287 git_config["branch"] = util::get_git_branch();
1288 git_config["revision"] = util::get_git_revision();
1289 git_config["commit"] = util::get_git_commit();
1290 git_config["toplevel"] = util::get_git_toplevel_dir();
1291
1292 doc["git"] = git_config;
1293 }
1294
1295 if (has_key(doc, "diagrams")) {
1296 auto diagrams = doc["diagrams"];
1297
1298 assert(diagrams.Type() == YAML::NodeType::Map);
1299
1300 for (auto d : diagrams) {
1301 auto name = d.first.as<std::string>();
1302 std::shared_ptr<clanguml::config::diagram> diagram_config{};
1303 auto parent_path = doc["__parent_path"].as<std::string>();
1304
1305 if (has_key(d.second, "include!")) {
1306 auto include_path = std::filesystem::path{parent_path};
1307 include_path /= d.second["include!"].as<std::string>();
1308
1309 YAML::Node included_node =
1310 YAML::LoadFile(include_path.string());
1311
1312 diagrams[name] = included_node;
1313 }
1314 }
1315 }
1316
1317 if (validate) {
1318 auto schema_errors = schema_validator.validate(doc);
1319
1320 if (!schema_errors.empty()) {
1321 throw clanguml::error::config_schema_error(
1322 std::move(schema_errors));
1323 }
1324 }
1325
1326 auto d = doc.as<config>();
1327
1328 if (inherit)
1329 d.inherit();
1330
1331 d.initialize_diagram_templates();
1332
1333 return d;
1334 }
1335 catch (YAML::BadFile &e) {
1336 throw std::runtime_error(fmt::format(
1337 "Could not open config file {}: {}", config_file, e.what()));
1338 }
1339 catch (YAML::Exception &e) {
1340 throw std::runtime_error(
1341 fmt::format("Cannot parse YAML file {} at line {}: {}", config_file,
1342 e.mark.line, e.msg));
1343 }
1344}
1345} // namespace clanguml::config
  Copyright © 2022-present Bartek Kryza Generated by  doxygen 1.9.7