nyara 0.0.1.pre → 0.0.1.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cb0049e820e49ff09f09423ecce778a56834fd82
-  data.tar.gz: 30a2651c518f2f7c3db0581396b52ef1655c4ce8
+  metadata.gz: 924fd91c47d5907d59fac0bef09fa645ed552188
+  data.tar.gz: f3f74e666325973cc8a1938eb91ce9a91102ed99
 SHA512:
-  metadata.gz: b43a204aa71c4a3b1f2a94b21ee87be98d0e78348e93d9ba7439df27cb383cced9d1135e3ac1ce47e6bd7479d8542456360ce1c297399eaa77cfcce41871ea79
-  data.tar.gz: 955570020bccc660c5d7ae82ecad85c821988f92ebc80b4beffaa84575a1b487ccecf07be51d6041c7a88af62565e6a61260bec11009dacaf0c88814decedca7
+  metadata.gz: 88025bd5ad58a09e1c53e239572dbbc78039a5f93de7e52475074f4da6415f6616c39b59235f24fb8e8f30bd66e3530e66f48829369edab085ea139edd837d36
+  data.tar.gz: 8e602eb1355aeb7a4abd81f9e7bfe5cb586f3d697eecfaba5546ae40f5aa7d6e119ea93d1937198c2805ca5bb36825cc73cae93592cb5b844a759f244b27734e

data/ext/accept.c

@@ -45,7 +45,7 @@ static void qarray_delete(QArray* qa) {
   xfree(qa->qs);
 }
 
