cool.io 1.8.1 → 1.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 963110b3477915c06d5122e46b0f92bb1ec3027ad61fa61bb19a4cfdb14f711c
-  data.tar.gz: f60f872be0ec258fc9ba31ac0ece2a7f8dd5be4c34306f4ecd9cd74c6597a210
+  metadata.gz: 1d38b3958d9ad5505fb4a53ded526d2ab347d46200a567a9aa0681cc5ca487cc
+  data.tar.gz: 42cb1b75db2c409dfc48756b8df29663675e31a104d03c37bbbfce9344592d6d
 SHA512:
-  metadata.gz: cc856dadd22e6a5c8ef8d19be3e7c8e62d23ca5d77ebfb07724594fa985dd16883559c4c6b5a813754b8604c2b9ffb2adee5114db79c0ef2986807fdf6e4d586
-  data.tar.gz: ebf278654c250395cacba0b0b11552303fffed6d5e2b002b4637eaa68723183be401aa2d7e8485f473b979708232a9e3a1d0be18f094dc6a4c3eea65be4e848f
+  metadata.gz: 6e3358de317e34735ca0f264c75f93d34d38325482c02eabf4d1289b3c44ef6557918bd59078a34c809322d69d05299ccb58f89db630c4054dc0162de8ab49b6
+  data.tar.gz: 775568343fe8788adbc43757a6f06ef5474e1d19477571317f29e21ff3da777d8567a6401377c6eb854e9f0c4060d97da7c84dafa56dc1e772f636417365d338

data/.github/workflows/test.yaml

@@ -26,6 +26,7 @@ jobs:
           - "3.0"
           - "3.1"
           - "3.2"
+          - "3.3"
           - "head"
         
         experimental: [false]

data/.gitignore

@@ -26,4 +26,5 @@ tmp
 conftest.dSYM
 
 *.lock
+gems.locked
 .ruby-version

data/Rakefile

@@ -31,11 +31,6 @@ def configure_cross_compilation(ext)
   end
 end
 
-Rake::ExtensionTask.new('iobuffer_ext', spec) do |ext|
-  ext.ext_dir = 'ext/iobuffer'
-  configure_cross_compilation(ext)
-end
-
 Rake::ExtensionTask.new('cool.io_ext', spec) do |ext|
   ext.ext_dir = 'ext/cool.io'
   configure_cross_compilation(ext)

data/cool.io.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.homepage    = "https://github.com/socketry/cool.io"
   s.summary     = "A cool framework for doing high performance I/O in Ruby"
   s.description = "Cool.io provides a high performance event framework for Ruby which uses the libev C library"
-  s.extensions = ["ext/cool.io/extconf.rb", "ext/iobuffer/extconf.rb"]
+  s.extensions = ["ext/cool.io/extconf.rb"]
   s.licenses   = ["MIT"]
 
   s.files         = `git ls-files`.split("\n")

data/ext/{iobuffer/iobuffer.c → cool.io/buffer.c}

@@ -43,27 +43,28 @@ struct buffer_node {
     unsigned char   data[0];
 };
 
