cool.io 1.0.0 → 1.9.0

data/ext/cool.io/cool.io.h

@@ -8,7 +8,11 @@
 #define COOLIO_H
 
 #include "ruby.h"
+#if defined(HAVE_RUBY_IO_H)
+#include "ruby/io.h"
+#else
 #include "rubyio.h"
+#endif
 
 #ifdef GetReadFile
 #define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
@@ -32,6 +36,7 @@ struct Coolio_Event
 struct Coolio_Loop 
 {
   struct ev_loop *ev_loop;
+  struct ev_timer timer; /* for timeouts */
 
   int running;
   int events_received;
@@ -55,4 +60,12 @@ struct Coolio_Watcher
 
 void Coolio_Loop_process_event(VALUE watcher, int revents);
 
+void Init_coolio_buffer();
+void Init_coolio_loop();
+void Init_coolio_watcher();
+void Init_coolio_iowatcher();
+void Init_coolio_timer_watcher();
+void Init_coolio_stat_watcher();
+void Init_coolio_utils();
+
 #endif

data/ext/cool.io/cool.io_ext.c

@@ -16,6 +16,7 @@ static VALUE mCoolio = Qnil;
 void Init_cool() 
 {
   /* Initializers for other modules */
+  Init_coolio_buffer();
   Init_coolio_loop();
   Init_coolio_watcher();
   Init_coolio_iowatcher();

data/ext/cool.io/ev_wrap.h

@@ -1,7 +1,9 @@
 #define EV_STANDALONE              /* keeps ev from requiring config.h */
+
 #ifdef _WIN32
-# define EV_SELECT_IS_WINSOCKET 1   /* configure libev for windows select */
-# define FD_SETSIZE 2048 /* wishful thinking, as msvcrt6 [?] seems to only allow 512 fd's and 256 sockets max */
+#define EV_SELECT_IS_WINSOCKET 1   /* configure libev for windows select */
+#define EV_USE_MONOTONIC 0
+#define EV_USE_REALTIME 0
 #endif
 
 #include "../libev/ev.h"

data/ext/cool.io/extconf.rb

@@ -4,20 +4,25 @@ libs = []
 
 $defs << "-DRUBY_VERSION_CODE=#{RUBY_VERSION.gsub(/\D/, '')}"
 
-if have_func('rb_thread_blocking_region')
-  $defs << '-DHAVE_RB_THREAD_BLOCKING_REGION'
+have_func('rb_io_descriptor')
+have_func('rb_thread_blocking_region')
+have_func('rb_thread_call_without_gvl')
+have_func('rb_thread_alone')
+have_func('rb_str_set_len')
+have_library('rt', 'clock_gettime')
+
+have_func("rb_io_descriptor")
+have_library("c", "main")
+if have_macro("HAVE_RB_IO_T", "ruby/io.h")
+  have_struct_member("rb_io_t", "fd", "ruby/io.h")
 end
 
-if have_func('rb_thread_alone')
-  $defs << '-DHAVE_RB_THREAD_ALONE'
+if have_header('ruby/io.h')
+  $defs << '-DHAVE_RUBY_IO_H'
 end
 
-if have_func('rb_str_set_len')
-  $defs << '-DHAVE_RB_STR_SET_LEN'
-end
-
-if have_library('rt', 'clock_gettime')
-  libs << "-lrt"
+if have_header('ruby/thread.h')
+  $defs << '-DHAVE_RUBY_THREAD_H'
 end
 
 if have_header('sys/select.h')
@@ -40,9 +45,7 @@ if have_header('port.h')
   $defs << '-DEV_USE_PORT'
 end
 
-if have_header('sys/resource.h')
-  $defs << '-DHAVE_SYS_RESOURCE_H'
-end
+have_header('sys/resource.h')
 
 # ncpu detection specifics
 case RUBY_PLATFORM
@@ -54,16 +57,24 @@ else
   end
 end
 
+if RUBY_PLATFORM =~ /solaris/
+  # libev/ev.c requires NSIG which is undefined if _XOPEN_SOURCE is defined
+  $defs << '-D__EXTENSIONS__'
+end
+
 $LIBS << ' ' << libs.join(' ')
 
 dir_config('cool.io_ext')
 create_makefile('cool.io_ext')
 
 # win32 needs to link in "just the right order" for some reason or  ioctlsocket will be mapped to an [inverted] ruby specific version.  See libev mailing list for (not so helpful discussion--true cause I'm not sure, but this overcomes the symptom)
-if RUBY_PLATFORM =~ /mingw|win32/
+if RUBY_PLATFORM =~ /mingw|mswin/
   makefile_contents = File.read 'Makefile'
 
-  makefile_contents.gsub! 'LIBS = $(LIBRUBYARG_SHARED)', 'LIBS = -lws2_32 $(LIBRUBYARG_SHARED)'
+  # "Init_cool could not be found" when loading cool.io.so.
+  # I'm not sure why this is needed. But this line causes "1114 A dynamic link library (DLL) initialization routine failed." So I commented out this line.
+  #makefile_contents.gsub! 'DLDFLAGS = ', 'DLDFLAGS = -export-all '
+
+  makefile_contents.gsub! /LIBS = (.*) (\S*ws2_32\S*)/i, 'LIBS = \\2 \\1'
   File.open('Makefile', 'w') { |f| f.write makefile_contents }
 end
-

data/ext/cool.io/iowatcher.c

@@ -5,7 +5,11 @@
  */
 
 #include "ruby.h"
+#if defined(HAVE_RUBY_IO_H)
+#include "ruby/io.h"
+#else
 #include "rubyio.h"
+#endif
 
 #include "ev_wrap.h"
 
@@ -61,11 +65,6 @@ static VALUE Coolio_IOWatcher_initialize(int argc, VALUE *argv, VALUE self)
   char *flags_str;
   int events;
   struct Coolio_Watcher *watcher_data;
-#if HAVE_RB_IO_T
-  rb_io_t *fptr;
-#else
-  OpenFile *fptr;
-#endif
 
   rb_scan_args(argc, argv, "11", &io, &flags);
 
@@ -84,10 +83,20 @@ static VALUE Coolio_IOWatcher_initialize(int argc, VALUE *argv, VALUE self)
     rb_raise(rb_eArgError, "invalid event type: '%s' (must be 'r', 'w', or 'rw')", flags_str);
 
   Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
-  GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
+  io = rb_convert_type(io, T_FILE, "IO", "to_io");
 
   watcher_data->dispatch_callback = Coolio_IOWatcher_dispatch_callback;
+#ifdef HAVE_RB_IO_DESCRIPTOR
+  ev_io_init(&watcher_data->event_types.ev_io, Coolio_IOWatcher_libev_callback, rb_io_descriptor(io), events);
+#else
+#if defined(HAVE_RB_IO_T)
+  rb_io_t *fptr;
+#else
+  OpenFile *fptr;
+#endif
+  GetOpenFile(io, fptr);
   ev_io_init(&watcher_data->event_types.ev_io, Coolio_IOWatcher_libev_callback, FPTR_TO_FD(fptr), events);
+#endif
   watcher_data->event_types.ev_io.data = (void *)self;
 
   return Qnil;
@@ -181,9 +190,9 @@ static void Coolio_IOWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_i
 static void Coolio_IOWatcher_dispatch_callback(VALUE self, int revents)
 {   
   if(revents & EV_READ)
-    rb_funcall(self, rb_intern("on_readable"), 0, 0);
+    rb_funcall(self, rb_intern("on_readable"), 0);
   else if(revents & EV_WRITE)
-    rb_funcall(self, rb_intern("on_writable"), 0, 0);
+    rb_funcall(self, rb_intern("on_writable"), 0);
   else
     rb_raise(rb_eRuntimeError, "unknown revents value for ev_io: %d", revents);
 }

data/ext/cool.io/loop.c

@@ -6,19 +6,10 @@
 
 #include <assert.h>
 #include "ruby.h"
-#include "rubysig.h"
 #include "ev_wrap.h"
 
 #include "cool.io.h"
 
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
-#  define Coolio_Loop_may_block_safely() (1)
-#elif defined(HAVE_RB_THREAD_ALONE)
-#  define Coolio_Loop_may_block_safely() (rb_thread_alone())
-#else /* just in case Ruby changes: */
-#  define Coolio_Loop_may_block_safely() (0)
-#endif
-
 static VALUE mCoolio = Qnil;
 static VALUE cCoolio_Loop = Qnil;
 
@@ -26,12 +17,11 @@ static VALUE Coolio_Loop_allocate(VALUE klass);
 static void Coolio_Loop_mark(struct Coolio_Loop *loop);
 static void Coolio_Loop_free(struct Coolio_Loop *loop);
 
-static VALUE Coolio_Loop_initialize(VALUE self);
 static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags);
-static VALUE Coolio_Loop_run_once(VALUE self);
+static VALUE Coolio_Loop_run_once(int argc, VALUE *argv, VALUE self);
 static VALUE Coolio_Loop_run_nonblock(VALUE self);
 
-static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data);
+static void Coolio_Loop_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents);
 static void Coolio_Loop_dispatch_events(struct Coolio_Loop *loop_data);
 
 #define DEFAULT_EVENTBUF_SIZE 32
