Move psr/http-factory requirement from the uri-interfaces to the uri package

Author: nyamsprod

CHANGELOG.md

@@ -6,7 +6,7 @@ All Notable changes to `League\Uri` will be documented in this file
 
 ### Added
 
-- Added methods to align with the upcoming `Uri\Rfc3986Uri` PHP native class (see: https://wiki.php.net/rfc/url_parsing_api#proposal)
+- `Uri::parse` returns a new `Uri` instance on success or null on failure (ie: a Relax version of `Uri::fromBaseUri` and `Uri::new`) that mimics the behaviour of the upcoming native PHP URI parse method.
 - `Uri::tryNew` returns a new `Uri` instance on success or null on failure (ie: a Relax version of `Uri::new`).
 - `Http::tryNew` returns a new `Uri` instance on success or null on failure (ie: a Relax version of `Http::new`).
 - `Http::when` conditional method to ease component building logic.
@@ -16,6 +16,10 @@ All Notable changes to `League\Uri` will be documented in this file
 - `Uri::fromMarkdownAnchor`
 - `Uri::fromHtmlAnchor`
 - `UriTemplate` implements the `Stringable` interface
+- `Uri::resolve` returns a new `Uri` instance resolve against the current instance.
+- `Uri::normalize` returns a new `Uri` instance with a full “normalized-decoded” representation: The URI is normalized (when applicable), and components are percent-decoded. Normalization may contain destructive operation.
+- `Uri`  and  `Http` classes implement a serialize mechanism to safely serialize and unserialize the instance
+- Dependency to `psr/http-factory` package which is required for the package.
 
 ### Fixed
 

FactoryTest.php

@@ -18,6 +18,7 @@
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\Attributes\Group;
 use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\Attributes\TestWith;
 use PHPUnit\Framework\TestCase;
 use Stringable;
 
@@ -240,26 +241,15 @@ public static function rfc8089UriProvider(): iterable
         ];
     }
 
-    #[DataProvider('invalidRfc8089UriProvider')]
-    public function testIfFailsToGenerateAnUriFromRfc8089(string $invalidUri): void
+    #[TestWith(['invalidUri' => 'http://www.example.com'], 'unsupported scheme')]
+    #[TestWith(['invalidUri' => '//localhost/etc/fstab'], 'missing scheme')]
+    public function it_fails_to_generate_an_uri_from_rfc8089(string $invalidUri): void
     {
         $this->expectException(SyntaxError::class);
 
         Uri::fromRfc8089($invalidUri);
     }
 
-    public static function invalidRfc8089UriProvider(): iterable
-    {
-        return [
-            'unsupported scheme' => [
-                'invalidUri' => 'http://www.example.com',
-            ],
-            'missing scheme' => [
-                'invalidUri' => '//localhost/etc/fstab',
-            ],
-        ];
-    }
-
     public function testCreateFromUri(): void
     {
         $expected = 'https://login:pass@secure.example.com:443/test/query.php?kingkong=toto#doc3';
@@ -553,21 +543,16 @@ public function testICanBeInstantiateFromRFC6750(): void
     }
 
     #[Test]
-    #[DataProvider('invalidUriWithWhitespaceProvider')]
+    #[TestWith(['uri' => '     '], 'uri containing only whitespaces')]
+    #[TestWith(['uri' => '    https://a/b?c'], 'uri starting with whitespaces')]
+    #[TestWith(['uri' => 'https://a/b?c   '], 'uri ending with whitespaces')]
     public function it_fails_parsing_uri_string_with_whitespace(string $uri): void
     {
         $this->expectException(InvalidArgumentException::class);
 
         Uri::new($uri);
     }
 
-    public static function invalidUriWithWhitespaceProvider(): iterable
-    {
-        yield 'uri containing only whitespaces' => ['uri' => '     '];
-        yield 'uri starting with whitespaces' => ['uri' => '    https://a/b?c'];
-        yield 'uri ending with whitespaces' => ['uri' => 'https://a/b?c   '];
-    }
-
     #[Test]
     #[DataProvider('provideAnchorTagHtml')]
     public function it_parses_uri_string_from_an_anchor_tag(string $html, ?string $baseUri, string $expected): void
@@ -637,20 +622,15 @@ public static function provideAnchorTagMarkdown(): iterable
     }
 
     #[Test]
-    #[DataProvider('provideInvalidMarkdown')]
+    #[TestWith(['html' => 'this is **markdown**'], 'missing markdown placeholder')]
+    #[TestWith(['html' => '[this is an incomplete href] http://example.com markdown'], 'invalid markdown placeholder; missing URI part')]
+    #[TestWith(['html' => 'this is an incomplete(http://example.com) markdown'], 'invalid markdown placeholder; missing content part')]
     public function it_fails_to_parse_an_invalid_markdown(string $html): void
     {
         $this->expectException(InvalidArgumentException::class);
         Uri::fromMarkdownAnchor($html);
     }
 
