nyara 0.0.1.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cb0049e820e49ff09f09423ecce778a56834fd82
+  data.tar.gz: 30a2651c518f2f7c3db0581396b52ef1655c4ce8
+SHA512:
+  metadata.gz: b43a204aa71c4a3b1f2a94b21ee87be98d0e78348e93d9ba7439df27cb383cced9d1135e3ac1ce47e6bd7479d8542456360ce1c297399eaa77cfcce41871ea79
+  data.tar.gz: 955570020bccc660c5d7ae82ecad85c821988f92ebc80b4beffaa84575a1b487ccecf07be51d6041c7a88af62565e6a61260bec11009dacaf0c88814decedca7

data/example/design.rb

@@ -0,0 +1,62 @@
+meta '#hello', accept: %w[js html] | default is text/html, default / * not implemented yet
+get '/' do
+  send_data ... --> will make encoding chunked
+
+  # set resp status
+  status 302 | :not_found
+
+  # content type is separated out from render
+  content_type :js
+
+  # terminal action : render view, or file for download
+  render ..., layout: [a, b, c]
+
+  render file # choose renderer by ext
+  render :slim => template_content
+
+  ... Fiber.yield
+
+  s = stream ... # same arg as render
+  ...
+  r.resume
+  ...
+  r.resume
+
+  render :slim, 'content'
+
+  # terminal action
+  redirect_to path_for '...'
+  redirect_to '/'
+  redirect_to :back # referrer
+
+  # terminate process
+  halt status
+
+  # loop response
+  loop do
+    sleep 4
+    send_data ...
+  end
+
+  # can use accept when meta is configured, raise error if not configured
+  case accept
+  when 'html'
+    ...
+  when 'js'
+  end
+end
+
+# default is no scheme, the links start with // to fit all schemes
+configure url_for, default_scheme nil / 'https'
+
+url_for '#b', scheme: 'http', format: 'js', host: 'a.b.c:3000' # string keys are put in query
+
+path_for 'cont#action', 12, 3, :format => 'js', # string keys are put in query, (what about hash tags?)
+
+partial '...'
+
+# for middleware, we use life cycle callbacks
+# on :header_complete
+# on :init
+
+# before

data/example/fib.rb

@@ -0,0 +1,15 @@
+require "nyara"
+
+configure do
+  port 3000
+end
+
+def fib i
+  a, b = 0, 1
+  i.times { a, b = b, a + b }
+  a
+end
+
+get '/fib/%d' do |i|
+  send_string "fib(#{i}) = #{fib i}\n"
+end

data/example/hello.rb

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

data/example/stream.rb

@@ -0,0 +1,10 @@
+require "nyara"
+require "slim"
+
+get '/' do
+  view = stream 'index'
+  4.times do
+    sleep 1
+    view.resume
+  end
+end

data/ext/accept.c

