fast-xml 1.0.1 → 1.1.0

data/ext/fastxml/ccan/str/str.h

@@ -0,0 +1,16 @@
+/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
+#ifndef CCAN_STR_H
+#define CCAN_STR_H
+/**
+ * stringify - Turn expression into a string literal
+ * @expr: any C expression
+ *
+ * Example:
+ *	#define PRINT_COND_IF_FALSE(cond) \
+ *		((cond) || printf("%s is false!", stringify(cond)))
+ */
+#define stringify(expr)		stringify_1(expr)
+/* Double-indirection required to stringify expansions */
+#define stringify_1(expr)	#expr
+
+#endif /* CCAN_STR_H */

data/ext/fastxml/fastxml.c

@@ -8,6 +8,7 @@ void Init_fastxml();
 VALUE xh_module;
 VALUE xh_parse_error_class;
 ID    xh_id_next;
+ID    xh_id_initialize;
 
 typedef struct {
     int           argc;
@@ -15,6 +16,12 @@ typedef struct {
     xh_h2x_ctx_t *ctx;
 } xh_h2x_arg_t;
 
+typedef struct {
+    int           argc;
+    VALUE        *argv;
+    xh_x2h_ctx_t *ctx;
+} xh_x2h_arg_t;
+
 static VALUE
 hash2xml_exec(VALUE a) {
     xh_h2x_arg_t *arg = (xh_h2x_arg_t *) a;
@@ -49,11 +56,36 @@ hash2xml(int argc, VALUE *argv, VALUE self) {
     return result;
 }
 
+static VALUE
+xml2hash_exec(VALUE a) {
+    xh_x2h_arg_t *arg = (xh_x2h_arg_t *) a;
+
+    xh_x2h_init_ctx(arg->ctx, arg->argc, arg->argv);
+
+    return xh_x2h(arg->ctx);
+}
+
 static VALUE
 xml2hash(int argc, VALUE *argv, VALUE self) {
-    VALUE obj = Qnil;
+    xh_x2h_ctx_t  ctx;
+    VALUE         result;
+    int           state;
+    xh_x2h_arg_t  arg;
 
-    return obj;
+    arg.argc = argc;
+    arg.argv = argv;
+    arg.ctx  = &ctx;
+
+    result = rb_protect(xml2hash_exec, (VALUE) &arg, &state);
+
+    if (state) {
+        xh_x2h_destroy_ctx(&ctx);
+        rb_exc_raise(rb_errinfo());
+    }
+
+    xh_x2h_destroy_ctx(&ctx);
+
+    return result;
 }
 
 void Init_fastxml(void) {
@@ -64,4 +96,5 @@ void Init_fastxml(void) {
     rb_define_module_function(xh_module, "xml2hash", xml2hash, -1);
 
     xh_id_next = rb_intern("next");
+    xh_id_initialize = rb_intern("initialize");
 }

data/ext/fastxml/xh.c

@@ -96,14 +96,6 @@ xh_parse_arg(VALUE key, VALUE value, VALUE ctx)
     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')) {
@@ -278,6 +270,8 @@ xh_parse_args(xh_opts_t *opts, xh_int_t *nparam, xh_int_t argc, VALUE *argv)
     (*nparam)++;
 
     rb_hash_foreach(hash, xh_parse_arg, (VALUE) opts);
+
+    opts->block_given = xh_param_assign_block();
 }
 
 void *
@@ -320,6 +314,23 @@ xh_get_hash_param(xh_int_t *nparam, xh_int_t argc, VALUE *argv)
     return param;
 }
 
+VALUE
+xh_get_str_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_TYPE_P(param, RUBY_T_STRING))
+        rb_raise(rb_eArgError, "Parameter is not a string");
+
+    (*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)
 {

data/ext/fastxml/xh.h

@@ -35,7 +35,7 @@ typedef struct {
     xh_bool_t              force_content;
     xh_bool_t              merge_text;
     xh_pattern_t           filter;
-    VALUE                  cb;
+    xh_bool_t              block_given;
 
     /* LX options */
     xh_char_t              attr[XH_PARAM_LEN];
@@ -53,6 +53,7 @@ void xh_parse_args(xh_opts_t *opts, xh_int_t *nparam, xh_int_t argc, VALUE *argv
 void xh_copy_opts(xh_opts_t *dst, xh_opts_t *src);
 void *xh_get_obj_param(xh_int_t *nparam, xh_int_t argc, VALUE *argv, const char *class);
 VALUE xh_get_hash_param(xh_int_t *nparam, xh_int_t argc, VALUE *argv);
+VALUE xh_get_str_param(xh_int_t *nparam, xh_int_t argc, VALUE *argv);
 void xh_merge_opts(xh_opts_t *ctx_opts, xh_opts_t *opts, xh_int_t *nparam, xh_int_t argc, VALUE *argv);
 
 #endif /* _XH_H_ */

data/ext/fastxml/xh_config.h

@@ -2,6 +2,8 @@
 #define _XH_CONFIG_H_
 
 #include "ruby.h"
+#include "ruby/io.h"
+#include "ruby/re.h"
 #if HAVE_RUBY_ENCODING_H
 #include "ruby/encoding.h"
 #endif
@@ -70,5 +72,6 @@ typedef u_char    xh_char_t;
 extern VALUE xh_module;
 extern VALUE xh_parse_error_class;
 extern ID    xh_id_next;
+extern ID    xh_id_initialize;
 
 #endif /* _XH_CONFIG_H_ */

data/ext/fastxml/xh_core.h

@@ -35,19 +35,15 @@
 #include "xh_string.h"
 #include "xh_sort.h"
 #include "xh_stack.h"
-//#include "xh_stash.h"
 #include "xh_param.h"
 #include "xh_buffer_helper.h"
 #include "xh_buffer.h"
 #include "xh_ruby_buffer.h"
 #include "xh_encoder.h"
-//#include "xh_reader.h"
+#include "xh_reader.h"
 #include "xh_writer.h"
 #include "xh.h"
 #include "xh_h2x.h"
 #include "xh_xml.h"
-/*
 #include "xh_x2h.h"
-#include "xh_dom.h"
-*/
 #endif /* _XH_CORE_H_ */

data/ext/fastxml/xh_log.h

@@ -14,25 +14,35 @@ typedef enum {
     XH_LOG_TRACE
 } xh_log_level_t;
 
+#if __STDC_VERSION__ < 199901L
+# if __GNUC__ >= 2
+#  define XH_CURRENT_FUNCTION __FUNCTION__
+# else
+#  define XH_CURRENT_FUNCTION "<unknown>"
+# endif
+#else
+# define XH_CURRENT_FUNCTION __func__
+#endif
+
 #ifdef WITH_TRACE
 #define xh_log_debug0(msg)                                                 \
-        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg)
+        xh_log(XH_LOG_DEBUG, XH_CURRENT_FUNCTION, __LINE__, msg)
 #define xh_log_debug1(msg, arg1)                                           \
-        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1)
+        xh_log(XH_LOG_DEBUG, XH_CURRENT_FUNCTION, __LINE__, msg, arg1)
 #define xh_log_debug2(msg, arg1, arg2)                                     \
-        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2)
+        xh_log(XH_LOG_DEBUG, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2)
 #define xh_log_debug3(msg, arg1, arg2, arg3)                               \
