.clang-tidy

@@ -4,6 +4,7 @@ Checks: >
   -bugprone-std-namespace-modification,
   -bugprone-exception-escape,
   -bugprone-macro-parentheses,
+  -bugprone-narrowing-conversions,
   -bugprone-crtp-constructor-accessibility,
   clang-diagnostic-*,
   -clang-diagnostic-pragma-once-outside-header,
@@ -13,7 +14,9 @@ Checks: >
   -cppcoreguidelines-avoid-const-or-ref-data-members,
   -cppcoreguidelines-use-enum-class,
   -cppcoreguidelines-pro-type-member-init,
+  -cppcoreguidelines-pro-type-vararg,
   -cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,
+  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
   google-*,
   -google-readability-namespace-comments,
   llvm-*,
@@ -92,5 +95,7 @@ CheckOptions:
     value: true
   - key: readability-function-cognitive-complexity.IgnoreMacros
     value: true
+  - key: readability-simplify-boolean-expr.IgnoreMacros
+    value: true
 ...
 

include/jvalidate/_config.h

@@ -6,3 +6,10 @@
 #else
 #define JVALIDATE_HAS_ICU 0
 #endif
+
+#if defined(JVALIDATE_HAS_IDNA)
+#elif __has_include(<ada/idna/to_unicode.h>)
+#define JVALIDATE_HAS_IDNA 1
+#else
+#define JVALIDATE_HAS_IDNA 0
+#endif

include/jvalidate/constraint.h

