fast_json-schema 0.1.0

data/ext/fast_json/schema/schema.c

@@ -0,0 +1,68 @@
+#include <ruby.h>
+#include "keywords.h"
+#include "compiled_schema.h"
+#include "types/context.h"
+#include "error.h"
+#include "is_valid.h"
+
+extern bool is_valid(VALUE, CompiledSchema *, VALUE, Context *);
+
+static CompiledSchema *root_schema(VALUE self) {
+  CompiledSchema *compiled_schema;
+  VALUE compiled_schema_obj = rb_ivar_get(self, rb_intern("compiled_schema"));
+
+  return GetCompiledSchema(compiled_schema_obj, compiled_schema);
+}
+
+VALUE rb_validate(VALUE self, VALUE data) {
+  if (!rb_block_given_p()) {
+    VALUE args[1] = { data };
+
+    RETURN_SIZED_ENUMERATOR(self, 1, args, 0);
+  }
+
+  CompiledSchema *schema = root_schema(self);
+  Context *context;
+  VALUE context_obj = create_context(&context);
+
+  schema->validation_function(self, schema, data, context);
+
+  RB_GC_GUARD(context_obj);
+
+  return Qnil;
+}
+
+VALUE rb_valid(VALUE self, VALUE data) {
+  CompiledSchema *schema = root_schema(self);
+  Context *context;
+  VALUE context_obj = create_context(&context);
+
+  bool valid = is_valid(self, schema, data, context);
+
+  RB_GC_GUARD(context_obj);
+
+  return valid ? Qtrue : Qfalse;
+}
+
+VALUE rb_compile(VALUE self) {
+  VALUE is_compiled = rb_ivar_get(self, rb_intern("compiled"));
+
+  if(is_compiled != Qtrue) compile_schema(self);
+
+  return self;
+}
+
+void Init_schema() {
+  VALUE fast_json_class = rb_const_get(rb_cObject, rb_intern("FastJSON"));
+  VALUE schema_class = rb_const_get(fast_json_class, rb_intern("Schema"));
+
+  Init_keywords();
+  Init_error(schema_class);
+  Init_compiled_schema(schema_class);
+  Init_context();
+  Init_is_valid();
+
+  rb_define_method(schema_class, "compile", rb_compile, 0);
+  rb_define_method(schema_class, "validate", rb_validate, 1);
+  rb_define_method(schema_class, "valid?", rb_valid, 1);
+}

data/ext/fast_json/schema/schema_collection.c

@@ -0,0 +1,29 @@
+#include "schema_collection.h"
+#include "compiled_schema.h"
+#include "path.h"
+
+extern CompiledSchema *create_compiled_schema(VALUE, schema_flag_t);
+extern void compile(CompiledSchema *, VALUE, VALUE, VALUE);
+
+void compile_schema_collection(VALUE *schema_member, VALUE ruby_schema_array, VALUE ref_data, VALUE path, VALUE custom_formats) {
+  long i;
+  VALUE compiled_schema_collection = rb_ary_new();
+
+  /*
+  * `ruby_schema_array` must be a non-empty array.
+  * Perhaps we should check if it's empty.
+  */
+  for(i = 0; i < RARRAY_LEN(ruby_schema_array); i++) {
+    VALUE ruby_schema = rb_ary_entry(ruby_schema_array, i);
+    VALUE new_path = append_long_to_path(path, i);
+
+    CompiledSchema *compiled_schema = create_compiled_schema(new_path, EXPOSE_TO_RUBY);
+    VALUE compiled_schema_obj = WrapCompiledSchema(compiled_schema);
+
+    compile(compiled_schema, ruby_schema, ref_data, custom_formats);
+
+    rb_ary_push(compiled_schema_collection, compiled_schema_obj);
+  }
+
+  *schema_member = compiled_schema_collection;
+}

data/ext/fast_json/schema/schema_collection.h

@@ -0,0 +1,3 @@
+#include <ruby.h>
+
+void compile_schema_collection(VALUE *, VALUE, VALUE, VALUE, VALUE);

