subspawn-posix 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e1e9a8cd307acbb03c05440d9300a7e48a3636d36734f2b4cb189aae0ab98bdd
+  data.tar.gz: e176b1617b2c674da1de970e1b9e7ecf7776ab9c418e746374ec3983e4d6a31b
+SHA512:
+  metadata.gz: 47fc587e35e40da9bffc3b8a8877363441c98dd25cbe1c46509c92478bae2651661194ad080271226b23446eb3f1de089af9e132e212f29e05940d5adecc86d5
+  data.tar.gz: 540342bd3dc2c875a0f94a8d6d0a6f58698a8cdc456cf707e09f8c5c1251d71294342a2d802d220ad6feea64f03d3f482c4f3c00781a88a2b3a19614a34bde3a

data/.rspec

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

data/Gemfile

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

data/README.md

@@ -0,0 +1,27 @@
+# SubSpawn Native POSIX API
+
+SubSpawn wrapper over libfixposix. Install `ffi-binary-libfixposix` if you need binaries.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add subspawn-posix
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install subspawn-posix
+
+## Usage
+
+```rb
+require 'subspawn/posix'
+```
+
+See SubSpawn for more details.
+
+An RBS file exists for this gem.
+
+## 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/binary.rb

@@ -0,0 +1,2 @@
+require 'libfixposix/binary'
+require 'subspawn/posix'

data/lib/subspawn/posix/ffi_helper.rb

@@ -0,0 +1,39 @@
+require 'ffi'
+
+module SubSpawn::POSIX::Internal
+	module SignalFn
+		extend FFI::Library
+		ffi_lib FFI::Library::LIBC
+
+		attach_function :emptyset, :sigemptyset, [:pointer], :int
+		attach_function :fillset, :sigfillset, [:pointer], :int
+		attach_function :addset, :sigaddset, [:pointer, :int], :int
+		attach_function :delset, :sigdelset, [:pointer, :int], :int
+		attach_function :ismember, :sigismember, [:pointer, :int], :int
+
+
+		ffi_lib %w{pthread.so.0 pthread pthread.dylib}
+
+		attach_function :mask, :pthread_sigmask, %i{int pointer pointer}, :int
+	end
+
+	module OpenPTY
+		extend FFI::Library
+
+		ffi_lib FFI::Platform.mac? ? FFI::Library::LIBC : "util"
+		attach_function :openpty, [:buffer_out, :buffer_out, :buffer_out, :buffer_in, :buffer_in], :int
+
+		ffi_lib FFI::Library::LIBC
+		attach_function :close, [:int], :int
+
+		def self.call(termios: nil, winsize: nil)
+			FFI::MemoryPointer.new(:int, 2) do |fds|
+				FFI::MemoryPointer.new(:char, 4096) do |name| # max on linux = 4096
+					ret = self.openpty(fds[0], fds[1], name, termios, winsize)
+					raise SystemCallError.new("OpenPTY Error", LFP.errno) unless ret == 0
+					return [*fds.read_array_of_int(2), name.read_string]
+				end
+			end
+		end
+	end
+end

data/lib/subspawn/posix/pty.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module SubSpawn
+class POSIX
+module PtyHelper
+	class PtyIO < IO
+		def inspect
+			"#<IO:masterpty:#{@slave_path}>"
+		end
+
+		# Subspawn-specific feature
+		attr_reader :slave_path
+
+		private
+		def __subspawn_init(name)
+			# All other files are opened cloexec, this one isn't yet as it came from native code
+			self.close_on_exec = true
+			@slave_path = name.freeze
+			self.sync = true
+		end
+	end
+
+	def self.open_internal(chmod_for_open = false)
+		m, s, name = Internal::OpenPTY.call
+
+		# chmod the slave path, but only if were were called as ::open, not as ::spawn
+		# I don't understand why, but doing this just to mirror MRI
+		File.chmod(0o600, name) if chmod_for_open
+
+		master = PtyIO.for_fd(m, IO::RDWR | IO::SYNC)
+		master.send(:__subspawn_init, name)
+
+		# we could shim the slave to be a fake file, or we could just re-open the path
+		# which fixes #inspect, #tty?, #path, and #close_on_exec, all in one go
+		# https://bugs.ruby-lang.org/issues/19036
+		slave = File.open(name, IO::RDWR | IO::SYNC)
+		slave.sync = true # still must do this manually though, as IO::SYNC seems to be mostly ignored
+		Internal::OpenPTY.close(s)
+
+		[master, slave, name]
+	end
+
+	def self.open
+		*files, name = open_internal(true)
+		return files unless block_given?
+
+		begin
+			return yield files.dup # Array, not splatted
+		ensure
+			files.reject(&:closed?).each(&:close)
+		end
+	end
+
+end
+end
+end

data/lib/subspawn/posix/signals.rb

@@ -0,0 +1,85 @@
+class SubSpawn::POSIX::SigSet
+	def initialize(base=:empty)
+		base = base.to_sym
+		raise ArgumentError, "SigSet only accepts :full, :empty, or :current" unless %i{full empty current}.include? base
+		# TODO: warn about current?
+		@base = base
+		@ops = []
+		@ptr = nil
+	end
+	def self.empty
+		self.new(:empty)
+	end
+	def self.full
+		self.new(:full)
+	end
+	def self.current
+		self.new(:current)
+	end
+	def include(*signals)
+		clean_signals(signals).each do |sig|
+			@ops << [:add, sig]
+		end
+		self
+	end
+	def exclude(*signals)
+		clean_signals(signals).each do |sig|
+			@ops << [:rm, sig]
+		end
+		self
+	end
+	alias :- :exclude
+	alias :+ :include
+	alias :add :exclude
+	alias :del :include
+	alias :delete :include
+
+	def to_ptr(&block)
+		if @ptr.nil?
+			# sigset_t is largest on linux, at 128 bytes, so always allocate that much
+			if block_given?
+				ret = nil
+				FFI::MemoryPointer.new(:uint8, 128) {|ptr| alloc_internal(ptr); ret = block.call(ptr)}
+				ret
+			else
+				FFI::MemoryPointer.new(:uint8, 128).tap {|ptr| @ptr = ptr; alloc_internal(ptr)}
+			end
+		else
+			if block_given?
+				block.call(@ptr)
+			else
+				@ptr
+			end
+		end
+	end
+	private
+	def clean_signals(signals)
+		signals.flatten.map do |sig|
+			if Integer === sig
+				sig
+			else
+				Signal.list[sig.to_s.upcase].tap do |good|
+					raise ArgumentError, "#{sig} cannot be converted to a signal" if good.nil?
+				end
+			end 
+		end
+	end
+	def alloc_internal ptr
+		sig = SubSpawn::POSIX::Internal::SignalFn
+		case @base
+		when :full then sig.fillset(ptr)
+		when :empty then sig.emptyset(ptr)
+		when :current
+			sig.emptyset(ptr)
+			sig.mask(0, nil, ptr) # get the current (old) set
+		else raise "Invalid State"
+		end
+		@ops.each do |op, num|
+			if op == :add
+				sig.addset(ptr, num)
+			else
+				sig.delset(ptr, num)
+			end
+		end
+	end
+end

data/lib/subspawn/posix/version.rb

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

data/lib/subspawn/posix.rb

@@ -0,0 +1,375 @@
+require 'libfixposix'
+require 'subspawn/posix/version'
+require 'subspawn/posix/ffi_helper'
+require 'subspawn/posix/signals'
+require 'subspawn/posix/pty'
+module SubSpawn
+class SpawnError < RuntimeError
+end
+class POSIX
+
+	OpenFD = Struct.new(:fd, :path, :mode, :flags)
+	
+	def initialize(command, *args, arg0: command)
+		@path = command
+		#raise SpawnError, "Command not found: #{command}" unless @path
+		# TODO: we use envp, so can't check this now
+		@argv = [arg0, *args.map(&:to_str)]
+		@fd_map = {}
+		@fd_keeps = []
+		@fd_closes = []
+		@fd_opens = []
+		@signal_mask = @signal_default = nil
+		@cwd = nil
+		@sid = false
+		@pgroup = nil
+		@env = :default
+		@ctty = nil
+		@rlimits = {}
+		@umask = nil
+	end
+	attr_writer :cwd, :ctty
+	
+	StdIn = 0
+	StdOut= 1
+	StdErr = 2
+	Std = {in: StdIn, out: StdOut, err: StdErr}.freeze
+	
+	def validate!
+		@argv.map!(&:to_str) # By spec
+		raise SpawnError, "Invalid argv" unless @argv.length > 0
+		@fd_map = @fd_map.map do |number, source|
+			raise SpawnError, "Invalid FD map: Not a number: #{number.inspect}" unless number.is_a? Integer
+			[number, fd_check(source)]
+		end.to_h
+		@fd_keeps.each{|x| fd_check(x)}
+		@fd_closes.each{|x| fd_check(x)}
+		@fd_opens.each{|x|
+			fd_check(x.fd)
+			raise SpawnError, "Invalid FD open: Not a number: #{x.mode.inspect}" unless x.mode.is_a? Integer
+			raise SpawnError, "Invalid FD open: Not a flag: #{x.flags.inspect}" unless x.flags.is_a? Integer
+			raise SpawnError, "Invalid FD open: Not a file: #{x.file.inspect}" unless File.exist? x.path or Dir.exist?(File.dirname(x.path))
+		}
+		
+		raise SpawnError, "Invalid cwd path" unless @cwd.nil? or Dir.exist?(@cwd = ensure_file_string(@cwd))
+		
+		@ctty = @ctty.path if !@ctty.nil? and @ctty.is_a? File # PTY.open returns files
+		raise SpawnError, "Invalid controlling tty path" unless @ctty.nil? or File.exist?(@ctty = ensure_file_string(@ctty))
+		
+		true
+	end
+	
+	def spawn!
+		validate!
+		sfa = LFP::SpawnFileActions.new
+		sa = LFP::Spawnattr.new
+		raise "Spawn Init Error" if 0 != sfa.init
+		out_pid = nil
+		begin
+			raise "Spawn Init Error" if 0 != sa.init
+			begin
+				# set up file descriptors
+				
+				@fd_keeps.each {|fd| sfa.addkeep(fd_number(fd)) }
+				@fd_opens.each {|opn|
+					sfa.addopen(fd_number(opn.fd), opn.path, opn.flags, opn.mode)
+				}
+				@fd_map.map{|k, v| [k, fd_number(v)] }.each do |dest, src|
+					sfa.adddup2(src, dest)
+				end
+				@fd_closes.each {|fd| sfa.addclose(fd_number(fd)) }
+
+				unless @rlimits.empty?
+					# allocate output (pid)
+					FFI::MemoryPointer.new(LFP::Rlimit, @rlimits.length) do |rlimits|
+						# build array
+						@rlimits.each_with_index {|(key, (cur, max)), i|
+							rlimit = LFP::Rlimit.new(rlimits[i])
+							#puts "building rlim at #{i} to #{[cur, max, key]}"
+							rlimit[:rlim_cur] = cur.to_i
+							rlimit[:rlim_max] = max.to_i
+							rlimit[:resource] = key.to_i
+						}
+						sa.setrlimit(rlimits, @rlimits.length)
+					end
+				end
+				
+				# set up signals
+				sa.sigmask = @signal_mask.to_ptr if @signal_mask
+				sa.sigdefault = @signal_default.to_ptr if @signal_default
+				
+				# set up ownership and groups
+				sa.pgroup = @pgroup.to_i if @pgroup
+				sa.umask = @umask.to_i if @umask
+				
+				# Set up terminal control
+				sa.setsid if @sid
+				sa.ctty = @ctty if @ctty
+				
+				# set up working dir
+				sa.cwd = @cwd if @cwd
+				
+				# allocate output (pid)
+				FFI::MemoryPointer.new(:int, 1) do |pid|
+					argv_str = @argv.map{|a|
+						raise ArgumentError, "Nulls not allowed in command: #{a.inspect}" if a.include? "\0"
+						FFI::MemoryPointer.from_string a
+					} + [nil] # null end of argv
+					FFI::MemoryPointer.new(:pointer, argv_str.length) do |argv_holder|
+					
+						# ARGV
+						argv_holder.write_array_of_pointer argv_str
+						
+						# ARGP/ENV
+						make_envp do |envp_holder|
+
+							# Launch!
+							ret = LFP.spawnp(pid, @path, argv_holder, envp_holder, sfa, sa)
+							if ret != 0
+								raise SystemCallError.new("Spawn Error: #{ret}", LFP.errno)
+							end
+							out_pid = pid.read_int
+						end
+					end
+				end
+			ensure
+				sa.destroy
+			end
+		ensure
+			sfa.destroy
+		end
+		out_pid
+	end
+	
+	# TODO: allow io on left?
+	def fd(number, io_or_fd)
+		num = number.is_a?(Symbol) ? Std[number] : number.to_i
+		raise ArgumentError, "Invalid file descriptor number: #{number}. Supported values = 0.. or #{std.keys.inspect}" if num.nil?
+		if fd_number(io_or_fd) == num
+			fd_keep(io_or_fd)
+		else
+			@fd_map[num] = io_or_fd
+		end
+		self
+	end
+
+	def fd_open(number, path, flags = 0, mode=0o666) # umask will remove bits
+		num = number.is_a?(Symbol) ? Std[number] : number.to_i
+		raise ArgumentError, "Invalid file descriptor number: #{number}. Supported values = 0.. or #{std.keys.inspect}" if num.nil?
+		@fd_opens << OpenFD.new(number, path, mode, flags)
+		self
+	end
+	def fd_keep(io_or_fd)
+		@fd_keep << io_or_fd
+		self
+	end
+	def fd_close(io_or_fd)
+		@fd_closes << io_or_fd
+		self
+	end
+	def name(string)
+		@argv[0] = string.to_s
+		self
+	end
+	alias :name= :name
+
+	def args(args)
+		@argv = [@argv[0], *args.map(&:to_str)]
+		self
+	end
+	alias :args= :args
+	def command(cmd)
+		@path = cmd
+		self
+	end
+	alias :command= :command
+
+	def env_reset!
+		@env = :default
+		self
+	end
+	def env(key, value)
+		@env = ENV.to_h.dup if @env == :default
+		@env[key.to_s] = value.to_s
+		self
+	end
+	def env=(hash)
+		@env = hash.to_h
+		self
+	end
+	# usage:
+	# signal_mask = SigSet.empty.add(:usr1).delete("USR2")
+	# signal_mask(:full, exclude: [9])
+	def signal_mask(sigmask = :default, add: [], delete: [], block: [], allow: [])
+		sigmask = :empty if sigmask == :default
+		@signal_mask = sigmask.is_a?(Symbol) ? SigSet.send(sigmask) : sigmask
+		@signal_mask.add(add, allow).delete(delete, block)
+		self
+	end
+	alias :signal_mask= :signal_mask
+	alias :sigmask= :signal_mask
+	alias :sigmask :signal_mask
+
+	# usage:
+	# signal_default = SigSet.empty.add(:usr1).delete("USR2")
+	# signal_default(:full, exclude: [9])
+	def signal_default(sigmask = :default, add: [], delete: [], default: [])
+		sigmask = :empty if sigmask == :default
+		@signal_default = sigmask.is_a?(Symbol) ? SigSet.send(sigmask) : sigmask
+		@signal_default.add(add, default).delete(delete)
+		self
+	end
+	alias :signal_default= :signal_default
+
+	def umask=(value)
+		@umask = value.nil? ? nil : value.to_i
+		self
+	end
+	alias :umask :umask=
+
+	def pwd(path)
+		@cwd = path
+		self
+	end
+	alias :cwd :pwd
+	alias :pwd= :cwd=
+	alias :chdir :pwd
+	alias :chdir= :cwd=
+	
+	def sid!
+		@sid = true
+		self
+	end
+	def pgroup(pid)
+		raise ArgumentError, "Invalid pgroup: #{pid}" if pid < 0 or !pid.is_a?(Integer)
+		@pgroup = pid.to_i
+		self
+	end
+	alias :pgroup= :pgroup
+	
+	def ctty(path)
+		@ctty = path
+		self
+	end
+	alias :tty= :ctty=
+	alias :tty :ctty
+	
+
+	def rlimit(key, cur, max=nil)
+		key = if key.is_a? Integer
+			key.to_i
+		else # TODO: these const lookup should have better error handling
+			Process.const_get("RLIMIT_#{key.to_s.upcase}")
+		end
+		cur = ensure_rlimit(key, cur, 0)
+		max = ensure_rlimit(key, max, 1)
+		cur = max if cur > max
+		@rlimits[key] = [cur, max]
+		self
+	end
+	alias :setrlimit :rlimit
+	
+	def validate
+		validate! rescue false
+	end
+	
+	
+
+	# generator for candidates for an executable name
+	# usage:
+	# SubSpawn::POSIX.each_which("ls", ENV) {|path| ...}
+	# SubSpawn::POSIX.each_which("ls", ENV).to_a
+	def self.expand_which(name, env=ENV)
+		return self.to_enum(:expand_which, name, env) unless block_given?
+		# only allow relative paths if they traverse, and if they traverse, only allow relative paths
+		if name.include? "/"
+			yield File.absolute_path(name)
+		else
+			env['PATH'].split(File::PATH_SEPARATOR).each do |path|
+				yield File.join(path, name)
+			end
+		end
+	end
+
+	def self.shell_command(string)
+		# MRI scans for "basic" commands and if so, just un-expands the shell
+		# we could do that too, and there are 2 tests about that in rubyspec
+		# but we shall ignore them for now
+		# TODO: implement that
+		["sh", "-c", string.to_str]
+	end
+
+	COMPLETE_VERSION = {
+		subspawn_posix: SubSpawn::POSIX::VERSION,
+		libfixposix: LFP::COMPLETE_VERSION,
+	}
+
+	private
+	def none
+		@@none ||= Object.new
+	end
+	def ensure_rlimit(key, value, index)
+		if value.nil?
+			return Process.getrlimit(key)[index] # unspecified, load saved
+		end
+		return value.to_i if value.is_a? Integer
+		Process.const_get("RLIMIT_#{value.to_s.upcase}")
+	end
+
+	def make_envp
+		if @env == :default
+			yield LFP.get_environ
+		else
+			strings = @env.select{|k, v|
+				!k.nil? and !v.nil?
+			}.map{|k,v|
+				k = k.to_str
+				str = "#{k}=#{v.to_str}"  # rubyspec says to convert to_str
+				raise ArgumentError, "Nulls not allowed in environment variable: #{str.inspect}" if str.include? "\0" # By Spec
+				raise ArgumentError, "Variable key cannot include '=': #{str.inspect}" if k.include? "=" # By Spec
+				FFI::MemoryPointer.from_string str
+			} + [nil] # null end of argp
+			FFI::MemoryPointer.new(:pointer, strings.length) do |argp_holder|
+				argp_holder.write_array_of_pointer strings
+				yield argp_holder
+			end
+		end
+	end
+	def ensure_file_string(path)
+		if defined? JRUBY_VERSION # accept File and Path java objects
+			path = path.to_file if path.respond_to? :to_file
+			if path.respond_to? :absolute_path
+				path.absoloute_path
+			else
+				path.to_s
+			end
+		else
+			path.to_s
+		end
+	end
+	def fd_check(source)
+		case source
+		when Integer then source
+		when IO then source
+		when :in, :out, :err
+			Std[source]
+		else
+			raise SpawnError, "Invalid FD map: Not a io or number: #{source.inspect}"
+		end
+	end
+	def fd_number(source)
+		case source
+		when Integer then source
+		when IO then source.fileno
+		when :in, :out, :err
+			Std[source]
+		else
+			raise SpawnError, "Invalid FD map: Not a io or number: #{source.inspect}"
+		end
+	end
+
+end
+end
+
+
+

