isomorfeus-preact 23.1.0.rc1 → 23.6.0.rc1

data/ext/isomorfeus_preact_ext/preact.c

@@ -1,9 +1,10 @@
+#include "vnode.h"
 #include <ruby.h>
-#define FIO_STR_NAME render_result
-#include "fio-stl.h"
-#include "isomorfeus_preact_ext.h"
+#include <ruby/encoding.h>
+#include <ruby/re.h>
+
+rb_encoding *utf8_encoding;
 
-static ID id_ancestors;
 static ID id_checked;
 static ID id_children;
 static ID id_class;
@@ -20,20 +21,14 @@ static ID id_downcase;
 static ID id_encode_entities;
 static ID id_eqeq;
 static ID id_for;
-static ID id_freeze;
 static ID id_get_child_context;
 static ID id_get_derived_state_from_props;
 static ID id_gsub;
 static ID id_html_for;
-static ID id_include;
-static ID id_is_a;
-static ID id_is_renderable;
+
 static ID id_key;
-static ID id_keyq;
 static ID id_keys;
-static ID id_match;
 static ID id_merge;
-static ID id_new;
 static ID id_props;
 static ID id_ref;
 static ID id_render;
@@ -41,10 +36,9 @@ static ID id_render_buffer;
 static ID id_selected;
 static ID id_self;
 static ID id_source;
-static ID id_start_withq;
-static ID id_state;
 static ID id_style;
 static ID id_style_obj_to_css;
+static ID id_to_s;
 static ID id_validate_props;
 static ID id_value;
 
@@ -54,6 +48,8 @@ static ID iv_next_state;
 static ID iv_props;
 static ID iv_state;
 
+static char *str_aria = "aria-";
+static char *str_data = "data-";
 static char *str_foreign_object = "foreignObject";
 static char *str_option = "option";
 static char *str_select = "select";
@@ -61,13 +57,13 @@ static char *str_selected = "selected";
 static char *str_svg = "svg";
 static char *str_textarea = "textarea";
 
-static char *str_rve = "^(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$";
+static char *str_rve =
+    "^(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$";
 static char *str_run = "[\\s\\n\\\\\\/='\"\\0<>]";
 static char *str_rxl = "^xlink:?.";
 static char *str_rx2 = "^xlink:?";
 // static char *str_ree = "[\"&<]";
 
-static VALUE s_aria;
 static VALUE s_false;
 static VALUE s_true;
 static VALUE s_xlink;
@@ -85,8 +81,6 @@ static VALUE sym_value;
 static VALUE mIsomorfeus;
 static VALUE mPreact;
 static VALUE cFragment;
-static VALUE cProc;
-static VALUE cRegexp;
 
 extern VALUE cVNode;
 
@@ -95,359 +89,400 @@ static VALUE rUnsafe;
 static VALUE rVoid;
 static VALUE rXlink2;
 
-int set_default_prop_value(VALUE prop, VALUE value, VALUE props) {
-  if ((rb_funcall(value, id_keyq, 1, sym_default) == Qtrue) && (rb_funcall(props, id_keyq, 1, prop) == Qfalse)) {
-    rb_hash_aset(props, props, rb_hash_lookup(value, sym_default));
-  }
+static int set_default_prop_value(VALUE prop, VALUE value, VALUE props) {
+  VALUE def_val = rb_hash_lookup(value, sym_default);
+  if ((def_val != Qnil) && (rb_hash_lookup(props, prop) == Qnil))
+    rb_hash_aset(props, prop, def_val);
   return 0;
 }
 
-ID normalize_prop_name(ID name_id, VALUE is_svg_mode) {
-  if (name_id == id_class_name || name_id == id_class_name2) { return id_class; }
-  if (name_id == id_html_for) { return id_for; }
-  if (name_id == id_default_value) { return id_value; }
-  if (name_id == id_default_checked) { return id_checked; }
-  if (name_id == id_default_selected) { return id_selected; }
+static ID normalize_prop_name(ID name_id, VALUE is_svg_mode) {
+  if (name_id == id_class_name || name_id == id_class_name2)
+    return id_class;
+  if (name_id == id_html_for)
+    return id_for;
+  if (name_id == id_default_value)
+    return id_value;
+  if (name_id == id_default_checked)
+    return id_checked;
+  if (name_id == id_default_selected)
+    return id_selected;
   if (is_svg_mode == Qtrue) {
     VALUE name_s = rb_id2str(name_id);
-    if (rb_funcall(rXlink, id_match, 1, name_s) == Qtrue) {
+    if (rb_reg_match(rXlink, name_s) == Qtrue) {
       name_s = rb_funcall(name_s, id_downcase, 0);
       name_s = rb_funcall(name_s, id_gsub, 2, rXlink2, s_xlink);
-      return SYM2ID(rb_to_symbol(name_s));
+      return rb_intern_str(name_s);
     }
   }
   return name_id;
 }
 
-VALUE normalize_prop_value(ID name_id, VALUE name_s, VALUE value, VALUE self) {
-	if (name_id == id_style && value != Qnil && TYPE(value) == T_HASH) {
-		return rb_funcall(self, id_style_obj_to_css, 1, value);
-	}
-  // name[0] === 'a' && name[1] === 'r'
-  if (value == Qtrue && rb_funcall(name_s, id_start_withq, 1, s_aria) == Qtrue) {
-    // always use string values instead of booleans for aria attributes
-		// also see https://github.com/preactjs/preact/pull/2347/files
-    return s_true;
-	}
-  if (value == Qfalse && rb_funcall(name_s, id_start_withq, 1, s_aria) == Qtrue) {
-    // always use string values instead of booleans for aria attributes
-		// also see https://github.com/preactjs/preact/pull/2347/files
-    return s_false;
-	}
-	return value;
+static VALUE normalize_prop_value(ID name_id, VALUE name_s, VALUE value,
+                                  VALUE self) {
+  if (name_id == id_style && TYPE(value) == T_HASH)
+    return rb_funcall(self, id_style_obj_to_css, 1, value);
+  if (value == Qtrue && RSTRING_LEN(name_s) > 4) {
+    if ((0 == strncmp(RSTRING_PTR(name_s), str_aria, 5)) ||
+        (0 == strncmp(RSTRING_PTR(name_s), str_data, 5))) {
+      // always use string values instead of booleans for aria attributes
+      // also see https://github.com/preactjs/preact/pull/2347/files
+      return s_true;
+    }
+  }
+  if (value == Qfalse && RSTRING_LEN(name_s) > 4) {
+    if ((0 == strncmp(RSTRING_PTR(name_s), str_aria, 5)) ||
+        (0 == strncmp(RSTRING_PTR(name_s), str_data, 5))) {
+      // always use string values instead of booleans for aria attributes
+      // also see https://github.com/preactjs/preact/pull/2347/files
+      return s_false;
+    }
+  }
+  return value;
 }
 
-VALUE get_context(VALUE node_type, VALUE context) {
+static VALUE get_context(VALUE node_type, VALUE context) {
   VALUE ctx_type = rb_funcall(node_type, id_context_type, 0);
-  VALUE provider = Qnil;
-  VALUE cctx = context;
   if (ctx_type != Qnil) {
-    provider = rb_hash_lookup(context, rb_funcall(ctx_type, id_context_id, 0));
-    if (provider != Qnil) {
-      cctx = rb_hash_lookup(rb_funcall(provider, id_props, 0), sym_value); }
-    else {
-      cctx = rb_funcall(ctx_type, id_value, 0); }
+    VALUE provider =
+        rb_hash_lookup(context, rb_funcall(ctx_type, id_context_id, 0));
+    if (provider != Qnil)
+      return rb_hash_lookup(rb_funcall(provider, id_props, 0), sym_value);
+    else
+      return rb_funcall(ctx_type, id_value, 0);
   }
-  return cctx;
+  return context;
 }
 
-VALUE render_class_component(VALUE vnode, VALUE context) {
-  VNode *v = (VNode *)DATA_PTR(vnode);
-
-	VALUE node_type = v->type;
+static VALUE render_class_component(VALUE vnode, VALUE context, VNode *v) {
+  VALUE node_type = v->type;
   VALUE props = v->props;
-  VALUE state = rb_hash_new();
 
   // get context
-	VALUE cctx = get_context(node_type, context);
+  VALUE cctx = get_context(node_type, context);
 
   // validate props
   VALUE declared_props = rb_ivar_get(node_type, iv_declared_props);
   if (declared_props != Qnil) {
     rb_hash_foreach(declared_props, set_default_prop_value, props);
-    if (rb_funcall(mIsomorfeus, id_development, 0) == Qtrue) { rb_funcall(node_type, id_validate_props, 1, props); }
+    if (rb_funcall(mIsomorfeus, id_development, 0) == Qtrue)
+      rb_funcall(node_type, id_validate_props, 1, props);
   }
 
   // freeze props
-  rb_funcall(props, id_freeze, 0);
+  rb_obj_freeze(props);
 
   // instantiate component
-  VALUE c = rb_funcall(node_type, id_new, 2, props, cctx);
-	v->component = c;
+  const VALUE cargs[2] = {props, cctx};
+  VALUE c = rb_class_new_instance(2, (const VALUE *)&cargs, node_type);
+  v->component = c;
 
   // set state, props, context
   rb_ivar_set(c, iv_props, props);
-  if (rb_funcall(c, id_state, 0) == Qnil) { rb_ivar_set(c, iv_state, state); }
-  if (rb_ivar_get(c, iv_next_state) == Qnil) { rb_ivar_set(c, iv_next_state, rb_funcall(c, id_state, 0)); }
+  if (rb_ivar_get(c, iv_state) == Qnil)
+    rb_ivar_set(c, iv_state, rb_hash_new());
+  if (rb_ivar_get(c, iv_next_state) == Qnil)
+    rb_ivar_set(c, iv_next_state, rb_ivar_get(c, iv_state));
   rb_ivar_set(c, iv_context, cctx);
 
   // get_derived_state_from_props
   if (rb_respond_to(c, id_get_derived_state_from_props)) {
-    VALUE state = rb_funcall(c, id_state, 0);
-    VALUE res = rb_funcall(c, id_get_derived_state_from_props, 2, rb_funcall(c, id_props, 0), state);
+    VALUE state = rb_ivar_get(c, iv_state);
+    VALUE res = rb_funcall(c, id_get_derived_state_from_props, 2,
+                           rb_funcall(c, id_props, 0), state);
     rb_ivar_set(c, iv_state, rb_funcall(state, id_merge, res));
   }
 
   // freeze state
-  rb_funcall(rb_funcall(c, id_state, 0), id_freeze, 0);
+  rb_obj_freeze(rb_ivar_get(c, iv_state));
 
   // render
-	return rb_funcall(c, id_render, 0);
+  return rb_funcall(c, id_render, 0);
 }
 
-void internal_render_to_string(VALUE vnode, VALUE context, VALUE is_svg_mode, VALUE select_value, VALUE self, render_result_s *rres) {
-  VNode *v;
-  VALUE res;
-  VALUE node_type, props;
-  int i, len;
+void internal_render_to_string(VALUE vnode, VALUE context, VALUE is_svg_mode,
+                               VALUE select_value, VALUE self, VALUE rres) {
+  size_t i, len;
 
-  if (vnode == Qnil || vnode == Qfalse || vnode == Qtrue || ((TYPE(vnode) == T_STRING) && RSTRING_LEN(vnode) == 0)) {
+  if (vnode == Qnil || vnode == Qfalse || vnode == Qtrue)
     return;
-  }
 
   switch (TYPE(vnode)) {
-    case T_STRING:
-      res = rb_funcall(self, id_encode_entities, 1, vnode);
-      render_result_write(rres, RSTRING_PTR(res), RSTRING_LEN(res));
-      return;
-    case T_FIXNUM:
-    case T_BIGNUM:
-      res = rb_obj_as_string(vnode);
-      render_result_write(rres, RSTRING_PTR(res), RSTRING_LEN(res));
-      return;
-    case T_ARRAY:
-      len = RARRAY_LEN(vnode);
-      for (i = 0; i < len; i++) {
-        internal_render_to_string(RARRAY_PTR(vnode)[i], context, is_svg_mode, select_value, self, rres);
-      }
+  case T_STRING:
+    if (RSTRING_LEN(vnode) == 0)
       return;
+    rb_str_buf_append(rres, rb_funcall(self, id_encode_entities, 1, vnode));
+    return;
+  case T_FIXNUM:
+  case T_BIGNUM:
+    rb_str_buf_append(rres, rb_funcall(vnode, id_to_s, 0));
+    return;
+  case T_ARRAY:
+    len = RARRAY_LEN(vnode);
+    for (i = 0; i < len; i++) {
+      internal_render_to_string(RARRAY_PTR(vnode)[i], context, is_svg_mode,
+                                select_value, self, rres);
+    }
+    return;
   }
 
-  v = (VNode *)DATA_PTR(vnode);
-  node_type = v->type;
-  props = v->props;
+  VNode *v = (VNode *)DATA_PTR(vnode);
+  VALUE node_type = v->type;
+  VALUE props = v->props;
 
   if (TYPE(node_type) != T_STRING) {
-    // components and Fragments
-    VALUE rendered;
-    VALUE ancestors = rb_funcall(node_type, id_ancestors, 0);
-    rb_funcall(ancestors, id_include, 1, cFragment);
+    // Components and Fragments
+    VALUE rendered = Qnil;
 
-    if (RARRAY_PTR(ancestors)[0] == cFragment) {
+    if (node_type == cFragment && RHASH_SIZE(props) > 0) {
       rendered = rb_hash_lookup(props, sym_children);
     } else {
-      rendered = render_class_component(vnode, context);
+      rendered = render_class_component(vnode, context, v);
 
       VALUE component = v->component;
       if (rb_respond_to(component, id_get_child_context)) {
-        context = rb_funcall(context, id_merge, 1, rb_funcall(component, id_get_child_context, 0));
+        context = rb_funcall(context, id_merge, 1,
+                             rb_funcall(component, id_get_child_context, 0));
       }
     }
 
-    internal_render_to_string(rendered, context, is_svg_mode, select_value, self, rres);
+    internal_render_to_string(rendered, context, is_svg_mode, select_value,
+                              self, rres);
     return;
   }
 
-  props = v->props;
-
   // render JSX to HTML
-  VALUE node_type_s = rb_obj_as_string(node_type);
-  render_result_write(rres, "<", 1);
-  render_result_write(rres, RSTRING_PTR(node_type_s), RSTRING_LEN(node_type_s));
+  rb_str_cat(rres, "<", 1);
+  rb_str_buf_append(rres, node_type);
 
   VALUE children = Qnil;
   VALUE html = Qnil;
 
-  if (props != Qnil) {
+  if (props != Qnil && RHASH_SIZE(props) > 0) {
     children = rb_hash_lookup(props, sym_children);
     VALUE attrs = rb_funcall(props, id_keys, 0);
     len = RARRAY_LEN(attrs);
     for (i = 0; i < len; i++) {
       VALUE name = RARRAY_PTR(attrs)[i];
-      if (TYPE(name) == T_STRING) { name = rb_to_symbol(name); }
       ID name_id = SYM2ID(name);
-      VALUE value = rb_hash_lookup(props, name);
-
-      if (name_id == id_key || name_id == id_ref || name_id == id_self || name_id == id_source || name_id == id_children ||
-        ((name_id == id_class_name || name_id == id_class_name2) && (rb_hash_lookup(props, sym_class) != Qnil)) ||
-        ((name_id == id_html_for) && (rb_hash_lookup(props, sym_for) != Qnil))) {
+      VALUE value = rb_hash_lookup(props, rb_to_symbol(name));
+
+      if (name_id == id_key || name_id == id_ref || name_id == id_self ||
+          name_id == id_source || name_id == id_children ||
+          ((name_id == id_class_name || name_id == id_class_name2) &&
+           (rb_hash_lookup(props, sym_class) != Qnil)) ||
+          ((name_id == id_html_for) &&
+           (rb_hash_lookup(props, sym_for) != Qnil)))
         continue;
-      }
 
+      VALUE orig_name_id = name_id;
       VALUE name_s = rb_id2str(name_id);
-      if (rb_funcall(rUnsafe, id_match, 1, name_s) == Qtrue) {
+      if (rb_reg_match(rUnsafe, name_s) == Qtrue)
         continue;
-      }
 
       name_id = normalize_prop_name(name_id, is_svg_mode);
-      name_s = rb_id2str(name_id);
+      if (name_id != orig_name_id)
+        name_s = rb_id2str(name_id);
       value = normalize_prop_value(name_id, name_s, value, self);
 
       if (name_id == id_dangerously_set_inner_html && value != Qnil) {
         html = rb_hash_lookup(value, sym_html);
-      } else if (name_id == id_value && strcmp(RSTRING_PTR(node_type_s), str_textarea) == 0) {
+      } else if (name_id == id_value &&
+                 strcmp(RSTRING_PTR(node_type), str_textarea) == 0) {
         // <textarea value="a&b"> --> <textarea>a&amp;b</textarea>
         children = value;
-      } else if (value != Qnil && value != Qfalse && rb_funcall(value, id_is_a, 1, cProc) != Qtrue) {
-        if (value == Qtrue || ((TYPE(value) == T_STRING) && (RSTRING_PTR(value)[0] == 0))) {
+      } else if (value != Qnil && value != Qfalse &&
+                 rb_obj_is_proc(value) != Qtrue) {
+        if (value == Qtrue ||
+            ((TYPE(value) == T_STRING) && (RSTRING_PTR(value)[0] == 0))) {
           // if (name_id == id_class || name_id == id_style) { continue; }
           value = name_s;
-          render_result_write(rres, " ", 1);
-          render_result_write(rres, RSTRING_PTR(name_s), RSTRING_LEN(name_s));
+          rb_str_cat(rres, " ", 1);
+          rb_str_buf_append(rres, name_s);
           continue;
         }
 
         if (name_id == id_value) {
-          if (strcmp(RSTRING_PTR(node_type_s), str_select) == 0) {
+          if (strcmp(RSTRING_PTR(node_type), str_select) == 0) {
             select_value = value;
             continue;
           } else if (
-            // If we're looking at an <option> and it's the currently selected one
-            strcmp(RSTRING_PTR(node_type_s), str_option) == 0 &&
-            rb_funcall(select_value, id_eqeq, 1, value) == Qtrue &&
-            // and the <option> doesn't already have a selected attribute on it
-            rb_hash_lookup(props, sym_selected) == Qnil
-          ) {
-            render_result_write(rres, " ", 1);
-            render_result_write(rres, str_selected, strlen(str_selected));
+              // If we're looking at an <option> and it's the currently selected
+              // one
+              strcmp(RSTRING_PTR(node_type), str_option) == 0 &&
+              rb_funcall(select_value, id_eqeq, 1, value) == Qtrue &&
+              // and the <option> doesn't already have a selected attribute on
+              // it
+              rb_hash_lookup(props, sym_selected) == Qnil) {
+            rb_str_cat(rres, " ", 1);
+            rb_str_cat(rres, str_selected, strlen(str_selected));
           }
         }
 
-        render_result_write(rres, " ", 1);
-        render_result_write(rres, RSTRING_PTR(name_s), RSTRING_LEN(name_s));
-        render_result_write(rres, "=\"", 2);
-        res = rb_funcall(self, id_encode_entities, 1, value);
-        render_result_write(rres, RSTRING_PTR(res), RSTRING_LEN(res));
-        render_result_write(rres, "\"", 1);
+        rb_str_cat(rres, " ", 1);
+        rb_str_buf_append(rres, name_s);
+        rb_str_cat(rres, "=\"", 2);
+        rb_str_buf_append(rres, rb_funcall(self, id_encode_entities, 1, rb_funcall(value, id_to_s, 0)));
+        rb_str_cat(rres, "\"", 1);
       }
     }
   }
 
-  render_result_write(rres, ">", 1);
+  rb_str_cat(rres, ">", 1);
 
-  if (rb_funcall(rUnsafe, id_match, 1, node_type_s) == Qtrue) {
-    rb_raise(rb_eRuntimeError, "%s is not a valid HTML tag name in %s", RSTRING_PTR(node_type_s), render_result2ptr(rres));
-  }
+  if (rb_reg_match(rUnsafe, node_type) == Qtrue)
+    rb_raise(rb_eRuntimeError, "%s is not a valid HTML tag name in %s",
+             RSTRING_PTR(node_type), RSTRING_PTR(rres));
 
-  render_result_s *pieces = render_result_new();
   VALUE has_children = Qfalse;
-  int children_type = TYPE(children);
+  int children_type = (children == Qnil) ? T_NIL : TYPE(children);
 
   if (html != Qnil) {
-    render_result_write(pieces, RSTRING_PTR(html), RSTRING_LEN(html));
+    rb_str_buf_append(rres, html);
     has_children = Qtrue;
   } else if (children_type == T_STRING) {
-    res = rb_funcall(self, id_encode_entities, 1, children);
-    render_result_write(pieces, RSTRING_PTR(res), RSTRING_LEN(res));
+    rb_str_buf_append(rres, rb_funcall(self, id_encode_entities, 1, children));
     has_children = Qtrue;
   } else if (children_type == T_ARRAY) {
     VALUE child;
     len = RARRAY_LEN(children);
-    for (i = 0; i < len; i++) {
-      child = RARRAY_PTR(children)[i];
-      if (child != Qnil && child != Qfalse) {
-        VALUE child_svg_mode;
-        if (strcmp(RSTRING_PTR(node_type_s), str_svg) == 0) {
-          child_svg_mode = Qtrue;
-        } else if (strcmp(RSTRING_PTR(node_type_s), str_foreign_object) == 0 && is_svg_mode == Qtrue) {
-          child_svg_mode = Qfalse;
-        } else {
-          child_svg_mode = is_svg_mode;
+    if (len > 0) {
+      long rres_len;
+      for (i = 0; i < len; i++) {
+        child = RARRAY_PTR(children)[i];
+        if (child != Qnil && child != Qfalse) {
+          VALUE child_svg_mode;
+          if (strcmp(RSTRING_PTR(node_type), str_svg) == 0)
+            child_svg_mode = Qtrue;
+          else if (strcmp(RSTRING_PTR(node_type), str_foreign_object) == 0 &&
+                   is_svg_mode == Qtrue)
+            child_svg_mode = Qfalse;
+          else
+            child_svg_mode = is_svg_mode;
+          rres_len = RSTRING_LEN(rres);
+          internal_render_to_string(child, context, child_svg_mode,
+                                    select_value, self, rres);
+          if (rres_len < RSTRING_LEN(rres))
+            has_children = Qtrue;
         }
-        size_t len = render_result_len(pieces);
-        internal_render_to_string(child, context, child_svg_mode, select_value, self, pieces);
-        if (len < render_result_len(pieces)) { has_children = Qtrue; }
       }
     }
   } else if (children != Qnil && children != Qfalse && children != Qtrue) {
     VALUE child_svg_mode;
-    if (strcmp(RSTRING_PTR(node_type_s), str_svg) == 0) {
+    if (strcmp(RSTRING_PTR(node_type), str_svg) == 0)
       child_svg_mode = Qtrue;
-    } else if (strcmp(RSTRING_PTR(node_type_s), str_foreign_object) == 0 && is_svg_mode == Qtrue) {
+    else if (strcmp(RSTRING_PTR(node_type), str_foreign_object) == 0 &&
+             is_svg_mode == Qtrue)
       child_svg_mode = Qfalse;
-    } else {
+    else
       child_svg_mode = is_svg_mode;
-    }
-    size_t len = render_result_len(pieces);
-    internal_render_to_string(children, context, child_svg_mode, select_value, self, pieces);
-    if (len < render_result_len(pieces)) { has_children = Qtrue; }
+    long rres_len = RSTRING_LEN(rres);
+    internal_render_to_string(children, context, child_svg_mode, select_value,
+                              self, rres);
+    if (rres_len < RSTRING_LEN(rres))
+      has_children = Qtrue;
   }
 
-  if (has_children == Qtrue) {
-    render_result_concat(rres, pieces);
-  } else if (rb_funcall(rVoid, id_match, 1, node_type_s) == Qtrue) {
-    char *s = render_result2ptr(rres);
-    char l = s[render_result_len(rres) - 1];
+  if (has_children == Qfalse && rb_reg_match(rVoid, node_type) == Qtrue) {
+    char l = RSTRING_PTR(rres)[RSTRING_LEN(rres) - 1];
     if (l == '>') {
-      render_result_resize(rres, render_result_len(rres) - 1);
-      render_result_write(rres, " />", 3);
+      rb_str_set_len(rres, RSTRING_LEN(rres) - 1);
+      rb_str_cat(rres, " />", 3);
     }
     return;
   }
 
-  render_result_free(pieces);
-
-  render_result_write(rres, "</", 2);
-  render_result_write(rres, RSTRING_PTR(node_type_s), RSTRING_LEN(node_type_s));
-  render_result_write(rres, ">", 1);
+  rb_str_cat(rres, "</", 2);
+  rb_str_buf_append(rres, node_type);
+  rb_str_cat(rres, ">", 1);
 
   return;
 }
 
-VALUE render_to_string(int argc, VALUE *argv, VALUE self) {
-  VALUE vnode, context, is_svg_mode, select_value, res;
-  render_result_s *rres = render_result_new();
-  rb_scan_args(argc, argv, "22", &vnode, &context, &is_svg_mode, &select_value);
-  internal_render_to_string(vnode, context, is_svg_mode, select_value, self, rres);
-  res = rb_str_new(render_result2ptr(rres), render_result_len(rres));
-  render_result_free(rres);
+static VALUE render_to_string(int argc, VALUE *argv, VALUE self) {
+  if (argc != 2)
+    rb_raise(rb_eArgError,
+             "wrong argument count, required args: vnode, context");
+  VALUE vnode = argv[0];
+  VALUE context = argv[1];
+  if (context == Qnil)
+    context = rb_hash_new();
+  VALUE res = rb_enc_str_new("", 0, utf8_encoding);
+  internal_render_to_string(vnode, context, Qfalse, Qnil, self, res);
   return res;
 }
 
-VALUE create_element(int argc, VALUE *argv, VALUE self) {
-  VALUE type, props, children;
-  rb_scan_args(argc, argv, "12", &type, &props, &children);
-  VALUE normalized_props, key, ref;
+static VALUE is_renderable_q(VALUE self, VALUE block_result) {
+  switch (TYPE(block_result)) {
+  case T_BIGNUM:
+  case T_FIXNUM:
+  case T_FLOAT:
+  case T_STRING:
+    return Qtrue;
+  case T_ARRAY:
+    if (RARRAY_LEN(block_result) > 0)
+      return is_renderable_q(self, RARRAY_PTR(block_result)[0]);
+    return Qfalse;
+  case T_DATA:
+    if (RBASIC_CLASS(block_result) == cVNode)
+      return Qtrue;
+    return Qfalse;
+  default:
+    return Qfalse;
+  }
+  return Qfalse;
+}
+
+static VALUE create_element(int argc, VALUE *argv, VALUE self) {
+  if (argc < 1 || argc > 3)
+    rb_raise(rb_eArgError, "wrong argument count, required arg: type, optional "
+                           "args: props, children");
+  VALUE type = argv[0];
+  VALUE props = (argc > 1) ? argv[1] : Qnil;
+  VALUE children = (argc > 2) ? argv[2] : Qnil;
+  VALUE normalized_props, key = Qnil, ref = Qnil;
 
   if (props != Qnil) {
     if (TYPE(props) == T_HASH) {
       normalized_props = rb_hash_dup(props);
-      key = rb_hash_delete(normalized_props, sym_key);
-      ref = rb_hash_delete(normalized_props, sym_ref);
+      if (RHASH_SIZE(normalized_props) > 0) {
+        key = rb_hash_delete(normalized_props, sym_key);
+        ref = rb_hash_delete(normalized_props, sym_ref);
+      }
     } else {
       children = props;
       normalized_props = rb_hash_new();
-      key = Qnil;
-      ref = Qnil;
     }
   } else {
     normalized_props = rb_hash_new();
-    key = Qnil;
-    ref = Qnil;
   }
 
   if (rb_block_given_p()) {
     VALUE pr = rb_funcall(mPreact, id_render_buffer, 0);
-    pr = rb_ary_push(pr, rb_ary_new());
+    rb_ary_push(pr, rb_ary_new());
     VALUE block_result = rb_yield(Qnil);
     VALUE c = rb_ary_pop(pr);
-    if (rb_funcall(mPreact, id_is_renderable, 1, block_result) == Qtrue) {
+    if (is_renderable_q(mPreact, block_result) == Qtrue)
       rb_ary_push(c, block_result);
-    }
-    if (RARRAY_LEN(c) > 0) {
+    if (RARRAY_LEN(c) > 0)
       children = c;
-    }
   }
 
-  if (children != Qnil) {
+  if (children != Qnil)
     rb_hash_aset(normalized_props, sym_children, children);
-  }
 
-  return rb_funcall(cVNode, id_new, 4, type, normalized_props, key, ref);
+  const VALUE args[4] = {type, normalized_props, key, ref};
+  return rb_class_new_instance(4, (const VALUE *)&args, cVNode);
+}
+
+static VALUE render_element(int argc, VALUE *argv, VALUE self) {
+  VALUE pr = rb_funcall(self, id_render_buffer, 0);
+  rb_ary_push(RARRAY_PTR(pr)[RARRAY_LEN(pr) - 1], create_element(argc, argv, self));
+  return Qnil;
 }
 
 void Init_Preact(void) {
-  id_ancestors = rb_intern("ancestors");
+  utf8_encoding = rb_utf8_encoding();
   id_checked = rb_intern("checked");
   id_children = rb_intern("children");
   id_class = rb_intern("class");
@@ -463,21 +498,14 @@ void Init_Preact(void) {
   id_downcase = rb_intern("downcase");
   id_encode_entities = rb_intern("_encode_entities");
   id_eqeq = rb_intern("==");
+  id_for = rb_intern("for");
   id_get_child_context = rb_intern("get_child_context");
   id_get_derived_state_from_props = rb_intern("get_derived_state_from_props");
   id_gsub = rb_intern("gsub");
   id_html_for = rb_intern("html_for");
-  id_for = rb_intern("for");
-  id_freeze = rb_intern("freeze");
-  id_include = rb_intern("include?");
-  id_is_a = rb_intern("is_a?");
-  id_is_renderable = rb_intern("is_renderable?");
   id_key = rb_intern("key");
-  id_keyq = rb_intern("key?");
   id_keys = rb_intern("keys");
-  id_match = rb_intern("match?");
   id_merge = rb_intern("merge");
-  id_new = rb_intern("new");
   id_props = rb_intern("props");
   id_ref = rb_intern("ref");
   id_render = rb_intern("render");
@@ -485,10 +513,9 @@ void Init_Preact(void) {
   id_selected = rb_intern("selected");
   id_self = rb_intern("__self");
   id_source = rb_intern("__source");
-  id_start_withq = rb_intern("start_with?");
-  id_state = rb_intern("state");
   id_style = rb_intern("style");
   id_style_obj_to_css = rb_intern("_style_obj_to_css");
+  id_to_s = rb_intern("to_s");
   id_validate_props = rb_intern("validate_props");
   id_value = rb_intern("value");
 
@@ -508,30 +535,25 @@ void Init_Preact(void) {
   sym_selected = ID2SYM(rb_intern("selected"));
   sym_value = ID2SYM(id_value);
 
-  cProc = rb_const_get(rb_cObject, rb_intern("Proc"));
-  cRegexp = rb_const_get(rb_cObject, rb_intern("Regexp"));
   mIsomorfeus = rb_const_get(rb_cObject, rb_intern("Isomorfeus"));
   mPreact = rb_define_module("Preact");
   cFragment = rb_define_class("Fragment", rb_cObject);
 
   // set instance variables on the module to keep references to these objects
-  // to prevent garbage colloction
-  rUnsafe = rb_funcall(cRegexp, id_new, 1, rb_str_new_cstr(str_run));
+  // to prevent garbage collection
+  rUnsafe = rb_reg_regcomp(rb_str_new_cstr(str_run));
   rb_obj_freeze(rUnsafe);
   rb_ivar_set(mPreact, rb_intern("@_r_unsafe"), rUnsafe);
-  rVoid = rb_funcall(cRegexp, id_new, 1, rb_str_new_cstr(str_rve));
+  rVoid = rb_reg_regcomp(rb_str_new_cstr(str_rve));
   rb_obj_freeze(rVoid);
   rb_ivar_set(mPreact, rb_intern("@_r_void"), rVoid);
-  rXlink = rb_funcall(cRegexp, id_new, 1, rb_str_new_cstr(str_rxl));
+  rXlink = rb_reg_regcomp(rb_str_new_cstr(str_rxl));
   rb_obj_freeze(rXlink);
   rb_ivar_set(mPreact, rb_intern("@_r_xlink"), rXlink);
-  rXlink2 = rb_funcall(cRegexp, id_new, 1, rb_str_new_cstr(str_rx2));
+  rXlink2 = rb_reg_regcomp(rb_str_new_cstr(str_rx2));
   rb_obj_freeze(rXlink2);
   rb_ivar_set(mPreact, rb_intern("@_r_xlink2"), rXlink2);
 
-  s_aria = rb_str_new_cstr("aria");
-  rb_obj_freeze(s_aria);
-  rb_ivar_set(mPreact, rb_intern("@_s_aria"), s_aria);
   s_false = rb_str_new_cstr("false");
   rb_obj_freeze(s_false);
   rb_ivar_set(mPreact, rb_intern("@_s_false"), s_false);
@@ -542,6 +564,8 @@ void Init_Preact(void) {
   rb_obj_freeze(s_xlink);
   rb_ivar_set(mPreact, rb_intern("@_s_xlink"), s_xlink);
 
+  rb_define_module_function(mPreact, "_render_element", render_element, -1);
   rb_define_module_function(mPreact, "_render_to_string", render_to_string, -1);
   rb_define_module_function(mPreact, "create_element", create_element, -1);
+  rb_define_module_function(mPreact, "is_renderable?", is_renderable_q, 1);
 }