-static VALUE    cIO_Buffer = Qnil;
-
-static VALUE    IO_Buffer_allocate(VALUE klass);
-static void     IO_Buffer_mark(struct buffer *);
-static void     IO_Buffer_free(struct buffer *);
-
-static VALUE    IO_Buffer_default_node_size(VALUE klass);
-static VALUE    IO_Buffer_set_default_node_size(VALUE klass, VALUE size);
-static VALUE    IO_Buffer_initialize(int argc, VALUE * argv, VALUE self);
-static VALUE    IO_Buffer_clear(VALUE self);
-static VALUE    IO_Buffer_size(VALUE self);
-static VALUE    IO_Buffer_empty(VALUE self);
-static VALUE    IO_Buffer_append(VALUE self, VALUE data);
-static VALUE    IO_Buffer_prepend(VALUE self, VALUE data);
-static VALUE    IO_Buffer_read(int argc, VALUE * argv, VALUE self);
-static VALUE    IO_Buffer_read_frame(VALUE self, VALUE data, VALUE mark);
-static VALUE    IO_Buffer_to_str(VALUE self);
-static VALUE    IO_Buffer_read_from(VALUE self, VALUE io);
-static VALUE    IO_Buffer_write_to(VALUE self, VALUE io);
-
-static struct buffer *buffer_new(void);
+static VALUE    mCoolio = Qnil;
+static VALUE    cCoolio_Buffer = Qnil;
+
+static VALUE    Coolio_Buffer_allocate(VALUE klass);
+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);
+static VALUE    Coolio_Buffer_initialize(int argc, VALUE * argv, VALUE self);
+static VALUE    Coolio_Buffer_clear(VALUE self);
+static VALUE    Coolio_Buffer_size(VALUE self);
+static VALUE    Coolio_Buffer_empty(VALUE self);
+static VALUE    Coolio_Buffer_append(VALUE self, VALUE data);
+static VALUE    Coolio_Buffer_prepend(VALUE self, VALUE data);
+static VALUE    Coolio_Buffer_read(int argc, VALUE * argv, VALUE self);
+static VALUE    Coolio_Buffer_read_frame(VALUE self, VALUE data, VALUE mark);
+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_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);
@@ -83,60 +84,73 @@ static int      buffer_write_to(struct buffer * buf, int fd);
  * Ruby IO objects.
  */
 void
