$PATH checking

lfur · 01-04-2005, 01:20 PM

Hi!

I was wondering if someone has any thoughts about this short script for $PATH checking (delete the evil . and remove all duplicates + check if entries are really directories). Any suggestions are very welcome.

Code:

newpath=""

for i in `echo $PATH | sed -e "s/:/\n/g" | grep -v "\." | uniq`
do
  if [ -d $i ]
  then
    if [ "$newpath" == "" ]
    then
      newpath=$i
    else
      newpath=${newpath}:$i
    fi
  fi
done

export PATH=$newpath
unset newpath

any thoughts, optimisations ... ???

Enjoy

acid_kewpie · 01-04-2005, 01:42 PM

Code:

newpath=""

for i in $(echo $PATH | sed -e "s/:/\n/g" | grep -v "\." | uniq)
do
  if [ -d "$i" ]
  then
    newpath=$newpath:$i
  fi
done

export PATH=$(echo $newpath | cut -b 2-)
unset newpath

a little shorter. personally i'd not worry about the initialisation and unset, but that's just a bad habit on my part. I also put $i in quotes incase a space or a null string creeps in.

lfur · 01-04-2005, 02:17 PM

Hi!

Code:

cut -b 2-

nice one, didn't even think about it. Just a question: any big difference between $() and `(backticks) ??

Enjoy

acid_kewpie · 01-04-2005, 02:25 PM

to be honest i only recently found out about $() notation. AFAIK it's new-school as opposed to "retro" backticks. either work the same as far as i am aware, but it's nice to be consistent.

lfur · 01-04-2005, 02:35 PM

Yup, it seems thats it plus one more thing as seen in http://www.gnu.org/software/bash/man...ref.html#SEC30 :

Quote:

When the old-style backquote form of substitution is used, backslash retains its literal meaning except when followed by `$', ``', or `\'. The first backquote not preceded by a backslash terminates the command substitution. When using the $(command) form, all characters between the parentheses make up the command; none are treated specially.

Enjoy and thanx for the reply

Dark_Helmet · 01-04-2005, 02:49 PM

One other point to bring up... From the man page of uniq:

Quote:

Discard all but one of successive identical lines from INPUT (or standard
input), writing to OUTPUT (or standard output).

So, this:

Code:

for i in $(echo $PATH | sed -e "s/:/\n/g" | grep -v "\." | uniq)

ought to be changed to this:

Code:

for i in $(echo $PATH | sed -e "s/:/\n/g" | grep -v "\." | sort | uniq)

If not, identical paths separated by one or more other paths will not be removed. However, the sort will clearly screw up any specific ordering of your paths.

lfur · 01-04-2005, 03:03 PM

Code:

for i in $(echo $PATH | sed -e "s/:/\n/g" | grep -v "\." | sort | uniq)

the problem with this is that it sorts like this

/bin
/home
/usr/bin
...

which is not good (at least for mes) as sometimes you find files with similar names in /home that exist in /usr/bin and then there's a confusion. The problem with duplicates is actually a problem with my .bash_profile, where I have something like this:

Code:

export PATH=$PATH:$HOME/bin

and when I source it, it duplicates $HOME/bin.

Well there should be a solution waiting to be found. Untill then ...

Exactly what you said

(Ireplied too fast)

Enjoy

Dark_Helmet · 01-04-2005, 05:10 PM

There is another option. You can declare some functions in your ~/.bash_profile. I saw this technique in the LFS materials. In fact, that's exactly where the code comes from:

Code:

# Begin /etc/profile
# Written for Beyond Linux From Scratch
# by James Robertson <jameswrobertson@earthlink.net>
# modifications by Dagmar d'Surreal <rivyqntzne@pbzpnfg.arg>

#<snip>
   
# Functions to help us manage paths.  Second argument is the name of the
# path variable to be modified (default: PATH)
pathremove () {
        local IFS=':'
        local NEWPATH
        local DIR
        local PATHVARIABLE=${2:-PATH}
        for DIR in ${!PATHVARIABLE} ; do
                if [ "$DIR" != "$1" ] ; then
                  NEWPATH=${NEWPATH:+$NEWPATH:}$DIR
                fi  
        done
        export $PATHVARIABLE="$NEWPATH"
}

pathprepend () {
        pathremove $1 $2
        local PATHVARIABLE=${2:-PATH}
        export $PATHVARIABLE="$1${!PATHVARIABLE:+:${!PATHVARIABLE}}"
}

pathappend () {
        pathremove $1 $2
        local PATHVARIABLE=${2:-PATH}
        export $PATHVARIABLE="${!PATHVARIABLE:+${!PATHVARIABLE}:}$1"
}

Then, when you want to add a directory to your path, do something like:

Code:

pathappend $HOME/bin

The pathremove function will rip out any existing copy of a path you're trying to add, and since both pathprepend and pathappend always call pathremove, you're guaranteed to never get duplicates.

lfur · 01-05-2005, 10:25 AM

Removed uniq and added checking for duplicates:

Code:

newpath=""

for old in $(echo $PATH | sed -e "s/:/\n/g" | grep -v "\.")
do
  if [ -d "$old" ]
  then
    bad=0
    for new in $(echo $newpath | sed -e "s/:/\n/g")
    do
      if [ "$old" == "$new" ]
      then
        bad=1
      fi
    done
    if [ "$bad" == "0" ]
    then
      if [ "$newpath" == "" ]
      then
        newpath=$old
      else
        newpath=${newpath}:$old
      fi
    fi
  fi
done

echo $newpath

Any comments?

Enjoy