ox 1.0.0

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2011, Peter Ohler
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ - Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+ - Neither the name of Peter Ohler nor the names of its contributors may be
+   used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -0,0 +1,153 @@
+= Ox: A fast XML parser and Object marshaller.
+
+*GitHub* *repo*: https://github.com/ohler55/ox
+
+=== Description:
+
+Optimized XML (Ox), as the name implies was written to provide speed optimized
+XML handling. It was designed to be an alternative to Nokogiri in generic XML
+parsing and as an alternative to Marshal for Object serialization. 
+
+Nokogiri relies on libXml while Ox is self contained. Ox uses nothing other
+than standard C libraries so version issues with libXml are not an issue.
+
+Marshal uses a binary format for serializing Objects. That binary format
+changes with releases making Marshal dumped Object incompatible between some
+versions. The use of a binary format make debugging message streams or file
+contents next to impossible unless the same version of Ruby and only Ruby is
+used for inspecting the serialize Object. Ox on the other hand uses human
+readable XML.
+
+It is possible to write an XML serialization gem with Nokogiri but writing
+such a package in Ruby results in a module significantly slower than
+Marshal. This is what triggered the start of Ox development.
+
+Ox handles XML documents in two ways. It is a generic XML parser and writer as
+well as a fast Object / XML marshaller. Ox was written for speed as a
+replacement for Nokogiri and for Marshal.
+
+As an XML parser it is 2 or more times faster than Nokogiri and as a generic
+XML writer it is as much as 20 times faster than Nokogiri. Of course different
+files may result in slightly different times.
+
+As an Object serializer Ox is up to 6 times faster than the standard Ruby
+Marshal.dump() and up to 3 times faster than Marshal.load().
+
+
+=== Object Dump Sample:
+
+  require 'ox'
+
+  class Sample
+    attr_accessor :a, :b, :c
+
+    def initialize(a, b, c)
+      @a = a
+      @b = b
+      @c = c
+    end
+  end
+
+  # Create Object
+  obj = Sample.new(1, "bee", ['x', :y, 7.0])
+  # Now dump the Object to an XML String.
+  xml = Ox.dump(obj)
+  # Convert the object back into a Sample Object.
+  obj2 = Ox.parse_obj(xml)
+
+=== Generic XML Writing and Parsing:
+
+  require 'ox'
+
+  doc = Ox::Document.new(:version => '1.0')
+
+  top = Ox::Element.new('top')
+  top[:name] = 'sample'
+  doc << top
+
+  mid = Ox::Element.new('middle')
+  mid[:name] = 'second'
+  top << mid
+
+  bot = Ox::Element.new('bottom')
+  bot[:name] = 'third'
+  mid << bot
+
+  xml = Ox.dump(doc)
+  puts xml
+  doc2 = Ox.parse(xml)
+  puts "Same? #{doc == doc2}"
+
+
+=== Object XML format
+
+The XML format used for Object encoding follows the structure of the
+Object. Each XML element is encoded so that the XML element name is a type
+indicator. Attributes of the element provide additional information such as
+the Class if relevant, the Object attribute name, and Object ID if
+necessary.
+
+The type indicator map is:
+
+- +a+ => Array
+- +b+ => Base64
+- +c+ => Class
+- +f+ => Float
+- +g+ => Regexp
+- +h+ => Hash
+- +i+ => Fixnum
+- +j+ => Bignum
+- +l+ => Rational
+- +m+ => Symbol
+- +n+ => FalseClass
+- +o+ => Object
+- +p+ => Ref
+- +r+ => Range
+- +s+ => String
+- +t+ => Time
+- +u+ => Struct
+- +v+ => Complex
+- +x+ => Raw
+- +y+ => TrueClass
+- +z+ => NilClass
+
+If the type is an Object, type 'o' then an attribute named 'c' should be set
+with the full Class name including the Module names. If the XML element
+represents an Object then a sub-elements is included for each attribute of
+the Object. An XML element attribute 'a' is set with a value that is the
+name of the Ruby Object attribute. In all cases, except for the Exception
+attribute hack the attribute names begin with an @ character. (Exception are
+strange in that the attributes of the Exception Class are not named with a @
+suffix. A hack since it has to be done in C and can not be done through the
+interpreter.)
+
+Values are encoded as the text portion of an element or in the sub-elements
+of the principle. For example, a Fixnum is encoded as:
+
+  <i>123</i>
+
+An Array has sub-elements and is encoded similar to this example.
+
+  <a>
+    <i>1</i>
+    <s>abc</s>
+  </a>
+
+A Hash is encoded with an even number of elements where the first element is
+the key and the second is the value. This is repeated for each entry in the
+Hash. An example is of { 1 => 'one', 2 => 'two' } encoding is:
+
+  <h>
+    <i>1</i>
+    <s>one</s>
+    <i>2</i>
+    <s>two</s>
+  </h>
+
+Strings with characters not allowed in XML are base64 encoded amd will be
+converted back into a String when loaded.
+
+Ox supports circular references where attributes of one Object can refer to
+an Object that refers back to the first Object. When this option is used an
+Object ID is added to each XML Object element as the value of the 'a'
+attribute.

data/ext/ox/base64.c

@@ -0,0 +1,123 @@
+/* base64.c
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ *  - Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ *  - Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ *  - Neither the name of Peter Ohler nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+
+#include "base64.h"
+
+static char	digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+// invalid or terminating characters are set to 'X' or \x58
+static u_char   s_digits[256] = "\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x3E\x58\x58\x58\x3F\
+\x34\x35\x36\x37\x38\x39\x3A\x3B\x3C\x3D\x58\x58\x58\x58\x58\x58\
+\x58\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\
+\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x58\x58\x58\x58\x58\
+\x58\x1A\x1B\x1C\x1D\x1E\x1F\x20\x21\x22\x23\x24\x25\x26\x27\x28\
+\x29\x2A\x2B\x2C\x2D\x2E\x2F\x30\x31\x32\x33\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\
+\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58\x58";
+
+void
+to_base64(const u_char *src, int len, char *b64) {
+    const u_char	*end3;
+    int			len3 = len % 3;
+    u_char		b1, b2, b3;
+    
+    end3 = src + (len - len3);
+    while (src < end3) {
+	b1 = *src++;
+	b2 = *src++;
+	b3 = *src++;
+	*b64++ = digits[b1 >> 2];
+	*b64++ = digits[((b1 & 0x03) << 4) | (b2 >> 4)];
+	*b64++ = digits[((b2 & 0x0F) << 2) | (b3 >> 6)];
+	*b64++ = digits[b3 & 0x3F];
+    }
+    if (1 == len3) {
+	b1 = *src++;
+	*b64++ = digits[b1 >> 2];
+	*b64++ = digits[(b1 & 0x03) << 4];
+	*b64++ = '=';
+	*b64++ = '=';
+    } else if (2 == len3) {
+	b1 = *src++;
+	b2 = *src++;
+	*b64++ = digits[b1 >> 2];
+	*b64++ = digits[((b1 & 0x03) << 4) | (b2 >> 4)];
+	*b64++ = digits[(b2 & 0x0F) << 2];
+	*b64++ = '=';
+    }
+    *b64 = '\0';
+}
+
+unsigned long
+b64_orig_size(const char *text) {
+    const char          *start = text;
+    unsigned long        size = 0;
+    
+    if ('\0' != *text) {
+        for (; 0 != *text; text++) { }
+        size = (text - start) * 3 / 4;
+        text--;
+        if ('=' == *text) {
+            size--;
+            text--;
+            if ('=' == *text) {
+                size--;
+            }
+        }
+    }
+    return size;
+}
+
+void
+from_base64(const char *b64, u_char *str) {
+    u_char      b0, b1, b2, b3;
+    
+    while (1) {
+        if ('X' == (b0 = s_digits[(u_char)*b64++])) { break; }
+        if ('X' == (b1 = s_digits[(u_char)*b64++])) { break; }
+        *str++ = (b0 << 2) | ((b1 >> 4) & 0x03);
+        if ('X' == (b2 = s_digits[(u_char)*b64++])) { break; }
+        *str++ = (b1 << 4) | ((b2 >> 2) & 0x0F);
+        if ('X' == (b3 = s_digits[(u_char)*b64++])) { break; }
+        *str++ = (b2 << 6) | b3;
+    }
+    *str = '\0';
+}

data/ext/ox/base64.h

@@ -0,0 +1,44 @@
+/* base64.h
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ *  - Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ *  - Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ *  - Neither the name of Peter Ohler nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __BASE64_H__
+#define __BASE64_H__
+
+#include <sys/types.h>
+
+
+#define b64_size(len) ((len + 2) / 3 * 4)
+
+extern unsigned long    b64_orig_size(const char *text);
+
+extern void	        to_base64(const u_char *src, int len, char *b64);
+extern void             from_base64(const char *b64, u_char *str);
+
+#endif /* __BASE64_H__ */

