nio4r 2.5.2 → 2.7.0

data/ext/nio4r/selector.c

@@ -5,7 +5,7 @@
 
 #include "nio4r.h"
 #ifdef HAVE_RUBYSIG_H
-# include "rubysig.h"
+#include "rubysig.h"
 #endif
 
 #ifdef HAVE_UNISTD_H
@@ -14,18 +14,19 @@
 #include <io.h>
 #endif
 
-#include <fcntl.h>
 #include <assert.h>
+#include <fcntl.h>
 
 static VALUE mNIO = Qnil;
-static VALUE cNIO_Monitor  = Qnil;
+static VALUE cNIO_Monitor = Qnil;
 static VALUE cNIO_Selector = Qnil;
 
 /* Allocator/deallocator */
 static VALUE NIO_Selector_allocate(VALUE klass);
-static void NIO_Selector_mark(struct NIO_Selector *loop);
+static void NIO_Selector_mark(void *data);
 static void NIO_Selector_shutdown(struct NIO_Selector *selector);
-static void NIO_Selector_free(struct NIO_Selector *loop);
+static void NIO_Selector_free(void *data);
+static size_t NIO_Selector_memsize(const void *data);
 
 /* Class methods */
 static VALUE NIO_Selector_supported_backends(VALUE klass);
@@ -43,13 +44,13 @@ static VALUE NIO_Selector_closed(VALUE self);
 static VALUE NIO_Selector_is_empty(VALUE self);
 
 /* Internal functions */
-static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VALUE *args);
+static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE arg), VALUE arg);
 static VALUE NIO_Selector_unlock(VALUE lock);
-static VALUE NIO_Selector_register_synchronized(VALUE *args);
-static VALUE NIO_Selector_deregister_synchronized(VALUE *args);
-static VALUE NIO_Selector_select_synchronized(VALUE *args);
-static VALUE NIO_Selector_close_synchronized(VALUE *args);
-static VALUE NIO_Selector_closed_synchronized(VALUE *args);
+static VALUE NIO_Selector_register_synchronized(VALUE arg);
+static VALUE NIO_Selector_deregister_synchronized(VALUE arg);
+static VALUE NIO_Selector_select_synchronized(VALUE arg);
+static VALUE NIO_Selector_close_synchronized(VALUE arg);
+static VALUE NIO_Selector_closed_synchronized(VALUE arg);
 
 static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout);
 static void NIO_Selector_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents);
@@ -62,7 +63,7 @@ static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_io *
 #define BUSYWAIT_INTERVAL 0.01
 
 /* Selectors wait for events */
-void Init_NIO_Selector()
+void Init_NIO_Selector(void)
 {
     mNIO = rb_define_module("NIO");
     cNIO_Selector = rb_define_class_under(mNIO, "Selector", rb_cObject);
@@ -80,9 +81,21 @@ void Init_NIO_Selector()
     rb_define_method(cNIO_Selector, "closed?", NIO_Selector_closed, 0);
     rb_define_method(cNIO_Selector, "empty?", NIO_Selector_is_empty, 0);
 
-    cNIO_Monitor = rb_define_class_under(mNIO, "Monitor",  rb_cObject);
+    cNIO_Monitor = rb_define_class_under(mNIO, "Monitor", rb_cObject);
 }
 
