nyara 0.0.1.pre.5 → 0.0.1.pre.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ff97920b70aa73d175c0c11ceabd1d2117d680da
-  data.tar.gz: 37bb1733ddfafef3a1ce806e58e1ddf145396a15
+  metadata.gz: 4923242f45af2bfc9d06879f83c200d10379f89b
+  data.tar.gz: 7a03f851beecfb9e5846bd17adf3b15efe91968b
 SHA512:
-  metadata.gz: dabf49a57dd4c1e91693020c699e5dcb9a5726663af573a162d8c1df44d712c0ac4894b15e943010e5259488746d4da117d98c127563b7a75905813dcc2bceb5
-  data.tar.gz: 636bbcd0ab74719cb7feb9c93891dc04287c3445eb19465c8bb232495b935964b7e4f9da582e6faed3a33f5d6be14f7410b9534096832692cbafcda8ee35ab8e
+  metadata.gz: 3ffe022bf0b05d95238fddcf4bf2fdb998c23e8490d31eec5154bd011034eb058fb2fd6ca99dcc37aeee1282102f6cb924e61fe20eeecc81f0ed50d903762186
+  data.tar.gz: cf2fe6b094478f9ed04c96e940e2075a019908abafb7fbf5eb255e66c91afa80dd5efea3b4c9d943f6d27a6a18f966b17b116e1664552c658264c7abda26fe69

data/example/factorial.rb

@@ -0,0 +1,19 @@
+require 'nyara'
+
+get '/factorial(%u)' do |n|
+  redirect_to '#product', 1, n
+end
+
+meta '#product'
+get '/%u*factorial(%u)' do |product, n|
+  if n == 0
+    redirect_to '#result', product
+  else
+    redirect_to '#product', product * n, n - 1
+  end
+end
+
+meta '#result'
+get '/%u' do |result|
+  send_string result
+end

data/ext/accept.c

@@ -44,7 +44,7 @@ static VALUE trim_space_and_truncate(volatile VALUE str) {
     // todo log this exception
     olen = ACCEPT_MAX;
   }
