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

Author: nyamsprod

interfaces/CHANGELOG.md

@@ -54,7 +54,7 @@ All Notable changes to `League\Uri\Interfaces` will be documented in this file
 
 ### Removed
 
-- None
+- Dependency to `psr/http-factory` package which is never required in the package.
 
 ## [7.5.0](https://github.com/thephpleague/uri-interfaces/compare/7.3.1...7.5.0) - 2024-12-08
 

interfaces/composer.json

@@ -39,8 +39,7 @@
     "require": {
         "php" : "^8.1",
         "ext-filter": "*",
-        "psr/http-message": "^1.1 || ^2.0",
-        "psr/http-factory": "^1"
+        "psr/http-message": "^1.1 || ^2.0"
     },
     "autoload": {
         "psr-4": {

uri/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
 

uri/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:[email protected]: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'];
-    }
 }

uri/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'],

uri/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.
      *

uri/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:[email protected]:81/path?query#fragment');
+        /** @var Http $newUri */
+        $newUri = unserialize(serialize($uri));
+
+        self::assertEquals($uri, $newUri);
+    }
 }