iodine 0.7.12 → 0.7.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 754d32e0aca1e86482fbe961e45127e068c9890d3cff09c67e70349872bfa87e
-  data.tar.gz: e7d9c1abacfec11b27eeb8879585f12c010ddb52c64938cffe530d60f325dd69
+  metadata.gz: 943a41860e82f16cade6bb4f0ba8eabab9d712eb620de04cfbeca7153e4e8551
+  data.tar.gz: ef24434b749862566b869ff248089bc5f420a46b0492644096a40588766d3c3e
 SHA512:
-  metadata.gz: f6141afd0ec6d66f0de2cfb0d85d997be21287b0c307c1f370374f5ed2758c77aa206a4e9a09abd7a7ee701423177655e5c67ef3dec69de3a189b3597177c258
-  data.tar.gz: 6bc527391894adeb5431d2fa57e6c8c073036775ad4cd4f4571765f9baa3e01cdb4eb00b39c230d7296d8df707bdffc0f926ef3a8bf66c3d0c21eed28132ea5c
+  metadata.gz: 95c9c98a8b85201a98989e96379fbbaeb74e3d16ae9ea4b42bf3fd49d7591d7224bb406d568298b19583411f675b337110d464ad7447221ee19583d10e6a37aa
+  data.tar.gz: 4614ca29b759b2c1c8e6329c38b565415eb69c356298a53429f0af100545fe1944e1340ccf6334e55d444d8f7659c13c3e6d1f45e6b9d384972acbaa59f7f8d4

data/CHANGELOG.md

@@ -6,6 +6,12 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.13
+
+**Fix**: (`mustache`) added support for padding in template partials.
+
+**Fix**: (`mustache`) added support for method names as keys (i.e., `{{user.to_json}}` or `{{#user}}{{to_json}}{{/user}}`). Note: no arguments may be passed (no Ruby code parsing, just testing against method names).
+
 #### Change log v.0.7.12
 
 **Fix**: (`mustache`) fixed multiple issues with `Iodine::Mustache` and added lambda support for mustache templates.

data/ext/iodine/fio.c

@@ -6448,10 +6448,15 @@ static size_t fio_mem_block_count;
       "(fio) Total memory blocks allocated before cleanup %zu\n"               \
       "       Maximum memory blocks allocated at a single time %zu\n",         \
       fio_mem_block_count, fio_mem_block_count_max)
+#define FIO_MEMORY_PRINT_BLOCK_STAT_END()                                      \
+  FIO_LOG_INFO("(fio) Total memory blocks allocated "                          \
+               "after cleanup (possible leak) %zu\n",                          \
+               fio_mem_block_count)
 #else
 #define FIO_MEMORY_ON_BLOCK_ALLOC()
 #define FIO_MEMORY_ON_BLOCK_FREE()
 #define FIO_MEMORY_PRINT_BLOCK_STAT()
+#define FIO_MEMORY_PRINT_BLOCK_STAT_END()
 #endif
 /* *****************************************************************************
 Per-CPU Arena management
@@ -6722,7 +6727,7 @@ static void fio_mem_destroy(void) {
   if (!memory.forked && fio_ls_embd_any(&memory.available)) {
     FIO_LOG_WARNING("facil.io detected memory traces remaining after cleanup"
                     " - memory leak?");
-    FIO_MEMORY_PRINT_BLOCK_STAT();
+    FIO_MEMORY_PRINT_BLOCK_STAT_END();
     size_t count = 0;
     FIO_LS_EMBD_FOR(&memory.available, node) { ++count; }
     FIO_LOG_DEBUG("Memory pool size: %zu (%zu blocks per allocation).", count,

data/ext/iodine/fiobj_mustache.c

@@ -73,71 +73,6 @@ FIOBJ fiobj_mustache_build(mustache_s *mustache, FIOBJ data) {
 Mustache Callbacks
 ***************************************************************************** */
 