@@ -0,0 +1,133 @@
+/* efficient Accpet-* value parser in C */
+
+#include "nyara.h"
+#include <ctype.h>
+#include "inc/str_intern.h"
+
+// standard:
+//   http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+// about +q+:
+//   http://www.gethifi.com/blog/browser-rest-http-accept-headers
+// +level+ is a waste of time:
+//   http://stackoverflow.com/questions/13890996/http-accept-level
+
+// sorted data structure
+typedef struct {
+  double* qs;
+  long len;
+  long cap;
+} QArray;
+
+static QArray qarray_new() {
+  QArray qa = {ALLOC_N(double, 10), 0, 10};
+  return qa;
+}
+
+// return inserted pos
+static long qarray_insert(QArray* qa, double v) {
+  if (qa->len == qa->cap) {
+    qa->cap *= 2;
+    REALLOC_N(qa->qs, double, qa->cap);
+  }
+  long i = 0;
+  for (; i < qa->len; i++) {
+    if (qa->qs[i] < v) {
+      memmove(qa->qs + i + 1, qa->qs + i, sizeof(double) * (qa->len - i));
+      break;
+    }
+  }
+  qa->qs[i] = v;
+  qa->len++;
+  return i;
+}
+
+static void qarray_delete(QArray* qa) {
+  xfree(qa->qs);
+}
+
+static VALUE trim_space(VALUE str) {
+  long olen = RSTRING_LEN(str);
+  str = rb_str_new(RSTRING_PTR(str), olen);
+  char* s = RSTRING_PTR(str);
+  long len = 0;
+  for (long i = 0; i < olen; i++) {
+    if (!isspace(s[i])) {
+      s[len++] = s[i];
+    }
+  }
+  STR_SET_LEN(str, len);
+  return str;
+}
+
+// stopped by ',' or EOS, return seg_len
+static long find_seg(const char* s, long len) {
+  long i = 0;
+  for (; i < len; i++) {
+    if (s[i] == ',') {
+      break;
+    }
+  }
+  return i;
+}
+
+// return first pointer to ';q='
+static const char* find_q(const char* s, long len) {
+  for (long i = 0; i < (len - 2); i++) {
+    if (s[i] == ';' && s[i+1] == 'q' && s[i+2] == '=') {
+      return s + i;
+    }
+  }
+  return NULL;
+}
+
+// parse a segment, and +out[value] = q+
+static void parse_seg(const char* s, long len, VALUE out, QArray* qa) {
+  double qval = 1;
+  const char* q = find_q(s, len);
+  if (q) {
+    if (q == s) {
+      return;
+    }
+    char* str_end = (char*)q + 3;
+    qval = strtod(q + 3, &str_end);
+    if (str_end == q + 3 || isnan(qval) || qval > 3) {
+      qval = 1;
+    } else if (qval <= 0) {
+      return;
+    }
+    len = q - s;
+  }
+  long pos = qarray_insert(qa, qval);
+  rb_ary_push(out, Qnil); // just to increase cap
+  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));
+}
+
+VALUE ext_parse_accept_value(VALUE _, VALUE str) {
+  if (str == Qnil) {
+    return rb_ary_new();
+  }
+
+  str = trim_space(str);
+  const char* s = RSTRING_PTR(str);
+  long len = RSTRING_LEN(str);
+  volatile VALUE out = rb_ary_new();
+  QArray qa = qarray_new();
+  while (len > 0) {
+    long seg_len = find_seg(s, len);
+    if (seg_len == 0) {
+      break;
+    }
+    parse_seg(s, seg_len, out, &qa);
+    s += seg_len + 1;
+    len -= seg_len + 1;
+  }
+  qarray_delete(&qa);
+  return out;
+}
+
+void Init_accept(VALUE ext) {
+  rb_define_singleton_method(ext, "parse_accept_value", ext_parse_accept_value, 1);
+}

data/ext/event.c

@@ -0,0 +1,89 @@
+#include "nyara.h"
+#include <sys/fcntl.h>
+#include <sys/socket.h>
+#include <errno.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#define ETYPE_ACCEPT 0
+#define ETYPE_REQUEST 1
+#define ETYPE_CONNECT 2
+#define MAX_E 1024
+static void loop_body(int fd, int etype);
+static int qfd;
+
+#ifdef HAVE_KQUEUE
+#include "inc/kqueue.h"
+#elif HAVE_EPOLL
+#include "inc/epoll.h"
+#endif
+
+static void set_nonblock(int fd) {
+  int flags;
+
+  if ((flags = fcntl(fd, F_GETFL)) == -1) {
+    rb_raise(rb_eRuntimeError, "fcntl(F_GETFL): %s", strerror(errno));
+  }
+  if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
+    rb_raise(rb_eRuntimeError, "fcntl(F_SETFL,O_NONBLOCK): %s", strerror(errno));
+  }
+}
+
+static VALUE ext_add(VALUE _, VALUE vfd) {
+  int fd = FIX2INT(vfd);
+  ADD_E(fd, ETYPE_CONNECT);
+  return Qnil;
+}
+
+// platform independent, invoked by LOOP_E()
+static void loop_body(int fd, int etype) {
+  switch (etype) {
+    case ETYPE_ACCEPT: {
+      int cfd = accept(fd, NULL, NULL);
+      if (cfd > 0) {
+        set_nonblock(cfd);
+        ADD_E(cfd, ETYPE_REQUEST);
+      }
+      break;
+    }
+    case ETYPE_REQUEST: {
+      nyara_handle_request(fd);
+      break;
+    }
+    case ETYPE_CONNECT: {
+      // todo
+      // NOTE
+      // fd and connection are 1:1, there can more more than 1 fds on a same file / address
+      // so it's streight forward to using fd as query index
+    }
+  }
+}
+
+static VALUE ext_init_queue(VALUE _) {
+  INIT_E();
+  return Qnil;
+}
+
+static VALUE ext_run_queue(VALUE _, VALUE v_fd) {
+  int fd = FIX2INT(v_fd);
+  set_nonblock(fd);
+  ADD_E(fd, ETYPE_ACCEPT);
+
+  LOOP_E();
+  return Qnil;
+}
+
+static VALUE ext_set_nonblock(VALUE _, VALUE v_fd) {
+  int fd = FIX2INT(v_fd);
+  set_nonblock(fd);
+  return Qnil;
+}
+
+void Init_event(VALUE ext) {
+  // rb_define_singleton_method(c, "add", add_q, 2);
+  rb_define_singleton_method(ext, "init_queue", ext_init_queue, 0);
+  rb_define_singleton_method(ext, "run_queue", ext_run_queue, 1);
+
+  // for test
+  rb_define_singleton_method(ext, "set_nonblock", ext_set_nonblock, 1);
+}