+static const rb_data_type_t NIO_Selector_type = {
+    "NIO::Selector",
+    {
+        NIO_Selector_mark,
+        NIO_Selector_free,
+        NIO_Selector_memsize,
+    },
+    0,
+    0,
+    RUBY_TYPED_WB_PROTECTED // Don't free immediately because of shutdown
+};
+
 /* Create the libev event loop and incoming event buffer */
 static VALUE NIO_Selector_allocate(VALUE klass)
 {
@@ -95,18 +108,16 @@ static VALUE NIO_Selector_allocate(VALUE klass)
        safety. Pipes are nice and safe to use between threads.
 
        Note that Java NIO uses this same mechanism */
-    if(pipe(fds) < 0) {
+    if (pipe(fds) < 0) {
         rb_sys_fail("pipe");
     }
 
     /* Use non-blocking reads/writes during wakeup, in case the buffer is full */
-    if(fcntl(fds[0], F_SETFL, O_NONBLOCK) < 0 ||
-       fcntl(fds[1], F_SETFL, O_NONBLOCK) < 0) {
+    if (fcntl(fds[0], F_SETFL, O_NONBLOCK) < 0 || fcntl(fds[1], F_SETFL, O_NONBLOCK) < 0) {
         rb_sys_fail("fcntl");
     }
 
-    selector = (struct NIO_Selector *)xmalloc(sizeof(struct NIO_Selector));
-
+    VALUE obj = TypedData_Make_Struct(klass, struct NIO_Selector, &NIO_Selector_type, selector);
     /* Defer initializing the loop to #initialize */
     selector->ev_loop = 0;
 
@@ -119,15 +130,22 @@ static VALUE NIO_Selector_allocate(VALUE klass)
     selector->wakeup.data = (void *)selector;
 
     selector->closed = selector->selecting = selector->wakeup_fired = selector->ready_count = 0;
-    selector->ready_array = Qnil;
+    RB_OBJ_WRITE(obj, &selector->ready_array, Qnil);
+    return obj;
+}
 
-    return Data_Wrap_Struct(klass, NIO_Selector_mark, NIO_Selector_free, selector);
+struct NIO_Selector *NIO_Selector_unwrap(VALUE self)
+{
+    struct NIO_Selector *selector;
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
+    return selector;
 }
 
 /* NIO selectors store all Ruby objects in instance variables so mark is a stub */
-static void NIO_Selector_mark(struct NIO_Selector *selector)
+static void NIO_Selector_mark(void *data)
 {
-    if(selector->ready_array != Qnil) {
+    struct NIO_Selector *selector = (struct NIO_Selector *)data;
+    if (selector->ready_array != Qnil) {
         rb_gc_mark(selector->ready_array);
     }
 }
@@ -136,14 +154,14 @@ static void NIO_Selector_mark(struct NIO_Selector *selector)
    Called by both NIO::Selector#close and the finalizer below */
 static void NIO_Selector_shutdown(struct NIO_Selector *selector)
 {
-    if(selector->closed) {
+    if (selector->closed) {
         return;
     }
 
     close(selector->wakeup_reader);
     close(selector->wakeup_writer);
 
-    if(selector->ev_loop) {
+    if (selector->ev_loop) {
         ev_loop_destroy(selector->ev_loop);
         selector->ev_loop = 0;
     }
@@ -152,37 +170,52 @@ static void NIO_Selector_shutdown(struct NIO_Selector *selector)
 }
 
 /* Ruby finalizer for selector objects */
-static void NIO_Selector_free(struct NIO_Selector *selector)
+static void NIO_Selector_free(void *data)
 {
+    struct NIO_Selector *selector = (struct NIO_Selector *)data;
     NIO_Selector_shutdown(selector);
     xfree(selector);
 }
 
+static size_t NIO_Selector_memsize(const void *data)
+{
+    return sizeof(struct NIO_Selector);
+}
+
 /* Return an array of symbols for supported backends */
-static VALUE NIO_Selector_supported_backends(VALUE klass) {
+static VALUE NIO_Selector_supported_backends(VALUE klass)
+{
     unsigned int backends = ev_supported_backends();
     VALUE result = rb_ary_new();
 
-    if(backends & EVBACKEND_EPOLL) {
+    if (backends & EVBACKEND_EPOLL) {
         rb_ary_push(result, ID2SYM(rb_intern("epoll")));
     }
 
-    if(backends & EVBACKEND_POLL) {
+    if (backends & EVBACKEND_POLL) {
         rb_ary_push(result, ID2SYM(rb_intern("poll")));
     }
 
-    if(backends & EVBACKEND_KQUEUE) {
+    if (backends & EVBACKEND_KQUEUE) {
         rb_ary_push(result, ID2SYM(rb_intern("kqueue")));
     }
 
-    if(backends & EVBACKEND_SELECT) {
+    if (backends & EVBACKEND_SELECT) {
         rb_ary_push(result, ID2SYM(rb_intern("select")));
     }
 
-    if(backends & EVBACKEND_PORT) {
+    if (backends & EVBACKEND_PORT) {
         rb_ary_push(result, ID2SYM(rb_intern("port")));
     }
 
+    if (backends & EVBACKEND_LINUXAIO) {
+        rb_ary_push(result, ID2SYM(rb_intern("linuxaio")));
+    }
+
+    if (backends & EVBACKEND_IOURING) {
+        rb_ary_push(result, ID2SYM(rb_intern("io_uring")));
+    }
+
     return result;
 }
 
@@ -197,31 +230,33 @@ static VALUE NIO_Selector_initialize(int argc, VALUE *argv, VALUE self)
     struct NIO_Selector *selector;
     unsigned int flags = 0;
 
-    Data_Get_Struct(self, struct NIO_Selector, selector);
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
 
     rb_scan_args(argc, argv, "01", &backend);
 
-    if(backend != Qnil) {
-        if(!rb_ary_includes(NIO_Selector_supported_backends(CLASS_OF(self)), backend)) {
-            rb_raise(rb_eArgError, "unsupported backend: %s",
-                RSTRING_PTR(rb_funcall(backend, rb_intern("inspect"), 0)));
+    if (backend != Qnil) {
+        if (!rb_ary_includes(NIO_Selector_supported_backends(CLASS_OF(self)), backend)) {
+            rb_raise(rb_eArgError, "unsupported backend: %s", RSTRING_PTR(rb_funcall(backend, rb_intern("inspect"), 0)));
         }
 
         backend_id = SYM2ID(backend);
 
-        if(backend_id == rb_intern("epoll")) {
+        if (backend_id == rb_intern("epoll")) {
             flags = EVBACKEND_EPOLL;
-        } else if(backend_id == rb_intern("poll")) {
+        } else if (backend_id == rb_intern("poll")) {
             flags = EVBACKEND_POLL;
-        } else if(backend_id == rb_intern("kqueue")) {
+        } else if (backend_id == rb_intern("kqueue")) {
             flags = EVBACKEND_KQUEUE;
-        } else if(backend_id == rb_intern("select")) {
+        } else if (backend_id == rb_intern("select")) {
             flags = EVBACKEND_SELECT;
-        } else if(backend_id == rb_intern("port")) {
+        } else if (backend_id == rb_intern("port")) {
             flags = EVBACKEND_PORT;
+        } else if (backend_id == rb_intern("linuxaio")) {
+            flags = EVBACKEND_LINUXAIO;
+        } else if (backend_id == rb_intern("io_uring")) {
+            flags = EVBACKEND_IOURING;
         } else {
-            rb_raise(rb_eArgError, "unsupported backend: %s",
-                RSTRING_PTR(rb_funcall(backend, rb_intern("inspect"), 0)));
+            rb_raise(rb_eArgError, "unsupported backend: %s", RSTRING_PTR(rb_funcall(backend, rb_intern("inspect"), 0)));
         }
     }
 
@@ -229,7 +264,7 @@ static VALUE NIO_Selector_initialize(int argc, VALUE *argv, VALUE self)
     assert(!selector->ev_loop);
 
     selector->ev_loop = ev_loop_new(flags);
-    if(!selector->ev_loop) {
+    if (!selector->ev_loop) {
         rb_raise(rb_eIOError, "error initializing event loop");
     }
 
@@ -245,11 +280,12 @@ static VALUE NIO_Selector_initialize(int argc, VALUE *argv, VALUE self)
     return Qnil;
 }
 
-static VALUE NIO_Selector_backend(VALUE self) {
+static VALUE NIO_Selector_backend(VALUE self)
+{
     struct NIO_Selector *selector;
 
-    Data_Get_Struct(self, struct NIO_Selector, selector);
-    if(selector->closed) {
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
+    if (selector->closed) {
         rb_raise(rb_eIOError, "selector is closed");
     }
 
@@ -264,29 +300,33 @@ static VALUE NIO_Selector_backend(VALUE self) {
             return ID2SYM(rb_intern("select"));
         case EVBACKEND_PORT:
             return ID2SYM(rb_intern("port"));
+        case EVBACKEND_LINUXAIO:
+            return ID2SYM(rb_intern("linuxaio"));
+        case EVBACKEND_IOURING:
+            return ID2SYM(rb_intern("io_uring"));
     }
 
     return ID2SYM(rb_intern("unknown"));
 }
 
 /* Synchronize around a reentrant selector lock */
-static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VALUE *args)
+static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE arg), VALUE arg)
 {
     VALUE current_thread, lock_holder, lock;
 
     current_thread = rb_thread_current();
     lock_holder = rb_ivar_get(self, rb_intern("lock_holder"));
 
-    if(lock_holder != current_thread) {
+    if (lock_holder != current_thread) {
         lock = rb_ivar_get(self, rb_intern("lock"));
         rb_funcall(lock, rb_intern("lock"), 0);
         rb_ivar_set(self, rb_intern("lock_holder"), current_thread);
 
         /* We've acquired the lock, so ensure we unlock it */
-        return rb_ensure(func, (VALUE)args, NIO_Selector_unlock, self);
+        return rb_ensure(func, (VALUE)arg, NIO_Selector_unlock, self);
     } else {
         /* We already hold the selector lock, so no need to unlock it */
-        return func(args);
+        return func(arg);
     }
 }
 
@@ -307,29 +347,30 @@ static VALUE NIO_Selector_unlock(VALUE self)
 static VALUE NIO_Selector_register(VALUE self, VALUE io, VALUE interests)
 {
     VALUE args[3] = {self, io, interests};
-    return NIO_Selector_synchronize(self, NIO_Selector_register_synchronized, args);
+    return NIO_Selector_synchronize(self, NIO_Selector_register_synchronized, (VALUE)args);
 }
 
 /* Internal implementation of register after acquiring mutex */
-static VALUE NIO_Selector_register_synchronized(VALUE *args)
+static VALUE NIO_Selector_register_synchronized(VALUE _args)
 {
     VALUE self, io, interests, selectables, monitor;
     VALUE monitor_args[3];
     struct NIO_Selector *selector;
 
+    VALUE *args = (VALUE *)_args;
     self = args[0];
     io = args[1];
     interests = args[2];
 
-    Data_Get_Struct(self, struct NIO_Selector, selector);
-    if(selector->closed) {
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
+    if (selector->closed) {
         rb_raise(rb_eIOError, "selector is closed");
     }
 
     selectables = rb_ivar_get(self, rb_intern("selectables"));
     monitor = rb_hash_lookup(selectables, io);
 
-    if(monitor != Qnil)
+    if (monitor != Qnil)
         rb_raise(rb_eArgError, "this IO is already registered with selector");
 
     /* Create a new NIO::Monitor */
@@ -347,21 +388,22 @@ static VALUE NIO_Selector_register_synchronized(VALUE *args)
 static VALUE NIO_Selector_deregister(VALUE self, VALUE io)
 {
     VALUE args[2] = {self, io};
-    return NIO_Selector_synchronize(self, NIO_Selector_deregister_synchronized, args);
+    return NIO_Selector_synchronize(self, NIO_Selector_deregister_synchronized, (VALUE)args);
 }
 
 /* Internal implementation of register after acquiring mutex */
-static VALUE NIO_Selector_deregister_synchronized(VALUE *args)
+static VALUE NIO_Selector_deregister_synchronized(VALUE _args)
 {
     VALUE self, io, selectables, monitor;
 
+    VALUE *args = (VALUE *)_args;
     self = args[0];
     io = args[1];
 
     selectables = rb_ivar_get(self, rb_intern("selectables"));
     monitor = rb_hash_delete(selectables, io);
 
-    if(monitor != Qnil) {
+    if (monitor != Qnil) {
         rb_funcall(monitor, rb_intern("close"), 1, Qfalse);
     }
 
@@ -381,53 +423,52 @@ static VALUE NIO_Selector_is_registered(VALUE self, VALUE io)
 static VALUE NIO_Selector_select(int argc, VALUE *argv, VALUE self)
 {
     VALUE timeout;
-    VALUE args[2];
 
     rb_scan_args(argc, argv, "01", &timeout);
 
-    if(timeout != Qnil && NUM2DBL(timeout) < 0) {
+    if (timeout != Qnil && NUM2DBL(timeout) < 0) {
         rb_raise(rb_eArgError, "time interval must be positive");
     }
 
-    args[0] = self;
-    args[1] = timeout;
-
-    return NIO_Selector_synchronize(self, NIO_Selector_select_synchronized, args);
+    VALUE args[2] = {self, timeout};
+    return NIO_Selector_synchronize(self, NIO_Selector_select_synchronized, (VALUE)args);
 }
 
 /* Internal implementation of select with the selector lock held */
-static VALUE NIO_Selector_select_synchronized(VALUE *args)
+static VALUE NIO_Selector_select_synchronized(VALUE _args)
 {
     int ready;
     VALUE ready_array;
     struct NIO_Selector *selector;
 
-    Data_Get_Struct(args[0], struct NIO_Selector, selector);
+    VALUE *args = (VALUE *)_args;
+
+    TypedData_Get_Struct(args[0], struct NIO_Selector, &NIO_Selector_type, selector);
 
-    if(selector->closed) {
+    if (selector->closed) {
         rb_raise(rb_eIOError, "selector is closed");
     }
 
-    if(!rb_block_given_p()) {
-        selector->ready_array = rb_ary_new();
+    if (!rb_block_given_p()) {
+        RB_OBJ_WRITE(args[0], &selector->ready_array, rb_ary_new());
     }
 
     ready = NIO_Selector_run(selector, args[1]);
 
     /* Timeout */
-    if(ready < 0) {
-        if(!rb_block_given_p()) {
-            selector->ready_array = Qnil;
+    if (ready < 0) {
+        if (!rb_block_given_p()) {
+            RB_OBJ_WRITE(args[0], &selector->ready_array, Qnil);
         }
 
         return Qnil;
     }
 
-    if(rb_block_given_p()) {
+    if (rb_block_given_p()) {
         return INT2NUM(ready);
     } else {
         ready_array = selector->ready_array;
-        selector->ready_array = Qnil;
+        RB_OBJ_WRITE(args[0], &selector->ready_array, Qnil);
         return ready_array;
     }
 }
@@ -441,12 +482,12 @@ static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout)
     selector->selecting = 1;
     selector->wakeup_fired = 0;
 
-    if(timeout == Qnil) {
+    if (timeout == Qnil) {
         /* Don't fire a wakeup timeout if we weren't passed one */
         ev_timer_stop(selector->ev_loop, &selector->timer);
     } else {
         timeout_val = NUM2DBL(timeout);
-        if(timeout_val == 0) {
+        if (timeout_val == 0) {
             /* If we've been given an explicit timeout of 0, perform a non-blocking
                select operation */
             ev_run_flags = EVRUN_NOWAIT;
@@ -462,7 +503,7 @@ static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout)
     result = selector->ready_count;
     selector->selecting = selector->ready_count = 0;
 
-    if(result > 0 || selector->wakeup_fired) {
+    if (result > 0 || selector->wakeup_fired) {
         selector->wakeup_fired = 0;
         return result;
     } else {
@@ -474,9 +515,9 @@ static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout)
 static VALUE NIO_Selector_wakeup(VALUE self)
 {
     struct NIO_Selector *selector;
-    Data_Get_Struct(self, struct NIO_Selector, selector);
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
 
-    if(selector->closed) {
+    if (selector->closed) {
         rb_raise(rb_eIOError, "selector is closed");
     }
 
@@ -489,15 +530,14 @@ static VALUE NIO_Selector_wakeup(VALUE self)
 /* Close the selector and free system resources */
 static VALUE NIO_Selector_close(VALUE self)
 {
-    VALUE args[1] = {self};
-    return NIO_Selector_synchronize(self, NIO_Selector_close_synchronized, args);
+    return NIO_Selector_synchronize(self, NIO_Selector_close_synchronized, self);
 }
 
-static VALUE NIO_Selector_close_synchronized(VALUE *args)
+static VALUE NIO_Selector_close_synchronized(VALUE self)
 {
     struct NIO_Selector *selector;
-    VALUE self = args[0];
-    Data_Get_Struct(self, struct NIO_Selector, selector);
+
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
 
     NIO_Selector_shutdown(selector);
 
@@ -507,15 +547,14 @@ static VALUE NIO_Selector_close_synchronized(VALUE *args)
 /* Is the selector closed? */
 static VALUE NIO_Selector_closed(VALUE self)
 {
-    VALUE args[1] = {self};
-    return NIO_Selector_synchronize(self, NIO_Selector_closed_synchronized, args);
+    return NIO_Selector_synchronize(self, NIO_Selector_closed_synchronized, self);
 }
 
-static VALUE NIO_Selector_closed_synchronized(VALUE *args)
+static VALUE NIO_Selector_closed_synchronized(VALUE self)
 {
     struct NIO_Selector *selector;
-    VALUE self = args[0];
-    Data_Get_Struct(self, struct NIO_Selector, selector);
+
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
 
     return selector->closed ? Qtrue : Qfalse;
 }
@@ -528,7 +567,6 @@ static VALUE NIO_Selector_is_empty(VALUE self)
     return rb_funcall(selectables, rb_intern("empty?"), 0) == Qtrue ? Qtrue : Qfalse;
 }
 
-
 /* Called whenever a timeout fires on the event loop */
 static void NIO_Selector_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
 {
@@ -542,7 +580,8 @@ static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_io *
     selector->selecting = 0;
 
     /* Drain the wakeup pipe, giving us level-triggered behavior */
-    while(read(selector->wakeup_reader, buffer, 128) > 0);
+    while (read(selector->wakeup_reader, buffer, 128) > 0)
+        ;
 }
 
 /* libev callback fired whenever a monitor gets an event */
@@ -558,7 +597,7 @@ void NIO_Selector_monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, in
     selector->ready_count++;
     monitor_data->revents = revents;
 
-    if(rb_block_given_p()) {
+    if (rb_block_given_p()) {
         rb_yield(monitor);
     } else {
         assert(selector->ready_array != Qnil);

data/lib/nio/bytebuffer.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
+# Released under the MIT License.
+# Copyright, 2016, by Upekshe Jayasekera.
+# Copyright, 2016-2017, by Tony Arcieri.
+# Copyright, 2020, by Thomas Dziedzic.
+# Copyright, 2023, by Samuel Williams.
+
 module NIO
   # Efficient byte buffers for performant I/O operations
   class ByteBuffer
@@ -24,6 +30,7 @@ module NIO
     # @return [NIO::ByteBuffer]
     def initialize(capacity)
       raise TypeError, "no implicit conversion of #{capacity.class} to Integer" unless capacity.is_a?(Integer)
+
       @capacity = capacity
       clear
     end
@@ -119,9 +126,11 @@ module NIO
     # @return [self]
     def put(str)
       raise TypeError, "expected String, got #{str.class}" unless str.respond_to?(:to_str)
+
       str = str.to_str
 
       raise OverflowError, "buffer is full" if str.length > @limit - @position
+
       @buffer[@position...str.length] = str
       @position += str.length
       self
@@ -188,6 +197,7 @@ module NIO
     # @raise [NIO::ByteBuffer::MarkUnsetError] mark has not been set (call `#mark` first)
     def reset
       raise MarkUnsetError, "mark has not been set" unless @mark
+
       @position = @mark
       self
     end

data/lib/nio/monitor.rb

@@ -1,5 +1,12 @@
 # frozen_string_literal: true
 
+# Released under the MIT License.
+# Copyright, 2011-2018, by Tony Arcieri.
+# Copyright, 2015, by Upekshe Jayasekera.
+# Copyright, 2015, by Vladimir Kochnev.
+# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2019-2020, by Gregory Longtin.
+
 module NIO
   # Monitors watch IO objects for specific events
   class Monitor
@@ -8,7 +15,7 @@ module NIO
 
     # :nodoc:
     def initialize(io, interests, selector)
-      unless io.is_a? OpenSSL::SSL::SSLSocket
+      unless defined?(::OpenSSL) && io.is_a?(::OpenSSL::SSL::SSLSocket)
         unless io.is_a?(IO)
           if IO.respond_to? :try_convert
             io = IO.try_convert(io)

data/lib/nio/selector.rb

@@ -1,5 +1,20 @@
 # frozen_string_literal: true
 
+# Released under the MIT License.
+# Copyright, 2011-2017, by Tony Arcieri.
+# Copyright, 2012, by Logan Bowers.
+# Copyright, 2013, by Sadayuki Furuhashi.
+# Copyright, 2013, by Stephen von Takach.
+# Copyright, 2013, by Tim Carey-Smith.
+# Copyright, 2013, by Ravil Bayramgalin.
+# Copyright, 2014, by Sergey Avseyev.
+# Copyright, 2014, by John Thornton.
+# Copyright, 2015, by Vladimir Kochnev.
+# Copyright, 2015, by Upekshe Jayasekera.
+# Copyright, 2019-2020, by Gregory Longtin.
+# Copyright, 2020-2021, by Joao Fernandes.
+# Copyright, 2023, by Samuel Williams.
+
 require "set"
 
 module NIO
@@ -14,7 +29,7 @@ module NIO
 
     # Create a new NIO::Selector
     def initialize(backend = :ruby)
-      raise ArgumentError, "unsupported backend: #{backend}" unless backend == :ruby
+      raise ArgumentError, "unsupported backend: #{backend}" unless [:ruby, nil].include?(backend)
 
       @selectables = {}
       @lock = Mutex.new
@@ -26,14 +41,16 @@ module NIO
 
     # Return a symbol representing the backend I/O multiplexing mechanism used.
     # Supported backends are:
-    # * :ruby    - pure Ruby (i.e IO.select)
-    # * :java    - Java NIO on JRuby
-    # * :epoll   - libev w\ Linux epoll
-    # * :poll    - libev w\ POSIX poll
-    # * :kqueue  - libev w\ BSD kqueue
-    # * :select  - libev w\ SysV select
-    # * :port    - libev w\ I/O completion ports
-    # * :unknown - libev w\ unknown backend
+    # * :ruby     - pure Ruby (i.e IO.select)
+    # * :java     - Java NIO on JRuby
+    # * :epoll    - libev w\ Linux epoll
+    # * :poll     - libev w\ POSIX poll
+    # * :kqueue   - libev w\ BSD kqueue
+    # * :select   - libev w\ SysV select
+    # * :port     - libev w\ I/O completion ports
+    # * :linuxaio - libev w\ Linux AIO io_submit (experimental)
+    # * :io_uring - libev w\ Linux io_uring (experimental)
+    # * :unknown  - libev w\ unknown backend
     def backend
       :ruby
     end
@@ -44,7 +61,7 @@ module NIO
     # * :w - is the IO writeable?
     # * :rw - is the IO either readable or writeable?
     def register(io, interest)
-      unless io.is_a? OpenSSL::SSL::SSLSocket
+      unless defined?(::OpenSSL) && io.is_a?(::OpenSSL::SSL::SSLSocket)
         io = IO.try_convert(io)
       end
 

data/lib/nio/version.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+# Released under the MIT License.
+# Copyright, 2011-2018, by Tony Arcieri.
+# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2023, by Tsimnuj Hawj.
+
 module NIO
-  VERSION = "2.5.2"
+  VERSION = "2.7.0"
 end