Json Schema: Add enum value descriptions

include/rfl/config.hpp

@@ -1,6 +1,8 @@
 #ifndef RFL_CONFIG_HPP_
 #define RFL_CONFIG_HPP_
 
+#include <string_view>
+
 namespace rfl::config {
 
 // To specify a different range for a particular enum type, specialize the
@@ -13,6 +15,27 @@ struct enum_range {
   // static constexpr int max = ...;
 };
 
+// To add descriptions to enum values for JSON schema generation, specialize
+// the enum_descriptions template for that enum type.
+// Example:
+//   template <>
+//   struct rfl::config::enum_descriptions<MyEnum> {
+//     static constexpr std::string_view get(MyEnum value) {
+//       switch (value) {
+//         case MyEnum::option1: return "Description for option1";
+//         case MyEnum::option2: return "Description for option2";
+//         default: return "";
+//       }
+//     }
+//   };
+template <typename T>
+struct enum_descriptions {
+  // Default implementation returns empty string (no descriptions)
+  static constexpr std::string_view get(T) { return ""; }
+  // Set to true in specializations that provide descriptions
+  static constexpr bool has_descriptions = false;
+};
+
 }  // namespace rfl::config
 
 #endif

include/rfl/json/schema/Type.hpp

@@ -110,6 +110,11 @@ struct Type {
     std::string pattern{};
   };
 