-Init_iobuffer_ext()
+Init_coolio_buffer()
 {
-    cIO_Buffer = rb_define_class_under(rb_cIO, "Buffer", rb_cObject);
-    rb_define_alloc_func(cIO_Buffer, IO_Buffer_allocate);
-
-    rb_define_singleton_method(cIO_Buffer, "default_node_size",
-                   IO_Buffer_default_node_size, 0);
-    rb_define_singleton_method(cIO_Buffer, "default_node_size=",
-                   IO_Buffer_set_default_node_size, 1);
-
-    rb_define_method(cIO_Buffer, "initialize", IO_Buffer_initialize, -1);
-    rb_define_method(cIO_Buffer, "clear", IO_Buffer_clear, 0);
-    rb_define_method(cIO_Buffer, "size", IO_Buffer_size, 0);
-    rb_define_method(cIO_Buffer, "empty?", IO_Buffer_empty, 0);
-    rb_define_method(cIO_Buffer, "<<", IO_Buffer_append, 1);
-    rb_define_method(cIO_Buffer, "append", IO_Buffer_append, 1);
-    rb_define_method(cIO_Buffer, "write", IO_Buffer_append, 1);
-    rb_define_method(cIO_Buffer, "prepend", IO_Buffer_prepend, 1);
-    rb_define_method(cIO_Buffer, "read", IO_Buffer_read, -1);
-    rb_define_method(cIO_Buffer, "read_frame", IO_Buffer_read_frame, 2);
-    rb_define_method(cIO_Buffer, "to_str", IO_Buffer_to_str, 0);
-    rb_define_method(cIO_Buffer, "read_from", IO_Buffer_read_from, 1);
-    rb_define_method(cIO_Buffer, "write_to", IO_Buffer_write_to, 1);
-
-    rb_define_const(cIO_Buffer, "MAX_SIZE", INT2NUM(MAX_BUFFER_SIZE));
+    mCoolio = rb_define_module("Coolio");
+    cCoolio_Buffer = rb_define_class_under(mCoolio, "Buffer", rb_cObject);
+    rb_define_alloc_func(cCoolio_Buffer, Coolio_Buffer_allocate);
+
+    rb_define_singleton_method(cCoolio_Buffer, "default_node_size",
+                   Coolio_Buffer_default_node_size, 0);
+    rb_define_singleton_method(cCoolio_Buffer, "default_node_size=",
+                   Coolio_Buffer_set_default_node_size, 1);
+
+    rb_define_method(cCoolio_Buffer, "initialize", Coolio_Buffer_initialize, -1);
+    rb_define_method(cCoolio_Buffer, "clear", Coolio_Buffer_clear, 0);
+    rb_define_method(cCoolio_Buffer, "size", Coolio_Buffer_size, 0);
+    rb_define_method(cCoolio_Buffer, "empty?", Coolio_Buffer_empty, 0);
+    rb_define_method(cCoolio_Buffer, "<<", Coolio_Buffer_append, 1);
+    rb_define_method(cCoolio_Buffer, "append", Coolio_Buffer_append, 1);
+    rb_define_method(cCoolio_Buffer, "write", Coolio_Buffer_append, 1);
+    rb_define_method(cCoolio_Buffer, "prepend", Coolio_Buffer_prepend, 1);
+    rb_define_method(cCoolio_Buffer, "read", Coolio_Buffer_read, -1);
+    rb_define_method(cCoolio_Buffer, "read_frame", Coolio_Buffer_read_frame, 2);
+    rb_define_method(cCoolio_Buffer, "to_str", Coolio_Buffer_to_str, 0);
+    rb_define_method(cCoolio_Buffer, "read_from", Coolio_Buffer_read_from, 1);
+    rb_define_method(cCoolio_Buffer, "write_to", Coolio_Buffer_write_to, 1);
+
+    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
-IO_Buffer_allocate(VALUE klass)
+Coolio_Buffer_allocate(VALUE klass)
 {
-    return Data_Wrap_Struct(klass, IO_Buffer_mark, IO_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
-IO_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
-IO_Buffer_free(struct buffer * buf)
+Coolio_Buffer_free(void * buf)
 {
     buffer_free(buf);
 }
 
 /**
  * call-seq:
- *   IO_Buffer.default_node_size -> 4096
+ *   Coolio::Buffer.default_node_size -> 4096
  *
  * Retrieves the current value of the default node size.
  */
 static VALUE
-IO_Buffer_default_node_size(VALUE klass)
+Coolio_Buffer_default_node_size(VALUE klass)
 {
     return UINT2NUM(default_node_size);
 }
@@ -159,12 +173,12 @@ convert_node_size(VALUE size)
 
 /**
  * call-seq:
- *   IO_Buffer.default_node_size = 16384
+ *   Coolio::Buffer.default_node_size = 16384
  *
- * Sets the default node size for calling IO::Buffer.new with no arguments.
+ * Sets the default node size for calling Coolio::Buffer.new with no arguments.
  */
 static VALUE
-IO_Buffer_set_default_node_size(VALUE klass, VALUE size)
+Coolio_Buffer_set_default_node_size(VALUE klass, VALUE size)
 {
     default_node_size = convert_node_size(size);
 
@@ -173,18 +187,18 @@ IO_Buffer_set_default_node_size(VALUE klass, VALUE size)
 
 /**
  *  call-seq:
- *    IO_Buffer.new(size = IO::Buffer.default_node_size) -> IO_Buffer
+ *    Coolio::Buffer.new(size = Coolio::Buffer.default_node_size) -> Coolio::Buffer
  *
- * Create a new IO_Buffer with linked segments of the given size
+ * Create a new Coolio::Buffer with linked segments of the given size
  */
 static VALUE
-IO_Buffer_initialize(int argc, VALUE * argv, VALUE self)
+Coolio_Buffer_initialize(int argc, VALUE * argv, VALUE self)
 {
     VALUE           node_size_obj;
     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
@@ -200,15 +214,15 @@ IO_Buffer_initialize(int argc, VALUE * argv, VALUE self)
 
 /**
  *  call-seq:
- *    IO_Buffer#clear -> nil
+ *    Coolio::Buffer#clear -> nil
  *
- * Clear all data from the IO_Buffer
+ * Clear all data from the Coolio::Buffer
  */
 static VALUE
-IO_Buffer_clear(VALUE self)
+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);
 
@@ -217,45 +231,45 @@ IO_Buffer_clear(VALUE self)
 
 /**
  *  call-seq:
- *    IO_Buffer#size -> Integer
+ *    Coolio::Buffer#size -> Integer
  *
  * Return the size of the buffer in bytes
  */
 static VALUE
-IO_Buffer_size(VALUE self)
+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);
 }
 
 /**
  *  call-seq:
- *    IO_Buffer#empty? -> Boolean
+ *    Coolio::Buffer#empty? -> Boolean
  *
  * Is the buffer empty?
  */
 static VALUE
-IO_Buffer_empty(VALUE self)
+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;
 }
 
 /**
  *  call-seq:
- *    IO_Buffer#append(data) -> String
+ *    Coolio::Buffer#append(data) -> String
  *
  * Append the given data to the end of the buffer
  */
 static VALUE
-IO_Buffer_append(VALUE self, VALUE data)
+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");
@@ -266,15 +280,15 @@ IO_Buffer_append(VALUE self, VALUE data)
 
 /**
  *  call-seq:
- *    IO_Buffer#prepend(data) -> String
+ *    Coolio::Buffer#prepend(data) -> String
  *
  * Prepend the given data to the beginning of the buffer
  */
 static VALUE
-IO_Buffer_prepend(VALUE self, VALUE data)
+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));
@@ -284,7 +298,7 @@ IO_Buffer_prepend(VALUE self, VALUE data)
 
 /**
  *  call-seq:
- *    IO_Buffer#read(length = nil) -> String
+ *    Coolio::Buffer#read(length = nil) -> String
  *
  * Read the specified abount of data from the buffer.  If no value
  * is given the entire contents of the buffer are returned.  Any data
@@ -294,13 +308,13 @@ IO_Buffer_prepend(VALUE self, VALUE data)
  * the given length).
  */
 static VALUE
