Bernd Eggink

Normalized and relative file paths

Sometimes one needs to convert a file path into a form that is relative to an arbitrary base (not necessarily the current directory). That's what the function relpath does. Example:

path=a/b/c  base=../x/y
pwd                   # Output: /usr/joe
relpath $base $path   # Output: ../../joe/a/b/c

The problem is not quite trivial, as the function should also work in cases like this:

relpath  ../x/./y   ./a/../a/b/c

To relate the paths to each other, they must first be normalized, i.e. freed of any .. and . components. Also, file names with embedded blanks (a common pitfall in shell programming) should be handled correctly.

The function may be called with one or two parameters:

relpath path prints the path path in an absolute and normalized form.

relpath base path prints the path path relative to directory base. Both may be given in absolute or relative form and need not exist physically. The result may start with one or several .. components and is normalized otherwise.

# Normalize one or more file paths and output them 
# relative to a base directory
#
# Usage: relpath path           Output path normalized 
#        relpath base path...   Output paths normalized+relative to base


function relpath    # (base [path])
{
    typeset dot
    
    [[ $1 == -p ]] && 
    {
        dot=1
        shift
    }

    (( $# == 0 )) && return 2
    
    typeset base=$1 path empty
    typeset IFS=/
    typeset abase=($(relpath_normalize_ "$base")) # normalize 1st arg
    typeset apath 
    typeset -i i j

    shift

    if (( $# > 0 )) 
    then
        # more arguments

        for path
        do
            apath=($(relpath_normalize_ "$path"))  # normalize next 
            slash=
            empty=1

            # look for common components at the left

            for (( i = 0; i < ${#abase[*]} && i < ${#apath[*]}; ++i ))
            do
                [[ ${abase[i]} != ${apath[i]} ]] && break
            done

            # output necessary amounts of .. 

            for (( j = i; j < ${#abase[*]}; ++j ))
            do
                if (( j > i )) 
                then
                    echo -n "/.."
                else
                    echo -n ".."
                    slash=/
                fi

                empty=
            done

            # output rest of relative path

            for (( j = i; j < ${#apath[*]}; ++j ))
            do
                echo -n "$slash${apath[j]}"
                slash=/
                empty=
            done

            if [[ $dot && $empty ]]
            then
                echo "."
            else
                echo
            fi
        done
    else
        # single arg, print normalized base

        for (( j = i; j < ${#abase[*]}; ++j ))
        do
            echo -n "/${abase[j]}"
        done

        echo
    fi
}

#-----------------------------------------------------------------------

function relpath_normalize_  # (path)    
{
    typeset path=$1 a
    typeset -i i j
    typeset IFS=/

    if [[ "$path" == . ]]
    then
        path=$PWD
    elif [[ "$path" != /* ]] 
    then                    
        path="$PWD/$path"
    fi

    a=($path)

    for (( i = 1; i < ${#a[*]}; ++i ))
    {
        if [[ ${a[i]} == "." ]]
        then
            a[i]=""
        elif [[ ${a[i]} == ".." ]]
        then
            a[i]=""

            for (( j = i - 1; j > 0; --j ))
            do
                [[ ${a[j]} ]] &&
                {
                    a[j]=""
                    break
                }
            done
        fi
    }

    for p in ${a[*]}
    do
        [[ "$p" ]] && echo -n "$p/"
    done
}

#-----------------------------------------------------------------------

typeset -fx relpath relpath_normalize_