@@ -51,10 +41,9 @@ void Init_coolio_loop()
   mCoolio = rb_define_module("Coolio");
   cCoolio_Loop = rb_define_class_under(mCoolio, "Loop", rb_cObject);
   rb_define_alloc_func(cCoolio_Loop, Coolio_Loop_allocate);
- 
-  rb_define_method(cCoolio_Loop, "initialize", Coolio_Loop_initialize, 0);
+
   rb_define_private_method(cCoolio_Loop, "ev_loop_new", Coolio_Loop_ev_loop_new, 1);
-  rb_define_method(cCoolio_Loop, "run_once", Coolio_Loop_run_once, 0);
+  rb_define_method(cCoolio_Loop, "run_once", Coolio_Loop_run_once, -1);
   rb_define_method(cCoolio_Loop, "run_nonblock", Coolio_Loop_run_nonblock, 0);
 }
 
@@ -63,6 +52,7 @@ static VALUE Coolio_Loop_allocate(VALUE klass)
   struct Coolio_Loop *loop = (struct Coolio_Loop *)xmalloc(sizeof(struct Coolio_Loop));
 
   loop->ev_loop = 0;
+  ev_init(&loop->timer, Coolio_Loop_timeout_callback);
   loop->running = 0;
   loop->events_received = 0;
   loop->eventbuf_size = DEFAULT_EVENTBUF_SIZE;
@@ -86,11 +76,6 @@ static void Coolio_Loop_free(struct Coolio_Loop *loop)
   xfree(loop);
 }
 
-static VALUE Coolio_Loop_initialize(VALUE self)
-{
-  Coolio_Loop_ev_loop_new(self, INT2NUM(0));
-}
-
 /* Wrapper for populating a Coolio_Loop struct with a new event loop */
 static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags)
 {
@@ -174,90 +159,57 @@ void Coolio_Loop_process_event(VALUE watcher, int revents)
   loop_data->events_received++;
 }
 
+/* Called whenever a timeout fires on the event loop */
+static void Coolio_Loop_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
+{
+  /* We don't actually need to do anything here, the mere firing of the
+     timer is sufficient to interrupt the selector. However, libev still wants a callback */
+}
+
 /**
  *  call-seq:
  *    Coolio::Loop.run_once -> nil
  * 
  * Run the Coolio::Loop once, blocking until events are received.
  */
-static VALUE Coolio_Loop_run_once(VALUE self)
+static VALUE Coolio_Loop_run_once(int argc, VALUE *argv, VALUE self)
 {
+  VALUE timeout;
   VALUE nevents;
+  struct Coolio_Loop *loop_data;
 
-  if (Coolio_Loop_may_block_safely()) {
-    struct Coolio_Loop *loop_data;
-
-    Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+  rb_scan_args(argc, argv, "01", &timeout);
 
-    assert(loop_data->ev_loop && !loop_data->events_received);
+  if (timeout != Qnil && NUM2DBL(timeout) < 0) {
+    rb_raise(rb_eArgError, "time interval must be positive");
+  }
 
-    Coolio_Loop_ev_loop_oneshot(loop_data);
-    Coolio_Loop_dispatch_events(loop_data);
+  Data_Get_Struct(self, struct Coolio_Loop, loop_data);
 
-    nevents = INT2NUM(loop_data->events_received);
-    loop_data->events_received = 0;
+  assert(loop_data->ev_loop && !loop_data->events_received);
 
+  /* Implement the optional timeout (if any) as a ev_timer */
+  /* Using the technique written at
+     http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#code_ev_timer_code_relative_and_opti,
+     the timer is not stopped/started everytime when timeout is specified, instead,
+     the timer is stopped when timeout is not specified. */
+  if (timeout != Qnil) {
+    /* It seems libev is not a fan of timers being zero, so fudge a little */
+    loop_data->timer.repeat = NUM2DBL(timeout) + 0.0001;
+    ev_timer_again(loop_data->ev_loop, &loop_data->timer);
   } else {
-    nevents = Coolio_Loop_run_nonblock(self);
-    rb_thread_schedule();
+    ev_timer_stop(loop_data->ev_loop, &loop_data->timer);
   }
 
-  return nevents;
-}
-
-/* Ruby 1.9 supports blocking system calls through rb_thread_blocking_region() */
-#ifdef HAVE_RB_THREAD_BLOCKING_REGION
-#define HAVE_EV_LOOP_ONESHOT
-static VALUE Coolio_Loop_ev_loop_oneshot_blocking(void *ptr) 
-{
-  /* The libev loop has now escaped through the Global VM Lock unscathed! */
-  struct Coolio_Loop *loop_data = (struct Coolio_Loop *)ptr;
-
+  /* libev is patched to release the GIL when it makes its system call */
   RUN_LOOP(loop_data, EVLOOP_ONESHOT);
-  
-  return Qnil;
-}
-
-static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data)
-{
-  /* Use Ruby 1.9's rb_thread_blocking_region call to make a blocking system call */
-  rb_thread_blocking_region(Coolio_Loop_ev_loop_oneshot_blocking, loop_data, RUBY_UBF_IO, 0);
-}
-#endif
-
-/* Ruby 1.8 requires us to periodically run the event loop then defer back to
- * the green threads scheduler */
-#ifndef HAVE_EV_LOOP_ONESHOT
-#define BLOCKING_INTERVAL 0.01 /* Block for 10ms at a time */
-
-/* Stub for scheduler's ev_timer callback */
-static void timer_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
-{
-   ev_timer_again (ev_loop, timer);
-}
 
