main.go

package main

import (
	"flag"
	"fmt"
	"os"
	"strings"
	"unicode"

	"github.com/elliotchance/pie/v2"
)

var (
	path         = flag.String("path", os.Getenv("PATH"), "PATH to add onto")
	pathFile     = flag.String("file", "~/.paths", "The location of your paths file")
	allowReverse = flag.Bool("allowReverse", false, "Read paths file in reverse")
	allowMissing = flag.Bool("allowMissing", true, "Add non-existent directories to PATH")
	allowInvalid = flag.Bool("allowInvalid", false, "Add invalid directories to PATH")
)

func main() {
	flag.Parse()

	homeDir, err := os.UserHomeDir()
	if err != nil {
		panic(err)
	}

	if s, ok := strings.CutPrefix(*pathFile, "~"); ok {
		*pathFile = homeDir + s
	}

	b, err := os.ReadFile(*pathFile)
	if err != nil {
		panic(err)
	}

	paths := make([]string, 0)
	validatePath := func(pathsNew []string) {
		for _, p := range pathsNew {
			p = os.ExpandEnv(p)
			p = strings.TrimSuffix(p, "/")

			if s, ok := strings.CutPrefix(p, "~"); ok {
				p = homeDir + s
			}

			if _, err := os.Stat(p); err != nil {
				if os.IsNotExist(err) { // file does not exist
					if !*allowMissing {
						continue
					}
				} else { // other error
					if !*allowInvalid {
						continue
					}
				}
			}

			if p == " " || len(p) == 0 {
				continue
			}

			if pie.Contains(paths, p) {
				continue
			}

			paths = pie.Insert(paths, 0, p)
		}
	}

	validatePath(processLines(string(b), *allowReverse))
	validatePath(pie.Reverse(strings.Split(*path, ":")))

	fmt.Printf(`export PATH="%s"`, strings.Join(paths, ":"))
}

func processLines(s string, r bool) []string {
	a := make([]string, 0)
	for _, p := range getReversed(strings.Split(s, "\n"), r) {
		a = append(a, strings.Split(p, ":")...)
	}

	return pie.FilterNot(a, func(f string) bool {
		if len(f) == 0 {
			return true
		}

		// This handles \n and \t cases as well
		// See Pattern_White_Space in https://www.unicode.org/reports/tr31/
		for _, c := range f {
			if !unicode.IsSpace(c) {
				return false
			}
		}

		return true
	})
}

func getReversed(s []string, r bool) []string {
	if !r {
		return s
	}

	return pie.Reverse(s)
}