Added comments to YAML

Author: liuzicheng1987

include/rfl.hpp

@@ -16,6 +16,8 @@
 #include "rfl/Binary.hpp"
 #include "rfl/Box.hpp"
 #include "rfl/Bytestring.hpp"
+#include "rfl/CamelCaseToSnakeCase.hpp"
+#include "rfl/Commented.hpp"
 #include "rfl/DefaultIfMissing.hpp"
 #include "rfl/DefaultVal.hpp"
 #include "rfl/Description.hpp"
@@ -41,7 +43,6 @@
 #include "rfl/Skip.hpp"
 #include "rfl/SnakeCaseToCamelCase.hpp"
 #include "rfl/SnakeCaseToPascalCase.hpp"
-#include "rfl/CamelCaseToSnakeCase.hpp"
 #include "rfl/TaggedUnion.hpp"
 #include "rfl/Timestamp.hpp"
 #include "rfl/UnderlyingEnums.hpp"

include/rfl/Commented.hpp

@@ -6,6 +6,8 @@
 #include <type_traits>
 #include <utility>
 
+#include "default.hpp"
+
 namespace rfl {
 
 template <class T>

include/rfl/parsing/Parent.hpp

@@ -7,6 +7,7 @@
 #include "../always_false.hpp"
 #include "schemaful/IsSchemafulWriter.hpp"
 #include "supports_attributes.hpp"
+#include "supports_comments.hpp"
 
 namespace rfl::parsing {
 
@@ -71,6 +72,21 @@ struct Parent {
     }
   }
 
+  /// Adds a comment to the parent element, if supported by the writer.
+  template <class ParentType>
+  static void add_comment(const W& _w, std::string_view _comment,
+                          const ParentType& _parent) {
+    using Type = std::remove_cvref_t<ParentType>;
+    if constexpr (supports_comments<W>) {
+      if constexpr (std::is_same<Type, Array>()) {
+        _w.add_comment_to_array(_comment, _parent.arr_);
+
+      } else if constexpr (std::is_same<Type, Object>()) {
+        _w.add_comment_to_object(_comment, _parent.obj_);
+      }
+    }
+  }
+
   // For schemaful formats only.
   template <class ParentType>
   static auto add_map(const W& _w, const size_t _size,

include/rfl/parsing/Parser_commented.hpp

@@ -28,30 +28,21 @@ struct Parser<R, W, Commented<T>, ProcessorsType> {
 
   static Result<Commented<T>> read(const R& _r,
                                    const InputVarType& _var) noexcept {
-    if constexpr (supports_comments<R>) {
-      return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(_r,
-                                                                        _var)
-          .transform([&](auto&& _t) {
-            return Commented<T>(std::move(_t), _r.get_comment(_var));
-          });
-    } else {
-      return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(_r,
-                                                                        _var)
-          .transform([](auto&& _t) {
-            return Commented<T>(std::forward<decltype(_t)>(_t));
-          });
-    }
+    return Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::read(_r, _var)
+        .transform([](auto&& _t) {
+          return Commented<T>(std::forward<decltype(_t)>(_t));
+        });
   }
 
   template <class P>
   static void write(const W& _w, const Commented<T>& _c, const P& _parent) {
+    Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, _c.get(),
+                                                                _parent);
     if constexpr (supports_comments<W>) {
       if (_c.comment()) {
-        _w.add_comment(_parent, *_c.comment());
+        ParentType::add_comment(_w, *_c.comment(), _parent);
       }
     }
-    Parser<R, W, std::remove_cvref_t<T>, ProcessorsType>::write(_w, _c.get(),
-                                                                _parent);
   }
 
   static schema::Type to_schema(

include/rfl/parsing/supports_comments.hpp

@@ -7,31 +7,18 @@
 #include <string_view>
 
 #include "../Result.hpp"
-#include "IsReader.hpp"
-#include "IsWriter.hpp"
 
 namespace rfl::parsing {
 
-/// Determines whether a reader supports comments.
-template <class R>
-concept reader_supports_comments =
-    requires(R r, typename R::InputVarType var, std::string_view comment) {
-      { r.get_comment(var) } -> std::same_as<std::optional<std::string>>;
-    };
-
 /// Determines whether a writer supports comments.
 template <class W>
-concept writer_supports_comments =
-    requires(W w, Parent<W> parent, std::string_view comment) {
-      {
-        w.add_comment(parent, comment)
-      } -> std::same_as<typename W::OutputVarType>;
-    };
-
-template <class RorW>
 concept supports_comments =
-    (IsReader<RorW, int> && reader_supports_comments<RorW>) ||
-    (IsWriter<RorW, int> && writer_supports_comments<RorW>);
+    requires(W w, typename W::OutputArrayType arr,
+             typename W::OutputObjectType obj, std::string_view comment) {
+      { w.add_comment_to_array(comment, &arr) } -> std::same_as<void>;
+
+      { w.add_comment_to_object(comment, &obj) } -> std::same_as<void>;
+    };
 
 }  // namespace rfl::parsing
 

include/rfl/yaml/Writer.hpp

@@ -11,8 +11,7 @@
 #include "../always_false.hpp"
 #include "../common.hpp"
 
-namespace rfl {
-namespace yaml {
+namespace rfl::yaml {
 
 class RFL_API Writer {
  public:
@@ -42,11 +41,17 @@ class RFL_API Writer {
   }
 
   OutputArrayType add_array_to_array(const size_t _size,
-                                     OutputArrayType* _parent) const;
+                                     OutputArrayType* /*_parent*/) const;
 
   OutputArrayType add_array_to_object(const std::string_view& _name,
                                       const size_t _size,
-                                      OutputObjectType* _parent) const;
+                                      OutputObjectType* /*_parent*/) const;
+
+  void add_comment_to_array(const std::string_view& _comment,
+                            OutputArrayType* _parent) const;
+
+  void add_comment_to_object(const std::string_view& _comment,
+                             OutputObjectType* _parent) const;
 
   OutputObjectType add_object_to_array(const size_t _size,
                                        OutputArrayType* _parent) const;
@@ -122,6 +127,8 @@ class RFL_API Writer {
 
   OutputArrayType new_array() const;
 
+  void new_comment(const std::string_view& _comment) const;
+
   OutputObjectType new_object(const std::string_view& _name) const;
 
   OutputObjectType new_object() const;
@@ -130,7 +137,6 @@ class RFL_API Writer {
   const Ref<YAML::Emitter> out_;
 };
 
-}  // namespace yaml
-}  // namespace rfl
+}  // namespace rfl::yaml
 
 #endif

src/rfl/yaml/Writer.cpp

@@ -29,6 +29,16 @@ Writer::OutputArrayType Writer::add_array_to_object(
   return new_array(_name);
 }
 
+void Writer::add_comment_to_array(const std::string_view& _comment,
+                                  OutputArrayType*) const {
+  new_comment(_comment);
+}
+
+void Writer::add_comment_to_object(const std::string_view& _comment,
+                                   OutputObjectType*) const {
+  new_comment(_comment);
+}
+
 Writer::OutputObjectType Writer::add_object_to_array(
     const size_t /*_size*/, OutputArrayType* /*_parent*/) const {
   return new_object();
@@ -68,6 +78,10 @@ Writer::OutputArrayType Writer::new_array() const {
   return OutputArrayType{};
 }
 
+void Writer::new_comment(const std::string_view& _comment) const {
+  (*out_) << YAML::Comment(std::string(_comment));
+}
+
 Writer::OutputObjectType Writer::new_object(
     const std::string_view& _name) const {
   (*out_) << YAML::Key << std::string(_name) << YAML::Value << YAML::BeginMap;

tests/yaml/test_comment.cpp

@@ -0,0 +1,27 @@
+#include <rfl.hpp>
+#include <string>
+#include <vector>
+
+#include "write_and_read.hpp"
+
+namespace test_comment {
+
+struct Person {
+  std::string first_name;
+  std::string last_name;
+  rfl::Commented<std::string> town;
+};
+
+TEST(yaml, test_comment) {
+  const auto homer = Person{.first_name = "Homer",
+                            .last_name = "Simpson",
+                            .town = rfl::Commented<std::string>(
+                                "Springfield", "The town where Homer lives")};
+
+  const auto yaml_str = rfl::yaml::write(homer);
+
+  EXPECT_EQ(yaml_str, R"(first_name: Homer
+last_name: Simpson
+town: Springfield  # The town where Homer lives)");
+}
+}  // namespace test_comment