fast_json-schema 0.1.0

data/ext/fast_json/schema/formats/utils/uri_template_parser.c

@@ -0,0 +1,235 @@
+#include "formats/utils/uri_template_parser.h"
+#include "formats/utils/utf8.h"
+
+#include <stdbool.h>
+
+#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
+#define IS_ALPHA(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
+#define IS_HEX(c)   (IS_DIGIT(c) || ((c) >= 'A' && (c) <= 'F') || ((c) >= 'a' && (c) <= 'f'))
+
+/*
+* varchar per RFC 6570 section 2.3:
+*   ALPHA / DIGIT / "_"
+* (pct-encoded handled separately).
+*/
+static bool is_varchar_ascii(unsigned char c) {
+  return IS_ALPHA(c) || IS_DIGIT(c) || c == '_';
+}
+
+/*
+* Operator per RFC 6570 section 2.2:
+*   op-level2  = "+" / "#"
+*   op-level3  = "." / "/" / ";" / "?" / "&"
+*   op-reserve = "=" / "," / "!" / "@" / "|"
+*/
+static bool is_operator(unsigned char c) {
+  switch(c) {
+    case '+': case '#':
+    case '.': case '/': case ';': case '?': case '&':
+    case '=': case ',': case '!': case '@': case '|':
+      return true;
+  }
+  return false;
+}
+
+/*
+* Literal ASCII per RFC 6570 section 2.1:
+*   %x21 / %x23-24 / %x26 / %x28-3B / %x3D / %x3F-5B / %x5D / %x5F / %x61-7A / %x7E
+*
+* That is: any printable ASCII except SP, control chars, DEL, and the set
+* { '"' '%' '\'' '<' '>' '\\' '^' '`' '{' '|' '}' }.
+* ('%' is allowed only as the start of a pct-encoded triple.)
+*/
+static bool is_literal_ascii(unsigned char c) {
+  if(c == 0x21) return true;                       // "!"
+  if(c >= 0x23 && c <= 0x24) return true;          // "#" "$"
+  if(c == 0x26) return true;                       // "&"
+  if(c >= 0x28 && c <= 0x3B) return true;          // "(" .. ";"
+  if(c == 0x3D) return true;                       // "="
+  if(c >= 0x3F && c <= 0x5B) return true;          // "?" .. "["
+  if(c == 0x5D) return true;                       // "]"
+  if(c == 0x5F) return true;                       // "_"
+  if(c >= 0x61 && c <= 0x7A) return true;          // "a" .. "z"
+  if(c == 0x7E) return true;                       // "~"
+  return false;
+}
+
+/*
+* pct-encoded per RFC 3986 section 2.1: "%" HEXDIG HEXDIG.
+* Returns 3 on success, 0 on failure.
+*/
+static long consume_pct_encoded(const char *s, long len) {
+  if(len < 3 || s[0] != '%') return 0;
+  if(!IS_HEX((unsigned char)s[1]) || !IS_HEX((unsigned char)s[2])) return 0;
+  return 3;
+}
+
+/*
+* Consume one literal unit: literal ASCII byte, pct-encoded triple, or
+* valid UTF-8 multi-byte sequence. Returns bytes consumed, or 0 on failure.
+*/
+static long consume_literal_byte(const char *s, long len) {
+  unsigned char c = (unsigned char)s[0];
+
+  if(c < 0x80) {
+    if(c == '%') return consume_pct_encoded(s, len);
+    return is_literal_ascii(c) ? 1 : 0;
+  }
+
+  long n = utf8_seq_len((const unsigned char *)s, len);
+  return n >= 2 ? n : 0;
+}
+
+/*
+* Consume a run of literals (1+ bytes) until "{" or an invalid byte.
+* Returns bytes consumed (must be > 0).
+*/
+static long parse_literals_run(const char *s, long len) {
+  long pos = 0;
+  while(pos < len && s[pos] != '{') {
+    long n = consume_literal_byte(s + pos, len - pos);
+    if(n == 0) return 0;
+    pos += n;
+  }
+  return pos;
+}
+
+/*
+* Consume one varchar: ALPHA / DIGIT / "_" / pct-encoded per RFC 6570 section 2.3.
+* Returns bytes consumed (1 or 3), or 0 on failure.
+*/
+static long parse_varchar(const char *s, long len) {
+  if(len == 0) return 0;
+  unsigned char c = (unsigned char)s[0];
+
+  if(c == '%') return consume_pct_encoded(s, len);
+  if(is_varchar_ascii(c)) return 1;
+  return 0;
+}
+
+/*
+* varname per RFC 6570 section 2.3:
+*   varchar *( ["."] varchar )
+* Dots are optional separators between varchars (no leading/trailing dot,
+* no consecutive dots).
+*/
+static long parse_varname(const char *s, long len) {
+  long first = parse_varchar(s, len);
+  if(first == 0) return 0;
+
+  long pos = first;
+
+  while(pos < len) {
+    if(s[pos] == '.') {
+      long n = parse_varchar(s + pos + 1, len - pos - 1);
+      if(n == 0) return 0;  // trailing dot or no varchar after dot
+      pos += 1 + n;
+      continue;
+    }
+    long n = parse_varchar(s + pos, len - pos);
+    if(n == 0) break;
+    pos += n;
+  }
+
+  return pos;
+}
+
+/*
+* modifier-level4 per RFC 6570 section 2.4:
+*   prefix = ":" max-length     ; max-length = %x31-39 0*3DIGIT (1..9999)
+*   explode = "*"
+* Caller must only invoke this when s[0] is ':' or '*'.
+* Returns bytes consumed, or 0 on failure.
+*/
+static long parse_modifier(const char *s, long len) {
+  if(len == 0) return 0;
+
+  if(s[0] == '*') return 1;
+
+  if(s[0] == ':') {
+    if(len < 2) return 0;
+    unsigned char first = (unsigned char)s[1];
+    if(first < '1' || first > '9') return 0;
+
+    long pos = 2;
+    while(pos < len && IS_DIGIT((unsigned char)s[pos])) pos++;
+
+    long digits = pos - 1;
+    if(digits < 1 || digits > 4) return 0;
+    return pos;
+  }
+
+  return 0;
+}
+
+/*
+* varspec per RFC 6570 section 2.3:
+*   varname [ modifier-level4 ]
+*/
+static long parse_varspec(const char *s, long len) {
+  long n = parse_varname(s, len);
+  if(n == 0) return 0;
+
+  long pos = n;
+  if(pos < len && (s[pos] == ':' || s[pos] == '*')) {
+    long m = parse_modifier(s + pos, len - pos);
+    if(m == 0) return 0;
+    pos += m;
+  }
+  return pos;
+}
+
+/*
+* variable-list per RFC 6570 section 2.3:
+*   varspec *( "," varspec )
+*/
+static long parse_variable_list(const char *s, long len) {
+  long n = parse_varspec(s, len);
+  if(n == 0) return 0;
+
+  long pos = n;
+  while(pos < len && s[pos] == ',') {
+    long m = parse_varspec(s + pos + 1, len - pos - 1);
+    if(m == 0) return 0;
+    pos += 1 + m;
+  }
+  return pos;
+}
+
+/*
+* expression per RFC 6570 section 2.2:
+*   "{" [ operator ] variable-list "}"
+* Returns bytes consumed (including braces), or 0 on failure.
+*/
+static long parse_expression(const char *s, long len) {
+  if(len < 2 || s[0] != '{') return 0;
+
+  long pos = 1;
+
+  if(pos < len && is_operator((unsigned char)s[pos])) pos++;
+
+  long vl = parse_variable_list(s + pos, len - pos);
+  if(vl == 0) return 0;
+  pos += vl;
+
+  if(pos >= len || s[pos] != '}') return 0;
+  return pos + 1;
+}
+
+bool parse_uri_template(const char *s, long len) {
+  long pos = 0;
+
+  while(pos < len) {
+    if(s[pos] == '{') {
+      long n = parse_expression(s + pos, len - pos);
+      if(n == 0) return false;
+      pos += n;
+    } else {
+      long n = parse_literals_run(s + pos, len - pos);
+      if(n == 0) return false;
+      pos += n;
+    }
+  }
+
+  return true;
+}

data/ext/fast_json/schema/formats/utils/uri_template_parser.h

@@ -0,0 +1,18 @@
+#ifndef FAST_JSON_FORMATS_UTILS_URI_TEMPLATE_PARSER_H
+#define FAST_JSON_FORMATS_UTILS_URI_TEMPLATE_PARSER_H
+
+#include <stdbool.h>
+
+/*
+* RFC 6570 URI Template parser.
+*
+* A URI Template is *( literals / expression ). Literals accept any valid
+* UTF-8 (ucschar / iprivate) plus pct-encoded; expressions are ASCII-only:
+*   "{" [ operator ] variable-list "}"
+*
+* Returns true if the entire input is a well-formed URI Template. The empty
+* string is valid (zero repetitions of literals/expression).
+*/
+bool parse_uri_template(const char *s, long len);
+
+#endif

data/ext/fast_json/schema/formats/utils/utf8.c

@@ -0,0 +1,73 @@
+#include "formats/utils/utf8.h"
+
+/* Continuation-byte range (RFC 3629). */
+#define UTF8_CONT_MIN         0x80   /* 1000 0000 */
+#define UTF8_CONT_MAX         0xBF   /* 1011 1111 */
+
+/* ASCII upper bound. */
+#define UTF8_ASCII_MAX        0x7F   /* 0111 1111 */
+
+/* Valid lead-byte ranges per sequence length. */
+#define UTF8_LEAD2_MIN        0xC2   /* 1100 0010 */
+#define UTF8_LEAD2_MAX        0xDF   /* 1101 1111 */
+#define UTF8_LEAD3_MIN        0xE0   /* 1110 0000 */
+#define UTF8_LEAD3_MAX        0xEF   /* 1110 1111 */
+#define UTF8_LEAD4_MIN        0xF0   /* 1111 0000 */
+#define UTF8_LEAD4_MAX        0xF4   /* 1111 0100 */
+
+/* Lead byte triggering byte-2 anti-surrogate tightening (U+D800..U+DFFF). */
+#define UTF8_LEAD3_SURROGATE  0xED   /* 1110 1101 */
+
+/* Tightened byte-2 bounds for irregular lead bytes. */
+#define UTF8_E0_BYTE2_MIN     0xA0   /* 1010 0000 */
+#define UTF8_ED_BYTE2_MAX     0x9F   /* 1001 1111 */
+#define UTF8_F0_BYTE2_MIN     0x90   /* 1001 0000 */
+#define UTF8_F4_BYTE2_MAX     0x8F   /* 1000 1111 */
+
+long utf8_seq_len(const unsigned char *s, long remaining) {
+  if(remaining < 1) return 0;
+
+  unsigned char first_byte = s[0];
+
+  if(first_byte <= UTF8_ASCII_MAX) return 1;
+
+  if(first_byte < UTF8_LEAD2_MIN) return 0;
+
+  if(first_byte <= UTF8_LEAD2_MAX) {
+    if(remaining < 2) return 0;
+    if(s[1] < UTF8_CONT_MIN || s[1] > UTF8_CONT_MAX) return 0;
+
+    return 2;
+  }
+
+  if(first_byte <= UTF8_LEAD3_MAX) {
+    if(remaining < 3) return 0;
+
+    unsigned char low = UTF8_CONT_MIN, high = UTF8_CONT_MAX;
+
+    if(first_byte == UTF8_LEAD3_MIN) low = UTF8_E0_BYTE2_MIN;        /* anti-overlong */
+    if(first_byte == UTF8_LEAD3_SURROGATE) high = UTF8_ED_BYTE2_MAX; /* anti-surrogate */
+
+    if(s[1] < low || s[1] > high) return 0;
+    if(s[2] < UTF8_CONT_MIN || s[2] > UTF8_CONT_MAX) return 0;
+
+    return 3;
+  }
+
+  if(first_byte <= UTF8_LEAD4_MAX) {
+    if(remaining < 4) return 0;
+
+    unsigned char low = UTF8_CONT_MIN, high = UTF8_CONT_MAX;
+
+    if(first_byte == UTF8_LEAD4_MIN) low = UTF8_F0_BYTE2_MIN;  /* anti-overlong */
+    if(first_byte == UTF8_LEAD4_MAX) high = UTF8_F4_BYTE2_MAX; /* anti-codepoint > U+10FFFF */
+
+    if(s[1] < low || s[1] > high) return 0;
+    if(s[2] < UTF8_CONT_MIN || s[2] > UTF8_CONT_MAX) return 0;
+    if(s[3] < UTF8_CONT_MIN || s[3] > UTF8_CONT_MAX) return 0;
+
+    return 4;
+  }
+
+  return 0;
+}

