cool.io 1.9.0 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e56b06dac89092ba3fb69d7705788b4aecb51a205075b47afa6b8ff946f8bfa6
-  data.tar.gz: d9ff9ac907b8eb86d3158d893acdcc0f64c58985ae2ccfeeafbcc9c2a5e366a4
+  metadata.gz: 1d38b3958d9ad5505fb4a53ded526d2ab347d46200a567a9aa0681cc5ca487cc
+  data.tar.gz: 42cb1b75db2c409dfc48756b8df29663675e31a104d03c37bbbfce9344592d6d
 SHA512:
-  metadata.gz: b9d3c85e07f9f439c86be0572d4c455a429fbb2b8fd5b1cbdb87cd0fdca1c629060515074751eecb92357b365edf05c8b0cc79ce63ca4d6188e4eeca903cf95e
-  data.tar.gz: 942c188b705d59f6aa0c9d028d87b17722f9cba55c317cfb1be8f7548562c68e1467c8ec5664297cbb575fd1f6997875311d1a35d76efb772c4f50c87c20aa94
+  metadata.gz: 6e3358de317e34735ca0f264c75f93d34d38325482c02eabf4d1289b3c44ef6557918bd59078a34c809322d69d05299ccb58f89db630c4054dc0162de8ab49b6
+  data.tar.gz: 775568343fe8788adbc43757a6f06ef5474e1d19477571317f29e21ff3da777d8567a6401377c6eb854e9f0c4060d97da7c84dafa56dc1e772f636417365d338

data/ext/cool.io/buffer.c

@@ -47,8 +47,8 @@ static VALUE    mCoolio = Qnil;
 static VALUE    cCoolio_Buffer = Qnil;
 
 static VALUE    Coolio_Buffer_allocate(VALUE klass);
-static void     Coolio_Buffer_mark(struct buffer *);
-static void     Coolio_Buffer_free(struct buffer *);
+static void     Coolio_Buffer_mark(void *);
+static void     Coolio_Buffer_free(void *);
 
 static VALUE    Coolio_Buffer_default_node_size(VALUE klass);
 static VALUE    Coolio_Buffer_set_default_node_size(VALUE klass, VALUE size);
@@ -64,7 +64,7 @@ static VALUE    Coolio_Buffer_to_str(VALUE self);
 static VALUE    Coolio_Buffer_read_from(VALUE self, VALUE io);
 static VALUE    Coolio_Buffer_write_to(VALUE self, VALUE io);
 
-static struct buffer *buffer_new(void);
+static struct buffer *buffer_init(struct buffer *);
 static void     buffer_clear(struct buffer * buf);
 static void     buffer_free(struct buffer * buf);
 static void     buffer_free_pool(struct buffer * buf);
@@ -86,8 +86,6 @@ static int      buffer_write_to(struct buffer * buf, int fd);
 void
 Init_coolio_buffer()
 {
-    VALUE cCoolio_IO;
-
     mCoolio = rb_define_module("Coolio");
     cCoolio_Buffer = rb_define_class_under(mCoolio, "Buffer", rb_cObject);
     rb_define_alloc_func(cCoolio_Buffer, Coolio_Buffer_allocate);
@@ -114,21 +112,33 @@ Init_coolio_buffer()
     rb_define_const(cCoolio_Buffer, "MAX_SIZE", INT2NUM(MAX_BUFFER_SIZE));
 }
 
+static const rb_data_type_t Coolio_Buffer_type = {
+    "Coolio::Buffer",
+    {
+        Coolio_Buffer_mark,
+        Coolio_Buffer_free,
+    }
+};
+
 static VALUE
 Coolio_Buffer_allocate(VALUE klass)
 {
-    return Data_Wrap_Struct(klass, Coolio_Buffer_mark, Coolio_Buffer_free, buffer_new());
+    struct buffer *buf;
+    VALUE buffer = TypedData_Make_Struct(klass, struct buffer, &Coolio_Buffer_type, buf);
+
+    buffer_init(buf);
+    return buffer;
 }
 
 static void
