nyara 0.0.1.pre

data/ext/route.cc

@@ -0,0 +1,325 @@
+extern "C" {
+#include "nyara.h"
+}
+#include <ruby/re.h>
+#include <ruby/encoding.h>
+#include <vector>
+#include <map>
+#include "inc/str_intern.h"
+
+struct RouteEntry {
+  // note on order: scope is supposed to be the last, but when searching, is_sub is checked first
+  bool is_sub; // = last_prefix.start_with? prefix
+  char* prefix;
+  long prefix_len;
+  regex_t *suffix_re;
+  VALUE controller;
+  VALUE id; // symbol
+  VALUE accept_exts;  // {ext => true}
+  VALUE accept_mimes; // [[m1, m2, ext]]
+  std::vector<ID> conv;
+  VALUE scope;
+  char* suffix; // only for inspect
+  long suffix_len;
+
+  // don't make it destructor, or it could be called twice if on stack
+  void dealloc() {
+    if (prefix) {
+      xfree(prefix);
+      prefix = NULL;
+    }
+    if (suffix_re) {
+      onig_free(suffix_re);
+      suffix_re = NULL;
+    }
+    if (suffix) {
+      xfree(suffix);
+      suffix = NULL;
+    }
+  }
+};
+
+typedef std::vector<RouteEntry> RouteEntries;
+static std::map<enum http_method, RouteEntries*> route_map;
+static OnigRegion region; // we can reuse the region without worrying thread safety
+static ID id_to_s;
+static rb_encoding* u8_enc;
+static VALUE str_html;
+static VALUE nyara_http_methods;
+
+static bool start_with(const char* a, long a_len, const char* b, long b_len) {
+  if (b_len > a_len) {
+    return false;
+  }
+  for (size_t i = 0; i < b_len; i++) {
+    if (a[i] != b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static enum http_method canonicalize_http_method(VALUE m) {
+  VALUE method_num;
+  if (TYPE(m) == T_STRING) {
+    method_num = rb_hash_aref(nyara_http_methods, m);
+  } else {
+    method_num = m;
+  }
+  Check_Type(method_num, T_FIXNUM);
+  return (enum http_method)FIX2INT(method_num);
+}
+
+static VALUE ext_clear_route(VALUE req) {
+  for (auto i = route_map.begin(); i != route_map.end(); ++i) {
+    RouteEntries* entries = i->second;
+    for (auto j = entries->begin(); j != entries->end(); ++j) {
+      j->dealloc();
+    }
+    delete entries;
+  }
+  route_map.clear();
+  return Qnil;
+}
+
+static VALUE ext_register_route(VALUE self, VALUE v_e) {
+  // get route entries
+  enum http_method m = canonicalize_http_method(rb_iv_get(v_e, "@http_method"));
+  RouteEntries* route_entries;
+  auto map_iter = route_map.find(m);
+  if (map_iter == route_map.end()) {
+    route_entries = new RouteEntries();
+    route_map[m] = route_entries;
+  } else {
+    route_entries = map_iter->second;
+  }
+
+  // prefix
+  VALUE v_prefix = rb_iv_get(v_e, "@prefix");
+  long prefix_len = RSTRING_LEN(v_prefix);
+  char* prefix = ALLOC_N(char, prefix_len);
+  memcpy(prefix, RSTRING_PTR(v_prefix), prefix_len);
+
+  // check if prefix is substring of last entry
+  bool is_sub = false;
+  if (route_entries->size()) {
+    is_sub = start_with(route_entries->rbegin()->prefix, route_entries->rbegin()->prefix_len, prefix, prefix_len);
+  }
+
+  // suffix
+  VALUE v_suffix = rb_iv_get(v_e, "@suffix");
+  long suffix_len = RSTRING_LEN(v_suffix);
+  char* suffix = ALLOC_N(char, suffix_len);
+  memcpy(suffix, RSTRING_PTR(v_suffix), suffix_len);
+  regex_t* suffix_re;
+  OnigErrorInfo err_info;
+  onig_new(&suffix_re, (const UChar*)suffix, (const UChar*)(suffix + suffix_len),
+           ONIG_OPTION_NONE, ONIG_ENCODING_ASCII, ONIG_SYNTAX_RUBY, &err_info);
+
+  std::vector<ID> _conv;
+  RouteEntry e;
+  e.is_sub = is_sub;
+  e.prefix = prefix;
+  e.prefix_len = prefix_len;
+  e.suffix_re = suffix_re;
+  e.suffix = suffix;
+  e.suffix_len = suffix_len;
+  e.controller = rb_iv_get(v_e, "@controller");
+  e.id = rb_iv_get(v_e, "@id");
+  e.conv = _conv;
+  e.scope = rb_iv_get(v_e, "@scope");
+
+  // conv
+  VALUE v_conv = rb_iv_get(v_e, "@conv");
+  VALUE* conv_ptr = RARRAY_PTR(v_conv);
+  long conv_len = RARRAY_LEN(v_conv);
+  if (onig_number_of_captures(suffix_re) != conv_len) {
+    e.dealloc();
+    rb_raise(rb_eRuntimeError, "number of captures mismatch");
+  }
+  for (long i = 0; i < conv_len; i++) {
+    ID conv_id = SYM2ID(conv_ptr[i]);
+    e.conv.push_back(conv_id);
+  }
+
+  // accept
+  e.accept_exts = rb_iv_get(v_e, "@accept_exts");
+  e.accept_mimes = rb_iv_get(v_e, "@accept_mimes");
+
+  route_entries->push_back(e);
+  return Qnil;
+}
+
+static VALUE ext_list_route(VALUE self) {
+  // note: prevent leak with init nil
+  volatile VALUE arr = Qnil;
+  volatile VALUE e = Qnil;
+  volatile VALUE prefix = Qnil;
+  volatile VALUE conv = Qnil;
+
+  volatile VALUE route_hash = rb_hash_new();
+  for (auto j = route_map.begin(); j != route_map.end(); j++) {
+    RouteEntries* route_entries = j->second;
+    VALUE arr = rb_ary_new();
+    rb_hash_aset(route_hash, rb_str_new2(http_method_str(j->first)), arr);
+    for (auto i = route_entries->begin(); i != route_entries->end(); i++) {
+      e = rb_ary_new();
+      rb_ary_push(e, i->is_sub ? Qtrue : Qfalse);
+      rb_ary_push(e, i->scope);
+      rb_ary_push(e, rb_str_new(i->prefix, i->prefix_len));
+      rb_ary_push(e, rb_str_new(i->suffix, i->suffix_len));
+      rb_ary_push(e, i->controller);
+      rb_ary_push(e, i->id);
+      conv = rb_ary_new();
+      for (size_t j = 0; j < i->conv.size(); j++) {
+        rb_ary_push(conv, ID2SYM(i->conv[j]));
+      }
+      rb_ary_push(e, conv);
+      rb_ary_push(arr, e);
+    }
+  }
+  return route_hash;
+}
+
+static VALUE build_args(const char* suffix, std::vector<ID>& conv) {
+  volatile VALUE args = rb_ary_new();
+  volatile VALUE str = rb_str_new2("");
+  long last_len = 0;
+  for (size_t j = 0; j < conv.size(); j++) {
+    const char* capture_ptr = suffix + region.beg[j+1];
+    long capture_len = region.end[j+1] - region.beg[j+1];
+    if (conv[j] == id_to_s) {
+      rb_ary_push(args, rb_enc_str_new(capture_ptr, capture_len, u8_enc));
+    } else if (capture_len == 0) {
+      rb_ary_push(args, Qnil);
+    } else {
+      if (capture_len > last_len) {
+        RESIZE_CAPA(str, capture_len);
+        last_len = capture_len;
+      }
+      memcpy(RSTRING_PTR(str), capture_ptr, capture_len);
+      STR_SET_LEN(str, capture_len);
+      rb_ary_push(args, rb_funcall(str, conv[j], 0)); // hex, to_i, to_f
+    }
+  }
+  return args;
+}
+
+static VALUE extract_ext(const char* s, long len) {
+  if (s[0] != '.') {
+    return Qnil;
+  }
+  s++;
+  len--;
+  for (long i = 0; i < len; i++) {
+    if (!isalnum(s[i])) {
+      return Qnil;
+    }
+  }
+  return rb_str_new(s, len);
+}
+
+extern "C"
+RouteResult nyara_lookup_route(enum http_method method_num, VALUE vpath) {
+  RouteResult r = {Qnil, Qnil, Qnil, Qnil};
+  auto map_iter = route_map.find(method_num);
+  if (map_iter == route_map.end()) {
+    return r;
+  }
+  RouteEntries* route_entries = map_iter->second;
+
+  const char* path = RSTRING_PTR(vpath);
+  long len = RSTRING_LEN(vpath);
+  // must iterate all
+  bool last_matched = false;
+  auto i = route_entries->begin();
+  for (; i != route_entries->end(); ++i) {
+    bool matched;
+    if (i->is_sub && last_matched) { // save a bit compare
+      matched = last_matched;
+    } else {
+      matched = start_with(path, len, i->prefix, i->prefix_len);
+    }
+    last_matched = matched;
+
+    if (/* prefix */ matched) {
+      const char* suffix = path + i->prefix_len;
+      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) {
+            break;
+          }
+        }
+        r.args = rb_ary_new3(1, i->id);
+        r.controller = i->controller;
+        break;
+      } else {
+        long matched_len = onig_match(i->suffix_re, (const UChar*)suffix, (const UChar*)(suffix + suffix_len),
+                                      (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) {
+              break;
+            }
+          }
+          r.args = build_args(suffix, i->conv);
+          rb_ary_push(r.args, i->id);
+          r.controller = i->controller;
+          break;
+        }
+      }
+    }
+  }
+
+  if (r.controller != Qnil) {
+    r.scope = i->scope;
+
+    if (r.ext == Qnil) {
+      if (i->accept_exts == Qnil) {
+        r.ext = str_html;
+      } else {
+        // NOTE maybe rejected
+        r.ext = i->accept_mimes;
+      }
+    } else {
+      if (i->accept_exts != Qnil) {
+        if (!RTEST(rb_hash_aref(i->accept_exts, r.ext))) {
+          r.controller = Qnil; // reject if ext mismatch
+        }
+      }
+    }
+  }
+  return r;
+}
+
+static VALUE ext_lookup_route(VALUE self, VALUE method, VALUE path) {
+  enum http_method method_num = canonicalize_http_method(method);
+  volatile RouteResult r = nyara_lookup_route(method_num, path);
+  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);
+  return a;
+}
+
+extern "C"
+void Init_route(VALUE nyara, VALUE ext) {
+  nyara_http_methods = rb_const_get(nyara, rb_intern("HTTP_METHODS"));
+  id_to_s = rb_intern("to_s");
+  u8_enc = rb_utf8_encoding();
+  str_html = rb_str_new2("html");
+  OBJ_FREEZE(str_html);
+  rb_gc_register_mark_object(str_html);
+  onig_region_init(&region);
+
+  rb_define_singleton_method(ext, "register_route", RUBY_METHOD_FUNC(ext_register_route), 1);
+  rb_define_singleton_method(ext, "clear_route", RUBY_METHOD_FUNC(ext_clear_route), 0);
+
+  // 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);
+}

data/ext/url_encoded.c

@@ -0,0 +1,304 @@
+// parse path / query / url-encoded body
+#include "nyara.h"
+#include <ruby/encoding.h>
+
+static rb_encoding* u8_encoding;
+
+static char _half_octet(char c) {
+  // there's a faster way but not validating the range:
+  //   #define hex2c(c) ((c | 32) % 39 - 9)
+  if (c >= '0' && c <= '9') {
+    return c - '0';
+  } else if (c >= 'A' && c <= 'F') {
+    return c - 'A' + 10;
+  } else if (c >= 'a' && c <= 'f') {
+    return c - 'a' + 10;
+  } else {
+    return -1;
+  }
+}
+
+static size_t _decode_url_seg(VALUE path, const char*s, size_t len, char stop_char) {
+  const char* last_s = s;
+  long last_len = 0;
+
+# define FLUSH_UNESCAPED\
+  if (last_len) {\
+    rb_str_cat(path, last_s, last_len);\
+    last_s += last_len;\
+    last_len = 0;\
+  }
+
+  size_t i;
+  for (i = 0; i < len; i++) {
+    if (s[i] == '%') {
+      if (i + 2 >= len) {
+        last_len++;
+        continue;
+      }
+      char r1 = _half_octet(s[i + 1]);
+      if (r1 < 0) {
+        last_len++;
+        continue;
+      }
+      char r2 = _half_octet(s[i + 2]);
+      if (r2 < 0) {
+        last_len++;
+        continue;
+      }
+      i += 2;
+      unsigned char r = ((unsigned char)r1 << 4) | (unsigned char)r2;
+      FLUSH_UNESCAPED;
+      last_s += 3;
+      rb_str_cat(path, (char*)&r, 1);
+
+    } else if (s[i] == stop_char) {
+      i++;
+      break;
+
+    } else if (s[i] == '+') {
+      FLUSH_UNESCAPED;
+      rb_str_cat(path, " ", 1);
+
+    } else {
+      last_len++;
+    }
+  }
+  FLUSH_UNESCAPED;
+# undef FLUSH_UNESCAPED
+
+  return i;
+}
+
+// return parsed len, s + return == start of query
+size_t nyara_parse_path(VALUE output, const char* s, size_t 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));
+  return ULONG2NUM(parsed);
+}
+
+static void _error(const char* msg, const char* s, long len, long segment_i) {
+  rb_raise(rb_eRuntimeError,
+    "error parsing \"%.*s\": segments[%ld] is %s",
+    (int)len, s, segment_i, msg);
+}
+
+static VALUE _new_child(long hash) {
+  return hash ? rb_class_new_instance(0, NULL, nyara_param_hash_class) : rb_ary_new();
+}
+
+// a, b, c = keys; h[a][b][c] = value
+// the last 2 args are for error report
+static void _aset_keys(VALUE output, VALUE keys, VALUE value, const char* kv_s, long kv_len) {
+  VALUE* arr = RARRAY_PTR(keys);
+  long len = RARRAY_LEN(keys);
+  if (!len) {
+    rb_bug("bug: aset 0 length key");
+    return;
+  }
+
+  // first key seg
+  volatile VALUE key = arr[0];
+  long is_hash_key = 1;
+
+  // middle key segs
+  for (long i = 0; i < len - 1; i++) {
+    key = arr[i];
+    long next_is_hash_key = RSTRING_LEN(arr[i + 1]);
+    if (is_hash_key) {
+      if (nyara_rb_hash_has_key(output, key)) {
+        output = rb_hash_aref(output, key);
+        if (next_is_hash_key) {
+          if (TYPE(output) != T_HASH) {
+            // note: StringValueCStr requires VALUE* as param, and can raise another error if there's nul in the string
+            _error("not array index (expect to be empty)", kv_s, kv_len, i);
+          }
+        } else {
+          if (TYPE(output) != T_ARRAY) {
+            _error("not hash key (expect to be non-empty)", kv_s, kv_len, i);
+          }
+        }
+      } else {
+        volatile VALUE child = _new_child(next_is_hash_key);
+        rb_hash_aset(output, key, child);
+        output = child;
+      }
+    } else {
+      volatile VALUE child = _new_child(next_is_hash_key);
+      rb_ary_push(output, child);
+      output = child;
+    }
+    is_hash_key = next_is_hash_key;
+  }
+
+  // terminate key seg: add value
+  key = arr[len - 1];
+  if (is_hash_key) {
+    rb_hash_aset(output, key, value);
+  } else {
+    rb_ary_push(output, value);
+  }
+}
+
+static const char* _strnchr(const char* s, long len, char c) {
+  for (long i = 0; i < len; i++) {
+    if (s[i] == c) {
+      return s + i;
+    }
+  }
+  return NULL;
+}
+
+static inline VALUE _new_blank_str() {
+  return rb_enc_str_new("", 0, u8_encoding);
+}
+
+static void _url_encoded_seg(VALUE output, const char* kv_s, long kv_len, int nested_mode) {
+  // (note if we _decode_url_seg with '&' first, then there may be multiple '='s in one kv)
+  const char* s = kv_s;
+  long len = kv_len;
+  if (!len) {
+    return;
+  }
+
+  volatile VALUE value = _new_blank_str();
+
+  // rule out the value part
+  {
+    // strnstr is not available on linux :(
+    const char* value_s = _strnchr(s, len, '=');
+    if (value_s) {
+      value_s++;
+      long value_len = s + len - value_s;
+      long parsed = _decode_url_seg(value, value_s, value_len, '&');
+      if (parsed != value_len) {
+        rb_raise(rb_eArgError, "separator & in param segment");
+      }
+      len = value_s - s - 1;
+    }
+    // starts with '='
+    if (value_s == s) {
+      rb_hash_aset(output, _new_blank_str(), value);
+      return;
+    }
+  }
+
+  volatile VALUE key = _new_blank_str();
+  if (nested_mode) {
+    // todo fault-tolerant?
+    long parsed = _decode_url_seg(key, s, len, '[');
+    if (parsed == len) {
+      rb_hash_aset(output, key, value);
+      return;
+    }
+    s += parsed;
+    len -= parsed;
+    volatile VALUE keys = rb_ary_new3(1, key);
+    while (len) {
+      key = _new_blank_str();
+      parsed = _decode_url_seg(key, s, len, ']');
+      rb_ary_push(keys, key);
+      s += parsed;
+      len -= parsed;
+      if (len) {
+        if (s[0] == '[') {
+          s++;
+          len--;
+        } else {
+          rb_raise(rb_eRuntimeError, "malformed params: remaining chars in key but not starting with '['");
+          return;
+        }
+      }
+    }
+    _aset_keys(output, keys, value, kv_s, kv_len);
+  } else {
+    _decode_url_seg(key, s, len, '=');
+    rb_hash_aset(output, key, value);
+  }
+
+  return;
+}
+
+static VALUE ext_parse_url_encoded_seg(VALUE self, VALUE output, VALUE kv, VALUE v_nested_mode) {
+  _url_encoded_seg(output, RSTRING_PTR(kv), RSTRING_LEN(kv), RTEST(v_nested_mode));
+  return output;
+}
+
+void nyara_parse_param(VALUE output, const char* s, size_t len) {
+  // split with /[&;] */
+  size_t last_i = 0;
+  size_t i = 0;
+  for (; i < len; i++) {
+    if (s[i] == '&' || s[i] == ';') {
+      if (i > last_i) {
+        _url_encoded_seg(output, s + last_i, i - last_i, 1);
+      }
+      while(i + 1 < len && s[i + 1] == ' ') {
+        i++;
+      }
+      last_i = i + 1;
+    }
+  }
+  if (i > last_i) {
+    _url_encoded_seg(output, s + last_i, i - last_i, 1);
+  }
+}
+
+static VALUE ext_parse_param(VALUE self, VALUE output, VALUE s) {
+  nyara_parse_param(output, RSTRING_PTR(s), RSTRING_LEN(s));
+  return output;
+}
+
+static VALUE _cookie_seg_str_new(const char* s, long len) {
+  // trim tailing space
+  for (; len > 0; len--) {
+    if (s[len - 1] != ' ') {
+      break;
+    }
+  }
+  return rb_enc_str_new(s, len, u8_encoding);
+}
+
+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);
+
+  // split with / *[,;] */
+  size_t last_i = 0;
+  size_t i = 0;
+  for (; i < len; i++) {
+    if (s[i] == ',' || s[i] == ';') {
+      // char* and len parse_seg
+      if (i > last_i) {
+        rb_ary_push(arr, _cookie_seg_str_new(s + last_i, i - last_i));
+      }
+      while(i + 1 < len && s[i + 1] == ' ') {
+        i++;
+      }
+      last_i = i + 1;
+    }
+  }
+  if (i > last_i) {
+    rb_ary_push(arr, _cookie_seg_str_new(s + last_i, i - last_i));
+  }
+
+  VALUE* arr_p = RARRAY_PTR(arr);
+  for (long j = RARRAY_LEN(arr) - 1; j >= 0; j--) {
+    _url_encoded_seg(output, RSTRING_PTR(arr_p[j]), RSTRING_LEN(arr_p[j]), 0);
+  }
+  return output;
+}
+
+void Init_url_encoded(VALUE ext) {
+  u8_encoding = rb_utf8_encoding();
+
+  rb_define_singleton_method(ext, "parse_param", ext_parse_param, 2);
+  rb_define_singleton_method(ext, "parse_cookie", ext_parse_cookie, 2);
+  // for test
+  rb_define_singleton_method(ext, "parse_url_encoded_seg", ext_parse_url_encoded_seg, 3);
+  rb_define_singleton_method(ext, "parse_path", ext_parse_path, 2);
+}

