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

data/ext/request_parse.c

@@ -2,17 +2,92 @@
 
 #include "nyara.h"
 #include "request.h"
+#include <ruby/re.h>
 
+static ID id_update;
+static ID id_final;
 static VALUE str_accept;
+static VALUE str_content_type;
 static VALUE method_override_key;
 static VALUE nyara_http_methods;
 
+static int mp_header_field(multipart_parser* parser, const char* s, size_t len) {
+  Request* p = multipart_parser_get_data(parser);
+  if (p->last_part == Qnil) {
+    p->last_part = rb_hash_new();
+  }
+
+  if (p->last_field == Qnil) {
+    p->last_field = rb_enc_str_new(s, len, u8_encoding);
+    p->last_value = Qnil;
+  } else {
+    rb_str_cat(p->last_field, s, len);
+  }
+  return 0;
+}
+
+static int mp_header_value(multipart_parser* parser, const char* s, size_t len) {
+  Request* p = multipart_parser_get_data(parser);
+  if (p->last_field == Qnil) {
+    if (p->last_value == Qnil) {
+      p->parse_state = PS_ERROR;
+      return 1;
+    }
+    rb_str_cat(p->last_value, s, len);
+  } else {
+    nyara_headerlize(p->last_field);
+    p->last_value = rb_enc_str_new(s, len, u8_encoding);
+    rb_hash_aset(p->last_part, p->last_field, p->last_value);
+    p->last_field = Qnil;
+  }
+  return 0;
+}
+
+static int mp_headers_complete(multipart_parser* parser) {
+  static VALUE part_class = Qnil;
+  if (part_class == Qnil) {
+    VALUE nyara = rb_const_get(rb_cModule, rb_intern("Nyara"));
+    part_class = rb_const_get(nyara, rb_intern("Part"));
+  }
+
+  Request* p = multipart_parser_get_data(parser);
+  p->last_field = Qnil;
+  p->last_value = Qnil;
+  p->last_part = rb_class_new_instance(1, &p->last_part, part_class);
+  return 0;
+}
+
+static int mp_part_data(multipart_parser* parser, const char* s, size_t len) {
+  Request* p = multipart_parser_get_data(parser);
+  rb_funcall(p->last_part, id_update, 1, rb_str_new(s, len)); // no need encoding
+  return 0;
+}
+
+static int mp_part_data_end(multipart_parser* parser) {
+  Request* p = multipart_parser_get_data(parser);
+  rb_ary_push(p->body, rb_funcall(p->last_part, id_final, 0));
+  p->last_part = Qnil;
+  return 0;
+}
+
+static multipart_parser_settings multipart_settings = {
+  .on_header_field = mp_header_field,
+  .on_header_value = mp_header_value,
+  .on_headers_complete = mp_headers_complete,
+
+  .on_part_data_begin = NULL,
+  .on_part_data = mp_part_data,
+  .on_part_data_end = mp_part_data_end,
+
+  .on_body_end = NULL
+};
+
 static int on_url(http_parser* parser, const char* s, size_t len) {
   Request* p = (Request*)parser;
   p->method = parser->method;
 
   if (p->path_with_query == Qnil) {
-    p->path_with_query = rb_str_new(s, len);
+    p->path_with_query = rb_enc_str_new(s, len, u8_encoding);
   } else {
     rb_str_cat(p->path_with_query, s, len);
   }
@@ -22,7 +97,7 @@ static int on_url(http_parser* parser, const char* s, size_t len) {
 static int on_header_field(http_parser* parser, const char* s, size_t len) {
   Request* p = (Request*)parser;
   if (p->last_field == Qnil) {
-    p->last_field = rb_str_new(s, len);
+    p->last_field = rb_enc_str_new(s, len, u8_encoding);
     p->last_value = Qnil;
   } else {
     rb_str_cat(p->last_field, s, len);
@@ -40,7 +115,7 @@ static int on_header_value(http_parser* parser, const char* s, size_t len) {
     rb_str_cat(p->last_value, s, len);
   } else {
     nyara_headerlize(p->last_field);
-    p->last_value = rb_str_new(s, len);
+    p->last_value = rb_enc_str_new(s, len, u8_encoding);
     rb_hash_aset(p->header, p->last_field, p->last_value);
     p->last_field = Qnil;
   }
@@ -79,6 +154,39 @@ static void _parse_path_and_query(Request* p) {
   }
 }
 
+static char* _parse_multipart_boundary(VALUE header) {
+  static regex_t* re = NULL;
+  static OnigRegion region;
+  if (!re) {
+    // rfc2046
+    // regexp copied from rack
+    const char* pattern = "\\Amultipart/.*boundary=\\\"?([^\\\";,]+)\\\"?";
+    onig_new(&re, (const UChar*)pattern, (const UChar*)(pattern + strlen(pattern)),
+             ONIG_OPTION_NONE, ONIG_ENCODING_ASCII, ONIG_SYNTAX_RUBY, NULL);
+    onig_region_init(&region);
+  }
+
+  VALUE content_type = rb_hash_aref(header, str_content_type);
+  if (content_type == Qnil) {
+    return NULL;
+  }
+
+  long len = RSTRING_LEN(content_type);
+  char* s = RSTRING_PTR(content_type);
+
+  long matched_len = onig_match(re, (const UChar*)s, (const UChar*)(s + len), (const UChar*)s, &region, 0);
+  if (matched_len > 0) {
+    // multipart-parser needs a buffer to end with '\0'
+    long boundary_len = region.end[0] - region.beg[0];
+    char* boundary_bytes = ALLOC_N(char, boundary_len + 1);
+    memcpy(boundary_bytes, s + region.beg[0], boundary_len);
+    boundary_bytes[boundary_len] = '\0';
+    return boundary_bytes;
+  } else {
+    return NULL;
+  }
+}
+
 static int on_headers_complete(http_parser* parser) {
   Request* p = (Request*)parser;
   p->last_field = Qnil;
@@ -87,11 +195,28 @@ static int on_headers_complete(http_parser* parser) {
   _parse_path_and_query(p);
   p->accept = ext_parse_accept_value(Qnil, rb_hash_aref(p->header, str_accept));
   p->parse_state = PS_HEADERS_COMPLETE;
+
+  char* boundary = _parse_multipart_boundary(p->header);
+  if (boundary) {
+    p->mparser = multipart_parser_init(boundary, &multipart_settings);
+    xfree(boundary);
+    multipart_parser_set_data(p->mparser, p);
+    p->body = rb_ary_new();
+  } else {
+    p->body = rb_enc_str_new("", 0, u8_encoding);
+  }
+
   return 0;
 }
 
 static int on_body(http_parser* parser, const char* s, size_t len) {
-  // todo
+  Request* p = (Request*)parser;
+  if (p->mparser) {
+    multipart_parser_execute(p->mparser, s, len);
+    // todo sum total length, if too big, trigger save to tmpfile
+  } else {
+    rb_str_cat(p->body, s, len);
+  }
   return 0;
 }
 
@@ -114,9 +239,13 @@ http_parser_settings nyara_request_parse_settings = {
 };
 
 void Init_request_parse(VALUE nyara) {
-  str_accept = rb_str_new2("Accept");
+  id_update = rb_intern("update");
+  id_final = rb_intern("final");
+  str_accept = rb_enc_str_new("Accept", strlen("Accept"), u8_encoding);
   rb_gc_register_mark_object(str_accept);
-  method_override_key = rb_str_new2("_method");
+  str_content_type = rb_enc_str_new("Content-Type", strlen("Content-Type"), u8_encoding);
+  rb_gc_register_mark_object(str_content_type);
+  method_override_key = rb_enc_str_new("_method", strlen("_method"), u8_encoding);
   OBJ_FREEZE(method_override_key);
   rb_const_set(nyara, rb_intern("METHOD_OVERRIDE_KEY"), method_override_key);
   nyara_http_methods = rb_const_get(nyara, rb_intern("HTTP_METHODS"));

data/ext/route.cc

@@ -4,7 +4,6 @@ extern "C" {
 #include "nyara.h"
 }
 #include <ruby/re.h>
-#include <ruby/encoding.h>
 #include <vector>
 #include <map>
 #include "inc/str_intern.h"
@@ -52,7 +51,6 @@ typedef RouteMap::iterator MapIter;
 static RouteMap 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;
 
@@ -169,13 +167,13 @@ static VALUE ext_list_route(VALUE self) {
   for (MapIter j = route_map.begin(); j != route_map.end(); j++) {
     RouteEntries* route_entries = j->second;
     arr = rb_ary_new();
-    rb_hash_aset(route_hash, rb_str_new2(http_method_str(j->first)), arr);
+    rb_hash_aset(route_hash, rb_enc_str_new(http_method_str(j->first), strlen(http_method_str(j->first)), u8_encoding), arr);
     for (EntriesIter 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, rb_enc_str_new(i->prefix, i->prefix_len, u8_encoding));
+      rb_ary_push(e, rb_enc_str_new(i->suffix, i->suffix_len, u8_encoding));
       rb_ary_push(e, i->controller);
       rb_ary_push(e, i->id);
       conv = rb_ary_new();
@@ -191,13 +189,13 @@ static VALUE ext_list_route(VALUE self) {
 
 static VALUE build_args(const char* suffix, std::vector<ID>& conv) {
   volatile VALUE args = rb_ary_new();
-  volatile VALUE str = rb_str_new2("");
+  volatile VALUE str = rb_str_new2(""); // tmp for conversion, no need encoding
   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));
+      rb_ary_push(args, rb_enc_str_new(capture_ptr, capture_len, u8_encoding));
     } else if (capture_len == 0) {
       rb_ary_push(args, Qnil);
     } else {
@@ -224,7 +222,7 @@ static VALUE extract_ext(const char* s, long len) {
       return Qnil;
     }
   }
-  return rb_str_new(s, len);
+  return rb_enc_str_new(s, len, u8_encoding);
 }
 
 extern "C"
@@ -320,8 +318,7 @@ 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");
+  str_html = rb_enc_str_new("html", strlen("html"), u8_encoding);
   OBJ_FREEZE(str_html);
   rb_gc_register_mark_object(str_html);
   onig_region_init(&region);

data/ext/test_response.c

@@ -0,0 +1,155 @@
+/* response parse callbacks, for test helper */
+
+#include "nyara.h"
+
+typedef struct {
+  http_parser hparser;
+  VALUE header;
+  VALUE body;
+  VALUE last_field;
+  VALUE last_value;
+  VALUE set_cookies;
+} Response;
+
+static VALUE str_set_cookie;
+static VALUE nyara_http_methods;
+
+static int on_header_field(http_parser* parser, const char* s, size_t len) {
+  Response* p = (Response*)parser;
+  if (p->last_field == Qnil) {
+    p->last_field = rb_enc_str_new(s, len, u8_encoding);
+    p->last_value = Qnil;
+  } else {
+    rb_str_cat(p->last_field, s, len);
+  }
+  return 0;
+}
+
+static int on_header_value(http_parser* parser, const char* s, size_t len) {
+  Response* p = (Response*)parser;
+  if (p->last_field == Qnil) {
+    if (p->last_value == Qnil) {
+      // todo show where
+      rb_raise(rb_eRuntimeError, "parse error");
+      return 1;
+    }
+    rb_str_cat(p->last_value, s, len);
+  } else {
+    nyara_headerlize(p->last_field);
+    p->last_value = rb_enc_str_new(s, len, u8_encoding);
+    if (RTEST(rb_funcall(p->last_field, rb_intern("=="), 1, str_set_cookie))) {
+      rb_ary_push(p->set_cookies, p->last_value);
+    } else {
+      rb_hash_aset(p->header, p->last_field, p->last_value);
+    }
+    p->last_field = Qnil;
+  }
+  return 0;
+}
+
+static int on_headers_complete(http_parser* parser) {
+  Response* p = (Response*)parser;
+  p->last_field = Qnil;
+  p->last_value = Qnil;
+  return 0;
+}
+
+static int on_body(http_parser* parser, const char* s, size_t len) {
+  Response* p = (Response*)parser;
+  if (p->body == Qnil) {
+    p->body = rb_enc_str_new(s, len, u8_encoding);
+  } else {
+    rb_str_cat(p->body, s, len);
+  }
+  return 0;
+}
+
+static int on_message_complete(http_parser* parser) {
+  Response* p = (Response*)parser;
+  p->last_field = Qnil;
+  p->last_value = Qnil;
+  return 0;
+}
+
+static http_parser_settings response_parse_settings = {
+  .on_message_begin = NULL,
+  .on_url = NULL,
+  .on_status_complete = NULL,
+  .on_header_field = on_header_field,
+  .on_header_value = on_header_value,
+  .on_headers_complete = on_headers_complete,
+  .on_body = on_body,
+  .on_message_complete = on_message_complete
+};
+
+static void response_mark(void* pp) {
+  Response* p = pp;
+  if (p) {
+    rb_gc_mark_maybe(p->header);
+    rb_gc_mark_maybe(p->body);
+    rb_gc_mark_maybe(p->last_field);
+    rb_gc_mark_maybe(p->last_value);
+    rb_gc_mark_maybe(p->set_cookies);
+  }
+}
+
+static VALUE response_alloc(VALUE klass) {
+  Response* p = ALLOC(Response);
+  http_parser_init(&(p->hparser), HTTP_RESPONSE);
+  p->header = Qnil;
+  p->body = Qnil;
+  p->last_field = Qnil;
+  p->last_value = Qnil;
+  p->set_cookies = Qnil;
+  // NOTE new in alloc func will crash GCC-4.2/4.6 in GC.stress mode
+  return Data_Wrap_Struct(klass, response_mark, xfree, p);
+}
+
+static VALUE response_initialize(VALUE self, VALUE data) {
+  Check_Type(data, T_STRING);
+  Response* p;
+  Data_Get_Struct(self, Response, p);
+  p->header = rb_class_new_instance(0, NULL, nyara_header_hash_class);
+  p->set_cookies = rb_ary_new();
+  http_parser_execute(&(p->hparser), &response_parse_settings, RSTRING_PTR(data), RSTRING_LEN(data));
+  return self;
+}
+
+static VALUE response_header(VALUE self) {
+  Response* p;
+  Data_Get_Struct(self, Response, p);
+  return p->header;
+}
+
+static VALUE response_body(VALUE self) {
+  Response* p;
+  Data_Get_Struct(self, Response, p);
+  return p->body;
+}
+
+static VALUE response_status(VALUE self) {
+  Response* p;
+  Data_Get_Struct(self, Response, p);
+  return INT2FIX(p->hparser.status_code);
+}
+
+static VALUE response_set_cookies(VALUE self) {
+  Response* p;
+  Data_Get_Struct(self, Response, p);
+  return p->set_cookies;
+}
+
+void Init_test_response(VALUE nyara) {
+  str_set_cookie = rb_enc_str_new("Set-Cookie", strlen("Set-Cookie"), u8_encoding);
+  rb_gc_register_mark_object(str_set_cookie);
+
+  nyara_http_methods = rb_const_get(nyara, rb_intern("HTTP_METHODS"));
+  VALUE test = rb_define_module_under(nyara, "Test");
+  VALUE response = rb_define_class_under(test, "Response", rb_cObject);
+  rb_define_alloc_func(response, response_alloc);
+  rb_define_method(response, "initialize", response_initialize, 1);
+  rb_define_method(response, "header", response_header, 0);
+  rb_define_method(response, "body", response_body, 0);
+  rb_define_method(response, "status", response_status, 0);
+  rb_define_method(response, "set_cookies", response_set_cookies, 0);
+}

data/ext/url_encoded.c

@@ -1,9 +1,6 @@
 /* url-encoded parsing */
 
 #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:
@@ -354,8 +351,6 @@ static VALUE ext_parse_cookie(VALUE self, VALUE output, VALUE str) {
 }
 
 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

data/lib/nyara/config.rb

@@ -6,6 +6,11 @@ module Nyara
   # - public
   Config = ConfigHash.new
   class << Config
+    def reset
+      clear
+      Route.clear
+    end
+
     def map prefix, controller
       Route.register_controller prefix, controller
     end

data/lib/nyara/controller.rb

@@ -15,7 +15,7 @@ module Nyara
         action.http_method = HTTP_METHODS[method]
         action.path = path
         action.set_accept_exts @formats
-        action.id = @curr_id.to_sym if @curr_id
+        action.id = @curr_id if @curr_id
         action.blk = blk
         @route_entries << action
 
@@ -45,7 +45,7 @@ module Nyara
         if tag
           # todo scan class
           id = tag[/\#\w++(\-\w++)*/]
-          @curr_id = id
+          @curr_id = id.to_sym
         end
 
         if opts
@@ -81,8 +81,8 @@ module Nyara
         http 'PATCH', path, &blk
       end
 
-      # HTTP OPTIONS
-      # todo generate options response for a url
+      # HTTP OPTIONS<br>
+      # todo generate options response for a url<br>
       # see http://tools.ietf.org/html/rfc5789
       def options path, &blk
         http 'OPTIONS', path, &blk
@@ -104,8 +104,7 @@ module Nyara
       end
       attr_reader :controller_name
 
-      # :nodoc:
-      def preprocess_actions
+      def compile_route_entries scope # :nodoc:
         raise "#{self}: no action defined" unless @route_entries
 
         curr_id = :'#0'
@@ -118,68 +117,127 @@ module Nyara
         }
         next_id[]
 
+        @path_templates = {}
         @route_entries.each do |e|
-          e.id ||= next_id[]
+          e.id = next_id[] if e.id.empty?
           define_method e.id, &e.blk
+          e.compile self, scope
+          e.validate
+          @path_templates[e.id] = e.path_template
         end
         @route_entries
       end
+
+      attr_accessor :path_templates
     end
 
     include Renderable
 
-    # :nodoc:
     def self.inherited klass
       # klass will also have this inherited method
       # todo check class name
       klass.extend ClassMethods
-      [:@route_entries, :@usred_ids, :@default_layout].each do |iv|
+      [:@used_ids, :@default_layout].each do |iv|
         klass.instance_variable_set iv, klass.superclass.instance_variable_get(iv)
       end
+
+      route_entries = klass.superclass.instance_variable_get :@route_entries
+      if route_entries
+        route_entries.map! {|e| e.dup }
+        klass.instance_variable_set :@route_entries, route_entries
+      end
     end
 
     # Path helper
-    def path_for id, *args
+    def path_to id, *args
       if args.last.is_a?(Hash)
         opts = args.pop
       end
 
-      r = Route.path_template(self.class, id) % args
+      r = self.class.path_templates[id.to_s] % args
 
       if opts
-        r << ".#{opts[:format]}" if opts[:format]
-        query = opts.map do |k, v|
-          next if k == :format
-          "#{CGI.escape k.to_s}=#{CGI.escape v}"
-        end
-        query.compact!
-        r << '?' << query.join('&') unless query.empty?
+        format = opts.delete :format
+        r << ".#{format}" if format
+        r << '?' << opts.to_query unless opts.empty?
       end
       r
     end
 
-    # Url helper
-    # NOTE: host can include port
-    def url_for id, *args, scheme: nil, host: Config['host'], **opts
+    # Url helper<br>
+    # NOTE: host string can include port number<br>
+    # TODO: user and password?
+    def url_to id, *args, scheme: nil, host: nil, **opts
       scheme = scheme ? scheme.sub(/\:?$/, '://') : '//'
-      host ||= 'localhost'
-      path = path_for id, *args, opts
+      host ||= request.host_with_port
+      path = path_to id, *args, opts
       scheme << host << path
     end
 
+    # Redirect to a url or path, terminates action<br>
+    # +status+ can be one of:
+    #
+    # - 300 multiple choices (e.g. offer different languages)
+    # - 301 moved permanently
+    # - 302 found (default)
+    # - 303 see other (e.g. for results of cgi-scripts)
+    # - 307 temporary redirect
+    #
+    # Caveats: there's no content in a redirect response yet, if you want one, you can configure nginx to add it
+    def redirect url_or_path, status=302
+      status = status.to_i
+      raise "unsupported redirect status: #{status}" unless HTTP_REDIRECT_STATUS.include?(status)
+
+      r = request
+      header = r.header
+      self.status status
+
+      uri = URI.parse url_or_path
+      if uri.host.nil?
+        uri.host = request.domain
+        uri.port = request.port
+      end
+      uri.scheme = r.ssl? ? 'https' : 'http'
+      r.header['Location'] = uri.to_s
+
+      # similar to send_header, but without content-type
+      Ext.request_send_data r, HTTP_STATUS_FIRST_LINES[r.status]
+      data = header.serialize
+      data.concat r.response_header_extra_lines
+      data << "\r\n"
+      Ext.request_send_data r, data.join
+
+      Fiber.yield :term_close
+    end
+
+    # Shortcut for +redirect url_to *xs+
+    def redirect_to *xs
+      redirect url_to(*xs)
+    end
+
+    # Request extension or generated by `Accept`
     def format
       request.format
     end
 
+    # Request header<br>
+    # NOTE to change response header, use +set_header+
     def header
       request.header
     end
     alias headers header
 
-    def set_header k, v
-      request.response_header[k] = v
+    # Set response header
+    def set_header field, value
+      request.response_header[field] = value
     end
 
+    # Append an extra line in reponse header
+    #
+    # :call-seq:
+    #
+    #   add_header_line "X-Myheader: here we are"
+    #
     def add_header_line h
       raise 'can not modify sent header' if request.response_header.frozen?
       h = h.sub /(?<![\r\n])\z/, "\r\n"
@@ -239,6 +297,10 @@ module Nyara
       request.session
     end
 
+    def flash
+      request.flash
+    end
+
     # Set response status
     def status n
       raise ArgumentError, "unsupported status: #{n}" unless HTTP_STATUS_FIRST_LINES[n]
@@ -268,15 +330,16 @@ module Nyara
 
       header.reverse_merge! OK_RESP_HEADER
 
-      data = header.map do |k, v|
-        "#{k}: #{v}\r\n"
-      end
+      data = header.serialize
       data.concat r.response_header_extra_lines
+      data << Session.encode_set_cookie(r.session, r.ssl?)
       data << "\r\n"
       Ext.request_send_data r, data.join
 
       # forbid further modification
       header.freeze
+      session.freeze
+      flash.next.freeze
     end
 
     # Send raw data, that is, not wrapped in chunked encoding<br>

data/lib/nyara/cookie.rb

@@ -3,6 +3,13 @@ module Nyara
   module Cookie
     extend self
 
+    # encode to string value
+    def encode h
+      h.map do |k, v|
+        "#{CGI.escape k.to_s}=#{CGI.escape v.to_s}"
+      end.join '; '
+    end
+
     def decode header
       res = ParamHash.new
       if data = header['Cookie']