-Coolio_Buffer_mark(struct buffer * buf)
+Coolio_Buffer_mark(void *buf)
 {
     /* Naively discard the memory pool whenever Ruby garbage collects */
     buffer_free_pool(buf);
 }
 
 static void
-Coolio_Buffer_free(struct buffer * buf)
+Coolio_Buffer_free(void * buf)
 {
     buffer_free(buf);
 }
@@ -188,7 +198,7 @@ Coolio_Buffer_initialize(int argc, VALUE * argv, VALUE self)
     struct buffer *buf;
 
     if (rb_scan_args(argc, argv, "01", &node_size_obj) == 1) {
-        Data_Get_Struct(self, struct buffer, buf);
+        TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
         /*
          * Make sure we're not changing the buffer size after data
@@ -212,7 +222,7 @@ static VALUE
 Coolio_Buffer_clear(VALUE self)
 {
     struct buffer *buf;
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     buffer_clear(buf);
 
@@ -229,7 +239,7 @@ static VALUE
 Coolio_Buffer_size(VALUE self)
 {
     struct buffer *buf;
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     return INT2NUM(buf->size);
 }
@@ -244,7 +254,7 @@ static VALUE
 Coolio_Buffer_empty(VALUE self)
 {
     struct buffer *buf;
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     return buf->size > 0 ? Qfalse : Qtrue;
 }
@@ -259,7 +269,7 @@ static VALUE
 Coolio_Buffer_append(VALUE self, VALUE data)
 {
     struct buffer *buf;
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     /* Is this needed?  Never seen anyone else do it... */
     data = rb_convert_type(data, T_STRING, "String", "to_str");
@@ -278,7 +288,7 @@ static VALUE
 Coolio_Buffer_prepend(VALUE self, VALUE data)
 {
     struct buffer *buf;
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     data = rb_convert_type(data, T_STRING, "String", "to_str");
     buffer_prepend(buf, RSTRING_PTR(data), RSTRING_LEN(data));
@@ -304,7 +314,7 @@ Coolio_Buffer_read(int argc, VALUE * argv, VALUE self)
     int    length;
     struct buffer *buf;
 
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     if (rb_scan_args(argc, argv, "01", &length_obj) == 1) {
         length = NUM2INT(length_obj);
@@ -340,7 +350,7 @@ Coolio_Buffer_read_frame(VALUE self, VALUE data, VALUE mark)
     char mark_c = (char) NUM2INT(mark);
     struct buffer *buf;
 
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     if (buffer_read_frame(buf, data, mark_c)) {
         return Qtrue;
@@ -361,7 +371,7 @@ Coolio_Buffer_to_str(VALUE self)
     VALUE          str;
     struct buffer *buf;
 
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     str = rb_str_new(0, buf->size);
     buffer_copy(buf, RSTRING_PTR(str), buf->size);
@@ -388,7 +398,7 @@ Coolio_Buffer_read_from(VALUE self, VALUE io)
     OpenFile       *fptr;
 #endif
 
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
     io = rb_convert_type(io, T_FILE, "IO", "to_io");
     GetOpenFile(io, fptr);
     rb_io_set_nonblock(fptr);
@@ -419,7 +429,7 @@ Coolio_Buffer_write_to(VALUE self, VALUE io)
     OpenFile       *fptr;
 #endif
 
-    Data_Get_Struct(self, struct buffer, buf);
+    TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
     io = rb_convert_type(io, T_FILE, "IO", "to_io");
     GetOpenFile(io, fptr);
     rb_io_set_nonblock(fptr);
@@ -438,11 +448,8 @@ Coolio_Buffer_write_to(VALUE self, VALUE io)
 
 /* Create a new buffer */
 static struct buffer *
-buffer_new(void)
+buffer_init(struct buffer *buf)
 {
-    struct buffer *buf;
-
-    buf = (struct buffer *) xmalloc(sizeof(struct buffer));
     buf->head = buf->tail = buf->pool_head = buf->pool_tail = 0;
     buf->size = 0;
     buf->node_size = default_node_size;

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

@@ -68,4 +68,7 @@ void Init_coolio_timer_watcher();
 void Init_coolio_stat_watcher();
 void Init_coolio_utils();
 
+struct Coolio_Loop *Coolio_Loop_ptr(VALUE loop);
+struct Coolio_Watcher *Coolio_Watcher_ptr(VALUE watcher);
+
 #endif

data/ext/cool.io/iowatcher.c

@@ -82,7 +82,7 @@ static VALUE Coolio_IOWatcher_initialize(int argc, VALUE *argv, VALUE self)
   else
     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);
+  watcher_data = Coolio_Watcher_ptr(self);
   io = rb_convert_type(io, T_FILE, "IO", "to_io");
 
   watcher_data->dispatch_callback = Coolio_IOWatcher_dispatch_callback;

data/ext/cool.io/loop.c

@@ -14,8 +14,7 @@ static VALUE mCoolio = Qnil;
 static VALUE cCoolio_Loop = Qnil;
 
 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 void Coolio_Loop_free(void *data);
 
 static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags);
 static VALUE Coolio_Loop_run_once(int argc, VALUE *argv, VALUE self);
@@ -47,9 +46,26 @@ void Init_coolio_loop()
   rb_define_method(cCoolio_Loop, "run_nonblock", Coolio_Loop_run_nonblock, 0);
 }
 
+static const rb_data_type_t Coolio_Loop_type = {
+  "Coolio::Loop",
+  {
+    NULL,
+    Coolio_Loop_free,
+  },
+};
+
+struct Coolio_Loop *Coolio_Loop_ptr(VALUE self)
+{
+  struct Coolio_Loop *loop;
+
+  TypedData_Get_Struct(self, struct Coolio_Loop, &Coolio_Loop_type, loop);
+  return loop;
+}
+
 static VALUE Coolio_Loop_allocate(VALUE klass)
 {
-  struct Coolio_Loop *loop = (struct Coolio_Loop *)xmalloc(sizeof(struct Coolio_Loop));
+  struct Coolio_Loop *loop;
+  VALUE obj = TypedData_Make_Struct(klass, struct Coolio_Loop, &Coolio_Loop_type, loop);
 
   loop->ev_loop = 0;
   ev_init(&loop->timer, Coolio_Loop_timeout_callback);
@@ -58,15 +74,13 @@ static VALUE Coolio_Loop_allocate(VALUE klass)
   loop->eventbuf_size = DEFAULT_EVENTBUF_SIZE;
   loop->eventbuf = (struct Coolio_Event *)xmalloc(sizeof(struct Coolio_Event) * DEFAULT_EVENTBUF_SIZE);
 
-  return Data_Wrap_Struct(klass, Coolio_Loop_mark, Coolio_Loop_free, loop);
+  return obj;
 }
 
-static void Coolio_Loop_mark(struct Coolio_Loop *loop)
+static void Coolio_Loop_free(void *data)
 {
-}
+  struct Coolio_Loop *loop = data;
 
-static void Coolio_Loop_free(struct Coolio_Loop *loop)
-{
   if(!loop->ev_loop)
     return;
 
@@ -80,7 +94,7 @@ static void Coolio_Loop_free(struct Coolio_Loop *loop)
 static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags)
 {
   struct Coolio_Loop *loop_data;
-  Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+  loop_data = Coolio_Loop_ptr(self);
 
   if(loop_data->ev_loop)
     rb_raise(rb_eRuntimeError, "loop already initialized");
@@ -98,8 +112,8 @@ void Coolio_Loop_process_event(VALUE watcher, int revents)
 
   /* The Global VM lock isn't held right now, but hopefully
    * we can still do this safely */
-  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data);
-  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data);
+  watcher_data = Coolio_Watcher_ptr(watcher);
+  loop_data = Coolio_Loop_ptr(watcher_data->loop);
 
   /*  Well, what better place to explain how this all works than
    *  where the most wonky and convoluted stuff is going on!
@@ -184,7 +198,7 @@ static VALUE Coolio_Loop_run_once(int argc, VALUE *argv, VALUE self)
     rb_raise(rb_eArgError, "time interval must be positive");
   }
 
-  Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+  loop_data = Coolio_Loop_ptr(self);
 
   assert(loop_data->ev_loop && !loop_data->events_received);
 
@@ -222,7 +236,7 @@ static VALUE Coolio_Loop_run_nonblock(VALUE self)
   struct Coolio_Loop *loop_data;
   VALUE nevents;
   
-  Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+  loop_data = Coolio_Loop_ptr(self);
 
   assert(loop_data->ev_loop && !loop_data->events_received);
 
@@ -247,7 +261,7 @@ static void Coolio_Loop_dispatch_events(struct Coolio_Loop *loop_data)
     if(loop_data->eventbuf[i].watcher == Qnil)
       continue;
 
-    Data_Get_Struct(loop_data->eventbuf[i].watcher, struct Coolio_Watcher, watcher_data);
+    watcher_data = Coolio_Watcher_ptr(loop_data->eventbuf[i].watcher);
     watcher_data->dispatch_callback(loop_data->eventbuf[i].watcher, loop_data->eventbuf[i].revents);
   }
 }

data/ext/cool.io/stat_watcher.c

@@ -89,7 +89,7 @@ static VALUE Coolio_StatWatcher_initialize(int argc, VALUE *argv, VALUE self)
   path = rb_String(path);
   rb_iv_set(self, "@path", path);
 
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   watcher_data->dispatch_callback = Coolio_StatWatcher_dispatch_callback;
   ev_stat_init(
@@ -119,8 +119,8 @@ static VALUE Coolio_StatWatcher_attach(VALUE self, VALUE 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);
+  loop_data = Coolio_Loop_ptr(loop);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   if(watcher_data->loop != Qnil)
     Coolio_StatWatcher_detach(self);
@@ -206,7 +206,7 @@ static void Coolio_StatWatcher_libev_callback(struct ev_loop *ev_loop, struct ev
 static void Coolio_StatWatcher_dispatch_callback(VALUE self, int revents)
 {
   struct Coolio_Watcher *watcher_data;
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   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);

data/ext/cool.io/timer_watcher.c

@@ -68,7 +68,7 @@ static VALUE Coolio_TimerWatcher_initialize(int argc, VALUE *argv, VALUE self)
   rb_iv_set(self, "@interval", interval);
   rb_iv_set(self, "@repeating", repeating);
 
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   watcher_data->dispatch_callback = Coolio_TimerWatcher_dispatch_callback;
   ev_timer_init(
@@ -98,8 +98,8 @@ static VALUE Coolio_TimerWatcher_attach(VALUE self, VALUE 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);
+  loop_data = Coolio_Loop_ptr(loop);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   if(watcher_data->loop != Qnil)
     Coolio_TimerWatcher_detach(self);
@@ -180,12 +180,12 @@ static VALUE Coolio_TimerWatcher_reset(VALUE self)
   struct Coolio_Watcher *watcher_data;
   struct Coolio_Loop *loop_data;
 
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   if(watcher_data->loop == Qnil)
     rb_raise(rb_eRuntimeError, "not attached to a loop");
 
-  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data);
+  loop_data = Coolio_Loop_ptr(watcher_data->loop);
 
   ev_timer_again(loop_data->ev_loop, &watcher_data->event_types.ev_timer);
 

data/ext/cool.io/watcher.c

@@ -13,8 +13,7 @@ static VALUE mCoolio = Qnil;
 static VALUE cCoolio_Watcher = Qnil;
 
 static VALUE Coolio_Watcher_allocate(VALUE klass);
-static void Coolio_Watcher_mark(struct Coolio_Watcher *watcher);
-static void Coolio_Watcher_free(struct Coolio_Watcher *watcher);
+static void Coolio_Watcher_mark(void *data);
 
 static VALUE Coolio_Watcher_initialize(VALUE self);
 static VALUE Coolio_Watcher_attach(VALUE self, VALUE loop);
@@ -53,27 +52,41 @@ void Init_coolio_watcher()
   rb_define_method(cCoolio_Watcher, "enabled?", Coolio_Watcher_enabled, 0);
 }
 
+static const rb_data_type_t Coolio_Watcher_type = {
+  "Coolio::Watcher",
+  {
+    Coolio_Watcher_mark,
+    RUBY_DEFAULT_FREE,
+  },
+};
+
+struct Coolio_Watcher *Coolio_Watcher_ptr(VALUE watcher)
+{
+  struct Coolio_Watcher *watcher_data;
+
+  TypedData_Get_Struct(watcher, struct Coolio_Watcher, &Coolio_Watcher_type, watcher_data);
+  return watcher_data;
+}
+
 static VALUE Coolio_Watcher_allocate(VALUE klass)
 {
-  struct Coolio_Watcher *watcher_data = (struct Coolio_Watcher *)xmalloc(sizeof(struct Coolio_Watcher));
+  struct Coolio_Watcher *watcher_data;
+  VALUE watcher = TypedData_Make_Struct(klass, struct Coolio_Watcher, &Coolio_Watcher_type, watcher_data);
 
   watcher_data->loop = Qnil;
   watcher_data->enabled = 0;
 
-  return Data_Wrap_Struct(klass, Coolio_Watcher_mark, Coolio_Watcher_free, watcher_data);
+  return watcher;
 }
 
-static void Coolio_Watcher_mark(struct Coolio_Watcher *watcher_data)
+static void Coolio_Watcher_mark(void *data)
 {
+  struct Coolio_Watcher *watcher_data = data;
+
   if(watcher_data->loop != Qnil)
     rb_gc_mark(watcher_data->loop);
 }
 
-static void Coolio_Watcher_free(struct Coolio_Watcher *watcher_data)
-{
-  xfree(watcher_data);
-}
-
 static VALUE Coolio_Watcher_initialize(VALUE self)
 {
   rb_raise(rb_eRuntimeError, "watcher base class should not be initialized directly");
@@ -91,7 +104,7 @@ static VALUE Coolio_Watcher_attach(VALUE self, VALUE loop)
   VALUE loop_watchers, active_watchers;
   struct Coolio_Watcher *watcher_data;
 
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
   watcher_data->enabled = 1;
     
   loop_watchers = rb_iv_get(loop, "@watchers");
@@ -132,7 +145,7 @@ static VALUE Coolio_Watcher_detach(VALUE self)
   VALUE loop_watchers;
   int i;
 
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   if(watcher_data->loop == Qnil)
     rb_raise(rb_eRuntimeError, "not attached to a loop");
@@ -155,7 +168,7 @@ static VALUE Coolio_Watcher_detach(VALUE self)
 
   watcher_data->enabled = 0;
 
-  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data);
+  loop_data = Coolio_Loop_ptr(watcher_data->loop);
 
   /* Iterate through the events in the loop's event buffer.  If there
    * are any pending events from this watcher, mark them NULL.  The
@@ -182,7 +195,7 @@ static VALUE Coolio_Watcher_detach(VALUE self)
 static VALUE Coolio_Watcher_enable(VALUE self)
 {
   struct Coolio_Watcher *watcher_data;
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   if(watcher_data->enabled)
     rb_raise(rb_eRuntimeError, "already enabled");
@@ -208,7 +221,7 @@ static VALUE Coolio_Watcher_enable(VALUE self)
 static VALUE Coolio_Watcher_disable(VALUE self)
 {
   struct Coolio_Watcher *watcher_data;
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   if(!watcher_data->enabled)
     rb_raise(rb_eRuntimeError, "already disabled");
@@ -234,7 +247,7 @@ static VALUE Coolio_Watcher_evloop(VALUE self)
 {
   struct Coolio_Watcher *watcher_data;
 
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
   return watcher_data->loop;
 }
 
@@ -258,7 +271,7 @@ static VALUE Coolio_Watcher_attached(VALUE self)
 static VALUE Coolio_Watcher_enabled(VALUE self)
 {
 	struct Coolio_Watcher *watcher_data;
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
   
 	return watcher_data->enabled ? Qtrue : Qfalse;
 }

data/ext/cool.io/watcher.h

@@ -14,8 +14,8 @@
   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(watcher, struct Coolio_Watcher, watcher_data); \
-  Data_Get_Struct(loop, struct Coolio_Loop, loop_data); \
+  watcher_data = Coolio_Watcher_ptr(watcher); \
+  loop_data = Coolio_Loop_ptr(loop); \
   \
   if(watcher_data->loop != Qnil) \
     detach_func(watcher); \
@@ -28,12 +28,12 @@
   struct Coolio_Watcher *watcher_data; \
   struct Coolio_Loop *loop_data; \
   \
-  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
+  watcher_data = Coolio_Watcher_ptr(watcher); \
   \
   if(watcher_data->loop == Qnil) \
     rb_raise(rb_eRuntimeError, "not attached to a loop"); \
   \
-  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \
+  loop_data = Coolio_Loop_ptr(watcher_data->loop); \
   \
   ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
   rb_call_super(0, 0)
@@ -42,14 +42,14 @@
   struct Coolio_Watcher *watcher_data; \
   struct Coolio_Loop *loop_data; \
   \
-  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
+  watcher_data = Coolio_Watcher_ptr(watcher); \
   \
   if(watcher_data->loop == Qnil) \
     rb_raise(rb_eRuntimeError, "not attached to a loop"); \
   \
   rb_call_super(0, 0); \
   \
-  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \
+  loop_data = Coolio_Loop_ptr(watcher_data->loop); \
   \
   ev_##watcher_type##_start(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type)
 
@@ -57,14 +57,14 @@
   struct Coolio_Watcher *watcher_data; \
   struct Coolio_Loop *loop_data; \
   \
-  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
+  watcher_data = Coolio_Watcher_ptr(watcher); \
   \
   if(watcher_data->loop == Qnil) \
     rb_raise(rb_eRuntimeError, "not attached to a loop"); \
   \
   rb_call_super(0, 0); \
   \
-  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \
+  loop_data = Coolio_Loop_ptr(watcher_data->loop); \
   \
   ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type)
 

data/lib/cool.io/dns_resolver.rb

@@ -72,7 +72,7 @@ module Coolio
         raise RuntimeError, "no nameservers found" if nameservers.empty? # TODO just call resolve_failed, not raise [also handle Errno::ENOENT)]
       end
 
-      @nameservers = nameservers
+      @nameservers = nameservers.dup
       @question = request_question hostname
 
       @socket = UDPSocket.new

data/lib/cool.io/version.rb

@@ -1,5 +1,5 @@
 module Coolio
-  VERSION = "1.9.0"
+  VERSION = "1.9.1"
   
   def self.version
     VERSION

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cool.io
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.9.1
 platform: ruby
 authors:
 - Tony Arcieri
 - Masahiro Nakagawa
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-02 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -155,7 +154,6 @@ homepage: https://github.com/socketry/cool.io
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -170,8 +168,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 4.0.0.dev
 specification_version: 4
 summary: A cool framework for doing high performance I/O in Ruby
 test_files: