[Stuff] Umgang mit Pfaden

[Janoscharlipp]

Moinmoin,

schon seit längerem stört mich der Umgang mit Pfaden in PHP, dieses ständige Stringzusammengefuzle nervt mich ungeheuerlich, deshalb habe ich jetzt mal eine kleine Klasse dazu geschrieben.
Sie soll den Umgang mit den Pfaden etwas abstrahieren, und vorallem zuverlässig (schöne) Pfad-Strings ausspucken.

PHP-Code:

<?php

/**
 * Instanzen dieser Klasse repräsentieren relative Pfade.
 * Mit den Methoden {@code sup} und {@code sub} kann man in diesem Pfad
 * auf- und abwärts navigieren.
 */
class RelativePath
{
    var $steps;

    function RelativePath($pathString = '')
    {
        $this->setPath($pathString);
    }

    /**
     * Ließt einen neuen Pfad-String ein.
     */
    function setPath($pathString = '')
    {
        $this->setSteps(explode('/', $pathString));
    }

    /**
     * Schreibt die Pfad-Schritte neu, und räumt sie auf.
     */
    function setSteps($steps)
    {
        $this->steps = $steps;

        $this->cleanUp();
    }

    /**
     * Räumt diesen Pfad auf, d.h. entfernt unnötige „/“ und „./“.
     * Zudem werden „../“ wenn möglich auf den Pfad angewendet.
     */
    function cleanUp()
    {
        $l = count($this->steps);

        $stepsUp = 0;

        for ($i = $l - 1; $i > -1; $i--) {
            $currentStep = $this->steps[$i];

            if (($currentStep == '') || ($currentStep == '.')) {
                array_splice($this->steps, $i, 1);
            } else if ($currentStep == '..') {
                array_splice($this->steps, $i, 1);

                $stepsUp++;
            } else if ($stepsUp > 0) {
                array_splice($this->steps, $i, 1);

                $stepsUp--;
            }
        }

        if ($stepsUp > 0) {
            $upSteps = array_fill(0, $stepsUp, '..');

            $this->steps = array_merge($upSteps, $this->steps);
        }
    }

    /**
     * Geht vom momentanen Pfad aus {@code $count} Schritte nach oben
     * (wenn nicht übergeben einen Schritt) und gibt den neuen Pfad zurück.
     */
    function sup($count = 1)
    {
        $stepCount = count($this->steps);

        if ($count > $stepCount) {
            $newSteps = array_fill(0, $count - $stepCount, '..');
        } else {
            $newSteps = array_slice($this->steps, 0, -$count);
        }

        $resultPath = new RelativePath();

        $resultPath->setSteps($newSteps);

        return $resultPath;
    }

    /**
     * Hängt den in {@code $addString} festgelegten Pfad an diesen Pfad an,
     * und gibt das Ergebnis zurück.
     */
    function sub($addString)
    {
        if ($addString != null) {
            $addPath = new RelativePath($addString);

            return $this->concat($addPath);
        }
    }

    /**
     * Hängt den Pfad {@code $relativePath} an diesen Pfad an, und gibt
     * das Ergebnis zurück.
     */
    function concat($relativePath)
    {
        $resultPath = new RelativePath();

        $newSteps = array_merge($this->steps, $relativePath->steps);

        $resultPath->setSteps($newSteps);

        return $resultPath;
    }

    /**
     * Gibt den String zu diesem Pfad zurück.
     */
    function getString()
    {
        if (count($this->steps) == 0) {
            return './';
        } else {
            return implode('/', $this->steps) . '/';
        }
    }
}

?>

Mich würde interessieren, was ihr davon haltet, ob es für euch so brauchbar ist, ob ihr etwas ähnliches / besseres kennt, oder wie ihr überhaupt damit umgeht.

Mir ist die Klasse Net_URL von PEAR bekannt, diese hat aber den etwas anderen Anspruch URLs darzustellen, inklusive Get-Variablen, host, port und was nicht alles dazugehört.
Mir geht es mehr um die Navigation in dem Pfad.

EDIT: hier noch ein Beispiel:

PHP-Code:

<?php

require_once 'RelativePath.php';

$s = '/../..//./gaga/./blub///bla/../lala/././///../';

$p = new RelativePath($s);

