iodine 0.6.5 → 0.7.0

data/ext/iodine/fiobj_data.h

@@ -16,17 +16,17 @@ License: MIT
  */
 #define H_FIOBJ_IO_H
 
-#include "fiobject.h"
+#include <fiobject.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* *****************************************************************************
-Creating the IO object
+Creating the Data Stream object
 ***************************************************************************** */
 
-/** Creates a new local in-memory IO object */
+/** Creates a new local in-memory Data Stream object */
 FIOBJ fiobj_data_newstr(void);
 
 /**
@@ -37,20 +37,20 @@ FIOBJ fiobj_data_newstr(void);
 FIOBJ fiobj_data_newstr2(void *buffer, uintptr_t length,
                          void (*dealloc)(void *));
 
-/** Creates a new local tempfile IO object */
+/** Creates a new local tempfile Data Stream object */
 FIOBJ fiobj_data_newtmpfile(void);
 
-/** Creates a new local file IO object */
+/** Creates a new local file Data Stream object */
 FIOBJ fiobj_data_newfd(int fd);
 
 /** Creates a slice from an existing Data object. */
 FIOBJ fiobj_data_slice(FIOBJ parent, intptr_t offset, uintptr_t length);
 
 /* *****************************************************************************
-Saving the IO object
+Saving the Data Stream object
 ***************************************************************************** */
 
-/** Creates a new local file IO object */
+/** Creates a new local file Data Stream object */
 int fiobj_data_save(FIOBJ io, const char *filename);
 
 /* *****************************************************************************
@@ -65,9 +65,9 @@ Reading API
  * input backwards (0 == EOF).
  *
  * The C string object will be invalidate the next time a function call to the
- * IO object is made.
+ * Data Stream object is made.
  */
-fio_cstr_s fiobj_data_read(FIOBJ io, intptr_t length);
+fio_str_info_s fiobj_data_read(FIOBJ io, intptr_t length);
 
 /**
  * Reads until the `token` byte is encountered or until the end of the stream.
@@ -78,9 +78,9 @@ fio_cstr_s fiobj_data_read(FIOBJ io, intptr_t length);
  * stream might be loaded into the memory.
  *
  * The C string object will be invalidate the next time a function call to the
- * IO object is made.
+ * Data Stream object is made.
  */
-fio_cstr_s fiobj_data_read2ch(FIOBJ io, uint8_t token);
+fio_str_info_s fiobj_data_read2ch(FIOBJ io, uint8_t token);
 
 /**
  * Reads a line (until the '\n' byte is encountered) or until the end of the
@@ -93,7 +93,7 @@ fio_cstr_s fiobj_data_read2ch(FIOBJ io, uint8_t token);
  * might be loaded into the memory.
  *
  * The C string object will be invalidate the next time a function call to the
- * IO object is made.
+ * Data Stream object is made.
  */
 #define fiobj_data_gets(io) fiobj_data_read2ch((io), '\n');
 
@@ -118,38 +118,40 @@ void fiobj_data_seek(FIOBJ io, intptr_t position);
  * position is ignored and unchanged.
  *
  * The C string object will be invalidate the next time a function call to the
- * IO object is made.
+ * Data Stream object is made.
  */
