io-wait 0.1.0 → 0.2.2.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ea39ff5c3815f098f8c15eb5b493e27408afda30a88d11cd00564ab85438639
-  data.tar.gz: 1a9ba20f028fe3259153bac2aa27b70870ef8e103d00c20cb6f7a267da94a6b5
+  metadata.gz: 3cdf9086254a2bafdcebba616ff05a5b024389e554861fcea442fc27882bd73a
+  data.tar.gz: 51740df7f2f5b67161a3c6e336698de3a345f38ed331e4e701af28f3990875b8
 SHA512:
-  metadata.gz: bebdf7aba83d894c28fa9763b0048047c437c67962a939e3d29a6b4cbefe1ac690afd8ef8ed372d013204b1298f7fab0f01cd45c35ced0bb4d62e4234818f0ae
-  data.tar.gz: 0f9635692758b787c4dc873e449e0a3e893dee5427f122fbda17f9458d4f33916bd32c333bf76023a73285177ac70b4b576025504130423089467fdb703266b5
+  metadata.gz: 55eb2c59c806b21fb6d038c7ccc58ec59f1a7e7a5a4e5bc2991b893b19f2a8265624e666daed915a4b58c0981619bb3459d80aa7856be6a8c9ba1277449f1b83
+  data.tar.gz: ecc6d22a99dbb5ac2c911f187c0253a30c3764e398997cde8d57efd54d278a317cfbc6149ab8d2a1695b71119ab04c0498c122111d37b8eeb544a74372ce3937

data/Gemfile

@@ -1,4 +1,11 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in etc.gemspec
+# Specify your gem's dependencies in io-wait.gemspec
 gemspec
+
+group :development do
+  gem "rake"
+  gem "rake-compiler"
+  gem "test-unit"
+  gem 'ruby-maven', :platforms => :jruby
+end

data/ext/io/wait/depend

@@ -2,7 +2,7 @@
 wait.o: $(RUBY_EXTCONF_H)
 wait.o: $(arch_hdrdir)/ruby/config.h
 wait.o: $(hdrdir)/ruby.h
-wait.o: $(hdrdir)/ruby/assert.h
+# wait.o: $(hdrdir)/ruby/assert.h # not in 2.6
 wait.o: $(hdrdir)/ruby/backward.h
 wait.o: $(hdrdir)/ruby/defines.h
 wait.o: $(hdrdir)/ruby/encoding.h

data/ext/io/wait/extconf.rb

@@ -1,19 +1,24 @@
 # frozen_string_literal: false
 require 'mkmf'
-target = "io/wait"
 
-unless macro_defined?("DOSISH", "#include <ruby.h>")
-  have_header(ioctl_h = "sys/ioctl.h") or ioctl_h = nil
-  fionread = %w[sys/ioctl.h sys/filio.h sys/socket.h].find do |h|
-    have_macro("FIONREAD", [h, ioctl_h].compact)
-  end
-  if fionread
-    $defs << "-DFIONREAD_HEADER=\"<#{fionread}>\""
-    create_makefile(target)
-  end
+if RUBY_VERSION < "2.6"
+  File.write("Makefile", dummy_makefile($srcdir).join(""))
 else
-  if have_func("rb_w32_ioctlsocket", "ruby.h")
-    have_func("rb_w32_is_socket", "ruby.h")
-    create_makefile(target)
+  target = "io/wait"
+  have_func("rb_io_wait")
+  unless macro_defined?("DOSISH", "#include <ruby.h>")
+    have_header(ioctl_h = "sys/ioctl.h") or ioctl_h = nil
+    fionread = %w[sys/ioctl.h sys/filio.h sys/socket.h].find do |h|
+      have_macro("FIONREAD", [h, ioctl_h].compact)
+    end
+    if fionread
+      $defs << "-DFIONREAD_HEADER=\"<#{fionread}>\""
+      create_makefile(target)
+    end
+  else
+    if have_func("rb_w32_ioctlsocket", "ruby.h")
+      have_func("rb_w32_is_socket", "ruby.h")
+      create_makefile(target)
+    end
   end
 end

data/ext/io/wait/wait.c