-/* Run the event loop, calling rb_thread_schedule every 10ms */
-static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data)
-{
-  struct ev_timer timer;
-  struct timeval tv;
-
-  /* Set up an ev_timer to unblock the loop every 10ms */
-  ev_timer_init(&timer, timer_callback, BLOCKING_INTERVAL, BLOCKING_INTERVAL);
-  ev_timer_start(loop_data->ev_loop, &timer);
-
-  /* Loop until we receive events */
-  while(!loop_data->events_received) {
-    TRAP_BEG;
-    RUN_LOOP(loop_data, EVLOOP_ONESHOT);
-    TRAP_END;
-
-    rb_thread_schedule();
-  }
+  Coolio_Loop_dispatch_events(loop_data);
+  nevents = INT2NUM(loop_data->events_received);
+  loop_data->events_received = 0;
 
-  ev_timer_stop(loop_data->ev_loop, &timer);
+  return nevents;
 }
-#endif
 
 /**
  *  call-seq:

data/ext/cool.io/stat_watcher.c

@@ -13,6 +13,7 @@
 static VALUE mCoolio = Qnil;
 static VALUE cCoolio_Watcher = Qnil;
 static VALUE cCoolio_StatWatcher = Qnil;
+static VALUE cCoolio_StatInfo = Qnil;
 static VALUE cCoolio_Loop = Qnil;
 
 static VALUE Coolio_StatWatcher_initialize(int argc, VALUE *argv, VALUE self);
@@ -20,9 +21,11 @@ static VALUE Coolio_StatWatcher_attach(VALUE self, VALUE loop);
 static VALUE Coolio_StatWatcher_detach(VALUE self);
 static VALUE Coolio_StatWatcher_enable(VALUE self);
 static VALUE Coolio_StatWatcher_disable(VALUE self);
-static VALUE Coolio_StatWatcher_on_change(VALUE self);
+static VALUE Coolio_StatWatcher_on_change(VALUE self, VALUE previous, VALUE current);
 static VALUE Coolio_StatWatcher_path(VALUE self);
 
+static VALUE Coolio_StatInfo_build(ev_statdata *statdata_struct);
+
 static void Coolio_StatWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_stat *stat, int revents);
 static void Coolio_StatWatcher_dispatch_callback(VALUE self, int revents);
 
@@ -30,12 +33,27 @@ static void Coolio_StatWatcher_dispatch_callback(VALUE self, int revents);
  * Coolio::StatWatcher lets you create either one-shot or periodic stats which
  * run within Coolio's event loop.  It's useful for creating timeouts or
  * events which fire periodically.
- */
+ **/
 void Init_coolio_stat_watcher()
