proc-wait3 1.9.1 → 1.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2054430d4049b9aa27f1902f704220818bf4e6b8d7d19e428e10e3ed736d6c9
-  data.tar.gz: 9be23be7ddad009649f5ec83692102b05334a9013d99a68f1643c1c2eda37b62
+  metadata.gz: a6e56b25dc085ce18c5808a81d259c4e9f54cb75d1ff985985bb5a575d58ed90
+  data.tar.gz: 65379d28529797369401cc65abb6c234b9cf1995ec7cf92152d03c03c6a89a83
 SHA512:
-  metadata.gz: a6f95da3b81622fd0a4ca7be57f787ec63201be854f28bcb023aec9af3360ef8ec6af228ca3c180dfa7163831456aa57fd68ced837cb40d46f3b262e2a2b4554
-  data.tar.gz: fff3abd919e4c0f07ab666ea3f3a1db8d514fa63802fd408b57c87f0c8208d6cf4e886813605156625bc00e8b931405098e5a714d34a91a00830287974603507
+  metadata.gz: 51f2d1148e8fcadb8b9530420ac164e81b4645b04e3f7b8acded43a62acaa3000240f5e5e53b5fda4cc734f0e2f76edbf76d5b325c2cc3fefd450cf0f60ca519
+  data.tar.gz: ce1e71899e8db9c2c74bb5207d3a715e7cf8b355d0c5b6bc203b51608647d90fe53c0414bce48ee38c1c796987df7f9fa2b4a30c9eeebdd35900e34d288be82a

data/CHANGES.md

@@ -1,3 +1,9 @@
+## 1.9.2 - 21-Apr-2024
+* Added the P_JAILID constant for BSD platforms.
+* Added some notes to the README for coping with EINTR.
+* Added rubocop and rubocop-rspec as dev dependencies and did
+  some general rubocop cleanup.
+
 ## 1.9.1 - 8-Feb-2024
 * Replace sigset with sigaction in the pause method.
 * General cleanup and platform handling updates.

data/README.md

@@ -38,6 +38,38 @@ These methods may fail in conjunction with `fork` with `Errno::EINTR` unless
 you pass the WNOHANG flag, or explicitly ignore the `SIGCHLD` signal. Ruby's
 own `wait` methods appear to essentially be doing that behind the scenes.
 
+Note that on some platforms just setting a `SIGCHLD` handler may not be
+enough to prevent an `Errno::EINTR` from occuring since you can never be sure
+what signal it's going to receive. Since this appears to be coming from the
+guts of the Ruby core code itself IMO, it's somewhat out of my hands, but it's
+not impossible to deal with.
+
+A typical idiom would be to simulate the `TEMP_FAILURE_RETRY` macro that the GNU
+library provides. This macro wraps a given function and retries it so long as
+it doesn't fail, or the only failure is an `EINTR`. I've chosen not to integrate
+this into the code directly (yet), but you can simulate it like so:
+
+```ruby
+require 'English'
+
+begin
+  pid = fork{ sleep 1; exit 2 }
+  Process.wait3
+rescue Errno::EINTR
+  retry
+end
+
+p $CHILD_STATUS
+```
+
+For more information please see:
+
+https://www.gnu.org/savannah-checkouts/gnu/libc/manual/html_node/Interrupted-Primitives.html
+
+BSD provides another approach using sigaction handlers + `SA_RESTART`, but it requires knowing
+the signal type in advance. So, unless you want to apply the same handler to *every* type of
+signal, I don't find it especially useful.
+
 ## Integration with Ruby's process.c
 I considered simply providing a patch to the core process.c file, but I
 decided against it for two reasons.  First, I wanted to get something

data/Rakefile

@@ -1,6 +1,7 @@
 require 'rake'
 require 'rake/clean'
 require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 require 'fileutils'
 require 'rbconfig'
 include RbConfig
@@ -27,7 +28,7 @@ task :build => [:clean] do |t|
 end
 
 namespace :gem do
-  desc "Create the proc-wait3 gem"
+  desc 'Create the proc-wait3 gem'
   task :create => [:clean] do
     require 'rubygems/package'
     spec = Gem::Specification.load('proc-wait3.gemspec')