-fio_cstr_s fiobj_data_pread(FIOBJ io, intptr_t start_at, uintptr_t length);
+fio_str_info_s fiobj_data_pread(FIOBJ io, intptr_t start_at, uintptr_t length);
 
 /* *****************************************************************************
 Writing API
 ***************************************************************************** */
 
 /**
- * Writes `length` bytes at the end of the IO stream, ignoring the reading
- * position.
+ * Writes `length` bytes at the end of the Data Stream stream, ignoring the
+ * reading position.
  *
  * Behaves and returns the same value as the system call `write`.
  */
 intptr_t fiobj_data_write(FIOBJ io, void *buffer, uintptr_t length);
 
 /**
- * Writes `length` bytes at the end of the IO stream, ignoring the reading
- * position, adding an EOL marker ("\r\n") to the end of the stream.
+ * Writes `length` bytes at the end of the Data Stream stream, ignoring the
+ * reading position, adding an EOL marker ("\r\n") to the end of the stream.
  *
  * Behaves and returns the same value as the system call `write`.
  */
 intptr_t fiobj_data_puts(FIOBJ io, void *buffer, uintptr_t length);
 
 /**
- * Makes sure the IO object isn't attached to a static or external string.
+ * Makes sure the Data Stream object isn't attached to a static or external
+ * string.
  *
- * If the IO object is attached to a static or external string, the data will be
- * copied to a new memory block.
+ * If the Data Stream object is attached to a static or external string, the
+ * data will be copied to a new memory block.
  *
- * If the IO object is a slice from another IO object, the data will be copied
- * and the type of IO object (memory vs. tmpfile) will be inherited.
+ * If the Data Stream object is a slice from another Data Stream object, the
+ * data will be copied and the type of Data Stream object (memory vs. tmpfile)
+ * will be inherited.
  */
 void fiobj_data_assert_dynamic(FIOBJ io);
 

data/ext/iodine/fiobj_hash.c

@@ -3,17 +3,17 @@ Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
 
-#include "fiobject.h"
+#include <fiobject.h>
 
 #define FIO_OVERRIDE_MALLOC 1
-#include "fio_mem.h"
+#include <fiobj_mem.h>
 
 #if !FIO_FORCE_MALLOC
 #define FIO_HASH_REALLOC(ptr, original_size, size, valid_data_length)          \
   fio_realloc2((ptr), (size), (valid_data_length))
 #endif
 
-#include "fiobj_hash.h"
+#include <fiobj_hash.h>
 
 #include <assert.h>
 
@@ -38,7 +38,7 @@ static void hash_key_free(hash_key_s key) { fiobj_free(key.key); }
 #define FIO_HASH_KEY_COPY(k) hash_key_copy(k)
 #define FIO_HASH_KEY_DESTROY(k) hash_key_free(k)
 
-#include "fio_hashmap.h"
+#include <fio_hashmap.h>
 
 #include <errno.h>
 
@@ -133,7 +133,7 @@ static size_t fiobj_hash_is_true(const FIOBJ o) {
   return fiobj_hash_count(o) != 0;
 }
 
-fio_cstr_s fiobject___noop_to_str(const FIOBJ o);
+fio_str_info_s fiobject___noop_to_str(const FIOBJ o);
 intptr_t fiobject___noop_to_i(const FIOBJ o);
 double fiobject___noop_to_f(const FIOBJ o);
 
@@ -190,7 +190,7 @@ FIOBJ fiobj_hash_new2(size_t capa) {
 
 /**
  * Returns a temporary theoretical Hash map capacity.
- * This could be used for testig performance and memory consumption.
+ * This could be used for testing performance and memory consumption.
  */
 size_t fiobj_hash_capa(const FIOBJ hash) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
@@ -321,7 +321,7 @@ FIOBJ fiobj_hash_get(const FIOBJ hash, FIOBJ key) {
  * This function takes a `uintptr_t` Hash value (see `fio_siphash`) to
  * perform a lookup in the HashMap.
  *
- * Returns NULL if no object is asociated with this hashed key value.
+ * Returns NULL if no object is associated with this hashed key value.
  */
 FIOBJ fiobj_hash_get2(const FIOBJ hash, uint64_t key_hash) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));

data/ext/iodine/fiobj_hash.h

@@ -16,10 +16,11 @@ License: MIT
  */
 #define H_FIOBJ_HASH_H
 
-#include "fiobject.h"
+#include <fiobject.h>
+
+#include <fio_siphash.h>
+#include <fiobj_str.h>
 
-#include "fio_siphash.h"
-#include "fiobj_str.h"
 #include <errno.h>
 
 #ifdef __cplusplus
@@ -58,7 +59,7 @@ Hash properties and state
 
 /**
  * Returns a temporary theoretical Hash map capacity.
- * This could be used for testig performance and memory consumption.
+ * This could be used for testing performance and memory consumption.
  */
 size_t fiobj_hash_capa(const FIOBJ hash);
 
@@ -150,7 +151,7 @@ FIOBJ fiobj_hash_get(const FIOBJ hash, FIOBJ key);
  * perform a lookup in the HashMap, which is slightly faster than the other
  * variations.
  *
- * Returns FIOBJ_INVALID if no object is asociated with this hashed key value.
+ * Returns FIOBJ_INVALID if no object is associated with this hashed key value.
  */
 FIOBJ fiobj_hash_get2(const FIOBJ hash, uint64_t key_hash);
 

data/ext/iodine/fiobj_json.c

@@ -2,10 +2,10 @@
 Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
-#include "fiobj_json.h"
-#include "fio_json_parser.h"
+#include <fiobj_json.h>
 
-#include "fio_ary.h"
+#include <fio_ary.h>
+#include <fio_json_parser.h>
 
 #include <assert.h>
 #include <ctype.h>
@@ -162,8 +162,8 @@ JSON formatting
 
 /** Writes a JSON friendly version of the src String */
 static void write_safe_str(FIOBJ dest, const FIOBJ str) {
-  fio_cstr_s s = fiobj_obj2cstr(str);
-  fio_cstr_s t = fiobj_obj2cstr(dest);
+  fio_str_info_s s = fiobj_obj2cstr(str);
+  fio_str_info_s t = fiobj_obj2cstr(dest);
   t.data[t.len] = '"';
   t.len++;
   fiobj_str_resize(dest, t.len);
@@ -181,7 +181,7 @@ static void write_safe_str(FIOBJ dest, const FIOBJ str) {
     } else {
       capa = fiobj_str_capa_assert(dest, (end + s.len + 64));
     }
-    fio_cstr_s tmp = fiobj_obj2cstr(dest);
+    fio_str_info_s tmp = fiobj_obj2cstr(dest);
     t = tmp;
   }
   while (len) {
@@ -264,7 +264,7 @@ typedef struct {
   uint8_t pretty;
 } obj2json_data_s;
 
-static int fiobj_fiobj_obj2json_task(FIOBJ o, void *data_) {
+static int fiobj_obj2json_task(FIOBJ o, void *data_) {
   obj2json_data_s *data = data_;
   uint8_t add_seperator = 1;
   if (fiobj_hash_key_in_loop()) {
@@ -327,10 +327,10 @@ static int fiobj_fiobj_obj2json_task(FIOBJ o, void *data_) {
       uintptr_t indent = fio_ary_count(data->stack) - 1;
       fiobj_str_capa_assert(data->dest,
                             fiobj_obj2cstr(data->dest).len + (indent * 2));
-      fio_cstr_s buf = fiobj_obj2cstr(data->dest);
+      fio_str_info_s buf = fiobj_obj2cstr(data->dest);
       while (indent--) {
-        buf.bytes[buf.len++] = ' ';
-        buf.bytes[buf.len++] = ' ';
+        buf.data[buf.len++] = ' ';
+        buf.data[buf.len++] = ' ';
       }
       fiobj_str_resize(data->dest, buf.len);
     }
@@ -413,23 +413,26 @@ FIOBJ fiobj_obj2json2(FIOBJ dest, FIOBJ o, uint8_t pretty) {
     fiobj_str_write(dest, "null", 4);
     return 0;
   }
-  fio_ary_s stack;
+  fio_ary_s stack = FIO_ARY_INIT;
   obj2json_data_s data = {
-      .dest = dest, .stack = &stack, .pretty = pretty, .count = 1,
+      .dest = dest,
+      .stack = &stack,
+      .pretty = pretty,
+      .count = 1,
   };
   if (!o || !FIOBJ_IS_ALLOCATED(o) || !FIOBJECT2VTBL(o)->each) {
-    fiobj_fiobj_obj2json_task(o, &data);
+    fiobj_obj2json_task(o, &data);
     return dest;
   }
   fio_ary_new(&stack, 0);
-  fiobj_each2(o, fiobj_fiobj_obj2json_task, &data);
+  fiobj_each2(o, fiobj_obj2json_task, &data);
   fio_ary_free(&stack);
   return dest;
 }
 
 /* Formats an object into a JSON string. Remember to `fiobj_free`. */
 FIOBJ fiobj_obj2json(FIOBJ obj, uint8_t pretty) {
-  return fiobj_obj2json2(fiobj_str_buf(0), obj, pretty);
+  return fiobj_obj2json2(fiobj_str_buf(128), obj, pretty);
 }
 
 /* *****************************************************************************
@@ -442,7 +445,7 @@ void fiobj_test_json(void) {
 #define TEST_ASSERT(cond, ...)                                                 \
   if (!(cond)) {                                                               \
     fprintf(stderr, "* " __VA_ARGS__);                                         \
-    fprintf(stderr, "Testing failed.\n");                                      \
+    fprintf(stderr, "\n !!! Testing failed !!!\n");                            \
     exit(-1);                                                                  \
   }
   char json_str[] = "{\"array\":[1,2,3,\"boom\"],\"my\":{\"secret\":42},"
@@ -538,7 +541,7 @@ void fiobj_test_json(void) {
   fprintf(stderr, "* passed.\n");
   fprintf(stderr, "=== Testing JSON formatting (simple test)\n");
   tmp = fiobj_obj2json(o, 0);
-  fprintf(stderr, "* data (%p):\n%.*s\n", fiobj_obj2cstr(tmp).buffer,
+  fprintf(stderr, "* data (%p):\n%.*s\n", (void *)fiobj_obj2cstr(tmp).data,
           (int)fiobj_obj2cstr(tmp).len, fiobj_obj2cstr(tmp).data);
   if (!strcmp(fiobj_obj2cstr(tmp).data, json_str))
     fprintf(stderr, "* Stringify == Original.\n");

data/ext/iodine/fiobj_json.h

@@ -6,11 +6,11 @@ Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
 
-#include "fiobj_ary.h"
-#include "fiobj_hash.h"
-#include "fiobj_numbers.h"
-#include "fiobj_str.h"
-#include "fiobject.h"
+#include <fiobj_ary.h>
+#include <fiobj_hash.h>
+#include <fiobj_numbers.h>
+#include <fiobj_str.h>
+#include <fiobject.h>
 
 #ifdef __cplusplus
 extern "C" {

data/ext/iodine/fiobj_mem.h

@@ -0,0 +1,71 @@
+/*
+Copyright: Boaz Segev, 2018
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef H_FIOBJ_MEM_H
+
+/**
+ * This is a placeholder for facil.io memory allocator functions in fio.h.
+ *
+ * In cases where the FIOBJ library is extracted from facil.io, these functions
+ * will call the system's memory allocator (`malloc`, `free`, etc').
+ */
+#define H_FIOBJ_MEM_H
+
+#include <stdlib.h>
+
+/**
+ * Allocates memory using a per-CPU core block memory pool.
+ * Memory is zeroed out.
+ *
+ * Allocations above FIO_MEMORY_BLOCK_ALLOC_LIMIT (12,288 bytes when using 32Kb
+ * blocks) will be redirected to `mmap`, as if `fio_mmap` was called.
+ */
+void *fio_malloc(size_t size);
+
+/**
+ * same as calling `fio_malloc(size_per_unit * unit_count)`;
+ *
+ * Allocations above FIO_MEMORY_BLOCK_ALLOC_LIMIT (12,288 bytes when using 32Kb
+ * blocks) will be redirected to `mmap`, as if `fio_mmap` was called.
+ */
+void *fio_calloc(size_t size_per_unit, size_t unit_count);
+
+/** Frees memory that was allocated using this library. */
+void fio_free(void *ptr);
+
+/**
+ * Re-allocates memory. An attept to avoid copying the data is made only for big
+ * memory allocations (larger than FIO_MEMORY_BLOCK_ALLOC_LIMIT).
+ */
+void *fio_realloc(void *ptr, size_t new_size);
+
+/**
+ * Re-allocates memory. An attept to avoid copying the data is made only for big
+ * memory allocations (larger than FIO_MEMORY_BLOCK_ALLOC_LIMIT).
+ *
+ * This variation is slightly faster as it might copy less data.
+ */
+void *fio_realloc2(void *ptr, size_t new_size, size_t copy_length);
+
+/**
+ * Allocates memory directly using `mmap`, this is prefered for objects that
+ * both require almost a page of memory (or more) and expect a long lifetime.
+ *
+ * However, since this allocation will invoke the system call (`mmap`), it will
+ * be inherently slower.
+ *
+ * `fio_free` can be used for deallocating the memory.
+ */
+void *fio_mmap(size_t size);
+
+#if FIO_OVERRIDE_MALLOC
+#define malloc fio_malloc
+#define free fio_free
+#define realloc fio_realloc
+#define calloc fio_calloc
+#endif
+
+#endif /* H_FIOBJ_MEM_H */

data/ext/iodine/fiobj_mustache.c

@@ -0,0 +1,310 @@
+#define INCLUDE_MUSTACHE_IMPLEMENTATION 1
+#include <mustache_parser.h>
+
+#include <fiobj_ary.h>
+#include <fiobj_hash.h>
+#include <fiobj_mustache.h>
+#include <fiobj_str.h>
+
+/**
+ * Loads a mustache template, converting it into an opaque instruction array.
+ *
+ * Returns a pointer to the instruction array.
+ *
+ * The `folder` argument should contain the template's root folder which would
+ * also be used to search for any required partial templates.
+ *
+ * The `filename` argument should contain the template's file name.
+ */
+mustache_s *fiobj_mustache_load(fio_str_info_s filename) {
+  return mustache_load(.filename = filename.data, .filename_len = filename.len);
+}
+
+/** Free the mustache template */
+void fiobj_mustache_free(mustache_s *mustache) { mustache_free(mustache); }
+
+/**
+ * Renders a template into an existing FIOBJ String (`dest`'s end), using the
+ * information in the `data` object.
+ *
+ * Returns FIOBJ_INVALID if an error occured and a FIOBJ String on success.
+ */
+FIOBJ fiobj_mustache_build2(FIOBJ dest, mustache_s *mustache, FIOBJ data) {
+  mustache_build(mustache, .udata1 = (void *)dest, .udata2 = (void *)data);
+  return dest;
+}
+
+/**
+ * Creates a FIOBJ String containing the rendered template using the information
+ * in the `data` object.
+ *
+ * Returns FIOBJ_INVALID if an error occured and a FIOBJ String on success.
+ */
+FIOBJ fiobj_mustache_build(mustache_s *mustache, FIOBJ data) {
+  if (!mustache)
+    return FIOBJ_INVALID;
+  return fiobj_mustache_build2(fiobj_str_buf(mustache->u.read_only.data_length),
+                               mustache, data);
+}
+
+/* *****************************************************************************
+Mustache 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 FIOBJ fiobj_mustache_find_obj(mustache_section_s *section,
+                                            const char *name,
+                                            uint32_t name_len) {
+  FIOBJ key = fiobj_str_tmp();
+  fiobj_str_write(key, name, name_len);
+  FIOBJ o = FIOBJ_INVALID;
+  do {
+    if (!FIOBJ_TYPE_IS((FIOBJ)section->udata2, FIOBJ_T_HASH))
+      continue;
+    o = fiobj_hash_get((FIOBJ)section->udata2, key);
+    section = section->parent;
+  } while (o == FIOBJ_INVALID && section);
+  return o;
+}
+/**
+ * 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) {
+  FIOBJ o = fiobj_mustache_find_obj(section, name, name_len);
+  if (!o)
+    return 0;
+  if (!escape || !FIOBJ_TYPE_IS(o, FIOBJ_T_STRING)) {
+    fiobj_str_join((FIOBJ)section->udata1, o);
+    return 0;
+  }
+  /* TODO: html escape */
+  fio_str_info_s str = fiobj_obj2cstr(o);
+  if (!str.len)
+    return 0;
+  fio_str_info_s i = fiobj_obj2cstr(o);
+  i.capa = fiobj_str_capa_assert((FIOBJ)section->udata1, i.len + str.len + 64);
+  do {
+    if (i.len + 6 >= i.capa)
+      i.capa = fiobj_str_capa_assert((FIOBJ)section->udata1, i.capa + 64);
+    i.len = fiobj_str_write((FIOBJ)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;
+}
+
+/**
+ * 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) {
+  FIOBJ dest = (FIOBJ)section->udata1;
+  fiobj_str_write(dest, 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) {
+  FIOBJ o = fiobj_mustache_find_obj(section, name, name_len);
+  if (!o)
+    return 0;
+  if (FIOBJ_TYPE_IS(o, FIOBJ_T_ARRAY))
+    return fiobj_ary_count(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) {
+  FIOBJ o = fiobj_mustache_find_obj(section, name, name_len);
+  if (!o)
+    return -1;
+  if (FIOBJ_TYPE_IS(o, FIOBJ_T_ARRAY))
+    section->udata2 = (void *)fiobj_ary_index(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;
+}
+
+/* *****************************************************************************
+Testing
+***************************************************************************** */
+
+#if DEBUG
+static inline void mustache_save2file(char const *filename, char const *data,
+                                      size_t length) {
+  int fd = open(filename, O_CREAT | O_RDWR, 0);
+  if (fd == -1) {
+    perror("Couldn't open / create file for template testing");
+    exit(-1);
+  }
+  fchmod(fd, 0777);
+  if (pwrite(fd, data, length, 0) != (ssize_t)length) {
+    perror("Mustache template write error");
+    exit(-1);
+  }
+  close(fd);
+}
+
+void fiobj_mustache_test(void) {
+#define TEST_ASSERT(cond, ...)                                                 \
+  if (!(cond)) {                                                               \
+    fprintf(stderr, "* " __VA_ARGS__);                                         \
+    fprintf(stderr, "\n !!! Testing failed !!!\n");                            \
+    exit(-1);                                                                  \
+  }
+
+  char const *template = "{{=<< >>=}}* Users:\r\n<<#users>><<id>>. <<& name>> "
+                         "(<<name>>)\r\n<</users>>";
+  char const *template_name = "mustache_test_template.mustache";
+  mustache_save2file(template_name, template, strlen(template));
+  // mustache_error_en err = MUSTACHE_OK;
+  mustache_s *m =
+      fiobj_mustache_load((fio_str_info_s){.data = (char *)template_name});
+  unlink(template_name);
+  TEST_ASSERT(m, "fiobj_mustache_load failed.\n");
+  FIOBJ data = fiobj_hash_new();
+  FIOBJ key = fiobj_str_new("users", 5);
+  FIOBJ ary = fiobj_ary_new2(4);
+  fiobj_hash_set(data, key, ary);
+  fiobj_free(key);
+  for (int i = 0; i < 4; ++i) {
+    FIOBJ id = fiobj_str_buf(4);
+    fiobj_str_write_i(id, i);
+    FIOBJ name = fiobj_str_buf(4);
+    fiobj_str_write(name, "User ", 5);
+    fiobj_str_write_i(name, i);
+    FIOBJ usr = fiobj_hash_new2(2);
+    key = fiobj_str_new("id", 2);
+    fiobj_hash_set(usr, key, id);
+    fiobj_free(key);
+    key = fiobj_str_new("name", 4);
+    fiobj_hash_set(usr, key, name);
+    fiobj_free(key);
+    fiobj_ary_push(ary, usr);
+  }
+  key = fiobj_mustache_build(m, data);
+  fiobj_free(data);
+  TEST_ASSERT(key, "fiobj_mustache_build failed!\n");
+  fprintf(stderr, "%s\n", fiobj_obj2cstr(key).data);
+  fiobj_free(key);
+}
+
+#endif