-/** HTML ecape table, created using the following Ruby Script:
-
-a = (0..255).to_a.map {|i| i.chr }
-# 100.times {|i| a[i] = "&\#x#{ i < 16 ? "0#{i.to_s(16)}" : i.to_s(16)};"}
-100.times {|i| a[i] = "&\##{i.to_s(10)};"}
-('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;"
-a["\'".ord] = "&apos;"
-a['|'.ord] = "&\##{'|'.ord.to_s(10)};"
-
-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[] = {
-    "&#0;",  "&#1;",  "&#2;",   "&#3;",  "&#4;",   "&#5;",  "&#6;",  "&#7;",
-    "&#8;",  "&#9;",  "&#10;",  "&#11;", "&#12;",  "&#13;", "&#14;", "&#15;",
-    "&#16;", "&#17;", "&#18;",  "&#19;", "&#20;",  "&#21;", "&#22;", "&#23;",
-    "&#24;", "&#25;", "&#26;",  "&#27;", "&#28;",  "&#29;", "&#30;", "&#31;",
-    "&#32;", "&#33;", "&quot;", "&#35;", "&#36;",  "&#37;", "&amp;", "&apos;",
-    "&#40;", "&#41;", "&#42;",  "&#43;", "&#44;",  "&#45;", "&#46;", "&#47;",
-    "0",     "1",     "2",      "3",     "4",      "5",     "6",     "7",
-    "8",     "9",     "&#58;",  "&#59;", "&lt;",   "&#61;", "&gt;",  "&#63;",
-    "&#64;", "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",      "&#91;", "&#92;",  "&#93;", "&#94;", "&#95;",
-    "&#96;", "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",      "{",     "&#124;", "}",     "~",     "\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[] = {
-    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
-    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 5, 5, 5, 5, 6, 5, 5, 5, 5, 5, 5, 5, 5,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 4, 5, 4, 5, 5, 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, 5, 5, 5, 5, 5,
-    5, 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, 1, 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, 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, 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, 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, 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, 1};
-
 static inline FIOBJ fiobj_mustache_find_obj(mustache_section_s *section,
                                             const char *name,
                                             uint32_t name_len) {
@@ -169,30 +104,10 @@ static int mustache_on_arg(mustache_section_s *section, const char *name,
   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;
+  if (!i.len)
+    return 0;
+  return mustache_write_text(section, i.data, i.len, escape);
 }
 
 /**
@@ -230,7 +145,7 @@ static int32_t mustache_on_section_test(mustache_section_s *section,
   if (FIOBJ_TYPE_IS(o, FIOBJ_T_ARRAY))
     return fiobj_ary_count(o);
   return 1;
-  (void)callable;
+  (void)callable; /* FIOBJ doesn't support lambdas */
 }
 
 /**

data/ext/iodine/iodine_mustache.c

@@ -122,6 +122,11 @@ static inline VALUE fiobj_mustache_find_obj_absolute(VALUE udata,
   if (!RB_TYPE_P(udata, T_HASH)) {
     if (name_len == 1 && name[0] == '.')
       return udata;
+    /* search by method */
+    ID name_id = rb_intern2(name, name_len);
+    if (rb_respond_to(udata, name_id)) {
+      return IodineCaller.call(udata, name_id);
+    }
     return Qnil;
   }
   /* search by String */
@@ -130,8 +135,14 @@ static inline VALUE fiobj_mustache_find_obj_absolute(VALUE udata,
   if (tmp != Qnil)
     return tmp;
   /* search by Symbol */
-  key = rb_id2sym(rb_intern2(name, name_len));
+  ID name_id = rb_intern2(name, name_len);
+  key = rb_id2sym(name_id);
   tmp = rb_hash_aref(udata, key);
+  /* search by method */
+  if (tmp == Qnil && rb_respond_to(udata, name_id)) {
+    tmp = IodineCaller.call(udata, name_id);
+  }
+
   return tmp;
 }
 
@@ -175,10 +186,11 @@ static inline VALUE fiobj_mustache_find_obj(mustache_section_s *section,
     dot = 0;
     while (dot < name_len && name[dot] != '.')
       ++dot;
-    if (dot == name_len)
+    if (dot == name_len) {
       return Qnil;
+    }
     tmp = fiobj_mustache_find_obj_absolute(tmp, name, dot);
-    if (tmp == Qnil || !RB_TYPE_P(tmp, T_HASH))
+    if (tmp == Qnil)
       return Qnil;
     ++dot;
   }
@@ -206,39 +218,15 @@ static int mustache_on_arg(mustache_section_s *section, const char *name,
     fio_str_write(section->udata1, "true", 4);
     break;
   }
-  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)) {
+    if (rb_respond_to(o, call_func_id))
+      o = IodineCaller.call(o, call_func_id);
+    if (!RB_TYPE_P(o, T_STRING))
+      o = IodineCaller.call(o, to_s_func_id);
+  }
   if (!RB_TYPE_P(o, T_STRING) || !RSTRING_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 = IodineCaller.call(o, call_func_id);
-  if (RB_TYPE_P(o, T_STRING))
-    o = rb_funcall2(o, to_s_func_id, 0, NULL);
-  fio_str_write(section->udata1, RSTRING_PTR(o), RSTRING_LEN(o));
-  return 0;
+  return mustache_write_text(section, RSTRING_PTR(o), RSTRING_LEN(o), escape);
 }
 
 /**
@@ -287,7 +275,7 @@ static int32_t mustache_on_section_test(mustache_section_s *section,
     if (!RB_TYPE_P(o, T_STRING))
       o = rb_funcall2(o, to_s_func_id, 0, NULL);
     if (RB_TYPE_P(o, T_STRING) && RSTRING_LEN(o))
-      fio_str_write(section->udata1, RSTRING_PTR(o), RSTRING_LEN(o));
+      mustache_write_text(section, RSTRING_PTR(o), RSTRING_LEN(o), 0);
     return 0;
   }
   return 1;
@@ -359,10 +347,10 @@ error:
              "Iodine::Mustache template error, closure mismatch.");
     break;
   case MUSTACHE_ERR_FILE_NOT_FOUND:
-    rb_raise(rb_eRuntimeError, "Iodine::Mustache template not found.");
+    rb_raise(rb_eLoadError, "Iodine::Mustache template not found.");
     break;
   case MUSTACHE_ERR_FILE_TOO_BIG:
-    rb_raise(rb_eRuntimeError, "Iodine::Mustache template too big.");
+    rb_raise(rb_eLoadError, "Iodine::Mustache template too big.");
     break;
   case MUSTACHE_ERR_FILE_NAME_TOO_LONG:
     rb_raise(rb_eRuntimeError, "Iodine::Mustache template name too long.");
@@ -528,10 +516,10 @@ error:
              "Iodine::Mustache template error, closure mismatch.");
     break;
   case MUSTACHE_ERR_FILE_NOT_FOUND:
-    rb_raise(rb_eRuntimeError, "Iodine::Mustache template not found.");
+    rb_raise(rb_eLoadError, "Iodine::Mustache template not found.");
     break;
   case MUSTACHE_ERR_FILE_TOO_BIG:
-    rb_raise(rb_eRuntimeError, "Iodine::Mustache template too big.");
+    rb_raise(rb_eLoadError, "Iodine::Mustache template too big.");
     break;
   case MUSTACHE_ERR_FILE_NAME_TOO_LONG:
     rb_raise(rb_eRuntimeError, "Iodine::Mustache template name too long.");

data/ext/iodine/mustache_parser.h

@@ -71,7 +71,7 @@ Feel free to copy, use and enjoy according to the license provided.
 
 #if !defined(MUSTACHE_NESTING_LIMIT) || !MUSTACHE_NESTING_LIMIT
 #undef MUSTACHE_NESTING_LIMIT
-#define MUSTACHE_NESTING_LIMIT 96
+#define MUSTACHE_NESTING_LIMIT 82
 #endif
 
 #if !defined(__GNUC__) && !defined(__clang__) && !defined(FIO_GNUC_BYPASS)
@@ -89,7 +89,7 @@ Feel free to copy, use and enjoy according to the license provided.
 #endif
 
 /* *****************************************************************************
-Mustache API Functions and Arguments
+Mustache API Argument types
 ***************************************************************************** */
 
 /** an opaque type for mustache template data (when caching). */
@@ -125,15 +125,27 @@ typedef struct {
   mustache_error_en *err;
 } mustache_load_args_s;
 
+/* *****************************************************************************
+REQUIRED: Define INCLUDE_MUSTACHE_IMPLEMENTATION only in the implementation file
+***************************************************************************** */
+
 /**
- * Allows this header to be included within another header while limiting
- * exposure.
+ * In non-implementation files, don't define the INCLUDE_MUSTACHE_IMPLEMENTATION
+ * macro.
  *
- * before including the header within an implementation faile, define
+ * Before including the header within an implementation faile, define
  * INCLUDE_MUSTACHE_IMPLEMENTATION as 1.
+ *
+ * When unset (or zero), this will expose the return error reporting and
+ * function argument types, allowing them to be exposed in a public facing API.
+ * exposure to the function return and argument types.
  */
 #if INCLUDE_MUSTACHE_IMPLEMENTATION
 
+/* *****************************************************************************
+Mustache API Functions and Arguments
+***************************************************************************** */
+
 MUSTACHE_FUNC mustache_s *mustache_load(mustache_load_args_s args);
 
 #define mustache_load(...) mustache_load((mustache_load_args_s){__VA_ARGS__})
@@ -203,6 +215,18 @@ Callbacks Helpers - These functions can be called from within callbacks
 static inline mustache_section_s *
 mustache_section_parent(mustache_section_s *section);
 
