iodine 0.7.13 → 0.7.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 943a41860e82f16cade6bb4f0ba8eabab9d712eb620de04cfbeca7153e4e8551
-  data.tar.gz: ef24434b749862566b869ff248089bc5f420a46b0492644096a40588766d3c3e
+  metadata.gz: 0d3f8b237b265c8151aa3fe966a9c863fa3c053e4fd97289cfe498b77818e564
+  data.tar.gz: 389b80f9feff3abf97ba7fdaf08d0a2986521093fb0365ab10c5e4b3af3b2de5
 SHA512:
-  metadata.gz: 95c9c98a8b85201a98989e96379fbbaeb74e3d16ae9ea4b42bf3fd49d7591d7224bb406d568298b19583411f675b337110d464ad7447221ee19583d10e6a37aa
-  data.tar.gz: 4614ca29b759b2c1c8e6329c38b565415eb69c356298a53429f0af100545fe1944e1340ccf6334e55d444d8f7659c13c3e6d1f45e6b9d384972acbaa59f7f8d4
+  metadata.gz: d8b220410c1ebdecf221bde09d48f64ed0c69dc50a0f0ecba69a3e530dc2b9cace643c9a1d8bc7ce73ecf9f1274ffc1162a21db6db273673de84318f9ea81cb3
+  data.tar.gz: 94f71023813326cb0edfabecbbd862e566ec37882de35ca6b6f14a2759088b54ed52df9bb943888b3c58f3441881c67a4c82197550272593050eaca6fc66b3e8

data/CHANGELOG.md

@@ -6,6 +6,16 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.14
+
+**Fix**: (`facil.io`) fixed superfluous ping event.
+
+**Fix**: (`iodine_tcp`) fixed responsiveness to the argument name `timeout` (a spelling mistake was testing for `timout`).
+
+**Fix**: (`iodine_store`) fixed missing EOL marker in DEBUG messages when reporting iodine's GC guard activity.
+
+**Update**: (`iodine`) added support for dynamic (hot) connection callback switching.
+
 #### Change log v.0.7.13
 
 **Fix**: (`mustache`) added support for padding in template partials.

data/README.md

@@ -427,6 +427,8 @@ Iodine is written in C and allows some compile-time customizations, such as:
 
 * `FIO_ENGINE_POLL` - prefer the `poll` system call over `epoll` or `kqueue` (not recommended).
 
+* `FIO_LOG_LENGTH_LIMIT` - sets the limit on iodine's logging messages (uses stack memory, so limits must be reasonable. Defaults to 2048.
+
 These options can be used, for example, like so:
 
 ```bash
@@ -501,35 +503,99 @@ Iodine allows custom TCP/IP server authoring, for those cases where we need raw
 Here's a short and sweet echo server - No HTTP, just use `telnet`:
 
 ```ruby
-
 require 'iodine'
 
 # an echo protocol with asynchronous notifications.
 class EchoProtocol
   # `on_message` is an optional alternative to the `on_data` callback.
   # `on_message` has a 1Kb buffer that recycles itself for memory optimization.
-  def on_message buffer
+  def on_message client, buffer
     # writing will never block and will use a buffer written in C when needed.
-    write buffer
+    client.write buffer
     # close will be performed only once all the data in the write buffer
     # was sent. use `force_close` to close early.
-    close if buffer =~ /^bye[\r\n]/i
-    # use buffer.dup to save the data from being recycled once we return.
-    data = buffer.dup
-    # run asynchronous tasks with ease
-    run do
+    client.close if buffer =~ /^bye[\r\n]/i
+    # run asynchronous tasks using the thread pool
+    Iodine.run do
       sleep 1
-      puts "Echoed data: #{data}"
+      puts "Echoed data: #{buffer}"
     end
   end
 end
 
 # listen on port 3000 for the echo protocol.
-Iodine.listen 3000, EchoProtocol
-Iodine.threads = 1
-Iodine.processes = 1
+Iodine.listen(port: "3000") { EchoProtocol.new }
+Iodine.threads = 4
+Iodine.workers = 1
 Iodine.start
