The League of Extraordinary Packages

Our Packages:

Presented by The League of Extraordinary Packages

Getting Started

Uri functions

Uri parser

Uri schemes

Uri manipulations

Uri components

Uri Domain Parser

Upgrading Guide

Path Component

URI path component objects are modelled depending on the URI as such each URI scheme specific must implement its own path object. To ease usage, the package comes with a generic Path object as well as two more specialized Path objects. All Path objects expose the following methods:

<?php

class Path implements ComponentInterface
{
	public function isAbsolute(void): bool
	public function withLeadingSlash(void): self
	public function withoutDotSegments(void): self
	public function withoutLeadingSlash(void): self
	public function withoutTrailingSlash(void): self
	public function withoutEmptySegments(void): self
	public function withTrailingSlash(void): self
}

According to RFC3986, the component content can not be equal to null therefore Path::isNull always returns false

Because path are scheme specific, some methods may trigger an League\Uri\Components\Exception if for a given scheme the path does not support the given modification

Creating a new object

<?php
public Path::__construct(?string $content = null): void

submitted string is normalized to be RFC3986 compliant.

If the submitted value is not valid a League\Uri\Components\Exception exception is thrown.

The League\Uri\Components\Exception extends PHP’s SPL InvalidArgumentException.

Path properties

Absolute, rootless or empty

<?php

use League\Uri\Components\Path;

$relative_path = new Path('bar/baz');
echo $relative_path; //displays 'bar/baz'
$relative_path->isAbsolute(); //return false;
$relative_path->isEmpty(); //return false;

$absolute_path = new Path('/bar/baz');
echo $absolute_path; //displays '/bar/baz'
$absolute_path->isAbsolute(); //return true;
$absolute_path->isEmpty(); //return false;

$empty_path = new Path();
echo $absolute_path; //displays ''
$empty_path->isAbsolute(); //return false;
$empty_path->isEmpty(); //return true;

Path with or without a trailing slash

The Path object can tell you whether the current path ends with a slash or not using the Path::hasTrailingSlash method. This method takes no argument and return a boolean.

<?php

use League\Uri\Components\Path;

$path = new Path('/path/to/the/sky.txt');
$path->hasTrailingSlash(); //return false

$altPath = new Path('/path/');
$altPath->hasTrailingSlash(); //return true

Path modifications

If the modifications do not change the current object, it is returned as is, otherwise, a new modified object is returned.

When a modification fails a League\Uri\Components\Exception exception is thrown.

Out of the box, the Path object operates a number of non destructive normalizations. For instance, the path is correctly URI encoded against the RFC3986 rules.

Removing dot segments

To remove dot segment as per RFC3986 you need to explicitly call the Path::withoutDotSegments method as the result can be destructive. The method takes no argument and returns a new Path object which represents the current object without dot segments.

<?php

use League\Uri\Components\Path;

$path = new Path('path/to/./the/../the/sky%7bfoo%7d');
$newPath = $raw_path->withoutDotSegments();
echo $path;                   //displays 'path/to/./the/../the/sky%7bfoo%7d'
echo $newPath;                //displays 'path/to/the/sky%7Bfoo%7D'
$newPath->sameValueAs($path); //returns false;

Removing empty segments

Sometimes your path may contain multiple adjacent delimiters. Since removing them may result in a semantically different URI, this normalization can not be applied by default. To remove adjacent delimiters you can call the Path::withoutEmptySegments method which convert you path as described below:

<?php

use League\Uri\Components\Path;

$path    = new Path("path////to/the/sky//");
$newPath = $path->withoutEmptySegments();
echo $path;                   //displays 'path////to/the/sky//'
echo $newPath;                //displays 'path/to/the/sky/'
$newPath->sameValueAs($path); //returns false;

Manipulating the trailing slash

Depending on your context you may want to add or remove the path trailing slash. In order to do so the Path object uses two methods which accept no argument.

Path::withoutTrailingSlash will remove the ending slash of your path only if a slash is present.

<?php

use League\Uri\Components\Path;

$path    = new Path("path/to/the/sky/");
$newPath = $path->withoutTrailingSlash();
echo $path;     //displays 'path/to/the/sky/'
echo $newPath;  //displays 'path/to/the/sky'

Conversely, Path::withTrailingSlash will append a slash at the end of your path only if no slash is already present.

<?php

use League\Uri\Components\Path;

$path    = new Path("/path/to/the/sky");
$newPath = $path->withTrailingSlash();
echo $path;    //displays '/path/to/the/sky'
echo $newPath; //displays '/path/to/the/sky/'

Manipulating the leading slash

Conversely, to convert the path type the Path object uses two methods which accept no argument.

Path::withoutLeadingSlash will convert an absolute path into a relative one by removing the path leading slash if present.

<?php

use League\Uri\Components\Path;

$path    = new Path("path/to/the/sky/");
$newPath = $path->withoutTrailingSlash();
echo $path;    //displays 'path/to/the/sky/'
echo $newPath; //displays 'path/to/the/sky'

Path::withLeadingSlash will convert an relative path into a absolute one by prepending the path with a slash if none is present.

<?php

use League\Uri\Components\Path;

$path    = new Path("/path/to/the/sky");
$newPath = $path->withTrailingSlash();
echo $raw_path; //displays '/path/to/the/sky'
echo $newPath;  //displays '/path/to/the/sky/'

Specialized Path Object

What makes an URI specific apart from the scheme is how the path is parse and manipulated. This simple path class although functional will not ease parsing a Data URI path or a FTP Uri path. That’s why the library comes bundles with two specialized Path objects that extend the current object by adding more specific methods in accordance to the path usage: