fast_json-schema 0.1.0

data/ext/fast_json/schema/keywords.c

@@ -0,0 +1,220 @@
+#include "keywords.h"
+
+VALUE root_path_str;
+
+VALUE id_str,
+      ref_str,
+      recursiveAnchor_str,
+      recursiveRef_str;
+
+VALUE type_str,
+      const_str,
+      enum_str;
+
+VALUE if_str,
+      then_str,
+      else_str,
+      allOf_str,
+      anyOf_str,
+      oneOf_str,
+      not_str;
+
+// Integer and Number keywords
+VALUE multipleOf_str,
+      maximum_str,
+      exclusiveMaximum_str,
+      minimum_str,
+      exclusiveMinimum_str;
+
+// String keywords
+VALUE maxLength_str,
+      minLength_str,
+      pattern_str,
+      format_str;
+
+// Array keywords
+VALUE items_str,
+      additionalItems_str,
+      unevaluatedItems_str,
+      contains_str,
+      maxItems_str,
+      minItems_str,
+      uniqueItems_str,
+      maxContains_str,
+      minContains_str;
+
+// Object keywords
+VALUE properties_str,
+      patternProperties_str,
+      additionalProperties_str,
+      unevaluatedProperties_str,
+      propertyNames_str,
+      maxProperties_str,
+      minProperties_str,
+      required_str,
+      dependentRequired_str,
+      dependencies_str;
+
+VALUE object_str;
+
+VALUE known_keywords_hash;
+
+bool is_known_keyword(VALUE key) {
+  if(!RB_TYPE_P(key, T_STRING)) return false;
+
+  return rb_hash_lookup(known_keywords_hash, key) != Qnil;
+}
+
+void Init_keywords() {
+  root_path_str = rb_str_new_literal("#");
+
+  id_str = rb_str_new_literal("$id");
+  ref_str = rb_str_new_literal("$ref");
+  recursiveAnchor_str = rb_str_new_literal("$recursiveAnchor");
+  recursiveRef_str = rb_str_new_literal("$recursiveRef");
+
+  type_str = rb_str_new_literal("type");
+  const_str = rb_str_new_literal("const");
+  enum_str = rb_str_new_literal("enum");
+
+  if_str = rb_str_new_literal("if");
+  then_str = rb_str_new_literal("then");
+  else_str = rb_str_new_literal("else");
+  allOf_str = rb_str_new_literal("allOf");
+  anyOf_str = rb_str_new_literal("anyOf");
+  oneOf_str = rb_str_new_literal("oneOf");
+  not_str = rb_str_new_literal("not");
+
+  multipleOf_str = rb_str_new_literal("multipleOf");
+  maximum_str = rb_str_new_literal("maximum");
+  exclusiveMaximum_str = rb_str_new_literal("exclusiveMaximum");
+  minimum_str = rb_str_new_literal("minimum");
+  exclusiveMinimum_str = rb_str_new_literal("exclusiveMinimum");
+
+  maxLength_str = rb_str_new_literal("maxLength");
+  minLength_str = rb_str_new_literal("minLength");
+  pattern_str = rb_str_new_literal("pattern");
+  format_str = rb_str_new_literal("format");
+
+  items_str = rb_str_new_literal("items");
+  additionalItems_str = rb_str_new_literal("additionalItems");
+  unevaluatedItems_str = rb_str_new_literal("unevaluatedItems");
+  contains_str = rb_str_new_literal("contains");
+  maxItems_str = rb_str_new_literal("maxItems");
+  minItems_str = rb_str_new_literal("minItems");
+  uniqueItems_str = rb_str_new_literal("uniqueItems");
+  maxContains_str = rb_str_new_literal("maxContains");
+  minContains_str = rb_str_new_literal("minContains");
+
+  properties_str = rb_str_new_literal("properties");
+  patternProperties_str = rb_str_new_literal("patternProperties");
+  additionalProperties_str = rb_str_new_literal("additionalProperties");
+  unevaluatedProperties_str = rb_str_new_literal("unevaluatedProperties");
+  propertyNames_str = rb_str_new_literal("propertyNames");
+  maxProperties_str = rb_str_new_literal("maxProperties");
+  minProperties_str = rb_str_new_literal("minProperties");
+  required_str = rb_str_new_literal("required");
+  dependentRequired_str = rb_str_new_literal("dependentRequired");
+  dependencies_str = rb_str_new_literal("dependencies");
+
+  object_str = rb_str_new_literal("object");
+
+  known_keywords_hash = rb_hash_new();
+  rb_hash_aset(known_keywords_hash, id_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, ref_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, recursiveAnchor_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, recursiveRef_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, type_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, const_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, enum_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, if_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, then_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, else_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, allOf_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, anyOf_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, oneOf_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, not_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, multipleOf_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, maximum_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, exclusiveMaximum_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, minimum_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, exclusiveMinimum_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, maxLength_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, minLength_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, pattern_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, format_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, items_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, additionalItems_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, unevaluatedItems_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, contains_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, maxItems_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, minItems_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, uniqueItems_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, maxContains_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, minContains_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, properties_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, patternProperties_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, additionalProperties_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, unevaluatedProperties_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, propertyNames_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, maxProperties_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, minProperties_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, required_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, dependentRequired_str, Qtrue);
+  rb_hash_aset(known_keywords_hash, dependencies_str, Qtrue);
+
+  rb_gc_register_address(&known_keywords_hash);
+
+  rb_gc_register_address(&root_path_str);
+
+  rb_gc_register_address(&id_str);
+  rb_gc_register_address(&ref_str);
+  rb_gc_register_address(&recursiveAnchor_str);
+  rb_gc_register_address(&recursiveRef_str);
+
+  rb_gc_register_address(&type_str);
+  rb_gc_register_address(&const_str);
+  rb_gc_register_address(&enum_str);
+
+  rb_gc_register_address(&if_str);
+  rb_gc_register_address(&then_str);
+  rb_gc_register_address(&else_str);
+  rb_gc_register_address(&allOf_str);
+  rb_gc_register_address(&anyOf_str);
+  rb_gc_register_address(&oneOf_str);
+  rb_gc_register_address(&not_str);
+
+  rb_gc_register_address(&multipleOf_str);
+  rb_gc_register_address(&maximum_str);
+  rb_gc_register_address(&exclusiveMaximum_str);
+  rb_gc_register_address(&minimum_str);
+  rb_gc_register_address(&exclusiveMinimum_str);
+
+  rb_gc_register_address(&maxLength_str);
+  rb_gc_register_address(&minLength_str);
+  rb_gc_register_address(&pattern_str);
+  rb_gc_register_address(&format_str);
+
+  rb_gc_register_address(&items_str);
+  rb_gc_register_address(&additionalItems_str);
+  rb_gc_register_address(&unevaluatedItems_str);
+  rb_gc_register_address(&contains_str);
+  rb_gc_register_address(&maxItems_str);
+  rb_gc_register_address(&minItems_str);
+  rb_gc_register_address(&uniqueItems_str);
+  rb_gc_register_address(&maxContains_str);
+  rb_gc_register_address(&minContains_str);
+
+  rb_gc_register_address(&properties_str);
+  rb_gc_register_address(&patternProperties_str);
+  rb_gc_register_address(&additionalProperties_str);
+  rb_gc_register_address(&unevaluatedProperties_str);
+  rb_gc_register_address(&propertyNames_str);
+  rb_gc_register_address(&maxProperties_str);
+  rb_gc_register_address(&minProperties_str);
+  rb_gc_register_address(&required_str);
+  rb_gc_register_address(&dependentRequired_str);
+  rb_gc_register_address(&dependencies_str);
+
+  rb_gc_register_address(&object_str);
+}

data/ext/fast_json/schema/keywords.h

@@ -0,0 +1,60 @@
+#include <ruby.h>
+
+extern VALUE root_path_str;
+
+extern VALUE id_str,
+             ref_str,
+             recursiveAnchor_str,
+             recursiveRef_str;
+
+extern VALUE type_str,
+             const_str,
+             enum_str;
+
+extern VALUE if_str,
+             then_str,
+             else_str,
+             allOf_str,
+             anyOf_str,
+             oneOf_str,
+             not_str;
+
+extern VALUE multipleOf_str,
+             maximum_str,
+             exclusiveMaximum_str,
+             minimum_str,
+             exclusiveMinimum_str;
+
+extern VALUE maxLength_str,
+             minLength_str,
+             pattern_str,
+             format_str;
+
+extern VALUE items_str,
+             additionalItems_str,
+             unevaluatedItems_str,
+             contains_str,
+             maxItems_str,
+             minItems_str,
+             uniqueItems_str,
+             maxContains_str,
+             minContains_str;
+
+extern VALUE properties_str,
+             patternProperties_str,
+             additionalProperties_str,
+             unevaluatedProperties_str,
+             propertyNames_str,
+             maxProperties_str,
+             minProperties_str,
+             required_str,
+             dependentRequired_str,
+             dependencies_str;
+
+extern VALUE object_str;
+
+extern VALUE known_keywords_hash;
+
+bool is_known_keyword(VALUE);
+
+void Init_keywords();