data/ext/fast_json/schema/types/compiled_schema.h

@@ -0,0 +1,96 @@
+#include <ruby.h>
+#include "types/context.h"
+
+#define NO_FLAG 0
+#define ROOT_SCHEMA (1 << 0)
+#define EXPOSE_TO_RUBY (1 << 1)
+
+#define IS_CHILD(compiled_schema) ((compiled_schema->flags & ROOT_SCHEMA) == 0)
+#define INTERNAL_ONLY(compiled_schema) ((compiled_schema->flags & EXPOSE_TO_RUBY) == 0)
+
+#ifndef FAST_JSON_SCHEMA_COMPILED_SCHEMA_TYPE
+#define FAST_JSON_SCHEMA_COMPILED_SCHEMA_TYPE 1
+
+typedef struct compiled_schema_struct CompiledSchema;
+
+typedef void (*validation_function)(VALUE, CompiledSchema *, VALUE, Context *);
+typedef void (*format_validation_function)(VALUE, CompiledSchema *, VALUE, Context *);
+
+typedef unsigned char schema_flag_t;
+
+/*
+* TODO:
+* Currently all the validation keywords are stored flat in this struct
+* which is a waste of memory. I'm planning to use union for sustaining
+* the data locality and reducing the amount of memory wasted.
+*/
+typedef struct compiled_schema_struct {
+  schema_flag_t flags;
+  VALUE path;
+
+  VALUE id_val;
+  VALUE ref_val;
+  VALUE recursiveAnchor_val;
+  VALUE recursiveRef_val;
+
+  CompiledSchema *ref_schema;
+
+  validation_function validation_function;
+  validation_function type_validation_function;
+  format_validation_function format_validation_function;
+
+  VALUE custom_format_callable_val;
+  VALUE custom_format_error_key_val;
+
+  VALUE const_val;
+  VALUE enum_val;
+
+  CompiledSchema *if_schema;
+  CompiledSchema *then_schema;
+  CompiledSchema *else_schema;
+
+  VALUE allOf_val;
+  VALUE anyOf_val;
+  VALUE oneOf_val;
+  CompiledSchema *not_schema;
+
+  VALUE multipleOf_val;
+  VALUE maximum_val;
+  VALUE exclusiveMaximum_val;
+  VALUE minimum_val;
+  VALUE exclusiveMinimum_val;
+
+  VALUE maxLength_val;
+  VALUE minLength_val;
+  VALUE pattern_val;
+
+  /*
+  * `items` can be either a JSON schema or an array of valid JSON schemas.
+  *
+  *   - `items_schema` is set if it's a JSON schema
+  *   - `items_val` is set if it's an array of JSON schemas
+  */
+  CompiledSchema *items_schema;
+  VALUE items_val;
+  CompiledSchema *additionalItems_schema;
+  CompiledSchema *contains_schema;
+  VALUE maxItems_val;
+  VALUE minItems_val;
+  VALUE uniqueItems_val;
+  VALUE maxContains_val;
+  VALUE minContains_val;
+
+  VALUE properties_val;
+  VALUE patternProperties_val;
+  CompiledSchema *propertyNames_schema;
+  CompiledSchema *additionalProperties_schema;
+  VALUE maxProperties_val;
+  VALUE minProperties_val;
+  VALUE required_val;
+  VALUE dependencies_val;
+
+  CompiledSchema **nested_schemas;
+  size_t nested_schemas_count;
+} CompiledSchema;
+
+#endif

data/ext/fast_json/schema/types/context.h

@@ -0,0 +1,27 @@
+#include <ruby.h>
+
+#ifndef FAST_JSON_SCHEMA_CONTEXT_TYPE
+#define FAST_JSON_SCHEMA_CONTEXT_TYPE 1
+
+#define MAX_CONTEXT_DEPTH 1000
+
+typedef struct context_struct {
+  VALUE path[MAX_CONTEXT_DEPTH];
+  int depth;
+  bool short_circuit_on_error;
+} Context;
+
+VALUE create_context(Context **out_context);
+void Init_context(void);
+
+#endif
+
+#define INCR_CONTEXT(context)                             \
+  do {                                                    \
+    if(++context->depth > MAX_CONTEXT_DEPTH)              \
+      rb_raise(rb_eRuntimeError, "Document is too deep"); \
+  } while(0);
+
+#define DECR_CONTEXT(context) context->depth--;
+
+#define ADD_TO_CONTEXT(context, value) context->path[context->depth] = value;

data/ext/fast_json/schema/validate.c

@@ -0,0 +1,63 @@
+#include "validate.h"
+#include "error.h"
+
+void no_op_validate(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  return;
+}
+
+void false_validate(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  yield_error(compiled_schema, data, context, "false_schema");
+}
+
+void validate_by_data_type(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(RB_INTEGER_TYPE_P(data)) {
+    validate_integer(schema, compiled_schema, data, context);
+  } else if(RB_TYPE_P(data, T_FLOAT)) {
+    validate_number(schema, compiled_schema, data, context);
+  } else if(RB_TYPE_P(data, T_STRING)) {
+    validate_string(schema, compiled_schema, data, context);
+  } else if(RB_TYPE_P(data, T_HASH)) {
+    validate_object(schema, compiled_schema, data, context);
+  } else if(RB_TYPE_P(data, T_ARRAY)) {
+    validate_array(schema, compiled_schema, data, context);
+  }
+}
+
+static void validate_const(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  VALUE equal = rb_funcall(compiled_schema->const_val, rb_intern("=="), 1, data);
+
+  if(equal == Qfalse)
+    yield_error(compiled_schema, data, context, "const");
+}
+
+static void validate_enum(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  VALUE include = rb_funcall(compiled_schema->enum_val, rb_intern("include?"), 1, data);
+
+  if(include == Qfalse)
+    yield_error(compiled_schema, data, context, "enum");
+}
+
+void validate(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  compiled_schema->type_validation_function(schema, compiled_schema, data, context);
+
+  if(compiled_schema->const_val != Qundef)
+    validate_const(schema, compiled_schema, data, context);
+
+  if(compiled_schema->enum_val != Qundef)
+    validate_enum(schema, compiled_schema, data, context);
+
+  if(compiled_schema->if_schema != NULL)
+    validate_if(schema, compiled_schema, data, context);
+
+  if(compiled_schema->not_schema != NULL)
+    validate_not(schema, compiled_schema, data, context);
+
+  if(compiled_schema->allOf_val != Qundef)
+    validate_all_of(schema, compiled_schema, data, context);
+
+  if(compiled_schema->anyOf_val != Qundef)
+    validate_any_of(schema, compiled_schema, data, context);
+
+  if(compiled_schema->oneOf_val != Qundef)
+    validate_one_of(schema, compiled_schema, data, context);
+}

data/ext/fast_json/schema/validate.h

@@ -0,0 +1,19 @@
+#include <ruby.h>
+#include "compiled_schema.h"
+#include "if.h"
+#include "all_of.h"
+#include "any_of.h"
+#include "one_of.h"
+#include "not.h"
+#include "validate_array.h"
+#include "validate_bool.h"
+#include "validate_integer.h"
+#include "validate_null.h"
+#include "validate_number.h"
+#include "validate_object.h"
+#include "validate_string.h"
+
+void no_op_validate(VALUE, CompiledSchema *, VALUE, Context *);
+void false_validate(VALUE, CompiledSchema *, VALUE, Context *);
+void validate_by_data_type(VALUE, CompiledSchema *, VALUE, Context *);
+void validate(VALUE, CompiledSchema *, VALUE, Context *);

data/ext/fast_json/schema/validate_array.c

@@ -0,0 +1,130 @@
+#include "validate_array.h"
+#include "error.h"
+
+extern bool is_valid(VALUE, CompiledSchema *, VALUE, Context *);
+
+static void validate_items(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  long i;
+  CompiledSchema *items_schema = compiled_schema->items_schema;
+
+  INCR_CONTEXT(context);
+
+  for(i = 0; i < RARRAY_LEN(data); i++) {
+    ADD_TO_CONTEXT(context, LONG2NUM(i));
+
+    items_schema->validation_function(schema, items_schema, rb_ary_entry(data, i), context);
+  }
+
+  DECR_CONTEXT(context);
+}
+
+/*
+* Returns `true` if all the items in the array instance are validated.
+* Returns `false` otherwise.
+*/
+static bool validate_with_multiple_items_schema(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  long i;
+  long data_length = RARRAY_LEN(data);
+  long items_val_length = RARRAY_LEN(compiled_schema->items_val);
+  long upper_bound = (items_val_length < data_length) ? items_val_length : data_length;
+
+  INCR_CONTEXT(context);
+
+  for(i = 0; i < upper_bound; i++) {
+    ADD_TO_CONTEXT(context, LONG2NUM(i));
+
+    CompiledSchema *relevant_schema;
+    VALUE relevant_schema_obj = rb_ary_entry(compiled_schema->items_val, i);
+
+    GetCompiledSchema(relevant_schema_obj, relevant_schema);
+
+    relevant_schema->validation_function(schema, relevant_schema, rb_ary_entry(data, i), context);
+  }
+
+  DECR_CONTEXT(context);
+
+  return (data_length <= items_val_length);
+}
+
+static void validate_additional_items(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  long i = RARRAY_LEN(compiled_schema->items_val);
+  CompiledSchema *additionalItems_schema = compiled_schema->additionalItems_schema;
+
+  INCR_CONTEXT(context);
+
+  for(; i < RARRAY_LEN(data); i++) {
+    ADD_TO_CONTEXT(context, LONG2NUM(i));
+
+    additionalItems_schema->validation_function(schema, additionalItems_schema, rb_ary_entry(data, i), context);
+  }
+
+  DECR_CONTEXT(context);
+}
+
+static void validate_contains(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  long i, valid_count = 0;
+
+  for(i = 0; i < RARRAY_LEN(data); i++) {
+    VALUE entry = rb_ary_entry(data, i);
+
+    bool valid = is_valid(schema, compiled_schema->contains_schema, entry, context);
+
+    if(valid)
+      valid_count++;
+  }
+
+  if(RB_INTEGER_TYPE_P(compiled_schema->maxContains_val)) {
+    if(valid_count > NUM2LONG(compiled_schema->maxContains_val))
+      yield_error(compiled_schema, data, context, "maxContains");
+  }
+
+  /*
+  * According to spec description, when the `minContains` keyword is missing, we must check
+  * if there is at least one valid item against the `contains` schema.
+  *
+  * If the `minContains` keyword exists, we must check if the number of valid items are
+  * greater than or equal to the `minContains` value.
+  */
+  if(RB_INTEGER_TYPE_P(compiled_schema->minContains_val)) {
+    if(valid_count < NUM2LONG(compiled_schema->minContains_val))
+      yield_error(compiled_schema, data, context, "minContains");
+  } else {
+    if(valid_count == 0)
+      yield_error(compiled_schema->contains_schema, data, context, "contains");
+  }
+}
+
+void validate_array(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!RB_TYPE_P(data, T_ARRAY))
+    return yield_error(compiled_schema, data, context, "type_array");
+
+  if(compiled_schema->maxItems_val != Qundef) {
+    if(RARRAY_LEN(data) > NUM2LONG(compiled_schema->maxItems_val))
+      yield_error(compiled_schema, data, context, "maxItems");
+  }
+
+  if(compiled_schema->minItems_val != Qundef) {
+    if(RARRAY_LEN(data) < NUM2LONG(compiled_schema->minItems_val))
+      yield_error(compiled_schema, data, context, "minItems");
+  }
+
+  if(compiled_schema->uniqueItems_val == Qtrue) {
+    // I don't really want to deal with comparing array elements
+    VALUE unique_arr = rb_funcall(data, rb_intern("uniq"), 0);
+
+    if(RARRAY_LEN(unique_arr) < RARRAY_LEN(data))
+      yield_error(compiled_schema, data, context, "uniqueItems");
+  }
+
+  if(compiled_schema->items_schema != NULL) {
+    validate_items(schema, compiled_schema, data, context);
+  } else if(compiled_schema->items_val != Qundef) {
+    long all_validated = validate_with_multiple_items_schema(schema, compiled_schema, data, context);
+
+    if(!all_validated && compiled_schema->additionalItems_schema != NULL)
+      validate_additional_items(schema, compiled_schema, data, context);
+  }
+
+  if(compiled_schema->contains_schema != NULL)
+    validate_contains(schema, compiled_schema, data, context);
+}

