ox 2.14.18 → 2.14.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd178b1fd415d3a97ef3b60e73896d52fd3eea1e9ef7a32dd0de316e00a21542
-  data.tar.gz: f9813bab8a071e6ba9efa07a92c228d3ea783a29503cfc763e72e73220899fe8
+  metadata.gz: 8f79925bdad366a8453ecda24602c7372371b5ac90363def31f7a21c5f46e85a
+  data.tar.gz: 1d88152e72cd654b215592b9874f6cf4c018853fcbfe3a5e3a37aa4f15a7d0f1
 SHA512:
-  metadata.gz: 1a7cfc1bfbe0693f52f66f662d4f0f8eeabe20bc50ddefb854abde16e1f1e1c8236b64a2c1ebd51d6de18a697f588ff4d60f854e7b50b383db14ad6eed57ae92
-  data.tar.gz: ae9344f3607e94721eafda29f7255be6a36a0340dd4de3b03d249e616126ec340f5c9485f855ba342f33c951d7153c1b47e0b95aaada4e1936741f2b6755452c
+  metadata.gz: ed6c242bf2a70049e9af314614fc9c47f51fb4740a1fdb4785fa693d1c93586bf10b4a1c73ba60e6e88c39c6b6b6d283b324ffbd27cac51e915a1fc48c69b5a0
+  data.tar.gz: 8c0d35c215e6720fff4c82cb711f9f9991b6dfcd91c4ec1c74ac656c52ef1cb74fcc93a4171fbbe28b09aee0ceefe8c50173d20af4935321207db93f45009b18

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All changes to the Ox gem are documented here. Releases follow semantic versioning.
 
+## [2.14.19] - 2024-12-25
+
+### Fixed
+
+- Code cleanup in sax.c  to close issue #363.
+
+- Updated the dump options documentation to `:with_xml` option to resolve #352.
+
+- Updated the sax tests to pass to resolve #335.
+
+- Element#replace_text on nil `@nodes` no longer fails. Closes #364.
+
 ## [2.14.18] - 2024-03-21
 
 ### Fixed

data/ext/ox/builder.c

@@ -17,6 +17,19 @@
 
 #define MAX_DEPTH 128
 
+static void builder_free(void *ptr);
+
+static const rb_data_type_t ox_builder_type = {
+    "Ox/builder",
+    {
+        NULL,
+        builder_free,
+        NULL,
+    },
+    0,
+    0,
+};
+
 typedef struct _element {
     char *name;
     char  buf[64];
@@ -353,14 +366,14 @@ static VALUE builder_new(int argc, VALUE *argv, VALUE self) {
     init(b, 0, indent, buf_size);
 
     if (rb_block_given_p()) {
-        volatile VALUE rb = Data_Wrap_Struct(builder_class, NULL, builder_free, b);
+        volatile VALUE rb = TypedData_Wrap_Struct(builder_class, &ox_builder_type, b);
 
         rb_yield(rb);
         bclose(b);
 
         return to_s(b);
     } else {
-        return Data_Wrap_Struct(builder_class, NULL, builder_free, b);
+        return TypedData_Wrap_Struct(builder_class, &ox_builder_type, b);
     }
 }
 
@@ -408,12 +421,12 @@ static VALUE builder_file(int argc, VALUE *argv, VALUE self) {
     init(b, fileno(f), indent, buf_size);
 
     if (rb_block_given_p()) {
-        volatile VALUE rb = Data_Wrap_Struct(builder_class, NULL, builder_free, b);
+        volatile VALUE rb = TypedData_Wrap_Struct(builder_class, &ox_builder_type, b);
         rb_yield(rb);
         bclose(b);
         return Qnil;
     } else {
-        return Data_Wrap_Struct(builder_class, NULL, builder_free, b);
+        return TypedData_Wrap_Struct(builder_class, &ox_builder_type, b);
     }
 }
 
@@ -461,12 +474,12 @@ static VALUE builder_io(int argc, VALUE *argv, VALUE self) {
     init(b, fd, indent, buf_size);
 
     if (rb_block_given_p()) {
-        volatile VALUE rb = Data_Wrap_Struct(builder_class, NULL, builder_free, b);
+        volatile VALUE rb = TypedData_Wrap_Struct(builder_class, &ox_builder_type, b);
         rb_yield(rb);
         bclose(b);
         return Qnil;
     } else {
-        return Data_Wrap_Struct(builder_class, NULL, builder_free, b);
+        return TypedData_Wrap_Struct(builder_class, &ox_builder_type, b);
     }
 }
 
@@ -478,8 +491,9 @@ static VALUE builder_io(int argc, VALUE *argv, VALUE self) {
  * - +options+ - (Hash) version or encoding
  */
 static VALUE builder_instruct(int argc, VALUE *argv, VALUE self) {
-    Builder b = (Builder)DATA_PTR(self);
+    Builder b;
 
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
     i_am_a_child(b, false);
     append_indent(b);
     if (0 == argc) {
@@ -548,11 +562,13 @@ static VALUE builder_instruct(int argc, VALUE *argv, VALUE self) {
  * - +attributes+ - (Hash) of the element
  */
 static VALUE builder_element(int argc, VALUE *argv, VALUE self) {
-    Builder     b = (Builder)DATA_PTR(self);
+    Builder     b;
     Element     e;
     const char *name;
     long        len;
 
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
+
     if (1 > argc) {
         rb_raise(ox_arg_error_class, "missing element name");
     }
@@ -608,10 +624,12 @@ static VALUE builder_element(int argc, VALUE *argv, VALUE self) {
  * - +attributes+ - (Hash) of the element
  */
 static VALUE builder_void_element(int argc, VALUE *argv, VALUE self) {
-    Builder     b = (Builder)DATA_PTR(self);
+    Builder     b;
     const char *name;
     long        len;
 
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
+
     if (1 > argc) {
         rb_raise(ox_arg_error_class, "missing element name");
     }
@@ -649,8 +667,9 @@ static VALUE builder_void_element(int argc, VALUE *argv, VALUE self) {
  * - +text+ - (String) contents of the comment
  */
 static VALUE builder_comment(VALUE self, VALUE text) {
-    Builder b = (Builder)DATA_PTR(self);
+    Builder b;
 
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
     rb_check_type(text, T_STRING);
     i_am_a_child(b, false);
     append_indent(b);
@@ -671,8 +690,9 @@ static VALUE builder_comment(VALUE self, VALUE text) {
  * - +text+ - (String) contents of the doctype
  */
 static VALUE builder_doctype(VALUE self, VALUE text) {
-    Builder b = (Builder)DATA_PTR(self);
+    Builder b;
 
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
     rb_check_type(text, T_STRING);
     i_am_a_child(b, false);
     append_indent(b);
@@ -694,10 +714,12 @@ static VALUE builder_doctype(VALUE self, VALUE text) {
  * - +strip_invalid_chars+ - [true|false] strips any characters invalid for XML, defaults to false
  */
 static VALUE builder_text(int argc, VALUE *argv, VALUE self) {
-    Builder        b = (Builder)DATA_PTR(self);
+    Builder        b;
     volatile VALUE v;
     volatile VALUE strip_invalid_chars;
 
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
+
     if ((0 == argc) || (argc > 2)) {
         rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 1..2)", argc);
     }
@@ -721,13 +743,15 @@ static VALUE builder_text(int argc, VALUE *argv, VALUE self) {
  * - +data+ - (String) contents of the CDATA element
  */
 static VALUE builder_cdata(VALUE self, VALUE data) {
-    Builder        b = (Builder)DATA_PTR(self);
+    Builder        b;
     volatile VALUE v = data;
     const char    *str;
     const char    *s;
     const char    *end;
     int            len;
 
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
+
     v   = rb_String(v);
     str = StringValuePtr(v);
     len = (int)RSTRING_LEN(v);
@@ -761,13 +785,14 @@ static VALUE builder_cdata(VALUE self, VALUE data) {
  * - +text+ - (String) contents to be added
  */
 static VALUE builder_raw(VALUE self, VALUE text) {
-    Builder        b = (Builder)DATA_PTR(self);
+    Builder        b;
     volatile VALUE v = text;
     const char    *str;
     const char    *s;
     const char    *end;
     int            len;
 
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
     v   = rb_String(v);
     str = StringValuePtr(v);
     len = (int)RSTRING_LEN(v);
@@ -792,7 +817,10 @@ static VALUE builder_raw(VALUE self, VALUE text) {
  * Returns the JSON document string in what ever state the construction is at.
  */
 static VALUE builder_to_s(VALUE self) {
-    return to_s((Builder)DATA_PTR(self));
+    Builder b;
+
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
+    return to_s(b);
 }
 
 /* call-seq: line()
@@ -800,7 +828,10 @@ static VALUE builder_to_s(VALUE self) {
  * Returns the current line in the output. The first line is line 1.
  */
 static VALUE builder_line(VALUE self) {
-    return LONG2NUM(((Builder)DATA_PTR(self))->line);
+    Builder b;
+
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
+    return LONG2NUM(b->line);
 }
 
 /* call-seq: column()
@@ -809,7 +840,10 @@ static VALUE builder_line(VALUE self) {
  * column 1.
  */
 static VALUE builder_column(VALUE self) {
-    return LONG2NUM(((Builder)DATA_PTR(self))->col);
+    Builder b;
+
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
+    return LONG2NUM(b->col);
 }
 
 /* call-seq: indent()
@@ -817,7 +851,10 @@ static VALUE builder_column(VALUE self) {
  * Returns the indentation level
  */
 static VALUE builder_get_indent(VALUE self) {
-    return INT2NUM(((Builder)DATA_PTR(self))->indent);
+    Builder b;
+
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
+    return INT2NUM(b->indent);
 }
 
 /* call-seq: indent=(indent)
@@ -827,11 +864,15 @@ static VALUE builder_get_indent(VALUE self) {
  * - +indent+ (Fixnum) indentaion level, negative values excludes terminating newline
  */
 static VALUE builder_set_indent(VALUE self, VALUE indent) {
+    Builder b;
+
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
+
     if (rb_cInteger != rb_obj_class(indent)) {
         rb_raise(ox_parse_error_class, "indent must be a fixnum.\n");
     }
 
-    ((Builder)DATA_PTR(self))->indent = NUM2INT(indent);
+    b->indent = NUM2INT(indent);
     return Qnil;
 }
 
@@ -840,7 +881,10 @@ static VALUE builder_set_indent(VALUE self, VALUE indent) {
  * Returns the number of bytes written.
  */
 static VALUE builder_pos(VALUE self) {
-    return LONG2NUM(((Builder)DATA_PTR(self))->pos);
+    Builder b;
+
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
+    return LONG2NUM(b->pos);
 }
 
 /* call-seq: pop()
@@ -848,7 +892,9 @@ static VALUE builder_pos(VALUE self) {
  * Closes the current element.
  */
 static VALUE builder_pop(VALUE self) {
-    pop((Builder)DATA_PTR(self));
+    Builder b;
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
+    pop(b);
 
     return Qnil;
 }
@@ -858,7 +904,10 @@ static VALUE builder_pop(VALUE self) {
  * Closes the all elements and the document.
  */
 static VALUE builder_close(VALUE self) {
-    bclose((Builder)DATA_PTR(self));
+    Builder b;
+
+    TypedData_Get_Struct(self, struct _builder, &ox_builder_type, b);
+    bclose(b);
 
     return Qnil;
 }

data/ext/ox/cache.c

@@ -54,6 +54,17 @@ typedef struct _cache {
     bool    mark;
 } *Cache;
 
+const rb_data_type_t ox_cache_type = {
+    "Ox/Cache",
+    {
+        ox_cache_mark,
+        ox_cache_free,
+        NULL,
+    },
+    0,
+    0,
+};
+
 static uint64_t hash_calc(const uint8_t *key, size_t len) {
     const uint8_t *end     = key + len;
     const uint8_t *endless = key + (len & 0xFFFFFFFC);
@@ -263,7 +274,8 @@ Cache ox_cache_create(size_t size, VALUE (*form)(const char *str, size_t len), b
     return c;
 }
 
-void ox_cache_free(Cache c) {
+void ox_cache_free(void *ptr) {
+    Cache    c = (Cache)ptr;
     uint64_t i;
 
     for (i = 0; i < c->size; i++) {
@@ -279,7 +291,8 @@ void ox_cache_free(Cache c) {
     free(c);
 }
 
-void ox_cache_mark(Cache c) {
+void ox_cache_mark(void *ptr) {
+    Cache    c = (Cache)ptr;
     uint64_t i;
 
 #if !HAVE_PTHREAD_MUTEX_INIT

data/ext/ox/cache.h

@@ -11,9 +11,11 @@
 
 struct _cache;
 
+extern const rb_data_type_t ox_cache_type;
+
 extern struct _cache *ox_cache_create(size_t size, VALUE (*form)(const char *str, size_t len), bool mark, bool locking);
-extern void           ox_cache_free(struct _cache *c);
-extern void           ox_cache_mark(struct _cache *c);
+extern void           ox_cache_free(void *ptr);
+extern void           ox_cache_mark(void *ptr);
 extern VALUE          ox_cache_intern(struct _cache *c, const char *key, size_t len, const char **keyp);
 
 #endif /* OX_CACHE_H */

data/ext/ox/foo.h

@@ -0,0 +1,204 @@
+/* sax_buf.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef OX_SAX_BUF_H
+#define OX_SAX_BUF_H
+
+#include <stdio.h>
+
+typedef struct _buf {
+    char  base[0x00001000];
+    char *head;
+    char *end;
+    char *tail;
+    char *read_end; /* one past last character read */
+    char *pro;      /* protection start, buffer can not slide past this point */
+    char *str;      /* start of current string being read */
+    off_t pos;
+    off_t line;
+    off_t col;
+    off_t pro_pos;
+    off_t pro_line;
+    off_t pro_col;
+    int (*read_func)(struct _buf *buf);
+    union {
+        int         fd;
+        VALUE       io;
+        const char *str;
+    } in;
+    struct _saxDrive *dr;
+} *Buf;
+
+typedef struct _checkPt {
+    off_t pro_dif;
+    off_t pos;
+    off_t line;
+    off_t col;
+    char  c;
+} *CheckPt;
+
+#define CHECK_PT_INIT {-1, 0, 0, 0, '\0'}
+
+extern void ox_sax_buf_init(Buf buf, VALUE io);
+extern int  ox_sax_buf_read(Buf buf);
+
+static inline char buf_get(Buf buf) {
+    // printf("*** drive get from '%s'  from start: %ld  buf: %p  from read_end: %ld\n", buf->tail, buf->tail -
+    // buf->head, buf->head, buf->read_end - buf->tail);
+    if (buf->read_end <= buf->tail) {
+        if (0 != ox_sax_buf_read(buf)) {
+            return '\0';
+        }
+    }
+    if ('\n' == *buf->tail) {
+        buf->line++;
+        buf->col = 0;
+    } else {
+        buf->col++;
+    }
+    buf->pos++;
+
+    return *buf->tail++;
+}
+
+static inline void buf_backup(Buf buf) {
+    buf->tail--;
+    buf->col--;
+    buf->pos--;
+    if (0 >= buf->col) {
+        buf->line--;
+        // allow col to be negative since we never backup twice in a row
+    }
+}
+
+static inline void buf_protect(Buf buf) {
+    buf->pro      = buf->tail;
+    buf->str      = buf->tail;  // can't have str before pro
+    buf->pro_pos  = buf->pos;
+    buf->pro_line = buf->line;
+    buf->pro_col  = buf->col;
+}
+
+static inline void buf_reset(Buf buf) {
+    buf->tail = buf->pro;
+    buf->pos  = buf->pro_pos;
+    buf->line = buf->pro_line;
+    buf->col  = buf->pro_col;
+}
+
+/* Starts by reading a character so it is safe to use with an empty or
+ * compacted buffer.
+ */
+static inline char buf_next_non_white(Buf buf) {
+    char c;
+
+    while ('\0' != (c = buf_get(buf))) {
+        switch (c) {
+        case ' ':
+        case '\t':
+        case '\f':
+        case '\n':
+        case '\r': break;
+        default: return c;
+        }
+    }
+    return '\0';
+}
+
+/* Starts by reading a character so it is safe to use with an empty or
+ * compacted buffer.
+ */
+static inline char buf_next_white(Buf buf) {
+    char c;
+
+    while ('\0' != (c = buf_get(buf))) {
+        switch (c) {
+        case ' ':
+        case '\t':
+        case '\f':
+        case '\n':
+        case '\r':
+        case '\0': return c;
+        default: break;
+        }
+    }
+    return '\0';
+}
+
+static inline void buf_cleanup(Buf buf) {
+    if (buf->base != buf->head && 0 != buf->head) {
+        xfree(buf->head);
+        buf->head = 0;
+    }
+}
+
+static inline int is_white(char c) {
+    switch (c) {
+    case ' ':
+    case '\t':
+    case '\f':
+    case '\n':
+    case '\r': return 1;
+    default: break;
+    }
+    return 0;
+}
+
+static inline void buf_checkpoint(Buf buf, CheckPt cp) {
+    cp->pro_dif = (int)(buf->tail - buf->pro);
+    cp->pos     = buf->pos;
+    cp->line    = buf->line;
+    cp->col     = buf->col;
+    cp->c       = *(buf->tail - 1);
+}
+
+static inline int buf_checkset(CheckPt cp) {
+    return (0 <= cp->pro_dif);
+}
+
+static inline char buf_checkback(Buf buf, CheckPt cp) {
+    buf->tail = buf->pro + cp->pro_dif;
+    buf->pos  = cp->pos;
+    buf->line = cp->line;
+    buf->col  = cp->col;
+    return cp->c;
+}
+
+static inline void buf_collapse_return(char *str) {
+    char *s    = str;
+    char *back = str;
+
+    for (; '\0' != *s; s++) {
+        if (back != str && '\n' == *s && '\r' == *(back - 1)) {
+            *(back - 1) = '\n';
+        } else {
+            *back++ = *s;
+        }
+    }
+    *back = '\0';
+}
+
+static inline void buf_collapse_white(char *str) {
+    char *s    = str;
+    char *back = str;
+
+    for (; '\0' != *s; s++) {
+        switch (*s) {
+        case ' ':
+        case '\t':
+        case '\f':
+        case '\n':
+        case '\r':
+            if (back == str || ' ' != *(back - 1)) {
+                *back++ = ' ';
+            }
+            break;
+        default: *back++ = *s; break;
+        }
+    }
+    *back = '\0';
+}
+
+#endif /* OX_SAX_BUF_H */

data/ext/ox/intern.c

@@ -67,26 +67,26 @@ static VALUE form_id(const char *str, size_t len) {
     return (VALUE)rb_intern3(str, len, rb_utf8_encoding());
 }
 
-void ox_hash_init() {
+void ox_hash_init(void) {
     VALUE cache_class = rb_define_class_under(Ox, "Cache", rb_cObject);
 #if RUBY_API_VERSION_CODE >= 30200
     rb_undef_alloc_func(cache_class);
 #endif
 
     ox_str_cache     = ox_cache_create(0, form_str, true, false);
-    ox_str_cache_obj = Data_Wrap_Struct(cache_class, ox_cache_mark, ox_cache_free, ox_str_cache);
+    ox_str_cache_obj = TypedData_Wrap_Struct(cache_class, &ox_cache_type, ox_str_cache);
     rb_gc_register_address(&ox_str_cache_obj);
 
     ox_sym_cache     = ox_cache_create(0, form_sym, true, false);
-    ox_sym_cache_obj = Data_Wrap_Struct(cache_class, ox_cache_mark, ox_cache_free, ox_sym_cache);
+    ox_sym_cache_obj = TypedData_Wrap_Struct(cache_class, &ox_cache_type, ox_sym_cache);
     rb_gc_register_address(&ox_sym_cache_obj);
 
     ox_attr_cache     = ox_cache_create(0, form_attr, false, false);
-    ox_attr_cache_obj = Data_Wrap_Struct(cache_class, ox_cache_mark, ox_cache_free, ox_attr_cache);
+    ox_attr_cache_obj = TypedData_Wrap_Struct(cache_class, &ox_cache_type, ox_attr_cache);
     rb_gc_register_address(&ox_attr_cache_obj);
 
     ox_id_cache     = ox_cache_create(0, form_id, false, false);
-    ox_id_cache_obj = Data_Wrap_Struct(cache_class, ox_cache_mark, ox_cache_free, ox_id_cache);
+    ox_id_cache_obj = TypedData_Wrap_Struct(cache_class, &ox_cache_type, ox_id_cache);
     rb_gc_register_address(&ox_id_cache_obj);
 }
 

data/ext/ox/obj_load.c

@@ -234,7 +234,7 @@ static unsigned long get_id_from_attrs(PInfo pi, Attr a) {
     return 0;
 }
 
-static CircArray circ_array_new() {
+static CircArray circ_array_new(void) {
     CircArray ca;
 
     ca       = ALLOC(struct _circArray);

data/ext/ox/ox.c

@@ -1273,6 +1273,9 @@ static void parse_dump_options(VALUE ropts, Options copts) {
  * :strict
  *     - _:strict_ - raise an NotImplementedError if an undumpable object is encountered
  *     - _:tolerant_ - replaces undumplable objects with nil
+ *   - *:with_dtd* [true|false|nil] include DTD in the dump
+ *   - *:with_instruct* [true|false|nil] include instructions in the dump
+ *   - *:with_xml* [true|false|nil] include XML prolog in the dump
  *
  * Note that an indent of less than zero will result in a tight one line output
  * unless the text in the XML fields contain new line characters.
@@ -1310,6 +1313,9 @@ static VALUE dump(int argc, VALUE *argv, VALUE self) {
  * :strict
  *     - _:strict_ - raise an NotImplementedError if an undumpable object is encountered
  *     - _:tolerant_ - replaces undumplable objects with nil
+ *   - *:with_dtd* [true|false|nil] include DTD in the dump
+ *   - *:with_instruct* [true|false|nil] include instructions in the dump
+ *   - *:with_xml* [true|false|nil] include XML prolog in the dump
  *
  * Note that an indent of less than zero will result in a tight one line output
  * unless the text in the XML fields contain new line characters.
@@ -1331,6 +1337,9 @@ static VALUE to_xml(int argc, VALUE *argv, VALUE self) {
  * :strict
  *     - _:strict_ - raise an NotImplementedError if an undumpable object is encountered
  *     - _:tolerant_ - replaces undumplable objects with nil
+ *   - *:with_dtd* [true|false|nil] include DTD in the dump
+ *   - *:with_instruct* [true|false|nil] include instructions in the dump
+ *   - *:with_xml* [true|false|nil] include XML prolog in the dump
  *
  * Note that an indent of less than zero will result in a tight one line output
  * unless the text in the XML fields contain new line characters.
@@ -1363,7 +1372,7 @@ static VALUE cache8_test(VALUE self) {
 }
 #endif
 
-void Init_ox() {
+void Init_ox(void) {
 #if HAVE_RB_EXT_RACTOR_SAFE
     rb_ext_ractor_safe(true);
 #endif

data/ext/ox/parse.c

@@ -18,6 +18,7 @@
 #include "ruby.h"
 #include "special.h"
 
+static void  mark_pi_cb(void *ptr);
 static void  read_instruction(PInfo pi);
 static void  read_doctype(PInfo pi);
 static void  read_comment(PInfo pi);
@@ -33,6 +34,17 @@ static char *read_coded_chars(PInfo pi, char *text);
 static void  next_non_white(PInfo pi);
 static int   collapse_special(PInfo pi, char *str);
 
+static const rb_data_type_t ox_wrap_type = {
+    "Object",
+    {
+        mark_pi_cb,
+        NULL,
+        NULL,
+    },
+    0,
+    0,
+};
+
 /* This XML parser is a single pass, destructive, callback parser. It is a
  * single pass parse since it only make one pass over the characters in the
  * XML document string. It is destructive because it re-uses the content of
@@ -140,7 +152,7 @@ ox_parse(char *xml, size_t len, ParseCallbacks pcb, char **endp, Options options
     // initialize parse info
     helper_stack_init(&pi.helpers);
     // Protect against GC
-    wrap = Data_Wrap_Struct(rb_cObject, mark_pi_cb, NULL, &pi);
+    wrap = TypedData_Wrap_Struct(rb_cObject, &ox_wrap_type, &pi);
 
     err_init(&pi.err);
     pi.str        = xml;

data/ext/ox/sax.c

@@ -62,6 +62,17 @@ static Nv   hint_try_close(SaxDrive dr, const char *name);
 
 VALUE ox_sax_value_class = Qnil;
 
+const rb_data_type_t ox_sax_value_type = {
+    "Ox/Sax/Value",
+    {
+        NULL,
+        NULL,
+        NULL,
+    },
+    0,
+    0,
+};
+
 static VALUE protect_parse(VALUE drp) {
     parse((SaxDrive)drp);
 
@@ -256,7 +267,7 @@ static void sax_drive_init(SaxDrive dr, VALUE handler, VALUE io, SaxOptions opti
     dr->buf.dr = dr;
     stack_init(&dr->stack);
     dr->handler   = handler;
-    dr->value_obj = Data_Wrap_Struct(ox_sax_value_class, 0, 0, dr);
+    dr->value_obj = TypedData_Wrap_Struct(ox_sax_value_class, &ox_sax_value_type, dr);
     rb_gc_register_address(&dr->value_obj);
     dr->options = *options;
     dr->err     = 0;
@@ -984,7 +995,11 @@ static char read_element_end(SaxDrive dr) {
             } else {
                 snprintf(msg, sizeof(msg) - 1, "%selement '%s' closed but not opened", EL_MISMATCH, dr->buf.str);
                 ox_sax_drive_error_at(dr, msg, pos, line, col);
-                name = str2sym(dr, dr->buf.str, dr->buf.tail - dr->buf.str - 2, 0);
+                if ('\x00' == *dr->buf.tail) {
+                    name = str2sym(dr, dr->buf.str, dr->buf.tail - dr->buf.str - 1, 0);
+                } else {
+                    name = str2sym(dr, dr->buf.str, dr->buf.tail - dr->buf.str - 2, 0);
+                }
                 if (dr->has_start_element && 0 >= dr->blocked &&
                     (NULL == h || ActiveOverlay == h->overlay || NestOverlay == h->overlay)) {
                     VALUE args[1];

data/ext/ox/sax.h

@@ -54,6 +54,8 @@ typedef struct _saxDrive {
 
 } *SaxDrive;
 
+extern const rb_data_type_t ox_sax_value_type;
+
 extern void ox_collapse_return(char *str);
 extern void ox_sax_parse(VALUE handler, VALUE io, SaxOptions options);
 extern void ox_sax_drive_cleanup(SaxDrive dr);

data/ext/ox/sax_as.c

@@ -106,9 +106,11 @@ static VALUE parse_xsd_time(const char *text) {
  * *return* value as an String.
  */
 static VALUE sax_value_as_s(VALUE self) {
-    SaxDrive dr = DATA_PTR(self);
+    SaxDrive dr;
     VALUE    rs;
 
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
+
     if ('\0' == *dr->buf.str) {
         return Qnil;
     }
@@ -132,7 +134,9 @@ static VALUE sax_value_as_s(VALUE self) {
  * *return* value as an Symbol.
  */
 static VALUE sax_value_as_sym(VALUE self) {
-    SaxDrive dr = DATA_PTR(self);
+    SaxDrive dr;
+
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
 
     if ('\0' == *dr->buf.str) {
         return Qnil;
@@ -145,7 +149,9 @@ static VALUE sax_value_as_sym(VALUE self) {
  * *return* value as an Float.
  */
 static VALUE sax_value_as_f(VALUE self) {
-    SaxDrive dr = DATA_PTR(self);
+    SaxDrive dr;
+
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
 
     if ('\0' == *dr->buf.str) {
         return Qnil;
@@ -158,11 +164,14 @@ static VALUE sax_value_as_f(VALUE self) {
  * *return* value as an Fixnum.
  */
 static VALUE sax_value_as_i(VALUE self) {
-    SaxDrive    dr  = DATA_PTR(self);
-    const char *s   = dr->buf.str;
+    SaxDrive    dr;
+    const char *s;
     long        n   = 0;
     int         neg = 0;
 
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
+    s = dr->buf.str;
+
     if ('\0' == *s) {
         return Qnil;
     }
@@ -190,10 +199,13 @@ static VALUE sax_value_as_i(VALUE self) {
  * *return* value as an Time.
  */
 static VALUE sax_value_as_time(VALUE self) {
-    SaxDrive    dr  = DATA_PTR(self);
-    const char *str = dr->buf.str;
+    SaxDrive    dr;
+    const char *str;
     VALUE       t;
 
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
+    str = dr->buf.str;
+
     if ('\0' == *str) {
         return Qnil;
     }
@@ -212,7 +224,10 @@ static VALUE sax_value_as_time(VALUE self) {
  * *return* value as an boolean.
  */
 static VALUE sax_value_as_bool(VALUE self) {
-    return (0 == strcasecmp("true", ((SaxDrive)DATA_PTR(self))->buf.str)) ? Qtrue : Qfalse;
+    SaxDrive dr;
+
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
+    return (0 == strcasecmp("true", dr->buf.str)) ? Qtrue : Qfalse;
 }
 
 /* call-seq: empty()
@@ -220,7 +235,10 @@ static VALUE sax_value_as_bool(VALUE self) {
  * *return* true if the value is empty.
  */
 static VALUE sax_value_empty(VALUE self) {
-    return ('\0' == *((SaxDrive)DATA_PTR(self))->buf.str) ? Qtrue : Qfalse;
+    SaxDrive dr;
+
+    TypedData_Get_Struct(self, struct _saxDrive, &ox_sax_value_type, dr);
+    return ('\0' == *dr->buf.str) ? Qtrue : Qfalse;
 }
 
 /* Document-class: Ox::Sax::Value
@@ -228,7 +246,7 @@ static VALUE sax_value_empty(VALUE self) {
  * Values in the SAX callbacks. They can be converted to various different
  * types. with the _as_x()_ methods.
  */
-void ox_sax_define() {
+void ox_sax_define(void) {
 #if 0
     ox = rb_define_module("Ox");
 #if RUBY_API_VERSION_CODE >= 30200

data/ext/ox/sax_buf.c

@@ -198,7 +198,7 @@ static int read_from_str(Buf buf) {
     if (max < cnt) {
         cnt = max;
     }
-    strncpy(buf->tail, buf->in.str, cnt);
+    memcpy(buf->tail, buf->in.str, cnt);
     s   = buf->tail + cnt - 1;
     *s  = '\0';
     cnt = s - buf->tail;

data/ext/ox/sax_buf.h

@@ -39,8 +39,7 @@ typedef struct _checkPt {
     char  c;
 } *CheckPt;
 
-#define CHECK_PT_INIT \
-    { -1, 0, 0, 0, '\0' }
+#define CHECK_PT_INIT {-1, 0, 0, 0, '\0'}
 
 extern void ox_sax_buf_init(Buf buf, VALUE io);
 extern int  ox_sax_buf_read(Buf buf);

data/ext/ox/sax_hint.c

@@ -153,7 +153,7 @@ static struct _hint html_hint_array[] = {
 };
 static struct _hints html_hints = {"HTML", html_hint_array, sizeof(html_hint_array) / sizeof(*html_hint_array)};
 
-Hints ox_hints_html() {
+Hints ox_hints_html(void) {
     return &html_hints;
 }
 

data/ext/ox/special.c

@@ -367,7 +367,7 @@ static Slot cache_get(const char *key) {
     return NULL;
 }
 
-static void cache_init() {
+static void cache_init(void) {
     Slot e = entities;
 
     memset(&entity_cache, 0, sizeof(struct _cache));

data/lib/ox/element.rb

@@ -79,7 +79,7 @@ module Ox
     # - +other+ [Object] Object compare _self_ to.
     # *return* [Boolean] true if both Objects are equivalent, otherwise false.
     def eql?(other)
-      return false unless super(other)
+      return false unless super
       return false unless attributes == other.attributes
       return false unless nodes == other.nodes
 
@@ -100,7 +100,11 @@ module Ox
     def replace_text(txt)
       raise 'the argument to replace_text() must be a String' unless txt.is_a?(String)
 
-      @nodes.clear
+      if !instance_variable_defined?(:@nodes) or @nodes.nil?
+        @node = []
+      else
+        @nodes.clear
+      end
       @nodes << txt
     end
 

data/lib/ox/instruct.rb

@@ -23,7 +23,7 @@ module Ox
     # - +other+ [Object] Object compare _self_ to.
     # *return* [Boolean] true if both Objects are equivalent, otherwise false.
     def eql?(other)
-      return false unless super(other)
+      return false unless super
       return false unless attributes == other.attributes
       return false unless content == other.content
 

data/lib/ox/version.rb

@@ -1,4 +1,4 @@
 module Ox
   # Current version of the module.
-  VERSION = '2.14.18'
+  VERSION = '2.14.19'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ox
 version: !ruby/object:Gem::Version
-  version: 2.14.18
+  version: 2.14.19
 platform: ruby
 authors:
 - Peter Ohler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-21 00:00:00.000000000 Z
-dependencies: []
+date: 2024-12-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: "A fast XML parser and object serializer that uses only standard C lib.\n\nOptimized
   XML (Ox), as the name implies was written to provide speed optimized\nXML handling.
   It was designed to be an alternative to Nokogiri and other Ruby\nXML parsers for
@@ -38,6 +52,7 @@ files:
 - ext/ox/err.c
 - ext/ox/err.h
 - ext/ox/extconf.rb
+- ext/ox/foo.h
 - ext/ox/gen_load.c
 - ext/ox/hash_load.c
 - ext/ox/helper.h
@@ -79,6 +94,11 @@ homepage: http://www.ohler.com/ox
 licenses:
 - MIT
 metadata:
+  bug_tracker_uri: https://github.com/ohler55/ox/issues
+  changelog_uri: https://github.com/ohler55/ox/blob/master/CHANGELOG.md
+  documentation_uri: http://www.ohler.com/ox/doc/index.html
+  homepage_uri: http://www.ohler.com/ox/
+  source_code_uri: https://github.com/ohler55/ox
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options:
@@ -105,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: A fast XML parser and object serializer.