iodine 0.6.5 → 0.7.0

data/ext/iodine/iodine_defer.h

@@ -2,6 +2,5 @@
 #define H_IODINE_DEFER_H
 
 void iodine_defer_initialize(void);
-void iodine_defer_on_finish(void);
 
 #endif

data/ext/iodine/iodine_fiobj2rb.h

@@ -18,7 +18,9 @@ typedef struct {
   uint8_t str2sym;
 } fiobj2rb_s;
 
-typedef struct { uint8_t str2sym; } fiobj2rb_settings_s;
+typedef struct {
+  uint8_t str2sym;
+} fiobj2rb_settings_s;
 
 static inline VALUE fiobj2rb(FIOBJ o, uint8_t str2sym) {
   VALUE rb;
@@ -40,7 +42,7 @@ static inline VALUE fiobj2rb(FIOBJ o, uint8_t str2sym) {
   case FIOBJ_T_DATA:    /* fallthrough */
   case FIOBJ_T_UNKNOWN: /* fallthrough */
   case FIOBJ_T_STRING: {
-    fio_cstr_s tmp = fiobj_obj2cstr(o);
+    fio_str_info_s tmp = fiobj_obj2cstr(o);
     if (str2sym) {
       rb = rb_intern2(tmp.data, tmp.len);
       rb = ID2SYM(rb);

data/ext/iodine/iodine_helpers.c

@@ -144,9 +144,9 @@ static VALUE date_str(int argc, VALUE *argv, VALUE self) {
       argv[0] = rb_funcallv(argv[0], iodine_to_i_func_id, 0, NULL);
     Check_Type(argv[0], T_FIXNUM);
     last_tick =
-        FIX2ULONG(argv[0]) ? FIX2ULONG(argv[0]) : facil_last_tick().tv_sec;
+        FIX2ULONG(argv[0]) ? FIX2ULONG(argv[0]) : fio_last_tick().tv_sec;
   } else
-    last_tick = facil_last_tick().tv_sec;
+    last_tick = fio_last_tick().tv_sec;
   VALUE str = rb_str_buf_new(32);
   struct tm tm;
 
@@ -172,7 +172,7 @@ Since Iodine uses time caching within it's reactor, using the default value
 static VALUE iodine_rfc2822(VALUE self, VALUE rtm) {
   time_t last_tick;
   rtm = rb_funcallv(rtm, iodine_to_i_func_id, 0, NULL);
-  last_tick = FIX2ULONG(rtm) ? FIX2ULONG(rtm) : facil_last_tick().tv_sec;
+  last_tick = FIX2ULONG(rtm) ? FIX2ULONG(rtm) : fio_last_tick().tv_sec;
   VALUE str = rb_str_buf_new(34);
   struct tm tm;
 
@@ -198,7 +198,7 @@ Since Iodine uses time caching within it's reactor, using the default value
 static VALUE iodine_rfc2109(VALUE self, VALUE rtm) {
   time_t last_tick;
   rtm = rb_funcallv(rtm, iodine_to_i_func_id, 0, NULL);
-  last_tick = FIX2ULONG(rtm) ? FIX2ULONG(rtm) : facil_last_tick().tv_sec;
+  last_tick = FIX2ULONG(rtm) ? FIX2ULONG(rtm) : fio_last_tick().tv_sec;
   VALUE str = rb_str_buf_new(32);
   struct tm tm;
 

data/ext/iodine/iodine_http.c

@@ -6,9 +6,8 @@ Feel free to copy, use and enjoy according to the license provided.
 */
 #include "iodine.h"
 
-#include "evio.h"
-#include "fio_mem.h"
 #include "http.h"
+
 #include <ruby/encoding.h>
 #include <ruby/io.h>
 // #include "iodine_websockets.h"
@@ -131,13 +130,13 @@ static void *iodine_ws_fire_message(void *msg_) {
   return NULL;
 }
 
-static void iodine_ws_on_message(ws_s *ws, char *data, size_t size,
+static void iodine_ws_on_message(ws_s *ws, fio_str_info_s data,
                                  uint8_t is_text) {
   iodine_msg2ruby_s msg = {
-      .data = data,
-      .size = size,
+      .data = data.data,
+      .size = data.len,
       .is_text = is_text,
-      .io = (VALUE)websocket_udata(ws),
+      .io = (VALUE)websocket_udata_get(ws),
   };
   IodineCaller.enterGVL(iodine_ws_fire_message, &msg);
 }
@@ -147,7 +146,7 @@ static void iodine_ws_on_message(ws_s *ws, char *data, size_t size,
  * `on_message` events are raised before `on_open` returns.
  */
 static void iodine_ws_on_open(ws_s *ws) {
-  VALUE h = (VALUE)websocket_udata(ws);
+  VALUE h = (VALUE)websocket_udata_get(ws);
   iodine_connection_s *c = iodine_connection_CData(h);
   c->arg = ws;
   c->uuid = websocket_uuid(ws);
@@ -160,7 +159,7 @@ static void iodine_ws_on_open(ws_s *ws) {
  * If the socket's buffer is never used, the callback is never called.
  */
 static void iodine_ws_on_ready(ws_s *ws) {
-  iodine_connection_fire_event((VALUE)websocket_udata(ws),
+  iodine_connection_fire_event((VALUE)websocket_udata_get(ws),
                                IODINE_CONNECTION_ON_DRAINED, Qnil);
 }
 /**
@@ -169,7 +168,7 @@ static void iodine_ws_on_ready(ws_s *ws) {
  * `on_close`).
  */
 static void iodine_ws_on_shutdown(ws_s *ws) {
-  iodine_connection_fire_event((VALUE)websocket_udata(ws),
+  iodine_connection_fire_event((VALUE)websocket_udata_get(ws),
                                IODINE_CONNECTION_ON_SHUTDOWN, Qnil);
 }
 /**
@@ -195,7 +194,7 @@ static void iodine_ws_attach(http_s *h, VALUE handler, VALUE env) {
   if (io == Qnil)
     return;
 
-  http_upgrade2ws(.http = h, .on_message = iodine_ws_on_message,
+  http_upgrade2ws(h, .on_message = iodine_ws_on_message,
                   .on_open = iodine_ws_on_open, .on_ready = iodine_ws_on_ready,
                   .on_shutdown = iodine_ws_on_shutdown,
                   .on_close = iodine_ws_on_close, .udata = (void *)io);
@@ -226,7 +225,7 @@ static void iodine_sse_on_open(http_sse_s *sse) {
   c->uuid = http_sse2uuid(sse);
   iodine_connection_fire_event(h, IODINE_CONNECTION_ON_OPEN, Qnil);
   sse->on_ready = iodine_sse_on_ready;
-  evio_add_write(sock_uuid2fd(c->uuid), (void *)c->uuid);
+  fio_force_event(c->uuid, FIO_EVENT_ON_READY);
 }
 
 static void iodine_sse_attach(http_s *h, VALUE handler, VALUE env) {
@@ -250,7 +249,7 @@ Copying data from the C request to the Rack's ENV
 int iodine_copy2env_task(FIOBJ o, void *env_) {
   VALUE env = (VALUE)env_;
   FIOBJ name = fiobj_hash_key_in_loop();
-  fio_cstr_s tmp = fiobj_obj2cstr(name);
+  fio_str_info_s tmp = fiobj_obj2cstr(name);
   VALUE hname = (VALUE)0;
   if (tmp.len > 59) {
     char *buf = fio_malloc(tmp.len + 5);
@@ -303,7 +302,7 @@ static inline VALUE copy2env(iodine_http_request_handle_s *handle) {
   }
   IodineStore.add(env);
 
-  fio_cstr_s tmp;
+  fio_str_info_s tmp;
   char *pos = NULL;
   /* Copy basic data */
   tmp = fiobj_obj2cstr(h->method);
@@ -330,17 +329,9 @@ static inline VALUE copy2env(iodine_http_request_handle_s *handle) {
   }
 
   { // Support for Ruby web-console.
-    char buf[64];
-    buf[63] = 0;
-    sock_peer_addr_s addrinfo = http_peer_addr(h);
-    if (addrinfo.addrlen &&
-        inet_ntop(
-            addrinfo.addr->sa_family,
-            addrinfo.addr->sa_family == AF_INET
-                ? (void *)&((struct sockaddr_in *)addrinfo.addr)->sin_addr
-                : (void *)&((struct sockaddr_in6 *)addrinfo.addr)->sin6_addr,
-            buf, 64)) {
-      rb_hash_aset(env, REMOTE_ADDR, rb_str_new(buf, strlen(buf)));
+    fio_str_info_s peer = http_peer_addr(h);
+    if (peer.len) {
+      rb_hash_aset(env, REMOTE_ADDR, rb_str_new(peer.data, peer.len));
     }
   }
 
@@ -477,7 +468,7 @@ static int for_each_header_data(VALUE key, VALUE val, VALUE h_) {
   // make the headers lowercase
   FIOBJ name = fiobj_str_new(key_s, key_len);
   {
-    fio_cstr_s tmp = fiobj_obj2cstr(name);
+    fio_str_info_s tmp = fiobj_obj2cstr(name);
     for (int i = 0; i < key_len; ++i) {
       tmp.data[i] = tolower(tmp.data[i]);
     }
@@ -719,7 +710,7 @@ static inline void
 iodine_perform_handle_action(iodine_http_request_handle_s handle) {
   switch (handle.type) {
   case IODINE_HTTP_SENDBODY: {
-    fio_cstr_s data = fiobj_obj2cstr(handle.body);
+    fio_str_info_s data = fiobj_obj2cstr(handle.body);
     http_send_body(handle.h, data.data, data.len);
     fiobj_free(handle.body);
     break;
@@ -732,7 +723,7 @@ iodine_perform_handle_action(iodine_http_request_handle_s handle) {
             .len == 7)
       fiobj_hash_delete2(handle.h->private_data.out_headers,
                          fiobj_obj2hash(HTTP_HEADER_CONTENT_ENCODING));
-    fio_cstr_s data = fiobj_obj2cstr(handle.body);
+    fio_str_info_s data = fiobj_obj2cstr(handle.body);
     if (http_sendfile2(handle.h, data.data, data.len, NULL, 0)) {
       http_send_error(handle.h, 404);
     }
@@ -754,7 +745,8 @@ iodine_perform_handle_action(iodine_http_request_handle_s handle) {
 }
 static void on_rack_request(http_s *h) {
   iodine_http_request_handle_s handle = (iodine_http_request_handle_s){
-      .h = h, .upgrade = IODINE_UPGRADE_NONE,
+      .h = h,
+      .upgrade = IODINE_UPGRADE_NONE,
   };
   IodineCaller.enterGVL((void *(*)(void *))iodine_handle_request_in_GVL,
                         &handle);
@@ -794,13 +786,14 @@ void *iodine_print_http_msg_in_gvl(void *d_) {
     fprintf(stderr,
             "Iodine HTTP Server on port %s:\n"
             " *    Serving static files from %s\n\n",
-            StringValueCStr(arg->port), StringValueCStr(arg->www));
+            (arg->port ? StringValueCStr(arg->port) : "----"),
+            StringValueCStr(arg->www));
   }
   return NULL;
 }
 
 static void iodine_print_http_msg(void *www, void *port) {
-  if (getpid() != facil_parent_pid())
+  if (!fio_is_master())
     goto finish;
   struct {
     void *www;
@@ -989,7 +982,7 @@ VALUE iodine_http_listen(VALUE self, VALUE opt) {
           .ws_timeout = ping, .ws_max_msg_size = max_msg,
           .max_header_size = max_headers, .on_finish = free_iodine_http,
           .log = log_http, .max_body_size = max_body,
-          .public_folder = (www ? StringValueCStr(www) : NULL))) {
+          .public_folder = (www ? StringValueCStr(www) : NULL)) == -1) {
     fprintf(stderr,
             "ERROR: Failed to initialize a listening HTTP socket for port %s\n",
             port ? StringValueCStr(port) : "3000");
@@ -1002,7 +995,7 @@ VALUE iodine_http_listen(VALUE self, VALUE opt) {
             "static files.\n",
             (port ? StringValueCStr(port) : "3000"));
   }
-  defer(iodine_print_http_msg, (www ? (void *)www : NULL), (void *)port);
+  fio_defer(iodine_print_http_msg, (www ? (void *)www : NULL), (void *)port);
 
   return Qtrue;
   (void)self;

data/ext/iodine/iodine_json.c

@@ -1,8 +1,9 @@
 #include "iodine.h"
 
+#include "fio.h"
+
 #include "fio_ary.h"
 #include "fio_json_parser.h"
-#include "fio_mem.h"
 #include "fiobj.h"
 #include "iodine_fiobj2rb.h"
 #include "iodine_store.h"

data/ext/iodine/iodine_mustache.c

@@ -0,0 +1,423 @@
+
+#define INCLUDE_MUSTACHE_IMPLEMENTATION 1
+#include "mustache_parser.h"
+
+#include "iodine.h"
+
+#define FIO_INCLUDE_STR
+#include <fio.h>
+
+ID call_func_id;
+ID to_s_func_id;
+/* *****************************************************************************
+C <=> Ruby Data allocation
+***************************************************************************** */
+
+static size_t iodine_mustache_data_size(const void *c_) {
+  return sizeof(mustache_s *);
+  (void)c_;
+}
+
+static size_t iodine_mustache_data_free(const void *c_) {
+  mustache_free(((mustache_s **)c_)[0]);
+  free((void *)c_);
+  return sizeof(mustache_s *);
+  (void)c_;
+}
+
+const rb_data_type_t iodine_mustache_data_type = {
+    .wrap_struct_name = "IodineMustacheData",
+    .function =
+        {
+            .dmark = NULL,
+            .dfree = free,
+            .dsize = iodine_mustache_data_size,
+        },
+    .data = NULL,
+    // .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+/* Iodine::PubSub::Engine.allocate */
+static VALUE iodine_mustache_data_alloc_c(VALUE self) {
+  void *m = malloc(sizeof(mustache_s *));
+  ((mustache_s **)m)[0] = NULL;
+  return TypedData_Wrap_Struct(self, &iodine_mustache_data_type, m);
+}
+
+static inline mustache_s *iodine_mustache_ruby2C(VALUE self) {
+  mustache_s **m = NULL;
+  TypedData_Get_Struct(self, mustache_s *, &iodine_mustache_data_type, m);
+  if (!m)
+    return NULL;
+  return m[0];
+}
+
+/* *****************************************************************************
+Parser Callbacks
+***************************************************************************** */
+
+/** HTML ecape table, created using the following Ruby Script:
+a = []
+256.times {|i| a[i] = "&\#x#{ i < 16 ? "0#{i.to_s(16)}" : i.to_s(16)};"}
+('a'.ord..'z'.ord).each {|i| a[i] = i.chr }
+('A'.ord..'Z'.ord).each {|i| a[i] = i.chr }
+('0'.ord..'9'.ord).each {|i| a[i] = i.chr }
+a['<'.ord] = "&lt;"
+a['>'.ord] = "&gt;"
+a['&'.ord] = "&amp;"
+a['"'.ord] = "&quot;"
+
+b = a.map {|s| s.length }
+puts "static char *html_escape_strs[] = {", a.to_s.slice(1..-2) ,"};",
+     "static uint8_t html_escape_len[] = {", b.to_s.slice(1..-2),"};"
+*/
+static char *html_escape_strs[] = {
+    "&#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;", "&#x1a;", "&#x1b;",
+    "&#x1c;", "&#x1d;", "&#x1e;", "&#x1f;", "&#x20;", "&#x21;", "&quot;",
+    "&#x23;", "&#x24;", "&#x25;", "&amp;",  "&#x27;", "&#x28;", "&#x29;",
+    "&#x2a;", "&#x2b;", "&#x2c;", "&#x2d;", "&#x2e;", "&#x2f;", "0",
+    "1",      "2",      "3",      "4",      "5",      "6",      "7",
+    "8",      "9",      "&#x3a;", "&#x3b;", "&lt;",   "&#x3d;", "&gt;",
+    "&#x3f;", "&#x40;", "A",      "B",      "C",      "D",      "E",
+    "F",      "G",      "H",      "I",      "J",      "K",      "L",
+    "M",      "N",      "O",      "P",      "Q",      "R",      "S",
+    "T",      "U",      "V",      "W",      "X",      "Y",      "Z",
+    "&#x5b;", "&#x5c;", "&#x5d;", "&#x5e;", "&#x5f;", "&#x60;", "a",
+    "b",      "c",      "d",      "e",      "f",      "g",      "h",
+    "i",      "j",      "k",      "l",      "m",      "n",      "o",
+    "p",      "q",      "r",      "s",      "t",      "u",      "v",
+    "w",      "x",      "y",      "z",      "&#x7b;", "&#x7c;", "&#x7d;",
+    "&#x7e;", "&#x7f;", "&#x80;", "&#x81;", "&#x82;", "&#x83;", "&#x84;",
+    "&#x85;", "&#x86;", "&#x87;", "&#x88;", "&#x89;", "&#x8a;", "&#x8b;",
+    "&#x8c;", "&#x8d;", "&#x8e;", "&#x8f;", "&#x90;", "&#x91;", "&#x92;",
+    "&#x93;", "&#x94;", "&#x95;", "&#x96;", "&#x97;", "&#x98;", "&#x99;",
+    "&#x9a;", "&#x9b;", "&#x9c;", "&#x9d;", "&#x9e;", "&#x9f;", "&#xa0;",
+    "&#xa1;", "&#xa2;", "&#xa3;", "&#xa4;", "&#xa5;", "&#xa6;", "&#xa7;",
+    "&#xa8;", "&#xa9;", "&#xaa;", "&#xab;", "&#xac;", "&#xad;", "&#xae;",
+    "&#xaf;", "&#xb0;", "&#xb1;", "&#xb2;", "&#xb3;", "&#xb4;", "&#xb5;",
+    "&#xb6;", "&#xb7;", "&#xb8;", "&#xb9;", "&#xba;", "&#xbb;", "&#xbc;",
+    "&#xbd;", "&#xbe;", "&#xbf;", "&#xc0;", "&#xc1;", "&#xc2;", "&#xc3;",
+    "&#xc4;", "&#xc5;", "&#xc6;", "&#xc7;", "&#xc8;", "&#xc9;", "&#xca;",
+    "&#xcb;", "&#xcc;", "&#xcd;", "&#xce;", "&#xcf;", "&#xd0;", "&#xd1;",
+    "&#xd2;", "&#xd3;", "&#xd4;", "&#xd5;", "&#xd6;", "&#xd7;", "&#xd8;",
+    "&#xd9;", "&#xda;", "&#xdb;", "&#xdc;", "&#xdd;", "&#xde;", "&#xdf;",
+    "&#xe0;", "&#xe1;", "&#xe2;", "&#xe3;", "&#xe4;", "&#xe5;", "&#xe6;",
+    "&#xe7;", "&#xe8;", "&#xe9;", "&#xea;", "&#xeb;", "&#xec;", "&#xed;",
+    "&#xee;", "&#xef;", "&#xf0;", "&#xf1;", "&#xf2;", "&#xf3;", "&#xf4;",
+    "&#xf5;", "&#xf6;", "&#xf7;", "&#xf8;", "&#xf9;", "&#xfa;", "&#xfb;",
+    "&#xfc;", "&#xfd;", "&#xfe;", "&#xff;"};
+static uint8_t html_escape_len[] = {
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 6, 4, 6, 4, 6, 6, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 6, 6, 6, 6,
+    6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6};
+
+static inline VALUE fiobj_mustache_find_obj(mustache_section_s *section,
+                                            const char *name,
+                                            uint32_t name_len) {
+  do {
+    VALUE tmp;
+#if 0
+    /* test for Array indexing */
+    if (name[0] >= '0' && name[0] <= '9' &&
+        RB_TYPE_P((VALUE)section->udata2, T_ARRAY)) {
+      char **pos = (char **)&name;
+      tmp = rb_ary_entry((VALUE)section->udata2, fio_atol(pos));
+      if (tmp)
+        return tmp;
+    }
+#endif
+    if (!RB_TYPE_P((VALUE)section->udata2, T_HASH)) {
+      continue;
+    }
+    /* search by String */
+    VALUE key = rb_str_new(name, name_len);
+    tmp = rb_hash_aref((VALUE)section->udata2, key);
+    if (tmp != Qnil)
+      return tmp;
+    /* search by Symbol */
+    key = rb_id2sym(rb_intern2(name, name_len));
+    tmp = rb_hash_aref((VALUE)section->udata2, key);
+    if (tmp != Qnil)
+      return tmp;
+    section = section->parent;
+  } while (section);
+  return Qnil;
+}
+/**
+ * Called when an argument name was detected in the current section.
+ *
+ * A conforming implementation will search for the named argument both in the
+ * existing section and all of it's parents (walking backwards towards the root)
+ * until a value is detected.
+ *
+ * A missing value should be treated the same as an empty string.
+ *
+ * A conforming implementation will output the named argument's value (either
+ * HTML escaped or not, depending on the `escape` flag) as a string.
+ */
+static int mustache_on_arg(mustache_section_s *section, const char *name,
+                           uint32_t name_len, unsigned char escape) {
+  VALUE o = fiobj_mustache_find_obj(section, name, name_len);
+  if (!o)
+    return 0;
+  if (rb_respond_to(o, call_func_id))
+    goto callable;
+  if (!RB_TYPE_P(o, T_STRING))
+    o = IodineCaller.call(o, to_s_func_id);
+  if (!RB_TYPE_P(o, T_STRING) || !RSTRUCT_LEN(o))
+    return 0;
+  if (!escape) {
+    fio_str_write(section->udata1, RSTRING_PTR(o), RSTRING_LEN(o));
+    return 0;
+  }
+  /* HTML escape */
+  fio_str_info_s str = {.data = RSTRING_PTR(o), .len = RSTRING_LEN(o)};
+  fio_str_info_s i = fio_str_capa_assert(
+      section->udata1, fio_str_len(section->udata1) + str.len + 64);
+  do {
+    if (i.len + 6 >= i.capa)
+      i = fio_str_capa_assert(section->udata1, i.capa + 64);
+    i = fio_str_write(section->udata1, html_escape_strs[(uint8_t)str.data[0]],
+                      html_escape_len[(uint8_t)str.data[0]]);
+    --str.len;
+    ++str.data;
+  } while (str.len);
+  (void)section;
+  (void)name;
+  (void)name_len;
+  (void)escape;
+  return 0;
+callable:
+  o = rb_funcall2(o, call_func_id, 0, NULL);
+  o = rb_any_to_s(o);
+  fio_str_write(section->udata1, RSTRING_PTR(o), RSTRUCT_LEN(o));
+  return 0;
+}
+
+/**
+ * Called when simple template text (string) is detected.
+ *
+ * A conforming implementation will output data as a string (no escaping).
+ */
+static int mustache_on_text(mustache_section_s *section, const char *data,
+                            uint32_t data_len) {
+  fio_str_write(section->udata1, data, data_len);
+  return 0;
+}
+
+/**
+ * Called for nested sections, must return the number of objects in the new
+ * subsection (depending on the argument's name).
+ *
+ * Arrays should return the number of objects in the array.
+ *
+ * `true` values should return 1.
+ *
+ * `false` values should return 0.
+ *
+ * A return value of -1 will stop processing with an error.
+ *
+ * Please note, this will handle both normal and inverted sections.
+ */
+static int32_t mustache_on_section_test(mustache_section_s *section,
+                                        const char *name, uint32_t name_len) {
+  VALUE o = fiobj_mustache_find_obj(section, name, name_len);
+  if (o == Qnil) {
+    return 0;
+  }
+  if (RB_TYPE_P(o, T_ARRAY)) {
+    return rb_array_len(o);
+  }
+  return 1;
+}
+
+/**
+ * Called when entering a nested section.
+ *
+ * `index` is a zero based index indicating the number of repetitions that
+ * occurred so far (same as the array index for arrays).
+ *
+ * A return value of -1 will stop processing with an error.
+ *
+ * Note: this is a good time to update the subsection's `udata` with the value
+ * of the array index. The `udata` will always contain the value or the parent's
+ * `udata`.
+ */
+static int mustache_on_section_start(mustache_section_s *section,
+                                     char const *name, uint32_t name_len,
+                                     uint32_t index) {
+  VALUE o = fiobj_mustache_find_obj(section, name, name_len);
+  if (o == Qnil)
+    return 0;
+  if (RB_TYPE_P(o, T_ARRAY))
+    section->udata2 = (void *)rb_ary_entry(o, index);
+  else
+    section->udata2 = (void *)o;
+  return 0;
+}
+
+/**
+ * Called for cleanup in case of error.
+ */
+static void mustache_on_formatting_error(void *udata1, void *udata2) {
+  (void)udata1;
+  (void)udata2;
+}
+
+/* *****************************************************************************
+Loading the template
+***************************************************************************** */
+
+/**
+Loads a mustache template (and any partials).
+
+Once a template was loaded, it could be rendered using {render}.
+*/
+static VALUE iodine_mustache_new(VALUE self, VALUE filename) {
+  mustache_s **m = NULL;
+  TypedData_Get_Struct(self, mustache_s *, &iodine_mustache_data_type, m);
+  if (!m) {
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache allocation error.");
+  }
+  Check_Type(filename, T_STRING);
+  mustache_error_en err;
+  *m = mustache_load(.filename = RSTRING_PTR(filename),
+                     .filename_len = RSTRING_LEN(filename), .err = &err);
+  if (!*m)
+    goto error;
+  return self;
+error:
+  switch (err) {
+  case MUSTACHE_OK:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache template ok, unknown error.");
+    break;
+  case MUSTACHE_ERR_TOO_DEEP:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache element nesting too deep.");
+    break;
+  case MUSTACHE_ERR_CLOSURE_MISMATCH:
+    rb_raise(rb_eRuntimeError,
+             "Iodine::Mustache template error, closure mismatch.");
+    break;
+  case MUSTACHE_ERR_FILE_NOT_FOUND:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache template not found.");
+    break;
+  case MUSTACHE_ERR_FILE_TOO_BIG:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache template too big.");
+    break;
+  case MUSTACHE_ERR_FILE_NAME_TOO_LONG:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache template name too long.");
+    break;
+  case MUSTACHE_ERR_EMPTY_TEMPLATE:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache template is empty.");
+    break;
+  case MUSTACHE_ERR_UNKNOWN:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache unknown error.");
+    break;
+  case MUSTACHE_ERR_USER_ERROR:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache internal error.");
+    break;
+  }
+  return self;
+}
+
+/* *****************************************************************************
+Rendering
+***************************************************************************** */
+
+/**
+Renders the mustache template using the data provided in the `data` argument.
+
+Returns a String.
+
+Raises an exception on error.
+
+NOTE:
+
+As one might notice, no binding is provided. Instead, a `data` Hash is assumed.
+Iodine will search the Hash for any data while protecting against code
+execution.
+*/
+static VALUE iodine_mustache_render(VALUE self, VALUE data) {
+  fio_str_s str = FIO_STR_INIT;
+  mustache_s **m = NULL;
+  TypedData_Get_Struct(self, mustache_s *, &iodine_mustache_data_type, m);
+  if (!m) {
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache allocation error.");
+  }
+  if (mustache_build(*m, .udata1 = &str, .udata2 = (void *)data))
+    goto error;
+  fio_str_info_s i = fio_str_info(&str);
+  VALUE ret = rb_str_new(i.data, i.len);
+  fio_str_free(&str);
+  return ret;
+
+error:
+  fio_str_free(&str);
+  rb_raise(rb_eRuntimeError, "Couldn't build template frome data.");
+}
+
+/* *****************************************************************************
+Initialize Iodine::Mustache
+***************************************************************************** */
+
+void iodine_init_mustache(void) {
+  call_func_id = rb_intern2("call", 4);
+  to_s_func_id = rb_intern2("to_s", 4);
+  /**
+  Iodine::Mustache offers a logicless mustache template engine with strict HTML
+  escaping (more than the basic `"<>'$`).
+
+  This offers more security against XSS and protects against the chance of
+  executing Ruby code within the template.
+
+  You can test the parser using:
+
+      TEMPLATE="my_template.mustache"
+
+      require 'json'
+      require 'iodine'
+      TIMES = 100
+      STR = IO.binread(JSON_FILENAME); nil
+
+      JSON.parse(STR) == Iodine::JSON.parse(STR) # => true
+      JSON.parse(STR,
+          symbolize_names: true) == Iodine::JSON.parse(STR,
+           symbolize_names: true) # => true
+      JSON.parse!(STR) == Iodine::JSON.parse!(STR) # => true/false (unknown)
+
+      # warm-up
+      TIMES.times { JSON.parse STR }
+      TIMES.times { Iodine::JSON.parse STR }
+
+      Benchmark.bm do |b|
+        sys = b.report("system") { TIMES.times { JSON.parse STR } }
+        sys_sym = b.report("system sym") { TIMES.times { JSON.parse STR,
+                                                 symbolize_names: true } }
+        iodine = b.report("iodine") { TIMES.times { Iodine::JSON.parse STR } }
+        iodine_sym = b.report("iodine sym") do
+                           TIMES.times { Iodine::JSON.parse STR,
+                                                  symbolize_names: true }
+                      end
+        puts "System    /    Iodine: #{sys/iodine}"
+        puts "System-sym/Iodine-sym: #{sys_sym/iodine_sym}"
+      end; nil
+
+
+  */
+  VALUE tmp = rb_define_class_under(IodineModule, "Mustache", rb_cData);
+  rb_define_alloc_func(tmp, iodine_mustache_data_alloc_c);
+  rb_define_method(tmp, "initialize", iodine_mustache_new, 1);
+  rb_define_method(tmp, "render", iodine_mustache_render, 1);
+  // rb_define_module_function(tmp, "parse", iodine_json_parse, -1);
+}