-  str = rb_str_new(RSTRING_PTR(str), olen);
+  str = rb_enc_str_new(RSTRING_PTR(str), olen, u8_encoding);
   char* s = RSTRING_PTR(str);
   long len = 0;
   for (long i = 0; i < olen; i++) {
@@ -99,7 +99,7 @@ static void parse_seg(const char* s, long len, VALUE out) {
   VALUE* out_ptr = RARRAY_PTR(out);
   long out_len = RARRAY_LEN(out); // note this len is +1
   memmove(out_ptr + pos + 1, out_ptr + pos, sizeof(VALUE) * (out_len - pos - 1));
-  rb_ary_store(out, pos, rb_str_new(s, len));
+  rb_ary_store(out, pos, rb_enc_str_new(s, len, u8_encoding));
 }
 
 VALUE ext_parse_accept_value(VALUE _, volatile VALUE str) {

data/ext/event.c

@@ -18,10 +18,9 @@ extern VALUE rb_obj_reveal(VALUE obj, VALUE klass);
 #define ETYPE_CONNECT 2
 #define MAX_E 1024
 static void loop_body(int fd, int etype);
-static int qfd;
+static int qfd = 0;
 
-#define MAX_RECEIVE_DATA 65536
-// * 4
+#define MAX_RECEIVE_DATA 65536 * 2
 static char received_data[MAX_RECEIVE_DATA];
 extern http_parser_settings nyara_request_parse_settings;
 
@@ -40,17 +39,6 @@ static VALUE sym_reading;
 static VALUE sym_sleep;
 static Request* curr_request;
 
-static void _set_nonblock(int fd) {
-  int flags;
-
-  if ((flags = fcntl(fd, F_GETFL)) == -1) {
-    rb_sys_fail("fcntl(F_GETFL)");
-  }
-  if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
-    rb_sys_fail("fcntl(F_SETFL,O_NONBLOCK)");
-  }
-}
-
 static VALUE _fiber_func(VALUE _, VALUE args) {
   VALUE instance = rb_ary_pop(args);
   VALUE meth = rb_ary_pop(args);
@@ -97,10 +85,12 @@ static void _handle_request(VALUE request) {
       rb_ary_push(result.args, rb_class_new_instance(1, &(p->self), result.controller));
       // result.args is on stack, no need to worry gc
       p->fiber = rb_fiber_new(_fiber_func, result.args);
+      p->instance = RARRAY_PTR(result.args)[RARRAY_LEN(result.args) - 1];
       p->scope = result.scope;
       p->format = result.format;
       p->response_header = rb_class_new_instance(0, NULL, nyara_header_hash_class);
       p->response_header_extra_lines = rb_ary_new();
+      nyara_request_init_env(request);
     } else {
       rb_funcall(p->self, id_not_found, 0);
       nyara_detach_fd(p->fd);
@@ -113,9 +103,9 @@ static void _handle_request(VALUE request) {
   VALUE state = rb_fiber_resume(p->fiber, 0, NULL);
   if (state == Qnil) { // _fiber_func always returns Qnil
     // terminated (todo log raised error ?)
-    nyara_request_term_close(request, false);
+    nyara_request_term_close(request);
   } else if (state == sym_term_close) {
-    nyara_request_term_close(request, true);
+    nyara_request_term_close(request);
   } else if (state == sym_writing) {
     // do nothing
   } else if (state == sym_reading) {
@@ -131,7 +121,7 @@ static void loop_body(int fd, int etype) {
     case ETYPE_CAN_ACCEPT: {
       int cfd = accept(fd, NULL, NULL);
       if (cfd > 0) {
-        _set_nonblock(cfd);
+        nyara_set_nonblock(cfd);
         ADD_E(cfd, ETYPE_HANDLE_REQUEST);
       }
       break;
@@ -176,7 +166,7 @@ static VALUE ext_init_queue(VALUE _) {
 
 static VALUE ext_run_queue(VALUE _, VALUE v_fd) {
   int fd = FIX2INT(v_fd);
-  _set_nonblock(fd);
+  nyara_set_nonblock(fd);
   ADD_E(fd, ETYPE_CAN_ACCEPT);
 
   LOOP_E();
@@ -187,21 +177,32 @@ static VALUE ext_request_sleep(VALUE _, VALUE request) {
   Request* p;
   Data_Get_Struct(request, Request, p);
 
+  p->sleeping = true;
+  if (!qfd) {
+    // we are in a test
+    return Qnil;
+  }
+
   VALUE* v_fds = RARRAY_PTR(p->watched_fds);
   long v_fds_len = RARRAY_LEN(p->watched_fds);
   for (long i = 0; i < v_fds_len; i++) {
     DEL_E(FIX2INT(v_fds[i]));
   }
   DEL_E(p->fd);
-  p->sleeping = true;
   return Qnil;
 }
 
 static VALUE ext_request_wakeup(VALUE _, VALUE request) {
-  // NOTE should not use current_request
+  // NOTE should not use curr_request
   Request* p;
   Data_Get_Struct(request, Request, p);
 
+  p->sleeping = false;
+  if (!qfd) {
+    // we are in a test
+    return Qnil;
+  }
+
   VALUE* v_fds = RARRAY_PTR(p->watched_fds);
   long v_fds_len = RARRAY_LEN(p->watched_fds);
   for (long i = 0; i < v_fds_len; i++) {
@@ -213,7 +214,7 @@ static VALUE ext_request_wakeup(VALUE _, VALUE request) {
 
 static VALUE ext_set_nonblock(VALUE _, VALUE v_fd) {
   int fd = FIX2INT(v_fd);
-  _set_nonblock(fd);
+  nyara_set_nonblock(fd);
   return Qnil;
 }
 
@@ -297,6 +298,27 @@ static VALUE ext_fd_recv(VALUE _, VALUE v_fd, VALUE v_len, VALUE v_flags) {
   return str;
 }
 
+// (for test) run request handler, read from associated fd and write to it
+static VALUE ext_handle_request(VALUE _, VALUE request) {
+  Request* p;
+  Data_Get_Struct(request, Request, p);
+
+  while (p->fiber == Qnil || rb_fiber_alive_p(p->fiber)) {
+    _handle_request(request);
+    // stop if no more to read
+    // NOTE this condition is sufficient to terminate handle, because
+    // - there's no connect yield during test
+    // - there's no view pause yield up to _handle_request
+    if (!p->sleeping) {
+      char buf[1];
+      if (recv(p->fd, buf, 1, MSG_PEEK) <= 0) {
+        break;
+      }
+    }
+  }
+  return p->instance;
+}
+
 void Init_event(VALUE ext) {
   fd_request_map = rb_hash_new();
   rb_gc_register_mark_object(fd_request_map);
@@ -311,12 +333,15 @@ void Init_event(VALUE ext) {
   rb_define_singleton_method(ext, "init_queue", ext_init_queue, 0);
   rb_define_singleton_method(ext, "run_queue", ext_run_queue, 1);
 
-  rb_define_singleton_method(ext, "request_sleep", ext_request_sleep, 0);
-  rb_define_singleton_method(ext, "request_wakeup", ext_request_wakeup, 0);
+  rb_define_singleton_method(ext, "request_sleep", ext_request_sleep, 1);
+  rb_define_singleton_method(ext, "request_wakeup", ext_request_wakeup, 1);
 
   // fd operations
   rb_define_singleton_method(ext, "set_nonblock", ext_set_nonblock, 1);
   rb_define_singleton_method(ext, "fd_watch", ext_fd_watch, 1);
   rb_define_singleton_method(ext, "fd_send", ext_fd_send, 3);
   rb_define_singleton_method(ext, "fd_recv", ext_fd_recv, 3);
+
+  // for test
+  rb_define_singleton_method(ext, "handle_request", ext_handle_request, 1);
 }

data/ext/extconf.rb

@@ -24,6 +24,8 @@ have_epoll = have_func('epoll_create', 'sys/epoll.h')
 abort('no kqueue nor epoll') if !have_kqueue and !have_epoll
 $defs << "-DNDEBUG -D#{have_epoll ? 'HAVE_EPOLL' : 'HAVE_KQUEUE'}"
 
+have_func('rb_ary_new_capa', 'ruby.h')
+
 tweak_include
 tweak_cflags
 create_makefile 'nyara'

data/ext/hashes.c

@@ -2,6 +2,7 @@
 
 #include "nyara.h"
 #include <ruby/st.h>
+#include "inc/str_intern.h"
 
 VALUE nyara_param_hash_class;
 VALUE nyara_header_hash_class;
@@ -69,7 +70,7 @@ static VALUE header_hash_tidy_key(VALUE key) {
     key = rb_sym_to_s(key);
   } else {
     Check_Type(key, T_STRING);
-    key = rb_str_new(RSTRING_PTR(key), RSTRING_LEN(key));
+    key = rb_enc_str_new(RSTRING_PTR(key), RSTRING_LEN(key), u8_encoding);
   }
   nyara_headerlize(key);
   return key;
@@ -83,7 +84,7 @@ static VALUE header_hash_key_p(VALUE self, VALUE key) {
   return nyara_rb_hash_has_key(self, header_hash_tidy_key(key)) ? Qtrue : Qfalse;
 }
 
-ID id_to_s;
+static ID id_to_s;
 static VALUE header_hash_aset(VALUE self, VALUE key, VALUE value) {
   key = header_hash_tidy_key(key);
   if (TYPE(value) != T_STRING) {
@@ -93,7 +94,7 @@ static VALUE header_hash_aset(VALUE self, VALUE key, VALUE value) {
   return rb_hash_aset(self, key, value);
 }
 
-int header_hash_merge_func(VALUE k, VALUE v, VALUE self_st) {
+static int header_hash_merge_func(VALUE k, VALUE v, VALUE self_st) {
   st_table* t = (st_table*)self_st;
   if (!st_is_member(t, k)) {
     st_insert(t, (st_data_t)k, (st_data_t)v);
@@ -110,6 +111,29 @@ static VALUE header_hash_reverse_merge_bang(VALUE self, VALUE other) {
   return self;
 }
 
+static int header_hash_serialize_func(VALUE k, VALUE v, VALUE arr) {
+  long klen = RSTRING_LEN(k);
+  long vlen = RSTRING_LEN(v);
+  long capa = klen + vlen + 4;
+  volatile VALUE s = rb_str_buf_new(capa);
+  sprintf(RSTRING_PTR(s), "%.*s: %.*s\r\n", (int)klen, RSTRING_PTR(k), (int)vlen, RSTRING_PTR(v));
+  STR_SET_LEN(s, capa);
+  rb_enc_associate(s, u8_encoding);
+  rb_ary_push(arr, s);
+  return ST_CONTINUE;
+}
+
+static VALUE header_hash_serialize(VALUE self) {
+# ifdef HAVE_RB_ARY_NEW_CAPA
+  long size = (!RHASH(self)->ntbl ? RHASH(self)->ntbl->num_entries : 0);
+  volatile VALUE arr = rb_ary_new_capa(size);
+# else
+  volatile VALUE arr = rb_ary_new();
+# endif
+  rb_hash_foreach(self, header_hash_serialize_func, arr);
+  return arr;
+}
+
 void Init_hashes(VALUE nyara) {
   id_to_s = rb_intern("to_s");
 
@@ -125,6 +149,7 @@ void Init_hashes(VALUE nyara) {
   rb_define_method(nyara_header_hash_class, "key?", header_hash_key_p, 1);
   rb_define_method(nyara_header_hash_class, "[]=", header_hash_aset, 2);
   rb_define_method(nyara_header_hash_class, "reverse_merge!", header_hash_reverse_merge_bang, 1);
+  rb_define_method(nyara_header_hash_class, "serialize", header_hash_serialize, 0);
 
   // for internal use
   rb_define_method(nyara_header_hash_class, "_aset", rb_hash_aset, 2);

data/ext/http-parser/http_parser.h

@@ -24,6 +24,7 @@
 extern "C" {
 #endif
 
+/* Also update SONAME in the Makefile whenever you change these. */
 #define HTTP_PARSER_VERSION_MAJOR 2
 #define HTTP_PARSER_VERSION_MINOR 1
 

data/ext/nyara.c

@@ -4,6 +4,20 @@
 #include <ruby/io.h>
 #include <sys/socket.h>
 #include <sys/resource.h>
+#include <sys/fcntl.h>
+
+rb_encoding* u8_encoding;
+
+void nyara_set_nonblock(int fd) {
+  int flags;
+
+  if ((flags = fcntl(fd, F_GETFL)) == -1) {
+    rb_sys_fail("fcntl(F_GETFL)");
+  }
+  if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
+    rb_sys_fail("fcntl(F_SETFL,O_NONBLOCK)");
+  }
+}
 
 static void set_fd_limit(int nofiles) {
   struct rlimit rlim;
@@ -17,11 +31,12 @@ static void set_fd_limit(int nofiles) {
 }
 
 void Init_nyara() {
+  u8_encoding = rb_utf8_encoding();
   set_fd_limit(20000);
 
   VALUE nyara = rb_define_module("Nyara");
 # include "inc/version.inc"
-  rb_const_set(nyara, rb_intern("VERSION"), rb_str_new2(NYARA_VERSION));
+  rb_const_set(nyara, rb_intern("VERSION"), rb_enc_str_new(NYARA_VERSION, strlen(NYARA_VERSION), u8_encoding));
 
   // utils: hashes
   Init_hashes(nyara);
@@ -31,7 +46,7 @@ void Init_nyara() {
   rb_const_set(nyara, rb_intern("HTTP_METHODS"), method_map);
   VALUE tmp_key = Qnil;
 # define METHOD_STR2NUM(n, name, string) \
-    tmp_key = rb_str_new2(#string);\
+    tmp_key = rb_enc_str_new(#string, strlen(#string), u8_encoding);\
     OBJ_FREEZE(tmp_key);\
     rb_hash_aset(method_map, tmp_key, INT2FIX(n));
   HTTP_METHOD_MAP(METHOD_STR2NUM);
@@ -43,7 +58,7 @@ void Init_nyara() {
   rb_const_set(nyara, rb_intern("HTTP_STATUS_CODES"), status_map);
   VALUE tmp_value = Qnil;
 # define STATUS_DESC(status, desc) \
-    tmp_value = rb_str_new2(desc);\
+    tmp_value = rb_enc_str_new(desc, strlen(desc), u8_encoding);\
     OBJ_FREEZE(tmp_value);\
     rb_hash_aset(status_map, INT2FIX(status), tmp_value);
   HTTP_STATUS_CODES(STATUS_DESC);
@@ -54,6 +69,8 @@ void Init_nyara() {
   Init_accept(ext);
   Init_mime(ext);
   Init_request(nyara, ext);
+  Init_request_parse(nyara);
+  Init_test_response(nyara);
   Init_event(ext);
   Init_route(nyara, ext);
   Init_url_encoded(ext);

data/ext/nyara.h

@@ -1,8 +1,9 @@
 #pragma once
 #include <ruby.h>
+#include <ruby/encoding.h>
 #include <stdbool.h>
 #include <http_parser.h>
-#include "inc/status_codes.inc"
+#include "inc/status_codes.h"
 
 #ifdef DEBUG
 #undef NDEBUG
@@ -21,7 +22,12 @@ void Init_request_parse(VALUE nyara);
 /* request.c */
 void Init_request(VALUE nyara, VALUE ext);
 VALUE nyara_request_new(int fd);
-void nyara_request_term_close(VALUE request, bool write_last_chunk);
+void nyara_request_init_env(VALUE request);
+void nyara_request_term_close(VALUE request);
+
+
+/* test_response.c */
+void Init_test_response(VALUE nyara);
 
 
 /* url_encoded.c */
@@ -63,3 +69,8 @@ typedef struct {
 
 extern void Init_route(VALUE nyara, VALUE ext);
 extern RouteResult nyara_lookup_route(enum http_method method_num, VALUE vpath, VALUE accept_arr);
+
+
+/* nyara.c */
+void nyara_set_nonblock(int fd);
+extern rb_encoding* u8_encoding;

data/ext/request.c

@@ -1,13 +1,12 @@
 /* request parsing and request object */
 
 #include "nyara.h"
-#include <ruby/encoding.h>
 #include "request.h"
 
 static VALUE str_html;
-static rb_encoding* u8_encoding;
 static VALUE request_class;
 static VALUE sym_writing;
+static VALUE str_transfer_encoding;
 
 #define P \
   Request* p;\
@@ -26,10 +25,18 @@ static void request_mark(void* pp) {
     rb_gc_mark_maybe(p->query);
     rb_gc_mark_maybe(p->last_field);
     rb_gc_mark_maybe(p->last_value);
+    rb_gc_mark_maybe(p->last_part);
+    rb_gc_mark_maybe(p->body);
+
+    rb_gc_mark_maybe(p->cookie);
+    rb_gc_mark_maybe(p->session);
+    rb_gc_mark_maybe(p->flash);
+
     rb_gc_mark_maybe(p->response_content_type);
     rb_gc_mark_maybe(p->response_header);
     rb_gc_mark_maybe(p->response_header_extra_lines);
     rb_gc_mark_maybe(p->watched_fds);
+    rb_gc_mark_maybe(p->instance);
   }
 }
 
@@ -38,6 +45,11 @@ static void request_free(void* pp) {
   if (p) {
     if (p->fd) {
       nyara_detach_fd(p->fd);
+      p->fd = 0;
+    }
+    if (p->mparser) {
+      multipart_parser_free(p->mparser);
+      p->mparser = NULL;
     }
     xfree(p);
   }
@@ -66,12 +78,20 @@ static Request* _request_alloc() {
   p->query = query;
   p->last_field = Qnil;
   p->last_value = Qnil;
+  p->last_part = Qnil;
+  p->body = Qnil;
+
+  p->cookie = Qnil;
+  p->session = Qnil;
+  p->flash = Qnil;
+
   p->response_content_type = Qnil;
   p->response_header = Qnil;
   p->response_header_extra_lines = Qnil;
 
   volatile VALUE watched_fds = rb_ary_new();
   p->watched_fds = watched_fds;
+  p->instance = Qnil;
 
   p->sleeping = false;
 
@@ -85,20 +105,48 @@ VALUE nyara_request_new(int fd) {
   return p->self;
 }
 
-void nyara_request_term_close(VALUE self, bool write_last_chunk) {
+void nyara_request_init_env(VALUE self) {
+  static VALUE cookie_mod = Qnil;
+  static VALUE session_mod = Qnil;
+  static VALUE flash_class = Qnil;
+  static ID id_decode = 0;
+  if (cookie_mod == Qnil) {
+    VALUE nyara = rb_const_get(rb_cModule, rb_intern("Nyara"));
+    cookie_mod = rb_const_get(nyara, rb_intern("Cookie"));
+    session_mod = rb_const_get(nyara, rb_intern("Session"));
+    flash_class = rb_const_get(nyara, rb_intern("Flash"));
+    id_decode = rb_intern("decode");
+  }
+
+  P;
+  p->cookie = rb_funcall(cookie_mod, id_decode, 1, p->header);
+  p->session = rb_funcall(session_mod, id_decode, 1, p->cookie);
+  p->flash = rb_class_new_instance(1, &p->session, flash_class);
+}
+
+void nyara_request_term_close(VALUE self) {
   P;
-  if (write_last_chunk || p->status == 200) {
-    // usually this succeeds, while not, it doesn't matter cause we are closing it
-    if (write(p->fd, "0\r\n\r\n", 5)) {
+  VALUE transfer_enc = rb_hash_aref(p->response_header, str_transfer_encoding);
+  if (TYPE(transfer_enc) == T_STRING) {
+    if (RSTRING_LEN(transfer_enc) == 7) {
+      if (strncmp(RSTRING_PTR(transfer_enc), "chunked", 7) == 0) {
+        // usually this succeeds, while not, it doesn't matter cause we are closing it
+        if (write(p->fd, "0\r\n\r\n", 5)) {
+        }
+      }
     }
   }
-  nyara_detach_fd(p->fd);
-  p->fd = 0;
+  if (p->fd) {
+    nyara_detach_fd(p->fd);
+    p->fd = 0;
+  }
 }
 
 static VALUE request_http_method(VALUE self) {
   P;
-  return rb_str_new2(http_method_str(p->method));
+  // todo reduce allocation
+  const char* str = http_method_str(p->method);
+  return rb_enc_str_new(str, strlen(str), u8_encoding);
 }
 
 static VALUE request_header(VALUE self) {
@@ -136,6 +184,21 @@ static VALUE request_format(VALUE self) {
   return p->format == Qnil ? str_html : p->format;
 }
 
+static VALUE request_cookie(VALUE self) {
+  P;
+  return p->cookie;
+}
+
+static VALUE request_session(VALUE self) {
+  P;
+  return p->session;
+}
+
+static VALUE request_flash(VALUE self) {
+  P;
+  return p->flash;
+}
+
 static VALUE request_status(VALUE self) {
   P;
   return INT2FIX(p->status);
@@ -228,11 +291,17 @@ static VALUE ext_request_new(VALUE _) {
 
 static VALUE ext_request_set_fd(VALUE _, VALUE self, VALUE vfd) {
   P;
-  p->fd = NUM2INT(vfd);
+  int fd = NUM2INT(vfd);
+  if (fd) {
+    fd = dup(fd);
+    nyara_set_nonblock(fd);
+    p->fd = fd;
+  }
   return Qnil;
 }
 
-// set internal attrs in the request object
+// set internal attrs in the request object<br>
+// method_num is required, others are optional
 static VALUE ext_request_set_attrs(VALUE _, VALUE self, VALUE attrs) {
 # define ATTR(key) rb_hash_delete(attrs, ID2SYM(rb_intern(key)))
 # define HEADER_HASH_NEW rb_class_new_instance(0, NULL, nyara_header_hash_class)
@@ -249,6 +318,10 @@ static VALUE ext_request_set_attrs(VALUE _, VALUE self, VALUE attrs) {
   p->scope                       = ATTR("scope");
   p->header                      = ATTR("header");
   p->format                      = ATTR("format");
+  p->body                        = ATTR("body");
+  p->cookie                      = ATTR("cookie");
+  p->session                     = ATTR("session");
+  p->flash                       = ATTR("flash");
   p->response_header             = ATTR("response_header");
   p->response_header_extra_lines = ATTR("response_header_extra_lines");
 
@@ -266,11 +339,12 @@ static VALUE ext_request_set_attrs(VALUE _, VALUE self, VALUE attrs) {
 }
 
 void Init_request(VALUE nyara, VALUE ext) {
-  str_html = rb_str_new2("html");
+  str_html = rb_enc_str_new("html", strlen("html"), u8_encoding);
   OBJ_FREEZE(str_html);
   rb_gc_register_mark_object(str_html);
-  u8_encoding = rb_utf8_encoding();
   sym_writing = ID2SYM(rb_intern("writing"));
+  str_transfer_encoding = rb_enc_str_new("Transfer-Encoding", strlen("Transfer-Encoding"), u8_encoding);
+  rb_gc_register_mark_object(str_transfer_encoding);
 
   // request
   request_class = rb_define_class_under(nyara, "Request", rb_cObject);
@@ -282,6 +356,9 @@ void Init_request(VALUE nyara, VALUE ext) {
   rb_define_method(request_class, "path_with_query", request_path_with_query, 0);
   rb_define_method(request_class, "accept", request_accept, 0);
   rb_define_method(request_class, "format", request_format, 0);
+  rb_define_method(request_class, "cookie", request_cookie, 0);
+  rb_define_method(request_class, "session", request_session, 0);
+  rb_define_method(request_class, "flash", request_flash, 0);
 
   rb_define_method(request_class, "status", request_status, 0);
   rb_define_method(request_class, "response_content_type", request_response_content_type, 0);

data/ext/request.h

@@ -3,9 +3,7 @@
 #include "nyara.h"
 #include <multipart_parser.h>
 #include <errno.h>
-#ifndef write
 #include <unistd.h>
-#endif
 
 enum ParseState {
   PS_INIT, PS_HEADERS_COMPLETE, PS_MESSAGE_COMPLETE, PS_ERROR
@@ -33,6 +31,13 @@ typedef struct {
   VALUE query;
   VALUE last_field;
   VALUE last_value;
+  VALUE last_part; // multipart last header or body
+  VALUE body; // string when single part, array when multipart
+
+  // env
+  VALUE cookie;
+  VALUE session;
+  VALUE flash;
 
   // response
   VALUE response_content_type;
@@ -40,6 +45,7 @@ typedef struct {
   VALUE response_header_extra_lines;
 
   VALUE watched_fds;
+  VALUE instance;
 
   bool sleeping;
 } Request;