Next major release

.github/workflows/ci.yml

@@ -12,5 +12,3 @@ jobs:
     uses: innmind/github-workflows/.github/workflows/psalm-matrix.yml@main
   cs:
     uses: innmind/github-workflows/.github/workflows/cs.yml@main
-    with:
-      php-version: '8.2'

.github/workflows/extensive.yml

@@ -0,0 +1,12 @@
+name: Extensive CI
+
+on:
+  push:
+    tags:
+      - '*'
+    paths:
+      - '.github/workflows/extensive.yml'
+
+jobs:
+  blackbox:
+    uses: innmind/github-workflows/.github/workflows/extensive.yml@main

CHANGELOG.md

@@ -2,9 +2,26 @@
 
 ## [Unreleased]
 
+### Added
+
+- `Innmind\UrlTemplate\Template::attempt()`
+- `Innmind\UrlTemplate\Template::expansion()`
+
 ### Changed
 
-- Requires `innmind/immutable:~5.18`
+- Requires `innmind/immutable:~6.0`
+- Requires `innmind/url:~5.0`
+- Requires PHP `8.4`
+- `Innmind\UrlTemplate\Template::extract()` now returns an `Innmind\Immutable\Attempt`
+- `Innmind\UrlTemplate\Template::matches()` now returns an `Innmind\Immutable\Attempt`
+
+### Removed
+
+- `Innmind\UrlTemplate\Template::expand()`, use `::expansion()` instead
+- `Innmind\UrlTemplate\Exception\Exception`
+- `Innmind\UrlTemplate\Exception\LogicException`
+- `Innmind\UrlTemplate\Exception\DomainException`
+- `Innmind\UrlTemplate\Exception\ExplodeExpressionCantBeMatched`
 
 ## 3.1.0 - 2023-09-16
 

composer.json

@@ -15,9 +15,9 @@
         "issues": "http://github.com/Innmind/UrlTemplate/issues"
     },
     "require": {
-        "php": "~8.2",
-        "innmind/url": "~4.1",
-        "innmind/immutable": "~5.18"
+        "php": "~8.4",
+        "innmind/url": "~5.0",
+        "innmind/immutable": "~6.0"
     },
     "autoload": {
         "psr-4": {
@@ -30,7 +30,7 @@
         }
     },
     "require-dev": {
-        "innmind/static-analysis": "^1.2.1",
+        "innmind/static-analysis": "~1.3",
         "innmind/black-box": "~6.5",
         "innmind/coding-standard": "~2.0"
     }

src/Expansion.php

@@ -0,0 +1,113 @@
+<?php
+declare(strict_types = 1);
+
+namespace Innmind\UrlTemplate;
+
+use Innmind\UrlTemplate\Expression\Name;
+use Innmind\Url\Url;
+use Innmind\Immutable\{
+    Sequence,
+    Str,
+    Map,
+};
+
+/**
+ * @psalm-immutable
+ */
+final class Expansion
+{
+    /**
+     * @param Sequence<Expression> $expressions
+     * @param Map<non-empty-string, string> $values
+     * @param Map<non-empty-string, list<string>> $lists
+     * @param Map<non-empty-string, list<array{Name, string}>> $keys
+     */
+    private function __construct(
+        private Str $template,
+        private Sequence $expressions,
+        private Map $values,
+        private Map $lists,
+        private Map $keys,
+    ) {
+    }
+
+    /**
+     * @psalm-pure
+     * @internal
+     *
+     * @param Sequence<Expression> $expressions
+     */
+    public static function of(Str $template, Sequence $expressions): self
+    {
+        return new self(
+            $template,
+            $expressions,
+            Map::of(),
+            Map::of(),
+            Map::of(),
+        );
+    }
+
+    /**
+     * @no-named-arguments
+     *
+     * @param non-empty-string $name
+     */
+    public function with(string $name, string ...$values): self
+    {
+        if (\count($values) === 1) {
+            return new self(
+                $this->template,
+                $this->expressions,
+                ($this->values)($name, $values[0]),
+                $this->lists->remove($name),
+                $this->keys->remove($name),
+            );
+        }
+
+        return new self(
+            $this->template,
+            $this->expressions,
+            $this->values->remove($name),
+            ($this->lists)($name, $values),
+            $this->keys->remove($name),
+        );
+    }
+
+    /**
+     * @no-named-arguments
+     *
+     * @param non-empty-string $name
+     * @param array{string, string} ...$keys
+     */
+    public function withKeys(string $name, array ...$keys): self
+    {
+        return new self(
+            $this->template,
+            $this->expressions,
+            $this->values->remove($name),
+            $this->lists->remove($name),
+            ($this->keys)($name, \array_map(
+                static fn($pair) => [Name::of($pair[0]), $pair[1]],
+                $keys,
+            )),
+        );
+    }
+
+    public function expand(): Url
+    {
+        $url = $this->expressions->reduce(
+            $this->template,
+            fn(Str $template, $expression) => $template->replace(
+                $expression->toString(),
+                $expression->expand(
+                    $this->values,
+                    $this->lists,
+                    $this->keys,
+                ),
+            ),
+        );
+
+        return Url::of($url->toString());
+    }
+}

src/Expression.php

@@ -3,10 +3,10 @@
 
 namespace Innmind\UrlTemplate;
 
+use Innmind\UrlTemplate\Expression\Name;
 use Innmind\Immutable\{
     Map,
-    Str,
-    Maybe,
+    Attempt,
 };
 
 /**
@@ -15,19 +15,18 @@
  */
 interface Expression
 {
+    public function expansion(): Expression\Expansion;
+
     /**
-     * @psalm-pure
-     *
-     * @return Maybe<self>
+     * @param Map<non-empty-string, string> $values
+     * @param Map<non-empty-string, list<string>> $lists
+     * @param Map<non-empty-string, list<array{Name, string}>> $keys
      */
-    public static function of(Str $string): Maybe;
-
-    public function expansion(): Expression\Expansion;
+    public function expand(Map $values, Map $lists, Map $keys): string;
 
     /**
-     * @param Map<non-empty-string, string|list<string>|list<array{string, string}>> $variables
+     * @return Attempt<string>
      */
-    public function expand(Map $variables): string;
-    public function regex(): string;
+    public function regex(): Attempt;
     public function toString(): string;
 }

src/Expression/Level1.php

@@ -10,41 +10,43 @@
 use Innmind\Immutable\{
     Map,
     Str,
-    Maybe,
+    Attempt,
 };
 
 /**
  * @psalm-immutable
+ * @internal
  */
 final class Level1 implements Expression
 {
-    private Name $name;
-    private UrlEncode $encode;
-
-    private function __construct(Name $name)
-    {
-        $this->name = $name;
-        $this->encode = new UrlEncode;
+    private function __construct(
+        private Name $name,
+        private UrlEncode $encode,
+    ) {
     }
 
     /**
      * @psalm-pure
+     *
+     * @return Attempt<self>
      */
-    #[\Override]
-    public static function of(Str $string): Maybe
+    public static function of(Str $string): Attempt
     {
-        /** @var Maybe<Expression> */
-        return Name::one($string, Expansion::simple)->map(
-            static fn($name) => new self($name),
-        );
+        return Name::one($string, Expansion::simple)
+            ->map(self::named(...));
     }
 
     /**
      * @psalm-pure
      */
     public static function named(Name $name): self
     {
-        return new self($name);
+        return new self($name, UrlEncode::everything);
+    }
+
+    public function name(): Name
+    {
+        return $this->name;
     }
 
     #[\Override]
@@ -54,22 +56,25 @@ public function expansion(): Expansion
     }
 
     #[\Override]
-    public function expand(Map $variables): string
+    public function expand(Map $values, Map $lists, Map $keys): string
     {
-        /** @psalm-suppress InvalidArgument Because of the filter */
-        return $variables
+        return $values
             ->get($this->name->toString())
-            ->filter(\is_string(...))
             ->match(
-                fn(string $variable) => ($this->encode)($variable),
+                $this->encode->encode(...),
                 static fn() => '',
             );
     }
 
+    public function encode(string $string): string
+    {
+        return $this->encode->encode($string);
+    }
+
     #[\Override]
-    public function regex(): string
+    public function regex(): Attempt
     {
-        return "(?<{$this->name->toString()}>[a-zA-Z0-9\%\-\.\_\~]*)";
+        return Attempt::result("(?<{$this->name->toString()}>[a-zA-Z0-9\%\-\.\_\~]*)");
     }
 
     #[\Override]