data/ext/extconf.rb

@@ -0,0 +1,34 @@
+require "mkmf"
+
+def tweak_include
+  dir = File.dirname __FILE__
+  multipart_dir = File.join dir, "multipart-parser-c"
+  http_parser_dir = File.join dir, "http-parser"
+  flags = " -I#{multipart_dir.shellescape} -I#{http_parser_dir.shellescape}"
+  $CFLAGS << flags
+  $CPPFLAGS << flags
+end
+
+def tweak_cflags
+  mf_conf = RbConfig::MAKEFILE_CONFIG
+  if mf_conf['CC'] =~ /clang/
+    # enable c++11. this can not be installed on $CPPFLAGS, wtf??
+    mf_conf['CXXFLAGS'] << ' -stdlib=libc++ -std=c++11'
+    $CFLAGS << ' $(xflags)'
+  else
+    mf_conf['CXXFLAGS'] << ' -std=c++11'
+    $CFLAGS << ' -std=c99 -Wno-declaration-after-statement $(xflags)'
+  end
+
+  $CPPFLAGS << ' $(xflags)'
+  puts "To enable debug: make xflags='-DDEBUG -O0'"
+end
+
+have_kqueue = (have_header("sys/event.h") and have_header("sys/queue.h"))
+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'}"
+
+tweak_include
+tweak_cflags
+create_makefile 'nyara'

data/ext/hashes.c

@@ -0,0 +1,130 @@
+// provide handy hash variants
+#include "nyara.h"
+#include <ruby/st.h>
+
+VALUE nyara_param_hash_class;
+VALUE nyara_header_hash_class;
+VALUE nyara_config_hash_class;
+
+// stolen from hash.c
+int nyara_rb_hash_has_key(VALUE hash, VALUE key) {
+  if (!RHASH(hash)->ntbl)
+    return 0;
+  if (st_lookup(RHASH(hash)->ntbl, key, 0))
+    return 1;
+  return 0;
+}
+
+// NOTE no need to add lots of methods like HashWithIndifferentAccess
+//      just return simple hash like rack
+
+static VALUE param_hash_aref(VALUE self, VALUE key) {
+  if (TYPE(key) == T_SYMBOL) {
+    key = rb_sym_to_s(key);
+  }
+  return rb_hash_aref(self, key);
+}
+
+static VALUE param_hash_key_p(VALUE self, VALUE key) {
+  if (TYPE(key) == T_SYMBOL) {
+    key = rb_sym_to_s(key);
+  }
+  return nyara_rb_hash_has_key(self, key) ? Qtrue : Qfalse;
+}
+
+static VALUE param_hash_aset(VALUE self, VALUE key, VALUE value) {
+  if (TYPE(key) == T_SYMBOL) {
+    key = rb_sym_to_s(key);
+  }
+  return rb_hash_aset(self, key, value);
+}
+
+void nyara_headerlize(VALUE str) {
+  char* s = (char*)RSTRING_PTR(str);
+  long len = RSTRING_LEN(str);
+  int border = 1;
+  for (long i = 0; i < len; i++) {
+    if (s[i] == '-') {
+      border = 1;
+      continue;
+    }
+    if (border) {
+      // note this is most reliable way,
+      // with <ctype.h> we have to deal with locale...
+      if (s[i] >= 'a' && s[i] <= 'z') {
+        s[i] = 'A' + (s[i] - 'a');
+      }
+      border = 0;
+    } else {
+      if (s[i] >= 'A' && s[i] <= 'Z') {
+        s[i] = 'a' + (s[i] - 'A');
+      }
+    }
+  }
+}
+
+static VALUE header_hash_tidy_key(VALUE key) {
+  if (TYPE(key) == T_SYMBOL) {
+    key = rb_sym_to_s(key);
+  }
+  Check_Type(key, T_STRING);
+  key = rb_str_new(RSTRING_PTR(key), RSTRING_LEN(key));
+  nyara_headerlize(key);
+  return key;
+}
+
+static VALUE header_hash_aref(VALUE self, VALUE key) {
+  return rb_hash_aref(self, header_hash_tidy_key(key));
+}
+
+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 VALUE header_hash_aset(VALUE self, VALUE key, VALUE value) {
+  key = header_hash_tidy_key(key);
+  if (TYPE(value) != T_STRING) {
+    value = rb_funcall(value, id_to_s, 0);
+  }
+
+  return rb_hash_aset(self, key, value);
+}
+
+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);
+  }
+  return ST_CONTINUE;
+}
+
+static VALUE header_hash_reverse_merge_bang(VALUE self, VALUE other) {
+  if (!rb_obj_is_kind_of(other, nyara_header_hash_class)) {
+    rb_raise(rb_eArgError, "need a Nyara::HeaderHash");
+  }
+  st_table* t = rb_hash_tbl(self);
+  rb_hash_foreach(other, header_hash_merge_func, (VALUE)t);
+  return self;
+}
+
+void Init_hashes(VALUE nyara) {
+  id_to_s = rb_intern("to_s");
+
+  nyara_param_hash_class = rb_define_class_under(nyara, "ParamHash", rb_cHash);
+  nyara_header_hash_class = rb_define_class_under(nyara, "HeaderHash", nyara_param_hash_class);
+  nyara_config_hash_class = rb_define_class_under(nyara, "ConfigHash", nyara_param_hash_class);
+
+  rb_define_method(nyara_param_hash_class, "[]", param_hash_aref, 1);
+  rb_define_method(nyara_param_hash_class, "key?", param_hash_key_p, 1);
+  rb_define_method(nyara_param_hash_class, "[]=", param_hash_aset, 2);
+
+  rb_define_method(nyara_header_hash_class, "[]", header_hash_aref, 1);
+  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);
+
+  // for internal use
+  rb_define_method(nyara_header_hash_class, "_aset", rb_hash_aset, 2);
+  rb_define_method(nyara_header_hash_class, "_aref", rb_hash_aref, 1);
+}