-        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3)
+        xh_log(XH_LOG_DEBUG, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3)
 #define xh_log_debug4(msg, arg1, arg2, arg3, arg4)                         \
-        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4)
+        xh_log(XH_LOG_DEBUG, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4)
 #define xh_log_debug5(msg, arg1, arg2, arg3, arg4, arg5)                   \
-        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5)
+        xh_log(XH_LOG_DEBUG, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4, arg5)
 #define xh_log_debug6(msg, arg1, arg2, arg3, arg4, arg5, arg6)             \
-        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6)
+        xh_log(XH_LOG_DEBUG, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6)
 #define xh_log_debug7(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)       \
-        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+        xh_log(XH_LOG_DEBUG, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
 #define xh_log_debug8(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
-        xh_log(XH_LOG_DEBUG, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+        xh_log(XH_LOG_DEBUG, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
 #else
 #define xh_log_debug0(msg)
 #define xh_log_debug1(msg, arg1)
@@ -47,23 +57,23 @@ typedef enum {
 
 #ifdef WITH_TRACE
 #define xh_log_trace0(msg)                                                 \
-        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg)
+        xh_log(XH_LOG_TRACE, XH_CURRENT_FUNCTION, __LINE__, msg)
 #define xh_log_trace1(msg, arg1)                                           \
-        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1)
+        xh_log(XH_LOG_TRACE, XH_CURRENT_FUNCTION, __LINE__, msg, arg1)
 #define xh_log_trace2(msg, arg1, arg2)                                     \
-        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2)
+        xh_log(XH_LOG_TRACE, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2)
 #define xh_log_trace3(msg, arg1, arg2, arg3)                               \
-        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3)
+        xh_log(XH_LOG_TRACE, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3)
 #define xh_log_trace4(msg, arg1, arg2, arg3, arg4)                         \
-        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4)
+        xh_log(XH_LOG_TRACE, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4)
 #define xh_log_trace5(msg, arg1, arg2, arg3, arg4, arg5)                   \
-        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5)
+        xh_log(XH_LOG_TRACE, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4, arg5)
 #define xh_log_trace6(msg, arg1, arg2, arg3, arg4, arg5, arg6)             \
-        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6)
+        xh_log(XH_LOG_TRACE, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6)
 #define xh_log_trace7(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)       \
-        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+        xh_log(XH_LOG_TRACE, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
 #define xh_log_trace8(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
-        xh_log(XH_LOG_TRACE, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+        xh_log(XH_LOG_TRACE, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
 #else
 #define xh_log_trace0(msg)
 #define xh_log_trace1(msg, arg1)
@@ -77,23 +87,23 @@ typedef enum {
 #endif
 
 #define xh_log_error0(msg)                                                 \
-        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg)
+        xh_log(XH_LOG_ERROR, XH_CURRENT_FUNCTION, __LINE__, msg)
 #define xh_log_error1(msg, arg1)                                           \
-        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1)
+        xh_log(XH_LOG_ERROR, XH_CURRENT_FUNCTION, __LINE__, msg, arg1)
 #define xh_log_error2(msg, arg1, arg2)                                     \
-        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2)
+        xh_log(XH_LOG_ERROR, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2)
 #define xh_log_error3(msg, arg1, arg2, arg3)                               \
-        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3)
+        xh_log(XH_LOG_ERROR, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3)
 #define xh_log_error4(msg, arg1, arg2, arg3, arg4)                         \
-        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4)
+        xh_log(XH_LOG_ERROR, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4)
 #define xh_log_error5(msg, arg1, arg2, arg3, arg4, arg5)                   \
-        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5)
+        xh_log(XH_LOG_ERROR, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4, arg5)
 #define xh_log_error6(msg, arg1, arg2, arg3, arg4, arg5, arg6)             \
-        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6)
+        xh_log(XH_LOG_ERROR, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6)
 #define xh_log_error7(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)       \
-        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
+        xh_log(XH_LOG_ERROR, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
 #define xh_log_error8(msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
-        xh_log(XH_LOG_ERROR, __FUNCTION__, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
+        xh_log(XH_LOG_ERROR, XH_CURRENT_FUNCTION, __LINE__, msg, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
 
 void xh_log(xh_log_level_t log_level, const char *func, xh_int_t line, const char *msg, ...);
 

data/ext/fastxml/xh_param.c

@@ -62,16 +62,8 @@ xh_param_assign_filter(xh_pattern_t *patt, VALUE value)
     }
 }
 
-VALUE
-xh_param_assign_cb(VALUE value)
+xh_bool_t
+xh_param_assign_block(void)
 {
-    if ( !RTEST(value) )
-        return Qnil;
-
-    if (rb_cProc != rb_class_of(value) && rb_cMethod != rb_class_of(value))
-      rb_raise(rb_eArgError, "Expected Proc or Method callback");
-
-    //rb_funcall(value, rb_intern("call"), 0);
-
-    return value;
+    return rb_block_given_p() ? TRUE : FALSE;
 }

data/ext/fastxml/xh_param.h

@@ -15,7 +15,7 @@ void xh_param_assign_int(xh_char_t *name, xh_int_t *param, VALUE value);
 xh_bool_t xh_param_assign_bool(VALUE value);
 void xh_param_assign_pattern(xh_pattern_t *param, VALUE value);
 void xh_param_assign_filter(xh_pattern_t *param, VALUE value);
-VALUE xh_param_assign_cb(VALUE value);
+VALUE xh_param_assign_block(void);
 
 #define XH_PARAM_LEN 32