cli/streams: don't depend on embedding

Define explicit wrapper methods instead of depending on the embedded
commonStreams struct.

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

Author: thaJeztah

cli/streams/in.go

@@ -11,15 +11,21 @@ import (
 // In is an input stream to read user input. It implements [io.ReadCloser]
 // with additional utilities, such as putting the terminal in raw mode.
 type In struct {
-	commonStream
 	in io.ReadCloser
+	cs commonStream
 }
 
 // NewIn returns a new [In] from an [io.ReadCloser].
 func NewIn(in io.ReadCloser) *In {
-	i := &In{in: in}
-	i.fd, i.isTerminal = term.GetFdInfo(in)
-	return i
+	return &In{
+		in: in,
+		cs: newCommonStream(in),
+	}
+}
+
+// FD returns the file descriptor number for this stream.
+func (i *In) FD() uintptr {
+	return i.cs.fd
 }
 
 // Read implements the [io.Reader] interface.
@@ -32,11 +38,21 @@ func (i *In) Close() error {
 	return i.in.Close()
 }
 
+// IsTerminal returns whether this stream is connected to a terminal.
+func (i *In) IsTerminal() bool {
+	return i.cs.isTerminal()
+}
+
 // SetRawTerminal sets raw mode on the input terminal. It is a no-op if In
 // is not a TTY, or if the "NORAW" environment variable is set to a non-empty
 // value.
 func (i *In) SetRawTerminal() error {
-	return i.setRawTerminal(term.SetRawTerminal)
+	return i.cs.setRawTerminal(term.SetRawTerminal)
+}
+
+// RestoreTerminal restores the terminal state if SetRawTerminal succeeded earlier.
+func (i *In) RestoreTerminal() {
+	i.cs.restoreTerminal()
 }
 
 // CheckTty checks if we are trying to attach to a container TTY
@@ -45,7 +61,7 @@ func (i *In) CheckTty(attachStdin, ttyMode bool) error {
 	// In order to attach to a container tty, input stream for the client must
 	// be a tty itself: redirecting or piping the client standard input is
 	// incompatible with `docker run -t`, `docker exec -t` or `docker attach`.
-	if ttyMode && attachStdin && !i.isTerminal {
+	if ttyMode && attachStdin && !i.cs.isTerminal() {
 		const eText = "the input device is not a TTY"
 		if runtime.GOOS == "windows" {
 			return errors.New(eText + ".  If you are using mintty, try prefixing the command with 'winpty'")
@@ -54,3 +70,10 @@ func (i *In) CheckTty(attachStdin, ttyMode bool) error {
 	}
 	return nil
 }
+
+// SetIsTerminal overrides whether a terminal is connected. It is used to
+// override this property in unit-tests, and should not be depended on for
+// other purposes.
+func (i *In) SetIsTerminal(isTerminal bool) {
+	i.cs.setIsTerminal(isTerminal)
+}

cli/streams/out.go

@@ -4,50 +4,63 @@ import (
 	"io"
 
 	"github.com/moby/term"
-	"github.com/sirupsen/logrus"
 )
 
 // Out is an output stream to write normal program output. It implements
 // an [io.Writer], with additional utilities for detecting whether a terminal
 // is connected, getting the TTY size, and putting the terminal in raw mode.
 type Out struct {
-	commonStream
 	out io.Writer
+	cs  commonStream
 }
 
 // NewOut returns a new [Out] from an [io.Writer].
 func NewOut(out io.Writer) *Out {
-	o := &Out{out: out}
-	o.fd, o.isTerminal = term.GetFdInfo(out)
-	return o
+	return &Out{
+		out: out,
+		cs:  newCommonStream(out),
+	}
+}
+
+// FD returns the file descriptor number for this stream.
+func (o *Out) FD() uintptr {
+	return o.cs.FD()
 }
 
+// Write writes to the output stream.
 func (o *Out) Write(p []byte) (int, error) {
 	return o.out.Write(p)
 }
 
+// IsTerminal returns whether this stream is connected to a terminal.
+func (o *Out) IsTerminal() bool {
+	return o.cs.isTerminal()
+}
+
 // SetRawTerminal puts the output of the terminal connected to the stream
 // into raw mode.
 //
 // On UNIX, this does nothing. On Windows, it disables LF -> CRLF/ translation.
 // It is a no-op if Out is not a TTY, or if the "NORAW" environment variable is
 // set to a non-empty value.
 func (o *Out) SetRawTerminal() error {
-	return o.setRawTerminal(term.SetRawTerminalOutput)
+	return o.cs.setRawTerminal(term.SetRawTerminalOutput)
+}
+
+// RestoreTerminal restores the terminal state if SetRawTerminal succeeded earlier.
+func (o *Out) RestoreTerminal() {
+	o.cs.restoreTerminal()
 }
 
 // GetTtySize returns the height and width in characters of the TTY, or
 // zero for both if no TTY is connected.
 func (o *Out) GetTtySize() (height uint, width uint) {
-	if !o.isTerminal {
-		return 0, 0
-	}
-	ws, err := term.GetWinsize(o.fd)
-	if err != nil {
-		logrus.WithError(err).Debug("Error getting TTY size")
-		if ws == nil {
-			return 0, 0
-		}
-	}
-	return uint(ws.Height), uint(ws.Width)
+	return o.cs.terminalSize()
+}
+
+// SetIsTerminal overrides whether a terminal is connected. It is used to
+// override this property in unit-tests, and should not be depended on for
+// other purposes.
+func (o *Out) SetIsTerminal(isTerminal bool) {
+	o.cs.setIsTerminal(isTerminal)
 }

cli/streams/stream.go

@@ -4,33 +4,41 @@ import (
 	"os"
 
 	"github.com/moby/term"
+	"github.com/sirupsen/logrus"
 )
 
+func newCommonStream(stream any) commonStream {
+	fd, tty := term.GetFdInfo(stream)
+	return commonStream{
+		fd:  fd,
+		tty: tty,
+	}
+}
+
 type commonStream struct {
-	fd         uintptr
-	isTerminal bool
-	state      *term.State
+	fd    uintptr
+	tty   bool
+	state *term.State
 }
 
 // FD returns the file descriptor number for this stream.
-func (s *commonStream) FD() uintptr {
-	return s.fd
-}
+func (s *commonStream) FD() uintptr { return s.fd }
 
-// IsTerminal returns true if this stream is connected to a terminal.
-func (s *commonStream) IsTerminal() bool {
-	return s.isTerminal
-}
+// isTerminal returns whether this stream is connected to a terminal.
+func (s *commonStream) isTerminal() bool { return s.tty }
 
-// RestoreTerminal restores the terminal state if SetRawTerminal succeeded earlier.
-func (s *commonStream) RestoreTerminal() {
+// setIsTerminal overrides whether a terminal is connected for testing.
+func (s *commonStream) setIsTerminal(isTerminal bool) { s.tty = isTerminal }
+
+// restoreTerminal restores the terminal state if SetRawTerminal succeeded earlier.
+func (s *commonStream) restoreTerminal() {
 	if s.state != nil {
 		_ = term.RestoreTerminal(s.fd, s.state)
 	}
 }
 
 func (s *commonStream) setRawTerminal(setter func(uintptr) (*term.State, error)) error {
-	if !s.isTerminal || os.Getenv("NORAW") != "" {
+	if !s.tty || os.Getenv("NORAW") != "" {
 		return nil
 	}
 	state, err := setter(s.fd)
@@ -41,9 +49,16 @@ func (s *commonStream) setRawTerminal(setter func(uintptr) (*term.State, error))
 	return nil
 }
 
-// SetIsTerminal overrides whether a terminal is connected. It is used to
-// override this property in unit-tests, and should not be depended on for
-// other purposes.
-func (s *commonStream) SetIsTerminal(isTerminal bool) {
-	s.isTerminal = isTerminal
+func (s *commonStream) terminalSize() (height uint, width uint) {
+	if !s.tty {
+		return 0, 0
+	}
+	ws, err := term.GetWinsize(s.fd)
+	if err != nil {
+		logrus.WithError(err).Debug("Error getting TTY size")
+		if ws == nil {
+			return 0, 0
+		}
+	}
+	return uint(ws.Height), uint(ws.Width)
 }