+  struct StringConst {
+    std::optional<std::string> description{};
+    rfl::Rename<"const", std::string> value{};
+  };
+
   struct StringEnum {
     Literal<"string"> type{};
     std::optional<std::string> description{};
@@ -140,8 +145,8 @@ struct Type {
   using ReflectionType =
       rfl::Variant<AllOf, AnyOf, Boolean, ExclusiveMaximum, ExclusiveMinimum,
                    FixedSizeTypedArray, Integer, Maximum, Minimum, Number, Null,
-                   Object, OneOf, Reference, Regex, String, StringEnum,
-                   StringMap, Tuple, TypedArray>;
+                   Object, OneOf, Reference, Regex, String, StringConst,
+                   StringEnum, StringMap, Tuple, TypedArray>;
 
   const auto& reflection() const { return value; }
 

include/rfl/parsing/Parser_enum.hpp

@@ -5,6 +5,7 @@
 #include <type_traits>
 
 #include "../Result.hpp"
+#include "../config.hpp"
 #include "../enums.hpp"
 #include "../thirdparty/enchantum/enchantum.hpp"
 #include "AreReaderAndWriter.hpp"
@@ -70,6 +71,17 @@ struct Parser<R, W, T, ProcessorsType> {
       return Type{Type::Integer{}};
     } else if constexpr (enchantum::is_bitflag<U>) {
       return Type{Type::String{}};
+    } else if constexpr (config::enum_descriptions<U>::has_descriptions) {
+      // Generate DescribedLiteral for enums with descriptions
+      auto described = Type::DescribedLiteral{};
+      constexpr auto enumerators = get_enumerator_array<U>();
+      for (const auto& [name, value] : enumerators) {
+        auto desc = config::enum_descriptions<U>::get(value);
+        described.values_.push_back(Type::DescribedLiteral::ValueWithDescription{
+            .value_ = std::string(name),
+            .description_ = std::string(desc)});
+      }
+      return Type{std::move(described)};
     } else {
       return Parser<
           R, W,

include/rfl/parsing/schema/Type.hpp

@@ -55,6 +55,14 @@ struct RFL_API Type {
     std::vector<std::string> values_;
   };
 
+  struct DescribedLiteral {
+    struct ValueWithDescription {
+      std::string value_;
+      std::string description_;
+    };
+    std::vector<ValueWithDescription> values_;
+  };
+
   struct Object {
     rfl::Object<Type> types_;
     std::shared_ptr<Type> additional_properties_;
@@ -92,7 +100,7 @@ struct RFL_API Type {
 
   using VariantType =
       rfl::Variant<Boolean, Bytestring, Vectorstring, Int32, Int64, UInt32, UInt64, Integer,
-                   Float, Double, String, AnyOf, Description,
+                   Float, Double, String, AnyOf, Description, DescribedLiteral,
                    FixedSizeTypedArray, Literal, Object, Optional, Reference,
                    StringMap, Tuple, TypedArray, Validated>;
 

src/rfl/json/to_schema.cpp

@@ -237,6 +237,19 @@ schema::Type type_to_json_schema_type(const parsing::schema::Type& _type,
       return schema::Type{.value =
                               schema::Type::StringEnum{.values = _t.values_}};
 
+    } else if constexpr (std::is_same<T, Type::DescribedLiteral>()) {
+      // Convert to OneOf with StringConst for each described value
+      auto one_of = std::vector<schema::Type>();
+      for (const auto& v : _t.values_) {
+        one_of.push_back(schema::Type{
+            .value = schema::Type::StringConst{
+                .description = v.description_.empty()
+                                   ? std::nullopt
+                                   : std::optional<std::string>(v.description_),
+                .value = v.value_}});
+      }
+      return schema::Type{.value = schema::Type::OneOf{.oneOf = one_of}};
+
     } else if constexpr (std::is_same<T, Type::Object>()) {
       auto properties = rfl::Object<schema::Type>();
       auto required = std::vector<std::string>();

tests/json/test_enum_descriptions.cpp

@@ -0,0 +1,76 @@
+#include <gtest/gtest.h>
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <string>
+
+namespace test_enum_descriptions {
+
+// Define an enum with descriptions
+enum class Color { red, green, blue };
+
+// An enum without descriptions for comparison
+enum class Size { small, medium, large };
+
+struct Config {
+  Color color;
+  Size size;
+};
+
+}  // namespace test_enum_descriptions
+
+// Specialize enum_descriptions to provide descriptions for Color values
+template <>
+struct rfl::config::enum_descriptions<test_enum_descriptions::Color> {
+  static constexpr bool has_descriptions = true;
+  static constexpr std::string_view get(test_enum_descriptions::Color value) {
+    switch (value) {
+      case test_enum_descriptions::Color::red:
+        return "The color red";
+      case test_enum_descriptions::Color::green:
+        return "The color green";
+      case test_enum_descriptions::Color::blue:
+        return "The color blue";
+      default:
+        return "";
+    }
+  }
+};
+
+namespace test_enum_descriptions {
+
+TEST(json, test_enum_descriptions_schema) {
+  const auto json_schema = rfl::json::to_schema<Config>();
+
+  // The schema should contain oneOf with const/description for Color
+  EXPECT_TRUE(json_schema.find("\"oneOf\"") != std::string::npos)
+      << "Expected oneOf for described enum. Schema: " << json_schema;
+  EXPECT_TRUE(json_schema.find("\"const\":\"red\"") != std::string::npos)
+      << "Expected const for red. Schema: " << json_schema;
+  EXPECT_TRUE(json_schema.find("\"description\":\"The color red\"") !=
+              std::string::npos)
+      << "Expected description for red. Schema: " << json_schema;
+  EXPECT_TRUE(json_schema.find("\"const\":\"green\"") != std::string::npos)
+      << "Expected const for green. Schema: " << json_schema;
+  EXPECT_TRUE(json_schema.find("\"const\":\"blue\"") != std::string::npos)
+      << "Expected const for blue. Schema: " << json_schema;
+
+  // Size should still use regular enum format
+  EXPECT_TRUE(json_schema.find("\"enum\":[\"small\",\"medium\",\"large\"]") !=
+              std::string::npos)
+      << "Expected regular enum for Size. Schema: " << json_schema;
+}
+
+TEST(json, test_enum_descriptions_read_write) {
+  // Verify that read/write still works correctly with described enums
+  const Config config{.color = Color::green, .size = Size::medium};
+
+  const auto json_string = rfl::json::write(config);
+  EXPECT_EQ(json_string, R"({"color":"green","size":"medium"})");
+
+  const auto parsed = rfl::json::read<Config>(json_string);
+  EXPECT_TRUE(parsed.has_value()) << "Failed to parse: " << parsed.error().what();
+  EXPECT_EQ(parsed.value().color, Color::green);
+  EXPECT_EQ(parsed.value().size, Size::medium);
+}
+
+}  // namespace test_enum_descriptions