-static VALUE trim_space(VALUE str) {
+static VALUE trim_space(volatile VALUE str) {
   long olen = RSTRING_LEN(str);
   str = rb_str_new(RSTRING_PTR(str), olen);
   char* s = RSTRING_PTR(str);
@@ -105,7 +105,7 @@ static void parse_seg(const char* s, long len, VALUE out, QArray* qa) {
   rb_ary_store(out, pos, rb_str_new(s, len));
 }
 
-VALUE ext_parse_accept_value(VALUE _, VALUE str) {
+VALUE ext_parse_accept_value(VALUE _, volatile VALUE str) {
   if (str == Qnil) {
     return rb_ary_new();
   }

data/ext/hashes.c

@@ -66,9 +66,10 @@ void nyara_headerlize(VALUE str) {
 static VALUE header_hash_tidy_key(VALUE key) {
   if (TYPE(key) == T_SYMBOL) {
     key = rb_sym_to_s(key);
+  } else {
+    Check_Type(key, T_STRING);
+    key = rb_str_new(RSTRING_PTR(key), RSTRING_LEN(key));
   }
-  Check_Type(key, T_STRING);
-  key = rb_str_new(RSTRING_PTR(key), RSTRING_LEN(key));
   nyara_headerlize(key);
   return key;
 }

data/ext/mime.c

@@ -12,7 +12,9 @@ static const char* _strnchr(const char* s, long len, char c) {
   return NULL;
 }
 
-static bool mime_match_seg(const char* m1_ptr, long m1_len, VALUE v1, VALUE v2) {
+// m1, m2: request
+// v1, v2: action
+static bool _mime_match_seg(const char* m1_ptr, long m1_len, VALUE v1, VALUE v2) {
   const char* m2_ptr = _strnchr(m1_ptr, m1_len, '/');
   long m2_len;
   if (m2_ptr) {
@@ -31,21 +33,6 @@ static bool mime_match_seg(const char* m1_ptr, long m1_len, VALUE v1, VALUE v2)
 # define EQL_STAR(s, len) (len == 1 && s[0] == '*')
 # define EQL(s1, len1, s2, len2) (len1 == len2 && strncmp(s1, s2, len1) == 0)
 
-  /*
-  if m1 == '*'
-    if m2.nil? || m2 == '*'
-      return true
-    elsif m2 == v2
-      return true
-    else
-      return false
-    end
-  end
-  return false if v1 != m1
-  return true if m2.nil? || m2 == '*'
-  m2 == v2
-  */
-
   if (EQL_STAR(m1_ptr, m1_len)) {
     if (m2_len == 0 || EQL_STAR(m2_ptr, m2_len)) {
       return true;
@@ -69,30 +56,32 @@ static bool mime_match_seg(const char* m1_ptr, long m1_len, VALUE v1, VALUE v2)
 
 // for test
 static VALUE ext_mime_match_seg(VALUE self, VALUE m, VALUE v1, VALUE v2) {
-  if (mime_match_seg(RSTRING_PTR(m), RSTRING_LEN(m), v1, v2)) {
+  if (_mime_match_seg(RSTRING_PTR(m), RSTRING_LEN(m), v1, v2)) {
     return Qtrue;
   } else {
     return Qfalse;
   }
 }
 
-// returns matched ext or nil
-VALUE ext_mime_match(VALUE self, VALUE request_accept, VALUE accept_mimes) {
+// +request_accept+ is an array of mime types
+// +action_accept+ is an array of split mime type and format, e.g. +[['application', 'javascript', 'js']]+
+// returns matched format or nil
+VALUE ext_mime_match(VALUE self, VALUE request_accept, VALUE action_accept) {
   Check_Type(request_accept, T_ARRAY);
-  Check_Type(accept_mimes, T_ARRAY);
+  Check_Type(action_accept, T_ARRAY);
 
-  VALUE* accepts = RARRAY_PTR(request_accept);
-  long accepts_len = RARRAY_LEN(request_accept);
-  VALUE* values = RARRAY_PTR(accept_mimes);
-  long values_len = RARRAY_LEN(accept_mimes);
+  VALUE* requests = RARRAY_PTR(request_accept);
+  long requests_len = RARRAY_LEN(request_accept);
+  VALUE* values = RARRAY_PTR(action_accept);
+  long values_len = RARRAY_LEN(action_accept);
 
-  for (long j = 0; j < accepts_len; j++) {
-    char* s = RSTRING_PTR(accepts[j]);
-    long len = RSTRING_LEN(accepts[j]);
+  for (long j = 0; j < requests_len; j++) {
+    char* s = RSTRING_PTR(requests[j]);
+    long len = RSTRING_LEN(requests[j]);
     for (long i = 0; i < values_len; i++) {
       Check_Type(values[i], T_ARRAY);
       VALUE* arr = RARRAY_PTR(values[i]);
-      if (mime_match_seg(s, len, arr[0], arr[1])) {
+      if (_mime_match_seg(s, len, arr[0], arr[1])) {
         return arr[2];
       }
     }

data/ext/multipart-parser-c/multipart_parser.c

@@ -23,8 +23,8 @@ static void multipart_log(const char * format, ...)
 
 #define NOTIFY_CB(FOR)                                                 \
 do {                                                                   \
-  if (p->settings->on_##FOR) {                                     \
-    if (p->settings->on_##FOR(p) != 0) {                           \
+  if (p->settings->on_##FOR) {                                         \
+    if (p->settings->on_##FOR(p) != 0) {                               \
       return i;                                                        \
     }                                                                  \
   }                                                                    \
@@ -114,7 +114,7 @@ size_t multipart_parser_execute(multipart_parser* p, const char *buf, size_t len
   char c, cl;
   int is_last = 0;
 
-  while(!is_last) {
+  while(i < len) {
     c = buf[i];
     is_last = (i == (len - 1));
     switch (p->state) {

data/ext/nyara.h

@@ -20,8 +20,8 @@ void nyara_handle_request(int fd);
 
 /* -- url encoded parse -- */
 void Init_url_encoded(VALUE ext);
-size_t nyara_parse_path(VALUE path, const char*s, size_t len);
-void nyara_parse_param(VALUE output, const char* s, size_t len);
+long nyara_parse_path(VALUE path, const char*s, long len);
+void nyara_parse_param(VALUE output, const char* s, long len);
 
 
 /* -- accept parse -- */
@@ -52,8 +52,8 @@ typedef struct {
   VALUE controller;
   VALUE args;
   VALUE scope;
-  VALUE ext; // maybe string or map
+  VALUE format; // string, path extension or matched ext in config
 } RouteResult;
 
 extern void Init_route(VALUE nyara, VALUE ext);
-extern RouteResult nyara_lookup_route(enum http_method method_num, VALUE vpath);
+extern RouteResult nyara_lookup_route(enum http_method method_num, VALUE vpath, VALUE accept_arr);

data/ext/request.c

@@ -11,14 +11,15 @@ typedef struct {
   multipart_parser* mparser;
   enum http_method method;
   VALUE header;
+  VALUE accept; // mime array sorted with q
+  VALUE format; // string ext without dot
   VALUE fiber;
   VALUE scope; // mapped prefix
+  VALUE path_with_query;
   VALUE path;
-  VALUE param;
+  VALUE query;
   VALUE last_field;
   VALUE last_value;
-  // string if determined by url, or hash if need further check with header[Accept]
-  VALUE ext;
   VALUE self;
   int fd;
 
@@ -44,7 +45,7 @@ static VALUE fd_request_map;
 #define MAX_RECEIVE_DATA 65536
 static char received_data[MAX_RECEIVE_DATA];
 
-static VALUE fiber_func(VALUE _, VALUE args) {
+static VALUE _fiber_func(VALUE _, VALUE args) {
   VALUE instance = rb_ary_pop(args);
   VALUE meth = rb_ary_pop(args);
   rb_apply(instance, SYM2ID(meth), args);
@@ -66,49 +67,16 @@ static inline void _close_fd(int fd) {
   close(fd);
 }
 
-// fixme assume url is always sent as whole (tcp window is large!)
 static int on_url(http_parser* parser, const char* s, size_t len) {
   Request* p = (Request*)parser;
   p->method = parser->method;
 
-  // matching raw path is bad idea, for example: %a0 and %A0 are different strings but same route
-  p->path = rb_enc_str_new("", 0, u8_encoding);
-  size_t query_i = nyara_parse_path(p->path, s, len);
-  p->param = rb_class_new_instance(0, NULL, nyara_param_hash_class);
-  if (query_i < len) {
-    nyara_parse_param(p->param, s + query_i, len - query_i);
-
-    // do method override with _method=xxx in query
-    if (p->method == HTTP_POST) {
-      VALUE meth = rb_hash_aref(p->param, method_override_key);
-      if (TYPE(meth) == T_STRING) {
-        _upcase_method(meth);
-        VALUE meth_num = rb_hash_aref(nyara_http_methods, meth);
-        if (meth_num != Qnil) {
-          p->method = FIX2INT(meth_num);
-        }
-      }
-    }
-  }
-
-  volatile RouteResult result = nyara_lookup_route(p->method, p->path);
-  if (RTEST(result.controller)) {
-    {
-      VALUE instance = rb_class_new_instance(1, &(p->self), result.controller);
-      rb_ary_push(result.args, instance);
-    }
-    // result.args is on stack, no need to worry gc
-    p->fiber = rb_fiber_new(fiber_func, result.args);
-    p->scope = result.scope;
-    p->header = rb_class_new_instance(0, NULL, nyara_header_hash_class);
-    p->ext = result.ext;
-    p->response_header = rb_class_new_instance(0, NULL, nyara_header_hash_class);
-    p->response_header_extra_lines = rb_ary_new();
-    return 0;
+  if (p->path_with_query == Qnil) {
+    p->path_with_query = rb_str_new(s, len);
   } else {
-    rb_funcall(p->self, id_not_found, 0);
-    return 1;
+    rb_str_cat(p->path_with_query, s, len);
   }
+  return 0;
 }
 
 static int on_message_complete(http_parser* parser) {
@@ -160,25 +128,48 @@ static int on_header_value(http_parser* parser, const char* s, size_t len) {
   return 0;
 }
 
+// may override POST by _method in query
+static void _parse_path_and_query(Request* p) {
+  char* s = RSTRING_PTR(p->path_with_query);
+  long len = RSTRING_LEN(p->path_with_query);
+  long query_i = nyara_parse_path(p->path, s, len);
+  if (query_i < len) {
+    nyara_parse_param(p->query, s + query_i, len - query_i);
+
+    // do method override with _method=xxx in query
+    if (p->method == HTTP_POST) {
+      VALUE meth = rb_hash_aref(p->query, method_override_key);
+      if (TYPE(meth) == T_STRING) {
+        _upcase_method(meth);
+        VALUE meth_num = rb_hash_aref(nyara_http_methods, meth);
+        if (meth_num != Qnil) {
+          p->method = FIX2INT(meth_num);
+        }
+      }
+    }
+  }
+}
+
 static int on_headers_complete(http_parser* parser) {
   Request* p = (Request*)parser;
   p->last_field = Qnil;
   p->last_value = Qnil;
 
-  if (TYPE(p->ext) != T_STRING) {
-    VALUE accept = rb_hash_aref(p->header, str_accept);
-    if (RTEST(accept)) {
-      accept = ext_parse_accept_value(Qnil, accept);
-      rb_iv_set(p->self, "@accept", accept);
-      p->ext = ext_mime_match(Qnil, accept, p->ext);
-    }
-    if (p->ext == Qnil) {
-      rb_funcall(p->self, id_not_found, 0);
-      return 1;
-    }
+  _parse_path_and_query(p);
+  p->accept = ext_parse_accept_value(Qnil, rb_hash_aref(p->header, str_accept));
+  volatile RouteResult result = nyara_lookup_route(p->method, p->path, p->accept);
+  if (RTEST(result.controller)) {
+    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->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();
+    return 0;
   }
-
-  return 0;
+  rb_funcall(p->self, id_not_found, 0);
+  return 1;
 }
 
 static http_parser_settings request_settings = {
@@ -196,13 +187,15 @@ static void request_mark(void* pp) {
   Request* p = pp;
   if (p) {
     rb_gc_mark_maybe(p->header);
+    rb_gc_mark_maybe(p->accept);
+    rb_gc_mark_maybe(p->format);
     rb_gc_mark_maybe(p->fiber);
     rb_gc_mark_maybe(p->scope);
+    rb_gc_mark_maybe(p->path_with_query);
     rb_gc_mark_maybe(p->path);
-    rb_gc_mark_maybe(p->param);
+    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->ext);
     rb_gc_mark_maybe(p->response_content_type);
     rb_gc_mark_maybe(p->response_header);
     rb_gc_mark_maybe(p->response_header_extra_lines);
@@ -222,15 +215,20 @@ static void request_free(void* pp) {
 static Request* request_alloc() {
   Request* p = ALLOC(Request);
   http_parser_init(&(p->hparser), HTTP_REQUEST);
+  volatile VALUE header = rb_class_new_instance(0, NULL, nyara_header_hash_class);
+  volatile VALUE path = rb_enc_str_new("", 0, u8_encoding);
+  volatile VALUE query = rb_class_new_instance(0, NULL, nyara_param_hash_class);
   p->mparser = NULL;
-  p->header = Qnil;
+  p->header = header;
+  p->accept = Qnil;
+  p->format = Qnil;
   p->fiber = Qnil;
   p->scope = Qnil;
-  p->path = Qnil;
-  p->param = Qnil;
+  p->path_with_query = Qnil;
+  p->path = path;
+  p->query = query;
   p->last_field = Qnil;
   p->last_value = Qnil;
-  p->ext = Qnil;
   p->fd = 0;
   p->status = 200;
   p->response_content_type = Qnil;
@@ -248,8 +246,8 @@ static VALUE request_alloc_func(VALUE klass) {
 invoke order:
 - find/create request
 - http_parser_execute
-- on_url
-- on_message_complete
+- on_headers_complete => 404 or create request
+- on_message_complete => run action
 */
 void nyara_handle_request(int fd) {
   Request* p = NULL;
@@ -311,9 +309,24 @@ static VALUE request_path(VALUE self) {
   return p->path;
 }
 
-static VALUE request_matched_accept(VALUE _, VALUE self) {
+static VALUE request_query(VALUE self) {
   P;
-  return p->ext == Qnil ? str_html : p->ext;
+  return p->query;
+}
+
+static VALUE request_path_with_query(VALUE self) {
+  P;
+  return p->path_with_query;
+}
+
+static VALUE request_accept(VALUE self) {
+  P;
+  return p->accept;
+}
+
+static VALUE request_format(VALUE self) {
+  P;
+  return p->format == Qnil ? str_html : p->format;
 }
 
 static VALUE request_status(VALUE self) {
@@ -348,11 +361,6 @@ static VALUE ext_request_set_status(VALUE _, VALUE self, VALUE n) {
   return n;
 }
 
-static VALUE ext_request_param(VALUE _, VALUE self) {
-  P;
-  return p->param;
-}
-
 static VALUE ext_send_data(VALUE _, VALUE self, VALUE data) {
   P;
   char* buf = RSTRING_PTR(data);
@@ -397,42 +405,37 @@ static VALUE ext_handle_request(VALUE _, VALUE v_fd) {
 
 // set internal attrs in the request object
 static VALUE ext_set_request_attrs(VALUE _, VALUE self, VALUE attrs) {
-# define ATTR(key) rb_hash_aref(attrs, ID2SYM(rb_intern(key)))
+# 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)
   P;
 
-  if (ATTR("method_num") == Qnil) {
+  VALUE method_num = ATTR("method_num");
+  if (method_num == Qnil) {
     rb_raise(rb_eArgError, "bad method_num");
   }
-
-  p->method          = NUM2INT(ATTR("method_num"));
-  p->path            = ATTR("path");
-  p->param           = ATTR("param");
-  p->fiber           = ATTR("fiber");
-  p->scope           = ATTR("scope");
-  p->header          = RTEST(ATTR("header")) ? ATTR("header") : HEADER_HASH_NEW;
-  p->ext             = ATTR("ext");
-  p->response_header = RTEST(ATTR("response_header")) ? ATTR("response_header") : HEADER_HASH_NEW;
-  if (RTEST(ATTR("response_header_extra_lines"))) {
-    p->response_header_extra_lines = ATTR("response_header_extra_lines");
-  } else {
-    p->response_header_extra_lines = rb_ary_new();
+  p->method                      = NUM2INT(method_num);
+  p->path                        = ATTR("path");
+  p->query                       = ATTR("query");
+  p->fiber                       = ATTR("fiber");
+  p->scope                       = ATTR("scope");
+  p->header                      = ATTR("header");
+  p->format                      = ATTR("format");
+  p->response_header             = ATTR("response_header");
+  p->response_header_extra_lines = ATTR("response_header_extra_lines");
+
+  if (!RTEST(p->header)) p->header = HEADER_HASH_NEW;
+  if (!RTEST(p->response_header)) p->response_header = HEADER_HASH_NEW;
+  if (!RTEST(p->response_header_extra_lines)) p->response_header_extra_lines = rb_ary_new();
+
+  if (!RTEST(rb_funcall(attrs, rb_intern("empty?"), 0))) {
+    VALUE attrs_inspect = rb_funcall(attrs, rb_intern("inspect"), 0);
+    rb_raise(rb_eArgError, "unkown attrs: %.*s", (int)RSTRING_LEN(attrs_inspect), RSTRING_PTR(attrs_inspect));
   }
   return self;
 # undef HEADER_HASH_NEW
 # undef ATTR
 }
 
-// skip on_url so we can focus on testing request
-static VALUE ext_set_skip_on_url(VALUE _, VALUE pred) {
-  if (RTEST(pred)) {
-    request_settings.on_url = NULL;
-  } else {
-    request_settings.on_url = on_url;
-  }
-  return Qnil;
-}
-
 void Init_request(VALUE nyara, VALUE ext) {
   id_not_found = rb_intern("not_found");
   str_html = rb_str_new2("html");
@@ -445,7 +448,7 @@ void Init_request(VALUE nyara, VALUE ext) {
   fd_request_map = rb_hash_new();
   rb_gc_register_mark_object(fd_request_map);
   str_accept = rb_str_new2("Accept");
-  rb_gc_register_mark_object(fd_request_map);
+  rb_gc_register_mark_object(str_accept);
 
   // request
   request_class = rb_define_class_under(nyara, "Request", rb_cObject);
@@ -454,7 +457,10 @@ void Init_request(VALUE nyara, VALUE ext) {
   rb_define_method(request_class, "header", request_header, 0);
   rb_define_method(request_class, "scope", request_scope, 0);
   rb_define_method(request_class, "path", request_path, 0);
-  rb_define_method(request_class, "matched_accept", request_matched_accept, 0);
+  rb_define_method(request_class, "query", request_query, 0);
+  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, "status", request_status, 0);
   rb_define_method(request_class, "response_content_type", request_response_content_type, 0);
@@ -464,11 +470,9 @@ void Init_request(VALUE nyara, VALUE ext) {
 
   // hide internal methods in ext
   rb_define_singleton_method(ext, "request_set_status", ext_request_set_status, 2);
-  rb_define_singleton_method(ext, "request_param", ext_request_param, 1);
   rb_define_singleton_method(ext, "send_data", ext_send_data, 2);
   rb_define_singleton_method(ext, "send_chunk", ext_send_chunk, 2);
   // for test
   rb_define_singleton_method(ext, "handle_request", ext_handle_request, 1);
   rb_define_singleton_method(ext, "set_request_attrs", ext_set_request_attrs, 2);
-  rb_define_singleton_method(ext, "set_skip_on_url", ext_set_skip_on_url, 1);
 }

data/ext/route.cc

@@ -6,6 +6,9 @@ extern "C" {
 #include <vector>
 #include <map>
 #include "inc/str_intern.h"
+#ifndef isalnum
+#include <cctype>
+#endif
 
 struct RouteEntry {
   // note on order: scope is supposed to be the last, but when searching, is_sub is checked first
@@ -220,7 +223,7 @@ static VALUE extract_ext(const char* s, long len) {
 }
 
 extern "C"
-RouteResult nyara_lookup_route(enum http_method method_num, VALUE vpath) {
+RouteResult nyara_lookup_route(enum http_method method_num, VALUE vpath, VALUE accept_arr) {
   RouteResult r = {Qnil, Qnil, Qnil, Qnil};
   auto map_iter = route_map.find(method_num);
   if (map_iter == route_map.end()) {
@@ -247,8 +250,8 @@ RouteResult nyara_lookup_route(enum http_method method_num, VALUE vpath) {
       long suffix_len = len - i->prefix_len;
       if (i->suffix_len == 0) {
         if (suffix_len) {
-          r.ext = extract_ext(suffix, suffix_len);
-          if (r.ext == Qnil) {
+          r.format = extract_ext(suffix, suffix_len);
+          if (r.format == Qnil) {
             break;
           }
         }
@@ -260,8 +263,8 @@ RouteResult nyara_lookup_route(enum http_method method_num, VALUE vpath) {
                                       (const UChar*)suffix, &region, 0);
         if (matched_len > 0) {
           if (matched_len < suffix_len) {
-            r.ext = extract_ext(suffix + matched_len, suffix_len);
-            if (r.ext == Qnil) {
+            r.format = extract_ext(suffix + matched_len, suffix_len);
+            if (r.format == Qnil) {
               break;
             }
           }
@@ -277,17 +280,19 @@ RouteResult nyara_lookup_route(enum http_method method_num, VALUE vpath) {
   if (r.controller != Qnil) {
     r.scope = i->scope;
 
-    if (r.ext == Qnil) {
+    if (r.format == Qnil) {
       if (i->accept_exts == Qnil) {
-        r.ext = str_html;
+        r.format = str_html; // not configured, just plain html
       } else {
-        // NOTE maybe rejected
-        r.ext = i->accept_mimes;
+        r.format = ext_mime_match(Qnil, accept_arr, i->accept_mimes);
+        if (r.format == Qnil) {
+          r.controller = Qnil; // reject if mime mismatch
+        }
       }
     } else {
       if (i->accept_exts != Qnil) {
-        if (!RTEST(rb_hash_aref(i->accept_exts, r.ext))) {
-          r.controller = Qnil; // reject if ext mismatch
+        if (!RTEST(rb_hash_aref(i->accept_exts, r.format))) {
+          r.controller = Qnil; // reject if path ext mismatch
         }
       }
     }
@@ -295,14 +300,14 @@ RouteResult nyara_lookup_route(enum http_method method_num, VALUE vpath) {
   return r;
 }
 
-static VALUE ext_lookup_route(VALUE self, VALUE method, VALUE path) {
+static VALUE ext_lookup_route(VALUE self, VALUE method, VALUE path, VALUE accept_arr) {
   enum http_method method_num = canonicalize_http_method(method);
-  volatile RouteResult r = nyara_lookup_route(method_num, path);
+  volatile RouteResult r = nyara_lookup_route(method_num, path, accept_arr);
   volatile VALUE a = rb_ary_new();
   rb_ary_push(a, r.scope);
   rb_ary_push(a, r.controller);
   rb_ary_push(a, r.args);
-  rb_ary_push(a, r.ext);
+  rb_ary_push(a, r.format);
   return a;
 }
 
@@ -321,5 +326,5 @@ void Init_route(VALUE nyara, VALUE ext) {
 
   // for test
   rb_define_singleton_method(ext, "list_route", RUBY_METHOD_FUNC(ext_list_route), 0);
-  rb_define_singleton_method(ext, "lookup_route", RUBY_METHOD_FUNC(ext_lookup_route), 2);
+  rb_define_singleton_method(ext, "lookup_route", RUBY_METHOD_FUNC(ext_lookup_route), 3);
 }

data/ext/url_encoded.c

@@ -18,7 +18,7 @@ static char _half_octet(char c) {
   }
 }
 
-static size_t _decode_url_seg(VALUE path, const char*s, size_t len, char stop_char) {
+static long _decode_url_seg(VALUE path, const char*s, long len, char stop_char) {
   const char* last_s = s;
   long last_len = 0;
 
@@ -29,7 +29,7 @@ static size_t _decode_url_seg(VALUE path, const char*s, size_t len, char stop_ch
     last_len = 0;\
   }
 
-  size_t i;
+  long i;
   for (i = 0; i < len; i++) {
     if (s[i] == '%') {
       if (i + 2 >= len) {
@@ -71,12 +71,12 @@ static size_t _decode_url_seg(VALUE path, const char*s, size_t len, char stop_ch
 }
 
 // return parsed len, s + return == start of query
-size_t nyara_parse_path(VALUE output, const char* s, size_t len) {
+long nyara_parse_path(VALUE output, const char* s, long len) {
   return _decode_url_seg(output, s, len, '?');
 }
 
 static VALUE ext_parse_path(VALUE self, VALUE output, VALUE input) {
-  size_t parsed = nyara_parse_path(output, RSTRING_PTR(input), RSTRING_LEN(input));
+  long parsed = nyara_parse_path(output, RSTRING_PTR(input), RSTRING_LEN(input));
   return ULONG2NUM(parsed);
 }
 
@@ -227,10 +227,10 @@ static VALUE ext_parse_url_encoded_seg(VALUE self, VALUE output, VALUE kv, VALUE
   return output;
 }
 
-void nyara_parse_param(VALUE output, const char* s, size_t len) {
+void nyara_parse_param(VALUE output, const char* s, long len) {
   // split with /[&;] */
-  size_t last_i = 0;
-  size_t i = 0;
+  long last_i = 0;
+  long i = 0;
   for (; i < len; i++) {
     if (s[i] == '&' || s[i] == ';') {
       if (i > last_i) {
@@ -265,11 +265,11 @@ static VALUE _cookie_seg_str_new(const char* s, long len) {
 static VALUE ext_parse_cookie(VALUE self, VALUE output, VALUE str) {
   volatile VALUE arr = rb_ary_new();
   const char* s = RSTRING_PTR(str);
-  size_t len = RSTRING_LEN(str);
+  long len = RSTRING_LEN(str);
 
   // split with / *[,;] */
-  size_t last_i = 0;
-  size_t i = 0;
+  long last_i = 0;
+  long i = 0;
   for (; i < len; i++) {
     if (s[i] == ',' || s[i] == ';') {
       // char* and len parse_seg

data/hello.rb

@@ -3,3 +3,5 @@ require_relative "lib/nyara"
 get '/' do
   send_string 'hello world'
 end
+
+# GC.stress = true

data/lib/nyara/controller.rb

@@ -14,7 +14,7 @@ module Nyara
         action = RouteEntry.new
         action.http_method = HTTP_METHODS[method]
         action.path = path
-        action.set_accept_exts @accept
+        action.set_accept_exts @formats
         action.id = @curr_id.to_sym if @curr_id
         action.blk = blk
         @route_entries << action
@@ -25,7 +25,7 @@ module Nyara
           @curr_id = nil
           @meta_exist = nil
         end
-        @accept = nil
+        @formats = nil
       end
 
       # Set meta data for next action
@@ -50,7 +50,7 @@ module Nyara
 
         if opts
           # todo add opts: strong param, etag, cache-control
-          @accept = opts[:accept]
+          @formats = opts[:formats]
         end
 
         @meta_exist = true
@@ -167,8 +167,8 @@ module Nyara
       scheme << host << path
     end
 
-    def matched_accept
-      request.matched_accept
+    def format
+      request.format
     end
 
     def header
@@ -244,7 +244,8 @@ module Nyara
         r.response_content_type ||
         header.aref_content_type ||
         (r.accept and MIME_TYPES[r.accept]) ||
-        template_deduced_content_type
+        template_deduced_content_type ||
+        'text/html'
 
       header.reverse_merge! OK_RESP_HEADER
 

data/lib/nyara/request.rb

@@ -3,7 +3,7 @@
 module Nyara
   # request and handler
   class Request
-    # c-ext: http_method, scope, path, matched_accept, header
+    # c-ext: http_method, scope, path, query, path_with_query format, accept, header
     #        status, response_content_type, response_header, response_header_extra_lines
     # todo: body, move all underline methods into Ext
 
@@ -77,10 +77,6 @@ module Nyara
       header["Requested-With"] == "XMLHttpRequest"
     end
 
-    def accept
-      @accept ||= Ext.parse_accept_value header['Accept']
-    end
-
     def accept_language
       @accept_language ||= Ext.parse_accept_value header['Accept-Language']
     end
@@ -116,11 +112,12 @@ module Nyara
 
     def param
       @param ||= begin
-        query_param = Ext.request_param self
+        q = query.dup
         if form?
-          Ext.parse_param query_param, body
+          # todo read body, change encoding
+          Ext.parse_param q, body
         end
-        query_param
+        q
       end
     end
 

data/nyara.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "nyara"
-  s.version = "0.0.1.pre"
+  s.version = "0.0.1.pre.1"
   s.author = "Zete Lui"
   s.email = "nobody@example.com"
   s.homepage = "https://github.com/luikore/nyara"

data/rakefile

@@ -4,6 +4,8 @@ Dir.chdir __dir__
 
 status_file = "ext/inc/status_codes.inc"
 version_file = "ext/inc/version.inc"
+makefile = "ext/Makefile"
+extconf = "ext/extconf.rb"
 
 desc "code generate"
 task :gen => [status_file, version_file]
@@ -42,13 +44,57 @@ file version_file => 'nyara.gemspec' do
   end
 end
 
+desc "generate makefile"
+file makefile => extconf do
+  Dir.chdir 'ext' do
+    sh 'ruby extconf.rb'
+  end
+end
+
 desc "build ext"
-task :build do
+task :build => makefile do
   Dir.chdir 'ext' do
     sh 'make'
   end
 end
 
+def term_color n
+  print "\e[38;5;#{n}m"
+end
+
+def reset_color
+  print "\e[00m"
+end
+
+desc "check arity of rb_define_method/rb_define_singleton_method"
+task :check_arity do
+  Dir.glob 'ext/*.{c,cc}' do |f|
+    puts "validatign #{f}"
+    arities = {}
+    data = File.read f
+    data.scan /^(?:static )?VALUE (\w+)\((.+)\)/ do |func, params|
+      arities[func] = params.count(',')
+      puts "  scan: #{func}/#{arities[func]}"
+    end
+    data.scan /rb_define(?:_singleton)?_method\(.*?(\w+)\s*\,\s*(\d+)\)/ do |func, arity|
+      print "  check: #{func}/#{arity} "
+      if arities[func].nil?
+        term_color 5
+        print "UNSCANNED"
+        reset_color
+        puts
+      elsif arities[func] != arity.to_i
+        term_color 9
+        print "MISMATCH #{arities[func]}"
+        reset_color
+        puts
+      else
+        puts "OK"
+      end
+    end
+  end
+end
+
 desc "test"
 task :test => :build do
   sh 'rspec', '-c'
@@ -58,8 +104,10 @@ desc "build and test"
 task :default => :test
 
 desc "build and install gem"
-task :gem do
-  sh 'rm', '-f', '*.gem'
+task :gem => 'gen' do
+  Dir.glob('*.gem') do |f|
+    sh 'rm', f
+  end
   sh 'gem', 'build', 'nyara.gemspec'
   gem_package = Dir.glob('*.gem').first
   sh 'gem', 'install', '--no-rdoc', '--no-ri', gem_package

data/readme.md

@@ -1,35 +1,96 @@
-git submodule update --recursive
+Not Yet Another Ruby Async web framework and server. Not on rack nor rack-compatible neither eventmachine.
+
+- Evented IO while API remains synchrony
+- Prefork production server
+- Sinatra-like http method and scanf-like http path and path helper
+- Request format matcher with just `case ... when`
+- Easy to stream the view with `Fiber.yield`
+
+# Getting started
+
+Requires Ruby 2.0+, BSD/Linux/Mac OS X.
+
+Install
+
+```bash
+gem ins --pre nyara
+```
+
+Edit a file, name it `nyahaha.rb` for example
+
+```ruby
+require 'nyara'
+get '/' do
+  send_string 'hello world'
+end
+```
+
+And start server
+
+```bash
+ruby nyahaha.rb
+```
+
+# Build from source
+
+After cloning
+
+```bash
+git submodule update --init
+bundle
 rake gen
 rake gem
+```
 
 # Why fast
 
-## Solid http parsers written in C
+### Solid http parsers written in C
+
+Nyara uses two evented parsers:
+
+- [http_parser](https://github.com/joyent/http-parser) with chunked encoding support
+- [multipart-parser-c](https://github.com/iafonov/multipart-parser-c) (todo)
+
+And implemented the following in addition:
+
+- RFC2616 compliant `Accept*` parser
+- MIME type matcher
+- Url-encoded parser for path / query / request body
+
+### Decisive routing on header complete
+
+To support HTTP methods like PUT, DELETE for archaic browsers, a technique called **method override** is used, and the HTTP method can be overriden by a request param (usually named `_method`). In Rack the param may rest in request body, so it needs to parse the whole body before routing to a desired action. In Nyara the param is always in request path query, and routing starts when header completes. So server can do a lot of things before a huge file completely uploaded and provide better user experience.
+
+### Thin evented IO layer built for BSD or Linux
+
+Nyara is only for systems with kqueue or epoll (maybe iocp in the future). Manufactural event queue is a waste of time.
+
+### Solve sequential problems with Fiber
+
+The common caveats of an evented framework is: mutual callbacks must be used to ensure the order of operations. In eventmachine, sent data buffers are copied and chained in a deque to flush, and `close_connection_after_writing` must be called to ensure that all data are written before close.
+
+While in Nyara, the data sending is much simpler: we send them directly, if there are remaining bytes, the action fiber is paused. When the socket is ready again, we wake up the fiber to continue the send action. So a lot of duplications, memory copy and schedule are avoided and `close` is the `close`.
+
+### More stable memory management
 
-These evented parsers are used:
+To make better user experience, you may tune the server to stop GC while doing request, and start GC again after every serveral requests. But by doing so you are increasing the probability of OOM: there are cases when `malloc` or `new` fails to get memory while the GC stopped by you can release some. With C-ext this can be partly fixed with Ruby's `ALLOC` and `ALLOC_N`, which can make GC release some memory when `malloc` fails. But with C++ this becomes a bit messy: you need to redefine `new` operators.
 
-- http_parser with chunked encoding support
-- multipart request parser
+In Nyara, the use of C++ memory allocation is limited to boot time (the use of C++ may possibly removed in the future) so your server has less chance to be quit by a silent `OutOfMemoryException`.
 
-And these are implemented in addition:
+### Shared buffer in layout rendering
 
-- `Accept-*` parser
-- mime type parser and content type matcher
-- url-encoded parser for parsing path / query / request body
+Consider you have a page with nested layout: `layout1` encloses `layout2`, and `layout2` contains `page`.
 
-## Fast first-line routing and request class
+When rendering `layout2`, the output string of `page` becomes an element inside the array buffer of `layout2`, then the output of `page` is duplicated in the output of `layout2`. When rendering `layout1`, the output of `layout2` is duplicated so a string containing the output of `page` is duplicated, again.
 
-## Thin evented IO layer built for *nix and Fiber
+In Nyara, nested templates of Slim, ERB or Haml share the same output buffer, so the duplication is greatly reduced.
 
 # How fast
 
-Speed is feature, there are specs on:
+Performance is feature, there are specs on (TODO):
 
 - Accept-* parse vs rack
-- MIME parse vs rack
-- query parse vs rack
-- query parse vs houdini
-- layout engine vs tilt
+- MIME matching vs rack
+- param parse vs ruby
+- layout rendering vs tilt
 - evented IO vs eventmachine
-- helloworld vs sinatra
-- pseudo real app speed vs jruby sinatra threaded mode

data/spec/ext_route_spec.rb

@@ -50,20 +50,20 @@ module Nyara
     end
 
     it '#lookup_route' do
-      scope, cont, args = Ext.lookup_route 'GET', '/hello'
+      scope, cont, args = Ext.lookup_route 'GET', '/hello', nil
       assert_equal @e2.scope, scope
       assert_equal @e2.controller, cont
       assert_equal [:'#second'], args
 
-      scope, cont, args = Ext.lookup_route 'GET', '/hello/3world'
+      scope, cont, args = Ext.lookup_route 'GET', '/hello/3world', nil
       assert_equal @e1.scope, scope
       assert_equal @e1.controller, cont
       assert_equal [3, :'#1'], args
 
-      scope, _ = Ext.lookup_route 'GET', '/world'
+      scope, _ = Ext.lookup_route 'GET', '/world', nil
       assert_equal nil, scope
 
-      scope, _, args = Ext.lookup_route 'GET', '/a目录/2013-6-1'
+      scope, _, args = Ext.lookup_route 'GET', '/a目录/2013-6-1', nil
       assert_equal [2013, 6, 1, :'#dir'], args
     end
   end

data/spec/request_delegate_spec.rb

@@ -5,14 +5,6 @@ module Nyara
     class DelegateController < Controller
     end
 
-    before :all do
-      Ext.set_skip_on_url true
-    end
-
-    after :all do
-      Ext.set_skip_on_url false
-    end
-
     before :each do
       @client, @server = Socket.pair :UNIX, :STREAM
       Ext.set_nonblock @server.fileno
@@ -20,7 +12,7 @@ module Nyara
       Ext.set_request_attrs @request, {
         method_num: HTTP_METHODS['GET'],
         path: '/search',
-        param: ParamHash.new.tap{|h| h['q'] = 'nyara' },
+        query: ParamHash.new.tap{|h| h['q'] = 'nyara' },
         fiber: Fiber.new{},
         scope: '/scope',
         header: HeaderHash.new.tap{|h| h['Accept'] = 'en-US' }

data/spec/request_spec.rb

@@ -2,14 +2,6 @@ require_relative "spec_helper"
 
 module Nyara
   describe Request do
-    before :all do
-      Ext.set_skip_on_url true
-    end
-
-    after :all do
-      Ext.set_skip_on_url false
-    end
-
     before :each do
       @server, @client = Socket.pair :UNIX, :STREAM, 0
       Ext.set_nonblock @server.fileno
@@ -18,10 +10,10 @@ module Nyara
       @request_attrs = {
         method_num: HTTP_METHODS['GET'],
         path: '/',
-        param: HeaderHash.new.tap{|h| h['id'] = 1 },
+        query: HeaderHash.new.tap{|h| h['id'] = 1 },
         fiber: nil,
         scope: '/',
-        ext: nil
+        format: 'html'
       }
       set_request_attrs
     end

data/spec/spec_helper.rb

@@ -43,6 +43,14 @@ RSpec.configure do |config|
       end
     end
   end
+
+  config.before :each do
+    GC.stress = true
+  end
+
+  config.after :each do
+    GC.stress = false
+  end
 end
 
 configure do

data/spec/view_spec.rb

@@ -20,6 +20,10 @@ module Nyara
       View.init
     end
 
+    before :each do
+      GC.stress = false
+    end
+
     def render *xs
       @instance = RenderableMock.new
       view = View.new @instance, *xs

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nyara
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre
+  version: 0.0.1.pre.1
 platform: ruby
 authors:
 - Zete Lui
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-19 00:00:00.000000000 Z
+date: 2013-06-20 00:00:00.000000000 Z
 dependencies: []
 description: Fast, slim and fuzzy ruby web framework + server, based on preforked
   event queue and Fiber. NO rack NOR eventmachine are used.