375 lines
8.4 KiB
Go
375 lines
8.4 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
// ppsep is used as the replacement for slashes in path
|
|
// ex: ~/bin => ~bin
|
|
// ex: ~/bin => home~bin
|
|
// ex: ~/.local/opt/foo/bin => ~.local»opt»foo»bin
|
|
// other patterns considered:
|
|
// ~/.local/opt/foo/bin => ~.local·opt·foo·bin
|
|
// ~/.local/opt/foo/bin => home¬.local¬opt¬foo¬bin
|
|
// ~/.local/opt/foo/bin => home».local»opt»foo»bin
|
|
// ~/.local/opt/foo/bin => HOME•.local•opt•foo•bin
|
|
// ~/.local/opt/foo/bin => HOME_.local_opt_foo_bin
|
|
// ~/.local/opt/foo/bin => HOME·.local·opt·foo·bin
|
|
const ppsep = "-"
|
|
|
|
func usage() {
|
|
//fmt.Fprintf(os.Stderr, "Usage: envpath show|add|append|remove <path>\n")
|
|
fmt.Fprintf(os.Stderr, "Usage: envpath show|add|remove <path>\n")
|
|
}
|
|
|
|
func main() {
|
|
// TODO --system to add to the system PATH rather than the user PATH
|
|
|
|
// Usage:
|
|
if len(os.Args) < 2 {
|
|
usage()
|
|
os.Exit(1)
|
|
}
|
|
action := os.Args[1]
|
|
|
|
paths := Paths()
|
|
|
|
if "show" == action {
|
|
if len(os.Args) > 2 {
|
|
usage()
|
|
}
|
|
fmt.Println()
|
|
for i := range paths {
|
|
fmt.Println("\t" + paths[i])
|
|
}
|
|
fmt.Println()
|
|
return
|
|
}
|
|
|
|
if len(os.Args) < 3 {
|
|
usage()
|
|
os.Exit(1)
|
|
}
|
|
|
|
pathentry := os.Args[2]
|
|
if "remove" != action {
|
|
stat, err := os.Stat(pathentry)
|
|
if nil != err {
|
|
// TODO --force
|
|
fmt.Fprintf(os.Stderr, "%s\n", err)
|
|
os.Exit(2)
|
|
}
|
|
if !stat.IsDir() {
|
|
fmt.Fprintf(os.Stderr, "%q is not a directory (folder)\n", pathentry)
|
|
os.Exit(2)
|
|
}
|
|
}
|
|
|
|
switch action {
|
|
default:
|
|
usage()
|
|
os.Exit(1)
|
|
/*
|
|
case "append":
|
|
newpath, _, err := addPath(pathentry, appendOrder)
|
|
if nil != err {
|
|
fmt.Fprintf(os.Stderr, "%s\n", err)
|
|
return
|
|
}
|
|
fmt.Println("New sessions will have " + pathentry + " in their PATH.")
|
|
fmt.Println("To update this session run\n")
|
|
//fmt.Println("\tsource", pathfile)
|
|
fmt.Printf(`%sexport PATH="$PATH:%s"%s`, "\t", newpath, "\n")
|
|
*/
|
|
case "add":
|
|
_, pathfile, err := addPath(pathentry, prependOrder)
|
|
if nil != err {
|
|
fmt.Fprintf(os.Stderr, "%s\n", err)
|
|
return
|
|
}
|
|
fmt.Println("\nRun this command (or open a new shell) to finish:\n")
|
|
fmt.Printf("\tsource %s\n\n", pathfile)
|
|
//fmt.Printf(`%sexport PATH="%s:$PATH"%s`, "\t", newpath, "\n\n")
|
|
case "remove":
|
|
msg, err := removePath(pathentry)
|
|
if nil != err {
|
|
fmt.Fprintf(os.Stderr, "%s\n", err)
|
|
return
|
|
}
|
|
fmt.Println(msg)
|
|
}
|
|
}
|
|
|
|
// Paths returns the slice of PATHs from the Environment
|
|
func Paths() []string {
|
|
// ":" on *nix
|
|
return strings.Split(os.Getenv("PATH"), string(os.PathListSeparator))
|
|
}
|
|
|
|
type setOrder bool
|
|
|
|
const prependOrder setOrder = true
|
|
const appendOrder setOrder = false
|
|
|
|
// returns newpath, error
|
|
func addPath(oldpathentry string, order setOrder) (string, string, error) {
|
|
home, err := os.UserHomeDir()
|
|
if nil != err {
|
|
return "", "", err
|
|
}
|
|
home = filepath.ToSlash(home)
|
|
|
|
pathentry, fname, err := normalizeEntryAndFile(home, oldpathentry)
|
|
if nil != err {
|
|
return "", "", err
|
|
}
|
|
|
|
envpathd := filepath.Join(home, ".config/envpath/path.d")
|
|
err = os.MkdirAll(envpathd, 0755)
|
|
if nil != err {
|
|
return "", "", err
|
|
}
|
|
|
|
err = initializeShells(home)
|
|
if nil != err {
|
|
return "", "", err
|
|
}
|
|
|
|
nodes, err := ioutil.ReadDir(envpathd)
|
|
if nil != err {
|
|
return "", "", err
|
|
}
|
|
|
|
var priority int
|
|
if prependOrder == order {
|
|
// Counter-intuitively later PATHs, prepended are placed earlier
|
|
priority, err = getOrder(nodes, pathentry, fname, envpathd, sortForward)
|
|
} else {
|
|
// Counter-intuitively earlier PATHs are placed later
|
|
priority, err = getOrder(nodes, pathentry, fname, envpathd, sortBackward)
|
|
}
|
|
if nil != err {
|
|
return "", "", err
|
|
}
|
|
|
|
if index, ok := isInPath(home, pathentry); ok {
|
|
return "", "", fmt.Errorf(
|
|
"%q is in your PATH at position %d and must be removed manually to re-order\n",
|
|
pathentry,
|
|
index,
|
|
)
|
|
}
|
|
|
|
// ex: 100-opt»foo»bin.sh
|
|
// ex: 105-home»bar»bin.sh
|
|
pathfile := fmt.Sprintf("%03d-%s", priority, fname)
|
|
|
|
fullname := filepath.Join(envpathd, pathfile)
|
|
export := []byte(fmt.Sprintf("# Generated for envpath. Do not edit.\nexport PATH=\"%s:$PATH\"\n", pathentry))
|
|
err = ioutil.WriteFile(fullname, export, 0755)
|
|
if nil != err {
|
|
return "", "", err
|
|
}
|
|
// If we change from having the user source the path directory
|
|
// then we should uncomment this so the user knows where the path files are
|
|
//fmt.Printf("Wrote %s\n", fullname)
|
|
|
|
return pathentry, fullname, nil
|
|
}
|
|
|
|
func removePath(oldpathentry string) (string, error) {
|
|
home, err := os.UserHomeDir()
|
|
if nil != err {
|
|
return "", err
|
|
}
|
|
home = filepath.ToSlash(home)
|
|
|
|
pathentry, fname, err := normalizeEntryAndFile(home, oldpathentry)
|
|
if nil != err {
|
|
return "", err
|
|
}
|
|
|
|
envpathd := filepath.Join(home, ".config/envpath/path.d")
|
|
err = os.MkdirAll(envpathd, 0755)
|
|
if nil != err {
|
|
return "", err
|
|
}
|
|
|
|
nodes, err := ioutil.ReadDir(envpathd)
|
|
if nil != err {
|
|
return "", err
|
|
}
|
|
|
|
var fullname string
|
|
for i := range nodes {
|
|
node := nodes[i]
|
|
// 000-foo-bin.sh vs foo-bin.sh
|
|
if strings.HasSuffix(node.Name(), "-"+fname) {
|
|
if len(strings.Split(node.Name(), "-"))-1 == len(strings.Split(fname, "-")) {
|
|
fullname = node.Name()
|
|
}
|
|
}
|
|
}
|
|
|
|
paths := Paths()
|
|
index, exists := isInPath(home, pathentry)
|
|
|
|
if "" == fullname {
|
|
if exists {
|
|
return "", fmt.Errorf("%q is in your PATH, but is NOT managed by envpath", pathentry)
|
|
}
|
|
return "", fmt.Errorf("%q is NOT in your PATH, and NOT managed by envpath", pathentry)
|
|
}
|
|
|
|
err = os.Remove(filepath.Join(envpathd, fullname))
|
|
if nil != err {
|
|
return "", err
|
|
}
|
|
|
|
if !exists {
|
|
return fmt.Sprintf("Removed %s", filepath.Join(envpathd, fullname)), nil
|
|
}
|
|
|
|
newpaths := []string{}
|
|
for i := range paths {
|
|
if i == index {
|
|
continue
|
|
}
|
|
newpaths = append(newpaths, paths[i])
|
|
}
|
|
return fmt.Sprintf(
|
|
"Removed %s. To update the current shell re-export the new PATH:\n\n"+
|
|
"\texport PATH=%q\n",
|
|
fullname,
|
|
strings.Join(newpaths, ":"),
|
|
), nil
|
|
}
|
|
|
|
func isInPath(home, pathentry string) (int, bool) {
|
|
paths := Paths()
|
|
|
|
index := -1
|
|
for i := range paths {
|
|
entry, _ := normalizePathEntry(home, paths[i])
|
|
if pathentry == entry {
|
|
index = i
|
|
break
|
|
}
|
|
}
|
|
if index >= 0 {
|
|
return index, true
|
|
}
|
|
return -1, false
|
|
}
|
|
|
|
func normalizeEntryAndFile(home, pathentry string) (string, string, error) {
|
|
var err error
|
|
|
|
pathentry, err = normalizePathEntry(home, pathentry)
|
|
if nil != err {
|
|
return "", "", err
|
|
}
|
|
|
|
// Now we split and rejoin the paths as a unique name
|
|
// ex: /opt/foo/bin/ => opt/foo/bin => [opt foo bin]
|
|
// ex: ~/bar/bin/ => bar/bin => [bar bin]
|
|
names := strings.Split(strings.Trim(filepath.ToSlash(pathentry), "/"), "/")
|
|
if strings.HasPrefix(pathentry, "$HOME/") {
|
|
// ~/bar/bin/ => [home bar bin]
|
|
names[0] = "home"
|
|
}
|
|
|
|
// ex: /opt/foo/bin/ => opt»foo»bin.sh
|
|
fname := strings.Join(names, ppsep) + ".sh"
|
|
|
|
return pathentry, fname, nil
|
|
}
|
|
|
|
func normalizePathEntry(home, pathentry string) (string, error) {
|
|
var err error
|
|
|
|
// We add the slashes so that we don't get false matches
|
|
// ex: foo should match foo/bar, but should NOT match foobar
|
|
home, err = filepath.Abs(home)
|
|
if nil != err {
|
|
// I'm not sure how it's possible to get an error with Abs...
|
|
return "", err
|
|
}
|
|
home += "/"
|
|
pathentry, err = filepath.Abs(pathentry)
|
|
if nil != err {
|
|
return "", err
|
|
}
|
|
pathentry += "/"
|
|
|
|
// Next we make the path relative to / or ~/
|
|
// ex: /Users/me/.local/bin/ => .local/bin/
|
|
if strings.HasPrefix(pathentry, home) {
|
|
pathentry = "$HOME/" + strings.TrimPrefix(pathentry, home)
|
|
}
|
|
|
|
return pathentry, nil
|
|
}
|
|
|
|
func sortForward(priority, n int) int {
|
|
// Pick a number such that 99 > newpriority > priority
|
|
if n >= priority {
|
|
m := n % 5
|
|
if 0 == m {
|
|
priority += 5
|
|
} else {
|
|
priority += (5 - m)
|
|
}
|
|
}
|
|
|
|
return priority
|
|
}
|
|
|
|
func sortBackward(priority, n int) int {
|
|
// Pick a number such that 0 < newpriority < priority
|
|
if n <= priority {
|
|
m := n % 5
|
|
if 0 == m {
|
|
m = 5
|
|
}
|
|
priority -= m
|
|
}
|
|
|
|
return priority
|
|
}
|
|
|
|
type sorter = func(int, int) int
|
|
|
|
func getOrder(nodes []os.FileInfo, pathentry, fname, envpathd string, fn sorter) (int, error) {
|
|
// assuming people will append more often than prepend
|
|
// default the priority to less than halfway
|
|
priority := 100
|
|
for i := range nodes {
|
|
f := nodes[i]
|
|
name := f.Name()
|
|
if !strings.HasSuffix(name, ".sh") {
|
|
continue
|
|
}
|
|
if strings.HasSuffix(name, "-"+fname) {
|
|
return 0, fmt.Errorf(
|
|
"Error: %s already exports %s",
|
|
filepath.Join("~/.config/envpath/path.d", f.Name()),
|
|
pathentry,
|
|
)
|
|
}
|
|
n, err := strconv.Atoi(strings.Split(name, "-")[0])
|
|
if nil != err {
|
|
continue
|
|
}
|
|
|
|
priority = fn(priority, n)
|
|
}
|
|
|
|
return priority, nil
|
|
}
|