fable: Extend String schema with enum_of method

This allows input string to explicitely match a specific list
of valid strings, and is useful when we want to have a list of
valid values, but not define an enum for it.

In addition, String is now fully checked with a unit test.

Author: cassava

fable/CMakeLists.txt

@@ -77,6 +77,7 @@ if(BUILD_TESTING)
         src/fable/schema/ignore_test.cpp
         src/fable/schema/number_test.cpp
         src/fable/schema/optional_test.cpp
+        src/fable/schema/string_test.cpp
         src/fable/schema/struct_test.cpp
         src/fable/schema_test.cpp
     )

fable/include/fable/schema/string.hpp

@@ -18,6 +18,7 @@
 /**
  * \file fable/schema/string.hpp
  * \see  fable/schema/string.cpp
+ * \see  fable/schema/string_test.cpp
  * \see  fable/schema.hpp
  * \see  fable/schema_test.cpp
  */
@@ -29,6 +30,7 @@
 #include <limits>   // for numeric_limits<>
 #include <string>   // for string
 #include <utility>  // for move
+#include <vector>   // for vector<>
 
 #include <fable/schema/interface.hpp>  // for Base<>
 
@@ -213,6 +215,34 @@ class String : public Base<String> {
    */
   void set_environment(Environment* env);
 
+  /**
+   * Return the set of valid values for the string.
+   *
+   * \return valid values
+   */
+  const std::vector<std::string>& enum_of() const;
+
+  /**
+   * Set the valid values for the string.
+   *
+   * \note If a pattern is set, the string will need to validate
+   * against the pattern in addition to this list.
+   *
+   * \param init list of valid values
+   * \return *this, for chaining
+   */
+  String enum_of(std::vector<std::string>&& init);
+
+  /**
+   * Set the valid values for the string.
+   *
+   * \note If a pattern is set, the string will need to validate
+   * against the pattern in addition to this list.
+   *
+   * \param init list of valid values
+   */
+  void set_enum_of(std::vector<std::string>&& init);
+
  public:  // Overrides
   Json json_schema() const override;
   void validate(const Conf& c) const override;
@@ -228,6 +258,7 @@ class String : public Base<String> {
   size_t min_length_{0};
   size_t max_length_{std::numeric_limits<size_t>::max()};
   std::string pattern_{};
+  std::vector<std::string> enum_{};
   Environment* env_{nullptr};
   Type* ptr_{nullptr};
 };

fable/src/fable/schema/string.cpp

@@ -22,9 +22,10 @@
 
 #include <fable/schema/string.hpp>
 
-#include <limits>  // for numeric_limits
-#include <regex>   // for regex, regex_match
-#include <string>  // for string
+#include <algorithm>  // for find
+#include <limits>     // for numeric_limits
+#include <regex>      // for regex, regex_match
+#include <string>     // for string
 
 #include <fable/environment.hpp>  // for interpolate_vars
 
@@ -76,13 +77,23 @@ String String::environment(Environment* env) && {
   return std::move(*this);
 }
 
+const std::vector<std::string>& String::enum_of() const { return enum_; }
+void String::set_enum_of(std::vector<std::string>&& init) { enum_ = std::move(init); }
+String String::enum_of(std::vector<std::string>&& init) {
+  enum_ = std::move(init);
+  return std::move(*this);
+}
+
 Json String::json_schema() const {
   Json j{
       {"type", "string"},
   };
   if (!pattern_.empty()) {
     j["pattern"] = pattern_;
   }
+  if (!enum_.empty()) {
+    j["enum"] = enum_;
+  }
   if (min_length_ != 0) {
     j["minLength"] = min_length_;
   }
@@ -109,6 +120,11 @@ void String::validate(const Conf& c) const {
   if (!pattern_.empty() && !std::regex_match(src, std::regex(pattern_))) {
     this->throw_error(c, "expect string to match regex '{}': {}", pattern_, src);
   }
+  if (!enum_.empty()) {
+    if (std::find(enum_.begin(), enum_.end(), src) == enum_.end()) {
+      this->throw_error(c, "expect string to match one of {}, got {}", Json{enum_}.dump(), src);
+    }
+  }
 }  // namespace schema
 
 void String::reset_ptr() { ptr_ = nullptr; }

fable/src/fable/schema/string_test.cpp

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2023 Robert Bosch GmbH
+ *
+ * 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.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * \file fable/schema/string_test.cpp
+ * \see  fable/schema/string.hpp
+ */
+
+#include <gtest/gtest.h>
+
+#include <fable/confable.hpp>       // for Confable
+#include <fable/environment.hpp>    // for Environment
+#include <fable/schema/string.hpp>  // for String, ...
+#include <fable/utility/gtest.hpp>  // for assert_to_json, ...
+
+#define TO_CONF(x) fable::Conf{fable::Json(x)}
+
+TEST(fable_schema_string, plain) {
+  std::string t;
+  auto s = fable::schema::make_schema(&t, "plain");
+
+  fable::assert_to_json(s, TO_CONF(""));
+  fable::assert_from_eq_to(s, TO_CONF("hello string"));
+  fable::assert_schema_eq(s, R"({
+    "type": "string",
+    "description": "plain"
+  })");
+}
+
+TEST(fable_schema_string, not_empty) {
+  std::string t;
+  auto s = fable::schema::make_schema(&t, "not empty").not_empty();
+
+  fable::assert_invalidate(s, TO_CONF(""));
+  fable::assert_from_eq_to(s, TO_CONF("not empty"));
+  fable::assert_schema_eq(s, R"({
+    "type": "string",
+    "description": "not empty",
+    "minLength": 1
+  })");
+}
+
+TEST(fable_schema_string, min_max_length) {
+  std::string t;
+  auto s = fable::schema::make_schema(&t, "min 4, max 8").min_length(4).max_length(8);
+
+  for (const auto& x : {"", "a", "asdfasdfx"}) {
+    fable::assert_invalidate(s, TO_CONF(x));
+  }
+  for (const auto& x : {"asdf", "xxxxxx", "abcdefgh"}) {
+    fable::assert_from_eq_to(s, TO_CONF(x));
+  }
+  fable::assert_schema_eq(s, R"({
+    "type": "string",
+    "description": "min 4, max 8",
+    "minLength": 4,
+    "maxLength": 8
+  })");
+}
+
+TEST(fable_schema_string, pattern) {
+  std::string t;
+  auto s = fable::schema::make_schema(&t, "c_identifier").c_identifier();
+
+  for (const auto& x : {"0_", "0", "not identifier", "", "a-b"}) {
+    fable::assert_invalidate(s, TO_CONF(x));
+  }
+  for (const auto& x : {"asdf", "_8", "_", "c_identier", "somethingElse"}) {
+    fable::assert_from_eq_to(s, TO_CONF(x));
+  }
+  fable::assert_schema_eq(s, R"({
+    "type": "string",
+    "description": "c_identifier",
+    "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$"
+  })");
+}
+
+TEST(fable_schema_string, interpolate) {
+  std::string t;
+  fable::Environment env{
+    {"TEST", "true"},
+    {"NAME", "world"}
+  };
+  auto s = fable::schema::make_schema(&t, "interpolate").interpolate(true).environment(&env);
+
+  EXPECT_ANY_THROW(assert_from_conf(s, TO_CONF("${}")));
+  EXPECT_ANY_THROW(assert_from_conf(s, TO_CONF("${__UNLIKELY}")));
+
+  fable::assert_from_conf(s, TO_CONF("${__UNLIKELY-default}"));
+  fable::assert_to_json(s, fable::Json("default"));
+  ASSERT_EQ(t, "default");
+
+  fable::assert_from_conf(s, TO_CONF("${TEST-false}"));
+  fable::assert_to_json(s, fable::Json("true"));
+  ASSERT_EQ(t, "true");
+
+  fable::assert_from_conf(s, TO_CONF("hello ${NAME}"));
+  fable::assert_to_json(s, fable::Json("hello world"));
+  ASSERT_EQ(t, "hello world");
+
+  fable::assert_schema_eq(s, R"({
+    "type": "string",
+    "description": "interpolate"
+  })");
+}
+
+TEST(fable_schema_string, enum) {
+  std::string t;
+  auto s = fable::schema::make_schema(&t, "enum").enum_of({"true", "false"});
+
+  for (const auto& x : {"", "asdf", "False"}) {
+    fable::assert_invalidate(s, TO_CONF(x));
+  }
+  for (const auto& x : {"true", "false"}) {
+    fable::assert_from_eq_to(s, TO_CONF(x));
+  }
+  fable::assert_schema_eq(s, R"({
+    "type": "string",
+    "description": "enum",
+    "enum": [ "true", "false" ]
+  })");
+}