+```
+
+Or a nice plain text chat room (connect using `telnet` or `nc` ):
+
+```ruby
+require 'iodine'
 
+# a chat protocol with asynchronous notifications.
+class ChatProtocol
+  def initialize nickname = "guest"
+    @nickname = nickname
+  end
+  def on_open client
+    client.subscribe :chat
+    client.publish :chat, "#{@nickname} joined chat.\n"
+    client.timeout = 40
+  end
+  def on_close client
+    client.publish :chat, "#{@nickname} left chat.\n"
+  end
+  def on_shutdown client
+    client.write "Server is shutting down... try reconnecting later.\n"
+  end
+  def on_message client, buffer
+    if(buffer[-1] == "\n")
+      client.publish :chat, "#{@nickname}: #{buffer}"
+    else
+      client.publish :chat, "#{@nickname}: #{buffer}\n"
+    end
+    # close will be performed only once all the data in the outgoing buffer
+    client.close if buffer =~ /^bye[\r\n]/i
+  end
+  def ping client
+    client.write "(ping) Are you there, #{@nickname}...?\n"
+  end
+end
+
+#an initial login protocol
+class LoginProtocol
+  def on_open client
+    client.write "Enter nickname to log in to chat room:\n"
+    client.timeout = 10
+  end
+  def ping client
+    client.write "Time's up... goodbye.\n"
+    client.close
+  end
+  def on_message client, buffer
+    # validate nickname and switch connection callback to ChatProtocol
+    nickname = buffer.split("\n")[0]
+    while (nickname && nickname.length() > 0 && (nickname[-1] == '\n' || nickname[-1] == '\r'))
+      nickname = nickname.slice(0, nickname.length() -1)
+    end
+    if(nickname && nickname.length() > 0 && buffer.split("\n").length() == 1)
+      chat = ChatProtocol.new(nickname)
+      client.handler = chat
+    else
+      client.write "Nickname error, try again.\n"
+      on_open client
+    end
+  end
+end
+
+# listen on port 3000
+Iodine.listen(port: 3000) { LoginProtocol.new }
+Iodine.threads = 1
+Iodine.workers = 1
+Iodine.start
 ```
 
 ### Why not EventMachine?

data/ext/iodine/fio.c

@@ -2009,7 +2009,7 @@ static void mock_ping(intptr_t uuid, fio_protocol_s *protocol) {
 static void mock_ping2(intptr_t uuid, fio_protocol_s *protocol) {
   (void)protocol;
 
-  uuid_data(uuid).active = fio_last_tick().tv_sec;
+  touchfd(fio_uuid2fd(uuid));
   if (uuid_data(uuid).timeout == 255)
     return;
   protocol->ping = mock_ping;
@@ -2046,7 +2046,7 @@ static void deferred_on_shutdown(void *arg, void *arg2) {
       return;
     goto postpone;
   }
-  uuid_data(arg).active = fio_data->last_cycle.tv_sec;
+  touchfd(fio_uuid2fd(arg));
   uint8_t r = pr->on_shutdown ? pr->on_shutdown((intptr_t)arg, pr) : 0;
   if (r) {
     if (r == 255) {
@@ -2733,6 +2733,7 @@ ssize_t fio_write2_fn(intptr_t uuid, fio_write_args_s options) {
   fio_unlock(&uuid_data(uuid).sock_lock);
 
   if (was_empty) {
+    touchfd(fio_uuid2fd(uuid));
     fio_defer_push_urgent(deferred_on_ready, (void *)uuid, NULL);
   }
   return 0;
@@ -2893,6 +2894,7 @@ test_errno:
 
   return -1;
 flushed:
+  touchfd(fio_uuid2fd(uuid));
   fio_unlock(&uuid_data(uuid).sock_lock);
   return 1;
 }
@@ -3045,7 +3047,7 @@ static int fio_attach__internal(void *uuid_, void *protocol_) {
   fio_protocol_s *old_pr = uuid_data(uuid).protocol;
   uuid_data(uuid).open = 1;
   uuid_data(uuid).protocol = protocol;
-  uuid_data(uuid).active = fio_data->last_cycle.tv_sec;
+  touchfd(fio_uuid2fd(uuid));
   fio_unlock(&uuid_data(uuid).protocol_lock);
   if (old_pr) {
     fio_defer_push_task(deferred_on_close, (void *)uuid, old_pr);
@@ -3082,7 +3084,7 @@ void fio_attach_fd(int fd, fio_protocol_s *protocol) {
 /** Sets a timeout for a specific connection (only when running and valid). */
 void fio_timeout_set(intptr_t uuid, uint8_t timeout) {
   if (uuid_is_valid(uuid)) {
-    uuid_data(uuid).active = fio_data->last_cycle.tv_sec;
+    touchfd(fio_uuid2fd(uuid));
     uuid_data(uuid).timeout = timeout;
   } else {
     FIO_LOG_DEBUG("Called fio_timeout_set for invalid uuid %p", (void *)uuid);

data/ext/iodine/fio.h

@@ -180,6 +180,15 @@ Version and helper macros
 #define FIO_PUBSUB_SUPPORT 1
 #endif
 
+#ifndef FIO_LOG_LENGTH_LIMIT
+/**
+ * Since logging uses stack memory rather than dynamic allocation, it's memory
+ * usage must be limited to avoid exploding the stack. The following sets the
+ * memory used for a logging event.
+ */
+#define FIO_LOG_LENGTH_LIMIT 2048
+#endif
+
 #ifndef FIO_IGNORE_MACRO
 /**
  * This is used internally to ignore macros that shadow functions (avoiding
@@ -427,9 +436,10 @@ extern int FIO_LOG_LEVEL;
 #define FIO_LOG_PRINT(level, ...)                                              \
   do {                                                                         \
     if (level <= FIO_LOG_LEVEL) {                                              \
-      char tmp___log[1024];                                                    \
-      int len___log = snprintf(tmp___log, 1000, __VA_ARGS__);                  \
-      if (len___log <= 0 || len___log > 1000) {                                \
+      char tmp___log[FIO_LOG_LENGTH_LIMIT];                                    \
+      int len___log =                                                          \
+          snprintf(tmp___log, FIO_LOG_LENGTH_LIMIT - 2, __VA_ARGS__);          \
+      if (len___log <= 0 || len___log >= FIO_LOG_LENGTH_LIMIT - 2) {           \
         fwrite("ERROR: log line output too long (can't write).", 46, 1,        \
                stderr);                                                        \
         break;                                                                 \

data/ext/iodine/iodine_connection.c

@@ -319,6 +319,63 @@ static VALUE iodine_connection_env(VALUE self) {
   return Qnil;
 }
 
+/**
+ * Returns the client's current callback object.
+ */
+static VALUE iodine_connection_handler_get(VALUE self) {
+  iodine_connection_data_s *data = iodine_connection_validate_data(self);
+  if (!data) {
+    FIO_LOG_DEBUG("(iodine) requested connection handler for "
+                  "an invalid connection: %p",
+                  (void *)self);
+    return Qnil;
+  }
+  return data->info.handler;
+}
+
+// clang-format off
+/**
+ * Sets the client's callback object, so future events will use the new object's callbacks.
+ *
+ * @Note this will fire the `on_close` callback in the old handler and the `on_open` callback on the new handler. However, existing subscriptions will remain intact.
+ */
+static VALUE iodine_connection_handler_set(VALUE self, VALUE handler) {
+  // clang-format on
+  iodine_connection_data_s *data = iodine_connection_validate_data(self);
+  if (!data) {
+    FIO_LOG_DEBUG("(iodine) attempted to set a connection handler for "
+                  "an invalid connection: %p",
+                  (void *)self);
+    return Qnil;
+  }
+  if (handler == Qnil || handler == Qfalse) {
+    FIO_LOG_DEBUG(
+        "(iodine) called client.handler = nil, closing connection: %p",
+        (void *)self);
+    iodine_connection_close(self);
+    return Qnil;
+  }
+  if (data->info.handler != handler) {
+    uint8_t answers_on_open = (rb_respond_to(handler, on_open_id) != 0);
+    if(data->answers_on_close)
+      IodineCaller.call2(data->info.handler, on_close_id, 1, &self);
+    fio_lock(&data->lock);
+    data->info.handler = handler;
+    data->answers_on_open = answers_on_open,
+    data->answers_on_message = (rb_respond_to(handler, on_message_id) != 0),
+    data->answers_ping = (rb_respond_to(handler, ping_id) != 0),
+    data->answers_on_drained = (rb_respond_to(handler, on_drained_id) != 0),
+    data->answers_on_shutdown = (rb_respond_to(handler, on_shutdown_id) != 0),
+    data->answers_on_close = (rb_respond_to(handler, on_close_id) != 0),
+    fio_unlock(&data->lock);
+    if (answers_on_open) {
+      iodine_connection_fire_event(self, IODINE_CONNECTION_ON_OPEN, Qnil);
+    }
+    FIO_LOG_DEBUG("(iodine) switched handlers for connection: %p",
+                  (void *)self);
+  }
+  return handler;
+}
 /* *****************************************************************************
 Pub/Sub Callbacks (internal implementation)
 ***************************************************************************** */
@@ -837,6 +894,10 @@ void iodine_connection_init(void) {
                    1);
   rb_define_method(ConnectionKlass, "env", iodine_connection_env, 0);
 
+  rb_define_method(ConnectionKlass, "handler", iodine_connection_handler_get,
+                   0);
+  rb_define_method(ConnectionKlass, "handler=", iodine_connection_handler_set,
+                   1);
   rb_define_method(ConnectionKlass, "subscribe", iodine_pubsub_subscribe, -1);
   rb_define_method(ConnectionKlass, "unsubscribe", iodine_pubsub_unsubscribe,
                    1);

data/ext/iodine/iodine_store.c

@@ -65,7 +65,7 @@ static void storage_print(void) {
   fprintf(stderr, "Total of %" PRIuPTR " objects protected form GC\n", index);
   fprintf(stderr,
           "Storage uses %" PRIuPTR " Hash bins for %" PRIuPTR " objects\n"
-          "The largest collection was %zu objects.",
+          "The largest collection was %zu objects.\n",
           iodine_storage.capa, iodine_storage.count, iodine_storage_count_max);
   fio_unlock(&iodine_storage_lock);
 }

data/ext/iodine/iodine_tcp.c

@@ -2,6 +2,7 @@
 #include <ruby/encoding.h>
 #include <ruby/io.h>
 
+#define FIO_INCLUDE_STR
 #include "fio.h"
 
 /* *****************************************************************************
@@ -40,6 +41,7 @@ static void *iodine_tcp_on_data_in_GIL(void *b_) {
   iodine_buffer_s *b = b_;
   if (!b) {
     FIO_LOG_FATAL("(iodine->tcp/ip->on_data->GIL) WTF?!\n");
+    exit(-1);
   }
   VALUE data = IodineStore.add(rb_str_new(b->buffer, b->len));
   rb_enc_associate(data, IodineBinaryEncoding);
@@ -148,7 +150,7 @@ The {listen} method instructs iodine to listen to incoming connections using eit
 
 The method accepts a single Hash argument with the following optional keys:
 
-:port :: The port to listen to, deafults to 0 (using a Unix socket)
+:port :: The port to listen to, deafults to nil (using a Unix socket)
 :address :: The address to listen to, which could be a Unix Socket path as well as an IPv4 / IPv6 address. Deafults to 0.0.0.0 (or the IPv6 equivelant).
 :handler :: An object that answers the `call` method (i.e., a Proc).
 
@@ -217,6 +219,7 @@ static VALUE iodine_tcp_listen(VALUE self, VALUE args) {
   VALUE rb_port = rb_hash_aref(args, port_id);
   VALUE rb_address = rb_hash_aref(args, address_id);
   VALUE rb_handler = rb_hash_aref(args, handler_id);
+  fio_str_s port = FIO_STR_INIT;
   if (rb_handler == Qnil || rb_handler == Qfalse || rb_handler == Qtrue) {
     rb_need_block();
     rb_handler = rb_block_proc();
@@ -225,10 +228,19 @@ static VALUE iodine_tcp_listen(VALUE self, VALUE args) {
   if (rb_address != Qnil) {
     Check_Type(rb_address, T_STRING);
   }
+
   if (rb_port != Qnil) {
-    Check_Type(rb_port, T_STRING);
+    if (rb_port == Qfalse) {
+      fio_str_write_i(&port, 0);
+    } else if (RB_TYPE_P(rb_port, T_STRING))
+      fio_str_write(&port, RSTRING_PTR(rb_port), RSTRING_LEN(rb_port));
+    else if (RB_TYPE_P(rb_port, T_FIXNUM))
+      fio_str_write_i(&port, FIX2LONG(rb_port));
+    else
+      rb_raise(rb_eTypeError,
+               "The `port` property MUST be either a String or a Number");
   }
-  if (fio_listen(.port = (rb_port == Qnil ? NULL : StringValueCStr(rb_port)),
+  if (fio_listen(.port = fio_str_info(&port).data,
                  .address =
                      (rb_address == Qnil ? NULL : StringValueCStr(rb_address)),
                  .on_open = iodine_tcp_on_open,
@@ -269,6 +281,7 @@ static VALUE iodine_tcp_connect(VALUE self, VALUE args) {
   VALUE rb_handler = rb_hash_aref(args, handler_id);
   VALUE rb_timeout = rb_hash_aref(args, timeout_id);
   uint8_t timeout = 0;
+  fio_str_s port = FIO_STR_INIT;
   if (rb_handler == Qnil || rb_handler == Qfalse || rb_handler == Qtrue) {
     rb_raise(rb_eArgError, "A callback object (:handler) must be provided.");
   }
@@ -277,13 +290,21 @@ static VALUE iodine_tcp_connect(VALUE self, VALUE args) {
     Check_Type(rb_address, T_STRING);
   }
   if (rb_port != Qnil) {
-    Check_Type(rb_port, T_STRING);
+    if (rb_port == Qfalse) {
+      fio_str_write_i(&port, 0);
+    } else if (RB_TYPE_P(rb_port, T_STRING))
+      fio_str_write(&port, RSTRING_PTR(rb_port), RSTRING_LEN(rb_port));
+    else if (RB_TYPE_P(rb_port, T_FIXNUM))
+      fio_str_write_i(&port, FIX2LONG(rb_port));
+    else
+      rb_raise(rb_eTypeError,
+               "The `port` property MUST be either a String or a Number");
   }
   if (rb_timeout != Qnil) {
     Check_Type(rb_timeout, T_FIXNUM);
     timeout = NUM2USHORT(rb_timeout);
   }
-  fio_connect(.port = (rb_port == Qnil ? NULL : StringValueCStr(rb_port)),
+  fio_connect(.port = fio_str_info(&port).data,
               .address =
                   (rb_address == Qnil ? NULL : StringValueCStr(rb_address)),
               .on_connect = iodine_tcp_on_connect,
@@ -332,7 +353,7 @@ void iodine_init_tcp_connections(void) {
   port_id = IodineStore.add(rb_id2sym(rb_intern("port")));
   address_id = IodineStore.add(rb_id2sym(rb_intern("address")));
   handler_id = IodineStore.add(rb_id2sym(rb_intern("handler")));
-  timeout_id = IodineStore.add(rb_id2sym(rb_intern("timout")));
+  timeout_id = IodineStore.add(rb_id2sym(rb_intern("timeout")));
   on_closed_id = rb_intern("on_closed");
 
   IodineBinaryEncoding = rb_enc_find("binary");

data/ext/iodine/mustache_parser.h

@@ -8,47 +8,6 @@ Feel free to copy, use and enjoy according to the license provided.
 /**
  * A mustache parser using a callback systems that allows this implementation to
  * be framework agnostic (i.e., can be used with any JSON library).
- *
- * When including the mustache parser within an iumplementation file,
- * `INCLUDE_MUSTACHE_IMPLEMENTATION` must be defined as 1. This allows the
- * header's types to be exposed within a containing header.
- *
- * The API has three functions:
- *
- * 1. `mustache_load` loads a template file, converting it to instruction data.
- * 2. `mustache_build` calls any callbacks according to the loaded instructions.
- * 3. `mustache_free` frees the instruction and data memory (the template).
- *
- * The template is loaded and converted to an instruction array using
- * `mustache_load`. This loads any nested templates / partials as well.
- *
- * The resulting instruction array (`mustache_s *`) is composed of three memory
- * segments: header segment, instruction array segment and data segment.
- *
- * The instruction array (`mustache_s *`) can be used to build actual output
- * data using the `mustache_build` function.
- *
- * The `mustache_build` function accepts two opaque pointers for user data
- * (`udata1` and `udata2`) that can be used by the callbacks for data input and
- * data output.
- *
- * The `mustache_build` function is thread safe and many threads can build
- * content based on the same template.
- *
- * While the build function is performed, the following callback might be
- * called:
- *
- * * `mustache_on_arg` - called to output an argument's value .
- * * `mustache_on_text` - called to output raw text.
- * * `mustache_on_section_test` - called when a section is tested for validity.
- * * `mustache_on_section_start` - called when entering a named section.
- * * `mustache_on_formatting_error` - called when a formatting error occurred.
- *
- * Once the template is no longer needed, it's easy to free the template using
- * the `mustache_free` function (which, at the moment, simply calls `free`).
- *
- * For details about mustache templating scheme, see: https://mustache.github.io
- *
  */
 #define H_MUSTACHE_LOADR_H
 
@@ -524,26 +483,28 @@ static inline int mustache__write_padding(mustache__builder_stack_s *s) {
  */
 static int mustache__write_escaped(mustache__builder_stack_s *s, char *text,
                                    uint32_t len) {
+#define MUSTACHE_ESCAPE_BUFFER_SIZE 4096
   /** 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),"};"
+        a = (0..255).to_a.map {|i| i.chr }
+        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[] = {
+  static const 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;",
@@ -576,7 +537,7 @@ puts "static char *html_escape_strs[] = {", a.to_s.slice(1..-2) ,"};",
       "\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[] = {
+  static const 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,
@@ -588,7 +549,7 @@ puts "static char *html_escape_strs[] = {", a.to_s.slice(1..-2) ,"};",
       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];
+  char buffer[MUSTACHE_ESCAPE_BUFFER_SIZE];
   size_t pos = 0;
   const char *end = text + len;
   while (text < end) {
@@ -604,7 +565,7 @@ puts "static char *html_escape_strs[] = {", a.to_s.slice(1..-2) ,"};",
       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) {
+      if (pos >= (MUSTACHE_ESCAPE_BUFFER_SIZE - 6)) {
         buffer[pos] = 0;
         if (mustache_on_text(&s->stack[s->index].sec, buffer, pos) == -1)
           return -1;
@@ -619,6 +580,7 @@ puts "static char *html_escape_strs[] = {", a.to_s.slice(1..-2) ,"};",
       return -1;
   }
   return 0;
+#undef MUSTACHE_ESCAPE_BUFFER_SIZE
 }
 /**
  * This helper function should be used to write text to the output

data/lib/iodine/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.13
+  version: 0.7.14
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-07 00:00:00.000000000 Z
+date: 2018-12-12 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.13.
+post_install_message: 'Thank you for installing Iodine 0.7.14.
 
 '
 rdoc_options: []