@@ -1,3 +1,4 @@
+/* -*- c-file-style: "ruby"; indent-tabs-mode: t -*- */
 /**********************************************************************
 
   io/wait.c -
@@ -39,6 +40,7 @@
 #define FIONREAD_POSSIBLE_P(fd) ((void)(fd),Qtrue)
 #endif
 
+#ifndef HAVE_RB_IO_WAIT
 static VALUE io_ready_p _((VALUE io));
 static VALUE io_wait_readable _((int argc, VALUE *argv, VALUE io));
 static VALUE io_wait_writable _((int argc, VALUE *argv, VALUE io));
@@ -67,6 +69,7 @@ wait_for_single_fd(rb_io_t *fptr, int events, struct timeval *tv)
     rb_io_check_closed(fptr);
     return (i & events);
 }
+#endif
 
 /*
  * call-seq:
@@ -74,6 +77,8 @@ wait_for_single_fd(rb_io_t *fptr, int events, struct timeval *tv)
  *
  * Returns number of bytes that can be read without blocking.
  * Returns zero if no information available.
+ *
+ * You must require 'io/wait' to use this method.
  */
 
 static VALUE
@@ -93,77 +98,164 @@ io_nread(VALUE io)
     return INT2FIX(0);
 }
 
+#ifdef HAVE_RB_IO_WAIT
+static VALUE
+io_wait_event(VALUE io, int event, VALUE timeout)
+{
+    VALUE result = rb_io_wait(io, RB_INT2NUM(event), timeout);
+
+    if (!RB_TEST(result)) {
+	return Qnil;
+    }
+
+    int mask = RB_NUM2INT(result);
+
+    if (mask & event) {
+	return io;
+    }
+    else {
+	return Qfalse;
+    }
+}
+#endif
+
 /*
  * call-seq:
- *   io.ready? -> true or false
+ *   io.ready? -> truthy or falsy
  *
- * Returns true if input available without blocking, or false.
+ * Returns a truthy value if input available without blocking, or a
+ * falsy value.
+ *
+ * You must require 'io/wait' to use this method.
  */
 
 static VALUE
 io_ready_p(VALUE io)
 {
     rb_io_t *fptr;
+#ifndef HAVE_RB_IO_WAIT
     struct timeval tv = {0, 0};
+#endif
 
     GetOpenFile(io, fptr);
     rb_io_check_readable(fptr);
     if (rb_io_read_pending(fptr)) return Qtrue;
+
+#ifndef HAVE_RB_IO_WAIT
     if (wait_for_single_fd(fptr, RB_WAITFD_IN, &tv))
 	return Qtrue;
+#else
+    if (RTEST(io_wait_event(io, RUBY_IO_READABLE, RB_INT2NUM(0))))
+	return Qtrue;
+#endif
     return Qfalse;
 }
 
 /*
  * call-seq:
- *   io.wait_readable          -> IO, true or nil
- *   io.wait_readable(timeout) -> IO, true or nil
+ *   io.wait_readable          -> truthy or falsy
+ *   io.wait_readable(timeout) -> truthy or falsy
+ *
+ * Waits until IO is readable and returns a truthy value, or a falsy
+ * value when times out.  Returns a truthy value immediately when
+ * buffered data is available.
  *
- * Waits until IO is readable without blocking and returns +self+, or
- * +nil+ when times out.
- * Returns +true+ immediately when buffered data is available.
+ * You must require 'io/wait' to use this method.
  */
 
 static VALUE
 io_wait_readable(int argc, VALUE *argv, VALUE io)
 {
     rb_io_t *fptr;
+#ifndef HAVE_RB_IO_WAIT
     struct timeval timerec;
     struct timeval *tv;
+#endif
 
     GetOpenFile(io, fptr);
     rb_io_check_readable(fptr);
+
+#ifndef HAVE_RB_IO_WAIT
     tv = get_timeout(argc, argv, &timerec);
+#endif
     if (rb_io_read_pending(fptr)) return Qtrue;
+
+#ifndef HAVE_RB_IO_WAIT
     if (wait_for_single_fd(fptr, RB_WAITFD_IN, tv)) {
 	return io;
     }
     return Qnil;
+#else
+    rb_check_arity(argc, 0, 1);
+    VALUE timeout = (argc == 1 ? argv[0] : Qnil);
+
+    return io_wait_event(io, RUBY_IO_READABLE, timeout);
+#endif
 }
 
 /*
  * call-seq:
- *   io.wait_writable          -> IO
- *   io.wait_writable(timeout) -> IO or nil
+ *   io.wait_writable          -> truthy or falsy
+ *   io.wait_writable(timeout) -> truthy or falsy
+ *
+ * Waits until IO is writable and returns a truthy value or a falsy
+ * value when times out.
  *
- * Waits until IO is writable without blocking and returns +self+ or
- * +nil+ when times out.
+ * You must require 'io/wait' to use this method.
  */
 static VALUE
 io_wait_writable(int argc, VALUE *argv, VALUE io)
 {
     rb_io_t *fptr;
+#ifndef HAVE_RB_IO_WAIT
     struct timeval timerec;
     struct timeval *tv;
+#endif
 
     GetOpenFile(io, fptr);
     rb_io_check_writable(fptr);
+
+#ifndef HAVE_RB_IO_WAIT
     tv = get_timeout(argc, argv, &timerec);
     if (wait_for_single_fd(fptr, RB_WAITFD_OUT, tv)) {
 	return io;
     }
     return Qnil;
+#else
+    rb_check_arity(argc, 0, 1);
+    VALUE timeout = (argc == 1 ? argv[0] : Qnil);
+
+    return io_wait_event(io, RUBY_IO_WRITABLE, timeout);
+#endif
+}
+
+#ifdef HAVE_RB_IO_WAIT
+/*
+ * call-seq:
+ *   io.wait_priority          -> truthy or falsy
+ *   io.wait_priority(timeout) -> truthy or falsy
+ *
+ * Waits until IO is priority and returns a truthy value or a falsy
+ * value when times out.
+ *
+ * You must require 'io/wait' to use this method.
+ */
+static VALUE
+io_wait_priority(int argc, VALUE *argv, VALUE io)
+{
+    rb_io_t *fptr = NULL;
+
+    RB_IO_POINTER(io, fptr);
+    rb_io_check_readable(fptr);
+
+    if (rb_io_read_pending(fptr)) return Qtrue;
+
+    rb_check_arity(argc, 0, 1);
+    VALUE timeout = argc == 1 ? argv[0] : Qnil;
+
+    return io_wait_event(io, RUBY_IO_PRIORITY, timeout);
 }