data/ext/http-parser/AUTHORS

@@ -0,0 +1,41 @@
+# Authors ordered by first contribution.
+Ryan Dahl <ry@tinyclouds.org>
+Jeremy Hinegardner <jeremy@hinegardner.org>
+Sergey Shepelev <temotor@gmail.com>
+Joe Damato <ice799@gmail.com>
+tomika <tomika_nospam@freemail.hu>
+Phoenix Sol <phoenix@burninglabs.com>
+Cliff Frey <cliff@meraki.com>
+Ewen Cheslack-Postava <ewencp@cs.stanford.edu>
+Santiago Gala <sgala@apache.org>
+Tim Becker <tim.becker@syngenio.de>
+Jeff Terrace <jterrace@gmail.com>
+Ben Noordhuis <info@bnoordhuis.nl>
+Nathan Rajlich <nathan@tootallnate.net>
+Mark Nottingham <mnot@mnot.net>
+Aman Gupta <aman@tmm1.net>
+Tim Becker <tim.becker@kuriositaet.de>
+Sean Cunningham <sean.cunningham@mandiant.com>
+Peter Griess <pg@std.in>
+Salman Haq <salman.haq@asti-usa.com>
+Cliff Frey <clifffrey@gmail.com>
+Jon Kolb <jon@b0g.us>
+Fouad Mardini <f.mardini@gmail.com>
+Paul Querna <pquerna@apache.org>
+Felix Geisendörfer <felix@debuggable.com>
+koichik <koichik@improvement.jp>
+Andre Caron <andre.l.caron@gmail.com>
+Ivo Raisr <ivosh@ivosh.net>
+James McLaughlin <jamie@lacewing-project.org>
+David Gwynne <loki@animata.net>
+Thomas LE ROUX <thomas@november-eleven.fr>
+Randy Rizun <rrizun@ortivawireless.com>
+Andre Louis Caron <andre.louis.caron@usherbrooke.ca>
+Simon Zimmermann <simonz05@gmail.com>
+Erik Dubbelboer <erik@dubbelboer.com>
+Martell Malone <martellmalone@gmail.com>
+Bertrand Paquet <bpaquet@octo.com>
+BogDan Vatra <bogdan@kde.org>
+Peter Faiman <peter@thepicard.org>
+Corey Richardson <corey@octayn.net>
+Tóth Tamás <tomika_nospam@freemail.hu>

data/ext/http-parser/CONTRIBUTIONS

@@ -0,0 +1,4 @@
+Contributors must agree to the Contributor License Agreement before patches
+can be accepted.
+
+http://spreadsheets2.google.com/viewform?hl=en&formkey=dDJXOGUwbzlYaWM4cHN1MERwQS1CSnc6MQ

data/ext/http-parser/LICENSE-MIT

@@ -0,0 +1,23 @@
+http_parser.c is based on src/http/ngx_http_parse.c from NGINX copyright
+Igor Sysoev.
+
+Additional changes are licensed under the same terms as NGINX and
+copyright Joyent, Inc. and other Node contributors. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.