nyara 0.1.pre.0 → 0.1.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8488241a4b245171cf578a271e64cde4bcb5e992
-  data.tar.gz: 157848c9c7f726ebc67fbb9f63fb823274ed2312
+  metadata.gz: e8806d56e981db23403ba6662c31af80629c2afd
+  data.tar.gz: 98d333128c7785a3b32e49ffbf4c7cc16f570c16
 SHA512:
-  metadata.gz: dfc38bc4139cdae9178f69db59bffc2fa46867bb40864e8c1df13f80ca9a95707795ed2a48c9a4b3cc2c248726571cfbff062d515c2bf113095d5deafc89003f
-  data.tar.gz: 9d40524878b0ca0ba9d1606c9ad4f4336dc51ac042946fc53b04285dfbc8625248629522d1497cd36a1e9d95d4c4e00b8646ce0d84d8e936264bf7ca53a5eecd
+  metadata.gz: 79b6568857f0ef7fb6e5bd3d2286f68777554536e4223e592e48cface08b0754c3c4b725a7b52838617f48d1ee969c1aa412e3a3eae0710d5f1ef0d488ed3b7c
+  data.tar.gz: 5790f2a3e825c6eec82c0befab9a9e596894e71996ae922c63ca3bac48a5e1c0caf818cfd5f2a0cbc7347f6eff934ad36139e2ca8d4fd3b4687cd829308977a3

data/bin/nyara

@@ -1,17 +1,5 @@
 #!/usr/bin/env ruby
 require_relative "../lib/nyara/nyara"
+require_relative "../lib/nyara/command"
 
-args = ARGV.dup
-task_name = args.shift || 'help'
-
-
-case task_name
-when 'help', '-h'
-  Nyara::Command.help
-when '-v'
-  Nyara::Command.version
-when 'new'
-  Nyara::Command.new_project(*args)
-when 's','server'
-  Nyara::Command.run_server(*args)
-end
+Nyara::Command.start

data/changes

@@ -1,3 +1,6 @@
+2013-08-17 integrate with linner
+2013-08-16 use thor for `nyara` commands
+2013-08-15 (developers) migrated to git subtree, you don't need to hand-update submodules anymore
 2013-07-18 add automatic reloader for development mode
 2013-07-13 add bin script `nyara`
 2013-07-10 add before filter

data/example/factorial.rb

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

data/example/hello.rb

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

data/example/project.rb

@@ -0,0 +1,11 @@
+require_relative "../lib/nyara"
+
+configure do
+  set :root, __dir__
+  set :public, 'public'
+  set :views, 'views'
+end
+
+get '/' do
+  send_string 'hello'
+end

data/example/stream.rb

@@ -0,0 +1,14 @@
+require_relative "../lib/nyara"
+require "pry"
+
+configure do
+  set :root, __dir__
+end
+
+get '/' do
+  view = stream 'index'
+  4.times do
+    sleep 1
+    view.resume
+  end
+end

data/ext/extconf.rb

@@ -1,5 +1,23 @@
+Dir.chdir __dir__
 require "mkmf"
 
