ruby_rnv 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8fd8bf859c9269e4001838b7399bb2824ab6af9dad1ee25468c7534e3618fcc
-  data.tar.gz: b5a09f8fb49485d338039d91b2f4c4f3f4f6815c68b976f1db716cdda5a4300e
+  metadata.gz: d336dc0c4dae28d9aa530925a9d322cc2a46598d77dc179da6785e47250fe552
+  data.tar.gz: 4e04b15b29ba46fad249f180b923def4cb69e04a041788022769a80ae4a0fb64
 SHA512:
-  metadata.gz: c50fb3f7d4d5b38853169e4043c333b05ad2320c434f10a5474acca146b58769e17e75336cc77c1c7ebd7c3de81925871d3d6dd5f9188b8d126bdfbd5f39093a
-  data.tar.gz: 9314404ae4355a652ec4e0191b68ce908a0a50b87def123b2c2b3b46415c6742477bc6078f49179b009f33925d41fb9736e053e8031f1ae6621b8816e1315125
+  metadata.gz: 8578ad4848314ed6f152bdd39e8824ad95b705ff6c6d32c150b8491564a0a78997455627903f1c8d00f43f581178c0c1dbb75c2e1ca4358f47ad1e962e98eac9
+  data.tar.gz: 6b3a9ad08b327a3931a3c944a43ecbb48dbcdf6f1a99dceb0c1e5935916254a2e88d45f7d7e26f6b9a374e39355c7e2f69d39777b4b7e5bf3fa0f6b44cbf877c

data/ext/rnv/ruby_rnv.c

@@ -56,7 +56,7 @@ typedef struct document
 
 } document_t;
 
-VALUE RNV;
+VALUE RNV, SchemaNotLoaded, Error, Document;
 
 // convert error code to symbol
 ID errno_to_id(int erno)
@@ -275,7 +275,7 @@ int ruby_verror_handler(rnv_t *rnv, int erno, char *format, va_list ap)
   // lazyly strip with ruby
   rb_funcall(error_str, rb_intern("strip!"), 0);
 
-  VALUE err_class = rb_const_get(RNV, rb_intern("Error"));
+  VALUE err_class = Error;
   VALUE err_obj = rb_class_new_instance(0, NULL, err_class);
   rb_iv_set(err_obj, "@document", self);
   rb_iv_set(err_obj, "@code", error_erno);
@@ -317,61 +317,6 @@ int ruby_verror_handler(rnv_t *rnv, int erno, char *format, va_list ap)
   rb_ary_push(errors, err_obj);
 }
 
-/*
- * @return [String]
- */
-VALUE rb_error_inspect(VALUE self)
-{
-  VALUE code = rb_iv_get(self, "@code");
-  VALUE message = rb_iv_get(self, "@message");
-  VALUE expected = rb_iv_get(self, "@expected");
-  VALUE line = rb_iv_get(self, "@line");
-  VALUE col = rb_iv_get(self, "@col");
-
-  VALUE ret = rb_str_new2("#<RNV::Error ");
-  ret = rb_str_cat2(ret, "code: :");
-  ret = rb_str_append(ret, rb_obj_as_string(code));
-  ret = rb_str_cat2(ret, ", ");
-  ret = rb_str_cat2(ret, "message: '");
-  ret = rb_str_append(ret, message);
-  ret = rb_str_cat2(ret, "', ");
-  ret = rb_str_cat2(ret, "expected: '");
-  ret = rb_str_append(ret, expected);
-  ret = rb_str_cat2(ret, "', ");
-  ret = rb_str_cat2(ret, "line: ");
-  ret = rb_str_append(ret, rb_obj_as_string(line));
-  ret = rb_str_cat2(ret, ", ");
-  ret = rb_str_cat2(ret, "col: ");
-  ret = rb_str_append(ret, rb_obj_as_string(col));
-  ret = rb_str_cat2(ret, ">");
-  return ret;
-}
-
-/*
- * @return [String]
- */
-VALUE rb_error_to_s(VALUE self)
-{
-  VALUE message = rb_iv_get(self, "@message");
-  VALUE expected = rb_iv_get(self, "@expected");
-  VALUE line = rb_iv_get(self, "@line");
-  VALUE col = rb_iv_get(self, "@col");
-
-  VALUE ret = rb_str_new2("");
-
-  ret = rb_str_append(ret, rb_obj_as_string(line));
-  ret = rb_str_cat2(ret, ":");
-  ret = rb_str_append(ret, rb_obj_as_string(col));
-
-  ret = rb_str_cat2(ret, ": error: ");
-
-  ret = rb_str_append(ret, message);
-  ret = rb_str_cat2(ret, "\n");
-  ret = rb_str_append(ret, expected);
-
-  return ret;
-}
-
 void document_free(document_t *document)
 {
   // FIXME : introduce *_delete functions
@@ -417,7 +362,8 @@ void document_free(document_t *document)
 
   free(document->rnv);
 
-  free(document->text);
+  if (document->text)
+    free(document->text);
 
   ruby_xfree(document);
 }
