Bernd Eggink

Dateipfade normieren und relativieren

Gelegentlich möchte man einen Dateipfad relativ zu einem beliebigen Basisverzeichnis darstellen (nicht unbedingt zum Arbeitsverzeichnis). Dazu kann die Funktion relpath verwandt werden. Beispiel:

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

Das Problem ist nicht ganz trivial, denn das Verfahren soll auch in Fällen wie diesen funktionieren:

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

Um die Pfade in Beziehung setzen zu können, müssen sie zunächst normiert, d.h. von ..- und .-Komponenten befreit werden. Und auch Dateinamen, die Leerzeichen enthalten - eine gängige Stolperfalle für Shellscripte - sollen korrekt verarbeitet werden.

Die Funktion lässt sich mit einem oder zwei Parametern aufrufen:

relpath path

Der Pfad path wird absolut und in normierter Form ausgegeben.

relpath [-p]base path

Der Pfad path wird relativ zum Verzeichnis base ausgegeben. Beides können absolute oder relative Angaben sein, die nicht im Dateisystem zu existieren brauchen. Der ausgegebene Pfad enthält höchstens am Anfang ..-Komponenten und ist ansonsten normiert.

Wenn beide Pfade gleich sind, wird ohne Option ein Leerstring ausgegeben, mit Option -p ein Punkt.

# 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_