-{ 
+{
   mCoolio = rb_define_module("Coolio");
   cCoolio_Watcher = rb_define_class_under(mCoolio, "Watcher", rb_cObject);
   cCoolio_StatWatcher = rb_define_class_under(mCoolio, "StatWatcher", cCoolio_Watcher);
+  cCoolio_StatInfo = rb_struct_define("StatInfo",
+      "mtime",
+      "ctime",
+      "atime",
+      "dev",
+      "ino",
+      "mode",
+      "nlink",
+      "uid",
+      "guid",
+      "rdev",
+      "size",
+      "blksize",
+      "blocks",
+      NULL);
   cCoolio_Loop = rb_define_class_under(mCoolio, "Loop", rb_cObject);
 
   rb_define_method(cCoolio_StatWatcher, "initialize", Coolio_StatWatcher_initialize, -1);
@@ -43,14 +61,14 @@ void Init_coolio_stat_watcher()
   rb_define_method(cCoolio_StatWatcher, "detach", Coolio_StatWatcher_detach, 0);
   rb_define_method(cCoolio_StatWatcher, "enable", Coolio_StatWatcher_enable, 0);
   rb_define_method(cCoolio_StatWatcher, "disable", Coolio_StatWatcher_disable, 0);
-  rb_define_method(cCoolio_StatWatcher, "on_change", Coolio_StatWatcher_on_change, 0);
+  rb_define_method(cCoolio_StatWatcher, "on_change", Coolio_StatWatcher_on_change, 2);
   rb_define_method(cCoolio_StatWatcher, "path", Coolio_StatWatcher_path, 0);
 }
 
 /**
  *  call-seq:
  *    Coolio::StatWatcher.initialize(path, interval = 0) -> Coolio::StatWatcher
- * 
+ *
  * Create a new Coolio::StatWatcher for the given path.  This will monitor the
  * given path for changes at the filesystem level.  The interval argument
  * specified how often in seconds the path should be polled for changes.
@@ -75,11 +93,11 @@ static VALUE Coolio_StatWatcher_initialize(int argc, VALUE *argv, VALUE self)
 
   watcher_data->dispatch_callback = Coolio_StatWatcher_dispatch_callback;
   ev_stat_init(
-      &watcher_data->event_types.ev_stat, 
-      Coolio_StatWatcher_libev_callback, 
-      RSTRING_PTR(path), 
+      &watcher_data->event_types.ev_stat,
+      Coolio_StatWatcher_libev_callback,
+      RSTRING_PTR(path),
       interval == Qnil ? 0 : NUM2DBL(interval)
-  );  
+  );
   watcher_data->event_types.ev_stat.data = (void *)self;
 
   return Qnil;
@@ -88,7 +106,7 @@ static VALUE Coolio_StatWatcher_initialize(int argc, VALUE *argv, VALUE self)
 /**
  *  call-seq:
  *    Coolio::StatWatcher.attach(loop) -> Coolio::StatWatcher
- * 
+ *
  * Attach the stat watcher to the given Coolio::Loop.  If the watcher is already
  * attached to a loop, detach it from the old one and attach it to the new one.
  */
@@ -97,9 +115,9 @@ static VALUE Coolio_StatWatcher_attach(VALUE self, VALUE loop)
   ev_tstamp interval, timeout;
   struct Coolio_Loop *loop_data;
   struct Coolio_Watcher *watcher_data;
-    
-	if(!rb_obj_is_kind_of(loop, cCoolio_Loop))
-		rb_raise(rb_eArgError, "expected loop to be an instance of Coolio::Loop");
+
+  if(!rb_obj_is_kind_of(loop, cCoolio_Loop))
+    rb_raise(rb_eArgError, "expected loop to be an instance of Coolio::Loop, not %s", RSTRING_PTR(rb_inspect(loop)));
 
   Data_Get_Struct(loop, struct Coolio_Loop, loop_data);
   Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
@@ -112,13 +130,13 @@ static VALUE Coolio_StatWatcher_attach(VALUE self, VALUE loop)
   ev_stat_start(loop_data->ev_loop, &watcher_data->event_types.ev_stat);
 	rb_call_super(1, &loop);
 
-  return self;  
+  return self;
 }
 
 /**
  *  call-seq:
  *    Coolio::StatWatcher.detach -> Coolio::StatWatcher
- * 
+ *
  * Detach the stat watcher from its current Coolio::Loop.
  */
 static VALUE Coolio_StatWatcher_detach(VALUE self)