data/ext/fast_json/schema/formats/utils/utf8.h

@@ -0,0 +1,17 @@
+#ifndef FAST_JSON_FORMATS_UTILS_UTF8_H
+#define FAST_JSON_FORMATS_UTILS_UTF8_H
+
+#include <stdbool.h>
+
+/*
+* Strict UTF-8 sequence validator. Given a pointer to the leading byte of a
+* UTF-8 character, returns the byte length (1..4) of a valid UTF-8 sequence
+* starting at that position, or 0 if the bytes do not form a valid sequence.
+*
+* Returns 1 for any ASCII byte (< 0x80). Returns 2..4 for valid multi-byte
+* sequences. Rejects overlong encodings, UTF-16 surrogates (U+D800..U+DFFF)
+* and codepoints above U+10FFFF.
+*/
+long utf8_seq_len(const unsigned char *s, long remaining);
+
+#endif

data/ext/fast_json/schema/if.c

@@ -0,0 +1,31 @@
+#include "if.h"
+#include "error.h"
+
+extern bool is_valid(VALUE, CompiledSchema *, VALUE, Context *);
+
+static void run_then(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  bool valid = is_valid(schema, compiled_schema, data, context);
+
+  if(!valid)
+    yield_error(compiled_schema, data, context, "if/then");
+}
+
+static void run_else(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  bool valid = is_valid(schema, compiled_schema, data, context);
+
+  if(!valid)
+    yield_error(compiled_schema, data, context, "if/else");
+}
+
+void validate_if(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(compiled_schema->then_schema == NULL && compiled_schema->else_schema == NULL)
+    return;
+
+  bool valid = is_valid(schema, compiled_schema->if_schema, data, context);
+
+  if(valid && compiled_schema->then_schema != NULL) {
+    run_then(schema, compiled_schema->then_schema, data, context);
+  } else if(!valid && compiled_schema->else_schema != NULL) {
+    run_else(schema, compiled_schema->else_schema, data, context);
+  }
+}