-IO_Buffer_read(int argc, VALUE * argv, VALUE self)
+Coolio_Buffer_read(int argc, VALUE * argv, VALUE self)
 {
     VALUE  length_obj, str;
     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);
@@ -322,7 +336,7 @@ IO_Buffer_read(int argc, VALUE * argv, VALUE self)
 
 /**
  *  call-seq:
- *    IO_Buffer#read_frame(str, mark) -> boolean
+ *    Coolio::Buffer#read_frame(str, mark) -> boolean
  *
  * Read up to and including the given frame marker (expressed a a
  * Fixnum 0-255) byte, copying into the supplied string object. If the mark is
@@ -331,12 +345,12 @@ IO_Buffer_read(int argc, VALUE * argv, VALUE self)
  *
  */
 static VALUE
-IO_Buffer_read_frame(VALUE self, VALUE data, VALUE mark)
+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;
@@ -347,17 +361,17 @@ IO_Buffer_read_frame(VALUE self, VALUE data, VALUE mark)
 
 /**
  *  call-seq:
- *    IO_Buffer#to_str -> String
+ *    Coolio::Buffer#to_str -> String
  *
  * Convert the Buffer to a String.  The original buffer is unmodified.
  */
 static VALUE
-IO_Buffer_to_str(VALUE self)
+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);
@@ -367,14 +381,14 @@ IO_Buffer_to_str(VALUE self)
 
 /**
  *  call-seq:
- *    IO_Buffer#read_from(io) -> Integer
+ *    Coolio::Buffer#read_from(io) -> Integer
  *
  * Perform a nonblocking read of the the given IO object and fill
  * the buffer with any data received.  The call will read as much
  * data as it can until the read would block.
  */
 static VALUE
-IO_Buffer_read_from(VALUE self, VALUE io)
+Coolio_Buffer_read_from(VALUE self, VALUE io)
 {
     struct buffer  *buf;
     int             ret;
@@ -384,7 +398,7 @@ IO_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);
@@ -399,14 +413,14 @@ IO_Buffer_read_from(VALUE self, VALUE io)
 
 /**
  *  call-seq:
- *    IO_Buffer#write_to(io) -> Integer
+ *    Coolio::Buffer#write_to(io) -> Integer
  *
  * Perform a nonblocking write of the buffer to the given IO object.
  * As much data as possible is written until the call would block.
  * Any data which is written is removed from the buffer.
  */
 static VALUE
-IO_Buffer_write_to(VALUE self, VALUE io)
+Coolio_Buffer_write_to(VALUE self, VALUE io)
 {
     struct buffer  *buf;
 #if defined(HAVE_RB_IO_T) || defined(HAVE_RB_IO_DESCRIPTOR)
@@ -415,7 +429,7 @@ IO_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);
@@ -434,11 +448,8 @@ IO_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

@@ -60,6 +60,7 @@ 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();
@@ -67,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/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/extconf.rb