data/ext/fast_json/schema/validate_array.h

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

data/ext/fast_json/schema/validate_bool.c

@@ -0,0 +1,7 @@
+#include "validate_bool.h"
+#include "error.h"
+
+void validate_bool(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(data != Qtrue && data != Qfalse)
+    yield_error(compiled_schema, data, context, "type_bool");
+}

data/ext/fast_json/schema/validate_bool.h

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

data/ext/fast_json/schema/validate_integer.c

@@ -0,0 +1,52 @@
+#include "validate_integer.h"
+#include "error.h"
+
+void validate_integer(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!RB_INTEGER_TYPE_P(data))
+    return yield_error(compiled_schema, data, context, "type_integer");
+
+  long data_c = NUM2LONG(data);
+
+  if(RB_INTEGER_TYPE_P(compiled_schema->multipleOf_val)) {
+    if(data_c % NUM2LONG(compiled_schema->multipleOf_val) != 0)
+      yield_error(compiled_schema, data, context, "multipleOf");
+  } else if(RB_TYPE_P(compiled_schema->multipleOf_val, T_FLOAT)) {
+    double multipleOf = NUM2DBL(compiled_schema->multipleOf_val);
+    double div = data_c / multipleOf;
+
+    if(div - (int)div != 0.0) // fmod() does not work here due to IEEE floating point arithmetics
+      yield_error(compiled_schema, data, context, "multipleOf");
+  }
+
+  if(RB_INTEGER_TYPE_P(compiled_schema->maximum_val)) {
+    if(data_c > NUM2LONG(compiled_schema->maximum_val))
+      yield_error(compiled_schema, data, context, "maximum");
+  } else if(RB_TYPE_P(compiled_schema->maximum_val, T_FLOAT)) {
+    if(data_c > NUM2DBL(compiled_schema->maximum_val))
+      yield_error(compiled_schema, data, context, "maximum");
+  }
+
+  if(RB_INTEGER_TYPE_P(compiled_schema->exclusiveMaximum_val)) {
+    if(data_c >= NUM2LONG(compiled_schema->exclusiveMaximum_val))
+      yield_error(compiled_schema, data, context, "exclusiveMaximum");
+  } else if(RB_TYPE_P(compiled_schema->exclusiveMaximum_val, T_FLOAT)) {
+    if(data_c >= NUM2DBL(compiled_schema->exclusiveMaximum_val))
+      yield_error(compiled_schema, data, context, "exclusiveMaximum");
+  }
+
+  if(RB_INTEGER_TYPE_P(compiled_schema->minimum_val)) {
+    if(data_c < NUM2LONG(compiled_schema->minimum_val))
+      yield_error(compiled_schema, data, context, "minimum");
+  } else if(RB_TYPE_P(compiled_schema->minimum_val, T_FLOAT)) {
+    if(data_c < NUM2DBL(compiled_schema->minimum_val))
+      yield_error(compiled_schema, data, context, "minimum");
+  }
+
+  if(RB_INTEGER_TYPE_P(compiled_schema->exclusiveMinimum_val)) {
+    if(data_c <= NUM2LONG(compiled_schema->exclusiveMinimum_val))
+      yield_error(compiled_schema, data, context, "exclusiveMinimum");
+  } else if(RB_TYPE_P(compiled_schema->exclusiveMinimum_val, T_FLOAT)) {
+    if(data_c <= NUM2DBL(compiled_schema->exclusiveMinimum_val))
+      yield_error(compiled_schema, data, context, "exclusiveMinimum");
+  }
+}

