It wouldn't be that hard to adapt it so that @ARGV has all the information needed for just about every case -- e.g. consider a usage summary like this:

setpath.pl [ENV_VAR] [:NEWPATH | NEWPATH: | -[-]OLDPATH]

  Default ENV_VAR is PATH
  :NEWPATH appends ":NEWPATH" at end of ENV_VAR
  NEWPATH: prepends "NEWPATH:" at start of ENV_VAR
  -OLDPATH deletes first instance of "OLDPATH" from ENV_VAR
  --OLDPATH deletes all instances of "OLDPATH" from ENV_VAR
[download]

Conceivably, you could handle multiple path args to be added or removed from the given variable in a single command line. For that matter, you could even do multiple variables on one command line:

 setpath.pl VAR1 :NEWPATH VAR2 OTHERPATH: VAR3 --BADPATH
#
# shell function would be:
function setpath { /full/path/to/setpath.pl $*; if ... };
[download]

Maybe "chpath" would be a better name for the shell function.

update: Here is how I would do the @ARGV-based approach -- just a first attempt (I probably need to test more, esp. the regex for matching "valid" path args), but when combined with the appropriate shell function to use it, I think it would be serviceable for most needs. To me, it just seems a lot cleaner without all that prompting and reading user input on STDIN.

Not quite matching your spec but here you go. I implemented as much as I would use...

my %path;
my ($high, $low) = (0,0);
for (split /:/, $ENV{PATH} ){
  next if exists $path{$_};   # remove duplicates
  $path{$_} = $high;
  ++$high;
}

for (@ARGV){
  /^-(.*)/ and do {delete $path{$1} if exists $path{$1}; next;};
  /^\+\+(.*)/ and do {--$low; $path{$1}=$low unless exists $path{$1}; 
+next;};
  /^\+(.*)/ and do {++$high; $path{$1}=$high unless exists $path{$1}; 
+next;};
}

print join ":", sort {$path{$a} <=> $path{$b} }  keys %path;
print "\n";
[download]

--
Murray Barton
Do not seek to follow in the footsteps of the wise. Seek what they sought. -Basho

That's a nice variation. I think the two could be combined with arguments used by default but falling back to interactive behavior in their absence.

The regex path matching on a remove or remove all seems a little off:

> export PATHTEST=/foo:/foobar:/foo/bar
> setpath.pl --/foo
> more .setpath.out
export PATHTEST=:bar:/bar/

>

This works if you append a ':' to the path you're removing (which I guess the script could do for you). It might be nice to add some sort of wild carding to the removals so you could remove every directory rooted at /foo.

I initially wrote mine to do removes but for my usage I prefer to temporarily toggle directories on/off. The tools developers I work with chose executable names that match those of a number of gnu tools I make use of so on occassion I need to temporaily remove one or other directory from my PATH.

I had to save off the original path, suck in the new stuff, then cut out duplicates and other known useless bits, and set the path with the new shorter string. I think I just used a Perl script as a filter in backquotes in the shell, and all was (mostly) well...until I tried tcsh, but that's another story.

This sort of thing is not too difficult to do in pure shell commands. Here's some code I picked up a while back after a quick google search. (original source)

Example Usage

add_path $HOME/bin
add_path $HOME/perl PERL5LIB
[download]

The functions

#    @(#)Copyright (c) 1991 Simon J. Gerraty
#
#    This file is provided in the hope that it will
#    be of use.  There is absolutely NO WARRANTY.
#    Permission to copy, redistribute or otherwise
#    use this file is hereby granted provided that
#    the above copyright notice and this notice are
#    left intact.
#
# Modified by Dean Serenevy (2005) for more robust quoting

# is $1 missing from $2 (or PATH) ?
no_path() { eval "case \":\$${2-PATH}:\" in *:\"$1\":*) return 1;; *) 
+return 0;; esac"; }
# if $1 exists and is not in path, append it
add_path() { [ -d ${1:-.} ] && no_path $* && eval ${2:-PATH}="\$${2:-P
+ATH}:$1"; }
# if $1 exists and is not in path, prepend it
pre_path() { [ -d ${1:-.} ] && no_path $* && eval ${2:-PATH}="$1:\$${2
+:-PATH}"; }
# if $1 is in path, remove it
del_path() { no_path $* || eval ${2:-PATH}=`eval echo :'$'${2:-PATH}: 
+| sed -e "s;:$1:;:;g" -e "s;^:;;" -e "s;:\$;;"`; }
[download]

addpath
delpath
uniqpath
edpath

that allow you to manipulate path variables in various ways. (which are idempotent addition of paths, deletion of paths based on regex match, path uniquification, and path editing via your favourite editor)

They can be downloaded from http://www.netspinner.co.uk/Downloads/pathfunc.tgz

They're in the public domain so you can do what you like with them.

Steve Collyer

http://www.netspinner.co.uk/Downloads/pathfunc.tgz appears to be dead. Any idea where this code lives today?

The Wayback Machine is your friend: http://web.archive.org/web/20061213023831/http://www.netspinner.co.uk/Resources.html

I reckon we are the only monastery ever to have a dungeon stuffed with 16,000 zombies.