um/pipe/pipe.go

package pipe

import (
	"errors"
	"fmt"
	"io"
	"log"
	"os"
	"strings"
)

const Newline string = "\n"

func isStdinLoaded() bool {
	stat, _ := os.Stdin.Stat()
	return (stat.Mode() & os.ModeCharDevice) == 0
}

func GetStdin() ([]string, error) {
	if !isStdinLoaded() {
		return nil, errors.New("stdin not loaded")
	}
	dat, err := io.ReadAll(os.Stdin)
	if err != nil {
		log.Fatal(err)
	}
	// TODO: there's got to be a better way:
	s := strings.TrimSuffix(string(dat), Newline)
	return strings.Split(s, Newline), nil
}

// reads files from stdin if present, otherwise just returns the glob:
func GlobOrStdin(glob []string) ([]string, error) {
	filelist, err := GetStdin()
	if err != nil {
		if glob == nil || len(glob) == 0 {
			return nil, fmt.Errorf("glob is empty")
		}
		return glob, nil
	}
	return filelist, nil
}

// reads files from stdin if present, otherwise reads content from files in glob and assembles into a list.
func FileListFromGlobOrStdin(glob []string) ([]string, error) {
	filelist, err := GetStdin()
	if err != nil {
		for _, f := range glob {
			// TODO: don't see a neater way of wrapping these two when we depend on the non-nil in this block:
			// if i just return FileListSplit(), we lose the first err
			fl, err2 := FileListSplit(f)
			if err2 != nil {
				return nil, fmt.Errorf("%w: %w", err, err2)
			}
			filelist = append(filelist, fl...)
		}
		return filelist, nil
	}
	return filelist, nil
}

// opens the given filename and splits into lines:
func FileListSplit(f string) ([]string, error) {
	if f == "" {
		return nil, errors.New("filename is empty")
	}
	dat, err := os.ReadFile(f)
	if err != nil {
		return nil, fmt.Errorf("error opening file: %w", err)
	}
	s := strings.TrimSuffix(string(dat), Newline)
	return strings.Split(s, Newline), nil
}