fast-xml 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d5c3255eaacfe69128a428f67ab670d680e05bf2
+  data.tar.gz: 65b1e5898db7b64bd1b58ec0b23fedb1c3692a1c
+SHA512:
+  metadata.gz: 8a290a9676f388f342c63e2fdef2d2445f2db91df0d58b13cb64515f019c6595ce18cfef7466c2b932de527dca1230ef690280ec1ef7598ce6a25e9038a8d727
+  data.tar.gz: b0c95264bf47245e3d53e28844cee4fffe468b365098a45881f0869be4c01f9533ba9420527fc24c7ef8359303a3ee0779efae06d1a18073bde7336fc104a684

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Yuriy Ustushenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,164 @@
+# FastXML
+
+Fast Ruby Hash to XML and XML to Ruby Hash converter written in pure C.
+
+[![Build Status](https://secure.travis-ci.org/yoreek/fastxml.png?branch=master)](http://travis-ci.org/yoreek/fastxml)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fastxml'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fast-xml
+
+## Release Notes
+
+See [CHANGELOG.md](CHANGELOG.md)
+
+## Usage
+
+```ruby
+require 'fastxml'
+
+# convert hash to XML
+FastXML.hash2xml({ tag1: { tag2: 'content' } }, indent: 2)
+# =>
+# <?xml version="1.0" encoding="utf-8"?>
+# <root>
+#   <tag1>
+#     <tag2>content</tag2>
+#   </tag1>
+# </root>
+
+# use enumerator
+FastXML.hash2xml({ enumerator: 3.times }, indent:  2)
+# =>
+# <?xml version="1.0" encoding="utf-8"?>
+# <root>
+#   <enumerator>0</enumerator>
+#   <enumerator>1</enumerator>
+#   <enumerator>2</enumerator>
+# </root>
+
+# output to file handle
+# fh = StringIO.new
+FastXML.hash2xml({ enumerator: 3.times }, indent:  2, output: fh)
+fh.string
+# =>
+# <?xml version="1.0" encoding="utf-8"?>
+# <root>
+#   <enumerator>0</enumerator>
+#   <enumerator>1</enumerator>
+#   <enumerator>2</enumerator>
+# </root>
+
+```
+
+## Options
+
+The following options are available to pass to FastXML.hash2xml(hash, options = {}).
+
+* **:root** => 'root'
+  * Root node name.
+
+* **:version** => '1.0'
+  * XML document version
+
+* **:encoding** => 'utf-8'
+  * XML input/output encoding
+
+* **:indent** => 0
+  * if indent great than "0", XML output should be indented according to
+    its hierarchic structure. This value determines the number of
+    spaces.
+
+  * if indent is "0", XML output will all be on one line.
+
+* **:output** => nil
+  * XML output method
+
+  * if output is nil, XML document dumped into string.
+
+  * if output is filehandle, XML document writes directly to a filehandle or a
+    stream.
+
+* **:canonical** => false
+  * if canonical is "true", converter will be write hashes sorted by key.
+
+  * if canonical is "false", order of the element will be pseudo-randomly.
+
+* **:use_attr** => false
+  * if use_attr is "true", converter will be use the attributes.
+
+  * if use_attr is "fale", converter will be use tags only.
+
+* **:content** => nil
+  * if defined that the key name for the text content(used only if
+    use_attr = true).
+
+* **:force_array** => nil
+  * This option is similar to "ForceArray" from [XMl::Simple module]:
+    (https://metacpan.org/pod/XML::Simple#ForceArray-1-in---important).
+
+* **:force_content** => nil
+  * This option is similar to "ForceContent" from [XMl::Simple module]:
+    (https://metacpan.org/pod/XML::Simple#ForceContent-1-in---seldom-used).
+
+* **:merge_text** => false
+  * Setting this option to "true" will cause merge adjacent text nodes.
+
+* **:xml_decl** => true
+  * if xml_decl is "true", output will start with the XML declaration
+    '<?xml version="1.0" encoding="utf-8"?>'.
+
+  * if xml_decl is "false", XML declaration will not be output.
+
+* **:trim** => false
+  * Trim leading and trailing whitespace from text nodes.
+
+* **:utf8** => true
+  * Turn on utf8 flag for strings if enabled.
+
+* **:max_depth** => 1024
+  * Maximum recursion depth.
+
+* **:buf_size** => 4096
+  * Buffer size for reading end encoding data.
+
+* **:keep_root** => false
+  * Keep root element.
+
+## Configuration
+```
+  FastXML.configure do |config|
+    config.trim = true
+  end
+```
+
+## Benchmarks
+
+Performance benchmark in comparison with some popular gems:
+
+```
+Converting Hash to XML:
+                           user     system      total        real
+activesupport(rexml)    11.020000   0.000000  11.020000 ( 11.058084)
+activesupport(libxml)   10.690000   0.000000  10.690000 ( 10.731521)
+activesupport(nokogiri) 10.730000   0.010000  10.740000 ( 10.769866)
+xmlsimple                1.470000   0.000000   1.470000 (  1.477457)
+fastxml                  0.010000   0.000000   0.010000 (  0.018434)
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/ext/fastxml/extconf.rb

@@ -0,0 +1,17 @@
+require 'mkmf'
+
+extension_name = 'fastxml'
+dir_config(extension_name)
+
+puts ">>>>> Creating Makefile for #{RUBY_DESCRIPTION} <<<<<"
+
+OPTS = Hash[
+  ARGV.map { |a| a =~ /^--with-(.+)(?:=(.*))?$/ ? [$1.to_sym, $2 || true] : nil }.compact
+].freeze
+
+if OPTS[:debug]
+  $CPPFLAGS += ' -g -Wall -Werror -Wextra -pedantic -std=c99 -DWITH_DEBUG -O0'
+  $CPPFLAGS += ' -DWITH_TRACE' if OPTS[:trace]
+end
+
+create_makefile(extension_name)

data/ext/fastxml/fastxml.c

@@ -0,0 +1,67 @@
+#include "fastxml.h"
+
+#include "xh_config.h"
+#include "xh_core.h"
+
+void Init_fastxml();
+
+VALUE xh_module;
+VALUE xh_parse_error_class;
+ID    xh_id_next;
+
+typedef struct {
+    int           argc;
+    VALUE        *argv;
+    xh_h2x_ctx_t *ctx;
+} xh_h2x_arg_t;
+
+static VALUE
+hash2xml_exec(VALUE a) {
+    xh_h2x_arg_t *arg = (xh_h2x_arg_t *) a;
+
+    xh_h2x_init_ctx(arg->ctx, arg->argc, arg->argv);
+
+    return xh_h2x(arg->ctx);
+}
+
+static VALUE
+hash2xml(int argc, VALUE *argv, VALUE self) {
+    xh_h2x_ctx_t  ctx;
+    VALUE         result;
+    int           state;
+    xh_h2x_arg_t  arg;
+
+    arg.argc = argc;
+    arg.argv = argv;
+    arg.ctx  = &ctx;
+
+    result = rb_protect(hash2xml_exec, (VALUE) &arg, &state);
+
+    if (state) {
+        xh_h2x_destroy_ctx(&ctx);
+        rb_exc_raise(rb_errinfo());
+    }
+
+    if (ctx.opts.output != Qnil) result = Qnil;
+
+    xh_h2x_destroy_ctx(&ctx);
+
+    return result;
+}
+
+static VALUE
+xml2hash(int argc, VALUE *argv, VALUE self) {
+    VALUE obj = Qnil;
+
+    return obj;
+}
+
+void Init_fastxml(void) {
+    xh_module = rb_define_module("FastXML");
+    xh_parse_error_class = rb_const_get_at(xh_module, rb_intern("ParseError"));
+
+    rb_define_module_function(xh_module, "hash2xml", hash2xml, -1);
+    rb_define_module_function(xh_module, "xml2hash", xml2hash, -1);
+
+    xh_id_next = rb_intern("next");
+}

data/ext/fastxml/fastxml.h

@@ -0,0 +1,14 @@
+#ifndef __FASTXML_H__
+#define __FASTXML_H__
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#include "ruby.h"
+
+#if defined(__cplusplus)
+}  /* extern "C" { */
+#endif
+
+#endif /* __FASTXML_H__ */

data/ext/fastxml/xh.c

@@ -0,0 +1,338 @@
+#include "xh_config.h"
+#include "xh_core.h"
+
+xh_bool_t
+xh_init_opts(xh_opts_t *opts)
+{
+    xh_char_t method[XH_PARAM_LEN];
+
+    XH_PARAM_READ_INIT
+
+    /* native options */
+    XH_PARAM_READ_STRING (opts->root,          "@root");
+    XH_PARAM_READ_STRING (opts->version,       "@version");
+    XH_PARAM_READ_STRING (opts->encoding,      "@encoding");
+    XH_PARAM_READ_INT    (opts->indent,        "@indent");
+    XH_PARAM_READ_BOOL   (opts->canonical,     "@canonical");
+    XH_PARAM_READ_STRING (opts->content,       "@content");
+    XH_PARAM_READ_BOOL   (opts->utf8,          "@utf8");
+    XH_PARAM_READ_BOOL   (opts->xml_decl,      "@xml_decl");
+    XH_PARAM_READ_BOOL   (opts->keep_root,     "@keep_root");
+#ifdef XH_HAVE_DOM
+    XH_PARAM_READ_BOOL   (opts->doc,           "@doc");
+#endif
+    XH_PARAM_READ_INT    (opts->max_depth,     "@max_depth");
+    XH_PARAM_READ_INT    (opts->buf_size,      "@buf_size");
+    XH_PARAM_READ_PATTERN(opts->force_array,   "@force_array");
+    XH_PARAM_READ_BOOL   (opts->force_content, "@force_content");
+    XH_PARAM_READ_BOOL   (opts->merge_text,    "@merge_text");
+
+    /* XML::Hash::LX options */
+    XH_PARAM_READ_STRING (opts->attr,          "@attr");
+    opts->attr_len = xh_strlen(opts->attr);
+    XH_PARAM_READ_STRING (opts->text,          "@text");
+    XH_PARAM_READ_BOOL   (opts->trim,          "@trim");
+    XH_PARAM_READ_STRING (opts->cdata,         "@cdata");
+    XH_PARAM_READ_STRING (opts->comm,          "@comm");
+
+    /* method */
+    XH_PARAM_READ_STRING (method,              "@method");
+    XH_PARAM_READ_BOOL   (opts->use_attr,      "@use_attr");
+    if (xh_strcmp(method, XH_CHAR_CAST "LX") == 0) {
+        opts->method = XH_METHOD_LX;
+    }
+    else {
+        opts->method = XH_METHOD_NATIVE;
+    }
+
+    /* output, NULL - to string */
+    XH_PARAM_READ_REF    (opts->output,        "@output");
+
+    return TRUE;
+}
+
+xh_opts_t *
+xh_create_opts(void)
+{
+    xh_opts_t *opts;
+
+    if ((opts = malloc(sizeof(xh_opts_t))) == NULL) {
+        return NULL;
+    }
+    memset(opts, 0, sizeof(xh_opts_t));
+
+    if (! xh_init_opts(opts)) {
+        xh_destroy_opts(opts);
+        return NULL;
+    }
+
+    return opts;
+}
+
+void
+xh_destroy_opts(xh_opts_t *opts)
+{
+    /* nothing */
+}
+
+void
+xh_copy_opts(xh_opts_t *dst, xh_opts_t *src)
+{
+    memcpy(dst, src, sizeof(xh_opts_t));
+}
+
+static int
+xh_parse_arg(VALUE key, VALUE value, VALUE ctx)
+{
+    xh_opts_t *opts = (xh_opts_t *) ctx;
+    xh_char_t *keyptr, *valueptr;
+    size_t     keylen, valuelen;
+
+    if (SYMBOL_P(key)) {
+        key = rb_sym2str(key);
+    }
+
+    keyptr = XH_CHAR_CAST RSTRING_PTR(key);
+    keylen = RSTRING_LEN(key);
+
+    switch (keylen) {
+        case 2:
+            if (xh_str_equal2(keyptr, 'c', 'b')) {
+                VALUE v = rb_inspect(value);
+                rb_warn("cb: %s\n", StringValueCStr(v));
+                opts->cb = xh_param_assign_cb(value);
+                break;
+            }
+            goto error;
+#ifdef XH_HAVE_DOM
+        case 3:
+            if (xh_str_equal3(keyptr, 'd', 'o', 'c')) {
+                opts->doc = xh_param_assign_bool(value);
+                break;
+            }
+            goto error;
+#endif
+        case 4:
+            if (xh_str_equal4(keyptr, 'a', 't', 't', 'r')) {
+                xh_param_assign_string(opts->attr, value);
+                if (opts->attr[0] == '\0') {
+                    opts->attr_len = 0;
+                }
+                else {
+                    opts->attr_len = xh_strlen(opts->attr);
+                }
+                break;
+            }
+            if (xh_str_equal4(keyptr, 'c', 'o', 'm', 'm')) {
+                xh_param_assign_string(opts->comm, value);
+                break;
+            }
+            if (xh_str_equal4(keyptr, 'r', 'o', 'o', 't')) {
+                xh_param_assign_string(opts->root, value);
+                break;
+            }
+            if (xh_str_equal4(keyptr, 't', 'r', 'i', 'm')) {
+                opts->trim = xh_param_assign_bool(value);
+                break;
+            }
+            if (xh_str_equal4(keyptr, 't', 'e', 'x', 't')) {
+                xh_param_assign_string(opts->text, value);
+                break;
+            }
+            if (xh_str_equal4(keyptr, 'u', 't', 'f', '8')) {
+                opts->utf8 = xh_param_assign_bool(value);
+                break;
+            }
+            goto error;
+        case 5:
+            if (xh_str_equal5(keyptr, 'c', 'd', 'a', 't', 'a')) {
+                xh_param_assign_string(opts->cdata, value);
+                break;
+            }
+            goto error;
+        case 6:
+            if (xh_str_equal6(keyptr, 'i', 'n', 'd', 'e', 'n', 't')) {
+                xh_param_assign_int(keyptr, &opts->indent, value);
+                break;
+            }
+            if (xh_str_equal6(keyptr, 'm', 'e', 't', 'h', 'o', 'd')) {
+                if (value == Qnil) {
+                    rb_raise(rb_eArgError, "Parameter '%s' is undefined", StringValueCStr(key));
+                }
+                valueptr = XH_CHAR_CAST RSTRING_PTR(value);
+                valuelen = RSTRING_LEN(value);
+                switch  (valuelen) {
+                    case 6:
+                        if (xh_str_equal6(valueptr, 'N', 'A', 'T', 'I', 'V', 'E')) {
+                            opts->method = XH_METHOD_NATIVE;
+                            break;
+                        }
+                        goto error_value;
+                    case 2:
+                        if (valueptr[0] == 'L' && valueptr[1] == 'X') {
+                            opts->method = XH_METHOD_LX;
+                            break;
+                        }
+                        goto error_value;
+                    default:
+                        goto error_value;
+                }
+                break;
+            }
+            if (xh_str_equal6(keyptr, 'o', 'u', 't', 'p', 'u', 't')) {
+                if ( RTEST(value) ) {
+                    opts->output = value;
+                }
+                else {
+                    opts->output = Qnil;
+                }
+                break;
+            }
+            if (xh_str_equal6(keyptr, 'f', 'i', 'l', 't', 'e', 'r')) {
+                xh_param_assign_filter(&opts->filter, value);
+                break;
+            }
+            goto error;
+        case 7:
+            if (xh_str_equal7(keyptr, 'c', 'o', 'n', 't', 'e', 'n', 't')) {
+                xh_param_assign_string(opts->content, value);
+                break;
+            }
+            if (xh_str_equal7(keyptr, 'v', 'e', 'r', 's', 'i', 'o', 'n')) {
+                xh_param_assign_string(opts->version, value);
+                break;
+            }
+            goto error;
+        case 8:
+            if (xh_str_equal8(keyptr, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g')) {
+                xh_param_assign_string(opts->encoding, value);
+                break;
+            }
+            if (xh_str_equal8(keyptr, 'u', 's', 'e', '_', 'a', 't', 't', 'r')) {
+                opts->use_attr = xh_param_assign_bool(value);
+                break;
+            }
+            if (xh_str_equal8(keyptr, 'x', 'm', 'l', '_', 'd', 'e', 'c', 'l')) {
+                opts->xml_decl = xh_param_assign_bool(value);
+                break;
+            }
+            if (xh_str_equal8(keyptr, 'b', 'u', 'f', '_', 's', 'i', 'z', 'e')) {
+                xh_param_assign_int(keyptr, &opts->buf_size, value);
+                break;
+            }
+            goto error;
+        case 9:
+            if (xh_str_equal9(keyptr, 'c', 'a', 'n', 'o', 'n', 'i', 'c', 'a', 'l')) {
+                opts->canonical = xh_param_assign_bool(value);
+                break;
+            }
+            if (xh_str_equal9(keyptr, 'm', 'a', 'x', '_', 'd', 'e', 'p', 't', 'h')) {
+                xh_param_assign_int(keyptr, &opts->max_depth, value);
+                break;
+            }
+            if (xh_str_equal9(keyptr, 'k', 'e', 'e', 'p', '_', 'r', 'o', 'o', 't')) {
+                opts->keep_root = xh_param_assign_bool(value);
+                break;
+            }
+            goto error;
+        case 10:
+            if (xh_str_equal10(keyptr, 'm', 'e', 'r', 'g', 'e', '_', 't', 'e', 'x', 't')) {
+                opts->merge_text = xh_param_assign_bool(value);
+                break;
+            }
+        case 11:
+            if (xh_str_equal11(keyptr, 'f', 'o', 'r', 'c', 'e', '_', 'a', 'r', 'r', 'a', 'y')) {
+                xh_param_assign_pattern(&opts->force_array, value);
+                break;
+            }
+        case 13:
+            if (xh_str_equal13(keyptr, 'f', 'o', 'r', 'c', 'e', '_', 'c', 'o', 'n', 't', 'e', 'n', 't')) {
+                opts->force_content = xh_param_assign_bool(value);
+                break;
+            }
+        default:
+            goto error;
+    }
+
+    return ST_CONTINUE;
+
+error_value:
+    rb_raise(rb_eArgError, "Invalid parameter value for '%s': %s", StringValueCStr(key), StringValueCStr(value));
+
+error:
+    rb_raise(rb_eArgError, "Invalid parameter '%s'", StringValueCStr(key));
+}
+
+void
+xh_parse_args(xh_opts_t *opts, xh_int_t *nparam, xh_int_t argc, VALUE *argv)
+{
+    VALUE hash;
+
+    if (*nparam >= argc)
+        return;
+
+    hash = argv[*nparam];
+    if (rb_cHash != rb_obj_class(hash))
+        rb_raise(rb_eArgError, "Parameter is not a hash");
+
+    (*nparam)++;
+
+    rb_hash_foreach(hash, xh_parse_arg, (VALUE) opts);
+}
+
+void *
+xh_get_obj_param(xh_int_t *nparam, xh_int_t argc, VALUE *argv, const char *class)
+{
+    void *obj = NULL;
+/*
+    SV   *param;
+
+    if (*nparam >= items)
+        rb_raise(rb_eArgError, "Invalid parameters");
+
+    param = ST(*nparam);
+    if ( sv_derived_from(param, class) ) {
+        if ( sv_isobject(param) ) {
+            // reference to object
+            IV tmp = SvIV((SV *) SvRV(param));
+            obj = INT2PTR(xh_opts_t *, tmp);
+        }
+        (*nparam)++;
+    }
+*/
+    return obj;
+}
+
+VALUE
+xh_get_hash_param(xh_int_t *nparam, xh_int_t argc, VALUE *argv)
+{
+    VALUE param;
+
+    if (*nparam >= argc)
+        rb_raise(rb_eArgError, "Invalid parameters");
+
+    param = argv[*nparam];
+    if (rb_cHash != rb_obj_class(param))
+        rb_raise(rb_eArgError, "Parameter is not a hash");
+
+    (*nparam)++;
+
+    return param;
+}
+
+void
+xh_merge_opts(xh_opts_t *ctx_opts, xh_opts_t *opts, xh_int_t *nparam, xh_int_t argc, VALUE *argv)
+{
+    if (opts == NULL) {
+        /* read global options */
+        xh_init_opts(ctx_opts);
+    }
+    else {
+        /* copy options from object */
+        xh_copy_opts(ctx_opts, opts);
+    }
+    if (*nparam < argc) {
+        xh_parse_args(ctx_opts, nparam, argc, argv);
+    }
+}
+