+#endif
 
 static int
 wait_mode_sym(VALUE mode)
@@ -201,18 +293,27 @@ wait_mode_sym(VALUE mode)
 
 /*
  * call-seq:
- *   io.wait(timeout = nil, mode = :read) -> IO, true or nil
+ *   io.wait(events, timeout) -> truthy or falsy
+ *   io.wait(timeout = nil, mode = :read) -> truthy or falsy.
+ *
+ * Waits until the IO becomes ready for the specified events and returns the
+ * subset of events that become ready, or a falsy value when times out.
+ *
+ * The events can be a bit mask of +IO::READABLE+, +IO::WRITABLE+ or
+ * +IO::PRIORITY+.
+ *
+ * Returns a truthy value immediately when buffered data is available.
  *
- * Waits until IO is readable or writable without blocking and returns
- * +self+, or +nil+ when times out.
- * Returns +true+ immediately when buffered data is available.
  * Optional parameter +mode+ is one of +:read+, +:write+, or
  * +:read_write+.
+ *
+ * You must require 'io/wait' to use this method.
  */
 
 static VALUE
-io_wait_readwrite(int argc, VALUE *argv, VALUE io)
+io_wait(int argc, VALUE *argv, VALUE io)
 {
+#ifndef HAVE_RB_IO_WAIT
     rb_io_t *fptr;
     struct timeval timerec;
     struct timeval *tv = NULL;
@@ -236,6 +337,44 @@ io_wait_readwrite(int argc, VALUE *argv, VALUE io)
     if (wait_for_single_fd(fptr, event, tv))
 	return io;
     return Qnil;
+#else
+    VALUE timeout = Qundef;
+    rb_io_event_t events = 0;
+
+    if (argc != 2 || (RB_SYMBOL_P(argv[0]) || RB_SYMBOL_P(argv[1]))) {
+	for (int i = 0; i < argc; i += 1) {
+	    if (RB_SYMBOL_P(argv[i])) {
+		events |= wait_mode_sym(argv[i]);
+	    }
+	    else if (timeout == Qundef) {
+		rb_time_interval(timeout = argv[i]);
+	    }
+	    else {
+		rb_raise(rb_eArgError, "timeout given more than once");
+	    }
+	}
+	if (timeout == Qundef) timeout = Qnil;
+    }
+    else /* argc == 2 */ {
+	events = RB_NUM2UINT(argv[0]);
+	timeout = argv[1];
+    }
+
+    if (events == 0) {
+	events = RUBY_IO_READABLE;
+    }
+
+    if (events & RUBY_IO_READABLE) {
+	rb_io_t *fptr = NULL;
+	RB_IO_POINTER(io, fptr);
+
+	if (rb_io_read_pending(fptr)) {
+	    return Qtrue;
+	}
+    }
+
+    return io_wait_event(io, events, timeout);
+#endif
 }
 
 /*
@@ -245,9 +384,18 @@ io_wait_readwrite(int argc, VALUE *argv, VALUE io)
 void
 Init_wait(void)
 {
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+    RB_EXT_RACTOR_SAFE(true);
+#endif
+
     rb_define_method(rb_cIO, "nread", io_nread, 0);
     rb_define_method(rb_cIO, "ready?", io_ready_p, 0);
-    rb_define_method(rb_cIO, "wait", io_wait_readwrite, -1);
+
+    rb_define_method(rb_cIO, "wait", io_wait, -1);
+
     rb_define_method(rb_cIO, "wait_readable", io_wait_readable, -1);
     rb_define_method(rb_cIO, "wait_writable", io_wait_writable, -1);
+#ifdef HAVE_RB_IO_WAIT
+    rb_define_method(rb_cIO, "wait_priority", io_wait_priority, -1);
+#endif
 }

metadata

@@ -1,34 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: io-wait
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.2.pre1
 platform: ruby
 authors:
 - Nobu Nakada
+- Charles Oliver Nutter
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-09-18 00:00:00.000000000 Z
+date: 2022-03-10 00:00:00.000000000 Z
 dependencies: []
 description: Waits until IO is readable or writable without blocking.
 email:
 - nobu@ruby-lang.org
+- headius@headius.com
 executables: []
-extensions: []
+extensions:
+- ext/io/wait/extconf.rb
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
 - COPYING
 - Gemfile
 - README.md
-- Rakefile
-- bin/console
-- bin/setup
 - ext/io/wait/depend
 - ext/io/wait/extconf.rb
 - ext/io/wait/wait.c
-- io-wait.gemspec
 homepage: https://github.com/ruby/io-wait
 licenses:
 - Ruby
@@ -44,14 +41,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.2.0.rc.1
+rubygems_version: 3.4.0.dev
 signing_key:
 specification_version: 4
 summary: Waits until IO is readable or writable without blocking.

data/.gitignore

@@ -1,11 +0,0 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-*.bundle
-*.dll
-*.so

data/.travis.yml

@@ -1,6 +0,0 @@
----
-language: ruby
-cache: bundler
-rvm:
-  - 2.8.0
-before_install: gem install bundler -v 2.1.4

data/Rakefile

@@ -1,12 +0,0 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test/lib"
-  t.ruby_opts << "-rhelper"
-  t.test_files = FileList["test/**/test_*.rb"]
-end
-
-require 'rake/extensiontask'
-Rake::ExtensionTask.new("io/wait")
-task :default => :test

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "io/wait"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/io-wait.gemspec

@@ -1,22 +0,0 @@
-Gem::Specification.new do |spec|
-  spec.name          = "io-wait"
-  spec.version       = "0.1.0"
-  spec.authors       = ["Nobu Nakada"]
-  spec.email         = ["nobu@ruby-lang.org"]
-
-  spec.summary       = %q{Waits until IO is readable or writable without blocking.}
-  spec.description   = %q{Waits until IO is readable or writable without blocking.}
-  spec.homepage      = "https://github.com/ruby/io-wait"
-  spec.licenses      = ["Ruby", "BSD-2-Clause"]
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-end