@@ -35,7 +36,7 @@ namespace :gem do
     Gem::Package.build(spec)
   end
 
-  desc "Install the proc-wait3 gem"
+  desc 'Install the proc-wait3 gem'
   task :install => [:create] do |t|
     file = Dir['*.gem'].first
     sh "gem install -l #{file}"
@@ -69,9 +70,11 @@ namespace :example do
   end
 end
 
-desc "Run the test suite"
+desc 'Run the test suite'
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.rspec_opts = '-Iext'
 end
 
 task :default => [:build, :spec]
+
+RuboCop::RakeTask.new

data/examples/example_getrusage.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ########################################################################
 # example_getrusage.rb
 #
@@ -11,7 +13,7 @@ require 'pp'
 
 # Show resource stats for this process for 30 seconds
 10.times do
-   pp Process.getrusage
-   puts "=" * 50
-   sleep 3 
+  pp Process.getrusage
+  puts '=' * 50
+  sleep 3
 end

data/examples/example_pause.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #######################################################################
 # example_pause.rb
 #
@@ -9,13 +11,13 @@
 require 'rbconfig'
 require 'proc/wait3'
 
-puts "Pausing.  Hit Ctrl-C to continue."
+puts 'Pausing.  Hit Ctrl-C to continue.'
 
 if RbConfig::CONFIG['host_os'] =~ /linux|darwin/i
-   Process.pause(2)
+  Process.pause(2)
 else
-   Process.pause("INT")
+  Process.pause('INT')
 end
 
-puts "Hey, thanks for hitting Ctrl-C.  Continuing..."
-puts "Done"
+puts 'Hey, thanks for hitting Ctrl-C.  Continuing...'
+puts 'Done'

data/examples/example_wait3.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #######################################################################
 # example_wait3.rb
 #
@@ -6,10 +8,11 @@
 #
 # Modify as you see fit.
 #######################################################################
+require 'English'
 require 'proc/wait3'
 
-pid = fork{ sleep 1; exit 2 }
+pid = fork { sleep 1; exit 2 }
 
 p Time.now
 Process.wait3
-p $?
+p $CHILD_STATUS

data/examples/example_wait4.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #######################################################################
 # example_wait4.rb
 #
@@ -6,9 +8,10 @@
 #
 # Modify as you see fit.
 #######################################################################
+require 'English'
 require 'proc/wait3'
 
-pid = fork{ sleep 2 }
+pid = fork { sleep 2 }
 p Time.now
 Process.wait4(pid, Process::WUNTRACED)
-p $?
+p $CHILD_STATUS

data/examples/example_waitid.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #######################################################################
 # example_waitid.rb
 #
@@ -6,9 +8,10 @@
 #
 # Modify as you see fit.
 #######################################################################
+require 'English'
 require 'proc/wait3'
 
-pid = fork{ sleep 2 }
+pid = fork { sleep 2 }
 p Time.now
 Process.waitid(Process::P_PID, pid, Process::WEXITED)
-p $?
+p $CHILD_STATUS

data/ext/extconf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ########################################################
 # Use the mkmf.rb file that I provide, so I can use the
 # have_enum_member method
@@ -12,7 +14,7 @@ have_header('sys/wait.h')
 
 # wait3 is mandatory.
 unless have_func('wait3')
-  STDERR.puts 'wait3() function not found'
+  warn 'wait3() function not found'
   exit
 end
 
@@ -68,4 +70,7 @@ have_const('P_TASKID', 'signal.h')
 # RUSAGE_THREAD is Linux-specific
 have_const('RUSAGE_THREAD', 'sys/resource.h')
 
+# BSD
+have_const('P_JAILID', 'sys/wait.h')
+
 create_makefile('proc/wait3', 'proc')

data/ext/proc/wait3.c

@@ -957,12 +957,17 @@ void Init_wait3(void)
   rb_define_const(rb_mProcess, "P_PROJID", INT2FIX(P_PROJID));
 #endif
 
+#ifdef HAVE_CONST_P_JAILID
+  /* Process jail ID */
+  rb_define_const(rb_mProcess, "P_JAILID", INT2FIX(P_JAILID));
+#endif
+
 #ifdef HAVE_CONST_RUSAGE_THREAD
   rb_define_const(rb_mProcess, "RUSAGE_THREAD", INT2FIX(RUSAGE_THREAD));
 #endif
 
-  /* 1.9.0: The version of the proc-wait3 library */
-  rb_define_const(rb_mProcess, "WAIT3_VERSION", rb_str_freeze(rb_str_new2("1.9.1")));
+  /* 1.9.2: The version of the proc-wait3 library */
+  rb_define_const(rb_mProcess, "WAIT3_VERSION", rb_str_freeze(rb_str_new2("1.9.2")));
 
   /* Define this last in our Init_wait3 function */
   rb_define_readonly_variable("$last_status", &v_last_status);

data/lib/proc-wait3.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'proc/wait3'

data/proc-wait3.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'proc-wait3'
-  spec.version    = '1.9.1'
+  spec.version    = '1.9.2'
   spec.author     = 'Daniel J. Berger'
   spec.license    = 'Apache-2.0'
   spec.email      = 'djberg96@gmail.com'
@@ -10,11 +10,13 @@ Gem::Specification.new do |spec|
   spec.summary    = 'Adds wait3, wait4 and other methods to the Process module'
   spec.test_file  = 'spec/proc_wait3_spec.rb'
   spec.extensions = ['ext/extconf.rb']
-  spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
+  spec.files      = Dir['**/*'].reject { |f| f.include?('git') }
   spec.cert_chain = Dir['certs/*']
 
   spec.add_development_dependency('rake')
   spec.add_development_dependency('rspec', '~> 3.9')
+  spec.add_development_dependency('rubocop')
+  spec.add_development_dependency('rubocop-rspec')
 
   spec.metadata = {
     'homepage_uri'          => 'https://github.com/djberg96/proc-wait3',
@@ -23,7 +25,8 @@ Gem::Specification.new do |spec|
     'documentation_uri'     => 'https://github.com/djberg96/proc-wait3/wiki',
     'source_code_uri'       => 'https://github.com/djberg96/proc-wait3',
     'wiki_uri'              => 'https://github.com/djberg96/proc-wait3/wiki',
-    'rubygems_mfa_required' => 'true'
+    'rubygems_mfa_required' => 'true',
+    'github_repo'           => 'https://github.com/djberg96/proc-wait3'
   }
 
   spec.description = <<-EOF

data/spec/proc_wait3_spec.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 #######################################################################
 # proc_wait3_spec.rb
 #
 # Test suite for the Ruby proc-wait3 library. You should run these
 # via the 'rake spec' task.
 #######################################################################
+require 'English'
 require 'proc/wait3'
 require 'rspec'
 require 'rbconfig'
@@ -31,178 +34,178 @@ RSpec.describe Process do
     @pid = nil
   end
 
-  example "version constant is set to expected value" do
-    expect(Process::WAIT3_VERSION).to eq('1.9.1')
+  example 'version constant is set to expected value' do
+    expect(Process::WAIT3_VERSION).to eq('1.9.2')
     expect(Process::WAIT3_VERSION).to be_frozen
   end
 
-  example "wait3 method is defined" do
-    expect(Process).to respond_to(:wait3)
+  example 'wait3 method is defined' do
+    expect(described_class).to respond_to(:wait3)
   end
 
-  example "wait3 works as expected" do
+  example 'wait3 works as expected' do
     skip 'wait3 test skipped on this platform' if darwin
-    @pid = fork{ sleep 0.5 }
-    expect{ Process.wait3 }.not_to raise_error
+    @pid = fork { sleep 0.5 }
+    expect { described_class.wait3 }.not_to raise_error
   end
 
-  example "wait3 returns the expected proc status members" do
+  example 'wait3 returns the expected proc status members' do
     skip 'wait3 test skipped on this platform' if darwin
-    @pid = fork{ sleep 0.5 }
-    expect{ @proc_stat = Process.wait3 }.not_to raise_error
-    expect( @proc_stat.members).to eq(proc_stat_members)
+    @pid = fork { sleep 0.5 }
+    expect { @proc_stat = described_class.wait3 }.not_to raise_error
+    expect(@proc_stat.members).to eq(proc_stat_members)
   end
 
