noderb 0.0.11 → 0.0.12

data/ext/noderb_extension/noderb.c

@@ -9,6 +9,7 @@
 //#include <noderb_defer.h>
 #include <noderb_fs.h>
 
+#include <signal.h>
 // Core NodeRb module
 VALUE nodeRb;
 // Pointer for saving native data
@@ -24,7 +25,14 @@ VALUE nodeRb_get_nodeRb_pointer(){
     return nodeRbPointer;
 }
 
+void siginthandler(int param)
+{
+  rb_funcall(nodeRb, rb_intern("kill"), 0, 0);
+}
+
 void Init_noderb_extension() {
+    // Exits
+    signal(SIGINT, siginthandler);
     // Define module
     nodeRb = rb_define_module("NodeRb");
     // Define native pointer
@@ -33,11 +41,11 @@ void Init_noderb_extension() {
     VALUE nodeRbConnection = rb_define_module_under(nodeRb, "Connection");
     VALUE nodeRbProcess = rb_define_module_under(nodeRb, "Process");
     // Define connection methods
-    rb_define_method(nodeRbConnection, "write_data", nodeRb_tcp_send_data, 1);
-    rb_define_method(nodeRbConnection, "close_connection", nodeRb_tcp_close_connection, 0);
+    rb_define_method(nodeRbConnection, "connection_write", nodeRb_tcp_send_data, 1);
+    rb_define_method(nodeRbConnection, "connection_close", nodeRb_tcp_close_connection, 0);
     // Define process methods
-    rb_define_method(nodeRbProcess, "write_data", nodeRb_process_write, 1);
-    rb_define_method(nodeRbProcess, "kill_process", nodeRb_process_kill, 1);
+    rb_define_method(nodeRbProcess, "process_write", nodeRb_process_write, 1);
+    rb_define_method(nodeRbProcess, "process_kill", nodeRb_process_kill, 1);
     // Define utility methods
     rb_define_singleton_method(nodeRb, "next_tick_native", nodeRb_nextTick, 0);
     rb_define_singleton_method(nodeRb, "start_proxy", nodeRb_startProxy, 2);

data/ext/noderb_extension/noderb_dns.c

@@ -33,4 +33,5 @@ VALUE nodeRb_dns_resolve(VALUE self, VALUE host, VALUE callback){
     handle->data = data;
     // Resolve
     uv_getaddrinfo(uv_default_loop(), handle, nodeRb_dns_resolved, rb_string_value_cstr(&host), NULL, NULL);
+    return self;
 }

data/ext/noderb_extension/noderb_fs.c

@@ -118,6 +118,7 @@ VALUE nodeRb_fs_operation(VALUE self, VALUE roperation, VALUE path, VALUE params
             uv_fs_chown(uv_default_loop(), handle, rb_string_value_cstr(&path), (int) rb_num2long(rb_ary_entry(params, 0)), (int) rb_num2long(rb_ary_entry(params, 1)), nodeRb_fs_operation_callback);
             break;
     }
+    return self;
 }
 
 void nodeRb_fs_file_operation_callback(uv_fs_t* handle){
@@ -125,32 +126,32 @@ void nodeRb_fs_file_operation_callback(uv_fs_t* handle){
     nodeRb_file_handle* data = (nodeRb_file_handle*) handle->data;
     VALUE target = data->target;
     if(handle->result == -1){
-        rb_funcall(target, rb_intern("on_error"), 0, 0);
+        rb_funcall(target, rb_intern("on_file_error"), 0, 0);
     }else{
         switch(handle->fs_type) {
             case UV_FS_SENDFILE:
-                rb_funcall(target, rb_intern("on_sendfile"), 0, 0);
+                rb_funcall(target, rb_intern("on_file_sendfile"), 0, 0);
                 break;
             case UV_FS_FTRUNCATE:
-                rb_funcall(target, rb_intern("on_truncate"), 0, 0);
+                rb_funcall(target, rb_intern("on_file_truncate"), 0, 0);
                 break;
             case UV_FS_FUTIME:
-                rb_funcall(target, rb_intern("on_utime"), 0, 0);
+                rb_funcall(target, rb_intern("on_file_utime"), 0, 0);
                 break;
             case UV_FS_FCHMOD:
-                rb_funcall(target, rb_intern("on_chmod"), 0, 0);
+                rb_funcall(target, rb_intern("on_file_chmod"), 0, 0);
                 break;
             case UV_FS_FSYNC:
-                rb_funcall(target, rb_intern("on_sync"), 0, 0);
+                rb_funcall(target, rb_intern("on_file_sync"), 0, 0);
                 break;
             case UV_FS_FDATASYNC:
-                rb_funcall(target, rb_intern("on_datasync"), 0, 0);
+                rb_funcall(target, rb_intern("on_file_datasync"), 0, 0);
                 break;
             case UV_FS_FCHOWN:
-                rb_funcall(target, rb_intern("on_chown"), 0, 0);
+                rb_funcall(target, rb_intern("on_file_chown"), 0, 0);
                 break;
             case UV_FS_WRITE:
-                rb_funcall(target, rb_intern("on_write"), 0, 0);
+                rb_funcall(target, rb_intern("on_file_write"), 0, 0);
                 break;
             case UV_FS_FSTAT:
                 {
@@ -173,26 +174,26 @@ void nodeRb_fs_file_operation_callback(uv_fs_t* handle){
                     rb_iv_set(values, "@modified", LONG2NUM(stats->st_mtime));
                     rb_iv_set(values, "@changed", LONG2NUM(stats->st_ctime));
 
-                    rb_funcall(target, rb_intern("on_stat"), 1, values);
+                    rb_funcall(target, rb_intern("on_file_stat"), 1, values);
                 }
                 break;
             case UV_FS_OPEN:
                 {
                     uv_file fd = (uv_file) handle->result;
                     rb_iv_set(target, "@_handle", INT2NUM(fd)); //INT2NUM(fd)
-                    rb_funcall(target, rb_intern("on_open"), 0, 0);
+                    rb_funcall(target, rb_intern("on_file_open"), 0, 0);
                 }
                 break;
             case UV_FS_READ:
                 {
                     int size = (int) handle->result;
                     char* buf = data->buffer;
-                    rb_funcall(target, rb_intern("on_read"), 1, rb_str_new(buf, size));
+                    rb_funcall(target, rb_intern("on_file_read"), 1, rb_str_new(buf, size));
                     free(buf);
                 }
                 break;
             case UV_FS_CLOSE:
-                rb_funcall(target, rb_intern("on_close"), 0, 0);
+                rb_funcall(target, rb_intern("on_file_close"), 0, 0);
                 nodeRb_unregister_instance(target);
                 rb_iv_set(target, "@_handle", Qnil);
                 break;
@@ -274,4 +275,5 @@ VALUE nodeRb_fs_file_operation(VALUE self, VALUE roperation, VALUE params){
             uv_fs_close(uv_default_loop(), handle, fd, nodeRb_fs_file_operation_callback);
             break;
     }
+    return self;
 }

data/ext/noderb_extension/noderb_process.c

@@ -35,18 +35,20 @@ VALUE nodeRb_process_write(VALUE self, VALUE data) {
     nodeRb_process_handle* process_handle = (nodeRb_process_handle*) handle->data;
     // Write data to stream
     nodeRb_write((uv_stream_t*) process_handle->stdi, buffer, sizeof(buffer));
+    return self;
 }
 
 VALUE nodeRb_process_kill(VALUE self, VALUE signal) {
     uv_process_t *handle;
     Data_Get_Struct(rb_iv_get(self, "@_handle"), uv_process_t, handle);
     uv_process_kill(handle, (int) rb_num2int(signal));
+    return self;
 }
 
 void nodeRb_process_exit(uv_process_t* handle, int status, int signal) {
     nodeRb_process_handle* process_handle = (nodeRb_process_handle*) handle->data;
     VALUE clazz = nodeRb_get_class_from_id(process_handle->target);
-    rb_funcall(clazz, rb_intern("on_exit"), 2, rb_int2inum(status), rb_int2inum(signal));
+    rb_funcall(clazz, rb_intern("on_process_close"), 2, rb_int2inum(status), rb_int2inum(signal));
 }
 
 VALUE nodeRb_startProcess(VALUE self, VALUE executable, VALUE arguments, VALUE environment, VALUE directory, VALUE clazz) {
@@ -99,7 +101,7 @@ VALUE nodeRb_startProcess(VALUE self, VALUE executable, VALUE arguments, VALUE e
     options.stdout_stream = stdo;
     nodeRb_process_read_handle* stdout_handle = malloc(sizeof(nodeRb_process_read_handle));
     stdout_handle->target = process_handle->target;
-    stdout_handle->target_callback = (char*) "on_stdout";
+    stdout_handle->target_callback = (char*) "on_process_stdout";
     stdo->data = stdout_handle;
     process_handle->stdo = stdo;
     // stderr
@@ -108,7 +110,7 @@ VALUE nodeRb_startProcess(VALUE self, VALUE executable, VALUE arguments, VALUE e
     options.stderr_stream = stde;
     nodeRb_process_read_handle* stderr_handle = malloc(sizeof(nodeRb_process_read_handle));
     stderr_handle->target = process_handle->target;
-    stderr_handle->target_callback = (char*) "on_stderr";
+    stderr_handle->target_callback = (char*) "on_process_stderr";
     stde->data = stderr_handle;
     process_handle->stde = stde;
     // libuv handle
@@ -122,5 +124,6 @@ VALUE nodeRb_startProcess(VALUE self, VALUE executable, VALUE arguments, VALUE e
     uv_read_start((uv_stream_t*) stdo, nodeRb_read_alloc, nodeRb_read);
     uv_read_start((uv_stream_t*) stde, nodeRb_read_alloc, nodeRb_read);
     // call back ruby
-    rb_funcall(clazz, rb_intern("on_start"), 0);
+    rb_funcall(clazz, rb_intern("on_process_open"), 0);
+    return self;
 };

data/ext/noderb_extension/noderb_tcp.c

@@ -17,7 +17,7 @@ void nodeRb_tcp_on_close(uv_handle_t* client) {
     nodeRb_client *client_data = client->data;
     VALUE object = nodeRb_get_class_from_id(client_data->target);
     // Call callback for connection close
-    rb_funcall(object, rb_intern("on_close"), 0, 0);
+    rb_funcall(object, rb_intern("on_connection_close"), 0, 0);
     // Allow GC of handler instance
     nodeRb_unregister_instance(object);
     rb_iv_set(object, "@_handle", Qnil);
@@ -42,6 +42,7 @@ VALUE nodeRb_tcp_close_connection(VALUE self) {
     Data_Get_Struct(rhandler, uv_stream_t, handle);
     // Request shutdown of stream
     uv_shutdown(req, handle, nodeRb_tcp_on_shutdown);
+    return self;
 }
 
 VALUE nodeRb_tcp_send_data(VALUE self, VALUE data) {
@@ -50,6 +51,7 @@ VALUE nodeRb_tcp_send_data(VALUE self, VALUE data) {
     Data_Get_Struct(rb_iv_get(self, "@_handle"), uv_stream_t, handle);
     // Request write to stream
     nodeRb_write(handle, rb_string_value_ptr(&data), RSTRING_LEN(data));
+    return self;
 }
 
 /*
@@ -61,7 +63,7 @@ void nodeRb_tcp_on_client_connect(uv_connect_t* client, int status) {
     VALUE obj = nodeRb_get_class_from_id(client_data->target);
     rb_iv_set(obj, "@_handle", Data_Wrap_Struct(nodeRb_get_nodeRb_pointer(), 0, NULL, client->handle));
     rb_iv_set(obj, "@_proxy_target", Data_Wrap_Struct(nodeRb_get_nodeRb_pointer(), 0, NULL, client->handle));
-    rb_funcall(obj, rb_intern("on_connect"), 0, 0);
+    rb_funcall(obj, rb_intern("on_connection_open"), 0, 0);
     uv_read_start((uv_stream_t*) client->handle, nodeRb_read_alloc, nodeRb_read);
 }
 
@@ -75,11 +77,12 @@ VALUE nodeRb_tcp_startClient(VALUE self, VALUE address, VALUE port, VALUE clazz)
     // Save client data
     nodeRb_client *client_data = malloc(sizeof (nodeRb_client));
     client_data->target = rb_num2long(rb_obj_id(clazz));
-    client_data->target_callback = (char*) "on_data";
+    client_data->target_callback = (char*) "on_connection_read";
     handle->data = client_data;
     // Open socket
     int r = uv_tcp_connect(connect, handle, socket, nodeRb_tcp_on_client_connect);
     if (nodeRb_handle_error(r)) return Qnil;
+    return self;
 };
 
 /*
@@ -105,10 +108,10 @@ void nodeRb_tcp_on_server_connect(uv_stream_t* server, int status) {
     rb_iv_set(obj, "@_proxy_target", Data_Wrap_Struct(nodeRb_get_nodeRb_pointer(), 0, NULL, client));
     // Get object id of handler instance
     client_data->target = rb_num2long(rb_obj_id(obj));
-    client_data->target_callback = (char*) "on_data";
+    client_data->target_callback = (char*) "on_connection_read";
     client->data = client_data;
     // Call callback
-    rb_funcall(obj, rb_intern("on_connect"), 0, 0);
+    rb_funcall(obj, rb_intern("on_connection_open"), 0, 0);
     // Listen for incoming data
     uv_read_start(client, nodeRb_read_alloc, nodeRb_read);
 }
@@ -128,4 +131,5 @@ VALUE nodeRb_tcp_startServer(VALUE self, VALUE address, VALUE port, VALUE clazz)
     // Save information for server
     VALUE name = rb_class_name(clazz);
     server->data = rb_string_value_cstr(&name);
+    return self;
 };

data/ext/noderb_extension/noderb_timers.c

@@ -35,6 +35,7 @@ VALUE nodeRb_timers_stop(VALUE self){
     uv_timer_stop(handle);
     // Let the GC work
     nodeRb_unregister_instance(self);
+    return self;
 }
 
 VALUE nodeRb_timers_once(VALUE self, VALUE timeout, VALUE repeat, VALUE handler){
@@ -55,4 +56,5 @@ VALUE nodeRb_timers_once(VALUE self, VALUE timeout, VALUE repeat, VALUE handler)
     rb_iv_set(handler, "@_handle", Data_Wrap_Struct(nodeRb_get_nodeRb_pointer(), 0, NULL, handle));
     // Schedule
     uv_timer_start(handle, nodeRb_timers_callback, rb_num2long(timeout), rb_num2long(repeat));
+    return self;
 }

data/ext/noderb_extension/noderb_tools.c

@@ -74,6 +74,7 @@ VALUE nodeRb_startProxy(VALUE self, VALUE source, VALUE target){
     // Enable proxy
     data->proxy_enabled = 1;
     data->proxy_target = target_handle;
+    return self;
 }
 
 VALUE nodeRb_stopProxy(VALUE self, VALUE source){
@@ -84,6 +85,7 @@ VALUE nodeRb_stopProxy(VALUE self, VALUE source){
     nodeRb_basic_handle* data = (nodeRb_basic_handle*) source_handle->data;
     // Disable proxy
     data->proxy_enabled = 0;
+    return self;
 }
 
 /*
@@ -109,6 +111,7 @@ VALUE nodeRb_nextTick(VALUE self) {
         nodeRbNextTickStatus = 1;
         uv_idle_start(handle, nodeRb_next_tick);
     }
+    return self;
 }
 
 /*
@@ -118,21 +121,25 @@ VALUE nodeRb_nextTick(VALUE self) {
 // Register object to be GC safe
 VALUE nodeRb_register_instance(VALUE instance) {
     rb_ary_push(rb_iv_get(nodeRb_get_nodeRb_module(), "@instances"), instance);
+    return instance;
 }
 
 // Ruby wrapper for previous function
 VALUE nodeRb_registerInstance(VALUE self, VALUE instance) {
     nodeRb_register_instance(instance);
+    return self;
 }
 
 // Unregister object to be GC safe
 VALUE nodeRb_unregister_instance(VALUE instance) {
     rb_ary_delete(rb_iv_get(nodeRb_get_nodeRb_module(), "@instances"), instance);
+    return instance;
 }
 
 // Ruby wrapper for previous function
 VALUE nodeRb_unregisterInstance(VALUE self, VALUE instance) {
     nodeRb_unregister_instance(instance);
+    return self;
 }
 
 // Transforms Ruby Object.object_id back into the Object
@@ -158,4 +165,5 @@ VALUE nodeRb_start(VALUE self) {
         rb_yield(Qnil);
     }
     uv_run(uv_default_loop());
+    return self;
 };

data/lib/noderb.rb

@@ -17,4 +17,6 @@ require "noderb/file"
 require "noderb/fs"
 # Helpers
 require "noderb/connection"
-require "noderb/process"
+require "noderb/process"
+# Tools
+require "noderb/tools"

data/lib/noderb/connection.rb

@@ -1,13 +1,13 @@
 module NodeRb
   module Connection
 
-    def on_connect
+    def on_connection_open
     end
         
-    def on_data data
+    def on_connection_read(data)
     end
 
-    def on_close
+    def on_connection_close
     end
 
   end

data/lib/noderb/file.rb

@@ -1,119 +1,119 @@
 module NodeRb
 
-	module File
+  module File
 
-		# Operations
+    # Operations
 
-		def open file, flags = "r", mode = 600
-			flags = case flags
-				        when "r"
-					        1
-				        when "w"
-					        2
-				        else
-					        0
-			        end
-			operation_native(0, [file, flags, mode])
-		end
+    def file_open(file, flags = "r", mode = 600)
+      flags = case flags
+                when "r"
+                  1
+                when "w"
+                  2
+                else
+                  0
+              end
+      operation_native(0, [file, flags, mode])
+    end
 
-		def read size = 1024, offset = 0
-			operation_native(1, [size, offset])
-		end
+    def file_read(size = 1024, offset = 0)
+      operation_native(1, [size, offset])
+    end
 
-		def write data
-			operation_native(2, data)
-		end
+    def file_write(data)
+      operation_native(2, data)
+    end
 
-		def stat
-			operation_native(3, nil)
-		end
+    def file_stat
+      operation_native(3, nil)
+    end
 
-		def sync
-			operation_native(4, nil)
-		end
+    def file_sync
+      operation_native(4, nil)
+    end
 
-		def datasync
-			operation_native(5, nil)
-		end
+    def file_datasync
+      operation_native(5, nil)
+    end
 
-		def truncate offset = 0
-			operation_native(6, offset)
-		end
+    def file_truncate(offset = 0)
+      operation_native(6, offset)
+    end
 
-		def sendfile output, offset = 0, length = 1024
-			operation_native(7, [output, offset, length])
-		end
+    def file_sendfile(output, offset = 0, length = 1024)
+      operation_native(7, [output, offset, length])
+    end
 
-		def utime atime, mtime
-			operation_native(8, [atime, mtime])
-		end
+    def file_utime(atime, mtime)
+      operation_native(8, [atime, mtime])
+    end
 
-		def chmod mode
-			operation_native(9, mode)
-		end
+    def file_chmod(mode)
+      operation_native(9, mode)
+    end
 
-		def chown uid, gid
-			operation_native(10, [uid, gid])
-		end
+    def file_chown(uid, gid)
+      operation_native(10, [uid, gid])
+    end
 
-		def close
-			operation_native(11, nil)
-		end
+    def file_close
+      operation_native(11, nil)
+    end
 
-		# Callbacks
+    # Callbacks
 
-		def on_open
+    def on_file_open
 
-		end
+    end
 
-		def on_read data
+    def on_file_read(data)
 
-		end
+    end
 
-		def on_write
+    def on_file_write
 
-		end
+    end
 
-		def on_stat
-			
-		end
+    def on_file_stat
 
-		def on_sync
-			
-		end
+    end
 
-		def on_datasync
-			
-		end
+    def on_file_sync
 
-		def on_truncate
-			
-		end
+    end
 
-		def on_sendfile
-			
-		end
+    def on_file_datasync
 
-		def on_utime
+    end
 
-		end
+    def on_file_truncate
 
-		def on_chmod
-			
-		end
+    end
 
-		def on_chown
-			
-		end
+    def on_file_sendfile
 
-		def on_close
+    end
 
-		end
+    def on_file_utime
 
-		def on_error
-			
-		end
+    end
 
-	end
+    def on_file_chmod
+
+    end
+
+    def on_file_chown
+
+    end
+
+    def on_file_close
+
+    end
+
+    def on_file_error
+
+    end
+
+  end
 
 end

data/lib/noderb/fs.rb

@@ -1,72 +1,72 @@
 module NodeRb
 
-	class FileSystem
+  class FileSystem
 
-		class << self
+    class << self
 
-			def unlink path, &block
-				fs_native(0, path, nil, block)
-			end
+      def unlink path, &block
+        fs_native(0, path, nil, block)
+      end
 
-			def mkdir path, mode, &block
-				fs_native(1, path, mode, block)
-			end
+      def mkdir path, mode, &block
+        fs_native(1, path, mode, block)
+      end
 
-			def rmdir path, &block
-				fs_native(2, path, nil, block)
-			end
+      def rmdir path, &block
+        fs_native(2, path, nil, block)
+      end
 
-			def readdir path, flags = 2, &block
-				parser = proc do |data|
-					data ? block.call(data.split("\0")) : block.call(data)
-				end
-				fs_native(3, path, flags, parser)
-			end
+      def readdir path, flags = 2, &block
+        parser = proc do |data|
+          data ? block.call(data.split("\0")) : block.call(data)
+        end
+        fs_native(3, path, flags, parser)
+      end
 
-			def stat path, &block
-				fs_native(4, path, nil, block)
-			end
+      def stat path, &block
+        fs_native(4, path, nil, block)
+      end
 
-			def rename path, new_path, &block
-				fs_native(5, path, new_path, block)
-			end
+      def rename path, new_path, &block
+        fs_native(5, path, new_path, block)
+      end
 
-			def chmod path, mode, &block
-				fs_native(6, path, mode, block)
-			end
+      def chmod path, mode, &block
+        fs_native(6, path, mode, block)
+      end
 
-			def utime path, atime, mtime, &block
-				fs_native(7, path, [atime, mtime], block)
-			end
+      def utime path, atime, mtime, &block
+        fs_native(7, path, [atime, mtime], block)
+      end
 
-			def lstat path, &block
-				fs_native(8, path, nil, block)
-			end
+      def lstat path, &block
+        fs_native(8, path, nil, block)
+      end
 
-			def link path, new_path, &block
-				fs_native(9, path, new_path, block)
-			end
+      def link path, new_path, &block
+        fs_native(9, path, new_path, block)
+      end
 
-			def symlink path, new_path, flags, &block
-				fs_native(10, path, [new_path, flags], block)
-			end
+      def symlink path, new_path, flags, &block
+        fs_native(10, path, [new_path, flags], block)
+      end
 
-			def readlink path, &block
-				# ToDo: libuv not implemented yet
-				block.call(nil)
-				#fs_native(11, path, nil, block)
-			end
+      def readlink path, &block
+        # ToDo: libuv not implemented yet
+        block.call(nil)
+        #fs_native(11, path, nil, block)
+      end
 
-			def chown path, uid, gid, &block
-				fs_native(12, path, [uid, gid], block)
-			end
+      def chown path, uid, gid, &block
+        fs_native(12, path, [uid, gid], block)
+      end
 
-		end
+    end
 
-	end
+  end
 
-	class Stat
-		
-	end
+  class Stat
+
+  end
 
 end

data/lib/noderb/next_tick.rb

@@ -1,18 +1,24 @@
 module NodeRb
 
   class << self
-    
-    def next_tick &block
-      ( @next_tick ||= [] ) << block
+
+    def next_tick params = nil, &block
+      next_tick_schedule(block, params)
+    end
+
+    def next_tick_schedule block, params
+      @next_tick ||= []
+      @next_tick << [block, params]
       NodeRb.send(:next_tick_native)
     end
-    
+
     def next_tick_execute
       blocks, @next_tick = @next_tick, []
       blocks.each do |block|
-        block.call
+        block, params = block
+        params ? block.call(params) : block.call
       end
     end
-    
+
   end
 end

data/lib/noderb/process.rb

@@ -1,16 +1,16 @@
 module NodeRb
   module Process
     
-    def on_start pid
+    def on_process_open
     end
     
-    def on_stdout data
+    def on_process_stdout data
     end
     
-    def on_stderr data
+    def on_process_stderr data
     end
     
-    def on_exit status, signal
+    def on_process_close status, signal
     end
   
   end

data/lib/noderb/timers.rb

@@ -16,7 +16,7 @@ module NodeRb
   module Timer
 
     def call
-      
+
     end
 
   end

data/lib/noderb/tools.rb

@@ -0,0 +1,10 @@
+module NodeRb
+
+  def self.kill
+    NodeRb.next_tick do
+      puts "Exiting"
+      Kernel.exit(0)
+    end
+  end
+
+end

data/lib/noderb/version.rb

@@ -1,3 +1,3 @@
 module NodeRb
-  VERSION = "0.0.11" unless const_defined?(:VERSION)
-end
+  VERSION = "0.0.12" unless const_defined?(:VERSION)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: noderb
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-30 00:00:00.000000000Z
+date: 2011-10-04 00:00:00.000000000Z
 dependencies: []
 description: Port of the NodeJs library to Ruby, featuring asynchronous IO operations
   of all kinds.
@@ -29,6 +29,7 @@ files:
 - lib/noderb/process.rb
 - lib/noderb/tcp.rb
 - lib/noderb/timers.rb
+- lib/noderb/tools.rb
 - lib/noderb/version.rb
 - lib/noderb.rb
 - ext/noderb_extension/extconf.rb