data/ext/fast_json/schema/nested_schemas.c

@@ -0,0 +1,68 @@
+#include "nested_schemas.h"
+#include "keywords.h"
+#include "path.h"
+
+extern CompiledSchema *create_compiled_schema(VALUE, schema_flag_t);
+extern void compile(CompiledSchema *, VALUE, VALUE, VALUE);
+
+static bool is_schema_shaped(VALUE value) {
+  return RB_TYPE_P(value, T_HASH) ||
+         RB_TYPE_P(value, T_TRUE) ||
+         RB_TYPE_P(value, T_FALSE);
+}
+
+static int count_nested(VALUE key, VALUE value, VALUE data) {
+  if(!RB_TYPE_P(key, T_STRING)) return ST_CONTINUE;
+  if(is_known_keyword(key)) return ST_CONTINUE;
+  if(!is_schema_shaped(value)) return ST_CONTINUE;
+
+  size_t *count = (size_t *)data;
+  (*count)++;
+
+  return ST_CONTINUE;
+}
+
+struct compile_memo_S {
+  CompiledSchema *root_schema;
+  VALUE ref_data;
+  VALUE custom_formats;
+};
+
+static int compile_nested(VALUE key, VALUE value, VALUE data) {
+  if(!RB_TYPE_P(key, T_STRING)) return ST_CONTINUE;
+  if(is_known_keyword(key)) return ST_CONTINUE;
+  if(!is_schema_shaped(value)) return ST_CONTINUE;
+
+  struct compile_memo_S *memo = (struct compile_memo_S *)data;
+
+  VALUE child_path = new_path(memo->root_schema->path, key);
+
+  CompiledSchema *child = create_compiled_schema(child_path, NO_FLAG);
+
+  /*
+  * Append the child pointer to the parent's nested_schemas array and bump the
+  * count BEFORE running `compile` on the child, so the parent's mark function
+  * will reach this child if the GC fires during its compilation.
+  */
+  memo->root_schema->nested_schemas[memo->root_schema->nested_schemas_count++] = child;
+
+  compile(child, value, memo->ref_data, memo->custom_formats);
+
+  return ST_CONTINUE;
+}
+
+void compile_nested_schemas(CompiledSchema *root_schema, VALUE ruby_schema, VALUE ref_data, VALUE custom_formats) {
+  if(!RB_TYPE_P(ruby_schema, T_HASH)) return;
+
+  size_t total = 0;
+  rb_hash_foreach(ruby_schema, count_nested, (VALUE)&total);
+
+  if(total == 0) return;
+
+  root_schema->nested_schemas = ALLOC_N(CompiledSchema *, total);
+  root_schema->nested_schemas_count = 0;
+
+  struct compile_memo_S memo = { root_schema, ref_data, custom_formats };
+
+  rb_hash_foreach(ruby_schema, compile_nested, (VALUE)&memo);
+}

data/ext/fast_json/schema/nested_schemas.h

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

data/ext/fast_json/schema/not.c

@@ -0,0 +1,11 @@
+#include "not.h"
+#include "error.h"
+
+extern bool is_valid(VALUE, CompiledSchema *, VALUE, Context *);
+
+void validate_not(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  bool valid = is_valid(schema, compiled_schema->not_schema, data, context);
+
+  if(valid)
+    yield_error(compiled_schema->not_schema, data, context, "not");
+}