echo $p->getString() . "<br />";
// -> ../../gaga/blub/

$p = $p->sup();

echo $p->getString() . "<br />";
// -> ../../gaga/

$p = $p->sub('deeper/andDeeper/./..////');

echo $p->getString() . "<br />";
// -> ../../gaga/deeper/

$p->setPath('/.//');

echo $p->getString() . "<br />";
// -> ./

$p->setPath('/./gaga///');

$p = $p->sup(3);

echo $p->getString() . "<br />";
// -> ../../

?>

[sonar]

Janosch, kannst vielleicht schnell ein Beispiel posten, wie dieses "Stringzusammengefuzle" bei dir so aussieht, und was deine Klasse draus macht..?

Wäre (zumindest für mich) auf die Schnelle anschaulicher glaub ich...

[Janoscharlipp]

Jo, hatte ich doch glatt vergessen, schon hinzugefügt.

[rechtschreibfan]

ich sag nur: software reuse rules.

http://pear.php.net/package/Net_URL/...hodresolvePath

[Nightflyer]

Kann mir kein Anwendungsbereich dafür vorstellen. Mit Pfaden hatte ich bisher keine Probleme da ich meistens mit max. zwei Verzeichnisebenen arbeite.

[rechtschreibfan]

ne, gibt schon anwendungen... gerade auch z.b. um die identität von pfaden festzustellen.
wenn es dir mal passiert, dass "/home/bla/hello" und "/home/bla/../bla/hello" nicht identisch sind, hast du ein problem. ...

[elias]

Ich arbeite lieber mit absoluten Pfaden schon wegen der open_basedir Direktive.
Den Projektpfad bekomme ich einfach per:

PHP-Code:

$path = dirname(__FILE__); 


Man kann damit auch ../ simulieren:

PHP-Code:

$path = dirname(dirname(__FILE__)); 


Klassen und Libraries werden in einen /lib Ordner geschmissen und dann
in den include_path gesetzt, diese brauchen also auch keine relativen Pfade.

Wenn ich relative/existierende Pfade absolut haben will, leistet realpath()
eigentlich gute dienste. Das reicht imho auch um Pfade zu vergleichen.

[Janoscharlipp]

Bei mir ist das Problem eigentlich, dass ich mit einer RewriteRule den Kontext der PHP-Datei im Browser „verschiebe“ und deshalb dauernd mit wilden relativen Pfaden rumhantieren muss.
Net_URL ist mir bekannt (wie schon eingangs geschrieben) ermöglicht aber nicht die Navigation mit sub und sup.
Jetzt fehlt mir noch die Möglichkeit den „Differenzpfad“ von zwei Pfaden zu bestimmen, mal gucken

[elias]

Für das mod_rewrite Problem würde ich eher einen ordentlichen FrontController
bauen der das "Dateisystem simuliert". D.h. du Schreibst nicht wirklich Pfade
in andere Pfade um sondern Schreibst die Pfade in GET Parameter.

Also:
http://beispiel.de/myapp/artikel/23

Wird zu:
http://beispiel.de/myapp.php?show=artikel&id=23

Damit bist du unabhängig von der Struktur im Dateisystem.
Aber vielleicht trifft das ja garnicht auf deine Bedürfnisse zu..

[Janoscharlipp]

Es geht mehr darum, dass der Aufbau der Seite der einer „normalen“ Seite gleicht, d. h. sich ganz normal über FTP und geringen HTML-Kenntnissen pflegen und erweitern lässt. Allerdings sollen die Inhalte in einem Grundgerüst (=> Template) eingefügt werden, zudem soll automatisch ein Menue passend zur Ordnerstruktur und der aktuellen Position darin, generiert werden.

Ich verwende also die RewriteRule nur dafür, irgendwie mit PHP dazwischen zu funken, sprich die Inhalte in das Haupt-Template einzufügen, und das Menue zu generieren. Die Inhalte selbst (Bilder, Java-Applets …) sollen wie gewohnt in der Ordnerstruktur liegen.
D.h.:
www.x.tld/english/abc/efg
wird (wenn abc/efg keine existente Datei ist) vom Apache als
www.x.tld/english/content.php?content=abc/efg
behandelt.

[elias]

Und wo kommen dann die Lustigen Pfade ins spiel?