ruby_rnv 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a97a5b35a39aa2ad603660b81b9c13e04375dafbc9f537fec0720357befd53f8
-  data.tar.gz: 54dff4be913ec5e3e356cb43c5d58a936aa6aa76f38212212a19f3057875f22c
+  metadata.gz: 076d290b71d2baddf3f6655f99471138ba7a348ce04ac509f246a92c007d2c27
+  data.tar.gz: '014108a35aacd5f4c78804ef9740f40e314b9f28968f038f0746375acc259fff'
 SHA512:
-  metadata.gz: bacdd196d95d59883413268ab7dc70d68bd39d4d93876ca156687aceabd7d76cd917a09dbeea4537a3f3c96cbc883bd6f7cd35bf152ac0c421e6e9183f14c2a9
-  data.tar.gz: c43c097908014a8dc61fedab76ab407012077ec471fdc256aeca28d8261e3c90a4678f50a7b4308aa66efd96c008e1eb2e86f6fafe3ef1418b433b0da74a146c
+  metadata.gz: 4e79a6d9727dbf1736df5b972acc8fb609b996ed224cf7346e42269af7777a07be42dad27ce11ae7db2d151be1a5c27d39169301289537d45ec12303aab129e7
+  data.tar.gz: a52f9058d874dd8083a892e0aff3ca55f68bae0bbc6f34446b31bf1922ee0d74e14693ab4d2ef6bb2cf270a1f384cf0b9f32fc1dbe764dbb6e4d2bd936ca7b0d

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;
 }
 
@@ -550,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);
+}
+
+/*
+ * 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 a new document
+ * begin parsing a new document
  * @return [nil]
  */
 VALUE rb_document_begin(VALUE self)
@@ -559,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));
 
@@ -574,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);
@@ -602,21 +613,24 @@ 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;
@@ -626,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 (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;
@@ -648,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;
 
@@ -670,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;
@@ -678,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
@@ -686,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]
@@ -711,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);
@@ -721,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.(str))
     end
 
     private
@@ -57,22 +58,25 @@ 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|
@@ -85,11 +89,12 @@ 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)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_rnv
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Julien Boulnois
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-08 00:00:00.000000000 Z
+date: 2021-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -147,6 +147,9 @@ 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: https://github.com/immateriel/ruby_rnv
 licenses: