feat(pee): Add all flags and improve early exit behavior

Author: gabe565

README.md

@@ -165,5 +165,4 @@ My goal is 100% compatability, but there are currently some differences compared
 | **isutf8**   | Unlike moreutils, which prints the expected value range for non-UTF-8 files, the rewrite only logs the offending line, byte, and char.                                                                                                                                 |
 | **lckdo**    | Deprecated in moreutils and intentionally not implemented here. It is recommended to use `flock` as a replacement.                                                                                                                                                     |
 | **parallel** | The `-l` flag is not yet supported. Also note parallel is not symlinked by default since [GNU Parallel](https://www.gnu.org/software/parallel/) is typically preferred.                                                                                                |
-| **pee**      | The flags `--no-ignore-sigpipe` and `--no-ignore-write-errors` are not yet supported.                                                                                                                                                                                  |
 | **ts**       | The flags `-r`, `-i`, and `-s` are not yet supported. The `-m` flag will trigger a deprecation warning since Go always uses the system's monotonic clock.                                                                                                              |

cmd/pee/pee.go

@@ -3,16 +3,23 @@ package pee
 import (
 	"io"
 	"os/exec"
+	"os/signal"
+	"sync"
+	"syscall"
 
 	"github.com/gabe565/moreutils/internal/cmdutil"
 	"github.com/gabe565/moreutils/internal/util"
 	"github.com/spf13/cobra"
+	flag "github.com/spf13/pflag"
 )
 
 const (
-	Name                  = "pee"
-	FlagIgnoreSigpipe     = "ignore-sigpipe"
-	FlagIgnoreWriteErrors = "ignore-write-errors"
+	Name = "pee"
+
+	FlagIgnoreSigpipe       = "ignore-sigpipe"
+	FlagNoIgnoreSigpipe     = "no-ignore-sigpipe"
+	FlagIgnoreWriteErrors   = "ignore-write-errors"
+	FlagNoIgnoreWriteErrors = "no-ignore-write-errors"
 )
 
 func New(opts ...cmdutil.Option) *cobra.Command {
@@ -24,8 +31,10 @@ func New(opts ...cmdutil.Option) *cobra.Command {
 		GroupID: cmdutil.Applet,
 	}
 
-	cmd.Flags().Bool(FlagIgnoreSigpipe, true, "Ignores sigpipe")
-	cmd.Flags().Bool(FlagIgnoreWriteErrors, true, "Ignores write errors")
+	cmd.Flags().Bool(FlagIgnoreSigpipe, true, "")
+	cmd.Flags().Bool(FlagIgnoreWriteErrors, true, "")
+	cmd.Flags().Bool(FlagNoIgnoreSigpipe, false, "Do not ignore write errors")
+	cmd.Flags().Bool(FlagNoIgnoreWriteErrors, false, "Do not ignore SIGPIPE errors")
 	if err := cmd.Flags().MarkHidden(FlagIgnoreSigpipe); err != nil {
 		panic(err)
 	}
@@ -42,9 +51,26 @@ func New(opts ...cmdutil.Option) *cobra.Command {
 func run(cmd *cobra.Command, args []string) error {
 	cmd.SilenceUsage = true
 
+	ignoreSigpipe, ignoreWriteErrs := true, true
+	cmd.Flags().Visit(func(f *flag.Flag) {
+		switch f.Name {
+		case FlagIgnoreSigpipe:
+			ignoreSigpipe = true
+		case FlagNoIgnoreSigpipe:
+			ignoreSigpipe = false
+		case FlagIgnoreWriteErrors:
+			ignoreWriteErrs = true
+		case FlagNoIgnoreWriteErrors:
+			ignoreWriteErrs = false
+		}
+	})
+
+	if ignoreSigpipe {
+		signal.Ignore(syscall.SIGPIPE)
+	}
+
 	cmds := make([]*exec.Cmd, 0, len(args))
 	pipes := make([]io.Writer, 0, len(args))
-	pipeClosers := make([]io.WriteCloser, 0, len(args))
 	var errs []error
 	for _, arg := range args {
 		e := exec.Command("sh", "-c", arg)
@@ -60,22 +86,47 @@ func run(cmd *cobra.Command, args []string) error {
 		}
 
 		cmds = append(cmds, e)
-		pipes = append(pipes, util.NewSuppressErrorWriter(stdin))
-		pipeClosers = append(pipeClosers, stdin)
+		if ignoreWriteErrs {
+			pipes = append(pipes, util.NewSuppressErrorWriter(stdin))
+		} else {
+			pipes = append(pipes, stdin)
+		}
 	}
 
-	if _, err := io.Copy(io.MultiWriter(pipes...), cmd.InOrStdin()); err != nil {
-		return err
-	}
+	var mu sync.Mutex
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
 
-	for i, e := range cmds {
-		if err := pipeClosers[i].Close(); err != nil {
-			errs = append(errs, err)
+		// Wait for all commands to exit
+		for _, e := range cmds {
+			if err := e.Wait(); err != nil {
+				mu.Lock()
+				errs = append(errs, err)
+				mu.Unlock()
+			}
+		}
+
+		// Close pipes
+		for _, pipe := range pipes {
+			_ = pipe.(io.Closer).Close()
 		}
-		if err := e.Wait(); err != nil {
+	}()
+
+	if _, err := io.Copy(io.MultiWriter(pipes...), cmd.InOrStdin()); err != nil {
+		mu.Lock()
+		if ignoreWriteErrs {
+			errs = append(errs, util.NewExitCodeError(1))
+		} else {
 			errs = append(errs, err)
 		}
+		mu.Unlock()
+	}
+	for _, pipe := range pipes {
+		_ = pipe.(io.Closer).Close()
 	}
 
+	wg.Wait()
 	return util.JoinErrors(errs...)
 }

docs/pee.md

@@ -9,8 +9,10 @@ pee command... [flags]
 ### Options
 
 ```
-  -h, --help      help for pee
-  -v, --version   version for pee
+  -h, --help                     help for pee
+      --no-ignore-sigpipe        Do not ignore write errors
+      --no-ignore-write-errors   Do not ignore SIGPIPE errors
+  -v, --version                  version for pee
 ```
 
 ### SEE ALSO

internal/util/errors.go

@@ -3,6 +3,7 @@ package util
 import (
 	"errors"
 	"slices"
+	"strconv"
 )
 
 var ErrNotAPipe = errors.New("this command should be run in a pipe")
@@ -21,3 +22,19 @@ func JoinErrors(errs ...error) error {
 		return errors.Join(errs...)
 	}
 }
+
+func NewExitCodeError(code int) error {
+	return &ExitCodeError{code}
+}
+
+type ExitCodeError struct {
+	code int
+}
+
+func (e ExitCodeError) Error() string {
+	return "exit code " + strconv.Itoa(e.code)
+}
+
+func (e ExitCodeError) ExitCode() int {
+	return e.code
+}

internal/util/io.go

@@ -1,6 +1,10 @@
 package util
 
-import "io"
+import (
+	"io"
+	"sync"
+	"syscall"
+)
 
 func NewSuppressErrorWriter(w io.Writer) *SuppressErrorWriter {
 	return &SuppressErrorWriter{w: w}
@@ -9,17 +13,43 @@ func NewSuppressErrorWriter(w io.Writer) *SuppressErrorWriter {
 // SuppressErrorWriter proxies writes to another writer.
 // If a write returns an error, the error will be suppressed and the writer will be disabled.
 type SuppressErrorWriter struct {
-	w     io.Writer
-	Error error
+	w      io.Writer
+	closed bool
+	mu     sync.Mutex
+	Error  error
 }
 
 func (w *SuppressErrorWriter) Write(p []byte) (int, error) {
-	if w.Error == nil {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	switch {
+	case w.closed:
+		if w.Error != nil {
+			return 0, w.Error
+		}
+		return 0, syscall.EPIPE
+	case w.Error == nil:
 		_, w.Error = w.w.Write(p)
 	}
 	return len(p), nil
 }
 
 func (w *SuppressErrorWriter) Reset() {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	w.closed = false
 	w.Error = nil
 }
+
+func (w *SuppressErrorWriter) Close() error {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	w.closed = true
+	if closer, ok := w.w.(io.Closer); ok {
+		return closer.Close()
+	}
+	return nil
+}

main.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/gabe565/moreutils/cmd"
 	"github.com/gabe565/moreutils/internal/cmdutil"
+	"github.com/gabe565/moreutils/internal/util"
 )
 
 var version = "beta"
@@ -19,6 +20,12 @@ func main() {
 		if errors.As(err, &execErr) {
 			os.Exit(execErr.ExitCode())
 		}
+
+		var exitCodeErr *util.ExitCodeError
+		if errors.As(err, &exitCodeErr) {
+			os.Exit(exitCodeErr.ExitCode())
+		}
+
 		root.PrintErrln(root.ErrPrefix(), err.Error())
 		os.Exit(1)
 	}