fast_json-schema 0.1.0

data/ext/fast_json/schema/formats/custom_format.c

@@ -0,0 +1,63 @@
+#include "custom_format.h"
+#include "error.h"
+
+struct custom_call_args {
+  VALUE callable;
+  VALUE data;
+};
+
+static VALUE call_custom_validator(VALUE arg_ptr) {
+  struct custom_call_args *args = (struct custom_call_args *)arg_ptr;
+
+  return rb_funcall(args->callable, rb_intern("call"), 1, args->data);
+}
+
+static void validate_custom_format(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {  
+  int state = 0;
+  struct custom_call_args args = { compiled_schema->custom_format_callable_val, data };
+  VALUE result = rb_protect(call_custom_validator, (VALUE)&args, &state);
+
+  const char *error_key = RSTRING_PTR(compiled_schema->custom_format_error_key_val);
+
+  if(state) {
+    rb_set_errinfo(Qnil);
+
+    yield_error(compiled_schema, data, context, error_key);
+    return;
+  }
+
+  if(!RTEST(result))
+    yield_error(compiled_schema, data, context, error_key);
+}
+
+static VALUE custom_format_validation_callable_for(VALUE format_val, VALUE custom_formats) {
+  if(NIL_P(custom_formats) || custom_formats == Qundef)
+    return Qundef;
+
+  VALUE callable = rb_hash_aref(custom_formats, format_val);
+
+  if(NIL_P(callable))
+    return Qundef;
+
+  return callable;
+}
+
+static VALUE custom_format_error_key_for(VALUE format_val) {
+  VALUE error_key = rb_str_new_cstr("format_");
+  rb_str_append(error_key, format_val);
+  rb_str_freeze(error_key);
+
+  return error_key;
+}
+
+bool set_custom_format_validation_function_for_compiled_schema(CompiledSchema *compiled_schema, VALUE format_val, VALUE custom_formats) {
+  VALUE callable = custom_format_validation_callable_for(format_val, custom_formats);
+
+  if(Qundef == callable) return false;
+
+  compiled_schema->format_validation_function = validate_custom_format;
+  compiled_schema->custom_format_callable_val = callable;
+  compiled_schema->custom_format_error_key_val = custom_format_error_key_for(format_val);
+
+  return true;
+}

data/ext/fast_json/schema/formats/custom_format.h

@@ -0,0 +1,4 @@
+#include <ruby.h>
+#include "types/compiled_schema.h"
+
+bool set_custom_format_validation_function_for_compiled_schema(CompiledSchema *, VALUE, VALUE);

data/ext/fast_json/schema/formats/date.c

@@ -0,0 +1,48 @@
+#include "date.h"
+#include "error.h"
+
+#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
+
+/*
+* Days in each month of the year.
+* February has 28 days in a common year and 29 days in a leap year(See `days_in_month` function for more details).
+*/
+static const int days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+static bool is_leap_year(int year) {
+  return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
+}
+
+static int days_in_month(int year, int month) {
+  if(month == 2 && is_leap_year(year)) return 29;
+
+  return days[month - 1];
+}
+
+/*
+* Strict RFC 3339 full-date parser: YYYY-MM-DD
+* Returns true if valid, false otherwise.
+*/
+bool parse_full_date(const char *s, long len) {
+  if(len != 10) return false;
+
+  if(!IS_DIGIT(s[0]) || !IS_DIGIT(s[1]) || !IS_DIGIT(s[2]) || !IS_DIGIT(s[3])) return false;
+  if(s[4] != '-') return false;
+  if(!IS_DIGIT(s[5]) || !IS_DIGIT(s[6])) return false;
+  if(s[7] != '-') return false;
+  if(!IS_DIGIT(s[8]) || !IS_DIGIT(s[9])) return false;
+
+  int year  = (s[0] - '0') * 1000 + (s[1] - '0') * 100 + (s[2] - '0') * 10 + (s[3] - '0');
+  int month = (s[5] - '0') * 10 + (s[6] - '0');
+  int day   = (s[8] - '0') * 10 + (s[9] - '0');
+
+  if(month < 1 || month > 12) return false;
+  if(day < 1 || day > days_in_month(year, month)) return false;
+
+  return true;
+}
+
+void validate_format_date(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_full_date(RSTRING_PTR(data), RSTRING_LEN(data)))
+    yield_error(compiled_schema, data, context, "format_date");
+}

data/ext/fast_json/schema/formats/date.h

@@ -0,0 +1,5 @@
+#include <ruby.h>
+#include "types/compiled_schema.h"
+
+bool parse_full_date(const char *s, long len);
+void validate_format_date(VALUE, CompiledSchema *, VALUE, Context *);

data/ext/fast_json/schema/formats/date_time.c

@@ -0,0 +1,22 @@
+#include "date_time.h"
+#include "date.h"
+#include "time.h"
+#include "error.h"
+
+/*
+* Strict RFC 3339 date-time: full-date "T" full-time
+* Only uppercase "T" separator is accepted.
+*/
+void validate_format_date_time(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  const char *s = RSTRING_PTR(data);
+  long len = RSTRING_LEN(data);
+
+  if(len < 12 || s[10] != 'T')
+    return yield_error(compiled_schema, data, context, "format_date_time");
+
+  if(!parse_full_date(s, 10))
+    return yield_error(compiled_schema, data, context, "format_date_time");
+
+  if(!parse_full_time(s + 11, len - 11))
+    return yield_error(compiled_schema, data, context, "format_date_time");
+}

data/ext/fast_json/schema/formats/date_time.h

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

data/ext/fast_json/schema/formats/email.c

@@ -0,0 +1,8 @@
+#include "email.h"
+#include "formats/utils/addr_spec_parser.h"
+#include "error.h"
+
+void validate_format_email(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_addr_spec(RSTRING_PTR(data), RSTRING_LEN(data), false))
+    yield_error(compiled_schema, data, context, "format_email");
+}

data/ext/fast_json/schema/formats/email.h

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

data/ext/fast_json/schema/formats/format.c

@@ -0,0 +1,68 @@
+#include "format.h"
+#include "date.h"
+#include "time.h"
+#include "date_time.h"
+#include "email.h"
+#include "idn_email.h"
+#include "hostname.h"
+#include "idn_hostname.h"
+#include "ipv4.h"
+#include "ipv6.h"
+#include "uri.h"
+#include "uri_reference.h"
+#include "iri.h"
+#include "iri_reference.h"
+#include "uri_template.h"
+#include "regex.h"
+#include "json_pointer.h"
+#include "relative_json_pointer.h"
+#include "custom_format.h"
+
+static void no_op_format_validate(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  return;
+}
+
+static format_validation_function built_in_format_validation_function_for(VALUE format_val) {
+  const char *format_str = StringValueCStr(format_val);
+
+  if(strcmp(format_str, "date") == 0)                  return validate_format_date;
+  if(strcmp(format_str, "time") == 0)                  return validate_format_time;
+  if(strcmp(format_str, "date-time") == 0)             return validate_format_date_time;
+  if(strcmp(format_str, "email") == 0)                 return validate_format_email;
+  if(strcmp(format_str, "idn-email") == 0)             return validate_format_idn_email;
+  if(strcmp(format_str, "hostname") == 0)              return validate_format_hostname;
+  if(strcmp(format_str, "idn-hostname") == 0)          return validate_format_idn_hostname;
+  if(strcmp(format_str, "ipv4") == 0)                  return validate_format_ipv4;
+  if(strcmp(format_str, "ipv6") == 0)                  return validate_format_ipv6;
+  if(strcmp(format_str, "uri") == 0)                   return validate_format_uri;
+  if(strcmp(format_str, "uri-reference") == 0)         return validate_format_uri_reference;
+  if(strcmp(format_str, "iri") == 0)                   return validate_format_iri;
+  if(strcmp(format_str, "iri-reference") == 0)         return validate_format_iri_reference;
+  if(strcmp(format_str, "uri-template") == 0)          return validate_format_uri_template;
+  if(strcmp(format_str, "regex") == 0)                 return validate_format_regex;
+  if(strcmp(format_str, "json-pointer") == 0)          return validate_format_json_pointer;
+  if(strcmp(format_str, "relative-json-pointer") == 0) return validate_format_relative_json_pointer;
+
+  return no_op_format_validate;
+}
+
+static bool set_built_in_format_validation_function_for_compiled_schema(CompiledSchema *compiled_schema, VALUE format_val) {
+  compiled_schema->format_validation_function = built_in_format_validation_function_for(format_val);
+
+  return true;
+}
+
+static void set_no_op_format_validation_function_for_compiled_schema(CompiledSchema *compiled_schema) {
+  compiled_schema->format_validation_function = no_op_format_validate;
+}
+
+void set_format_validation_function_for_compiled_schema(CompiledSchema *compiled_schema, VALUE format_val, VALUE custom_formats) {
+  if(!RB_TYPE_P(format_val, T_STRING)) {
+    set_no_op_format_validation_function_for_compiled_schema(compiled_schema);
+
+    return;
+  }
+
+  set_custom_format_validation_function_for_compiled_schema(compiled_schema, format_val, custom_formats) || 
+    set_built_in_format_validation_function_for_compiled_schema(compiled_schema, format_val);
+}

data/ext/fast_json/schema/formats/format.h

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

data/ext/fast_json/schema/formats/hostname.c

@@ -0,0 +1,8 @@
+#include "hostname.h"
+#include "formats/utils/hostname_parser.h"
+#include "error.h"
+
+void validate_format_hostname(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_hostname(RSTRING_PTR(data), RSTRING_LEN(data), false))
+    yield_error(compiled_schema, data, context, "format_hostname");
+}

data/ext/fast_json/schema/formats/hostname.h

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

data/ext/fast_json/schema/formats/idn_email.c

@@ -0,0 +1,8 @@
+#include "idn_email.h"
+#include "formats/utils/addr_spec_parser.h"
+#include "error.h"
+
+void validate_format_idn_email(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_addr_spec(RSTRING_PTR(data), RSTRING_LEN(data), true))
+    yield_error(compiled_schema, data, context, "format_idn_email");
+}

data/ext/fast_json/schema/formats/idn_email.h

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

data/ext/fast_json/schema/formats/idn_hostname.c

@@ -0,0 +1,8 @@
+#include "idn_hostname.h"
+#include "formats/utils/hostname_parser.h"
+#include "error.h"
+
+void validate_format_idn_hostname(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_hostname(RSTRING_PTR(data), RSTRING_LEN(data), true))
+    yield_error(compiled_schema, data, context, "format_idn_hostname");
+}

data/ext/fast_json/schema/formats/idn_hostname.h

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

data/ext/fast_json/schema/formats/ipv4.c

@@ -0,0 +1,8 @@
+#include "ipv4.h"
+#include "formats/utils/ip_parser.h"
+#include "error.h"
+
+void validate_format_ipv4(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_ipv4(RSTRING_PTR(data), RSTRING_LEN(data)))
+    yield_error(compiled_schema, data, context, "format_ipv4");
+}

data/ext/fast_json/schema/formats/ipv4.h

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

data/ext/fast_json/schema/formats/ipv6.c

@@ -0,0 +1,8 @@
+#include "ipv6.h"
+#include "formats/utils/ip_parser.h"
+#include "error.h"
+
+void validate_format_ipv6(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_ipv6(RSTRING_PTR(data), RSTRING_LEN(data)))
+    yield_error(compiled_schema, data, context, "format_ipv6");
+}

data/ext/fast_json/schema/formats/ipv6.h

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

data/ext/fast_json/schema/formats/iri.c

@@ -0,0 +1,8 @@
+#include "iri.h"
+#include "formats/utils/uri_parser.h"
+#include "error.h"
+
+void validate_format_iri(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_uri_reference(RSTRING_PTR(data), RSTRING_LEN(data), true, true))
+    yield_error(compiled_schema, data, context, "format_iri");
+}

data/ext/fast_json/schema/formats/iri.h

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

data/ext/fast_json/schema/formats/iri_reference.c

@@ -0,0 +1,8 @@
+#include "iri_reference.h"
+#include "formats/utils/uri_parser.h"
+#include "error.h"
+
+void validate_format_iri_reference(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_uri_reference(RSTRING_PTR(data), RSTRING_LEN(data), false, true))
+    yield_error(compiled_schema, data, context, "format_iri_reference");
+}

data/ext/fast_json/schema/formats/iri_reference.h

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

data/ext/fast_json/schema/formats/json_pointer.c

@@ -0,0 +1,8 @@
+#include "json_pointer.h"
+#include "formats/utils/json_pointer_parser.h"
+#include "error.h"
+
+void validate_format_json_pointer(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_json_pointer(RSTRING_PTR(data), RSTRING_LEN(data)))
+    yield_error(compiled_schema, data, context, "format_json_pointer");
+}

data/ext/fast_json/schema/formats/json_pointer.h

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

data/ext/fast_json/schema/formats/regex.c

@@ -0,0 +1,27 @@
+#include "regex.h"
+#include "error.h"
+
+#include <ruby.h>
+
+/*
+* JSON Schema section 7.3.8 cites ECMA-262 section 21.2 as the regex dialect.
+*
+* This implementation delegates to Ruby's Regexp.new (Onigmo engine), which
+* differs from strict ECMA-262 in some edge cases. 
+*
+* The divergence matches the behavior of other Ruby JSON Schema validators.
+*/
+static VALUE try_compile_regex(VALUE data) {
+  return rb_reg_new_str(data, 0);
+}
+
+void validate_format_regex(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  int state = 0;
+  rb_protect(try_compile_regex, data, &state);
+
+  if(state) {
+    rb_set_errinfo(Qnil);
+
+    yield_error(compiled_schema, data, context, "format_regex");
+  }
+}

data/ext/fast_json/schema/formats/regex.h

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

data/ext/fast_json/schema/formats/relative_json_pointer.c

@@ -0,0 +1,57 @@
+#include "relative_json_pointer.h"
+#include "formats/utils/json_pointer_parser.h"
+#include "error.h"
+
+#include <stdbool.h>
+
+#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
+
+/*
+* draft-handrews-relative-json-pointer-02 section 3 Relative JSON Pointer parser.
+*
+*   relative-json-pointer = non-negative-integer ( "#" / json-pointer )
+*   non-negative-integer  = "0" / non-zero-digit *DIGIT
+*
+* The integer prefix may not have leading zeros (e.g. "01" is invalid).
+* The trailing portion may be "#" (key/index reference) or a valid JSON
+* Pointer including the empty string ("0" alone is valid).
+*/
+static bool parse_relative_json_pointer(const char *s, long len) {
+  if(len == 0) return false;
+
+  long pos = 0;
+  unsigned char first = (unsigned char)s[0];
+
+  /*
+  * Non-negative integer prefix
+  */
+  if(first == '0') {
+    pos = 1;
+  } else if(first >= '1' && first <= '9') {
+    pos = 1;
+
+    while(pos < len && IS_DIGIT((unsigned char)s[pos])) pos++;
+  } else {
+    return false;
+  }
+
+  /* 
+  * Integer prefix only
+  */
+  if(pos == len) return true;
+
+  /* 
+  * "#" alone
+  */
+  if(s[pos] == '#') return pos + 1 == len;
+
+  /* 
+  * A valid JSON Pointer
+  */
+  return parse_json_pointer(s + pos, len - pos);
+}
+
+void validate_format_relative_json_pointer(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_relative_json_pointer(RSTRING_PTR(data), RSTRING_LEN(data)))
+    yield_error(compiled_schema, data, context, "format_relative_json_pointer");
+}

data/ext/fast_json/schema/formats/relative_json_pointer.h

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

data/ext/fast_json/schema/formats/time.c

@@ -0,0 +1,65 @@
+#include "time.h"
+#include "error.h"
+
+#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
+
+/*
+* Strict RFC 3339 full-time parser: HH:MM:SS[.fraction](Z|(+|-)HH:MM)
+* Returns true if valid, false otherwise.
+*/
+bool parse_full_time(const char *s, long len) {
+  if(len < 9) return false;
+
+  if(!IS_DIGIT(s[0]) || !IS_DIGIT(s[1])) return false;
+  if(s[2] != ':') return false;
+  if(!IS_DIGIT(s[3]) || !IS_DIGIT(s[4])) return false;
+  if(s[5] != ':') return false;
+  if(!IS_DIGIT(s[6]) || !IS_DIGIT(s[7])) return false;
+
+  int hour   = (s[0] - '0') * 10 + (s[1] - '0');
+  int minute = (s[3] - '0') * 10 + (s[4] - '0');
+  int second = (s[6] - '0') * 10 + (s[7] - '0');
+
+  if(hour > 23) return false;
+  if(minute > 59) return false;
+  if(second > 60) return false; // 60 is allowed for leap second per RFC 3339
+
+  long pos = 8;
+
+  /*
+  * Fractional part calculation.
+  * Fractional part is optional(See RFC 3339 for more details).
+  */
+  if(s[pos] == '.') {
+    pos++;
+
+    long fraction_start = pos;
+
+    while(pos < len && IS_DIGIT(s[pos])) pos++;
+
+    if(pos == fraction_start) return false; // empty fractional part(`12:34:56.`)
+  }
+
+  if(pos >= len) return false;
+
+  if(s[pos] == 'Z') return pos == len - 1;
+
+  if(s[pos] != '+' && s[pos] != '-') return false;
+  if(len - pos != 6) return false;
+  if(!IS_DIGIT(s[pos + 1]) || !IS_DIGIT(s[pos + 2])) return false;
+  if(s[pos + 3] != ':') return false;
+  if(!IS_DIGIT(s[pos + 4]) || !IS_DIGIT(s[pos + 5])) return false;
+
+  int offset_hour   = (s[pos + 1] - '0') * 10 + (s[pos + 2] - '0');
+  int offset_minute = (s[pos + 4] - '0') * 10 + (s[pos + 5] - '0');
+
+  if(offset_hour > 23) return false;
+  if(offset_minute > 59) return false;
+
+  return true;
+}
+
+void validate_format_time(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_full_time(RSTRING_PTR(data), RSTRING_LEN(data)))
+    yield_error(compiled_schema, data, context, "format_time");
+}

data/ext/fast_json/schema/formats/time.h

@@ -0,0 +1,5 @@
+#include <ruby.h>
+#include "types/compiled_schema.h"
+
+bool parse_full_time(const char *s, long len);
+void validate_format_time(VALUE, CompiledSchema *, VALUE, Context *);

data/ext/fast_json/schema/formats/uri.c

@@ -0,0 +1,8 @@
+#include "uri.h"
+#include "formats/utils/uri_parser.h"
+#include "error.h"
+
+void validate_format_uri(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_uri_reference(RSTRING_PTR(data), RSTRING_LEN(data), true, false))
+    yield_error(compiled_schema, data, context, "format_uri");
+}

data/ext/fast_json/schema/formats/uri.h

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

data/ext/fast_json/schema/formats/uri_reference.c

@@ -0,0 +1,8 @@
+#include "uri_reference.h"
+#include "formats/utils/uri_parser.h"
+#include "error.h"
+
+void validate_format_uri_reference(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_uri_reference(RSTRING_PTR(data), RSTRING_LEN(data), false, false))
+    yield_error(compiled_schema, data, context, "format_uri_reference");
+}

data/ext/fast_json/schema/formats/uri_reference.h

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

data/ext/fast_json/schema/formats/uri_template.c

@@ -0,0 +1,8 @@
+#include "uri_template.h"
+#include "formats/utils/uri_template_parser.h"
+#include "error.h"
+
+void validate_format_uri_template(VALUE schema, CompiledSchema *compiled_schema, VALUE data, Context *context) {
+  if(!parse_uri_template(RSTRING_PTR(data), RSTRING_LEN(data)))
+    yield_error(compiled_schema, data, context, "format_uri_template");
+}

data/ext/fast_json/schema/formats/uri_template.h

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