data/ext/fast_json/schema/not.h

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

data/ext/fast_json/schema/one_of.c

@@ -0,0 +1,23 @@
+#include "one_of.h"
+#include "error.h"
+
+extern bool is_valid(VALUE, CompiledSchema *, VALUE, Context *);
+
+void validate_one_of(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  long i, valid_count = 0;
+
+  for(i = 0; i < RARRAY_LEN(compiled_schema->oneOf_val); i++) {
+    VALUE child_compiled_schema_obj = rb_ary_entry(compiled_schema->oneOf_val, i);
+
+    CompiledSchema *child_compiled_schema;
+    GetCompiledSchema(child_compiled_schema_obj, child_compiled_schema);
+
+    bool valid = is_valid(schema, child_compiled_schema, data, context);
+
+    if(valid && ++valid_count > 1)
+      break;
+  }
+
+  if(valid_count != 1)
+    yield_error(compiled_schema, data, context, "oneOf");
+}

data/ext/fast_json/schema/one_of.h

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

data/ext/fast_json/schema/path.c

@@ -0,0 +1,44 @@
+#include "path.h"
+
+VALUE new_path(VALUE root, VALUE name) {
+  StringValue(root);
+  StringValue(name);
+
+  VALUE result = rb_str_dup(root);
+
+  rb_str_cat_cstr(result, "/");
+  rb_str_buf_append(result, name);
+
+  return result;
+}
+
+VALUE to_path(VALUE *list, int depth) {
+  int i;
+  VALUE path = rb_str_new2("");
+
+  for(i = 0; i <= depth; i++) {
+    if(RB_TYPE_P(list[i], T_STRING)) {
+      rb_str_append(path, list[i]);
+    } else if (RB_INTEGER_TYPE_P(list[i])) {
+      VALUE str = rb_sprintf("%ld", NUM2LONG(list[i]));
+
+      rb_str_append(path, str);
+    } else {
+      rb_raise(rb_eRuntimeError, "Unexpected value while generating the path!");
+    }
+
+    rb_str_cat_cstr(path, "/");
+  }
+
+  return path;
+}
+
+VALUE append_long_to_path(VALUE root, long i) {
+  StringValue(root);
+
+  VALUE result = rb_str_dup(root);
+  VALUE suffix = rb_sprintf("/%ld", i);
+  rb_str_buf_append(result, suffix);
+
+  return result;
+}

data/ext/fast_json/schema/path.h

@@ -0,0 +1,5 @@
+#include <ruby.h>
+
+VALUE new_path(VALUE, VALUE);
+VALUE to_path(VALUE *list, int depth);
+VALUE append_long_to_path(VALUE, long);

data/ext/fast_json/schema/properties_val.c