@@ -11,6 +11,12 @@ 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_header('ruby/io.h')
   $defs << '-DHAVE_RUBY_IO_H'
 end
@@ -72,4 +78,3 @@ if RUBY_PLATFORM =~ /mingw|mswin/
   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

@@ -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/{Gemfile → gems.rb}

@@ -2,3 +2,8 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in cool.io.gemspec
 gemspec
+
+group :maintenance, optional: true do
+  gem "bake-gem"
+  gem "bake-modernize"
+end

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/io.rb

@@ -21,7 +21,7 @@ module Coolio
 
     def initialize(io)
       @_io = io
-      @_write_buffer  ||= ::IO::Buffer.new
+      @_write_buffer  ||= ::Coolio::Buffer.new
       @_read_watcher  = Watcher.new(io, self, :r)
       @_write_watcher = Watcher.new(io, self, :w)
     end

data/lib/cool.io/socket.rb

@@ -130,7 +130,7 @@ module Coolio
 
     # Called by precreate during asyncronous DNS resolution
     def preinitialize(addr, port, *args)
-      @_write_buffer = ::IO::Buffer.new # allow for writing BEFORE DNS has resolved
+      @_write_buffer = ::Coolio::Buffer.new # allow for writing BEFORE DNS has resolved
       @remote_host, @remote_addr, @remote_port = addr, addr, port
       @_resolver = TCPConnectResolver.new(self, addr, port, *args)
     end

data/lib/cool.io/version.rb

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

data/lib/cool.io.rb

@@ -6,7 +6,6 @@
 
 require "cool.io/version"
 require "cool.io/custom_require"
-cool_require "iobuffer_ext"
 cool_require "cool.io_ext"
 
 require "cool.io/loop"

data/spec/iobuffer_spec.rb

@@ -1,10 +1,10 @@
 require File.expand_path('../spec_helper', __FILE__)
 
 
-describe IO::Buffer do
+describe Cool.io::Buffer do
 
   let :buffer do
-    IO::Buffer.new
+    Cool.io::Buffer.new
   end
   
   it "provides a subset of the methods available in Strings" do

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cool.io
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 1.9.1
 platform: ruby
 authors:
 - Tony Arcieri
 - Masahiro Nakagawa
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-17 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -75,15 +74,12 @@ email:
 executables: []
 extensions:
 - ext/cool.io/extconf.rb
-- ext/iobuffer/extconf.rb
 extra_rdoc_files: []
 files:
 - ".github/workflows/test.yaml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - CHANGES.md
-- Gemfile
 - LICENSE
 - README.md
 - Rakefile
@@ -96,6 +92,7 @@ files:
 - examples/echo_server.rb
 - examples/google.rb
 - ext/cool.io/.gitignore
+- ext/cool.io/buffer.c
 - ext/cool.io/cool.io.h
 - ext/cool.io/cool.io_ext.c
 - ext/cool.io/ev_wrap.h
@@ -108,8 +105,6 @@ files:
 - ext/cool.io/utils.c
 - ext/cool.io/watcher.c
 - ext/cool.io/watcher.h
-- ext/iobuffer/extconf.rb
-- ext/iobuffer/iobuffer.c
 - ext/libev/Changes
 - ext/libev/LICENSE
 - ext/libev/README
@@ -125,6 +120,7 @@ files:
 - ext/libev/ev_win32.c
 - ext/libev/ev_wrap.h
 - ext/libev/test_libev_win32.c
+- gems.rb
 - lib/.gitignore
 - lib/cool.io.rb
 - lib/cool.io/async_watcher.rb
@@ -158,7 +154,6 @@ homepage: https://github.com/socketry/cool.io
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -173,8 +168,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-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:

data/.travis.yml

@@ -1,16 +0,0 @@
-language: ruby
-
-sudo: false
-
-rvm:
-  - 2.4.10
-  - 2.5
-  - 2.6
-  - 2.7
-  - ruby-head
-  - rbx
-
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-    - rvm: rbx

data/ext/iobuffer/extconf.rb

@@ -1,10 +0,0 @@
-require 'mkmf'
-
-dir_config("iobuffer")
-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
-
-create_makefile("iobuffer_ext")