data/sig/subspawn/posix.rbs

@@ -0,0 +1,100 @@
+module SubSpawn
+	class SpawnError < RuntimeError
+	end
+	class POSIX
+		VERSION: String
+
+		StdIn: Integer
+		StdErr: Integer
+		StdOut: Integer
+		Std: Hash[(:in | :out | :err), Integer]
+
+		def initialize: (String command, *String args, ?arg0: String) -> nil
+
+		# Environmental attributes
+		attr_writer cwd: String | File
+		def cwd: (String | File) -> self
+		alias pwd= cwd=
+		alias pwd cwd
+		alias chdir= cwd=
+		alias chdir cwd
+
+		def env_reset!: () -> self
+		attr_writer env: Hash
+		def env: (key: String, value: String) -> self
+		       
+		attr_writer umask: Integer
+		def umask: (Integer) -> self
+		         
+		# File descriptor mapping
+		type FD = IO | :in | :out | :err | Integer
+		def fd: (FD dest,FD source) -> self
+		def fd_open: (FD dest, String path, ?Integer flags, ?Integer create_file_mode) -> self
+		def fd_keep: (FD) -> self
+		def fd_close: (FD) -> self
+
+		# Head control
+		def sid!: () -> self
+		def pgroup: (Integer) -> self
+		attr_writer pgroup: Integer
+		attr_writer tty: String | File
+		def tty: (String | File) -> self
+		alias ctty= tty=
+		alias ctty tty
+
+		# Signals 
+		type SignalName = String | Symbol | Integer
+		def signal_mask: (SubSpawn::POSIX::SigSet | :full | :empty | :current | :default, ?add: SignalName | Array[SignalName], ?delete: SignalName | Array[SignalName], ?block: SignalName | Array[SignalName], ?allow: SignalName | Array[SignalName]) -> self
+		attr_writer signal_mask: SubSpawn::POSIX::SigSet
+		alias sigmask signal_mask
+		alias sigmask= signal_mask=
+
+		def signal_default: (SubSpawn::POSIX::SigSet | :full | :empty | :current | :default, ?add: SignalName | Array[SignalName], ?delete: SignalName | Array[SignalName], ?default: SignalName | Array[SignalName]) -> self
+		alias signal_default= signal_mask=
+
+		# Misc
+		type ResourceName = String | Symbol | Integer
+		def name: (String) -> self
+		attr_writer name: String
+		def args: (Array[String]) -> self
+		attr_writer args: Array[String]
+		def command: (String) -> self
+		attr_writer command: String
+
+		def rlimit: (ResourceName resource_type, Integer soft_limit, ?Integer hard_max) -> self
+		alias setrlimit rlimit
+
+		# Action items
+		def validate: () -> bool
+		def validate!: () -> TrueClass
+		def spawn!: () -> Integer
+		          
+		# class interface methods
+		def self.expand_which: (String, ?Hash[String, String]) -> Enumerable[String]
+		                     | [T] (String, ?Hash[String, String]) { (String) -> T} -> T
+
+		def self.shell_command: (String) -> Array[String]
+
+		# Nested Types
+		class SigSet
+			# Builders
+			def self.empty: -> SigSet
+			def self.full: -> SigSet
+			def self.current: -> SigSet
+			def initialize: (?:current | :empty | :full base) -> nil
+
+			# Modifiers
+			def include: (*(SignalName | Array[SignalName]) signals) -> self
+			def exclude: (*(SignalName | Array[SignalName]) signals) -> self
+			alias - exclude
+			alias + include
+			alias add exclude
+			alias del include
+			alias delete include
+
+			# Output (library use only)
+			def to_ptr: [T] () {(FFI::MemoryPointer) -> T} -> T
+			             | () -> FFI::MemoryPointer
+		end
+	end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: subspawn-posix
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Patrick Plenefisch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi-bindings-libfixposix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+description: A SubSpawn subproject to wrap libfixposix as a mid level API
+email:
+- simonpatp@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- lib/subspawn/binary.rb
+- lib/subspawn/posix.rb
+- lib/subspawn/posix/ffi_helper.rb
+- lib/subspawn/posix/pty.rb
+- lib/subspawn/posix/signals.rb
+- lib/subspawn/posix/version.rb
+- sig/subspawn/posix.rbs
+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: SubSpawn Mid-level API for POSIX systems
+test_files: []