+/**
+ * This helper function should be used to write text to the output
+ * stream form within `mustache_on_arg` or `mustache_on_section_test`.
+ *
+ * This function will call the `mustache_on_text` callback for each slice of
+ * text that requires padding and for escaped data.
+ *
+ * `mustache_on_text` must NEVER call this function.
+ */
+static inline int mustache_write_text(mustache_section_s *section, char *text,
+                                      uint32_t len, uint8_t escape);
+
 /**
  * Returns the section's unparsed content as a non-NUL terminated byte array.
  *
@@ -328,6 +352,9 @@ typedef struct mustache__instruction_s {
     MUSTACHE_SECTION_START_INV,
     MUSTACHE_SECTION_END,
     MUSTACHE_SECTION_GOTO,
+    MUSTACHE_PADDING_PUSH,
+    MUSTACHE_PADDING_POP,
+    MUSTACHE_PADDING_WRITE,
   } instruction;
   /** the data the instruction acts upon */
   struct {
@@ -353,15 +380,24 @@ typedef struct {
   uint16_t frame; /* the stack frame's index (zero based) */
 } mustache__section_stack_frame_s;
 
+/*
+ * The stack memory is placed in a structure to allow stack unrolling and
+ * avoiding recursion with it's stack overflow risks.
+ */
 typedef struct {
   mustache_s *data; /* the mustache template being built */
   uint32_t pos;     /* the instruction postision index */
+  uint32_t padding; /* padding instruction position */
   uint16_t index;   /* the stack postision index */
   mustache__section_stack_frame_s stack[MUSTACHE_NESTING_LIMIT];
 } mustache__builder_stack_s;
 
-#define MUSTACHE_DELIMITER_LENGTH_LIMIT 11
+#define MUSTACHE_DELIMITER_LENGTH_LIMIT 5
 
+/*
+ * The stack memory is placed in a structure to allow stack unrolling and
+ * avoiding recursion with it's stack overflow risks.
+ */
 typedef struct {
   mustache_s *m;
   mustache__instruction_s *i;
@@ -370,6 +406,7 @@ typedef struct {
   char *path;
   uint32_t i_capa;
   uint32_t data_len;
+  uint32_t padding;
   uint16_t path_len;
   uint16_t path_capa;
   uint16_t index; /* stack index */
@@ -409,6 +446,18 @@ Callbacks Helper Implementation
     (str) += (step);                                                           \
   }
 
+/*
+ * used internally by some of the helpers to find convert a section pointer to
+ * the full builder stack data.
+ */
+static inline mustache__builder_stack_s *
+mustache___section2stack(mustache_section_s *section) {
+  mustache__section_stack_frame_s *f =
+      (mustache__section_stack_frame_s *)section;
+  return MUSTACHE_OBJECT_OFFSET(mustache__builder_stack_s, stack,
+                                (f - f->frame));
+}
+
 /**
  * Returns the section's parent for nested sections, or NULL (for root section).
  *
@@ -442,10 +491,7 @@ static inline const char *mustache_section_text(mustache_section_s *section,
                                                 size_t *p_len) {
   if (!section || !p_len)
     goto error;
-  mustache__section_stack_frame_s *f =
-      (mustache__section_stack_frame_s *)section;
-  mustache__builder_stack_s *s =
-      MUSTACHE_OBJECT_OFFSET(mustache__builder_stack_s, stack, (f - f->frame));
+  mustache__builder_stack_s *s = mustache___section2stack(section);
   mustache__instruction_s *inst =
       MUSTACH2INSTRUCTIONS(s->data) + s->pos; /* current instruction*/
   if (inst->instruction != MUSTACHE_SECTION_START)
@@ -459,6 +505,148 @@ error:
   return NULL;
 }
 
+/**
+ * used internally to write escaped text rather than clear text.
+ */
+static inline int mustache__write_padding(mustache__builder_stack_s *s) {
+  mustache__instruction_s *const inst = MUSTACH2INSTRUCTIONS(s->data);
+  char *const data = MUSTACH2DATA(s->data);
+  for (uint32_t i = s->padding; i; i = inst[i].data.end) {
+    if (mustache_on_text(&s->stack[s->index].sec, data + inst[i].data.name_pos,
+                         inst[i].data.name_len) == -1)
+      return -1;
+  }
+  return 0;
+}
+
+/**
+ * used internally to write escaped text rather than clear text.
+ */
+static int mustache__write_escaped(mustache__builder_stack_s *s, char *text,
+                                   uint32_t len) {
+  /** HTML ecape table, created using the following Ruby Script:
+
+a = (0..255).to_a.map {|i| i.chr }
+# 100.times {|i| a[i] = "&\#x#{ i < 16 ? "0#{i.to_s(16)}" : i.to_s(16)};"}
+100.times {|i| a[i] = "&\##{i.to_s(10)};"}
+('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;"
+a["\'".ord] = "&apos;"
+a['|'.ord] = "&\##{'|'.ord.to_s(10)};"
+
+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[] = {
+      "&#0;",  "&#1;",  "&#2;",   "&#3;",  "&#4;",   "&#5;",  "&#6;",  "&#7;",
+      "&#8;",  "&#9;",  "&#10;",  "&#11;", "&#12;",  "&#13;", "&#14;", "&#15;",
+      "&#16;", "&#17;", "&#18;",  "&#19;", "&#20;",  "&#21;", "&#22;", "&#23;",
+      "&#24;", "&#25;", "&#26;",  "&#27;", "&#28;",  "&#29;", "&#30;", "&#31;",
+      "&#32;", "&#33;", "&quot;", "&#35;", "&#36;",  "&#37;", "&amp;", "&apos;",
+      "&#40;", "&#41;", "&#42;",  "&#43;", "&#44;",  "&#45;", "&#46;", "&#47;",
+      "0",     "1",     "2",      "3",     "4",      "5",     "6",     "7",
+      "8",     "9",     "&#58;",  "&#59;", "&lt;",   "&#61;", "&gt;",  "&#63;",
+      "&#64;", "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",      "&#91;", "&#92;",  "&#93;", "&#94;", "&#95;",
+      "&#96;", "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",      "{",     "&#124;", "}",     "~",     "\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[] = {
+      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+      5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 5, 5, 5, 5, 6, 5, 5, 5, 5, 5, 5, 5, 5,
+      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 5, 4, 5, 4, 5, 5, 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, 5, 5, 5, 5, 5,
+      5, 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, 1, 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, 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, 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, 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, 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, 1};
+  char buffer[4096];
+  size_t pos = 0;
+  const char *end = text + len;
+  while (text < end) {
+    if (*text == '\n' && s->padding) {
+      buffer[pos++] = '\n';
+      buffer[pos] = 0;
+      if (mustache_on_text(&s->stack[s->index].sec, buffer, pos) == -1)
+        return -1;
+      pos = 0;
+      if (mustache__write_padding(s) == -1)
+        return -1;
+    } else {
+      memcpy(buffer + pos, html_escape_strs[(uint8_t)text[0]],
+             html_escape_len[(uint8_t)text[0]]);
+      pos += html_escape_len[(uint8_t)text[0]];
+      if (pos >= 4090) {
+        buffer[pos] = 0;
+        if (mustache_on_text(&s->stack[s->index].sec, buffer, pos) == -1)
+          return -1;
+        pos = 0;
+      }
+    }
+    ++text;
+  }
+  if (pos) {
+    buffer[pos] = 0;
+    if (mustache_on_text(&s->stack[s->index].sec, buffer, pos) == -1)
+      return -1;
+  }
+  return 0;
+}
+/**
+ * This helper function should be used to write text to the output
+ * stream (often used within the `mustache_on_arg` callback).
+ */
+static inline int mustache_write_text(mustache_section_s *section, char *text,
+                                      uint32_t len, uint8_t escape) {
+  mustache__builder_stack_s *s = mustache___section2stack(section);
+  if (escape)
+    return mustache__write_escaped(s, text, len);
+  /* TODO */
+  char *end = memchr(text, '\n', len);
+  while (len && end) {
+    ++end;
+    const uint32_t slice_len = end - text;
+    if (mustache_on_text(&s->stack[s->index].sec, text, slice_len) == -1)
+      return -1;
+    text = end;
+    len -= slice_len;
+    end = memchr(text, '\n', len);
+    if (mustache__write_padding(s) == -1)
+      return -1;
+  }
+  if (len && mustache_on_text(&s->stack[s->index].sec, text, len) == -1)
+    return -1;
+  return 0;
+}
+
 /* *****************************************************************************
 Internal Helpers
 ***************************************************************************** */
@@ -517,6 +705,26 @@ mustache__data_segment_read(uint8_t *data) {
   return s;
 }
 
+static inline void mustache__stand_alone_adjust(mustache__loader_stack_s *s,
+                                                uint32_t stand_alone) {
+  if (!stand_alone)
+    return;
+  /* adjust reading position */
+  s->stack[s->index].data_pos +=
+      1 + (s->data[s->stack[s->index].data_pos] == '\r');
+  /* remove any padding from the beginning of the line */
+  if (s->m->u.read_only.intruction_count &&
+      s->i[s->m->u.read_only.intruction_count - 1].instruction ==
+          MUSTACHE_WRITE_TEXT) {
+    mustache__instruction_s *ins =
+        s->i + s->m->u.read_only.intruction_count - 1;
+    if (ins->data.name_len <= (stand_alone >> 1))
+      --s->m->u.read_only.intruction_count;
+    else
+      ins->data.name_len -= (stand_alone >> 1);
+  }
+}
+
 /* pushes an instruction to the instruction array */
 static inline int mustache__instruction_push(mustache__loader_stack_s *s,
                                              mustache__instruction_s inst) {
@@ -536,6 +744,52 @@ instructions_too_long:
   return -1;
 }
 
+/* pushes text and padding instruction to the instruction array */
+static inline int mustache__push_text_instruction(mustache__loader_stack_s *s,
+                                                  uint32_t pos, uint32_t len) {
+  /* always push padding instructions, in case or recursion with padding */
+  // if (!s->padding) {
+  //   /* no padding, push text, as is */
+  //   return mustache__instruction_push(
+  //       s, (mustache__instruction_s){
+  //              .instruction = MUSTACHE_WRITE_TEXT,
+  //              .data = {.name_pos = pos, .name_len = len},
+  //          });
+  // }
+  /* insert padding instruction after each new line */
+  for (;;) {
+    /* seek new line markers */
+    char *start = s->data + pos;
+    char *end = memchr(s->data + pos, '\n', len);
+    if (!end)
+      break;
+    /* offset marks the line's length */
+    const size_t offset = (end - start) + 1;
+    /* push text and padding instructions */
+    if (mustache__instruction_push(
+            s,
+            (mustache__instruction_s){
+                .instruction = MUSTACHE_WRITE_TEXT,
+                .data = {.name_pos = pos, .name_len = offset},
+            }) == -1 ||
+        mustache__instruction_push(s, (mustache__instruction_s){
+                                          .instruction = MUSTACHE_PADDING_WRITE,
+                                      }) == -1)
+      return -1;
+    pos += offset;
+    len -= offset;
+  }
+  /* done? */
+  if (!len)
+    return 0;
+  /* write any text that doesn't terminate in the EOL marker */
+  return mustache__instruction_push(
+      s, (mustache__instruction_s){
+             .instruction = MUSTACHE_WRITE_TEXT,
+             .data = {.name_pos = pos, .name_len = len},
+         });
+}
+
 /*
  * Returns the instruction's position if the template is already existing.
  *
@@ -554,9 +808,9 @@ static inline uint32_t mustache__file_is_loaded(mustache__loader_stack_s *s,
   return (uint32_t)-1;
 }
 
-static inline int mustache__load_data(mustache__loader_stack_s *s,
-                                      const char *name, size_t name_len,
-                                      const char *data, size_t data_len) {
+static inline ssize_t mustache__load_data(mustache__loader_stack_s *s,
+                                          const char *name, size_t name_len,
+                                          const char *data, size_t data_len) {
   const size_t old_len = s->data_len;
   if (old_len + data_len > UINT32_MAX)
     goto too_long;
@@ -608,14 +862,14 @@ static inline int mustache__load_data(mustache__loader_stack_s *s,
   s->stack[s->index].del_end[0] = s->stack[s->index].del_end[1] = '}';
   s->stack[s->index].del_end[2] = 0;
   s->stack[s->index].open_sections = 0;
-  return 0;
+  return data_len;
 too_long:
   *s->err = MUSTACHE_ERR_TOO_DEEP;
   return -1;
 }
 
-static inline int mustache__load_file(mustache__loader_stack_s *s,
-                                      const char *name, size_t name_len) {
+static inline ssize_t mustache__load_file(mustache__loader_stack_s *s,
+                                          const char *name, size_t name_len) {
   struct stat f_data;
   uint16_t i = s->index;
   uint32_t old_path_len = 0;
@@ -697,6 +951,9 @@ static inline int mustache__load_file(mustache__loader_stack_s *s,
 file_found:
   if (f_data.st_size >= INT32_MAX) {
     goto file_too_big;
+  } else if (f_data.st_size == 0) {
+    /* empty, do nothing */
+    return 0;
   } else {
     /* test if the file was previously loaded */
     uint32_t pre_existing = mustache__file_is_loaded(s, s->path, old_path_len);
@@ -715,7 +972,7 @@ file_found:
       return 0;
     }
   }
-  if (mustache__load_data(s, s->path, old_path_len, NULL, f_data.st_size))
+  if (mustache__load_data(s, s->path, old_path_len, NULL, f_data.st_size) == -1)
     goto unknown_error;
   int fd = open(s->path, O_RDONLY);
   if (fd == -1)
@@ -724,7 +981,7 @@ file_found:
       f_data.st_size)
     goto file_err;
   close(fd);
-  return 0;
+  return f_data.st_size;
 
 name_missing_error:
   *s->err = MUSTACHE_ERR_FILE_NAME_TOO_SHORT;
@@ -780,6 +1037,7 @@ MUSTACHE_FUNC int(mustache_build)(mustache_build_args_s args) {
   s.data = args.mustache;
   s.pos = 0;
   s.index = 0;
+  s.padding = 0;
   s.stack[0] = (mustache__section_stack_frame_s){
       .sec =
           {
@@ -863,12 +1121,29 @@ MUSTACHE_FUNC int(mustache_build)(mustache_build_args_s args) {
                                       instructions[s.pos].data.name_len,
                                       s.stack[s.index].index) == -1)
           goto user_error;
+        /* skip padding instructions in GOTO tags (recursive partials) */
+        if (instructions[s.pos].instruction == MUSTACHE_SECTION_GOTO)
+          ++s.pos;
         ++s.stack[s.index].index;
         break;
       }
       s.pos = s.stack[s.index].end;
       --s.index;
       break;
+    case MUSTACHE_PADDING_PUSH:
+      s.padding = s.pos;
+      break;
+    case MUSTACHE_PADDING_POP:
+      s.padding = instructions[s.padding].data.end;
+      break;
+    case MUSTACHE_PADDING_WRITE:
+      for (uint32_t i = s.padding; i; i = instructions[i].data.end) {
+        if (mustache_on_text(&s.stack[s.index].sec,
+                             data + instructions[i].data.name_pos,
+                             instructions[i].data.name_len))
+          goto user_error;
+      }
+      break;
     default:
       /* not a valid engine */
       fprintf(stderr, "ERROR: invalid mustache instruction set detected (wrong "
@@ -897,6 +1172,7 @@ Building the instrustion list (parsing the template)
 MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
   mustache_error_en err_if_missing;
   mustache__loader_stack_s s;
+  uint8_t flag = 0;
 
   if (!args.err)
     args.err = &err_if_missing;
@@ -907,6 +1183,7 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
   s.i = NULL;
   s.i_capa = 32;
   s.index = 0;
+  s.padding = 0;
   s.m = malloc(sizeof(*s.m) + (sizeof(*s.i) * 32));
   MUSTACHE_ASSERT(s.m, "failed to allocate memory for mustache data");
   s.m->u.read_only_pt = 0;
@@ -920,11 +1197,11 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
 
   if (args.data) {
     if (mustache__load_data(&s, args.filename, args.filename_len, args.data,
-                            args.data_len)) {
+                            args.data_len) == -1) {
       goto error;
     }
   } else {
-    if (mustache__load_file(&s, args.filename, args.filename_len)) {
+    if (mustache__load_file(&s, args.filename, args.filename_len) == -1) {
       goto error;
     }
   }
@@ -933,6 +1210,9 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
   while (s.index) {
     /* parsing loop */
     while (s.stack[s.index].data_pos < s.stack[s.index].data_end) {
+      /* stand-alone tag flag, also containes padding length after bit 1 */
+      uint32_t stand_alone = 0;
+      uint32_t stand_alone_pos = 0;
       /* start parsing at current position */
       const char *start = s.data + s.stack[s.index].data_pos;
       /* find the next instruction (beg == beginning) */
@@ -940,30 +1220,16 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
       const char *org_beg = beg;
       if (!beg || beg >= s.data + s.stack[s.index].data_end) {
         /* no instructions left, only text */
-        mustache__instruction_push(
-            &s, (mustache__instruction_s){
-                    .instruction = MUSTACHE_WRITE_TEXT,
-                    .data =
-                        {
-                            .name_pos = s.stack[s.index].data_pos,
-                            .name_len = s.stack[s.index].data_end -
-                                        s.stack[s.index].data_pos,
-                        },
-                });
+        mustache__push_text_instruction(&s, s.stack[s.index].data_pos,
+                                        s.stack[s.index].data_end -
+                                            s.stack[s.index].data_pos);
         s.stack[s.index].data_pos = s.stack[s.index].data_end;
         continue;
       }
       if (beg != start) {
         /* there's text before the instruction */
-        mustache__instruction_push(
-            &s, (mustache__instruction_s){
-                    .instruction = MUSTACHE_WRITE_TEXT,
-                    .data =
-                        {
-                            .name_pos = s.stack[s.index].data_pos,
-                            .name_len = beg - start,
-                        },
-                });
+        mustache__push_text_instruction(&s, s.stack[s.index].data_pos,
+                                        (uint32_t)(uintptr_t)(beg - start));
       }
       /* move beg (reading position) after the delimiter */
       beg += s.stack[s.index].del_start_len;
@@ -974,19 +1240,39 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
         *args.err = MUSTACHE_ERR_CLOSURE_MISMATCH;
         goto error;
       }
+
       /* update reading position in the stack */
       s.stack[s.index].data_pos = (end - s.data) + s.stack[s.index].del_end_len;
 
+      /* Test for stand-alone tags */
+      if (!end[s.stack[s.index].del_end_len] ||
+          end[s.stack[s.index].del_end_len] == '\n' ||
+          (end[s.stack[s.index].del_end_len] == '\r' &&
+           end[1 + s.stack[s.index].del_end_len] == '\n')) {
+        char *pad = beg - (s.stack[s.index].del_start_len + 1);
+        while (pad >= start && (pad[0] == ' ' || pad[0] == '\t'))
+          --pad;
+        if (pad[0] == '\n' || pad[0] == 0) {
+          /* Yes, this a stand-alone tag, store padding length + flag  */
+          ++pad;
+          stand_alone_pos = pad - s.data;
+          stand_alone =
+              ((beg - (pad + s.stack[s.index].del_start_len)) << 1) | 1;
+        }
+      }
+
       /* parse instruction content */
-      uint8_t escape_str = 1;
+      flag = 1;
 
       switch (beg[0]) {
       case '!':
-        /* comment, do nothing */
+        /* comment, do nothing... almost */
+        mustache__stand_alone_adjust(&s, stand_alone);
         break;
 
       case '=':
         /* define new seperators */
+        mustache__stand_alone_adjust(&s, stand_alone);
         ++beg;
         --end;
         if (end[0] != '=') {
@@ -1038,9 +1324,10 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
 
       case '^': /*overflow*/
         /* start inverted section */
-        escape_str = 0;
+        flag = 0;
       case '#':
         /* start section (or inverted section) */
+        mustache__stand_alone_adjust(&s, stand_alone);
         ++beg;
         --end;
         MUSTACHE_IGNORE_WHITESPACE(beg, 1);
@@ -1058,8 +1345,8 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
         if (mustache__instruction_push(
                 &s,
                 (mustache__instruction_s){
-                    .instruction = (escape_str ? MUSTACHE_SECTION_START
-                                               : MUSTACHE_SECTION_START_INV),
+                    .instruction = (flag ? MUSTACHE_SECTION_START
+                                         : MUSTACHE_SECTION_START_INV),
                     .data = {
                         .name_pos = beg - s.data,
                         .name_len = end - beg,
@@ -1071,17 +1358,51 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
 
       case '>':
         /* partial template - search data for loaded template or load new */
+        mustache__stand_alone_adjust(&s, stand_alone);
+        if ((stand_alone >> 1)) {
+          /* TODO: add padding markers */
+          if (mustache__instruction_push(
+                  &s, (mustache__instruction_s){
+                          .instruction = MUSTACHE_PADDING_PUSH,
+                          .data = {
+                              .name_pos = stand_alone_pos,
+                              .name_len = (stand_alone >> 1),
+                              .end = s.padding,
+                          }})) {
+            goto error;
+          }
+          s.padding = s.m->u.read_only.intruction_count - 1;
+        }
         ++beg;
         --end;
         MUSTACHE_IGNORE_WHITESPACE(beg, 1);
         MUSTACHE_IGNORE_WHITESPACE(end, -1);
         ++end;
-        if (mustache__load_file(&s, beg, end - beg))
+        ssize_t loaded = mustache__load_file(&s, beg, end - beg);
+        if (loaded == -1)
           goto error;
+        /* Add latest padding section to text */
+        if ((stand_alone >> 1)) {
+          if (loaded)
+            mustache__instruction_push(
+                &s, (mustache__instruction_s){
+                        .instruction = MUSTACHE_WRITE_TEXT,
+                        .data =
+                            {
+                                .name_pos = stand_alone_pos,
+                                .name_len = (stand_alone >> 1),
+                            },
+                    });
+          else if (mustache__instruction_push(
+                       &s, (mustache__instruction_s){.instruction =
+                                                         MUSTACHE_PADDING_POP}))
+            goto error;
+        }
         break;
 
       case '/':
         /* section end */
+        mustache__stand_alone_adjust(&s, stand_alone);
         ++beg;
         --end;
         MUSTACHE_IGNORE_WHITESPACE(beg, 1);
@@ -1143,7 +1464,7 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
         /*overflow*/
       case '&': /*overflow*/
         /* unescaped variable data */
-        escape_str = 0;
+        flag = 0;
         /* overflow to default */
       case ':': /*overflow*/
       case '<': /*overflow*/
@@ -1155,8 +1476,8 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
         ++end;
         mustache__instruction_push(
             &s, (mustache__instruction_s){
-                    .instruction = (escape_str ? MUSTACHE_WRITE_ARG
-                                               : MUSTACHE_WRITE_ARG_UNESCAPED),
+                    .instruction = (flag ? MUSTACHE_WRITE_ARG
+                                         : MUSTACHE_WRITE_ARG_UNESCAPED),
                     .data = {.name_pos = beg - s.data, .name_len = end - beg}});
         break;
       }
@@ -1166,12 +1487,36 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
       *args.err = MUSTACHE_ERR_CLOSURE_MISMATCH;
       goto error;
     }
-    /* add instruction closure */
+    /* move padding from section tail to post closure (adjust for padding
+     * changes) */
+    flag = 0;
+    if (s.m->u.read_only.intruction_count &&
+        s.i[s.m->u.read_only.intruction_count - 1].instruction ==
+            MUSTACHE_PADDING_WRITE) {
+      --s.m->u.read_only.intruction_count;
+      flag = 1;
+    }
+    /* mark section length */
     mustache__data_segment_s seg = mustache__data_segment_read(
         (uint8_t *)s.data + s.stack[s.index].data_start);
     s.i[seg.inst_start].data.end = s.m->u.read_only.intruction_count;
+    /* add instruction closure */
     mustache__instruction_push(
         &s, (mustache__instruction_s){.instruction = MUSTACHE_SECTION_END});
+    /* TODO: pop any padding (if exists) */
+    if (s.padding && s.padding + 1 == seg.inst_start) {
+      s.padding = s.i[s.padding].data.end;
+      mustache__instruction_push(&s, (mustache__instruction_s){
+                                         .instruction = MUSTACHE_PADDING_POP,
+                                     });
+    }
+    /* complete padding switch*/
+    if (flag) {
+      mustache__instruction_push(&s, (mustache__instruction_s){
+                                         .instruction = MUSTACHE_PADDING_WRITE,
+                                     });
+      flag = 0;
+    }
     /* pop stack */
     --s.index;
   }

data/lib/iodine/mustache.rb

@@ -1,11 +1,27 @@
 module Iodine
-  # Iodine includes a strict and extra safe Mustache templating engine.
+  # Iodine includes a safe and fast Mustache templating engine.
   #
-  # The Iodine Mustache templating engine provides increased XSS protection through agressive HTML escaping. It's also faster than the original (Ruby based) Mustache templating engine.
+  # The engine is also faster and simpler than the official and feature richer Ruby engine.
   #
-  # Another difference is that the Iodine Mustache templating engine makes it eady to load the templates from the disk (or specify a virtual filename), allowing for easy patial template path resolution.
+  # Note: {Iodine::Mustache} behaves differently than the official Ruby templating engine in a number of ways:
   #
-  # There's no monkey-patch for `mustache` Ruby gem since the API is incompatible.
+  # * When a partial template can't be found, a `LoadError` exception is raised (the official implementation outputs an empty String).
+  #
+  # * HTML escaping is more agressive, increasing XSS protection. Read why at: https://wonko.com/post/html-escaping .
+  #
+  # * Partial template padding in Iodine is adds padding to dynamic text as well as static text. i.e., unlike the official Ruby mustache engine, if an argument contains a new line marker, the new line will be padded to match the partial template padding.
+  #
+  # * Lambda support is significantly different. For example, the resulting text isn't parsed (no lambda interpolation).
+  #
+  # * Dot notation is tested in whole as well as in part (i.e. `user.name.first` will be tested as is, than the couplet `"user","name.first"` and than as each `"use","name","first"`), allowing for the Hash data to contain keys with dots while still supporting dot notation shortcuts.
+  #
+  # * Dot notation supports method names (even chained method names) as long as they don't have or require arguments. For example, `user.class.to_s` will behave differently on Iodine (returns `"String"`) than on the official mustache engine (returns empty string).
+  #
+  # Iodine Mustache's engine was designed to play best with basic data structures, such as results from the {Iodine::JSON} parser.
+  #
+  # Hash data is tested for String keys before being tested for Symbol keys and methods. This means that `"key"` has precedence over `:key`.
+  #
+  # Note: Although using methods as "keys" (or argument names) is supported, no Ruby code is evaluated.
   #
   # You can benchmark the Iodine Mustache performance and decide if you wish to switch from the Ruby implementation.
   #

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.7.12'.freeze
+  VERSION = '0.7.13'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.12
+  version: 0.7.13
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-30 00:00:00.000000000 Z
+date: 2018-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -210,7 +210,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 'Thank you for installing Iodine 0.7.12.
+post_install_message: 'Thank you for installing Iodine 0.7.13.
 
 '
 rdoc_options: []