don't use extra cmds, use a flag (#25)

Introduced a `-D` flag to drop a path before re-adding it, preventing duplicates.

Corrected typos in comments and method names for better clarity.

Enhanced `DirList` test to cover new functionality and ensure the integrity of path manipulation.

Updated usage message to include information about the new `-D` flag feature.

cmd/pathctl/main.go

@@ -20,6 +20,7 @@ var (
 	versionMode  bool
 	listMode     bool
 	noprefixMode bool
+	dropMode     bool
 )
 
 var (
@@ -31,42 +32,37 @@ var cmdHandlers map[string]func(d pathlist.List)
 func init() {
 	flag.BoolVar(&helpMode, "help", false, "display this help and exit.")
 	flag.BoolVar(&versionMode, "version", false, "output version information and exit.")
+	flag.BoolVar(&dropMode, "D", false, "drop the path before adding it again to the list.")
 	flag.BoolVar(&noprefixMode, "noprefix", false, "output the variable contents only.")
 	flag.BoolVar(&listMode, "L", false, "use a newline character as path list separator.")
-	flag.StringVar(&envVar, "E", "PATH", "input environment variable")
+	flag.StringVar(&envVar, "E", "PATH", "input environment variable.")
 	flag.Usage = usage
 	flag.CommandLine.SetOutput(os.Stderr)
 
 	cmdHandlers = func() map[string]func(pathlist.List) {
-		hAppend := func(d pathlist.List) { d.Append(flag.Arg(1)) }
-		hMoveAppend := func(d pathlist.List) {
-			d.Drop(flag.Arg(1))
+		hAppend := func(d pathlist.List) {
+			if dropMode {
+				d.Drop(flag.Arg(1))
+			}
 			d.Append(flag.Arg(1))
 		}
 		hDrop := func(d pathlist.List) { d.Drop(flag.Arg(1)) }
-		hMovePrepend := func(d pathlist.List) {
-			d.Drop(flag.Arg(1))
-			d.Prepend(flag.Arg(1))
-		}
 		hPrepend := func(d pathlist.List) {
+			if dropMode {
+				d.Drop(flag.Arg(1))
+			}
 			d.Prepend(flag.Arg(1))
 		}
 
 		return map[string]func(pathlist.List){
-			"append":       hAppend,
-			"drop":         hDrop,
-			"prepend":      hPrepend,
-			"move-append":  hMoveAppend,
-			"move-prepend": hMovePrepend,
-			//"appendPathctlDir":  func() { appendPath(exePath()) },
-			//"prependPathctlDir": func() { prependPath(exePath()) },
+			"append":  hAppend,
+			"drop":    hDrop,
+			"prepend": hPrepend,
 
 			// aliases
-			"a":  hAppend,
-			"d":  hDrop,
-			"p":  hPrepend,
-			"mv": hMoveAppend,
-			"mp": hMovePrepend,
+			"a": hAppend,
+			"d": hDrop,
+			"p": hPrepend,
 		}
 	}()
 }
@@ -115,10 +111,6 @@ func printPathList(d pathlist.List) {
 	fmt.Println(sb.String())
 }
 
-func list(d pathlist.List) {
-	printPathList(d)
-}
-
 func handleHelpAndVersionModes() {
 	if !helpMode && !versionMode {
 		return
@@ -135,29 +127,28 @@ func handleHelpAndVersionModes() {
 }
 
 func usage() {
-	s := fmt.Sprintf(`Usage: %s COMMAND [PATH]
+	s := fmt.Sprintf(`Usage: %s [COMMAND [PATH]]
 Make the management of the PATH environment variable
 simple, fast, and predictable.
 
 Commands:
 
-   append, a           append a path to the end of the list
-   move-append, ma     append a new path to the end of the list;
-                       if the list contains the path already then
-                       it will be moved to the end of the list
-   drop, d             drop a path
-   prepend, p          prepend a path to the list
-   move-prepend, mp    prepend a new path to the top of the list;
-                       if the list contains the path already then
-                       it will be moved to the top of the list
+   append, a           append a path to the end of the list.
+   drop, d             drop a path.
+   prepend, p          prepend a path to the list.
+
 Options:
 `, programme)
 	_, _ = fmt.Fprintln(os.Stderr, s)
 
 	flag.PrintDefaults()
 
 	_, _ = fmt.Fprintln(os.Stderr, `
+When used with the -D flag, the commands append and prepend
+drop PATH before adding it again to the list. This behaviour
+guarantees that PATH is added as either the first or the last
+element of the path list.
+
 If COMMAND is not provided, it prints the contents of the PATH
 environment variable.`)
 }
-

pathlist/list.go

@@ -1,4 +1,4 @@
-// Package pathlist implements functions to manipoulate PATH-like
+// Package pathlist implements functions to manipulate PATH-like
 // environment variables.
 package pathlist
 
@@ -42,8 +42,8 @@ type List interface {
 	// Slice returns the path list as a slice of strings.
 	Slice() []string
 
-	// Returns the path list as a string of path list separator-separated
-	// directories.
+	// String returns the path list as a string of path list
+	// separator-separated directories.
 	String() string
 }
 
@@ -168,18 +168,18 @@ func (d *dirList) clone(o *dirList) *dirList {
 }
 
 func removeDups[T comparable](col []T, applyFn func(T) (T, bool)) []T {
-	uniq := []T{}
+	var uniq = make([]T, 0)
 	ks := make(map[T]interface{})
 
 	for _, el := range col {
-		newval, ok := applyFn(el)
+		vv, ok := applyFn(el)
 		if !ok {
 			continue
 		}
 
-		if _, ok := ks[newval]; !ok {
-			uniq = append(uniq, newval)
-			ks[newval] = struct{}{}
+		if _, ok := ks[vv]; !ok {
+			uniq = append(uniq, vv)
+			ks[vv] = struct{}{}
 		}
 	}
 

pathlist/list_test.go

@@ -62,7 +62,8 @@ func Test_DirList_Prepend(t *testing.T) {
 
 func Test_DirList_Drop(t *testing.T) {
 	d := New()
-	d.Load("/opt/local/bin:/usr/local/bin:/sbin:/bin:/var")
+	d.Load("/opt/local/bin:/usr/local/bin:/sbin:/bin:/var:/bin")
+	require.Equal(t, d.Slice(), []string{"/opt/local/bin", "/usr/local/bin", "/sbin", "/bin", "/var"})
 	d.Drop("/opt/local/bin")
 	d.Drop("/opt/local/bin")
 	d.Drop("/opt/local/bin")