@@ -131,7 +149,7 @@ static VALUE Coolio_StatWatcher_detach(VALUE self)
 /**
  *  call-seq:
  *    Coolio::StatWatcher.enable -> Coolio::StatWatcher
- * 
+ *
  * Re-enable a stat watcher which has been temporarily disabled.  See the
  * disable method for a more thorough explanation.
  */
@@ -139,15 +157,15 @@ static VALUE Coolio_StatWatcher_enable(VALUE self)
 {
   Watcher_Enable(stat, self);
 
-  return self;  
+  return self;
 }
 
 /**
  *  call-seq:
  *    Coolio::StatWatcher.disable -> Coolio::StatWatcher
- * 
- * Temporarily disable a stat watcher which is attached to a loop.  
- * This is useful if you wish to toggle event monitoring on and off.  
+ *
+ * Temporarily disable a stat watcher which is attached to a loop.
+ * This is useful if you wish to toggle event monitoring on and off.
  */
 static VALUE Coolio_StatWatcher_disable(VALUE self)
 {
@@ -159,10 +177,10 @@ static VALUE Coolio_StatWatcher_disable(VALUE self)
 /**
  *  call-seq:
  *    Coolio::StatWatcher#on_change -> nil
- * 
+ *
  * Called whenever the status of the given path changes
  */
-static VALUE Coolio_StatWatcher_on_change(VALUE self)
+static VALUE Coolio_StatWatcher_on_change(VALUE self, VALUE previous, VALUE current)
 {
   return Qnil;
 }
@@ -170,7 +188,7 @@ static VALUE Coolio_StatWatcher_on_change(VALUE self)
 /**
  *  call-seq:
  *    Coolio::StatWatcher#path -> String
- * 
+ *
  * Retrieve the path associated with this StatWatcher
  */
 static VALUE Coolio_StatWatcher_path(VALUE self)
@@ -186,6 +204,66 @@ static void Coolio_StatWatcher_libev_callback(struct ev_loop *ev_loop, struct ev
 
 /* Coolio::Loop dispatch callback */
 static void Coolio_StatWatcher_dispatch_callback(VALUE self, int revents)
-{ 
-  rb_funcall(self, rb_intern("on_change"), 0, 0);
+{
+  struct Coolio_Watcher *watcher_data;
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+
+  VALUE previous_statdata = Coolio_StatInfo_build(&watcher_data->event_types.ev_stat.prev);
+  VALUE current_statdata = Coolio_StatInfo_build(&watcher_data->event_types.ev_stat.attr);
+  rb_funcall(self, rb_intern("on_change"), 2, previous_statdata, current_statdata);
+}
+
+/**
+ * Convience method to build StatInfo structs given an ev_statdata
+ * */
+static VALUE Coolio_StatInfo_build(ev_statdata *statdata_struct)
+{
+  VALUE at_method = rb_intern("at");
+  VALUE cTime     = rb_const_get(rb_cObject, rb_intern("Time"));
+
+  VALUE mtime     = Qnil;
+  VALUE ctime     = Qnil;
+  VALUE atime     = Qnil;
+  VALUE dev       = Qnil;
+  VALUE ino       = Qnil;
+  VALUE mode      = Qnil;
+  VALUE nlink     = Qnil;
+  VALUE uid       = Qnil;
+  VALUE gid       = Qnil;
+  VALUE rdev      = Qnil;
+  VALUE size      = Qnil;
+  VALUE blksize   = Qnil;
+  VALUE blocks    = Qnil;
+
+  mtime   = rb_funcall(cTime, at_method, 1, INT2NUM(statdata_struct->st_mtime));
+  ctime   = rb_funcall(cTime, at_method, 1, INT2NUM(statdata_struct->st_ctime));
+  atime   = rb_funcall(cTime, at_method, 1, INT2NUM(statdata_struct->st_atime));
+  dev     = INT2NUM(statdata_struct->st_dev);
+  ino     = INT2NUM(statdata_struct->st_ino);
+  mode    = INT2NUM(statdata_struct->st_mode);
+  nlink   = INT2NUM(statdata_struct->st_nlink);
+  uid     = INT2NUM(statdata_struct->st_uid);
+  gid     = INT2NUM(statdata_struct->st_gid);
+  rdev    = INT2NUM(statdata_struct->st_rdev);
+  size    = INT2NUM(statdata_struct->st_size);
+#ifdef HAVE_ST_BLKSIZE
+  blksize = INT2NUM(statdata_struct->st_blksize);
+  blocks  = INT2NUM(statdata_struct->st_blocks);
+#endif
+
+  return rb_struct_new(cCoolio_StatInfo,
+      mtime,
+      ctime,
+      atime,
+      dev,
+      ino,
+      mode,
+      nlink,
+      uid,
+      gid,
+      rdev,
+      size,
+      blksize,
+      blocks,
+      NULL);
 }

data/ext/cool.io/timer_watcher.c

@@ -95,8 +95,8 @@ static VALUE Coolio_TimerWatcher_attach(VALUE self, VALUE loop)
   struct Coolio_Loop *loop_data;
   struct Coolio_Watcher *watcher_data;
     
-	if(!rb_obj_is_kind_of(loop, cCoolio_Loop))
-		rb_raise(rb_eArgError, "expected loop to be an instance of Coolio::Loop");
+  if(!rb_obj_is_kind_of(loop, cCoolio_Loop))
+    rb_raise(rb_eArgError, "expected loop to be an instance of Coolio::Loop, not %s", RSTRING_PTR(rb_inspect(loop)));
 
   Data_Get_Struct(loop, struct Coolio_Loop, loop_data);
   Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
@@ -213,7 +213,7 @@ static void Coolio_TimerWatcher_libev_callback(struct ev_loop *ev_loop, struct e
 static void Coolio_TimerWatcher_dispatch_callback(VALUE self, int revents)
 { 
   if(revents & EV_TIMEOUT)
-    rb_funcall(self, rb_intern("on_timer"), 0, 0);
+    rb_funcall(self, rb_intern("on_timer"), 0);
   else
     rb_raise(rb_eRuntimeError, "unknown revents value for ev_timer: %d", revents);
 }

data/ext/cool.io/utils.c

@@ -15,6 +15,11 @@
 #include <sys/sysctl.h>
 #endif
 
+#ifdef HAVE_SYSCTLBYNAME
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#endif
+
 static VALUE mCoolio = Qnil;
 static VALUE cCoolio_Utils = Qnil;
 

data/ext/cool.io/watcher.h

@@ -12,7 +12,7 @@
   struct Coolio_Loop *loop_data; \
   \
   if(!rb_obj_is_kind_of(loop, cCoolio_Loop)) \
-    rb_raise(rb_eArgError, "expected loop to be an instance of Coolio::Loop"); \
+    rb_raise(rb_eArgError, "expected loop to be an instance of Coolio::Loop, not %s", RSTRING_PTR(rb_inspect(loop))); \
   \
   Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
   Data_Get_Struct(loop, struct Coolio_Loop, loop_data); \