-    public static function provideInvalidMarkdown(): iterable
-    {
-        yield 'missing markdown placeholder' => ['html' => 'this is **markdown**'];
-        yield 'invalid markdown placeholder; missing URI part' => ['html' => '[this is an imcomplete] http://example.com markdown'];
-        yield 'invalid markdown placeholder; missing content part' => ['html' => 'this is an imcomplete(http://example.com) markdown'];
-    }
-
     #[Test]
     #[DataProvider('provideInvalidUri')]
     public function it_fails_to_parse_with_new(Stringable|string|null $uri): void
@@ -665,15 +645,10 @@ public static function provideInvalidUri(): iterable
     }
 
     #[Test]
-    #[DataProvider('provideInvalidUriForResolution')]
+    #[TestWith(['uri' => ':', 'baseUri' => null], 'invalid URI')]
+    #[TestWith(['uri' => '', 'baseUri' => '/absolute/path'], 'invalid resolution with a non absolute URI')]
     public function it_fails_to_parse_with_parse(Stringable|string $uri, Stringable|string|null $baseUri): void
     {
         self::assertNull(Uri::parse($uri, $baseUri));
     }
-
-    public static function provideInvalidUriForResolution(): iterable
-    {
-        yield 'invalid URI' => ['uri' => ':', 'baseUri' => null];
-        yield 'invalid resolution with a non absolute URI' => ['uri' => '', 'baseUri' => '/absolute/path'];
-    }
 }

FtpTest.php

@@ -69,7 +69,6 @@ public function testConstructorThrowInvalidArgumentException(string $uri): void
     public static function invalidUrlProvider(): array
     {
         return [
-            //['http://example.com'],
             ['ftp:/example.com'],
             ['ftp:example.com'],
             ['ftp://example.com?query#fragment'],

Http.php

@@ -14,6 +14,7 @@
 namespace League\Uri;
 
 use Deprecated;
+use Exception;
 use JsonSerializable;
 use League\Uri\Contracts\Conditionable;
 use League\Uri\Contracts\UriException;
@@ -273,6 +274,26 @@ public function withFragment(string $fragment): self
         return $this->newInstance($this->uri->withFragment($this->filterInput($fragment)));
     }
 
+    /**
+     * @return array{uri: string}
+     */
+    public function __serialize(): array
+    {
+        return ['uri' => $this->uri->toString()];
+    }
+
+    /**
+     * @param array{uri: string} $data
+     *
+     * @throws Exception
+     */
+    public function __unserialize(array $data): void
+    {
+        $uri = self::new($data['uri'] ?? throw new Exception('The `uri` property is missing from the serialized object.'));
+
+        $this->uri = $uri->uri;
+    }
+
     /**
      * DEPRECATION WARNING! This method will be removed in the next major point release.
      *

HttpTest.php

@@ -16,9 +16,14 @@
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\Attributes\TestWith;
 use PHPUnit\Framework\TestCase;
 use Psr\Http\Message\UriInterface;
 
+use function serialize;
+use function unserialize;
+
 #[CoversClass(Http::class)]
 #[Group('http')]
 final class HttpTest extends TestCase
@@ -171,23 +176,16 @@ public static function portProvider(): array
         ];
     }
 
-    #[DataProvider('invalidPathProvider')]
+    #[TestWith(['data:go'])]
+    #[TestWith(['//data'])]
+    #[TestWith(['to://to'])]
     public function testPathIsInvalid(string $path): void
     {
         self::expectException(SyntaxError::class);
 
         Http::new()->withPath($path);
     }
 
-    public static function invalidPathProvider(): array
-    {
-        return [
-            ['data:go'],
-            ['//data'],
-            ['to://to'],
-        ];
-    }
-
     #[DataProvider('invalidURI')]
     public function testCreateFromInvalidUrlKO(string $uri): void
     {
@@ -262,4 +260,14 @@ public function testICanBeInstantiateFromRFC6750(): void
             Http::fromTemplate($template, $params)->getPath()
         );
     }
+
+    #[Test]
+    public function it_can_be_serialized_by_php(): void
+    {
+        $uri = Http::new('https://user:pass@example.com:81/path?query#fragment');
+        /** @var Http $newUri */
+        $newUri = unserialize(serialize($uri));
+
+        self::assertEquals($uri, $newUri);
+    }
 }

Uri.php

@@ -482,8 +482,6 @@ public static function new(Stringable|string $uri = ''): self
      * Returns a new instance from a URI and a Base URI.or null on failure.
      *
      * The returned URI must be absolute if a base URI is provided