-  example "wait3 with WNOHANG works as expected" do
-    @pid = fork{ sleep 0.5 }
-    expect{ Process.wait3(Process::WNOHANG) }.not_to raise_error
+  example 'wait3 with WNOHANG works as expected' do
+    @pid = fork { sleep 0.5 }
+    expect { described_class.wait3(Process::WNOHANG) }.not_to raise_error
   end
 
-  example "wait3 sets and returns $last_status to expected values" do
+  example 'wait3 sets and returns $last_status to expected values' do
     skip 'wait3 test skipped on this platform' if darwin
-    @pid = fork{ sleep 0.5 }
-    Process.wait3
-    expect($last_status).to be_kind_of(Struct::ProcStat)
+    @pid = fork { sleep 0.5 }
+    described_class.wait3
+    expect($last_status).to be_a(Struct::ProcStat)
     expect($last_status).not_to be_nil
   end
 
-  example "wait3 sets pid and status members of $?" do
+  example 'wait3 sets pid and status members of $?' do
     skip 'wait3 test skipped on this platform' if darwin
-    @pid = fork{ sleep 0.5 }
-    Process.wait3
-    expect($?).not_to be_nil
+    @pid = fork { sleep 0.5 }
+    described_class.wait3
+    expect($CHILD_STATUS).not_to be_nil
   end
 
-  example "wait3 returns frozen struct" do
+  example 'wait3 returns frozen struct' do
     skip 'wait3 test skipped on this platform' if darwin
-    @pid = fork{ sleep 0.5 }
-    struct = Process.wait3
+    @pid = fork { sleep 0.5 }
+    struct = described_class.wait3
     expect(struct).to be_frozen
   end
 
-  example "getdtablesize works as expected" do
+  example 'getdtablesize works as expected' do
     skip 'getdtablesize skipped on this platform' unless solaris
 
-    expect(Process).to respond_to(:getdtablesize)
-    expect(Process.getdtablesize).to be_kind_of(Fixnum)
-    assert(Process.getdtablesize > 0)
+    expect(described_class).to respond_to(:getdtablesize)
+    expect(described_class.getdtablesize).to be_a(Integer)
+    assert(described_class.getdtablesize > 0)
   end
 
-  example "wait4 method is defined" do
+  example 'wait4 method is defined' do
     skip 'wait4 test skipped on this platform' if hpux
-    expect(Process).to respond_to(:wait4)
+    expect(described_class).to respond_to(:wait4)
   end
 
-  example "wait4 requires at least one argument" do
+  example 'wait4 requires at least one argument' do
     skip 'wait4 test skipped on this platform' if hpux
-    expect{ Process.wait4 }.to raise_error(ArgumentError)
+    expect { described_class.wait4 }.to raise_error(ArgumentError)
   end
 
-  example "wait4 works as expected" do
+  example 'wait4 works as expected' do
     skip 'wait4 test skipped on this platform' if hpux || darwin
 
-    @pid = fork{ sleep 0.5 }
-    expect{ @proc_stat = Process.wait4(@pid) }.not_to raise_error
-    expect(@proc_stat).to be_kind_of(Struct::ProcStat)
+    @pid = fork { sleep 0.5 }
+    expect { @proc_stat = described_class.wait4(@pid) }.not_to raise_error
+    expect(@proc_stat).to be_a(Struct::ProcStat)
   end
 
-  example "wait4 sets and returns $last_status to expected values" do
+  example 'wait4 sets and returns $last_status to expected values' do
     skip 'wait4 test skipped on this platform' if hpux || darwin
 
-    @pid = fork{ sleep 0.5 }
-    Process.wait4(@pid)
-    expect($last_status).to be_kind_of(Struct::ProcStat)
+    @pid = fork { sleep 0.5 }
+    described_class.wait4(@pid)
+    expect($last_status).to be_a(Struct::ProcStat)
     expect($last_status).not_to be_nil
   end
 
-  example "wait4 sets pid and status members of $?" do
+  example 'wait4 sets pid and status members of $?' do
     skip 'wait4 test skipped on this platform' if hpux || darwin
 
-    @pid = fork{ sleep 0.5 }
-    Process.wait4(@pid)
-    expect($?).not_to be_nil
+    @pid = fork { sleep 0.5 }
+    described_class.wait4(@pid)
+    expect($CHILD_STATUS).not_to be_nil
   end
 
-  example "wait4 returns frozen struct" do
+  example 'wait4 returns frozen struct' do
     skip 'wait4 test skipped on this platform' if hpux || darwin
 
-    @pid = fork{ sleep 0.5 }
-    struct = Process.wait4(@pid)
+    @pid = fork { sleep 0.5 }
+    struct = described_class.wait4(@pid)
     expect(struct).to be_frozen
   end
 
-  example "waitid method is defined" do
+  example 'waitid method is defined' do
     skip 'waitid test skipped on this platform' if hpux || darwin || bsd
 
-    expect(Process).to respond_to(:waitid)
+    expect(described_class).to respond_to(:waitid)
   end
 
-  example "waitid method works as expected" do
+  example 'waitid method works as expected' do
     skip 'waitid test skipped on this platform' if hpux || darwin || bsd
 
-    @pid = fork{ sleep 0.5 }
-    expect{ Process.waitid(Process::P_PID, @pid, Process::WEXITED) }.not_to raise_error
+    @pid = fork { sleep 0.5 }
+    expect { described_class.waitid(Process::P_PID, @pid, Process::WEXITED) }.not_to raise_error
   end
 
-  example "waitid method raises expected errors if wrong argument type is passed" do
+  example 'waitid method raises expected errors if wrong argument type is passed' do
     skip 'waitid test skipped on this platform' if hpux || darwin || bsd
 
-    @pid = fork{ sleep 0.5 }
-    expect{ Process.waitid("foo", @pid, Process::WEXITED) }.to raise_error(TypeError)
-    expect{ Process.waitid(Process::P_PID, @pid, "foo") }.to raise_error(TypeError)
-    expect{ Process.waitid(Process::P_PID, "foo", Process::WEXITED) }.to raise_error(TypeError)
+    @pid = fork { sleep 0.5 }
+    expect { described_class.waitid('foo', @pid, Process::WEXITED) }.to raise_error(TypeError)
+    expect { described_class.waitid(Process::P_PID, @pid, 'foo') }.to raise_error(TypeError)
+    expect { described_class.waitid(Process::P_PID, 'foo', Process::WEXITED) }.to raise_error(TypeError)
   end
 
-  example "waitid method raises expected error if invalid argument is passed" do
+  example 'waitid method raises expected error if invalid argument is passed' do
     skip 'waitid test skipped on this platform' if hpux || darwin || bsd
 
-    @pid = fork{ sleep 0.5 }
-    expect{ Process.waitid(Process::P_PID, 99999999, Process::WEXITED) }.to raise_error(Errno::ECHILD)
+    @pid = fork { sleep 0.5 }
+    expect { described_class.waitid(Process::P_PID, 99999999, Process::WEXITED) }.to raise_error(Errno::ECHILD)
   end
 
-  example "sigsend method is defined" do
+  example 'sigsend method is defined' do
     skip 'sigsend test skipped on this platform' unless solaris
 
-    expect(Process).to respond_to(:sigsend)
+    expect(described_class).to respond_to(:sigsend)
   end
 
-  example "sigsend works as expected" do
+  example 'sigsend works as expected' do
     skip 'sigsend test skipped on this platform' unless solaris
 
-    @pid = fork{ sleep 0.5 }
-    expect{ Process.sigsend(Process::P_PID, @pid, 0) }.not_to raise_error
+    @pid = fork { sleep 0.5 }
+    expect { described_class.sigsend(Process::P_PID, @pid, 0) }.not_to raise_error
   end
 
-  example "getrusage method is defined" do
-    expect(Process).to respond_to(:getrusage)
+  example 'getrusage method is defined' do
+    expect(described_class).to respond_to(:getrusage)
   end
 