@@ -760,7 +760,7 @@ public:
    * @throws If the contained value is not interpretable as a string
    */
   static auto format(detail::ParserContext<A> const & context) {
-    return ptr(constraint::FormatConstraint{context.schema.as_string(),
+    return ptr(constraint::FormatConstraint{context.schema.as_string(), context.vocab->version(),
                                             context.vocab->is_format_assertion()});
   }
 

include/jvalidate/constraint/string_constraint.h

@@ -3,6 +3,8 @@
 #include <cstdlib>
 #include <string>
 
+#include <jvalidate/enum.h>
+
 namespace jvalidate::constraint {
 /**
  * @brief A constraint on the String type with the following characteristic(s):
@@ -51,6 +53,7 @@ struct PatternConstraint {
  */
 struct FormatConstraint {
   std::string format;
+  schema::Version for_version;
   bool is_assertion = false;
 };
 }

include/jvalidate/detail/idna_special_cases.h

@@ -0,0 +1,131 @@
+#pragma once
+#include <string_view>
+
+#include <jvalidate/detail/string.h>
+#include <jvalidate/forward.h>
+
+namespace jvalidate::format::detail {
+template <typename CharT> struct special_case {
+  std::basic_string_view<CharT> target;
+  bool (*accepts_at)(std::basic_string_view<CharT>, size_t);
+
+  bool accepts(std::basic_string_view<CharT> const str) const {
+    for (size_t n = str.find_first_of(target); n != str.npos;
+         n = str.find_first_of(target, n + 1)) {
+      if (not accepts_at(str, n)) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+}
+
+namespace jvalidate::format::detail {
+constexpr std::u32string_view g_exception_chars =
+    U"\u00B7\u00DF\u0375\u03C2\u05F3\u05F4\u0640\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667"
+    U"\u0668\u0669\u06F0\u06F1\u06F2\u06F3\u06F4\u06F5\u06F6\u06F7\u06F8\u06F9\u06FD\u06FE\u07FA"
+    U"\u0F0B\u3007\u302E\u302F\u3031\u3032\u3033\u3034\u3035\u303B\u30FB";
+constexpr std::u32string_view g_exception_disallowed_chars =
+    U"\u0640\u07FA\u302E\u302F\u3031\u3032\u3033\u3034\u3035\u303B";
+
+/**
+ * @brief Determine if the character is DISALLOWED by special case in the
+ * Exceptions (https://datatracker.ietf.org/doc/html/rfc5892#section-2.6)
+ * table.
+ */
+inline bool is_not_disallowed_exception(char32_t c) {
+  return g_exception_disallowed_chars.find(c) == std::u32string_view::npos;
+}
+
+/**
+ * @brief Determine if the character is in the "Greek" character range.
+ */
+inline bool is_greek(char32_t c) { return c >= U'\u0370' && c <= U'\u03FF'; }
+
+/**
+ * @brief Determine if the character is in the "Hebrew" character range.
+ */
+inline bool is_hebrew(char32_t c) { return c >= U'\u0590' && c <= U'\u05FF'; }
+
+/**
+ * @brief Determine if the character is in the "Han" (Kanji), "Hiragana", or
+ * "Katakana" character ranges, excepting "KATAKANA MIDDLE DOT".
+ */
+inline bool is_jp(char32_t c) {
+  using P = std::pair<char32_t, char32_t>;
+  constexpr std::array range{P{U'\u3040', U'\u30FA'},         P{U'\u30FC', U'\u30FF'},
+                             P{U'\u4E00', U'\u9FFF'},         P{U'\u3400', U'\u4DBF'},
+                             P{U'\U00020000', U'\U0002A6DF'}, P{U'\U0002A700', U'\U0002EBEF'},
+                             P{U'\U00030000', U'\U000323AF'}, P{U'\U0002EBF0', U'\U0002EE5F'},
+                             P{U'\U000323B0', U'\U0003347F'}, P{U'\uF900', U'\uFAFF'},
+                             P{U'\u2E80', U'\u303F'},         P{U'\u31C0', U'\u31EF'}};
+  return std::ranges::any_of(range, [c](P p) { return c >= p.first && c <= p.second; });
+}
+
+/**
+ * @brief Determine if the character is an ASCII 'l' - required for handling
+ * "MIDDLE DOT".
+ */
+inline bool is_l_char(char32_t c) { return c == 'l'; }
+}
+
+namespace jvalidate::format::detail {
+template <auto F> constexpr auto char_before(std::u32string_view str, size_t n) {
+  return n != 0 && F(str[n - 1]);
+}
+
+template <auto F> constexpr auto char_after(std::u32string_view str, size_t n) {
+  return (n != str.size() - 1) && F(str[n + 1]);
+}
+
+template <auto F> constexpr auto before_or_after(std::u32string_view str, size_t n) {
+  return char_before<F>(str, n) || char_after<F>(str, n);
+}
+
+template <auto F> constexpr auto before_and_after(std::u32string_view str, size_t n) {
+  return char_before<F>(str, n) && char_after<F>(str, n);
+}
+
+template <auto F> constexpr auto any_other_char(std::u32string_view str, size_t n) {
+  return std::any_of(str.begin(), str.begin() + n, F) ||
+         std::any_of(str.begin() + n + 1, str.end(), F);
+}
+}
+
+namespace jvalidate::format::detail {
+using std::string_view_literals::operator""sv;
+template <typename CharT> struct char_delimiters;
+
+template <> struct char_delimiters<char> {
+  static constexpr std::string_view hostname_part_delims{"."};
+  static constexpr std::string_view dotdot{".."};
+  static constexpr std::string_view double_slash{"//"};
+  static constexpr std::string_view illegal_hostname_chars;
+  static constexpr std::string_view punycode_prefix{"xn--"};
+  static constexpr std::string_view illegal_dashes_ulabel{"--"};
+  static constexpr std::array<special_case<char>, 0> special_cases;
+};
+
+template <> struct char_delimiters<char32_t> {
+  static constexpr std::u32string_view hostname_part_delims{U".\u3002\uff0e\uff61"};
+  static constexpr std::u32string_view dotdot{U".."};
+  static constexpr std::u32string_view double_slash{U"//"};
+  static constexpr std::u32string_view punycode_prefix{U"xn--"};
+  static constexpr std::u32string_view illegal_dashes_ulabel{U"--"};
+  static constexpr std::u32string_view illegal_hostname_chars{U"\u302E"};
+  static constexpr std::array special_cases{
+      special_case{U"\u0375"sv, char_after<is_greek>},
+      special_case{U"\u05f3"sv, char_before<is_hebrew>},
+      special_case{U"\u05f4"sv, char_before<is_hebrew>},
+      special_case{U"\u00b7"sv, before_and_after<is_l_char>},
+      special_case{U"\u30fb"sv, any_other_char<is_jp>},
+      special_case{g_exception_chars, before_or_after<is_not_disallowed_exception>},
+  };
+};
+
+template <typename CharT> bool is_special_case_ok(std::basic_string_view<CharT> name) {
+  return std::ranges::all_of(detail::char_delimiters<CharT>::special_cases,
+                             [name](auto & sc) { return sc.accepts(name); });
+}
+}

include/jvalidate/detail/string.h

@@ -6,6 +6,7 @@
 #include <jvalidate/_config.h> // IWYU pragma: keep
 
 #include <cstring>
+#include <memory>
 #include <string_view>
 
 #if JVALIDATE_HAS_ICU
@@ -13,8 +14,44 @@
 #include <unicode/unistr.h>
 #endif
 
+#if JVALIDATE_HAS_IDNA
+#include <ada/idna/unicode_transcoding.h>
+#endif
+
+#include <jvalidate/detail/expect.h>
+
 namespace jvalidate::detail {
-#if JVALIDATE_HAS_ICU
+inline std::string_view to_u8(std::string_view arg) { return arg; }
+inline std::u32string_view to_u32(std::u32string_view arg) { return arg; }
+}
+
+namespace jvalidate::detail {
+#if JVALIDATE_HAS_IDNA
+/**
+ * @brief Calculates the string-length of the argument, treating multi-byte
+ * characters as their individual bytes (as if the string was a std::string).
+ *
+ * @param arg Any UTF8 compatible string (including a standard ASCII string)
+ *
+ * @returns A number no greater than arg.length(), depending on the number of
+ * graphemes/codepoints in the string.
+ */
+inline size_t length(std::string_view arg) {
+  return ada::idna::utf32_length_from_utf8(arg.data(), arg.length());
+}
+
+inline std::string to_u8(std::u32string_view str) {
+  auto data = std::make_unique_for_overwrite<char[]>(4 * str.length());
+  size_t bytes = ada::idna::utf32_to_utf8(str.data(), str.length(), data.get());
+  return std::string(data.get(), data.get() + bytes);
+}
+
+inline std::u32string to_u32(std::string_view str) {
+  auto data = std::make_unique_for_overwrite<char32_t[]>(str.length());
+  size_t bytes = ada::idna::utf8_to_utf32(str.data(), str.length(), data.get());
+  return std::u32string(data.get(), data.get() + bytes);
+}
+#elif JVALIDATE_HAS_ICU
 /**
  * @brief Calculates the string-length of the argument, treating multi-byte
  * characters and unicode graphemes as single characters (which std::string

include/jvalidate/format.h

@@ -0,0 +1,829 @@
+#pragma once
+#include <jvalidate/_config.h>
+#include <jvalidate/_macro.h>
+
+/*
+ NOLINTBEGIN(readability-identifier-length,
+             bugprone-inc-dec-in-conditions,
+             cppcoreguidelines-avoid-magic-numbers,
+             bugprone-suspicious-stringview-data-usage,
+             readability-implicit-bool-conversion,
+             cppcoreguidelines-narrowing-conversions,
+             readability-identifier-length)
+ */
+#include <cstdint>
+#include <cstdio>
+#include <functional>
+
+#include <cctype>
+#include <chrono> // IWYU pragma: keep
+#include <cstddef>
+#include <cstring>
+#include <ctime>
+#include <string>
+#include <string_view>
+#include <system_error>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+#if JVALIDATE_HAS_IDNA
+#include <ada/idna/to_unicode.h>
+#include <ada/idna/validity.h>
+#endif
+
+#include <jvalidate/detail/expect.h>
+#include <jvalidate/detail/idna_special_cases.h>
+#include <jvalidate/detail/pointer.h>
+#include <jvalidate/detail/relative_pointer.h>
+#include <jvalidate/detail/string.h>
+#include <jvalidate/enum.h>
+#include <jvalidate/forward.h>
+
+#define CONSTRUCTS(TYPE) format::ctor_as_valid<detail::TYPE>
+
+#define UTF32(FN) JVALIDATE_IIF(JVALIDATE_HAS_IDNA, format::utf32<format::FN<char32_t>>, nullptr)
+
+namespace jvalidate::format {
+bool date(std::string_view dt);
+bool time(std::string_view dt);
+bool date_time(std::string_view dt);
+bool duration(std::string_view dur);
+
+template <typename CharT = char> bool uri(std::basic_string_view<CharT> uri);
+template <typename CharT = char> bool uri_reference(std::basic_string_view<CharT> uri);
+bool uri_template(std::u32string_view uri);
+bool uuid(std::string_view id);
+template <typename CharT = char> bool hostname(std::basic_string_view<CharT> name);
+
+bool ipv4(std::string_view ip);
+bool ipv6(std::string_view ip);
+
+template <typename CharT = char> bool email(std::basic_string_view<CharT> em);
+}
+
+namespace jvalidate::format::detail {
+inline bool is_dec(std::string_view s, size_t min = 0, size_t max = std::string_view::npos) {
+  constexpr char const * g_dec_digits = "0123456789";
+  return s.find_first_not_of(g_dec_digits) == std::string::npos && s.size() >= min &&
+         s.size() <= max;
+}
+
+inline bool is_hex(std::string_view s) {
+  constexpr char const * g_hex_digits = "0123456789ABCDEFabcdef";
+  return s.find_first_not_of(g_hex_digits) == std::string::npos;
+}
+
+struct Result {
+  ptrdiff_t consumed;
+  bool valid;
+};
+
+inline bool is_leapyear(int y) { return (y % 400) == 0 || ((y % 4) == 0 && (y % 100) != 0); }
+
+inline bool illegal_date(int y, int m, int d) {
+  static constexpr std::array<int, 12> days = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+  if (is_leapyear(y) && m == 1) {
+    --d;
+  }
+  return m >= 0 && m < days.size() && d > days.at(m);
+}
+
+inline Result date(std::string_view dt) {
+  struct tm tm;
+  if (char * end = strptime(dt.data(), "%Y-%m-%d", &tm); end) {
+    if ((end - dt.data()) != 10 || illegal_date(tm.tm_year + 1900, tm.tm_mon, tm.tm_mday)) {
+      return {.consumed = 0, .valid = false};
+    }
+    return {.consumed = end - dt.data(), .valid = true};
+  }
+  return {.consumed = 0L, .valid = false};
+}
+
+inline bool is_leapsecond(std::tm tm) {
+  if (tm.tm_sec != 60) {
+    return true; // NOLINT(readability-simplify-boolean-expr) See below...
+  }
+
+#if __cpp_lib_chrono >= 201907L
+  tm.tm_isdst = -1;
+  std::chrono::seconds time(std::mktime(&tm));
+  auto const & leap_seconds = std::chrono::get_tzdb().leap_seconds;
+  return std::ranges::find(leap_seconds, time) != leap_seconds.end();
+#else
+  return false;
+#endif
+}
+
+// https://www.rfc-editor.org/rfc/rfc6570.html#section-1.5
+inline bool is_uschar(int c) {
+  using P = std::pair<int, int>;
+  constexpr std::array data{
+      P{0xA0, 0xD7FF},     P{0xF900, 0xFDCF},   P{0xFDF0, 0xFFEF},   P{0x10000, 0x1FFFD},
+      P{0x20000, 0x2FFFD}, P{0x30000, 0x3FFFD}, P{0x40000, 0x4FFFD}, P{0x50000, 0x5FFFD},
+      P{0x60000, 0x6FFFD}, P{0x70000, 0x7FFFD}, P{0x80000, 0x8FFFD}, P{0x90000, 0x9FFFD},
+      P{0xA0000, 0xAFFFD}, P{0xB0000, 0xBFFFD}, P{0xC0000, 0xCFFFD}, P{0xD0000, 0xDFFFD},
+      P{0xE0000, 0xEFFFD},
+  };
+  return std::ranges::any_of(data,
+                             [c](auto & pair) { return c >= pair.first && c <= pair.second; });
+}
+
+template <typename CharT>
+inline bool is_pchar(std::basic_string_view<CharT> part, size_t & pos,
+                     std::string_view extra_valid_chars = ":@") {
+  constexpr char const * g_hex_digits = "0123456789ABCDEFabcdef";
+  if (std::isalnum(part[pos]) || is_uschar(part[pos]) ||
+      std::strchr("-._~!$&'()*+,;=", part[pos])) {
+    return true;
+  }
+  if (part[pos] == '%') {
+    return pos + 2 < part.size() && std::strchr(g_hex_digits, part[++pos]) &&
+           std::strchr(g_hex_digits, part[++pos]);
+  }
+  return extra_valid_chars.find(part[pos]) != std::basic_string_view<CharT>::npos;
+};
+
+inline bool is_uri_template_literal(std::u32string_view part, size_t & pos) {
+  constexpr char const * g_hex_digits = "0123456789ABCDEFabcdef";
+  if (part[pos] == '%') {
+    return pos + 2 < part.size() && std::strchr(g_hex_digits, part[++pos]) &&
+           std::strchr(g_hex_digits, part[++pos]);
+  }
+  return !std::strchr(R"( "'%<>\^`{|}`)", part[pos]) && part[pos] > 0x1F && part[pos] != 0x7F;
+}
+
+inline bool is_uri_template_varchar(std::u32string_view part, size_t & pos) {
+  constexpr char const * g_hex_digits = "0123456789ABCDEFabcdef";
+  if (part[pos] == '%') {
+    return pos + 2 < part.size() && std::strchr(g_hex_digits, part[++pos]) &&
+           std::strchr(g_hex_digits, part[++pos]);
+  }
+  return std::isalnum(part[pos]) || part[pos] == '_';
+}
+
+inline bool is_uri_template_expression(std::u32string_view part) {
+  if (part.empty()) {
+    return false;
+  }
+
+  if (std::strchr("+#./;?&=,!@|", part[0])) {
+    part.remove_prefix(1);
+  }
+
+  for (size_t pos = part.find(','); !part.empty();
+       part.remove_prefix(std::min(part.size(), pos)), pos = part.find(',')) {
+    std::u32string_view varspec = part.substr(0, pos);
+    std::u32string_view expand;
+    if (size_t const mod = varspec.find_first_of(U":*"); mod != std::u32string_view::npos) {
+      expand = varspec.substr(mod + 1);
+      varspec.remove_suffix(expand.size() + 1);
+    }
+
+    if (expand.empty() || expand == U"*") {
+      // No Modifier, or Explode
+    } else if (expand.size() > 4 || expand[0] == '0' ||
+               not std::ranges::all_of(expand, [](char c) { return std::isdigit(c); })) {
+      return false;
+    }
+    for (size_t i = 0; i < varspec.size(); ++i) {
+      JVALIDATE_RETURN_UNLESS(is_uri_template_varchar(varspec, i) || (i > 0 && varspec[i] == '.'),
+                              false);
+    }
+  }
+
+  return true;
+}
+
+template <typename CharT> bool is_uri_authority(std::basic_string_view<CharT> uri) {
+  // A URI Authority section MAY contain user info, which is every character up
+  // to the first "@" character, as long as that character is not part of the path
+  if (size_t pos = uri.find('@'); pos != uri.npos) {
+    for (size_t i = 0; i < pos; ++i) {
+      if (not is_pchar(uri, i, ":")) {
+        return false;
+      }
+    }
+    uri.remove_prefix(pos + 1);
+  }
+
+  // A URI Authority HOST section
+  // If the URI starts with '[', then it MUST BE an IPv6 or an "IPvFuture"
+  bool const has_ipv6 = (uri[0] == '[');
+  if (has_ipv6) {
+    size_t pos = uri.find(']');
+    auto ip = uri.substr(1, pos - 1);
+    uri.remove_prefix(pos + 1);
+    if (not ipv6(to_u8(ip))) {
+      return false;
+    }
+  }
+
+  // A URI Authority PORT section. Technically allows any number of digits
+  if (size_t pos = uri.find(':'); pos != uri.npos) {
+    if (not std::ranges::all_of(uri.substr(pos + 1), [](auto c) { return std::isdigit(c); })) {
+      return false;
+    }
+    uri.remove_suffix(uri.size() - pos + 1);
+  }
+
+  // Normal URI Authority HOST section is either an IPv4 or a HOSTNAME
+  // if we had an ipv6 part, we can permit an empty string (since hostname
+  // no longer permits them).
+  return (has_ipv6 && uri.empty()) || ipv4(to_u8(uri)) || hostname(uri);
+}
+
+// Tests if a URI "Query Part" or "Fragment Part" is valid and remove the part
+template <typename CharT> bool test_uri_part(std::basic_string_view<CharT> & uri, char delim) {
+  size_t const pos = uri.find(delim);
+  if (pos == uri.npos) {
+    return true;
+  }
+  auto part = uri.substr(pos + 1);
+  uri = uri.substr(0, pos);
+  for (size_t pos = 0; pos < part.size(); ++pos) {
+    JVALIDATE_RETURN_UNLESS(detail::is_pchar(part, pos, ":@/?"), false);
+  }
+  return true;
+};
+}
+
+namespace jvalidate::format::draft03 {
+namespace detail = jvalidate::format::detail;
+
+inline bool time(std::string_view dt) {
+  std::tm tm;
+  char const * end = strptime(dt.data(), "%T", &tm);
+  if (end == nullptr || (end - dt.data()) < 8) {
+    return false;
+  }
+  return end == dt.end();
+}
+
+inline bool utc_millisec(std::string_view utc) {
+  int64_t itime = 0;
+  if (auto [end, ec] = std::from_chars(utc.begin(), utc.end(), itime);
+      ec == std::errc{} && end == utc.end()) {
+    return true;
+  }
+  double dtime = 0.0;
+  auto [end, ec] = std::from_chars(utc.begin(), utc.end(), dtime);
+  return ec == std::errc{} && end == utc.end();
+}
+
+inline bool css_2_1_color(std::string_view color) {
+  if (color.empty()) {
+    return false;
+  }
+  constexpr char const * g_hex_digits = "0123456789ABCDEFabcdef";
+  if (color[0] == '#') {
+    return color.size() <= 7 && detail::is_hex(color.substr(1));
+  }
+  static std::unordered_set<std::string_view> g_color_codes{
+      "maroon", "red",  "orange", "yellow", "olive", "purple", "fuchsia", "white", "lime",
+      "green",  "navy", "blue",   "aqua",   "teal",  "black",  "silver",  "gray"};
+  return g_color_codes.contains(color);
+}
+
+inline bool e_123_phone(std::string_view phone) {
+  // https://support.secureauth.com/hc/en-us/articles/360036402211-Regular-Expressions-for-ITU-E-123-and-E-164-phone-number-formats
+  if (phone.empty()) {
+    return false;
+  }
+  if (phone[0] != '+') {
+    constexpr size_t g_usa_phone_tokens = 3;
+    char area[4], head[4], tail[5]; // NOLINT
+    return sscanf(phone.data(), "(%3s) %3s %4s", area, head, tail) == g_usa_phone_tokens &&
+           detail::is_dec(area, 3) && detail::is_dec(head, 3) && detail::is_dec(tail, 4);
+  }
+  char tok0[4], tok1[4], tok2[4], tok3[5]; // NOLINT
+  constexpr size_t g_i18n_phone_tokens = 4;
+  return sscanf(phone.data(), "+%3s %3s %3s %4s", tok0, tok1, tok2, tok3) == g_i18n_phone_tokens &&
+         detail::is_dec(tok0, 1, 3) && detail::is_dec(tok1, 2, 3) && detail::is_dec(tok2, 2, 3) &&
+         detail::is_dec(tok3, 4);
+}
+}
+
+namespace jvalidate::format {
+inline bool date(std::string_view dt) {
+  auto [consumed, valid] = detail::date(dt);
+  return valid && consumed == dt.size();
+}
+
+inline bool time(std::string_view dt) {
+  std::tm tm;
+  char const * end = strptime(dt.data(), "%T", &tm);
+  if (end == nullptr || end == dt.end() || (end - dt.data()) < 8) {
+    return false;
+  }
+  dt.remove_prefix(end - dt.begin());
+  if (dt[0] == '.') {
+    dt.remove_prefix(1);
+    if (dt.empty() || not std::isdigit(dt[0])) {
+      return false;
+    }
+    while (std::isdigit(dt[0])) {
+      dt.remove_prefix(1);
+    }
+  }
+
+  if (dt[0] == 'Z' || dt[0] == 'z') {
+    return dt.size() == 1 && detail::is_leapsecond(tm);
+  }
+  if (std::strchr("+-", dt[0])) {
+    dt.remove_prefix(1);
+    return strptime(dt.data(), "%R", &tm) == dt.end() && detail::is_leapsecond(tm);
+  }
+  return false;
+}
+
+inline bool date_time(std::string_view dt) {
+  auto [size, good] = detail::date(dt);
+  if (not good || std::strchr("Tt", dt[size]) == nullptr) {
+    return false;
+  }
+  dt.remove_prefix(size + 1);
+  return time(dt);
+}
+
+template <typename CharT> inline bool uri(std::basic_string_view<CharT> uri) {
+  using delim = detail::char_delimiters<CharT>;
+
+  // https://www.rfc-editor.org/rfc/rfc3986.html#appendix-A
+  if (size_t const pos = uri.find(':'); pos != uri.npos) {
+    JVALIDATE_RETURN_UNLESS(std::isalpha(uri[0]), false);
+    for (size_t i = 1; i < pos; ++i) {
+      JVALIDATE_RETURN_UNLESS(std::isalnum(uri[i]) || std::strchr("+-.", uri[i]), false);
+    }
+    uri.remove_prefix(pos + 1);
+  } else {
+    return false;
+  }
+
+  JVALIDATE_RETURN_UNLESS(detail::test_uri_part(uri, '#'), false);
+  JVALIDATE_RETURN_UNLESS(detail::test_uri_part(uri, '?'), false);
+
+  auto path = uri;
+  if (uri.starts_with(delim::double_slash)) {
+    uri.remove_prefix(2);
+    path = uri.substr(std::min(uri.size(), uri.find('/')));
+    uri.remove_suffix(path.size());
+    JVALIDATE_RETURN_UNLESS(detail::is_uri_authority(uri), false);
+  }
+
+  for (size_t i = 0; i < path.size(); ++i) {
+    JVALIDATE_RETURN_UNLESS(detail::is_pchar(path, i, "/:@"), false);
+  }
+
+  return true;
+}
+
+template <typename CharT> inline bool uri_reference(std::basic_string_view<CharT> uri) {
+  using delim = detail::char_delimiters<CharT>;
+  if (jvalidate::format::uri(uri)) {
+    return true;
+  }
+
+  JVALIDATE_RETURN_UNLESS(detail::test_uri_part(uri, '#'), false);
+  JVALIDATE_RETURN_UNLESS(detail::test_uri_part(uri, '?'), false);
+
+  auto path = uri;
+  if (uri.starts_with(delim::double_slash)) {
+    uri.remove_prefix(2);
+    path = uri.substr(std::min(uri.size(), uri.find('/')));
+    uri.remove_suffix(path.size());
+    JVALIDATE_RETURN_UNLESS(detail::is_uri_authority(uri), false);
+  }
+
+  if (size_t const pos = path.find('/'); pos != path.npos) {
+    for (size_t i = 0; i < pos; ++i) {
+      JVALIDATE_RETURN_UNLESS(detail::is_pchar(path, i, "@"), false);
+    }
+    path.remove_prefix(pos);
+  }
+
+  for (size_t i = 0; i < path.size(); ++i) {
+    JVALIDATE_RETURN_UNLESS(detail::is_pchar(path, i, "/:@"), false);
+  }
+
+  return true;
+}
+
+inline bool uri_template(std::u32string_view uri) {
+  for (size_t i = 0; i < uri.size(); ++i) {
+    if (uri[i] != '{') {
+      JVALIDATE_RETURN_UNLESS(detail::is_uri_template_literal(uri, i), false);
+      continue;
+    }
+
+    std::u32string_view expr = uri.substr(i + 1);
+    size_t const pos = expr.find('}');
+    JVALIDATE_RETURN_IF(pos == std::u32string_view::npos, false);
+    JVALIDATE_RETURN_UNLESS(detail::is_uri_template_expression(expr.substr(0, pos)), false);
+    i += pos + 1;
+  }
+  return true;
+}
+
+inline bool uuid(std::string_view id) {
+  constexpr size_t g_uuid_len = 36;
+  constexpr size_t g_uuid_tokens = 5;
+  char tok0[9], tok1[5], tok2[5], tok3[5], tok4[13]; // NOLINT
+
+  return id.size() == g_uuid_len &&
+         // NOLINTNEXTLINE(bugprone-suspicious-stringview-data-usage)
+         sscanf(id.data(), "%8s-%4s-%4s-%4s-%12s", tok0, tok1, tok2, tok3, tok4) == g_uuid_tokens &&
+         detail::is_hex(tok0) && detail::is_hex(tok1) && detail::is_hex(tok2) &&
+         detail::is_hex(tok3) && detail::is_hex(tok4);
+}
+
+inline bool duration(std::string_view dur) {
+  auto eat = [&dur](std::string_view text) {
+    char type = '\0';
+    unsigned int rep = 0;
+    // NOLINTNEXTLINE(bugprone-suspicious-stringview-data-usage)
+    if (sscanf(dur.data(), "%u%c", &rep, &type) != 2 || text.find(type) == std::string::npos) {
+      return std::string::npos;
+    }
+    dur.remove_prefix(dur.find(type) + 1);
+    return text.find(type);
+  };
+
+  // All DURATION entities must start with the prefix 'P', and cannot be empty
+  // past that point.
+  if (dur[0] != 'P' || dur.size() == 1) {
+    return false;
+  }
+  dur.remove_prefix(1);
+
+  // Special Case: a duration measured in weeks is incompatible with other
+  // duration tokens.
+  if (eat("W") != std::string::npos) {
+    return dur.empty();
+  }
+
+  // DURATION takes the following form, because we use the same token for both
+  // Months and Minutes.
+  // "P[#Y][#M][#D][T[#H][#M][#S]]".
+  // At least one of the optional fields must be present.
+  if (dur[0] != 'T') {
+    std::string_view ymd{"YMD"};
+    // Read YMD duration offsets in that order, allowing us to skip past them.
+    while (not ymd.empty() && not dur.empty()) {
+      if (size_t const pos = eat(ymd); pos != std::string::npos) {
+        ymd.remove_prefix(pos + 1);
+      } else {
+        return false;
+      }
+    }
+    if (dur.empty()) {
+      return true;
+    }
+  }
+
+  // If we have a 'T' prefix for Hour/Minute/Second offsets, we must have at
+  // least one of them present.
+  if (dur[0] != 'T' || dur.size() == 1) {
+    return false;
+  }
+  dur.remove_prefix(1);
+
+  std::string_view hms{"HMS"};
+  // Read HMS duration offsets in that order, allowing us to skip past them.
+  while (not hms.empty() && not dur.empty()) {
+    if (size_t const pos = eat(hms); pos != std::string::npos) {
+      hms.remove_prefix(pos + 1);
+    } else {
+      return false;
+    }
+  }
+  return dur.empty();
+}
+
+template <typename CharT>
+bool is_invalid_size_or_boundary_hostname(std::basic_string_view<CharT> name) {
+  using delim = detail::char_delimiters<CharT>;
+  return (name.empty() || name.length() >= 64 ||
+          (name.size() >= 4 && name.substr(2).starts_with(delim::illegal_dashes_ulabel)) ||
+          name[0] == '-' || name.back() == '-');
+}
+
+#if !JVALIDATE_HAS_IDNA
+inline bool hostname_part(std::string_view name) {
+  using delim = detail::char_delimiters<char>;
+
+  if (is_invalid_size_or_boundary_hostname(name)) {
+    return false;
+  }
+  return std::ranges::none_of(name, [](char c) { return c != '-' && not std::isalnum(c); });
+}
+#else
+template <typename CharT> inline bool hostname_part(std::basic_string_view<CharT> name) {
+  using delim = detail::char_delimiters<CharT>;
+  // Punycode is a way to restructure UTF-8 strings to be ASCII compatibly
+  // All Punycode string start with "xn--" (and would therefore fail below).
+  if (name.starts_with(delim::punycode_prefix)) {
+    std::u32string decoded = detail::to_u32(ada::idna::to_unicode(detail::to_u8(name)));
+    return (decoded != detail::to_u32(name)) && hostname_part<char32_t>(decoded);
+  }
+
+  // Unfortunately, the ada-idna library does not validate things like
+  // "is there a HEBREW character after the HEBREW COMMA".
+  if (not detail::is_special_case_ok(name)) {
+    return false;
+  }
+
+  if (name.find_first_of(delim::illegal_hostname_chars) != name.npos) {
+    return false;
+  }
+
+  // An INVALID hostname part is one of the following:
+  // - empty
+  // - more than 63 characters long
+  // - starts or ends with a '-'
+  // - matches the regular expression /^..--.*$/
+  if (is_invalid_size_or_boundary_hostname(name)) {
+    return false;
+  }
+
+  // This is a much easier check in hostname than idn-hostname, since we can
+  // just check for alphanumeric and '-'.
+  if constexpr (std::is_same_v<char, CharT>) {
+    return std::ranges::none_of(name, [](char c) { return c != '-' && not std::isalnum(c); });
+  } else {
+    return ada::idna::is_label_valid(name);
+  }
+}
+#endif
+
+template <typename CharT> inline bool hostname(std::basic_string_view<CharT> name) {
+  using delim = detail::char_delimiters<CharT>;
+  // In general, the maximum length of a hostname is 253 characters.
+  if (name.empty() || name.length() > 253) {
+    return false;
+  }
+
+  // We validate each sub-section of the hostname in parts, delimited by '.'
+  for (size_t n = name.find_first_of(delim::hostname_part_delims); n != std::string::npos;
+       name.remove_prefix(n + 1), n = name.find_first_of(delim::hostname_part_delims)) {
+    if (not hostname_part(name.substr(0, n))) {
+      return false;
+    }
+  }
+
+  // Previous test versions allowed for a hostname to end with '.', but this is
+  // not permitted in the latest test specification.
+  return hostname_part(name);
+}
+
+inline bool ipv4(std::string_view ip) {
+  unsigned int ip0, ip1, ip2, ip3; // NOLINT
+  char eof = '\0';
+  // IPv4 address MAY only contain DIGITS and '.'
+  if (ip.find_first_not_of("0123456789.") != std::string_view::npos) {
+    return false;
+  }
+
+  // Each OCTET of an IPv4 can only start with '0' if it is EXACTLY '0'
+  if (ip[0] == '0' && std::isdigit(ip[1])) {
+    return false;
+  }
+  if (size_t const pos = ip.find(".0");
+      pos != std::string_view::npos && std::isdigit(ip[pos + 2])) {
+    return false;
+  }
+
+  // sscanf returns the number of tokens parsed successfully.
+  // Therefore, we can add a trailing character output to the format-string
+  // and check that we failed to parse any token into the eof-character token.
+  if (sscanf(std::string(ip).c_str(), "%3u.%3u.%3u.%3u%c", &ip0, &ip1, &ip2, &ip3, &eof) != 4) {
+    return false;
+  }
+  // Affirm that each OCTET is only two bytes wide.
+  return ip0 <= 0xFF && ip1 <= 0xFF && ip2 <= 0xFF && ip3 <= 0xFF;
+}
+
+inline bool ipv6(std::string_view ip) {
+  int expected_spans = 8;
+
+  // There is a special rule with IPv6 to allow an IPv4 address as a suffix
+  if (size_t n = ip.find('.'); n != std::string::npos) {
+    if (not ipv4(ip.substr(ip.find_last_of(':') + 1))) {
+      return false;
+    }
+    // since ipv4 addresses contain 8 bytes of information, and each segment of
+    // an ipv6 address contains 4 bytes - we should reduce the number of
+    // expected spans to 6. Instead - we reduce it to 7 because we don't prune
+    // the first OCTET of the IPv4 section (as it can read as a valid segment).
+    expected_spans = 7;
+    ip = ip.substr(0, n);
+  }
+
+  // IPv6 address MAY only contain HEXDIGITs and ':'
+  if (ip.find_first_not_of("0123456789ABCDEFabcdef:") != std::string::npos) {
+    return false;
+  }
+  // IPv6 addresses can have a maximum of 39 characters (8 4-char HEXDIGIT
+  // segments with 7 dividing ':'s).
+  if (ip.size() >= 40) {
+    return false;
+  }
+
+  bool has_compressed = false;
+  int groups = 0;
+
+  if (ip.starts_with("::")) {
+    has_compressed = true;
+    ip.remove_prefix(2);
+  }
+
+  while (!ip.empty() && ++groups) {
+    int data = 0;
+    if (sscanf(ip.data(), "%4x", &data) != 1) {
+      // Not a 4-byte HEXDIGIT. Not sure that it's ever possible due to the
+      // char filter above.
+      return false;
+    }
+
+    size_t const div_pos = ip.find(':');
+    if (std::min(div_pos, ip.size()) > 4) {
+      return false; // Segments must be between 1 and 4 characters long
+    }
+    if (div_pos != std::string::npos) {
+      ip.remove_prefix(div_pos + 1);
+    } else {
+      break; // End of String
+    }
+
+    // We removed the regular ':', so this is a check for a compression mark
+    if (ip[0] != ':') {
+      continue;
+    }
+    if (std::exchange(has_compressed, true)) {
+      // The above trick allows us to ensure that there is no more than one
+      // set of "::" compression tokens in this IPv6 adfress.
+      return false;
+    }
+    ip.remove_prefix(1);
+  }
+
+  return groups == expected_spans || (has_compressed && groups < expected_spans);
+}
+
+// Let's be honest - no matter what RFC 5321 §4.1.2 or RFC 6531 say, the only
+// way to know if an email address is valid is to try and send a message to it.
+// Therefore, there's no point in trying to validate things according to a
+// complex grammar - as long as it has an '@' sign with at least one character
+// on each side, we ought to call it an email.
+template <typename CharT> inline bool email(std::basic_string_view<CharT> em) {
+  using delim = detail::char_delimiters<CharT>;
+  size_t const n = em.find_last_of('@');
+  if (n == 0 || n >= em.size() - 1) {
+    return false;
+  }
+
+  auto const who = em.substr(0, n);
+  if (who.starts_with('"') && who.ends_with('"')) {
+    // No validation
+  } else if (who.starts_with('.') || who.ends_with('.')) { // NOLINT(bugprone-branch-clone)
+    return false;
+  } else if (em.substr(0, n).find(delim::dotdot) != em.npos) {
+    return false;
+  } else if (who.find('@') != em.npos) {
+    // This will catch multiple emails, but will gracefully ignore quote-escaped
+    // '@' characters in the name element.
+    return false;
+  }
+
+  // The DOMAIN section of an email address MAY be either a HOSTNAME, or an
+  // IP Address surrounded in brackets.
+  auto domain = em.substr(n + 1);
+  if (not(domain.starts_with('[') && domain.ends_with(']'))) {
+    return hostname(domain);
+  }
+  domain.remove_prefix(1);
+  domain.remove_suffix(1);
+
+  // When the DOMAIN is an IPv6, it must start with "IPv6:" for some
+  // weird compatibility reason.
+  auto ip = detail::to_u8(domain);
+  if (ip.starts_with("IPv6:")) {
+    return ipv6(ip.substr(5));
+  }
+  return ipv4(ip);
+}
+
+template <typename T> inline bool ctor_as_valid(std::string_view str) {
+  try {
+    [[maybe_unused]] auto _ = T(str);
+    return true;
+  } catch (std::exception const &) { return false; }
+}
+
+#if JVALIDATE_HAS_IDNA
+template <auto Predicate> bool utf32(std::string_view str) {
+  return Predicate(detail::to_u32(str));
+}
+#endif
+}
+
+namespace jvalidate {
+class FormatValidator {
+public:
+  using StatelessPredicate = bool (*)(std::string_view);
+  using Predicate = std::function<bool(std::string_view)>;
+  using UserDefinedFormats = std::unordered_map<std::string, Predicate>;
+  enum class Status : int8_t { Unknown, Unimplemented, Valid, Invalid };
+
+private:
+  // This isn't actually a user format, but we don't generate any special
+  // annotations for user-defined format codes, so it doesn't really matter that
+  // we're putting it here. It simply reduces the number of LoC when setting up.
+  std::unordered_map<std::string, Predicate> formats_{{"regex", nullptr}};
+
+  std::unordered_map<std::string, StatelessPredicate> builtin_formats_{
+      {"date", &format::date},
+      {"date-time", &format::date_time},
+      {"duration", &format::duration},
+      {"email", &format::email},
+      {"hostname", &format::hostname},
+      {"idn-email", UTF32(email)},
+      {"idn-hostname", UTF32(hostname)},
+      {"ipv4", &format::ipv4},
+      {"ipv6", &format::ipv6},
+      {"iri", UTF32(uri)},
+      {"iri-reference", UTF32(uri_reference)},
+      {"json-pointer", CONSTRUCTS(Pointer)},
+      {"relative-json-pointer", CONSTRUCTS(RelativePointer)},
+      {"time", &format::time},
+      {"uri", &format::uri},
+      {"uri-reference", &format::uri_reference},
+#if JVALIDATE_HAS_IDNA
+      {"uri-template", &format::utf32<format::uri_template>},
+#else
+      {"uri-template", nullptr},
+#endif
+      {"uuid", &format::uuid},
+  };
+
+  std::unordered_map<std::string, StatelessPredicate> draft03_formats_{
+      {"date", &format::date},
+      // One of the weird things about draft03 - date-time allows for timezone
+      // and fraction-of-second in the argument, but time only allows hh:mm:ss.
+      {"date-time", &format::date_time},
+      {"time", &format::draft03::time},
+      {"utc-millisec", &format::draft03::utc_millisec},
+      {"color", &format::draft03::css_2_1_color},
+      {"style", nullptr},
+      {"phone", &format::draft03::e_123_phone},
+      {"uri", &format::uri},
+      {"email", &format::email},
+      {"ip-address", &format::ipv4},
+      {"ipv6", &format::ipv6},
+      {"host-name", &format::hostname},
+  };
+
+public:
+  FormatValidator() = default;
+  explicit(false) FormatValidator(Predicate is_regex) {
+    formats_.insert_or_assign("regex", is_regex);
+  }
+  FormatValidator(UserDefinedFormats formats, Predicate is_regex) : formats_(std::move(formats)) {
+    formats_.insert_or_assign("regex", is_regex);
+  }
+
+  Status operator()(std::string const & format, schema::Version for_version,
+                    std::string_view text) const {
+    auto const & supported =
+        for_version == schema::Version::Draft03 ? draft03_formats_ : builtin_formats_;
+    if (Status rval = (*this)(supported, format, text); rval != Status::Unknown) {
+      return rval;
+    }
+    return (*this)(formats_, format, text);
+  }
+
+private:
+  Status operator()(auto const & supported, std::string const & format,
+                    std::string_view text) const {
+    if (auto it = supported.find(format); it != supported.end()) {
+      if (not it->second) {
+        return Status::Unimplemented;
+      }
+      return it->second(text) ? Status::Valid : Status::Invalid;
+    }
+    return Status::Unknown;
+  }
+};
+}
+
+#undef CONSTRUCTS
+#undef UTF32
+/*
+ NOLINTEND(readability-identifier-length,
+           bugprone-inc-dec-in-conditions,
+           cppcoreguidelines-avoid-magic-numbers,
+           bugprone-suspicious-stringview-data-usage,
+           readability-implicit-bool-conversion,
+           cppcoreguidelines-narrowing-conversions,
+           readability-identifier-length)
+ */

include/jvalidate/forward.h

@@ -20,6 +20,12 @@
 
 #define COMMA_NAME(X) , X
 
+namespace jvalidate::detail {
+}
+namespace jvalidate::format::detail {
+using namespace jvalidate::detail;
+}
+
 namespace jvalidate {
 class Schema;
 class Status;
@@ -179,6 +185,7 @@ concept MutableAdapter = Adapter<A> && requires(A const adapter) {
 template <typename R>
 concept RegexEngine = requires(R & engine) {
   { R::engine_name() } -> std::convertible_to<std::string_view>;
+  { R::is_regex("") } -> std::same_as<bool>;
   { engine.search("" /* pattern */, "" /* text */) } -> std::same_as<bool>;
 };
 

include/jvalidate/validation_visitor.h

@@ -30,6 +30,7 @@
 #include <jvalidate/detail/string.h>
 #include <jvalidate/detail/string_adapter.h>
 #include <jvalidate/detail/tribool.h>
+#include <jvalidate/format.h>
 #include <jvalidate/forward.h>
 #include <jvalidate/schema.h>
 #include <jvalidate/status.h>
@@ -89,6 +90,7 @@ private:
   ValidationConfig const & cfg_;
   ExtensionVisitor extension_;
   RE & regex_;
+  FormatValidator & format_;
 
   mutable VisitedAnnotation * visited_ = nullptr;
   mutable StoreResults tracking_ = StoreResults::ForInvalid;
@@ -106,9 +108,10 @@ public:
    * receive a detailed summary of why a document is supported/unsupported.
    */
   ValidationVisitor(schema::Node const & schema, Root const & root, ValidationConfig const & cfg,
-                    RE & regex, ExtensionVisitor extension, ValidationResult * result)
+                    RE & regex, FormatValidator & format, ExtensionVisitor extension,
+                    ValidationResult * result)
       : schema_(&schema), root_(&root), result_(result), cfg_(cfg), extension_(extension),
-        regex_(regex) {}
+        regex_(regex), format_(format) {}
 
 private:
   Status visit(constraint::ExtensionConstraint const & cons, Adapter auto const & document) const {
@@ -349,7 +352,15 @@ private:
       return true; // TODO(samjaffe): I think this can be made into Noop
     }
 
-    return result(Status::Reject, cons.format, " is unimplemented");
+    switch (format_(cons.format, cons.for_version, document.as_string())) {
+    case FormatValidator::Status::Unimplemented:
+      return result(Status::Reject, "unimplemented format '", cons.format, "'");
+    case FormatValidator::Status::Invalid:
+      return result(Status::Reject, "does not match format '", cons.format, "'");
+    case FormatValidator::Status::Unknown:
+    case FormatValidator::Status::Valid:
+      return result(Status::Accept, "matches format '", cons.format, "'");
+    }
   }
 
   Status visit(constraint::AdditionalItemsConstraint const & cons,

include/jvalidate/validator.h

@@ -32,6 +32,7 @@ private:
   ValidationConfig cfg_;
   ExtensionVisitor extension_{};
   RE regex_{};
+  FormatValidator format_{RE::is_regex};
 
 public:
   /**
@@ -42,12 +43,61 @@ public:
    * @param cfg Any special (runtime) configuration rules being applied to the
    * validator.
    */
-  explicit Validator(schema::Node const & schema, ExtensionVisitor extension = {},
+  explicit Validator(schema::Node const & schema, ValidationConfig const & cfg = {})
+      : schema_(schema), cfg_(cfg) {}
+
+  /**
+   * @brief Construct a Validator
+   *
+   * @param schema The root schema being validated against. Must outlive this.
+   *
+   * @param extension An extension visitor for processing user-defined
+   * constraints
+   *
+   * @param cfg Any special (runtime) configuration rules being applied to the
+   * validator.
+   */
+  explicit Validator(schema::Node const & schema, ExtensionVisitor extension,
                      ValidationConfig const & cfg = {})
       : schema_(schema), cfg_(cfg), extension_(extension) {}
 
-  Validator(schema::Node const & schema, ValidationConfig const & cfg)
-      : schema_(schema), cfg_(cfg) {}
+  /**
+   * @brief Construct a Validator
+   *
+   * @param schema The root schema being validated against. Must outlive this.
+   *
+   * @param user_defined_formats A map of format-name to string validator for
+   * user-defined format tools.
+   *
+   * @param cfg Any special (runtime) configuration rules being applied to the
+   * validator. Because user_defined_formats is provided by this constructor,
+   * we default to validate_format:=true.
+   */
+  Validator(schema::Node const & schema,
+            FormatValidator::UserDefinedFormats const & user_defined_formats,
+            ValidationConfig const & cfg = {.validate_format = true})
+      : schema_(schema), cfg_(cfg), format_(user_defined_formats, RE::is_regex) {}
+
+  /**
+   * @brief Construct a Validator
+   *
+   * @param schema The root schema being validated against. Must outlive this.
+   *
+   * @param extension An extension visitor for processing user-defined
+   * constraints
+   *
+   * @param user_defined_formats A map of format-name to string validator for
+   * user-defined format tools.
+   *
+   * @param cfg Any special (runtime) configuration rules being applied to the
+   * validator. Because user_defined_formats is provided by this constructor,
+   * we default to validate_format:=true.
+   */
+  Validator(schema::Node const & schema, ExtensionVisitor extension,
+            FormatValidator::UserDefinedFormats const & user_defined_formats,
+            ValidationConfig const & cfg = {.validate_format = true})
+      : schema_(schema), cfg_(cfg), extension_(extension),
+        format_(user_defined_formats, RE::is_regex) {}
 
   template <typename... Args> Validator(schema::Node &&, Args &&...) = delete;
 
@@ -70,7 +120,7 @@ public:
     EXPECT_M(not cfg_.construct_default_values,
              "Cannot perform mutations on an immutable JSON Adapter");
     detail::OnBlockExit const _ = [&result, this]() { post_process(result); };
-    ValidationVisitor visitor(schema_, json, cfg_, regex_, extension_, result);
+    ValidationVisitor visitor(schema_, json, cfg_, regex_, format_, extension_, result);
     return static_cast<bool>(visitor.validate(json));
   }
 
@@ -90,7 +140,7 @@ public:
    */
   template <MutableAdapter A> bool validate(A const & json, ValidationResult * result = nullptr) {
     detail::OnBlockExit const _ = [&result, this]() { post_process(result); };
-    ValidationVisitor visitor(schema_, json, cfg_, regex_, extension_, result);
+    ValidationVisitor visitor(schema_, json, cfg_, regex_, format_, extension_, result);
     return static_cast<bool>(visitor.validate(json));
   }
 

tests/CMakeLists.txt

@@ -11,6 +11,13 @@ find_package(CURL REQUIRED)
 # ICU components = data, i18n, io, le, lx, test, tu and uc.
 find_package(ICU 77.1 COMPONENTS uc i18n)
 
+FetchContent_Declare(
+  IDNA
+  GIT_REPOSITORY https://github.com/ada-url/idna.git
+  GIT_TAG        0.5.0
+)
+FetchContent_MakeAvailable(IDNA)
+
 FetchContent_Declare(
   json_schema_test_suite
   GIT_REPOSITORY https://github.com/json-schema-org/JSON-Schema-Test-Suite.git
@@ -60,6 +67,13 @@ foreach(CASE IN LISTS JVALIDATE_TESTS)
   else()
     target_compile_definitions(${CASE} PUBLIC JVALIDATE_HAS_ICU=0)
   endif()
+
+  if (idna_POPULATED)
+    target_compile_definitions(${CASE} PUBLIC JVALIDATE_HAS_IDNA=1)
+    target_link_libraries(${CASE} ada-idna)
+  else()
+    target_compile_definitions(${CASE} PUBLIC JVALIDATE_HAS_IDNA=0)
+  endif()
 endforeach()
 
 string(
@@ -68,7 +82,6 @@ string(
   "*optional_content"
   "*optional_*ecmascript_regex"
   "*optional_zeroTerminatedFloats"
-  "*optional_format*"
 )
 set(SelfValidateTest_Unsupported_Suites "")
 set(SelfValidateTest_Unsupported_Cases "*leap second")
@@ -80,6 +93,25 @@ if (NOT ICU_FOUND)
   )
 endif()
 
+if (NOT idna_POPULATED)
+  string(
+    APPEND SelfValidateTest_Unsupported
+    ":*optional_*iri*"
+    ":*optional_*idn*"
+    ":*optional_*uri_template*"
+  )
+  string(
+    APPEND SelfValidateTest_Unsupported_Suites
+    ":*punycode*"
+    ":*puny-code"
+  )
+  string(
+    APPEND SelfValidateTest_Unsupported_Cases
+    ":*punycode*"
+    ":*puny-code"
+  )
+endif()
+
 foreach(CASE IN LISTS JVALIDATE_UNIT_TESTS)
   gtest_discover_tests(${CASE})
 endforeach()

tests/json_schema_test_suite.h

@@ -65,17 +65,18 @@ static auto const SchemaTestName = [](auto const & info) {
   return name;
 };
 
-MATCHER_P(ValidatesAgainst, schema, "") {
+MATCHER_P2(ValidatesAgainst, schema, format, "") {
   jvalidate::ValidationResult result;
-  bool valid = jvalidate::Validator(schema).validate(arg, &result);
+  bool valid = jvalidate::Validator(schema, {.validate_format = format}).validate(arg, &result);
   *result_listener << result;
   return valid;
 }
 
 template <typename T>
-testing::Matcher<T> ValidatesAgainst(jvalidate::Schema const & schema, T const & test) {
+testing::Matcher<T> ValidatesAgainst(jvalidate::Schema const & schema, T const & test,
+                                     bool format) {
   if (not jvalidate::adapter::AdapterFor<T const>(test)["valid"].as_boolean()) {
-    return testing::Not(ValidatesAgainst(std::cref(schema)));
+    return testing::Not(ValidatesAgainst(std::cref(schema), format));
   }
-  return ValidatesAgainst(std::cref(schema));
+  return ValidatesAgainst(std::cref(schema), format);
 }

tests/selfvalidate_test.cxx

@@ -104,6 +104,7 @@ TEST_P(JsonSchemaTest, TestSuite) {
   std::string error;
   EXPECT_TRUE(load_file(file, spec, error)) << error;
 
+  bool is_format = file.string().find("optional/format") != std::string::npos;
   for (auto const & suite : spec) {
     if (skip_suite(suite["description"].asString())) {
       continue;
@@ -118,7 +119,7 @@ TEST_P(JsonSchemaTest, TestSuite) {
         try {
           std::cout << "\033[0;32m[ CASE     ] \033[0;0m    " << test["description"].asString()
                     << "\n";
-          EXPECT_THAT(test["data"], ValidatesAgainst(schema, test)) << suite["schema"];
+          EXPECT_THAT(test["data"], ValidatesAgainst(schema, test, is_format)) << suite["schema"];
         } catch (std::exception const & ex) { ADD_FAILURE() << ex.what() << "\n" << test; }
       }
     } catch (std::exception const & ex) {

tests/validation_visitor_test.cxx

@@ -35,7 +35,7 @@ protected:
   auto visit(jvalidate::detail::Pointer ptr, auto const & cons, Json::Value const & json,
              jvalidate::ValidationResult * result = nullptr, bool annotate_everything = false) {
     JsonCppAdapter const adapter(json);
-    ValidationVisitor visitor(node_, adapter, cfg_, regex_, extension_, result);
+    ValidationVisitor visitor(node_, adapter, cfg_, regex_, format_, extension_, result);
     if (annotate_everything) {
       visitor.tracking_ = StoreResults::ForAnything;
     }
@@ -49,10 +49,14 @@ protected:
   }
 
   void config(jvalidate::ValidationConfig cfg) { cfg_ = cfg; }
+  void format(FormatValidator::UserDefinedFormats && fmts) {
+    format_ = {std::move(fmts), jvalidate::StdRegexEngine::is_regex};
+  }
 
 private:
   jvalidate::schema::Node node_;
   jvalidate::StdRegexEngine regex_;
+  jvalidate::FormatValidator format_{jvalidate::StdRegexEngine::is_regex};
   jvalidate::ValidationConfig cfg_;
   jvalidate::detail::StubExtensionVisitor extension_;
 };
@@ -123,13 +127,24 @@ TEST_F(ValidationVisitorTest, EnumConstraintAnnotatesMatchingIndex) {
   EXPECT_THAT(result, ErrorAt("enum", "1"));
 }
 
+TEST_F(ValidationVisitorTest, UnknownFormatIsAccept) {
+  constraint::FormatConstraint cons{
+      .format = "bogus", .for_version = Draft2020_12, .is_assertion = true};
+  config({.validate_format = true});
+
+  ValidationResult result;
+  EXPECT_THAT(visit("/format"_jptr, cons, "\"Hello\""_json, &result), Eq(Status::Accept));
+}
+
 TEST_F(ValidationVisitorTest, UnimplementedFormatIsError) {
-  constraint::FormatConstraint cons{.format = "bogus", .is_assertion = true};
+  constraint::FormatConstraint cons{
+      .format = "bogus", .for_version = Draft2020_12, .is_assertion = true};
   config({.validate_format = true});
+  format({{"bogus", nullptr}});
 
   ValidationResult result;
   EXPECT_THAT(visit("/format"_jptr, cons, "\"Hello\""_json, &result), Eq(Status::Reject));
-  EXPECT_THAT(result, ErrorAt("format", "bogus is unimplemented"));
+  EXPECT_THAT(result, ErrorAt("format", "unimplemented format 'bogus'"));
 }
 }