data/ext/ox/cache.c

@@ -0,0 +1,148 @@
+/* cache.c
+ * Copyright (c) 2011, Peter Ohler
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ *  - Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 
+ *  - Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 
+ *  - Neither the name of Peter Ohler nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "cache.h"
+
+struct _Cache {
+    char                *key; // only set if the node has a value, and it is not an exact match
+    VALUE               value;
+    struct _Cache       *slots[16];
+};
+
+static void     slot_print(Cache cache, unsigned int depth);
+
+void
+ox_cache_new(Cache *cache) {
+    if (0 == (*cache = (Cache)malloc(sizeof(struct _Cache)))) {
+        rb_raise(rb_eNoMemError, "not enough memory\n");
+    }
+    (*cache)->key = 0;
+    (*cache)->value = Qundef;
+    bzero((*cache)->slots, sizeof((*cache)->slots));
+}
+
+VALUE
+ox_cache_get(Cache cache, const char *key, VALUE **slot) {
+    unsigned char       *k = (unsigned char*)key;
+    Cache               *cp;
+
+    for (; '\0' != *k; k++) {
+        cp = cache->slots + (unsigned int)(*k >> 4); // upper 4 bits
+        if (0 == *cp) {
+            ox_cache_new(cp);
+        }
+        cache = *cp;
+        cp = cache->slots + (unsigned int)(*k & 0x0F); // lower 4 bits
+        if (0 == *cp) {
+            ox_cache_new(cp);
+            cache = *cp;
+            cache->key = ('\0' == *(k + 1)) ? 0 : strdup(key);
+            break;
+        } else {
+            cache = *cp;
+            if (Qundef != cache->value && 0 != cache->key) {
+                unsigned char   *ck = (unsigned char*)(cache->key + (unsigned int)(k - (unsigned char*)key + 1));
+
+                if (0 == strcmp((char*)ck, (char*)(k + 1))) {
+                    break;
+                } else {
+                    Cache     *cp2 = cp;
+
+                    // if value was set along with the key then there are no slots filled yet
+                    cp2 = (*cp2)->slots + (*ck >> 4);
+                    ox_cache_new(cp2);
+                    cp2 = (*cp2)->slots + (*ck & 0x0F);
+                    ox_cache_new(cp2);
+                    if ('\0' == *(ck + 1)) {
+                        free(cache->key);
+                    } else {
+                        (*cp2)->key = cache->key;
+                    }
+                    (*cp2)->value = cache->value;
+                    cache->key = 0;
+                    cache->value = Qundef;
+                }
+            }
+        }
+    }
+    *slot = &cache->value;
+
+    return cache->value;
+}
+
+void
+ox_cache_print(Cache cache) {
+    //printf("-------------------------------------------\n");
+    slot_print(cache, 0);
+}
+
+static void
+slot_print(Cache c, unsigned int depth) {
+    char                indent[256];
+    Cache               *cp;
+    unsigned int        i;
+
+    if (sizeof(indent) - 1 < depth) {
+        depth = ((int)sizeof(indent) - 1);
+    }
+    memset(indent, ' ', depth);
+    indent[depth] = '\0';
+    for (i = 0, cp = c->slots; i < 16; i++, cp++) {
+        if (0 == *cp) {
+            //printf("%s%02u:\n", indent, i);
+        } else {
+            if (0 == (*cp)->key && Qundef == (*cp)->value) {
+                printf("%s%02u:\n", indent, i);
+            } else {
+                const char      *key = (0 == (*cp)->key) ? "*" : (*cp)->key;
+                const char      *vs;
+                const char      *clas;
+
+                if (Qundef == (*cp)->value) {
+                    vs = "undefined";
+                    clas = "";
+                } else {
+                    VALUE       rs = rb_funcall2((*cp)->value, rb_intern("to_s"), 0, 0);
+
+                    vs = StringValuePtr(rs);
+                    clas = rb_class2name(rb_obj_class((*cp)->value));
+                }
+                printf("%s%02u: %s = %s (%s)\n", indent, i, key, vs, clas);
+            }
+            slot_print(*cp, depth + 2);
+        }
+    }
+}