ox 2.4.1 → 2.4.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2215329004101c80d8889571ae58a0ffa6c29606
+  data.tar.gz: 960ed868f559389e88f2be2fd9baf32f1ca6a3de
+SHA512:
+  metadata.gz: 90c53c12df67cd76cbecbb9649efef8762c69ba7665904722959349fe113784dd3af1e8c16bdbd32da97d70806f9383aa12d02b974d9c074899e221997240f4f
+  data.tar.gz: cf95951c262f221dd8e1d679cc288ac5837cf00adf074c906bf0c2842772af368d606e2f6b56a6375ef31936ef298c9b8ec662405c3c18a88024f09eeb76838c

data/README.md

@@ -34,6 +34,10 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 ## Release Notes
 
+### Release 2.4.2
+
+ - Added methods to Ox::Builder to provide output position information.
+
 ### Release 2.4.1
 
  - Made SAX smarter a little smarter or rather let it handle unquoted string
@@ -51,23 +55,6 @@ A fast XML parser and Object marshaller as a Ruby gem.
  - Added Ox::Builder that constructs an XML string or writes XML to a stream
    using builder methods.
 
-### Release 2.3.0
-
- - Added Ox::Element.replace_text() method.
-
- - Ox::Element nodes variable is now always initialized to an empty Array.
-
- - Ox::Element attributes variable is now always initialized to an empty Hash.
-
- - A invalid_replace option has been added. It will replace invalid XML
-   character with a provided string. Strict effort now raises an exception if an
-   invalid character is encountered on dump or load.
-
- - Ox.load and Ox.parse now allow for a callback block to handle multiple top
-   level entities in the input.
-
- - The Ox SAX parser now supports strings as input directly without and IO wrapper.
-
 ## Description
 
 Optimized XML (Ox), as the name implies was written to provide speed optimized

data/ext/ox/builder.c

@@ -29,6 +29,9 @@ typedef struct _Builder {
     int			depth;
     FILE		*file;
     struct _Element	stack[MAX_DEPTH];
+    long		line;
+    long		col;
+    long		pos;
 } *Builder;
 
 static VALUE		builder_class = Qundef;
@@ -68,48 +71,70 @@ append_indent(Builder b) {
 	    cnt = sizeof(indent_spaces) - 1;
 	}
 	buf_append_string(&b->buf, indent_spaces, cnt);
+	b->line++;
+	b->col = cnt - 1;
+	b->pos += cnt;
     }
 }
 
 static void
-append_string(Buf b, const char *str, size_t size) {
+append_string(Builder b, const char *str, size_t size) {
     size_t	xsize = xml_str_len((const unsigned char*)str, size);
 
     if (size == xsize) {
-	buf_append_string(b, str, size);
+	const char	*s = str;
+	const char	*end = str + size;
+	
+	buf_append_string(&b->buf, str, size);
+	b->col += size;
+	while (NULL != (s = index(s, '\n'))) {
+	    b->line++;
+	    b->col = end - s;
+	}
+	b->pos += size;
     } else {
 	char	buf[256];
 	char	*end = buf + sizeof(buf) - 1;
 	char	*bp = buf;
 	int	i = size;
+	int	fcnt;
 	
 	for (; '\0' != *str && 0 < i; i--, str++) {
-	    if ('1' == xml_friendly_chars[(unsigned char)*str]) {
+	    if ('1' == (fcnt = xml_friendly_chars[(unsigned char)*str])) {
 		if (end <= bp) {
-		    buf_append_string(b, buf, bp - buf);
+		    buf_append_string(&b->buf, buf, bp - buf);
 		    bp = buf;
 		}
+		if ('\n' == *str) {
+		    b->line++;
+		    b->col = 1;
+		} else {
+		    b->col++;
+		}
+		b->pos++;
 		*bp++ = *str;
 	    } else {
+		b->pos += fcnt;
+		b->col += fcnt;
 		if (buf < bp) {
-		    buf_append_string(b, buf, bp - buf);
+		    buf_append_string(&b->buf, buf, bp - buf);
 		    bp = buf;
 		}
 		switch (*str) {
 		case '"':
-		    buf_append_string(b, "&quot;", 6);
+		    buf_append_string(&b->buf, "&quot;", 6);
 		    break;
 		case '&':
-		    buf_append_string(b, "&amp;", 5);
+		    buf_append_string(&b->buf, "&amp;", 5);
 		    break;
 		case '\'':
-		    buf_append_string(b, "&apos;", 6);
+		    buf_append_string(&b->buf, "&apos;", 6);
 		    break;
 		case '<':
-		    buf_append_string(b, "&lt;", 4);
+		    buf_append_string(&b->buf, "&lt;", 4);
 		    break;
 		case '>':
-		    buf_append_string(b, "&gt;", 4);
+		    buf_append_string(&b->buf, "&gt;", 4);
 		    break;
 		default:
 		    // Must be one of the invalid characters.
@@ -119,14 +144,14 @@ append_string(Buf b, const char *str, size_t size) {
 	    }
 	}
 	if (buf < bp) {
-	    buf_append_string(b, buf, bp - buf);
+	    buf_append_string(&b->buf, buf, bp - buf);
 	    bp = buf;
 	}
     }
 }
 
 static void
-append_sym_str(Buf b, VALUE v) {
+append_sym_str(Builder b, VALUE v) {
     const char	*s;
     int		len;
     
@@ -154,6 +179,8 @@ i_am_a_child(Builder b, bool is_text) {
 	if (!e->has_child) {
 	    e->has_child = true;
 	    buf_append(&b->buf, '>');
+	    b->col++;
+	    b->pos++;
 	}
 	if (!is_text) {
 	    e->non_text_child = true;
@@ -163,12 +190,19 @@ i_am_a_child(Builder b, bool is_text) {
 
 static int
 append_attr(VALUE key, VALUE value, Builder b) {
+    int	len;
+    
     buf_append(&b->buf, ' ');
-    append_sym_str(&b->buf, key);
+    b->col++;
+    b->pos++;
+    append_sym_str(b, key);
     buf_append_string(&b->buf, "=\"", 2);
     Check_Type(value, T_STRING);
-    buf_append_string(&b->buf, StringValuePtr(value), RSTRING_LEN(value));
+    len = (int)RSTRING_LEN(value);
+    buf_append_string(&b->buf, StringValuePtr(value), len);
     buf_append(&b->buf, '"');
+    b->col += len + 3;
+    b->pos += len + 3;
     
     return ST_CONTINUE;
 }
@@ -179,6 +213,9 @@ init(Builder b, int fd, int indent, long initial_size) {
     b->indent = indent;
     *b->encoding = '\0';
     b->depth = -1;
+    b->line = 1;
+    b->col = 1;
+    b->pos = 0;
 }
 
 static void
@@ -216,12 +253,16 @@ pop(Builder b) {
 	buf_append_string(&b->buf, "</", 2);
 	buf_append_string(&b->buf, e->name, e->len);
 	buf_append(&b->buf, '>');
+	b->col += e->len + 3;
+	b->pos += e->len + 3;
 	if (e->buf != e->name) {
 	    free(e->name);
 	    e->name = 0;
 	}
     } else {
 	buf_append_string(&b->buf, "/>", 2);
+	b->col += 2;
+	b->pos += 2;
     }
 }
 
@@ -231,6 +272,9 @@ bclose(Builder b) {
 	pop(b);
     }
     buf_append(&b->buf, '\n');
+    b->line++;
+    b->col = 1;
+    b->pos++;
     buf_finish(&b->buf);
     if (NULL != b->file) {
 	fclose(b->file);
@@ -246,6 +290,9 @@ to_s(Builder b) {
     }
     if ('\n' != *(b->buf.tail - 1)) {
 	buf_append(&b->buf, '\n');
+	b->line++;
+	b->col = 1;
+	b->pos++;
     }
     *b->buf.tail = '\0'; // for debugging
     rstr = rb_str_new(b->buf.head, buf_len(&b->buf));
@@ -296,6 +343,7 @@ builder_new(int argc, VALUE *argv, VALUE self) {
 
     if (rb_block_given_p()) {
 	volatile VALUE	rb = Data_Wrap_Struct(builder_class, NULL, builder_free, b);
+	
 	rb_yield(rb);
 	bclose(b);
 
@@ -429,27 +477,39 @@ builder_instruct(int argc, VALUE *argv, VALUE self) {
     append_indent(b);
     if (0 == argc) {
 	buf_append_string(&b->buf, "<?xml?>", 7);
+	b->col += 7;
+	b->pos += 7;
     } else {
 	volatile VALUE	v;
 	
 	buf_append_string(&b->buf, "<?", 2);
-	append_sym_str(&b->buf, *argv);
+	b->col += 2;
+	b->pos += 2;
+	append_sym_str(b, *argv);
 	if (1 < argc && rb_cHash == rb_obj_class(argv[1])) {
+	    int	len;
+		
 	    if (Qnil != (v = rb_hash_lookup(argv[1], ox_version_sym))) {
 		if (rb_cString != rb_obj_class(v)) {
 		    rb_raise(ox_parse_error_class, ":version must be a Symbol.\n");
 		}
+		len = (int)RSTRING_LEN(v);
 		buf_append_string(&b->buf, " version=\"", 10);
-		buf_append_string(&b->buf, StringValuePtr(v), RSTRING_LEN(v));
+		buf_append_string(&b->buf, StringValuePtr(v), len);
 		buf_append(&b->buf, '"');
+		b->col += len + 11;
+		b->pos += len + 11;
 	    }
 	    if (Qnil != (v = rb_hash_lookup(argv[1], ox_encoding_sym))) {
 		if (rb_cString != rb_obj_class(v)) {
 		    rb_raise(ox_parse_error_class, ":encoding must be a Symbol.\n");
 		}
+		len = (int)RSTRING_LEN(v);
 		buf_append_string(&b->buf, " encoding=\"", 11);
-		buf_append_string(&b->buf, StringValuePtr(v), RSTRING_LEN(v));
+		buf_append_string(&b->buf, StringValuePtr(v), len);
 		buf_append(&b->buf, '"');
+		b->col += len + 12;
+		b->pos += len + 12;
 		strncpy(b->encoding, StringValuePtr(v), sizeof(b->encoding));
 		b->encoding[sizeof(b->encoding) - 1] = '\0';
 	    }
@@ -457,12 +517,17 @@ builder_instruct(int argc, VALUE *argv, VALUE self) {
 		if (rb_cString != rb_obj_class(v)) {
 		    rb_raise(ox_parse_error_class, ":standalone must be a Symbol.\n");
 		}
+		len = (int)RSTRING_LEN(v);
 		buf_append_string(&b->buf, " standalone=\"", 13);
-		buf_append_string(&b->buf, StringValuePtr(v), RSTRING_LEN(v));
+		buf_append_string(&b->buf, StringValuePtr(v), len);
 		buf_append(&b->buf, '"');
+		b->col += len + 14;
+		b->pos += len + 14;
 	    }
 	}
 	buf_append_string(&b->buf, "?>", 2);
+	b->col += 2;
+	b->pos += 2;
     }
     return Qnil;
 }
@@ -517,7 +582,9 @@ builder_element(int argc, VALUE *argv, VALUE self) {
     e->non_text_child = false;
 
     buf_append(&b->buf, '<');
-    buf_append_string(&b->buf, e->name, len);
+    b->col++;
+    b->pos++;
+    append_string(b, e->name, len);
     if (1 < argc) {
 	rb_hash_foreach(argv[1], append_attr, (VALUE)b);
     }
@@ -537,14 +604,18 @@ builder_element(int argc, VALUE *argv, VALUE self) {
 static VALUE
 builder_comment(VALUE self, VALUE text) {
     Builder	b = (Builder)DATA_PTR(self);
-
+    
     rb_check_type(text, T_STRING);
     i_am_a_child(b, false);
     append_indent(b);
     buf_append_string(&b->buf, "<!-- ", 5);
-    buf_append_string(&b->buf, StringValuePtr(text), RSTRING_LEN(text));
+    b->col += 5;
+    b->pos += 5;
+    append_string(b, StringValuePtr(text), RSTRING_LEN(text));
     buf_append_string(&b->buf, " --/> ", 5);
-
+    b->col += 5;
+    b->pos += 5;
+	
     return Qnil;
 }
 
@@ -561,8 +632,12 @@ builder_doctype(VALUE self, VALUE text) {
     i_am_a_child(b, false);
     append_indent(b);
     buf_append_string(&b->buf, "<!DOCTYPE ", 10);
-    buf_append_string(&b->buf, StringValuePtr(text), RSTRING_LEN(text));
+    b->col += 10;
+    b->pos += 10;
+    append_string(b, StringValuePtr(text), RSTRING_LEN(text));
     buf_append(&b->buf, '>');
+    b->col++;
+    b->pos++;
 
     return Qnil;
 }
@@ -581,7 +656,7 @@ builder_text(VALUE self, VALUE text) {
 	v = rb_funcall(v, ox_to_s_id, 0);
     }
     i_am_a_child(b, true);
-    append_string(&b->buf, StringValuePtr(v), RSTRING_LEN(v));
+    append_string(b, StringValuePtr(v), RSTRING_LEN(v));
 
     return Qnil;
 }
@@ -595,15 +670,33 @@ static VALUE
 builder_cdata(VALUE self, VALUE data) {
     Builder		b = (Builder)DATA_PTR(self);
     volatile VALUE	v = data;
+    const char		*str;
+    const char		*s;
+    const char		*end;
+    int			len;
 
     if (T_STRING != rb_type(v)) {
 	v = rb_funcall(v, ox_to_s_id, 0);
     }
+    str = StringValuePtr(v);
+    len = (int)RSTRING_LEN(v);
+    s = str;
+    end = str + len;
     i_am_a_child(b, false);
     append_indent(b);
     buf_append_string(&b->buf, "<![CDATA[", 9);
-    buf_append_string(&b->buf, StringValuePtr(v), RSTRING_LEN(v));
+    b->col += 9;
+    b->pos += 9;
+    buf_append_string(&b->buf, str, len);
+    b->col += len;
+    while (NULL != (s = index(s, '\n'))) {
+	b->line++;
+	b->col = end - s;
+    }
+    b->pos += len;
     buf_append_string(&b->buf, "]]>", 3);
+    b->col += 3;
+    b->pos += 3;
 
     return Qnil;
 }
@@ -618,12 +711,26 @@ static VALUE
 builder_raw(VALUE self, VALUE text) {
     Builder		b = (Builder)DATA_PTR(self);
     volatile VALUE	v = text;
+    const char		*str;
+    const char		*s;
+    const char		*end;
+    int			len;
 
     if (T_STRING != rb_type(v)) {
 	v = rb_funcall(v, ox_to_s_id, 0);
     }
+    str = StringValuePtr(v);
+    len = (int)RSTRING_LEN(v);
+    s = str;
+    end = str + len;
     i_am_a_child(b, true);
-    buf_append_string(&b->buf, StringValuePtr(v), RSTRING_LEN(v));
+    buf_append_string(&b->buf, str, len);
+    b->col += len;
+    while (NULL != (s = index(s, '\n'))) {
+	b->line++;
+	b->col = end - s;
+    }
+    b->pos += len;
 
     return Qnil;
 }
@@ -637,6 +744,34 @@ builder_to_s(VALUE self) {
     return to_s((Builder)DATA_PTR(self));
 }
 
+/* call-seq: line()
+ *
+ * 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);
+}
+
+/* call-seq: column()
+ *
+ * Returns the current column in the output. The first character in a line is at
+ * column 1.
+ */
+static VALUE
+builder_column(VALUE self) {
+    return LONG2NUM(((Builder)DATA_PTR(self))->col);
+}
+
+/* call-seq: pos()
+ *
+ * Returns the number of bytes written.
+ */
+static VALUE
+builder_pos(VALUE self) {
+    return LONG2NUM(((Builder)DATA_PTR(self))->pos);
+}
+
 /* call-seq: pop()
  *
  * Closes the current element.
@@ -682,4 +817,7 @@ void ox_init_builder(VALUE ox) {
     rb_define_method(builder_class, "pop", builder_pop, 0);
     rb_define_method(builder_class, "close", builder_close, 0);
     rb_define_method(builder_class, "to_s", builder_to_s, 0);
+    rb_define_method(builder_class, "line", builder_line, 0);
+    rb_define_method(builder_class, "column", builder_column, 0);
+    rb_define_method(builder_class, "pos", builder_pos, 0);
 }

data/ext/ox/encode.h

@@ -0,0 +1,26 @@
+/* encode.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ */
+
+#ifndef __OX_ENCODE_H__
+#define __OX_ENCODE_H__
+
+#include "ruby.h"
+#if HAS_ENCODING_SUPPORT
+#include "ruby/encoding.h"
+#endif
+
+static inline VALUE
+ox_encode(VALUE rstr) {
+#if HAS_ENCODING_SUPPORT
+    rb_enc_associate(rstr, ox_utf8_encoding);
+#else
+    if (Qnil != ox_utf8_encoding) {
+	rstr = rb_funcall(ox_utf8_encoding, ox_iconv_id, 1, rstr);
+    }
+#endif
+    return rstr;
+}
+
+#endif /* __OX_ENCODE_H__ */

data/lib/ox/version.rb

@@ -1,5 +1,5 @@
 
 module Ox
   # Current version of the module. 
-  VERSION = '2.4.1'
+  VERSION = '2.4.2'
 end

metadata

@@ -1,21 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: ox
 version: !ruby/object:Gem::Version
-  version: 2.4.1
-  prerelease: 
+  version: 2.4.2
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-30 00:00:00.000000000 Z
+date: 2016-06-23 00:00:00.000000000 Z
 dependencies: []
-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 generic XML parsing and as an alternative to Marshal
-  for Object\nserialization. "
+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 generic XML parsing and as an alternative to Marshal for Object\nserialization. "
 email: peter@ohler.com
 executables: []
 extensions:
@@ -23,84 +21,85 @@ extensions:
 extra_rdoc_files:
 - README.md
 files:
-- lib/ox/bag.rb
-- lib/ox/cdata.rb
-- lib/ox/comment.rb
-- lib/ox/doctype.rb
-- lib/ox/document.rb
-- lib/ox/element.rb
-- lib/ox/error.rb
-- lib/ox/hasattrs.rb
-- lib/ox/instruct.rb
-- lib/ox/node.rb
-- lib/ox/raw.rb
-- lib/ox/sax.rb
-- lib/ox/version.rb
-- lib/ox/xmlrpc_adapter.rb
-- lib/ox.rb
-- ext/ox/extconf.rb
+- LICENSE
+- README.md
 - ext/ox/attr.h
+- ext/ox/base64.c
 - ext/ox/base64.h
 - ext/ox/buf.h
-- ext/ox/cache.h
-- ext/ox/cache8.h
-- ext/ox/err.h
-- ext/ox/helper.h
-- ext/ox/ox.h
-- ext/ox/sax.h
-- ext/ox/sax_buf.h
-- ext/ox/sax_has.h
-- ext/ox/sax_hint.h
-- ext/ox/sax_stack.h
-- ext/ox/special.h
-- ext/ox/type.h
-- ext/ox/base64.c
 - ext/ox/builder.c
 - ext/ox/cache.c
+- ext/ox/cache.h
 - ext/ox/cache8.c
+- ext/ox/cache8.h
 - ext/ox/dump.c
+- ext/ox/encode.h
 - ext/ox/err.c
+- ext/ox/err.h
+- ext/ox/extconf.rb
 - ext/ox/gen_load.c
+- ext/ox/helper.h
 - ext/ox/obj_load.c
 - ext/ox/ox.c
+- ext/ox/ox.h
 - ext/ox/parse.c
 - ext/ox/sax.c
+- ext/ox/sax.h
 - ext/ox/sax_as.c
 - ext/ox/sax_buf.c
+- ext/ox/sax_buf.h
+- ext/ox/sax_has.h
 - ext/ox/sax_hint.c
+- ext/ox/sax_hint.h
+- ext/ox/sax_stack.h
 - ext/ox/special.c
-- LICENSE
-- README.md
+- ext/ox/special.h
+- ext/ox/type.h
+- lib/ox.rb
+- lib/ox/bag.rb
+- lib/ox/cdata.rb
+- lib/ox/comment.rb
+- lib/ox/doctype.rb
+- lib/ox/document.rb
+- lib/ox/element.rb
+- lib/ox/error.rb
+- lib/ox/hasattrs.rb
+- lib/ox/instruct.rb
+- lib/ox/node.rb
+- lib/ox/raw.rb
+- lib/ox/sax.rb
+- lib/ox/version.rb
+- lib/ox/xmlrpc_adapter.rb
 homepage: http://www.ohler.com/ox
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options:
-- --main
+- "--main"
 - README.md
-- --title
+- "--title"
 - Ox Documentation
-- --exclude
+- "--exclude"
 - extconf.rb
 require_paths:
 - lib
 - ext
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: ox
-rubygems_version: 1.8.23.2
+rubygems_version: 2.4.5
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A fast XML parser and object serializer.
 test_files: []
+has_rdoc: true