Fix typos througout the repo

Author: iCharlesHu

README.md

@@ -64,27 +64,17 @@ To have more precise control over input and output, you can provide a custom clo
 ```swift
 import Subprocess
 
-let result = try await run(
-    .path("/bin/dd"),
-    arguments: ["if=/path/to/document"]
-) { execution in
-    var contents = ""
-    for try await chunk in execution.standardOutput {
-        let string = chunk.withUnsafeBytes { String(decoding: $0, as: UTF8.self) }
-        contents += string
-        if string == "Done" {
-            // Stop execution
-            await execution.teardown(
-                using: [
-                    .gracefulShutDown(
-                        allowedDurationToNextStep: .seconds(0.5)
-                    )
-                ]
-            )
-            return contents
+// Monitor Nginx log via `tail -f`
+async let monitorResult = run(
+    .path("/usr/bin/tail"),
+    arguments: ["-f", "/path/to/nginx.log"]
+) { execution, standardOutput in
+    for try await line in standardOutput.lines(encoding: UTF8.self) {
+        // Parse the log text
+        if line.contains("500") {
+            // Oh no, 500 error
         }
     }
-    return contents
 }
 ```
 
@@ -240,10 +230,6 @@ This option collects output as `[UInt8]`.
 
 Use it by setting `.bytes` or `.bytes(limit:)` for `input` or `error`.
 
-#### `SequenceOutput`:
-
-This option redirects the child output to the `.standardOutput` or `.standardError` property of `Execution`. It’s only for the `run()` family that takes a custom closure.
-
 
 ### Cross-platform support
 

Sources/Subprocess/API.swift

@@ -143,7 +143,7 @@ public func run<
 // MARK: - Custom Execution Body
 
 /// Run an executable with given parameters and a custom closure
-/// to manage the running subprocess' lifetime and its IOs.
+/// to manage the running subprocess' lifetime and stream its standard output.
 /// - Parameters:
 ///   - executable: The executable to run.
 ///   - arguments: The arguments to pass to the executable.
@@ -155,7 +155,7 @@ public func run<
 ///   - error: How to manager executable standard error.
 ///   - isolation: the isolation context to run the body closure.
 ///   - body: The custom execution body to manually control the running process
-/// - Returns a ExecutableResult type containing the return value
+/// - Returns an executableResult type containing the return value
 ///     of the closure.
 public func run<Result, Input: InputProtocol, Error: OutputProtocol>(
     _ executable: Executable,
@@ -204,7 +204,7 @@ public func run<Result, Input: InputProtocol, Error: OutputProtocol>(
     }
 }
 
-/// Run a executable with given parameters and a custom closure
+/// Run an executable with given parameters and a custom closure
 /// to manage the running subprocess' lifetime and stream its standard error.
 /// - Parameters:
 ///   - executable: The executable to run.
@@ -217,7 +217,7 @@ public func run<Result, Input: InputProtocol, Error: OutputProtocol>(
 ///   - output: How to manager executable standard output.
 ///   - isolation: the isolation context to run the body closure.
 ///   - body: The custom execution body to manually control the running process
-/// - Returns a ExecutableResult type containing the return value
+/// - Returns an executableResult type containing the return value
 ///     of the closure.
 public func run<Result, Input: InputProtocol, Output: OutputProtocol>(
     _ executable: Executable,
@@ -266,7 +266,7 @@ public func run<Result, Input: InputProtocol, Output: OutputProtocol>(
     }
 }
 
-/// Run a executable with given parameters and a custom closure
+/// Run an executable with given parameters and a custom closure
 /// to manage the running subprocess' lifetime, write to its
 /// standard input, and stream its standard output.
 /// - Parameters:
@@ -279,7 +279,7 @@ public func run<Result, Input: InputProtocol, Output: OutputProtocol>(
 ///   - error: How to manager executable standard error.
 ///   - isolation: the isolation context to run the body closure.
 ///   - body: The custom execution body to manually control the running process
-/// - Returns a ExecutableResult type containing the return value
+/// - Returns an executableResult type containing the return value
 ///     of the closure.
 public func run<Result, Error: OutputProtocol>(
     _ executable: Executable,
@@ -311,7 +311,7 @@ public func run<Result, Error: OutputProtocol>(
     }
 }
 
-/// Run a executable with given parameters and a custom closure
+/// Run an executable with given parameters and a custom closure
 /// to manage the running subprocess' lifetime, write to its
 /// standard input, and stream its standard error.
 /// - Parameters:
@@ -324,7 +324,7 @@ public func run<Result, Error: OutputProtocol>(
 ///   - output: How to manager executable standard output.
 ///   - isolation: the isolation context to run the body closure.
 ///   - body: The custom execution body to manually control the running process
-/// - Returns a ExecutableResult type containing the return value
+/// - Returns an executableResult type containing the return value
 ///     of the closure.
 public func run<Result, Output: OutputProtocol>(
     _ executable: Executable,
@@ -356,7 +356,7 @@ public func run<Result, Output: OutputProtocol>(
     }
 }
 
-/// Run a executable with given parameters and a custom closure
+/// Run an executable with given parameters and a custom closure
 /// to manage the running subprocess' lifetime, write to its
 /// standard input, and stream its standard output and standard error.
 /// - Parameters:
@@ -368,7 +368,7 @@ public func run<Result, Output: OutputProtocol>(
 ///     when running the executable.
 ///   - isolation: the isolation context to run the body closure.
 ///   - body: The custom execution body to manually control the running process
-/// - Returns a ExecutableResult type containing the return value
+/// - Returns an executableResult type containing the return value
 ///     of the closure.
 public func run<Result>(
     _ executable: Executable,
@@ -411,7 +411,7 @@ public func run<Result>(
 
 // MARK: - Configuration Based
 
-/// Run a `Configuration` asynchrously and returns
+/// Run a `Configuration` asynchronously and returns
 /// a `CollectedResult` containing the output of the child process.
 /// - Parameters:
 ///   - configuration: The `Subprocess` configuration to run.
@@ -503,14 +503,14 @@ public func run<
     )
 }
 
-/// Run a executable with given parameters specified by a `Configuration`
+/// Run an executable with given parameters specified by a `Configuration`
 /// - Parameters:
 ///   - configuration: The `Subprocess` configuration to run.
 ///   - isolation: the isolation context to run the body closure.
 ///   - body: The custom configuration body to manually control
 ///       the running process, write to its standard input, stream
 ///       its standard output and standard error.
-/// - Returns a ExecutableResult type containing the return value
+/// - Returns an executableResult type containing the return value
 ///     of the closure.
 public func run<Result>(
     _ configuration: Configuration,
@@ -534,7 +534,7 @@ public func run<Result>(
 
 // MARK: - Detached
 
-/// Run a executable with given parameters and return its process
+/// Run an executable with given parameters and return its process
 /// identifier immediately without monitoring the state of the
 /// subprocess nor waiting until it exits.
 ///
@@ -571,7 +571,7 @@ public func runDetached(
     return try runDetached(config, input: input, output: output, error: error)
 }
 
-/// Run a executable with given configuration and return its process
+/// Run an executable with given configuration and return its process
 /// identifier immediately without monitoring the state of the
 /// subprocess nor waiting until it exits.
 ///

Sources/Subprocess/AsyncBufferSequence.swift

@@ -50,7 +50,7 @@ public struct AsyncBufferSequence: AsyncSequence, Sendable {
             let data = try await self.diskIO.read(
                 upToLength: readBufferSize
             )
-            guard let data = data else {
+            guard let data else {
                 // We finished reading. Close the file descriptor now
                 #if os(Windows)
                 try self.diskIO.close()
@@ -61,7 +61,7 @@ public struct AsyncBufferSequence: AsyncSequence, Sendable {
             }
             let createdBuffers = Buffer.createFrom(data)
             // Most (all?) cases there should be only one buffer
-            // because DispatchData are motsly contiguous
+            // because DispatchData are mostly contiguous
             if _fastPath(createdBuffers.count == 1) {
                 // No need to push to the stack
                 return createdBuffers[0]
@@ -139,7 +139,7 @@ extension AsyncBufferSequence {
                         )
                     }
                     #else
-                    // Unfortunitely here we _have to_ copy the bytes out because
+                    // Unfortunately here we _have to_ copy the bytes out because
                     // DisptachIO (rightfully) reuses buffer, which means `buffer.data`
                     // has the same address on all iterations, therefore we can't directly
                     // create the result array from buffer.data
@@ -238,7 +238,7 @@ extension AsyncBufferSequence {
                                 // For UTF8, look for the next 0x85 byte
                                 guard (targetIndex + 1) < self.buffer.count,
                                       self.buffer[targetIndex + 1] == Encoding.CodeUnit(0x85) else {
-                                    // Not a valid new ine. Keep looking
+                                    // Not a valid new line. Keep looking
                                     continue
                                 }
                                 // Swallow 0x85 byte
@@ -254,7 +254,7 @@ extension AsyncBufferSequence {
                                 // For UTF8, look for the next 0x80 byte
                                 guard (targetIndex + 1) < self.buffer.count,
                                       self.buffer[targetIndex + 1] == Encoding.CodeUnit(0x80) else {
-                                    // Not a valid new ine. Keep looking
+                                    // Not a valid new line. Keep looking
                                     continue
                                 }
                                 // Swallow 0x80 byte
@@ -263,7 +263,7 @@ extension AsyncBufferSequence {
                                 guard (targetIndex + 1) < self.buffer.count,
                                       (self.buffer[targetIndex + 1] == Encoding.CodeUnit(0xA8) ||
                                        self.buffer[targetIndex + 1] == Encoding.CodeUnit(0xA9)) else {
-                                    // Not a valid new ine. Keep looking
+                                    // Not a valid new line. Keep looking
                                     continue
                                 }
                                 // Swallow 0xA8 (or 0xA9) byte

Sources/Subprocess/Buffer.swift

@@ -78,7 +78,7 @@ extension AsyncBufferSequence.Buffer {
     }
 
     #if SubprocessSpan
-    // Access the storge backing this Buffer
+    // Access the storage backing this Buffer
     #if SubprocessSpan
     @available(SubprocessSpan, *)
     #endif
@@ -113,7 +113,7 @@ extension AsyncBufferSequence.Buffer: Equatable, Hashable {
 // MARK: - DispatchData.Block
 #if canImport(Darwin) || canImport(Glibc) || canImport(Android) || canImport(Musl)
 extension DispatchData {
-    /// Unfortunitely `DispatchData.Region` is not available on Linux, hence our own wrapper
+    /// Unfortunately `DispatchData.Region` is not available on Linux, hence our own wrapper
     internal struct Slice: @unchecked Sendable, RandomAccessCollection {
         typealias Element = UInt8
 

Sources/Subprocess/Configuration.swift

@@ -40,7 +40,7 @@ public struct Configuration: Sendable {
     public var environment: Environment
     /// The working directory to use when running the executable.
     public var workingDirectory: FilePath
-    /// The platform specifc options to use when
+    /// The platform specific options to use when
     /// running the subprocess.
     public var platformOptions: PlatformOptions
 
@@ -58,9 +58,6 @@ public struct Configuration: Sendable {
         self.platformOptions = platformOptions
     }
 
-    #if SubprocessSpan
-    @available(SubprocessSpan, *)
-    #endif
     internal func run<Result>(
         input: consuming CreatedPipe,
         output: consuming CreatedPipe,
@@ -134,7 +131,7 @@ extension Configuration: CustomStringConvertible, CustomDebugStringConvertible {
 extension Configuration {
     /// Close each input individually, and throw the first error if there's multiple errors thrown
     @Sendable
-    internal func safelyCloseMultuple(
+    internal func safelyCloseMultiple(
         inputRead: consuming TrackedFileDescriptor?,
         inputWrite: consuming TrackedFileDescriptor?,
         outputRead: consuming TrackedFileDescriptor?,
@@ -393,7 +390,7 @@ extension Environment: CustomStringConvertible, CustomDebugStringConvertible {
                 """
         case .inherit(let updateValue):
             return """
-                Inherting current environment with updates:
+                Inheriting current environment with updates:
                 \(updateValue)
                 """
         #if !os(Windows)
@@ -454,7 +451,7 @@ public enum TerminationStatus: Sendable, Hashable, Codable {
 
     /// The subprocess was existed with the given code
     case exited(Code)
-    /// The subprocess was signalled with given exception value
+    /// The subprocess was signaled with given exception value
     case unhandledException(Code)
     /// Whether the current TerminationStatus is successful.
     public var isSuccess: Bool {
@@ -485,9 +482,6 @@ extension TerminationStatus: CustomStringConvertible, CustomDebugStringConvertib
 // MARK: - Internal
 
 extension Configuration {
-    #if SubprocessSpan
-    @available(SubprocessSpan, *)
-    #endif
     /// After Spawn finishes, child side file descriptors
     /// (input read, output write, error write) will be closed
     /// by `spawn()`. It returns the parent side file descriptors
@@ -581,7 +575,7 @@ internal enum StringOrRawBytes: Sendable, Hashable {
 }
 
 /// A wrapped `FileDescriptor` and whether it should be closed
-/// automactially when done.
+/// automatically when done.
 internal struct TrackedFileDescriptor: ~Copyable {
     internal var closeWhenDone: Bool
     internal let fileDescriptor: FileDescriptor
@@ -667,7 +661,7 @@ internal struct TrackedFileDescriptor: ~Copyable {
 
 #if !os(Windows)
 /// A wrapped `DispatchIO` and whether it should be closed
-/// automactially when done.
+/// automatically when done.
 internal struct TrackedDispatchIO: ~Copyable {
     internal var closeWhenDone: Bool
     internal var dispatchIO: DispatchIO

Sources/Subprocess/Execution.swift

@@ -27,12 +27,9 @@ import Musl
 import WinSDK
 #endif
 
-/// An object that repersents a subprocess that has been
+/// An object that represents a subprocess that has been
 /// executed. You can use this object to send signals to the
 /// child process as well as stream its output and error.
-#if SubprocessSpan
-@available(SubprocessSpan, *)
-#endif
 public struct Execution: Sendable {
     /// The process identifier of the current execution
     public let processIdentifier: ProcessIdentifier

Sources/Subprocess/IO/Input.swift

@@ -53,7 +53,7 @@ public struct NoInput: InputProtocol {
             writeFileDescriptor: nil
         )
         #else
-        let devnull: FileDescriptor = try .openDevNull(withAcessMode: .readOnly)
+        let devnull: FileDescriptor = try .openDevNull(withAccessMode: .readOnly)
         return CreatedPipe(
             readFileDescriptor: .init(devnull, closeWhenDone: true),
             writeFileDescriptor: nil
@@ -147,7 +147,7 @@ internal struct CustomWriteInput: InputProtocol {
 }
 
 extension InputProtocol where Self == NoInput {
-    /// Create a Subprocess input that specfies there is no input
+    /// Create a Subprocess input that specifies there is no input
     public static var none: Self { .init() }
 }