+def generate_version_file
+  version_file = 'inc/version.inc'
+  puts "generating: #{version_file}"
+  lines = File.readlines('../nyara.gemspec')
+  version = nil
+  lines.each do |line|
+    if line =~ /s\.version =/
+      version = line[/\d+(\.\d+)*(\.pre\.\d+)?/]
+      break
+    end
+  end
+  abort 'version not found' unless version
+  File.open version_file, 'w' do |f|
+    f.puts %Q{#define NYARA_VERSION "#{version}"}
+  end
+end
+
 def tweak_include
   dir = File.dirname __FILE__
   multipart_dir = File.join dir, "multipart-parser-c"
@@ -35,4 +53,5 @@ have_func('rb_ary_new_capa', 'ruby.h')
 
 tweak_include
 tweak_cflags
+generate_version_file
 create_makefile 'nyara'

data/ext/hashes.c

@@ -2,7 +2,9 @@
 
 #include "nyara.h"
 #include <ruby/st.h>
+#include <assert.h>
 #include "inc/str_intern.h"
+#include "inc/ary_intern.h"
 #include <ctype.h>
 
 VALUE nyara_param_hash_class;
@@ -42,29 +44,26 @@ static VALUE param_hash_aset(VALUE self, VALUE key, VALUE value) {
   return rb_hash_aset(self, key, value);
 }
 
-// prereq: name should be already url decoded <br>
-// "a[b][][c]" ==> ["a", "b", "", "c"]
-static VALUE param_hash_split_name(VALUE _, VALUE name) {
-  Check_Type(name, T_STRING);
+// replace content of keys with split name
+// existing prefices are not replaced for minimal allocation
+static VALUE _split_name(volatile VALUE name) {
   long len = RSTRING_LEN(name);
   if (len == 0) {
     rb_raise(rb_eArgError, "name should not be empty");
   }
   char* s = RSTRING_PTR(name);
 
-  // NOTE it's OK to compare utf-8 string with ascii chars, because utf-8 code units are either:
-  // - byte with 0 in highest nibble, which is ascii char
-  // - bytes with 1 in highest nibble, which can not be eql to any ascii char
-
   volatile VALUE keys = rb_ary_new();
+# define INSERT(s, len) \
+    rb_ary_push(keys, rb_enc_str_new(s, len, u8_encoding))
+
   long i;
   for (i = 0; i < len; i++) {
     if (s[i] == '[') {
       if (i == 0) {
         rb_raise(rb_eArgError, "bad name (starts with '[')");
       }
-      volatile VALUE key = rb_enc_str_new(s, i, u8_encoding);
-      rb_ary_push(keys, key);
+      INSERT(s, i);
       i++;
       break;
     } else if (s[i] == ']') {
@@ -80,8 +79,7 @@ static VALUE param_hash_split_name(VALUE _, VALUE name) {
     for (long j = last_j; j < len; j++) {
       if (s[j] == ']') {
         if (j == len - 1 || s[j + 1] == '[') {
-          volatile VALUE key = rb_enc_str_new(s + last_j, j - last_j, u8_encoding);
-          rb_ary_push(keys, key);
+          INSERT(s + last_j, j - last_j);
           last_j = j + 2; // fine for last round
           j++;
         } else {
@@ -95,70 +93,155 @@ static VALUE param_hash_split_name(VALUE _, VALUE name) {
     // single key
     rb_ary_push(keys, name);
   }
+# undef INSERT
   return keys;
 }
 
-// assume keys = [a, b, c] ==> self[a][b][c] = value
-// blank keys will be translated as array keys.
-// created hashes has the same class with output
-// todo make 2 versions, one for public use
-static VALUE param_hash_nested_aset(VALUE output, volatile VALUE keys, VALUE value) {
+// prereq: name should be already url decoded <br>
+// "a[b][][c]" ==> ["a", "b", "", "c"]
+static VALUE param_hash_split_name(VALUE _, VALUE name) {
+  Check_Type(name, T_STRING);
+  return _split_name(name);
+}
+
+// prereq: all elements in keys are string
+static VALUE param_hash_nested_aref(volatile VALUE obj, VALUE keys) {
   Check_Type(keys, T_ARRAY);
-  VALUE* arr = RARRAY_PTR(keys);
-  long len = RARRAY_LEN(keys);
-  if (!len) {
-    rb_raise(rb_eArgError, "aset 0 length key");
-    return Qnil;
+  VALUE* keys_ptr = RARRAY_PTR(keys);
+  long keys_len = RARRAY_LEN(keys);
+
+  for (long i = 0; i < keys_len; i++) {
+    volatile VALUE key = keys_ptr[i];
+    if (RSTRING_LEN(key)) {
+      if (rb_obj_is_kind_of(obj, rb_cHash)) {
+        obj = rb_hash_aref(obj, key);
+      } else {
+        return Qnil;
+      }
+    } else {
+      if (rb_obj_is_kind_of(obj, rb_cArray)) {
+        long arr_len = RARRAY_LEN(obj);
+        if (arr_len) {
+          obj = RARRAY_PTR(obj)[arr_len - 1];
+        } else {
+          return Qnil;
+        }
+      } else {
+        return Qnil;
+      }
+    }
   }
+  return obj;
+}
+
+// prereq: len > 0
+static void _nested_aset(VALUE output, volatile VALUE keys, VALUE value) {
   volatile VALUE klass = rb_obj_class(output);
+  VALUE* arr = RARRAY_PTR(keys);
+  long len = RARRAY_LEN(keys);
 
   // first key seg
-  long is_hash_key = 1;
+  if (!RSTRING_LEN(arr[0])) {
+    rb_raise(rb_eRuntimeError, "array key at:0 conflicts with hash");
+  }
+  bool is_hash_key = true;
+
+# define NEW_CHILD(child) \
+    volatile VALUE child = (next_is_hash_key ? rb_class_new_instance(0, NULL, klass) : rb_ary_new());
+# define ASSERT_HASH \
+    if (TYPE(output) != T_HASH) {\
+      rb_raise(rb_eTypeError, "hash key at:%ld conflicts with array", i + 1);\
+    }
+# define ASSERT_ARRAY \
+    if (TYPE(output) != T_ARRAY) {\
+      rb_raise(rb_eTypeError, "array key at:%ld conflicts with hash", i + 1);\
+    }
+# define CHECK_NEXT \
+    if (next_is_hash_key) {\
+      ASSERT_HASH;\
+    } else {\
+      ASSERT_ARRAY;\
+    }
+
+  // special treatment to array keys according to last 2 segments:
+  // *[][foo] append new hash if already exists
+  //
+  // normal cases:
+  // *[]      just push
+  // *[foo]   find last elem first
+  // *[]*     find last elem first
 
   // middle key segs
   for (long i = 0; i < len - 1; i++) {
-    long next_is_hash_key = RSTRING_LEN(arr[i + 1]);
-#   define NEW_CHILD(child) \
-      volatile VALUE child = (next_is_hash_key ? rb_class_new_instance(0, NULL, klass) : rb_ary_new());
-
+    bool next_is_hash_key = RSTRING_LEN(arr[i + 1]);
     if (is_hash_key) {
       if (nyara_rb_hash_has_key(output, arr[i])) {
         output = rb_hash_aref(output, arr[i]);
-        if (next_is_hash_key) {
-          if (TYPE(output) != T_HASH) {
-            rb_raise(rb_eRuntimeError, "hash key at:%ld conflicts with array", i + 1);
+        CHECK_NEXT;
+      } else {
+        NEW_CHILD(child);
+        rb_hash_aset(output, arr[i], child);
+        output = child;
+      }
+    } else {
+      // array key, try to use the last elem
+      long output_len = RARRAY_LEN(output);
+      if (output_len) {
+        bool append = false;
+        if (i == len - 2 && next_is_hash_key) {
+          volatile VALUE next_hash = RARRAY_PTR(output)[output_len - 1];
+          if (nyara_rb_hash_has_key(next_hash, arr[i + 1])) {
+            append = true;
           }
+        }
+        if (append) {
+          volatile VALUE child = rb_class_new_instance(0, NULL, klass);
+          rb_ary_push(output, child);
+          output = child;
         } else {
-          if (TYPE(output) != T_ARRAY) {
-            rb_raise(rb_eRuntimeError, "array key at:%ld conflicts with hash", i + 1);
-          }
+          output = RARRAY_PTR(output)[output_len - 1];
+          CHECK_NEXT;
         }
       } else {
         NEW_CHILD(child);
-        rb_hash_aset(output, arr[i], child);
+        rb_ary_push(output, child);
         output = child;
       }
-    } else {
-      NEW_CHILD(child);
-      rb_ary_push(output, child);
-      output = child;
     }
     is_hash_key = next_is_hash_key;
-#   undef NEW_CHILD
   }
 
-  // terminate key seg: add value
+# undef CHECK_NEXT
+# undef ASSERT_ARRAY
+# undef ASSERT_HASH
+# undef NEW_CHILD
+
+  // terminate seg
   if (is_hash_key) {
     rb_hash_aset(output, arr[len - 1], value);
   } else {
     rb_ary_push(output, value);
   }
+}
+
+// prereq: all elements in keys are string
+// assume keys = [a, b, c] ==> self[a][b][c] = value
+// blank keys will be translated as array keys.
+// created hashes has the same class with output
+static VALUE param_hash_nested_aset(VALUE output, VALUE keys, VALUE value) {
+  Check_Type(keys, T_ARRAY);
+  long len = RARRAY_LEN(keys);
+  if (!len) {
+    rb_raise(rb_eArgError, "aset 0 length key");
+    return Qnil;
+  }
+  _nested_aset(output, keys, value);
   return output;
 }
 
 // s, len is the raw kv string
 // returns trailing length
-static void _kv(VALUE output, const char* s, long len, bool nested_mode) {
+static void _cookie_kv(VALUE output, const char* s, long len) {
   // strip
   for (; len > 0; len--, s++) {
     if (!isspace(*s)) {
@@ -174,12 +257,7 @@ static void _kv(VALUE output, const char* s, long len, bool nested_mode) {
     volatile VALUE key = rb_enc_str_new("", 0, u8_encoding);
     volatile VALUE value = rb_enc_str_new("", 0, u8_encoding);
     nyara_decode_uri_kv(key, value, s, len);
-    if (nested_mode) {
-      volatile VALUE keys = param_hash_split_name(Qnil, key);
-      param_hash_nested_aset(output, keys, value);
-    } else {
-      rb_hash_aset(output, key, value);
-    }
+    rb_hash_aset(output, key, value);
   }
 }
 
@@ -201,17 +279,41 @@ static VALUE param_hash_parse_cookie(VALUE _, VALUE output, VALUE str) {
   for (; i >= 0; i--) {
     if (s[i] == ',' || s[i] == ';') {
       if (i < last_i) {
-        _kv(output, s + i + 1, last_i - i, false);
+        _cookie_kv(output, s + i + 1, last_i - i);
       }
       last_i = i - 1;
     }
   }
   if (last_i > 0) {
-    _kv(output, s, last_i + 1, false);
+    _cookie_kv(output, s, last_i + 1);
   }
   return output;
 }
 
+// s, len is the raw kv string
+// returns trailing length
+static void _param_kv(VALUE output, const char* s, long len) {
+  // strip
+  for (; len > 0; len--, s++) {
+    if (!isspace(*s)) {
+      break;
+    }
+  }
+  for (; len > 0; len--) {
+    if (!isspace(s[len - 1])) {
+      break;
+    }
+  }
+  if (len <= 0) {
+    return;
+  }
+
+  volatile VALUE name = rb_enc_str_new("", 0, u8_encoding);
+  volatile VALUE value = rb_enc_str_new("", 0, u8_encoding);
+  nyara_decode_uri_kv(name, value, s, len);
+  _nested_aset(output, _split_name(name), value);
+}
+
 // class method:
 // insert parsing result into output
 static VALUE param_hash_parse_param(VALUE _, VALUE output, VALUE str) {
@@ -229,13 +331,13 @@ static VALUE param_hash_parse_param(VALUE _, VALUE output, VALUE str) {
   for (; i < len; i++) {
     if (s[i] == '&' || s[i] == ';') {
       if (i > last_i) {
-        _kv(output, s + last_i, i - last_i, true);
+        _param_kv(output, s + last_i, i - last_i);
       }
       last_i = i + 1;
     }
   }
   if (i > last_i) {
-    _kv(output, s + last_i, i - last_i, true);
+    _param_kv(output, s + last_i, i - last_i);
   }
   return output;
 }
@@ -308,7 +410,7 @@ static VALUE header_hash_aset(VALUE self, VALUE key, VALUE value) {
   return rb_hash_aset(self, key, value);
 }
 
-static int header_hash_merge_func(VALUE k, VALUE v, VALUE self_st) {
+static int _reverse_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);
@@ -321,11 +423,11 @@ static VALUE header_hash_reverse_merge_bang(VALUE self, VALUE other) {
     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);
+  rb_hash_foreach(other, _reverse_merge_func, (VALUE)t);
   return self;
 }
 
-static int header_hash_serialize_func(VALUE k, VALUE v, VALUE arr) {
+static int _serialize_func(VALUE k, VALUE v, VALUE arr) {
   long vlen = RSTRING_LEN(v);
   // deleted field
   if (vlen == 0) {
@@ -349,7 +451,7 @@ static VALUE header_hash_serialize(VALUE self) {
 # else
   volatile VALUE arr = rb_ary_new();
 # endif
-  rb_hash_foreach(self, header_hash_serialize_func, arr);
+  rb_hash_foreach(self, _serialize_func, arr);
   return arr;
 }
 
@@ -364,6 +466,7 @@ void Init_hashes(VALUE nyara) {
   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_param_hash_class, "nested_aset", param_hash_nested_aset, 2);
+  rb_define_method(nyara_param_hash_class, "nested_aref", param_hash_nested_aref, 1);
   rb_define_singleton_method(nyara_param_hash_class, "split_name", param_hash_split_name, 1);
   rb_define_singleton_method(nyara_param_hash_class, "parse_param", param_hash_parse_param, 2);
   rb_define_singleton_method(nyara_param_hash_class, "parse_cookie", param_hash_parse_cookie, 2);
@@ -375,6 +478,6 @@ void Init_hashes(VALUE nyara) {
   rb_define_method(nyara_header_hash_class, "serialize", header_hash_serialize, 0);
 
   // for internal use
-  rb_define_method(nyara_header_hash_class, "_aset", rb_hash_aset, 2);
-  rb_define_method(nyara_header_hash_class, "_aref", rb_hash_aref, 1);
+  rb_define_method(nyara_param_hash_class, "_aset", rb_hash_aset, 2);
+  rb_define_method(nyara_param_hash_class, "_aref", rb_hash_aref, 1);
 }