Remove interrupt package and make app not depend on other private/pkg packages (#3827)

Author: bufdev

go.mod

@@ -10,6 +10,7 @@ require (
 	buf.build/gen/go/bufbuild/registry/connectrpc/go v1.18.1-20250424215339-a457693b5db4.1
 	buf.build/gen/go/bufbuild/registry/protocolbuffers/go v1.36.6-20250424215339-a457693b5db4.1
 	buf.build/go/bufplugin v0.9.0
+	buf.build/go/interrupt v1.1.0
 	buf.build/go/protovalidate v0.12.0
 	buf.build/go/protoyaml v0.6.0
 	buf.build/go/spdx v0.2.0

go.sum

@@ -10,6 +10,8 @@ buf.build/gen/go/pluginrpc/pluginrpc/protocolbuffers/go v1.36.6-20241007202033-c
 buf.build/gen/go/pluginrpc/pluginrpc/protocolbuffers/go v1.36.6-20241007202033-cf42259fcbfc.1/go.mod h1:OUbhXurY+VHFGn9FBxcRy8UB7HXk9NvJ2qCgifOMypQ=
 buf.build/go/bufplugin v0.9.0 h1:ktZJNP3If7ldcWVqh46XKeiYJVPxHQxCfjzVQDzZ/lo=
 buf.build/go/bufplugin v0.9.0/go.mod h1:Z0CxA3sKQ6EPz/Os4kJJneeRO6CjPeidtP1ABh5jPPY=
+buf.build/go/interrupt v1.1.0 h1:olBuhgv9Sav4/9pkSLoxgiOsZDgM5VhRhvRpn3DL0lE=
+buf.build/go/interrupt v1.1.0/go.mod h1:ql56nXPG1oHlvZa6efNC7SKAQ/tUjS6z0mhJl0gyeRM=
 buf.build/go/protovalidate v0.12.0 h1:4GKJotbspQjRCcqZMGVSuC8SjwZ/FmgtSuKDpKUTZew=
 buf.build/go/protovalidate v0.12.0/go.mod h1:q3PFfbzI05LeqxSwq+begW2syjy2Z6hLxZSkP1OH/D0=
 buf.build/go/protoyaml v0.6.0 h1:Nzz1lvcXF8YgNZXk+voPPwdU8FjDPTUV4ndNTXN0n2w=

private/pkg/app/app.go

@@ -34,7 +34,7 @@ import (
 	"sort"
 	"strconv"
 
-	"github.com/bufbuild/buf/private/pkg/interrupt"
+	"buf.build/go/interrupt"
 )
 
 // EnvContainer provides environment variables.

private/pkg/app/appcmd/appcmdtesting/appcmdtesting.go

@@ -27,8 +27,6 @@ import (
 
 	"github.com/bufbuild/buf/private/pkg/app"
 	"github.com/bufbuild/buf/private/pkg/app/appcmd"
-	"github.com/bufbuild/buf/private/pkg/slicesext"
-	"github.com/bufbuild/buf/private/pkg/stringutil"
 	"github.com/stretchr/testify/require"
 )
 
@@ -117,16 +115,16 @@ func Run(
 	if runOptions.expectedStdoutPresent {
 		require.Equal(
 			t,
-			stringutil.TrimLines(runOptions.expectedStdout),
-			stringutil.TrimLines(stdoutBuffer.String()),
+			trimLines(runOptions.expectedStdout),
+			trimLines(stdoutBuffer.String()),
 			requireErrorMessage(runOptions.args, stdoutBuffer, stderrBuffer),
 		)
 	}
 	if runOptions.expectedStderrPresent {
 		require.Equal(
 			t,
-			stringutil.TrimLines(runOptions.expectedStderr),
-			stringutil.TrimLines(stderrBuffer.String()),
+			trimLines(runOptions.expectedStderr),
+			trimLines(stderrBuffer.String()),
 			requireErrorMessage(runOptions.args, stdoutBuffer, stderrBuffer),
 		)
 	}
@@ -245,23 +243,37 @@ func WithExpectedExitCodes(expectedExitCodes ...int) RunOption {
 // *** PRIVATE ***
 
 func requireErrorMessage(args []string, stdout *bytes.Buffer, stderr *bytes.Buffer) string {
+	quotedArgs := make([]string, len(args))
+	for i, arg := range args {
+		// To make the args copy-pastable.
+		quotedArgs[i] = `'` + arg + `'`
+	}
 	return fmt.Sprintf(
 		"args: %s\nstdout: %s\nstderr: %s",
-		strings.Join(
-			slicesext.Map(
-				args,
-				// To make the args copy-pastable.
-				func(arg string) string {
-					return `'` + arg + `'`
-				},
-			),
-			" ",
-		),
-		stringutil.TrimLines(stdout.String()),
-		stringutil.TrimLines(stderr.String()),
+		strings.Join(quotedArgs, " "),
+		trimLines(stdout.String()),
+		trimLines(stderr.String()),
 	)
 }
 
+// trimLines splits the output into individual lines and trims the spaces from each line.
+//
+// This also trims the start and end spaces from the original output.
+func trimLines(output string) string {
+	return strings.TrimSpace(strings.Join(splitTrimLines(output), "\n"))
+}
+
+// splitTrimLines splits the output into individual lines and trims the spaces from each line.
+func splitTrimLines(output string) []string {
+	// this should work for windows as well as \r will be trimmed
+	split := strings.Split(output, "\n")
+	lines := make([]string, len(split))
+	for i, line := range split {
+		lines[i] = strings.TrimSpace(line)
+	}
+	return lines
+}
+
 type runOptions struct {
 	newEnv                        func(use string) map[string]string
 	stdin                         io.Reader

private/pkg/app/appext/appext.go

@@ -16,6 +16,7 @@
 package appext
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -26,8 +27,8 @@ import (
 	"time"
 
 	"github.com/bufbuild/buf/private/pkg/app"
-	"github.com/bufbuild/buf/private/pkg/encoding"
 	"github.com/spf13/pflag"
+	"gopkg.in/yaml.v3"
 )
 
 const (
@@ -167,7 +168,7 @@ func ReadConfig(container NameContainer, value any) error {
 		if err != nil {
 			return fmt.Errorf("could not read %s configuration file at %s: %w", container.AppName(), configFilePath, err)
 		}
-		if err := encoding.UnmarshalYAMLStrict(data, value); err != nil {
+		if err := unmarshalYAMLStrict(data, value); err != nil {
 			return fmt.Errorf("invalid %s configuration file: %w", container.AppName(), err)
 		}
 	}
@@ -186,7 +187,7 @@ func ReadConfigNonStrict(container NameContainer, value any) error {
 		if err != nil {
 			return fmt.Errorf("could not read %s configuration file at %s: %w", container.AppName(), configFilePath, err)
 		}
-		if err := encoding.UnmarshalYAMLNonStrict(data, value); err != nil {
+		if err := unmarshalYAMLNonStrict(data, value); err != nil {
 			return fmt.Errorf("invalid %s configuration file: %w", container.AppName(), err)
 		}
 	}
@@ -210,7 +211,7 @@ func ReadSecret(container NameContainer, name string) (string, error) {
 // The directory is created if it does not exist.
 // The value should be a pointer to marshal.
 func WriteConfig(container NameContainer, value any) error {
-	data, err := encoding.MarshalYAML(value)
+	data, err := marshalYAML(value)
 	if err != nil {
 		return err
 	}
@@ -239,3 +240,48 @@ func Listen(ctx context.Context, container NameContainer, defaultPort uint16) (n
 	var listenConfig net.ListenConfig
 	return listenConfig.Listen(ctx, "tcp", fmt.Sprintf("0.0.0.0:%d", port))
 }
+
+// *** PRIVATE ***
+
+// marshalYAML marshals the given value into YAML.
+func marshalYAML(v any) (_ []byte, retErr error) {
+	buffer := bytes.NewBuffer(nil)
+	yamlEncoder := yaml.NewEncoder(buffer)
+	yamlEncoder.SetIndent(2)
+	defer func() {
+		retErr = errors.Join(retErr, yamlEncoder.Close())
+	}()
+	if err := yamlEncoder.Encode(v); err != nil {
+		return nil, err
+	}
+	return buffer.Bytes(), nil
+}
+
+// unmarshalYAMLStrict unmarshals the data as YAML, returning a user error on failure.
+//
+// If the data length is 0, this is a no-op.
+func unmarshalYAMLStrict(data []byte, v any) error {
+	if len(data) == 0 {
+		return nil
+	}
+	yamlDecoder := yaml.NewDecoder(bytes.NewReader(data))
+	yamlDecoder.KnownFields(true)
+	if err := yamlDecoder.Decode(v); err != nil {
+		return fmt.Errorf("could not unmarshal as YAML: %v", err)
+	}
+	return nil
+}
+
+// unmarshalYAMLNonStrict unmarshals the data as YAML, returning a user error on failure.
+//
+// If the data length is 0, this is a no-op.
+func unmarshalYAMLNonStrict(data []byte, v any) error {
+	if len(data) == 0 {
+		return nil
+	}
+	yamlDecoder := yaml.NewDecoder(bytes.NewReader(data))
+	if err := yamlDecoder.Decode(v); err != nil {
+		return fmt.Errorf("could not unmarshal as YAML: %v", err)
+	}
+	return nil
+}

private/pkg/interrupt/usage.gen.go private/pkg/app/discard_reader.goprivate/pkg/interrupt/usage.gen.go renamed to private/pkg/app/discard_reader.go

@@ -12,8 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Generated. DO NOT EDIT.
+package app
 
-package interrupt
+import (
+	"io"
+)
 
-import _ "github.com/bufbuild/buf/private/usage"
+type discardReader struct{}
+
+func (discardReader) Read([]byte) (int, error) {
+	return 0, io.EOF
+}

private/pkg/interrupt/interrupt_unix.go private/pkg/app/locked_writer.goprivate/pkg/interrupt/interrupt_unix.go renamed to private/pkg/app/locked_writer.go

@@ -12,17 +12,25 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build unix
-
-package interrupt
+package app
 
 import (
-	"os"
-	"syscall"
+	"io"
+	"sync"
 )
 
-// Signals are all interrupt signals.
-//
-// As opposed to os.Interrupt, this adds syscall.SIGTERM for unix-like platforms. For
-// other platforms, this is just os.Interrupt
-var Signals = []os.Signal{os.Interrupt, syscall.SIGTERM}
+type lockedWriter struct {
+	writer io.Writer
+	lock   sync.Mutex
+}
+
+func newLockedWriter(writer io.Writer) *lockedWriter {
+	return &lockedWriter{writer: writer}
+}
+
+func (l *lockedWriter) Write(p []byte) (int, error) {
+	l.lock.Lock()
+	n, err := l.writer.Write(p)
+	l.lock.Unlock()
+	return n, err
+}

private/pkg/app/stderr_container.go

@@ -16,8 +16,6 @@ package app
 
 import (
 	"io"
-
-	"github.com/bufbuild/buf/private/pkg/ioext"
 )
 
 type stderrContainer struct {
@@ -29,7 +27,7 @@ func newStderrContainer(writer io.Writer) *stderrContainer {
 		writer = io.Discard
 	}
 	return &stderrContainer{
-		writer: ioext.LockedWriter(writer),
+		writer: newLockedWriter(writer),
 	}
 }
 

private/pkg/app/stdin_container.go

@@ -16,8 +16,6 @@ package app
 
 import (
 	"io"
-
-	"github.com/bufbuild/buf/private/pkg/ioext"
 )
 
 type stdinContainer struct {
@@ -26,7 +24,7 @@ type stdinContainer struct {
 
 func newStdinContainer(reader io.Reader) *stdinContainer {
 	if reader == nil {
-		reader = ioext.DiscardReader
+		reader = discardReader{}
 	}
 	return &stdinContainer{
 		reader: reader,

private/pkg/app/stdout_container.go

@@ -16,8 +16,6 @@ package app
 
 import (
 	"io"
-
-	"github.com/bufbuild/buf/private/pkg/ioext"
 )
 
 type stdoutContainer struct {
@@ -29,7 +27,7 @@ func newStdoutContainer(writer io.Writer) *stdoutContainer {
 		writer = io.Discard
 	}
 	return &stdoutContainer{
-		writer: ioext.LockedWriter(writer),
+		writer: newLockedWriter(writer),
 	}
 }