data/ext/fast_json/schema/if.h

@@ -0,0 +1,4 @@
+#include <ruby.h>
+#include "compiled_schema.h"
+
+void validate_if(VALUE, CompiledSchema *, VALUE, Context *);

data/ext/fast_json/schema/is_valid.c

@@ -0,0 +1,124 @@
+#include "is_valid.h"
+
+VALUE short_circuit_tag;
+
+struct is_valid_args_memo_S {
+  VALUE schema;
+  CompiledSchema *compiled_schema;
+  VALUE data;
+  Context *context;
+};
+
+struct ensure_args_memo_S {
+  Context *context;
+  bool prev_short_circuit;
+};
+
+static VALUE is_valid_body(RB_BLOCK_CALL_FUNC_ARGLIST(_tag, arg)) {
+  struct is_valid_args_memo_S *args = (struct is_valid_args_memo_S *)arg;
+
+  args->compiled_schema->validation_function(
+    args->schema, args->compiled_schema, args->data, args->context
+  );
+
+  return Qtrue;
+}
+
+static VALUE is_valid_catch(VALUE arg) {
+  return rb_catch_obj(short_circuit_tag, is_valid_body, arg);
+}
+
+static VALUE is_valid_ensure(VALUE arg) {
+  struct ensure_args_memo_S *ensure_args = (struct ensure_args_memo_S *)arg;
+
+  ensure_args->context->short_circuit_on_error = ensure_args->prev_short_circuit;
+
+  return Qnil;
+}
+
+/*
+ * `is_valid` runs the given compiled schema against the given data and
+ * reports whether the data validates, without yielding any error to the
+ * user. It is the entry point used by every combinator that needs a
+ * pure pass/fail answer about a sub-schema: `anyOf`, `oneOf`, `allOf`,
+ * `not`, `if`, and the array `contains` keyword.
+ *
+ * Why short-circuiting matters
+ * ----------------------------
+ * Validation is normally driven by side effects: when a constraint is
+ * violated, `yield_error` builds an `Error` and yields it to the user
+ * block. Combinators don't want that. As soon as `anyOf` (for example)
+ * sees the *first* failure inside a branch, it knows that branch is
+ * invalid and wants to abandon it immediately, no matter how deeply
+ * nested the failing constraint is. Letting validation run to completion
+ * to discover the failure would also leak the branch's internal errors
+ * to the user, which is wrong.
+ *
+ * How the short-circuit works
+ * ---------------------------
+ * Two pieces of state cooperate:
+ *
+ *   1. `context->short_circuit_on_error` (a `bool`) tells `yield_error`
+ *      whether it should yield (the default, top-level behavior) or
+ *      short-circuit (when an `is_valid` frame is active). The flag is
+ *      set to `true` here on entry and restored to its prior value on
+ *      exit, regardless of how the body unwinds.
+ *
+ *   2. `short_circuit_tag` (a unique frozen `Object.new` allocated in
+ *      `Init_validate`) is the tag we use with Ruby's `throw`/`catch`
+ *      mechanism. When `yield_error` is reached with the flag set, it
+ *      calls `rb_throw_obj(short_circuit_tag, Qfalse)`, which Ruby's
+ *      VM unwinds up to the matching `rb_catch_obj` registered below.
+ *
+ * Why throw/catch instead of setjmp/longjmp
+ * -----------------------------------------
+ * An earlier implementation used `RUBY_SETJMP`/`RUBY_LONGJMP` to escape
+ * out of nested validation. That worked on Ruby 2.x, but in Ruby 3.x it
+ * corrupts VM state when the jump crosses Ruby callbacks like
+ * `rb_funcall`, `rb_reg_match`, `rb_yield`, or `rb_hash_foreach`: those
+ * functions register frame and iteration bookkeeping that `longjmp`
+ * skips over, leaving the VM and GC in an inconsistent state and
+ * eventually segfaulting. `rb_throw_obj` performs the same logical
+ * non-local exit but uses the VM's own unwind machinery, which closes
+ * frames cleanly, releases hash iteration state, and runs intervening
+ * `ensure` blocks.
+ *
+ * Why we still need `rb_ensure`
+ * -----------------------------
+ * `rb_catch_obj` only intercepts throws matching its tag. A real Ruby
+ * exception -- e.g. the `RuntimeError` raised by `INCR_CONTEXT` when
+ * the document exceeds `MAX_CONTEXT_DEPTH`, or a user `raise` from
+ * inside the validate block -- is not a throw; it propagates straight
+ * through. We wrap the catch in `rb_ensure` so that even when an
+ * exception escapes, the ensure callback restores
+ * `short_circuit_on_error` to its prior value before unwinding
+ * continues. Without that, an active `is_valid` frame interrupted by
+ * a real exception would leave the flag stuck at `true`, silently
+ * breaking subsequent validations that share the same context.
+ *
+ * Nesting
+ * -------
+ * Combinators routinely nest (e.g. `anyOf` containing `oneOf`
+ * containing `allOf`). Saving and restoring the flag around each
+ * `is_valid` call, combined with `rb_catch_obj`'s LIFO semantics
+ * (each throw is caught by the nearest matching catch), gives correct
+ * behavior at any depth: an inner short-circuit unwinds only to the
+ * inner catch, leaving the outer combinator free to continue
+ * iterating its remaining branches with the flag still set.
+ */
+bool is_valid(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  struct is_valid_args_memo_S is_valid_args = { schema, compiled_schema, data, context };
+  struct ensure_args_memo_S ensure_args = { context, context->short_circuit_on_error };
+
+  context->short_circuit_on_error = true;
+
+  VALUE result = rb_ensure(is_valid_catch, (VALUE)&is_valid_args, is_valid_ensure, (VALUE)&ensure_args);
+
+  return result == Qtrue;
+}
+
+void Init_is_valid(void) {
+  short_circuit_tag = rb_obj_freeze(rb_class_new_instance(0, NULL, rb_cObject));
+
+  rb_gc_register_address(&short_circuit_tag);
+}

data/ext/fast_json/schema/is_valid.h

@@ -0,0 +1,6 @@
+#include <ruby.h>
+#include "compiled_schema.h"
+#include "types/context.h"
+
+extern VALUE short_circuit_tag;
+void Init_is_valid(void);