@@ -0,0 +1,103 @@
+#include "properties_val.h"
+#include "keywords.h"
+#include "path.h"
+#include "compiled_schema.h"
+
+extern CompiledSchema *create_compiled_schema(VALUE, schema_flag_t);
+extern void compile(CompiledSchema *, VALUE, VALUE, VALUE);
+
+typedef VALUE (*key_transform_function)(VALUE);
+
+struct memo_S {
+  VALUE properties_hash;
+  VALUE ref_data;
+  VALUE path;
+  VALUE custom_formats;
+  key_transform_function key_transform_function;
+};
+
+VALUE no_op_key_transform(VALUE key) {
+  return key;
+}
+
+VALUE regexp_key_transform(VALUE key) {
+  return rb_reg_new_str(key, 0);
+}
+
+static int compile_property(VALUE key, VALUE value, VALUE data) {
+  if(!RB_TYPE_P(key, T_STRING)) return ST_CONTINUE;
+
+  struct memo_S *memo = (struct memo_S*)(data);
+
+  VALUE path = new_path(memo->path, key);
+
+  CompiledSchema *compiled_schema = create_compiled_schema(path, EXPOSE_TO_RUBY);
+  VALUE compiled_schema_obj = WrapCompiledSchema(compiled_schema);
+
+  compile(compiled_schema, value, memo->ref_data, memo->custom_formats);
+
+  rb_hash_aset(memo->properties_hash, memo->key_transform_function(key), compiled_schema_obj);
+
+  return ST_CONTINUE;
+}
+
+static VALUE compile_properties(CompiledSchema *root_schema, VALUE ruby_schema, VALUE ref_data, VALUE custom_formats, VALUE keyword, key_transform_function func) {
+  VALUE properties = rb_hash_aref(ruby_schema, keyword);
+
+  if(!RB_TYPE_P(properties, T_HASH)) return Qundef;
+
+  VALUE properties_hash = rb_hash_new();
+  VALUE properties_path = new_path(root_schema->path, keyword);
+
+  struct memo_S memo = { properties_hash, ref_data, properties_path, custom_formats, func };
+
+  rb_hash_foreach(properties, compile_property, (VALUE)&memo);
+
+  return properties_hash;
+}
+
+void compile_properties_val(CompiledSchema *root_schema, VALUE ruby_schema, VALUE ref_data, VALUE custom_formats) {
+  root_schema->properties_val = compile_properties(root_schema, ruby_schema, ref_data, custom_formats, properties_str, no_op_key_transform);
+}
+
+void compile_pattern_properties_val(CompiledSchema *root_schema, VALUE ruby_schema, VALUE ref_data, VALUE custom_formats) {
+  root_schema->patternProperties_val = compile_properties(root_schema, ruby_schema, ref_data, custom_formats, patternProperties_str, regexp_key_transform);
+}
+
+static int compile_dependency(VALUE key, VALUE value, VALUE data) {
+  if(!RB_TYPE_P(key, T_STRING)) return ST_CONTINUE;
+
+  if(RB_TYPE_P(value, T_ARRAY)) {
+    /*
+    * If the value is an array, we are creating a temporary Ruby hash and compiling it as
+    * if it was provided by the user which looks something like the following;
+    *
+    *   { "type" => "object", "required" => ["foo", "bar"] }
+    */
+    VALUE tmp_schema = rb_hash_new();
+
+    rb_hash_aset(tmp_schema, required_str, value);
+    rb_hash_aset(tmp_schema, type_str, object_str);
+
+    compile_property(key, tmp_schema, data);
+  } else {
+    compile_property(key, value, data);
+  }
+
+  return ST_CONTINUE;
+}
+
+void compile_dependencies_val(CompiledSchema *root_schema, VALUE ruby_schema, VALUE ref_data, VALUE custom_formats) {
+  VALUE dependencies = rb_hash_aref(ruby_schema, dependencies_str);
+
+  if(!RB_TYPE_P(dependencies, T_HASH)) return;
+
+  VALUE dependencies_val = rb_hash_new();
+  VALUE dependencies_path = new_path(root_schema->path, dependencies_str);
+
+  struct memo_S memo = { dependencies_val, ref_data, dependencies_path, custom_formats, no_op_key_transform };
+
+  rb_hash_foreach(dependencies, compile_dependency, (VALUE)&memo);
+
+  root_schema->dependencies_val = dependencies_val;
+}

data/ext/fast_json/schema/properties_val.h

@@ -0,0 +1,6 @@
+#include <ruby.h>
+#include "types/compiled_schema.h"
+
+void compile_properties_val(CompiledSchema *, VALUE, VALUE, VALUE);
+void compile_pattern_properties_val(CompiledSchema *, VALUE, VALUE, VALUE);
+void compile_dependencies_val(CompiledSchema *, VALUE, VALUE, VALUE);

data/ext/fast_json/schema/ref.c

@@ -0,0 +1,7 @@
+#include "ref.h"
+
+void validate_ref(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  CompiledSchema *ref_schema = compiled_schema->ref_schema;
+
+  ref_schema->validation_function(schema, ref_schema, data, context);
+}

data/ext/fast_json/schema/ref.h

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

data/ext/fast_json/schema/ref_resolver.c

@@ -0,0 +1,85 @@
+#include "ref_resolver.h"
+#include "value_pointer_caster.h"
+
+static int resolve_refs_in_hash(VALUE key, VALUE value, VALUE data) {
+  CompiledSchema *child;
+  GetCompiledSchema(value, child);
+
+  resolve_refs(child, data);
+
+  return ST_CONTINUE;
+}
+
+static void resolve_refs_for_nested_schemas(CompiledSchema **children, size_t count, VALUE ref_data) {
+  for(size_t i = 0; i < count; i++)
+    resolve_refs(children[i], ref_data);
+}
+
+static void resolve_refs_in_array(VALUE array, VALUE ref_data) {
+  long i;
+
+  for(i = 0; i < RARRAY_LEN(array); i++) {
+    VALUE child_obj = rb_ary_entry(array, i);
+
+    CompiledSchema *child;
+    GetCompiledSchema(child_obj, child);
+
+    resolve_refs(child, ref_data);
+  }
+}
+
+void resolve_refs(CompiledSchema *compiled_schema, VALUE ref_data) {
+  if(compiled_schema == NULL) return;
+
+  if(compiled_schema->ref_val != Qundef) {
+    VALUE ref_schema_ptr = rb_hash_lookup(ref_data, compiled_schema->ref_val);
+
+    if(NIL_P(ref_schema_ptr))
+      rb_raise(rb_eRuntimeError, "Unresolved $ref: %s", StringValueCStr(compiled_schema->ref_val));
+
+    compiled_schema->ref_schema = (CompiledSchema *)NUM2PTR(ref_schema_ptr);
+  }
+
+  resolve_refs(compiled_schema->if_schema, ref_data);
+  resolve_refs(compiled_schema->then_schema, ref_data);
+  resolve_refs(compiled_schema->else_schema, ref_data);
+  resolve_refs(compiled_schema->not_schema, ref_data);
+  resolve_refs(compiled_schema->items_schema, ref_data);
+  resolve_refs(compiled_schema->additionalItems_schema, ref_data);
+  resolve_refs(compiled_schema->contains_schema, ref_data);
+  resolve_refs(compiled_schema->propertyNames_schema, ref_data);
+  resolve_refs(compiled_schema->additionalProperties_schema, ref_data);
+
+  if(compiled_schema->allOf_val != Qundef)
+    resolve_refs_in_array(compiled_schema->allOf_val, ref_data);
+
+  if(compiled_schema->anyOf_val != Qundef)
+    resolve_refs_in_array(compiled_schema->anyOf_val, ref_data);
+
+  if(compiled_schema->oneOf_val != Qundef)
+    resolve_refs_in_array(compiled_schema->oneOf_val, ref_data);
+
+  if(RB_TYPE_P(compiled_schema->items_val, T_ARRAY))
+    resolve_refs_in_array(compiled_schema->items_val, ref_data);
+
+  if(compiled_schema->properties_val != Qundef)
+    rb_hash_foreach(compiled_schema->properties_val, resolve_refs_in_hash, ref_data);
+
+  if(compiled_schema->patternProperties_val != Qundef)
+    rb_hash_foreach(compiled_schema->patternProperties_val, resolve_refs_in_hash, ref_data);
+
+  if(compiled_schema->dependencies_val != Qundef)
+    rb_hash_foreach(compiled_schema->dependencies_val, resolve_refs_in_hash, ref_data);
+
+  if(compiled_schema->nested_schemas != NULL)
+    resolve_refs_for_nested_schemas(compiled_schema->nested_schemas, compiled_schema->nested_schemas_count, ref_data);
+}
+
+void register_schema_for_ref_resolution(CompiledSchema *compiled_schema, VALUE ref_data) {
+  // Embed compiled schema into Ruby Hash
+  rb_hash_aset(ref_data, compiled_schema->path, PTR2NUM(compiled_schema));
+
+  // Embed compiled schema into Ruby Hash again if it has an $id
+  if(compiled_schema->id_val != Qundef)
+    rb_hash_aset(ref_data, compiled_schema->id_val, PTR2NUM(compiled_schema));
+}

data/ext/fast_json/schema/ref_resolver.h

@@ -0,0 +1,5 @@
+#include <ruby.h>
+#include "compiled_schema.h"
+
+void resolve_refs(CompiledSchema *compiled_schema, VALUE ref_data);
+void register_schema_for_ref_resolution(CompiledSchema *compiled_schema, VALUE ref_data);