-     *
-     * @see https://wiki.php.net/rfc/url_parsing_api
      */
     public static function parse(Stringable|string $uri, Stringable|string|null $baseUri = null): ?self
     {
@@ -1470,16 +1468,7 @@ public function withScheme(Stringable|string|null $scheme): UriInterface
 
         return match ($scheme) {
             $this->scheme => $this,
-            default => new self(
-                $scheme,
-                $this->user,
-                $this->pass,
-                $this->host,
-                $this->port,
-                $this->path,
-                $this->query,
-                $this->fragment,
-            ),
+            default => new self($scheme, $this->user, $this->pass, $this->host, $this->port, $this->path, $this->query, $this->fragment),
         };
     }
 
@@ -1513,16 +1502,7 @@ public function withUserInfo(
 
         return match ($userInfo) {
             $this->userInfo => $this,
-            default => new self(
-                $this->scheme,
-                $user,
-                $pass,
-                $this->host,
-                $this->port,
-                $this->path,
-                $this->query,
-                $this->fragment,
-            ),
+            default => new self($this->scheme, $user, $pass, $this->host, $this->port, $this->path, $this->query, $this->fragment),
         };
     }
 
@@ -1545,16 +1525,7 @@ public function withHost(Stringable|string|null $host): UriInterface
 
         return match ($host) {
             $this->host => $this,
-            default => new self(
-                $this->scheme,
-                $this->user,
-                $this->pass,
-                $host,
-                $this->port,
-                $this->path,
-                $this->query,
-                $this->fragment,
-            ),
+            default => new self($this->scheme, $this->user, $this->pass, $host, $this->port, $this->path, $this->query, $this->fragment),
         };
     }
 
@@ -1564,16 +1535,7 @@ public function withPort(int|null $port): UriInterface
 
         return match ($port) {
             $this->port => $this,
-            default => new self(
-                $this->scheme,
-                $this->user,
-                $this->pass,
-                $this->host,
-                $port,
-                $this->path,
-                $this->query,
-                $this->fragment,
-            ),
+            default => new self($this->scheme, $this->user, $this->pass, $this->host, $port, $this->path, $this->query, $this->fragment),
         };
     }
 
@@ -1585,16 +1547,7 @@ public function withPath(Stringable|string $path): UriInterface
 
         return match ($path) {
             $this->path => $this,
-            default => new self(
-                $this->scheme,
-                $this->user,
-                $this->pass,
-                $this->host,
-                $this->port,
-                $path,
-                $this->query,
-                $this->fragment,
-            ),
+            default => new self($this->scheme, $this->user, $this->pass, $this->host, $this->port, $path, $this->query, $this->fragment),
         };
     }
 
@@ -1604,16 +1557,7 @@ public function withQuery(Stringable|string|null $query): UriInterface
 
         return match ($query) {
             $this->query => $this,
-            default => new self(
-                $this->scheme,
-                $this->user,
-                $this->pass,
-                $this->host,
-                $this->port,
-                $this->path,
-                $query,
-                $this->fragment,
-            ),
+            default => new self($this->scheme, $this->user, $this->pass, $this->host, $this->port, $this->path, $query, $this->fragment),
         };
     }
 
@@ -1623,16 +1567,7 @@ public function withFragment(Stringable|string|null $fragment): UriInterface
 
         return match ($fragment) {
             $this->fragment => $this,
-            default => new self(
-                $this->scheme,
-                $this->user,
-                $this->pass,
-                $this->host,
-                $this->port,
-                $this->path,
-                $this->query,
-                $fragment,
-            ),
+            default => new self($this->scheme, $this->user, $this->pass, $this->host, $this->port, $this->path, $this->query, $fragment),
         };
     }
 
@@ -1747,10 +1682,8 @@ public function equals(UriInterface|Stringable|string $uri, bool $excludeFragmen
     }
 
     /**
-     * Normalize an URI by applying non-destructive and destructive normalization
+     * Normalize a URI by applying non-destructive and destructive normalization
      * rules as defined in RFC3986 and RFC3987.
-     *
-     * @see https://wiki.php.net/rfc/url_parsing_api
      */
     public function normalize(): UriInterface
     {
@@ -1759,7 +1692,12 @@ public function normalize(): UriInterface
             return $this;
         }
 
-        return self::new(UriString::normalize($uriString));
+        $normalizedUriString = UriString::normalize($uriString);
+        if ($normalizedUriString === $uriString) {
+            return $this;
+        }
+
+        return self::new($normalizedUriString);
     }
 
     /**
@@ -1770,8 +1708,6 @@ public function normalize(): UriInterface
      *
      * This method MUST be transparent when dealing with error and exceptions.
      * It MUST not alter or silence them apart from validating its own parameters.
-     *
-     * @see https://wiki.php.net/rfc/url_parsing_api
      */
     public function resolve(Stringable|string $uri): UriInterface
     {