-  example "getrusage works as expected" do
-    @pid = fork{ sleep 0.5 }
+  example 'getrusage works as expected' do
+    @pid = fork { sleep 0.5 }
 
-    expect{ Process.getrusage }.not_to raise_error
-    expect{ Process.getrusage(true) }.not_to raise_error
+    expect { described_class.getrusage }.not_to raise_error
+    expect { described_class.getrusage(true) }.not_to raise_error
   end
 
-  example "getrusage can get thread info on Linux" do
+  example 'getrusage can get thread info on Linux' do
     skip 'getrusage only tested on Linux' unless linux
-    expect{ Process.getrusage(Process::RUSAGE_THREAD) }.not_to raise_error
+    expect { described_class.getrusage(Process::RUSAGE_THREAD) }.not_to raise_error
   end
 
-  example "getrusage returns the expected struct" do
+  example 'getrusage returns the expected struct' do
     skip 'getrusage only tested on Linux' unless linux
 
-    @pid = fork{ sleep 0.5 }
-    expect(Process.getrusage).to be_kind_of(Struct::RUsage)
-    expect(Process.getrusage.stime).to be_kind_of(Float)
-    expect(Process.getrusage.utime).to be_kind_of(Float)
+    @pid = fork { sleep 0.5 }
+    expect(described_class.getrusage).to be_a(Struct::RUsage)
+    expect(described_class.getrusage.stime).to be_a(Float)
+    expect(described_class.getrusage.utime).to be_a(Float)
   end
 
-  example "pause method is defined" do
-    expect(Process).to respond_to(:pause)
+  example 'pause method is defined' do
+    expect(described_class).to respond_to(:pause)
   end
 
-  example "expected constants are defined" do
+  example 'expected constants are defined' do
     skip 'wait constant check skipped on this platform' if darwin || bsd
 
     expect(Process::WCONTINUED).not_to be_nil
@@ -214,7 +217,7 @@ RSpec.describe Process do
     expect(Process::WTRAPPED).not_to be_nil
   end
 
-  example "expected process type flag constants are defined" do
+  example 'expected process type flag constants are defined' do
     skip 'process type flag check skipped on this platform' if linux || darwin || bsd
 
     expect(Process::P_ALL).not_to be_nil
@@ -229,13 +232,18 @@ RSpec.describe Process do
     expect(Process::P_MYID).not_to be_nil
   end
 
-  example "solaris-specific process type flags are defined on solaris" do
+  example 'solaris-specific process type flags are defined on solaris' do
     skip 'P_TASKID and P_PROJID constant check skipped on this platform' unless solaris
 
     expect(Process::P_TASKID).not_to be_nil
     expect(Process::P_PROJID).not_to be_nil
   end
 
+  example 'bsd-specific process type flags are defined on BSD platforms' do
+    skip 'P_JAILID constant check skipped on this platform' unless bsd
+    expect(Process::P_JAILID).not_to be_nil
+  end
+
   def after
     Process.kill(9, @pid) if @pid
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: proc-wait3
 version: !ruby/object:Gem::Version
-  version: 1.9.1
+  version: 1.9.2
 platform: ruby
 authors:
 - Daniel J. Berger
@@ -35,7 +35,7 @@ cert_chain:
   ORVCZpRuCPpmC8qmqxUnARDArzucjaclkxjLWvCVHeFa9UP7K3Nl9oTjJNv+7/jM
   WZs4eecIcUc4tKdHxcAJ0MO/Dkqq7hGaiHpwKY76wQ1+8xAh
   -----END CERTIFICATE-----
-date: 2024-02-08 00:00:00.000000000 Z
+date: 2024-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -65,6 +65,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |2
       The proc-wait3 library adds the wait3, wait4, waitid, pause, sigsend,
       and getrusage methods to the Process module.
@@ -103,6 +131,7 @@ metadata:
   source_code_uri: https://github.com/djberg96/proc-wait3
   wiki_uri: https://github.com/djberg96/proc-wait3/wiki
   rubygems_mfa_required: 'true'
+  github_repo: https://github.com/djberg96/proc-wait3
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -118,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: Adds wait3, wait4 and other methods to the Process module