data/ext/fast_json/schema/validate_integer.h

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

data/ext/fast_json/schema/validate_null.c

@@ -0,0 +1,7 @@
+#include "validate_null.h"
+#include "error.h"
+
+void validate_null(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!NIL_P(data))
+    yield_error(compiled_schema, data, context, "type_null");
+}

data/ext/fast_json/schema/validate_null.h

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

data/ext/fast_json/schema/validate_number.c

@@ -0,0 +1,62 @@
+#include "validate_number.h"
+#include "error.h"
+
+void validate_number(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!RB_INTEGER_TYPE_P(data) && !RB_TYPE_P(data, T_FLOAT))
+    return yield_error(compiled_schema, data, context, "type_number");
+
+  double data_c;
+
+  if(!RB_INTEGER_TYPE_P(data)) {
+    data_c = NUM2DBL(data);
+  } else {
+    data_c = NUM2LONG(data);
+  }
+
+
+  if(RB_INTEGER_TYPE_P(compiled_schema->multipleOf_val)) {
+    long multipleOf = NUM2LONG(compiled_schema->multipleOf_val);
+    double div = data_c / multipleOf;
+
+    if(div - (int)div != 0.0) // fmod() does not work here due to IEEE floating point arithmetics
+      yield_error(compiled_schema, data, context, "multipleOf");
+  } else if(RB_TYPE_P(compiled_schema->multipleOf_val, T_FLOAT)) {
+    double multipleOf = NUM2DBL(compiled_schema->multipleOf_val);
+    double div = data_c / multipleOf;
+
+    if(div - (int)div != 0.0) // fmod() does not work here due to IEEE floating point arithmetics
+      yield_error(compiled_schema, data, context, "multipleOf");
+  }
+
+  if(RB_INTEGER_TYPE_P(compiled_schema->maximum_val)) {
+    if(data_c > NUM2LONG(compiled_schema->maximum_val))
+      yield_error(compiled_schema, data, context, "maximum");
+  } else if(RB_TYPE_P(compiled_schema->maximum_val, T_FLOAT)) {
+    if(data_c > NUM2DBL(compiled_schema->maximum_val))
+      yield_error(compiled_schema, data, context, "maximum");
+  }
+
+  if(RB_INTEGER_TYPE_P(compiled_schema->exclusiveMaximum_val)) {
+    if(data_c >= NUM2LONG(compiled_schema->exclusiveMaximum_val))
+      yield_error(compiled_schema, data, context, "exclusiveMaximum");
+  } else if(RB_TYPE_P(compiled_schema->exclusiveMaximum_val, T_FLOAT)) {
+    if(data_c >= NUM2DBL(compiled_schema->exclusiveMaximum_val))
+      yield_error(compiled_schema, data, context, "exclusiveMaximum");
+  }
+
+  if(RB_INTEGER_TYPE_P(compiled_schema->minimum_val)) {
+    if(data_c < NUM2LONG(compiled_schema->minimum_val))
+      yield_error(compiled_schema, data, context, "minimum");
+  } else if(RB_TYPE_P(compiled_schema->minimum_val, T_FLOAT)) {
+    if(data_c < NUM2DBL(compiled_schema->minimum_val))
+      yield_error(compiled_schema, data, context, "minimum");
+  }
+
+  if(RB_INTEGER_TYPE_P(compiled_schema->exclusiveMinimum_val)) {
+    if(data_c <= NUM2LONG(compiled_schema->exclusiveMinimum_val))
+      yield_error(compiled_schema, data, context, "exclusiveMinimum");
+  } else if(RB_TYPE_P(compiled_schema->exclusiveMinimum_val, T_FLOAT)) {
+    if(data_c <= NUM2DBL(compiled_schema->exclusiveMinimum_val))
+      yield_error(compiled_schema, data, context, "exclusiveMinimum");
+  }
+}

data/ext/fast_json/schema/validate_number.h

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