teptris 0.3.22.0 → 0.3.23.0

data/ext/teptris_ext/engine/src/teptris/schema/schema_internal.h

@@ -19,9 +19,10 @@ enum {
     ST_NUMBER = 1 << 2, /* float or integer */
     ST_BOOLEAN = 1 << 3,
     ST_OBJECT = 1 << 4,
-    ST_ARRAY = 1 << 5
+    ST_ARRAY = 1 << 5,
+    ST_NULL = 1 << 6 /* the JSON null type (policy 1: no TOML value) */
 };
-#define ST_ANY 0x3Fu
+#define ST_ANY 0x7Fu
 
 enum {
     FMT_NONE = 0,
@@ -109,11 +110,25 @@ struct sch_node {
     sch_node *uneval_props; /* unevaluatedProperties: frame-local */
     sch_node *uneval_items; /* unevaluatedItems: frame-local */
     sch_node *content_schema; /* contentSchema: asserts decoded content */
+    /* the dynamic anchors inside this node's own subtree (self
+     * included, document order): pushed as one scope frame whenever
+     * this node is applied — the dynamic scope grows per entered
+     * subschema, not per traversed anchor */
+    struct sch_scope_entry {
+        const char *name;
+        struct sch_node *node;
+        const jv *res; /* the anchor's own resource (nearest $id) */
+    } *self_scope;
+    size_t n_self_scope;
+    const jv *res_id;             /* the resource root this node sits in */
+    bool dynamic_recursive;       /* the ref site was a $recursiveRef */
     const char *dynamic_anchor;   /* $dynamicAnchor name carried here */
-    const char *recursive_anchor; /* "$" when $recursiveAnchor is true */
+    const char *recursive_anchor; /* "" when $recursiveAnchor is true */
     const char *dynamic_ref;      /* "#name" fragment for
                                    * $dynamicRef / $recursiveRef */
     sch_node *dynamic_ref_target; /* compile-resolved static fallback */
+    bool ref_only;  /* draft-07-and-older: this $ref ignores siblings */
+    bool enum_empty; /* "enum": [] matches nothing */
     sch_node *contains;
     long min_contains, max_contains;
     bool has_contains, has_min_contains, has_max_contains;
@@ -158,6 +173,8 @@ struct teptris_schema {
     char err[256];
 };
 
+typedef struct teptris_resource teptris_resource;
+
 typedef struct {
     teptris_arena *a;
     jv *root;
@@ -168,26 +185,76 @@ typedef struct {
         bool in_progress;
     } *memo;
     size_t n_memo, cap_memo;
+    /* pointer-keyed hash over the memo (compile is O(n), not O(n^2)):
+     * open addressing, slot = entry index + 1, 0 = empty */
+    uint32_t *memo_hash;
+    size_t memo_hash_cap; /* power of two, 0 = absent */
+    /* the same treatment for the per-node base table */
+    uint32_t *node_base_hash;
+    size_t node_base_hash_cap;
     /* dependency-list capacities (grow-in-place across keywords) */
     size_t cap_dep_req, cap_dep_schemas;
-    /* anchors: "$anchor": name -> subtree */
+    /* anchors: "$anchor": name -> subtree (doc-wide; the $anchor
+     * space of every loaded resource joins it) */
     struct {
         const char *name;
         jv *target;
     } *anchors;
     size_t n_anchors, cap_anchors;
-    /* $dynamicAnchor / $recursiveAnchor:true targets (the static
-     * fallback for $dynamicRef / $recursiveRef) */
+    /* $dynamicAnchor targets (the static fallback for $dynamicRef) */
     struct {
         const char *name;
         jv *target;
     } *dyn_anchors;
     size_t n_dyn_anchors, cap_dyn_anchors;
     jv *rec_anchor_target;
+    /* the resource model: every base URI this compile has materialized */
+    teptris_resource *resources;
+    size_t n_resources, cap_resources;
+    /* the resource the walk is currently inside */
+    jv *cur_root;        /* its root jv ("#" resolves here) */
+    const char *cur_abs; /* its base URI (NULL in local-only mode) */
+    const char *cur_dir; /* its fs dir (relative refs join against it) */
+    bool ref_exclusive;  /* draft-07-and-older: $ref ignores siblings */
+    char base_dir[1024]; /* fs dir of the main schema ("" = none) */
+    /* the base every node was pre-passed with: compile looks each
+     * node's base up here (pointers reach subtrees whose $id chain
+     * the document walk would otherwise miss) */
+    /* scratch accumulator for attach_self_scope */
+    struct sch_scope_entry *entry_acc;
+    size_t n_entry_acc, cap_entry_acc;
+    /* which standard vocabularies the dialect keeps (8.1.2: a custom
+     * metaschema's $vocabulary decides; absent = all of them) */
+    unsigned vocab_mask;
+    /* standard vocabulary gates (the core vocabulary is mandatory and
+ * never gated) */
+#define TEPTRIS_VOC_APPLICATOR 1u
+#define TEPTRIS_VOC_UNEVALUATED 2u
+#define TEPTRIS_VOC_VALIDATION 4u
+#define TEPTRIS_VOC_FORMAT 8u
+#define TEPTRIS_VOC_CONTENT 16u
+#define TEPTRIS_VOC_ALL 31u
+
+struct node_base {
+        const jv *node;
+        const char *abs;
+        const char *dir;
+        jv *root;
+        bool recursive;
+    } *node_bases;
+    size_t n_node_bases, cap_node_bases;
     char *err;
     size_t err_cap;
 } sctx;
 
+/* a materialized resource: a base URI naming a jv subtree */
+struct teptris_resource {
+    const char *abs; /* base URI (file://... or empty for local-only) */
+    jv *root;        /* the resource's root jv ("#" resolves here) */
+    sch_node *node;  /* compiled root (memo-resolved) */
+    bool recursive_anchor; /* $recursiveAnchor: true on the root */
+};
+
 /* the tagged value the validator walks: converted from a document's
  * DOM once per validate call, or synthesized (schema-side enum/const
  * values, propertyNames strings) */
@@ -231,6 +298,9 @@ sch_node *sch_resolve_pointer(sctx *c, const char *pointer);
  * with |mant| < 10^18; false for non-finite d */
 bool sch_decimal_of_double(double d, int64_t *mant, int *exp);
 
+/* refs.c: the resource loader used by $ref resolution */
+jv *sch_load_resource(sctx *c, const char *abs_uri);
+
 /* formats.c */
 /* the string-side format battery (the taplo parity set); datetimes
  * reach it through their canonical text like any other string */

data/ext/teptris_ext/engine/src/teptris/schema/validate.c

@@ -43,11 +43,17 @@ typedef struct {
         size_t n_idx, cap_idx;
     } *frames;
     int n_frames, cap_frames;
-    /* dynamic-scope stack for $dynamicRef / $recursiveRef: the
-     * innermost anchor on the evaluation path wins */
+    /* dynamic-scope stack for $dynamicRef / $recursiveRef: one frame
+     * per applied schema object, in evaluation order. Each entry
+     * names its anchor and the frame owner (the applied object), so
+     * resolution walks RESOURCES outermost-first (2020-12 8.2.3.2:
+     * the outermost resource in the dynamic scope that defines the
+     * fragment wins, its first anchor in document order) */
     struct dyn_scope {
         const char *name;
         sch_node *node;
+        const jv *res;    /* the anchor's resource (nearest $id) */
+        sch_node *owner;  /* the applied object that entered it */
     } *scopes;
     int n_scopes, cap_scopes;
 } vctx;
@@ -313,8 +319,9 @@ static void frames_free(vctx *vc) {
 
 /* ------------------------------------------------- dynamic scopes -- */
 
-static bool scope_push(vctx *vc, const char *name, sch_node *node) {
-    if (name == NULL || node == NULL) return true;
+static bool scope_push(vctx *vc, const char *name, sch_node *node,
+                       const jv *res, sch_node *owner) {
+    if (name == NULL || node == NULL || owner == NULL) return true;
     if (vc->n_scopes == vc->cap_scopes) {
         vc->cap_scopes = vc->cap_scopes == 0 ? 16 : vc->cap_scopes * 2;
         void *ns = realloc(vc->scopes, vc->cap_scopes * sizeof(*vc->scopes));
@@ -323,14 +330,47 @@ static bool scope_push(vctx *vc, const char *name, sch_node *node) {
     }
     vc->scopes[vc->n_scopes].name = name;
     vc->scopes[vc->n_scopes].node = node;
+    vc->scopes[vc->n_scopes].res = res;
+    vc->scopes[vc->n_scopes].owner = owner;
     vc->n_scopes++;
     return true;
 }
 
-/* the innermost dynamic anchor for a name on the evaluation path */
+/* 2020-12 $dynamicRef: walk the RESOURCES of the evaluation path
+ * outermost-first (the resource of each applied object, in frame
+ * order); the first resource that DEFINES an identically-named
+ * $dynamicAnchor — the anchor's nearest-$id resource anywhere in the
+ * stack — wins, and its first matching anchor in document order is
+ * the target (2020-12 8.2.3.2 + appendix C) */
 static sch_node *scope_resolve(vctx *vc, const char *name) {
-    for (int i = vc->n_scopes - 1; i >= 0; i--) {
-        if (strcmp(vc->scopes[i].name, name) == 0) return vc->scopes[i].node;
+    for (int i = 0; i < vc->n_scopes; i++) {
+        const jv *res = vc->scopes[i].owner->res_id;
+        bool seen = false;
+        for (int k = 0; k < i; k++) {
+            if (vc->scopes[k].owner->res_id == res) {
+                seen = true;
+                break;
+            }
+        }
+        if (seen) continue;
+        for (int j = 0; j < vc->n_scopes; j++) {
+            if (vc->scopes[j].res != res) continue;
+            if (strcmp(vc->scopes[j].name, name) == 0) {
+                return vc->scopes[j].node;
+            }
+        }
+    }
+    return NULL;
+}
+
+/* 2019-09 $recursiveRef: the first resource on the evaluation path
+ * (outermost first) whose ROOT carries $recursiveAnchor: true; the
+ * target is that resource's root */
+static sch_node *scope_resolve_recursive(vctx *vc) {
+    for (int i = 0; i < vc->n_scopes; i++) {
+        if (vc->scopes[i].owner->recursive_anchor != NULL) {
+            return vc->scopes[i].owner;
+        }
     }
     return NULL;
 }
@@ -346,6 +386,15 @@ static bool sv_equal(const sch_svalue *a, const sch_svalue *b) {
          * equals a datetime text */
         int ad = a->kind >= SV_DATETIME;
         int bd = b->kind >= SV_DATETIME;
+        /* numeric identity per JSON Schema: an integer and a float
+         * with the same value are equal (bools stay distinct - their
+         * kinds differ, so they never reach this branch) */
+        if ((a->kind == SV_INT || a->kind == SV_FLOAT) &&
+            (b->kind == SV_INT || b->kind == SV_FLOAT)) {
+            long double av = a->kind == SV_INT ? (long double)a->i : (long double)a->f;
+            long double bv = b->kind == SV_INT ? (long double)b->i : (long double)b->f;
+            return av == bv;
+        }
         if ((ad || bd) && (a->kind == SV_STRING || b->kind == SV_STRING)) {
             const sch_svalue *dt = ad ? a : b;
             const sch_svalue *st = ad ? b : a;
@@ -676,15 +725,31 @@ static int sv_to_st(const sch_svalue *v) {
     switch (v->kind) {
     case SV_STRING: return ST_STRING;
     case SV_INT: return ST_INTEGER | ST_NUMBER;
-    case SV_FLOAT: return ST_NUMBER;
+    case SV_FLOAT:
+        /* a float with a zero fractional part is an integer (the
+         * 2020-12 rule the suite tests) */
+        return (v->f == v->f && v->f != INFINITY && v->f != -INFINITY &&
+                v->f == (double)(int64_t)v->f)
+                   ? ST_INTEGER | ST_NUMBER
+                   : ST_NUMBER;
     case SV_BOOL: return ST_BOOLEAN;
     case SV_TABLE: return ST_OBJECT;
     case SV_ARRAY: return ST_ARRAY;
     case SV_DATETIME: case SV_DATE: case SV_TIME: return ST_STRING;
+    case SV_NULL: return ST_NULL;
     default: return 0;
     }
 }
 
+/* one application = one scope frame: every anchor inside the applied
+ * schema's own subtree is in scope below it, owned by this object */
+static void scope_frame_push(vctx *vc, sch_node *n) {
+    for (size_t i = 0; i < n->n_self_scope; i++) {
+        scope_push(vc, n->self_scope[i].name, n->self_scope[i].node,
+                   n->self_scope[i].res, n);
+    }
+}
+
 static void val(vctx *vc, sch_node *n, const sch_svalue *v) {
     if (n == NULL || v == NULL) return;
     if (vc->depth >= MAX_DEPTH) {
@@ -697,8 +762,7 @@ static void val(vctx *vc, sch_node *n, const sch_svalue *v) {
      * scope for the instance path below it */
     frame_push(vc, v);
     int scopes_base = vc->n_scopes;
-    scope_push(vc, n->dynamic_anchor, n);
-    scope_push(vc, n->recursive_anchor, n);
+    scope_frame_push(vc, n);
 
     /* a dynamic $ref resolves through the innermost scope entered on
      * the evaluation path; the compile-resolved target is the static
@@ -706,7 +770,8 @@ static void val(vctx *vc, sch_node *n, const sch_svalue *v) {
     if (n->dynamic_ref != NULL) {
         const char *name = n->dynamic_ref[0] == '#' ? n->dynamic_ref + 1
                                                     : n->dynamic_ref;
-        sch_node *target = scope_resolve(vc, name);
+        sch_node *target = n->dynamic_recursive ? scope_resolve_recursive(vc)
+                                                : scope_resolve(vc, name);
         if (target == NULL) target = n->dynamic_ref_target;
         if (target != NULL) {
             if (vc->ref_depth >= MAX_DEPTH) {
@@ -715,6 +780,7 @@ static void val(vctx *vc, sch_node *n, const sch_svalue *v) {
                 vc->ref_depth++;
                 spush(vc, "$dynamicRef");
                 val(vc, target, v);
+                vc->n_scopes = scopes_base;
                 spop(vc);
                 vc->ref_depth--;
             }
@@ -731,9 +797,16 @@ static void val(vctx *vc, sch_node *n, const sch_svalue *v) {
             vc->ref_depth++;
             spush(vc, "$ref");
             val(vc, n->ref, v);
+            vc->n_scopes = scopes_base;
             spop(vc);
             vc->ref_depth--;
         }
+        /* draft 07 and older: the $ref replaces every sibling */
+        if (n->ref_only) {
+            vc->n_scopes = scopes_base;
+            frame_pop(vc);
+            return;
+        }
     }
 
     if (n->is_false) {
@@ -767,6 +840,9 @@ static void val(vctx *vc, sch_node *n, const sch_svalue *v) {
             verr(vc, "value does not equal the constant");
         }
     }
+    if (n->enum_empty) {
+        verr(vc, "value does not match the empty enum (nothing matches)");
+    }
     if (n->n_enum > 0) {
         bool hit = false;
         for (size_t i = 0; i < n->n_enum && !hit; i++) {

data/lib/teptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Teptris
-  VERSION = "0.3.22.0"
+  VERSION = "0.3.23.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: teptris
 version: !ruby/object:Gem::Version
-  version: 0.3.22.0
+  version: 0.3.23.0
 platform: ruby
 authors:
 - teptris contributors
@@ -56,6 +56,10 @@ files:
 - ext/teptris_ext/engine/src/teptris/schema/formats.c
 - ext/teptris_ext/engine/src/teptris/schema/json_read.c
 - ext/teptris_ext/engine/src/teptris/schema/json_read.h
+- ext/teptris_ext/engine/src/teptris/schema/metaschemas.c
+- ext/teptris_ext/engine/src/teptris/schema/metaschemas.h
+- ext/teptris_ext/engine/src/teptris/schema/refs.c
+- ext/teptris_ext/engine/src/teptris/schema/refs.h
 - ext/teptris_ext/engine/src/teptris/schema/regex.c
 - ext/teptris_ext/engine/src/teptris/schema/regex.h
 - ext/teptris_ext/engine/src/teptris/schema/schema.c