@@ -450,9 +396,12 @@ VALUE rb_document_init(VALUE self)
   document->rnv->user_data = (void *)self;
   document->rnv->verror_handler = &ruby_verror_handler;
   document->nexp = 16; /* maximum number of candidates to display */
+  document->text = NULL;
 
   rb_iv_set(self, "@errors", rb_ary_new2(0));
 
+  rb_iv_set(self, "@libraries", rb_hash_new());
+
   return self;
 }
 
@@ -470,7 +419,7 @@ static void document_load(document_t *document)
 /*
  * load schema from a buffer
  * @param [String] r_str buffer
- * @return [String]
+ * @return [Boolean]
  */
 VALUE rb_document_load_string(VALUE self, VALUE r_str)
 {
@@ -489,40 +438,42 @@ VALUE rb_document_load_string(VALUE self, VALUE r_str)
                            document->fn,
                            RSTRING_PTR(r_str), RSTRING_LEN(r_str));
 
-  document_load(document);
-  return INT2NUM(document->ok);
+  if (document->opened)
+  {
+    document_load(document);
+    return Qtrue;
+  }
+  else
+    return Qfalse;
 }
 
 /*
  * load schema from a file
  * @param [String] r_fn filename
- * @return [String]
+ * @return [Boolean]
  */
 VALUE rb_document_load_file(VALUE self, VALUE r_fn)
 {
   document_t *document;
   Data_Get_Struct(self, document_t, document);
 
-  switch (TYPE(r_fn))
-  {
-  case T_STRING:
-    document->fn = RSTRING_PTR(r_fn);
+  Check_Type(r_fn, T_STRING);
 
-    document->opened = rnl_fn(document->rnv,
-                              document->rnc_st,
-                              document->rn_st,
-                              document->rnd_st,
-                              document->fn);
+  document->fn = RSTRING_PTR(r_fn);
 
-    break;
-  case T_FILE: // TODO
-  default:
-    rb_raise(rb_eTypeError, "invalid argument");
-    break;
-  }
+  document->opened = rnl_fn(document->rnv,
+                            document->rnc_st,
+                            document->rn_st,
+                            document->rnd_st,
+                            document->fn);
 
-  document_load(document);
-  return INT2NUM(document->ok);
+  if (document->opened)
+  {
+    document_load(document);
+    return Qtrue;
+  }
+  else
+    return Qfalse;
 }
 
 /*
@@ -548,8 +499,61 @@ static void flush_text(document_t *document)
   document->text[document->n_txt = 0] = '\0';
 }
 
+static int rb_dtl_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ, char *val, char *s, int n)
+{
+  VALUE self = (VALUE)rnv->user_data;
+  VALUE libraries = rb_iv_get(self, "@libraries");
+  VALUE lib = rb_hash_aref(libraries, INT2FIX(uri));
+
+  VALUE ret = rb_funcall(lib, rb_intern("equal"), 4,
+                         rb_str_new2(typ), rb_str_new2(val), rb_str_new2(s), INT2FIX(n));
+
+  return RTEST(ret);
+}
+
+static int rb_dtl_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ, char *ps, char *s, int n)
+{
+  VALUE self = (VALUE)rnv->user_data;
+  VALUE libraries = rb_iv_get(self, "@libraries");
+  VALUE lib = rb_hash_aref(libraries, INT2FIX(uri));
+
+  VALUE ret = rb_funcall(lib, rb_intern("allows"), 4,
+                         rb_str_new2(typ), rb_str_new2(ps), rb_str_new2(s), INT2FIX(n));
+
+  return RTEST(ret);
+}
+
 /*
- * begin a new document
+ * add a new datatype library
+ * @see https://www.oasis-open.org/committees/relax-ng/spec-20010811.html#IDA1I1R
+ * @param [String] r_ns unique ns URL for this datatype
+ * @param [RNV::DataTypeLibrary] r_cb_obj
+ * @return [nil]
+ */
+VALUE rb_document_add_dtl(VALUE self, VALUE r_ns, VALUE r_cb_obj)
+{
+  document_t *document;
+  Data_Get_Struct(self, document_t, document);
+
+  if (document->opened)
+  {
+    Check_Type(r_ns, T_STRING);
+
+    char *suri = RSTRING_PTR(r_ns);
+
+    drv_add_dtl(document->rnv, document->drv_st, document->rn_st, suri, &rb_dtl_equal, &rb_dtl_allows);
+
+    int uri = document->drv_st->dtl[document->drv_st->n_dtl - 1].uri;
+
+    VALUE libraries = rb_iv_get(self, "@libraries");
+
+    rb_hash_aset(libraries, INT2FIX(uri), r_cb_obj);
+  }
+  return Qnil;
+}
+
+/*
+ * begin parsing a new document
  * @return [nil]
  */
 VALUE rb_document_begin(VALUE self)
@@ -557,6 +561,12 @@ VALUE rb_document_begin(VALUE self)
   document_t *document;
   Data_Get_Struct(self, document_t, document);
 
+  if (!document->opened)
+    rb_raise(SchemaNotLoaded, "schema was not loaded correctly");
+
+  // reset errors
+  rb_iv_set(self, "@errors", rb_ary_new2(0));
+
   m_free(document->text);
   document->text = (char *)m_alloc(document->len_txt = LEN_T, sizeof(char));
 
@@ -572,14 +582,17 @@ VALUE rb_document_begin(VALUE self)
 /*
  * to be called by SAX characters handler
  * @param [String] r_str characters
- * @return [Integer]
+ * @return [Boolean]
  */
 VALUE rb_document_characters(VALUE self, VALUE r_str)
 {
   document_t *document;
   Data_Get_Struct(self, document_t, document);
 
-  if (document->opened && document->current != document->rnv->rn_notAllowed)
+  if (!document->opened)
+    rb_raise(SchemaNotLoaded, "schema was not loaded correctly");
+
+  if (document->current != document->rnv->rn_notAllowed)
   {
     Check_Type(r_str, T_STRING);
     char *s = RSTRING_PTR(r_str);
@@ -600,22 +613,26 @@ VALUE rb_document_characters(VALUE self, VALUE r_str)
     document->text[document->n_txt] = '\0'; /* '\0' guarantees that the text is bounded, and strto[ld] work for data */
   }
 
-  return INT2NUM(document->ok);
+  return RTEST(document->ok);
 }
 
 /*
  * to be called by SAX start tag handler
  * @param [String] r_name tag name, must be in the form 'NS_URI:TAG_NAME'
- * @param [Array<String>] r_attrs flattened array of tag attributes in the form ['NS_URI:ATTR_NAME','ATTR_VALUE']
- * @return [Integer]
+ * @param [Array<Array<String>>] r_attrs flattened array of tag attributes in the form [['NS_URI:ATTR_NAME','ATTR_VALUE']]
+ * @return [Boolean]
  */
 VALUE rb_document_start_tag(VALUE self, VALUE r_name, VALUE r_attrs)
 {
   document_t *document;
   Data_Get_Struct(self, document_t, document);
 
-  if (document->opened && document->current != document->rnv->rn_notAllowed)
+  if (!document->opened)
+    rb_raise(SchemaNotLoaded, "schema was not loaded correctly");
+
+  if (document->current != document->rnv->rn_notAllowed)
   {
+    int i;
     char *name;
     char **attrs;
 
@@ -623,20 +640,22 @@ VALUE rb_document_start_tag(VALUE self, VALUE r_name, VALUE r_attrs)
     name = RSTRING_PTR(r_name);
 
     Check_Type(r_attrs, T_ARRAY);
-    unsigned int attrs_len = RARRAY_LEN(r_attrs);
+
+    // lazyly flatten with ruby
+    VALUE r_flat_attrs = rb_funcall(r_attrs, rb_intern("flatten"), 0);
+    unsigned int attrs_len = RARRAY_LEN(r_flat_attrs);
 
     attrs = malloc(sizeof(char *) * (attrs_len + 1));
 
-    for (int i = 0; i < attrs_len; i++)
+    for (i = 0; i < attrs_len; i++)
     {
-      attrs[i] = RSTRING_PTR(rb_ary_entry(r_attrs, i));
+      attrs[i] = RSTRING_PTR(rb_ary_entry(r_flat_attrs, i));
     }
     attrs[attrs_len] = 0; // zero terminated
 
     document->mixed = 1;
 
     flush_text(document);
-    //printf("RNV START %d/%d %s %d\n", current, previous, name, attrs_len);
     document->ok = rnv_start_tag(document->rnv, document->drv_st, document->rn_st, document->rx_st,
                                  &document->current, &document->previous, (char *)name, (char **)attrs) &&
                    document->ok;
@@ -645,20 +664,23 @@ VALUE rb_document_start_tag(VALUE self, VALUE r_name, VALUE r_attrs)
     free(attrs);
   }
 
-  return INT2NUM(document->ok);
+  return RTEST(document->ok);
 }
 
 /*
  * to be called by SAX end tag handler
  * @param [String] r_name tag name, must be in the form 'NS_URI:TAG_NAME'
- * @return [Integer]
+ * @return [Boolean]
  */
 VALUE rb_document_end_tag(VALUE self, VALUE r_name)
 {
   document_t *document;
   Data_Get_Struct(self, document_t, document);
 
-  if (document->opened && document->current != document->rnv->rn_notAllowed)
+  if (!document->opened)
+    rb_raise(SchemaNotLoaded, "schema was not loaded correctly");
+
+  if (document->current != document->rnv->rn_notAllowed)
   {
     char *name;
 
@@ -667,7 +689,6 @@ VALUE rb_document_end_tag(VALUE self, VALUE r_name)
 
     flush_text(document);
 
-    //printf("RNV END %d/%d %s\n", current, previous, name);
     document->ok = rnv_end_tag(document->rnv, document->drv_st, document->rn_st,
                                &document->current, &document->previous, (char *)name) &&
                    document->ok;
@@ -675,7 +696,7 @@ VALUE rb_document_end_tag(VALUE self, VALUE r_name)
     document->mixed = 1;
   }
 
-  return INT2NUM(document->ok);
+  return RTEST(document->ok);
 }
 
 // The initialization method for this module
@@ -683,21 +704,15 @@ void Init_rnv()
 {
   RNV = rb_define_module("RNV");
 
-  VALUE Error = rb_define_class_under(RNV, "Error", rb_cObject);
+  SchemaNotLoaded = rb_define_class_under(RNV, "SchemaNotLoaded", rb_eStandardError);
 
-  rb_define_method(Error, "inspect", rb_error_inspect, 0);
-  rb_define_method(Error, "to_s", rb_error_to_s, 0);
+  Error = rb_define_class_under(RNV, "Error", rb_cObject);
 
   /*
    * error symbol code
    * @return [Symbol]
    */
   rb_define_attr(Error, "code", 1, 0);
-  /*
-   * error message
-   * @return [String]
-   */
-  rb_define_attr(Error, "message", 1, 0);
   /*
    * error line
    * @return [Integer]
@@ -708,8 +723,18 @@ void Init_rnv()
    * @return [Integer]
    */
   rb_define_attr(Error, "col", 1, 0);
+  /*
+   * error message
+   * @return [String]
+   */
+  rb_define_attr(Error, "message", 1, 0);
+  /*
+   * what was expected
+   * @return [String]
+   */
+  rb_define_attr(Error, "expected", 1, 0);
 
-  VALUE Document = rb_define_class_under(RNV, "Document", rb_cObject);
+  Document = rb_define_class_under(RNV, "Document", rb_cObject);
 
   rb_define_alloc_func(Document, rb_document_alloc);
   rb_define_method(Document, "initialize", rb_document_init, 0);
@@ -718,6 +743,8 @@ void Init_rnv()
   rb_define_method(Document, "load_string", rb_document_load_string, 1);
   rb_define_method(Document, "valid?", rb_document_valid, 0);
 
+  rb_define_method(Document, "add_datatype_library", rb_document_add_dtl, 2);
+
   rb_define_method(Document, "start_document", rb_document_begin, 0);
   rb_define_method(Document, "start_tag", rb_document_start_tag, 2);
   rb_define_method(Document, "characters", rb_document_characters, 1);

data/ext/rnv/src/drv.c

@@ -13,12 +13,6 @@
 #include "er.h"
 #include "drv.h"
 
-struct dtl {
-  int uri;
-  int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n);
-  int (*allows)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n);
-};
-
 #define LEN_DTL DRV_LEN_DTL
 #define LEN_M DRV_LEN_M
 #define PRIME_M DRV_PRIME_M
@@ -112,10 +106,10 @@ static void accept_m(rnv_t *rnv, drv_st_t *drv_st) {
   if(drv_st->i_m==drv_st->len_m) drv_st->memo=(int(*)[M_SIZE])m_stretch(drv_st->memo,drv_st->len_m=2*drv_st->i_m,drv_st->i_m,sizeof(int[M_SIZE]));
 }
 
-static int fallback_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n) {return 1;}
-static int fallback_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n) {return 1;}
+static int fallback_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n) {return 1;}
+static int fallback_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *ps,char *s,int n) {return 1;}
 
-static int builtin_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n) {
+static int builtin_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n) {
   int dt=rn_newDatatype(rnv, rn_st, 0,typ-rnv->rn_string);
   if(dt==rnv->rn_dt_string) return s_cmpn(val,s,n)==0;
   else if(dt==rnv->rn_dt_token) return s_tokcmpn(val,s,n)==0;
@@ -123,7 +117,7 @@ static int builtin_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,c
   return 0;
 }
 
-static int builtin_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n) {return 1;}
+static int builtin_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *ps,char *s,int n) {return 1;}
 
 static void windup(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st);
 
@@ -140,11 +134,11 @@ void drv_init(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st) {
     windup(rnv, drv_st, rn_st);
 }
 
-static int emb_xsd_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n) {
+static int emb_xsd_allows(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *ps,char *s,int n) {
   return xsd_allows(rx_st, typ,ps,s,n);
 }
 
-static int emb_xsd_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n) {
+static int emb_xsd_equal(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n) {
   return xsd_equal(rx_st, typ,val,s,n);
 }
 
@@ -160,7 +154,9 @@ void drv_clear(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st) {
   windup(rnv, drv_st, rn_st);
 }
 
-void drv_add_dtl(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, char *suri,int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n),int (*allows)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n)) {
+void drv_add_dtl(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, char *suri,
+    int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n),
+    int (*allows)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *ps,char *s,int n)) {
   if(drv_st->n_dtl==drv_st->len_dtl) drv_st->dtl=(struct dtl *)m_stretch(drv_st->dtl,drv_st->len_dtl=drv_st->n_dtl*2,drv_st->n_dtl,sizeof(struct dtl));
   drv_st->dtl[drv_st->n_dtl].uri=rn_newString(rnv, rn_st, suri);
   drv_st->dtl[drv_st->n_dtl].equal=equal;
@@ -381,13 +377,13 @@ static int text(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, drv_st_t *drv_st, in
     ret=rn_nullable(list(rnv, rn_st, rx_st, drv_st, p1,s,n))?rnv->rn_empty:rnv->rn_notAllowed;
     break;
   case RN_P_DATA: rn_Data(p,dt,ps); rn_Datatype(dt,lib,typ);
-    ret=getdtl(rnv, drv_st, lib)->allows(rnv,rn_st,rx_st,rnv->rn_string+typ,rnv->rn_string+ps,s,n)?rnv->rn_empty:rnv->rn_notAllowed;
+    ret=getdtl(rnv, drv_st, lib)->allows(rnv,rn_st,rx_st, lib, rnv->rn_string+typ,rnv->rn_string+ps,s,n)?rnv->rn_empty:rnv->rn_notAllowed;
     break;
   case RN_P_DATA_EXCEPT: rn_DataExcept(p,p1,p2);
     ret=text(rnv, rn_st, rx_st, drv_st, p1,s,n)==rnv->rn_empty&&!rn_nullable(text(rnv, rn_st, rx_st, drv_st, p2,s,n))?rnv->rn_empty:rnv->rn_notAllowed;
     break;
   case RN_P_VALUE: rn_Value(p,dt,val); rn_Datatype(dt,lib,typ);
-    ret=getdtl(rnv, drv_st, lib)->equal(rnv,rn_st,rx_st, rnv->rn_string+typ,rnv->rn_string+val,s,n)?rnv->rn_empty:rnv->rn_notAllowed;
+    ret=getdtl(rnv, drv_st, lib)->equal(rnv,rn_st,rx_st, lib, rnv->rn_string+typ,rnv->rn_string+val,s,n)?rnv->rn_empty:rnv->rn_notAllowed;
     break;
   default: assert(0);
   }

data/ext/rnv/src/drv.h

@@ -9,13 +9,21 @@
 
 #define DRV_ER_NODTL 0
 
+struct dtl {
+  int uri;
+  int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n);
+  int (*allows)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *ps,char *s,int n);
+};
+
 extern void drv_default_verror_handler(rnv_t *rnv, int erno,va_list ap);
 
 extern void drv_init(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, rx_st_t *rx_st);
 extern void drv_clear(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st);
 
 /* Expat passes character data unterminated.  Hence functions that can deal with cdata expect the length of the data */
-extern void drv_add_dtl(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, char *suri,int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *val,char *s,int n),int (*allows)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, char *typ,char *ps,char *s,int n));
+extern void drv_add_dtl(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, char *suri,
+int (*equal)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *val,char *s,int n),
+int (*allows)(rnv_t *rnv, rn_st_t *rn_st, rx_st_t *rx_st, int uri, char *typ,char *ps,char *s,int n));
 
 extern int drv_start_tag_open(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,char *suri,char *sname);
 extern int drv_start_tag_open_recover(rnv_t *rnv, drv_st_t *drv_st, rn_st_t *rn_st, int p,char *suri,char *sname);

data/lib/rnv.rb

@@ -1,2 +1,5 @@
 require 'rnv/rnv'
+require 'rnv/error'
 require 'rnv/validator'
+require 'rnv/data_type_library'
+require 'rnv/pre_processor'

data/lib/rnv/data_type_library.rb

@@ -0,0 +1,23 @@
+module RNV
+  # Datatype library callback object
+  # @see https://www.oasis-open.org/committees/relax-ng/spec-20010811.html#IDA1I1R
+  class DataTypeLibrary
+    # @param [String] typ
+    # @param [String] val
+    # @param [String] s
+    # @param [Integer] n
+    # @return [Boolean]
+    def equal(typ, val, s, n)
+      true
+    end
+
+    # @param [String] typ
+    # @param [String] ps
+    # @param [String] s
+    # @param [Integer] n
+    # @return [Boolean]
+    def allows(typ, ps, s, n)
+      true
+    end
+  end
+end

data/lib/rnv/error.rb

@@ -0,0 +1,13 @@
+module RNV
+  class Error
+    # @return [String]
+    def to_s
+      "#{@line}:#{@col}:error: #{@message}\n#{@expected}"
+    end
+
+    # @return [String]
+    def inspect
+      "#<RNV::Error code: :#{@code}, message: '#{@message}', expected: '#{@expected} line: #{@line}, column: #{@col}>"
+    end
+  end
+end

data/lib/rnv/pre_processor.rb

@@ -0,0 +1,25 @@
+module RNV
+  # Object to modify data before validation (eg: HTML5 data-* attributes)
+  class PreProcessor
+    # replace attributes before validate
+    # @param [Array<Array<String>>] attrs
+    # @return [Array<Array<String>>]
+    def attributes(attrs)
+      attrs
+    end
+
+    # replace tag name before validate
+    # @param [String] tag
+    # @return [String]
+    def tag(tag)
+      tag
+    end
+
+    # replace content text before validate
+    # @param [String] txt
+    # @return [String]
+    def text(txt)
+      txt
+    end
+  end
+end

data/lib/rnv/validator.rb

@@ -1,11 +1,12 @@
 require 'nokogiri'
 require 'rnv/rnv'
+require 'rnv/pre_processor'
 
 module RNV
   # @!visibility private
   class NokogiriSaxDocument < Nokogiri::XML::SAX::Document
     # @return [Nokogiri::XML::SAX::ParserContext]
-    attr_accessor :ctx
+    attr_accessor :ctx, :pre_processor
     # @param [RNV::Document] document
     def initialize(document)
       @document = document
@@ -15,23 +16,23 @@ module RNV
       update_line_col
       tag_attrs = attrs.map { |attr| [attr.uri ? "#{attr.uri}:#{attr.localname}" : attr.localname, attr.value] }
       tag_name = uri ? "#{uri}:#{name}" : name
-      @document.start_tag(tag_name, tag_attrs.flatten)
+      @document.start_tag(@pre_processor.tag(tag_name), @pre_processor.attributes(tag_attrs))
     end
 
     def end_element_namespace(name, prefix = nil, uri = nil)
       update_line_col
       tag_name = uri ? "#{uri}:#{name}" : name
-      @document.end_tag(tag_name)
+      @document.end_tag(@pre_processor.tag(tag_name))
     end
 
     def characters str
       update_line_col
-      @document.characters(str)
+      @document.characters(@pre_processor.text(str))
     end
 
     def cdata_block str
       update_line_col
-      @document.characters(str)
+      @document.characters(@pre_processor.text(str))
     end
 
     private
@@ -57,25 +58,29 @@ module RNV
     end
 
     # @param [String] str RNC schema buffer
+    # @return [Boolean] true if schema loaded successfuly
     def load_schema_from_string(str)
       @document.load_string(str)
     end
 
     # @param [String] file RNC schema filename
+    # @return [Boolean] true if schema loaded successfuly
     def load_schema_from_file(file)
       @document.load_file(file)
     end
 
     # parse and validate buffer
     # @param [String] str XML buffer to parse
+    # @param [RNV::PreProcessor] pre_processor an optional pre-processor for tag and attributes data
     # @return [Boolean] true if valid
-    def parse_string(str)
-      @document.errors = [] # reset errors
+    def parse_string(str, pre_processor = PreProcessor.new)
       @document.start_document
       rnv_doc = NokogiriSaxDocument.new(@document)
+      rnv_doc.pre_processor = pre_processor
 
       parser = Nokogiri::XML::SAX::Parser.new(rnv_doc)
       parser.parse_memory(str) do |ctx|
+        ctx.replace_entities = true
         rnv_doc.ctx = ctx
       end
 
@@ -84,16 +89,18 @@ module RNV
 
     # parse and validate file
     # @param [String, File] xml XML file to parse
+    # @param [RNV::PreProcessor] pre_processor an optional pre-processor for tag and attributes data
     # @return [Boolean] true if valid
-    def parse_file(xml)
-      @document.errors = [] # reset errors
+    def parse_file(xml, pre_processor = PreProcessor.new)
       @document.start_document
       rnv_doc = NokogiriSaxDocument.new(@document)
+      rnv_doc.pre_processor = pre_processor
 
       file = xml.is_a?(File) ? xml : File.open(xml)
 
       parser = Nokogiri::XML::SAX::Parser.new(rnv_doc)
       parser.parse(file) do |ctx|
+        ctx.replace_entities = true
         rnv_doc.ctx = ctx
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_rnv
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Julien Boulnois
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-07 00:00:00.000000000 Z
+date: 2021-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -147,8 +147,11 @@ files:
 - ext/rnv/src/xsd_tm.c
 - ext/rnv/src/xsd_tm.h
 - lib/rnv.rb
+- lib/rnv/data_type_library.rb
+- lib/rnv/error.rb
+- lib/rnv/pre_processor.rb
 - lib/rnv/validator.rb
-homepage: 
+homepage: https://github.com/immateriel/ruby_rnv
 licenses:
 - MIT
 metadata: {}
@@ -170,5 +173,5 @@ requirements: []
 rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
-summary: RelaxNG compact syntax validator
+summary: RelaxNG compact syntax validator for Ruby
 test_files: []