Merge branch 'develop'

* develop:
  specify next release
  fix ci for php 8.4
  bump minimum version of static analysis
  bump the minimum version of innmind/immutable
  fix access to old format
  fix using fixtures depending on the version used
  handle the case where the input string is empty
  add support for time-continuum 4

Author: Baptouuuu

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 1.9.0 - 2025-02-09
+
+### Added
+
+- Support for `innmind/time-continuum` `4`
+
 ## 1.8.0 - 2025-02-09
 
 ### Added

composer.json

@@ -16,16 +16,16 @@
     },
     "require": {
         "php": "~8.2",
-        "innmind/immutable": "~5.3",
-        "innmind/time-continuum": "~3.4"
+        "innmind/immutable": "~5.10",
+        "innmind/time-continuum": "~3.4|^4.0.2"
     },
     "autoload": {
         "psr-4": {
             "Innmind\\Validation\\": "src/"
         }
     },
     "require-dev": {
-        "innmind/static-analysis": "~1.1",
+        "innmind/static-analysis": "^1.2.1",
         "innmind/black-box": "~5.5",
         "innmind/coding-standard": "~2.0"
     }

docs/constraints/dates.md

@@ -4,14 +4,14 @@ This will transform `string`s into `PointInTime`s from the [`innmind/time-contin
 
 ```php
 use Innmind\Validation\PointInTime;
-use Innmind\TimeContinuum\Earth\{
+use Innmind\TimeContinuum\{
     Clock,
-    Format\ISO8601,
+    Format,
 };
 
 $validate = PointInTime::ofFormat(
-    new Clock,
-    new ISO8601,
+    Clock::live(),
+    Format::iso8601(),
 );
 ```
 

proofs/pointInTime.php

@@ -2,24 +2,38 @@
 declare(strict_types = 1);
 
 use Innmind\Validation\PointInTime;
-use Innmind\TimeContinuum\Earth\{
+use Innmind\TimeContinuum\{
+    Earth,
+    Earth\Format\ISO8601,
     Clock,
-    Format\ISO8601,
+    Format,
 };
 use Innmind\BlackBox\Set;
-use Fixtures\Innmind\TimeContinuum\Earth\PointInTime as FPointInTime;
+use Fixtures\Innmind\TimeContinuum\{
+    PointInTime as FPointInTime,
+    Earth as FEarth,
+};
 
 return static function() {
     yield proof(
         'PointInTime::ofFormat()',
         given(
-            FPointInTime::any(),
+            match (true) {
+                \class_exists(FEarth\PointInTime::class) => FEarth\PointInTime::any(),
+                default => FPointInTime::any(),
+            },
             Set\Strings::any(),
         ),
         static function($assert, $point, $random) {
-            $format = new ISO8601;
+            $format = match (true) {
+                \class_exists(ISO8601::class) => new ISO8601,
+                default => Format::of('Y-m-d\TH:i:s.uP'), // to support microseconds
+            };
             $string = $point->format($format);
-            $clock = new Clock;
+            $clock = match (true) {
+                \class_exists(Earth\Clock::class) => new Earth\Clock,
+                default => Clock::live(),
+            };
 
             $assert->true(
                 PointInTime::ofFormat($clock, $format)->asPredicate()($string),
@@ -58,8 +72,14 @@ static function($assert, $point, $random) {
             Set\Strings::any(),
         ),
         static function($assert, $expected, $random) {
-            $format = new ISO8601;
-            $clock = new Clock;
+            $format = match (true) {
+                \class_exists(ISO8601::class) => new ISO8601,
+                default => Format::iso8601(),
+            };
+            $clock = match (true) {
+                \class_exists(Earth\Clock::class) => new Earth\Clock,
+                default => Clock::live(),
+            };
 
             [[$path, $message]] = PointInTime::ofFormat($clock, $format)->withFailure($expected)($random)->match(
                 static fn() => null,
@@ -73,4 +93,33 @@ static function($assert, $expected, $random) {
             $assert->same($expected, $message);
         },
     );
+
+    yield test(
+        'PointInTime::ofFormat() with empty string fails',
+        static function($assert) {
+            $format = match (true) {
+                \class_exists(ISO8601::class) => new ISO8601,
+                default => Format::iso8601(),
+            };
+            $clock = match (true) {
+                \class_exists(Earth\Clock::class) => new Earth\Clock,
+                default => Clock::live(),
+            };
+
+            [[$path, $message]] = PointInTime::ofFormat($clock, $format)('')->match(
+                static fn() => null,
+                static fn($failures) => $failures
+                    ->map(static fn($failure) => [
+                        $failure->path()->toString(),
+                        $failure->message(),
+                    ])
+                    ->toList(),
+            );
+            $assert->same('$', $path);
+            $assert
+                ->string($message)
+                ->startsWith('Value is not a date of format ')
+                ->endsWith($format->toString());
+        },
+    );
 };

src/PointInTime.php

@@ -39,6 +39,12 @@ private function __construct(
 
     public function __invoke(mixed $value): Validation
     {
+        if ($value === '') {
+            return Validation::fail(Failure::of(
+                $this->message ?? "Value is not a date of format {$this->format->toString()}",
+            ));
+        }
+
         return $this->clock->at($value, $this->format)->match(
             static fn($point) => Validation::success($point),
             fn() => Validation::fail(Failure::of(