subspawn 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8517f5eae58feb737016bbdadf7a5fc6df22226834e7531e135a13549fbeb6c0
+  data.tar.gz: f57039d8c089adf0859ebea1123c7f216f8955028f2463b7204c04cb43f09272
+SHA512:
+  metadata.gz: 0d53923840da47ec6454de99ae34a1c9181a1baf0c4c25cef0e1763facb836c4b910e3bc47c7360f04ab26298dff2fdda994a274a3061b1ae707fb3e443ca0c3
+  data.tar.gz: '020817f64ac627bfe26bb044945f5d1cf2770ef5200270a95a501fba0cd7d2d2452f25ebd5a40d4fa3267d2736d3ebf8c7c9fcf34dee7bbb175b8eeaf514176e'

data/.rspec

@@ -0,0 +1,6 @@
+--format documentation
+--color
+--require spec_helper
+-I ../ffi-binary-libfixposix/lib
+-I ../subspawn-posix/lib
+-I ../ffi-bindings-libfixposix/lib

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in process-wrapper-high.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/README.md

@@ -0,0 +1,32 @@
+# SubSpawn Gem (High-level API)
+
+Native process launching. See parent SubSpawn readme for details
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add subspawn subspawn-posix
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install subspawn subspawn-posix
+
+## Usage
+
+```rb
+require 'subspawn'
+
+Subspawn.spawn(["ls", "/"])
+
+# or to augment the built-in ruby methoda
+require 'subspawn/replace'
+
+Process.spawn("ls", "/", :setsid=> true)
+PTY.spawn(...)
+PTY.subspawn(..., options...)
+```
+
+## Development
+
+See parent SubSpawn readme

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :build

data/lib/subspawn/fd_parse.rb

@@ -0,0 +1,148 @@
+require_relative './fd_types'
+require_relative './graph_helper'
+require_relative './pipes'
+
+module SubSpawn::Internal
+	# argument value to int (or :tty)
+	def self.parse_fd(fd, allow_pty=false)
+		# fd = if fd.respond_to? :to_path
+		# fd = if fd.respond_to? :to_file
+		# fd = if fd.respond_to? :to_file
+		case fd
+		when Integer then fd
+		when IO then fd.fileno
+		when :in, :input, :stdin then 0
+		when :out, :output, :stdout then 1
+		when :err, :error, :stderr then 2
+		else
+			if allow_pty and %i{pty tty}.include? fd
+				:tty
+			else
+				raise ArgumentError, "Unknown FD type: #{fd.inspect}"
+			end
+		end
+	end
+
+	# mode conversion
+	def self.guess_mode(d)
+		read = d.include? 0 # stdin
+		write = (d.include? 1 or d.include? 2) # stdout
+		if read && write
+			raise ArgumentError, "Invalid FD source specification: ambiguious mode (r & w)"
+		elsif read
+			:read
+		elsif write
+			:write
+		else
+			raise ArgumentError, "Invalid FD source specification: ambiguious mode (stdio missing)"
+		end
+	end
+
+	# make FdSource objects of each redirection
+	def self.parse_fd_opts(fds, &settty)
+		child_lookup = {}
+		fds.map do |dests, src|
+			d = dests.map{|x| parse_fd(x, true)} # TODO: configurable
+			src = case src
+			when Array
+				case src.first
+				when String # file
+					#raise ArgumentError, "Invalid :child FD source specification" unless src.length == 2
+					# TODO: validate
+					FdSource::File.new(d, *src)
+				when :child
+					raise ArgumentError, "Invalid :child FD source specification" unless src.length == 2
+					# {a => c, b => [child, a]} is the same as {[a, b] => c}
+					# so we can transform the former into the latter
+					newfd = parse_fd(src.last)
+					# TODO: this isn't an error, create a new one
+					raise ArgumentError, "Invalid :child FD source specification" unless child_lookup[newfd]
+					child_lookup[newfd].tap{|child|
+						# add our destinations to the source's redirection
+						d.each { |di| child.dests << di }
+					}
+				else
+					raise ArgumentError, "Invalid FD source specification"
+				end
+			when String
+				FdSource::File.new d, src, ({read: IO::RDONLY, write: IO::WRONLY | IO::CREAT | IO::TRUNC}[guess_mode(d)])
+			when :close
+				FdSource::Close.new d
+			when :pty, :tty
+				FdSource::PTY.new d
+			when :pipe
+				FdSource::Pipe.new d, guess_mode(d)
+			when :pipe_r
+				FdSource::Pipe.new d, :read # TODO: ensure pipe direction is sensical
+			when :pipe_w
+				FdSource::Pipe.new d, :read
+			else
+				if d.include? :tty and src.is_a? File # TODO: is this redundant?
+					settty.call(src.path)
+					d.delete(:tty)
+				end
+				FdSource::Basic.new d, parse_fd(src)
+			end
+			# save redirected fds so we can sneak a child reference in
+			src.tap{|x| d.each{|c|
+				raise ArgumentError, "Invalid FD source specification: duplicate FDs" if child_lookup[c]
+				child_lookup[c] = x
+				} }
+		end.reject(&:nil?)
+	end
+
+	# convert an unordered list of FdSource's into an ordered list with appropriate
+	# temporaries for a correct swap
+	def self.graph_order(fds)
+		# Note that we keep all dests together. It may be smarter to break dests apart to avoid 
+		# temporaries, but that is left as an excercise to the reader
+		next_temp = [fds.map(&:max).max || 2, 2].max + 1
+		graph = Bigraph.new
+		# build graphs
+		fds.each do |fd|
+			from = fd.heads || [Object.new]
+			to = fd.tails || [Object.new]
+			from.zip(to) do |h, t|
+				graph.insert(h, t, fd)
+			end
+		end
+		#puts graph.to_dot
+		# find and break cycles
+		while point = graph.find_cycle
+			# we probably could find the least-cost fd, but this will do for now
+			items = graph.delete_outgoing(point)
+			#p items
+			temp = FdSource::Temp.new([next_temp], point.to_i)
+			close = FdSource::Close.new([next_temp])
+			items = [temp, *items.map{|x|x.temp_source(next_temp)}, close]
+			#p items
+			# reinsert
+			items.each do |fd|
+				from = fd.heads || [Object.new]
+				to = fd.tails || [Object.new]
+				from.zip(to) do |h, t|
+					graph.insert(h, t, fd)
+				end
+			end
+			#puts graph.to_dot
+		end
+		#puts "removed all cycles, hopeuflly"
+		elts = graph.ordered_kahn.reverse # execute in the opposite order of dependencies
+		#puts graph.to_dot
+		elts
+	end
+
+	# I'd love to use this method, but it doesn't accept env
+	# def self.which_jruby(cmd)
+	# 	require 'jruby'
+	# 	org.jruby.util.ShellLauncher.findPathExecutable(JRuby.runtime, cmd)&.absolute_path
+	# end
+
+	def self.which(cmd, env)
+		return nil if cmd.nil? or cmd.to_str == ""
+		SubSpawn::Platform. 
+			expand_which(cmd, env).
+			lazy.
+			find {|x|!File.directory? x and File.executable? x}
+	end
+end

data/lib/subspawn/fd_types.rb

@@ -0,0 +1,180 @@
+module SubSpawn::Internal
+	class FdSource
+		def initialize(dests, all_dests=dests)
+			@dests = dests
+			@all_dests = all_dests
+			raise SpawnError, "Can't provide :tty in this source list" if dests.include? :tty
+		end
+		attr_reader :dests, :all_dests
+
+		def destroys? value
+			@dests.include? value
+		end
+		def depends? o
+			false
+		end
+		def before? o
+			depends? o
+		end
+		def max
+			@dests.max
+		end
+		def to_dbg
+			[self.class, @dests]
+		end
+		def heads
+			nil
+		end
+		def tails
+			@dests
+		end
+
+		def raw_apply base, value
+			@dests.each {|dest| 
+				base.fd(dest, value)
+			}
+			nil # TODO: return the io for basics? would need to cache the fds
+		end
+
+		# TODO: :tty in list shouldn't get here!
+		class Basic < FdSource
+			def initialize(dests, int)
+				super(dests)
+				@value = int
+			end
+			def max
+				[@dests.max, @value].max
+			end
+			def source
+				@value
+			end
+			def depend? o
+				o.dests.include? @value
+			end
+			def temp_source(new)
+				self.class.new(@dests, new)
+			end
+			def before? o
+				# we are before o if:
+				# o destroys any of our sources
+				# or we depend on o
+				depends? o or o.destroys? @value
+			end
+			def heads
+				[@value]
+			end
+			def tails
+				@dests
+			end
+			def to_dbg
+				[@dests, @value]
+			end
+			def apply base
+				raw_apply base, @value
+			end
+		end
+		class Temp < Basic
+			def tails
+				super.map{|x|Xchange.new(x)}
+			end
+		end
+		# class Child < Basic # I don't think this is any different?
+		# 	def to_dbg
+		# 		[@dests, :child, @value]
+		# 	end
+		# end
+
+		class Open < FdSource
+		end
+
+		class File < Open
+			def initialize(dests, file, mode = ::File::RDONLY, perm = 0o666)
+				super(dests)
+				@value = file
+				@mode = mode || ::File::RDONLY
+				if @mode.respond_to? :to_str
+					@mode = case @mode.to_str
+					when "w" then IO::WRONLY | IO::CREAT | IO::TRUNC
+					when "r" then IO::RDONLY
+					when "rb" then IO::RDONLY | IO::BINARY
+					when "wb" then IO::WRONLY | IO::BINARY | IO::CREAT | IO::TRUNC
+					when "r+", "w+" then IO::RDWR | IO::CREAT 
+						# TODO: all!
+					else
+						raise ArgumentError "Unknown File mode"
+					end
+				end
+				@perm = perm || 0o666
+			end
+			def to_dbg
+				[@dests, :file, @value, @mode, @perm]
+			end
+			def apply base
+				first, *rest = @dests
+				base.fd_open(first, @value, @mode, @perm)
+				rest.each {|dest| base.fd(dest, first) }
+				nil
+			end
+		end
+
+		class Pipe < Open
+			def initialize(dests, dir)
+				super(dests)
+				@dir = dir
+			end
+			def apply base
+				@saved ||= IO.pipe
+				r, w = {read: @saved, write: @saved.reverse}[@dir]
+				raw_apply base, r
+				@dests.each {|dest| base.fd_close(w) } # if you want the other end, pass it in yourself
+
+				SubSpawn::IoHolder::Pipe.new(w, r)
+			end
+			#attr_reader :output
+		end
+		class PTY < Open
+			def initialize(dests)
+				tty, ntty = dests.partition{|x|x == :tty}
+				super(ntty, dests)
+				@settty = !tty.empty?
+			end
+			def apply base
+				# MRI doesn't do a chmod for PTY.spawn. Weird, but lets just copy that here
+				m,s = (@saved ||= SubSpawn::Platform::PtyHelper.open_internal)
+				base.fd_close(m) # if you want the master, pass it in yourself
+				raw_apply base, s
+				if @settty
+					base.tty = s
+				end
+				SubSpawn::IoHolder::PTY.new(m,s)
+			end
+		end
+
+		class Close < FdSource
+			def to_dbg
+				[:close, @dests]
+			end
+
+			def heads
+				nil
+			end
+			def tails
+				@dests
+			end
+			def apply base
+				@dests.each {|dest| base.fd_close(dest) }
+				nil
+			end
+		end
+
+		Xchange = Struct.new(:fd)
+		class Xchange
+			def to_s
+				"xc_#{fd}"
+			end
+			def to_i
+				fd
+			end
+		end
+	end
+end

data/lib/subspawn/graph_helper.rb

@@ -0,0 +1,152 @@
+require 'set'
+
+module SubSpawn::Internal
+	class Bigraph
+		def initialize
+			@fwd = {}
+			@rev = {}
+		end
+		def insert(head, tail, data)
+			node = BiNode.new(head, tail, data)
+			((@fwd[head] ||= {})[tail] ||= []) << node
+			((@rev[tail] ||= {})[head] ||= []) << node
+		end
+		def unmark!
+			@fwd.each do |h, ts|
+				ts.each do |t, lst|
+					lst.each {|n| n.marker = nil}
+				end
+			end
+		end
+		def roots
+			unmark!
+			roots = []
+			@rev.each do |t, hs|
+				hs.each do |h, lst|
+					roots += lst unless @rev.key? h
+				end
+			end
+			roots
+		end
+		def roots_h
+			unmark!
+			roots = []
+			@rev.each do |t, hs|
+				hs.each do |h, lst|
+					roots << h unless @rev.key? h
+				end
+			end
+			roots.uniq
+		end
+		def leaves
+			unmark!
+			leaves = []
+			@fwd.each do |h, ts|
+				ts.each do |t, lst|
+					leaves += lst unless @fwd.key? t
+				end
+			end
+			leaves
+		end
+		def find_cycle
+			unmark!
+			# we have a forest, do for each forestry
+			rts = roots_h
+			if rts.empty? # probably have a loop
+				#puts "empt"
+				rts = [@fwd.keys.first]
+			end
+			at, rts = *rts
+			while at
+				#puts "searching at #{at} with #{rts}"
+				tmp = find_cycle_next(at)
+				return tmp unless tmp.nil?
+				at, rts = *rts
+			end
+		end
+		def find_cycle_next(start)
+			@fwd[start]&.each do |t, list|
+				#puts "cc = [#{start} -> #{t}]"
+				if list.any?(&:marker)
+					return t 
+				end
+				list.each(&:mark)
+				tmp = find_cycle_next(t)
+				return tmp unless tmp.nil?
+			end
+			return nil
+		end
+		def delete_outgoing(head)
+			@fwd[head].flat_map{|t, k|delete(head, t)}
+		end
+		def delete(head, tail)
+			@fwd[head].delete(tail)
+			@rev[tail].delete(head).map(&:data)
+		end
+		def find_unmarked
+			@fwd.each do |h, ts|
+				ts.each do |t, lst|
+					return [h, t] unless lst.first.marker
+				end
+			end
+			return nil
+		end
+		def ordered_kahn
+			unmark!
+			# now traverse the tree until we hit a junction, ensuring
+			# dependencies are met
+			# Note this assumes you removed all the cycles from your code
+			# returns each graph seperately as a sort of forest
+			l = []
+			s = Set.new(roots_h)
+
+			until s.empty?
+				n = s.first
+				#puts "checking #{n} in #{s}"
+				s.delete(n)
+				@fwd[n]&.each do |e, ms|
+					next if ms.any?(&:marker) # already visited
+					ms.each(&:mark)
+					# no incoming edges
+					unless @rev[e]&.any?{|nh, lst| !lst.first.marker}
+						# nil -> add
+						# any(unmarked) true -> none
+						# all(marked) -> add
+						s << e
+						l += ms
+						#puts "blank incoming #{e}"
+					else
+						#puts "had incoming #{e}: #{@rev[e]}"
+					end
+				end
+			end
+
+			if find_unmarked#.tap{|x| p x, "um"}
+				puts to_dot
+				#raise "Unmarked graph edges, an unresolved cycle probably exists. This is a bug in SubSpawn"
+				nil
+			else
+				return l.map(&:data)
+			end
+		end
+		
+		# for debugging
+		def to_dot
+			body = @fwd.map do |h, ts|
+				ts.map do |t, lst|
+					"\"#{h}\" -> \"#{t}\" ;" #{lst.first&.marker};"
+				end
+			end.join("\n")
+			return "digraph G {\n#{body}\n}"
+		end
+	end
+	class BiNode
+		def initialize(head, tail, data)
+			@head, @tail, @data, @marker = head, tail, data, nil
+		end
+		attr_accessor :head, :tail, :data, :marker
+		def mark
+			@marker = true
+		end
+	end
+end

data/lib/subspawn/pipes.rb

@@ -0,0 +1,49 @@
+
+class SubSpawn::IoHolder
+	def initialize(map)
+		@map = map
+	end
+
+	def [](key)
+		tmp = get(key)
+		tmp = tmp.to_io if tmp.respond_to? :to_io
+		tmp
+	end
+	def get(key)
+		@map[SubSpawn::Internal.parse_fd(key, true)]
+	end
+	def composite? key
+		self.get(key).is_a? Composite
+	end
+	def empty?
+		@map.values.reject(&:nil?).empty?
+	end
+
+	class Composite
+	end
+
+	class Pipe < Composite
+		def initialize(parent, child)
+			@parent, @child = parent, child
+		end
+		attr_reader :parent, :child
+		alias :to_io :parent
+		def fileno
+			@parent.fileno
+		end
+	end
+	
+	class PTY < Composite
+		def initialize(master, slave)
+			@master, @slave = master, slave
+		end
+		attr_reader :master, :slave
+		alias :to_io :master
+		def to_ary
+			[@master, @slave]
+		end
+		def fileno
+			@master.fileno
+		end
+	end
+end

data/lib/subspawn/replace-builtin.rb

@@ -0,0 +1,30 @@
+require 'subspawn'
+
+module Kernel
+	class << self
+		alias :builtin_spawn :spawn
+		def spawn(*args)
+			SubSpawn.spawn_compat(*args)
+		end
+	end
+
+	private
+	alias :builtin_spawn :spawn
+	def spawn(*args)
+		SubSpawn.spawn_compat(*args)
+	end
+end
+
+module Process
+	class << self
+		alias :builtin_spawn :spawn
+
+		def spawn(*args)
+			SubSpawn.spawn_compat(*args)
+		end
+
+		def subspawn(args, opt={})
+			SubSpawn.spawn(args, opt)
+		end
+	end
+end

data/lib/subspawn/replace-pty.rb

@@ -0,0 +1,40 @@
+require 'subspawn'
+
+$_ss_overwrite = defined? PTY
+
+module PTY
+	unless $_ss_overwrite
+		class ChildExited < RuntimeError
+			def initialize(status)
+				@status = status
+			end
+			attr_reader :status
+		end
+	end
+	class << self
+		if $_ss_overwrite
+			alias :builtin_spawn :spawn
+			alias :builtin_getpty :getpty
+		end
+
+		def spawn(*args, &block)
+			SubSpawn.pty_spawn_compat(*args, &block)
+		end
+		def subspawn(command, opts={}, &block)
+			SubSpawn.pty_spawn(command, opts, &block)
+		end
+		alias :getpty :spawn
+
+		def open(&blk)
+			SubSpawn::Platform::PtyHelper.open(&blk)
+		end
+
+		def check(pid, do_raise=false)
+			return if Process.waitpid(pid, Process::WNOHANG | Process::WUNTRACED).nil?
+			return $? unless do_raise
+			raise ::PTY::ChildExited.new($?)
+		end
+	end
+end
+
+$_ss_overwrite = nil

data/lib/subspawn/replace.rb

@@ -0,0 +1,2 @@
+require 'subspawn/replace-builtin'
+require 'subspawn/replace-pty'

data/lib/subspawn/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SubSpawn
+	VERSION = "0.1.0"
+end

data/lib/subspawn.rb

@@ -0,0 +1,221 @@
+require 'ffi'
+require 'subspawn/version'
+require 'subspawn/fd_parse'
+if FFI::Platform.unix?
+	require 'subspawn/posix'
+	SubSpawn::Platform = SubSpawn::POSIX
+elsif FFI::Platform.windows?
+	raise "SubSpawn Win32 is not yet implemented"
+else
+	raise "Unknown FFI platform"
+end
+
+module SubSpawn
+	# TODO: things to check: set $?
+	def self.spawn_compat(command, *command2)
+		#File.write('/tmp/spawn.trace', [command, *command2].inspect + "\n", mode: 'a+')
+
+		# return just the pid
+		delta_env = nil
+		# check for env
+		if command.respond_to? :to_hash
+			delta_env = command.to_hash
+			command = command2
+		else # 2-arg ctor
+			command = [command] + command2
+		end
+		opt = {}
+		if command.last.respond_to? :to_hash
+			*command, opt = *command
+		end
+		if command.first.is_a? Array and command.first.length != 2
+			raise ArgumentError, "First argument must be an pair TODO: check this"
+		end
+		raise ArgumentError, "Must provide a command to execute" if command.empty?
+		raise ArgumentError, "Must provide options as a hash" unless opt.is_a? Hash
+		if opt.key? :env and delta_env
+			# TODO: warn?
+			raise SpawnError, "SubSpawn.spawn_compat doesn't allow :env key, try SubSpawn.spawn instead"
+			# unsupported
+		else
+			opt[:env] = delta_env if delta_env
+		end
+		copt = {:__ss_compat => true }
+		copt[:__ss_compat_testing] = opt.delete(:__ss_compat_testing)
+		begin
+			cf = nil
+			if command.length == 1 and (cf = command.first).respond_to? :to_str
+				# and ((cf = cf.to_str).include? " " or (Internal.which(cmd)))
+				#command = ["sh", "-c", cf] # TODO: refactor
+				command = [command.first.to_str]
+				copt[:__ss_compat_shell] = true
+			end
+		rescue NoMethodError => e # by spec
+			raise TypeError.new(e)
+		end
+		SubSpawn.__spawn_internal(command, opt, copt).first
+	end
+	# TODO: accept block mode?
+	def self.spawn(command, opt={})
+		__spawn_internal(command, opt, {})
+	end
+	def self.spawn_shell(command, opt={})
+		__spawn_internal(Platform.shell_command(command), opt, {})
+	end
+	def self.__spawn_internal(command, opt, copt)
+		unless command.respond_to? :to_ary # TODO: fix this check up with new parsing
+			raise ArgumentError, "First argument must be an array" unless command.is_a? String
+			# not the cleanest check, but should be better than generic exec errors
+			raise SpawnError, "SubSpawn only accepts arrays #LINK TODO" if command.include? " " 
+			command = [command]
+		else
+			command = command.to_ary.dup
+		end
+		unless opt.respond_to? :to_hash # TODO: fix this check up with new parsing
+			raise ArgumentError, "Second argument must be a hash, did you mean to use spawn([#{command.inspect}, #{opt.inspect}]) ?"
+		end
+		fds = []
+		env_opts = {base: ENV, set: false, deltas: nil, only: false}
+		begin
+			if command.first.respond_to? :to_ary
+				warn "argv0 and array syntax both provided to SubSpawn. Preferring argv0" if opt[:argv0]
+				command[0], tmp = *command.first.to_ary.map(&:to_str) # by spec
+				opt[:argv0] = opt[:argv0] || tmp
+			end
+			command = command.map(&:to_str) # by spec
+		rescue NoMethodError => e # by spec
+			raise TypeError.new(e)
+		end
+		arg0 = command.first
+		raise ArgumentError, "Cannot spawn with null bytes: OS uses C-style strings" if command.any? {|x|x.include? "\0"}
+		base = SubSpawn::Platform.new(*command, arg0: (opt[:argv0] || arg0).to_s)
+		opt.each do |key, value|
+			case key
+			when Array # P.s
+				fds << [key,value]
+			# TODO:  ,:output, :input, :error, :stderr, :stdin, :stdout, :pty, :tty ?
+			when Integer, IO, :in,  :out, :err # P.s: in, out, err, IO, Integer
+				fds << [[key], value]
+			# TODO: , :cwd
+			when :chdir # P.s: :chdir
+				base.cwd = value.respond_to?(:to_path) ? value.to_path : value
+			when :tty, :pty
+				if value == :tty || value == :pty
+					fds << [[key], value] # make a new pty this way
+				else
+					base.tty = value
+					#base.sid!# TODO: yes? no?
+				end
+			when :sid
+				base.sid! if value
+			when :env
+				if env_opts[:deltas]
+					warn "Provided multiple ENV options"
+				end
+				env_opts[:deltas] = value
+				env_opts[:set] ||= value != nil
+			when :setenv, :set_env, :env=
+				if env_opts[:deltas]
+					warn "Provided multiple ENV options"
+				end
+				env_opts[:deltas] = env_opts[:base] = value
+				env_opts[:set] = value != nil
+				env_opts[:only] = true
+
+			# Difference: new_pgroup is linux too?
+			when :pgroup, :new_pgroup, :process_group # P.s: pgroup, :new_pgroup
+				raise TypeError, "pgroup must be boolean or integral" if value.is_a? Symbol
+				base.pgroup = value == true ? 0 : value if value
+			when :signal_mask # TODO: signal_default
+				base.signal_mask(value)
+			when /rlimit_(.*)/ # P.s
+				name = $1
+				keys = [value].flatten
+				base.rlimit(name, *keys)
+			when :rlimit # NEW?
+				raise ArgumentError, "rlimit as a hash must be a hash" unless value.respond_to? :to_h
+				value.to_h.each do |key, values|
+					base.rlimit(key, *[values].flatten)
+				end
+			when :umask # P.s
+				raise ArgumentError, "umask must be numeric" unless value.is_a? Integer
+				base.umask = value
+			when :unsetenv_others # P.s
+				env_opts[:only] = !!value
+				env_opts[:set] ||= !!value
+			when :close_others # P.s
+				warn "CLOEXEC is set by default, :close_others is a no-op in SubSpawn.spawn call. Consider :keep"
+			when :argv0
+				# Alraedy processed
+			else
+				# TODO: exception always?
+				if copt[:__ss_compat]
+					raise ArgumentError, "Unknown SubSpawn argument #{key.inspect}. Ignoring"
+				else
+				warn "Unknown SubSpawn argument #{key.inspect}. Ignoring"
+				end
+			end
+		end
+		working_env = if env_opts[:set]
+			base.env = if  env_opts[:only]
+				env_opts[:deltas].to_hash
+			else
+				env_opts[:base].to_hash.merge(env_opts[:deltas].to_hash)
+			end.to_h
+		else
+			ENV
+		end
+		# now that we have the working env, we can finally update the command
+		unless copt[:__ss_compat_testing]
+			if copt[:__ss_compat_shell] && Internal.which(command.first, working_env).nil? && command.first.include?(" ") # ruby specs don't allow builtins, apparently
+				command = Platform.shell_command(command.first)
+				base.args = command[1..-1]
+				base.command = base.name = command.first
+			end
+			newcmd = Internal.which(command.first, working_env)
+			# if newcmd is null, let the systemerror shine from below
+			if command.first!= "" && !newcmd.nil? && newcmd != command.first
+				base.command = newcmd
+			end
+		end
+
+		# parse and clean up fd descriptors
+		fds = Internal.parse_fd_opts(fds) {|path| base.tty = path }
+		# now make a graph and add temporaries
+		ordering = Internal.graph_order(fds)
+		# configure them in order, saving new io descriptors
+		created_pipes = ordering.flat_map do |fd|
+			result = fd.apply(base)
+			fd.all_dests.map{|x| [x, result] }
+		end.to_h
+		# Spawn and return any new pipes
+		[base.spawn!, IoHolder.new(created_pipes)]
+	end
+
+	def self.pty_spawn_compat(*args, &block)
+		pty_spawn(args, &block)
+	end
+	def self.pty_spawn(args, opts={}, &block)
+		# TODO: setsid?
+		# TODO: MRI tries to pull the shell out of the ENV var, but that seems wrong
+		pid, args = SubSpawn.spawn(args, {[:in, :out, :err, :tty] => :pty, :sid => true}.merge(opts))
+		tty = args[:tty]
+		list = [tty, tty, pid]
+		return list unless block_given?
+
+		begin
+			return block.call(*list)
+		ensure
+			tty.close unless tty.closed?
+			# MRI waits this way to ensure the process is reaped
+			if Process.waitpid(pid, Process::WNOHANG)
+				Process.detach(pid)
+			end
+		end
+	end
+
+	COMPLETE_VERSION = {
+		subspawn: SubSpawn::VERSION,
+		platform: SubSpawn::Platform::COMPLETE_VERSION,
+	}
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: subspawn
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Patrick Plenefisch
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: subspawn-posix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Advanced native subprocess spawning on MRI, JRuby, and TruffleRuby
+email:
+- simonpatp@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- lib/subspawn.rb
+- lib/subspawn/fd_parse.rb
+- lib/subspawn/fd_types.rb
+- lib/subspawn/graph_helper.rb
+- lib/subspawn/pipes.rb
+- lib/subspawn/replace-builtin.rb
+- lib/subspawn/replace-pty.rb
+- lib/subspawn/replace.rb
+- lib/subspawn/version.rb
+homepage: https://github.com/byteit101/subspawn
+licenses: []
+metadata:
+  homepage_uri: https://github.com/byteit101/subspawn
+  source_code_uri: https://github.com/byteit101/subspawn
+  changelog_uri: https://github.com/byteit101/subspawn
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Advanced native subprocess spawning
+test_files: []