data/hello.rb

@@ -0,0 +1,5 @@
+require_relative "lib/nyara"
+
+get '/' do
+  send_string 'hello world'
+end

data/lib/nyara/config.rb

@@ -0,0 +1,64 @@
+module Nyara
+  # other options:
+  # - session (see also Session)
+  # - host
+  # - views
+  # - public
+  Config = ConfigHash.new
+  class << Config
+    def map prefix, controller
+      Route.register_controller prefix, controller
+    end
+
+    def port n
+      n = n.to_i
+      assert n >= 0 && n <= 65535
+      Config['port'] = n
+    end
+
+    def workers n
+      n = n.to_i
+      assert n > 0 && n < 1000
+      Config['workers'] = n
+    end
+
+    def env
+      self['env'].to_s
+    end
+
+    def development?
+      e = env
+      e.empty? or e == 'development'
+    end
+
+    def production?
+      env == 'production'
+    end
+
+    def test?
+      env == 'test'
+    end
+
+    alias set []=
+    alias get []
+
+    def assert expr
+      raise ArgumentError unless expr
+    end
+
+    # todo env aware configure
+    def configure &blk
+      instance_eval &blk
+    end
+  end
+end
+
+def configure *xs, &blk
+  Nyara::Config.configure *xs, &blk
+end
+
+configure do
+  set 'env', 'development'
+  set 'views', 'views'
+  set 'public', 'public'
+end