Improve Interval tests and format

Author: nyamsprod

CHANGELOG.md

@@ -15,6 +15,7 @@ All Notable changes to `bakame/tokei` will be documented in this file.
 - `IntervalSet::nearest`
 - `Interval::fromFormat`
 - `Interval::roundTo`
+- `Interval::roundDurationTo`
 - `Duration::fromDateInterval`
 - `Duration::fromFormat`
 - `Duration::format`

README.md

@@ -576,6 +576,9 @@ Interval::expand(Duration $duration): self
 Interval::shift(Duration $duration): self
 Interval::shiftBound(Duration $duration, Bound $from): self
 Interval::lasting(Duration $duration, Bound $from): self
+Interval::roundTo(Unit $unit, SnapMode $mode): self
+Interval::roundDurationTo(Unit $unit, SnapMode $mode, Bound $anchor = Bound::Start): self
+Interval::lasting(Duration $duration, Bound $from): self
 Interval::complement(): self
 ```
 

src/EventTest.php

@@ -5,6 +5,7 @@
 namespace Bakame\Tokei;
 
 use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 
 #[CoversClass(Event::class)]
@@ -64,4 +65,96 @@ public function testWithAttributesReturnsNewTask(): void
         self::assertSame(['John'], $updated->identifiers->all());
         self::assertEquals($event->at, $updated->at);
     }
+
+    #[DataProvider('validFormats')]
+    public function testCanCreateEventFromFormattedString(
+        string $input,
+        string $expectedTime,
+        string $expectedIdentifier,
+    ): void {
+        $event = Event::fromFormat($input);
+
+        self::assertSame($expectedTime, $event->at->format());
+        self::assertSame($expectedIdentifier, $event->identifiers->formatted());
+    }
+
+    /**
+     * @return iterable<non-empty-string, array{0: string, 1: non-empty-string, 2: string}>
+     */
+    public static function validFormats(): iterable
+    {
+        yield 'no spaces' => [
+            '12:00:23;larry-king',
+            '12:00:23',
+            'larry-king',
+        ];
+
+        yield 'space after separator' => [
+            '12:00:23; larry-king',
+            '12:00:23',
+            'larry-king',
+        ];
+
+        yield 'space before separator' => [
+            '12:00:23 ;larry-king',
+            '12:00:23',
+            'larry-king',
+        ];
+
+        yield 'spaces around separator' => [
+            '12:00:23 ; larry-king',
+            '12:00:23',
+            'larry-king',
+        ];
+
+        yield 'multiple spaces around separator' => [
+            '12:00:23     ;     larry-king',
+            '12:00:23',
+            'larry-king',
+        ];
+
+        yield 'missing identifier' => [
+            '12:00:23;',
+            '12:00:23',
+            '',
+        ];
+
+        yield 'multiple spaces between identifier separator' => [
+            '12:00:23     ;     larry-king , junior',
+            '12:00:23',
+            'larry-king,junior',
+        ];
+    }
+
+    #[DataProvider('invalidFormats')]
+    public function testRejectsInvalidFormats(string $input): void
+    {
+        $this->expectException(TokeiException::class);
+
+        Event::fromFormat($input);
+    }
+
+    /**
+     * @return iterable<non-empty-string, array{0: string}>
+     */
+    public static function invalidFormats(): iterable
+    {
+        yield 'empty string' => [''];
+
+        yield 'missing separator' => [
+            '12:00:23 larry-king',
+        ];
+
+        yield 'missing time' => [
+            ';larry-king',
+        ];
+
+        yield 'invalid time' => [
+            '25:00:00;larry-king',
+        ];
+
+        yield 'extra separator' => [
+            '12:00:23;larry;king',
+        ];
+    }
 }

src/Identifiers.php

@@ -55,13 +55,20 @@ private static function sanitize(mixed $value): string
     private array $items;
 
     /**
-     * @param InputIdentifiers $items
+     * @param InputIdentifiers ...$items
      *
      * @throws TemporalException
      */
-    public function __construct(Identifiers|HasIdentifiers|iterable|string $items = [])
+    public function __construct(Identifiers|HasIdentifiers|iterable|string ...$items)
     {
-        $this->items = self::filterIdentifiers($items);
+        $found = [];
+        foreach ($items as $item) {
+            foreach (self::filterIdentifiers($item) as $value) {
+                $found[] = $value;
+            }
+        }
+
+        $this->items = array_values(array_unique($found));
     }
 
     /**

src/Interval.php

@@ -271,26 +271,38 @@ public function lasting(Duration $duration, Bound $from): self
      */
     public function expand(Duration $duration): self
     {
-        return self::between($this->start->shift($duration->negated()), $this->end->shift($duration));
+        $new = self::between($this->start->shift($duration->negated()), $this->end->shift($duration));
+
+        return $new->equals($this) ? $this : $new;
     }
 
     public function roundTo(Unit $unit, SnapMode $mode = SnapMode::Nearest): self
     {
-        $rounded = self::between($this->start->roundTo($unit, $mode), $this->end->roundTo($unit, $mode));
+        $new = self::between($this->start->roundTo($unit, $mode), $this->end->roundTo($unit, $mode));
+
+        return $new->equals($this) ? $this : $new;
+    }
+
+    public function roundDurationTo(Unit $unit, SnapMode $mode = SnapMode::Nearest, Bound $anchor = Bound::Start): self
+    {
+        $duration = $this->duration->roundTo($unit, $mode);
+        $new = Bound::Start === $anchor ? self::since($this->start, $duration) : self::until($this->end, $duration);
 
-        return $rounded->equals($this) ? $this : $rounded;
+        return $new->equals($this) ? $this : $new;
     }
 
     /**
      * @throws InvalidDuration
      */
     public function complement(): self
     {
-        return match ($this->type) {
+        $new = match ($this->type) {
             IntervalType::Collapsed => self::circular($this->start),
             IntervalType::Circular => self::collapsed($this->start),
             default => self::between($this->end, $this->start),
         };
+
+        return $new->equals($this) ? $this : $new;
     }
 
     /**

src/IntervalFormat.php

@@ -26,12 +26,10 @@ enum IntervalFormat
     case Iso8601DurationEnd;
     case Iso8601StartEnd;
     case Iso8601;
-    case Canonical;
 
     private const string REGEXP_ISO80000 = '/^\[(?<start>[^,)]*),(?<end>[^,)]*)\)$/';
     private const string REGEXP_BOURBAKI = '/^\[(?<start>[^,\[]*),(?<end>[^,\[]*)\[$/';
     private const string REGEXP_ISO8601 = '/^(?<start>[^\/]+)\/(?<end>[^\/]+)$/';
-    private const string REGEXP_CANONICAL = '/^(?<start>[^\/]+)\/(?<end>.+)\[\)$/';
 
     /**
      * @return non-empty-string
@@ -48,7 +46,6 @@ public function encode(Interval $interval, ?Unit $unit = null): string
             self::Iso8601StartEnd => $start.'/'.$end,
             self::Iso80000 => '['.$start.','.$end.')',
             self::Bourbaki => '['.$start.','.$end.'[',
-            self::Canonical => $start.'/'.$interval->duration->format().'[)',
         };
     }
 
@@ -61,7 +58,6 @@ public function decode(string $data, ?Unit $unit = null): Interval
         $pattern = match ($this) {
             self::Bourbaki => self::REGEXP_BOURBAKI,
             self::Iso80000 => self::REGEXP_ISO80000,
-            self::Canonical => self::REGEXP_CANONICAL,
             default => self::REGEXP_ISO8601,
         };
 
@@ -176,7 +172,6 @@ private function parseIso8601Interval(string $start, string $end, string $format
     private function supportsStartDuration(): bool
     {
         return match ($this) {
-            self::Canonical,
             self::Iso8601,
             self::Iso8601StartDuration => true,
             default => false,

src/IntervalTest.php

@@ -951,27 +951,6 @@ public function test_interval_formatting_improved(): void
         )->format(IntervalFormat::Bourbaki, Unit::Minute));
     }
 
-    /**
-     * @param non-empty-string $notation
-     */
-    #[DataProvider('invalidCanonicalNotation')]
-    public function test_it_can_not_decode_an_invalid_canonical_string(string $notation): void
-    {
-        $this->expectException(TimeException::class);
-
-        Interval::fromFormat('11:00:00/PT3M0.5S[]', IntervalFormat::Canonical);
-    }
-
-    /**
-     * @return iterable<non-empty-string, array{notation: non-empty-string}>
-     */
-    public static function invalidCanonicalNotation(): iterable
-    {
-        yield 'unsupported boundaries' => ['notation' => '11:00:00/PT3M0.5S[]'];
-        yield 'missing boundaries' => ['notation' => '11:00:00/PT3M0.5S'];
-        yield 'wrong notation' => ['notation' => '[11:00:00,12:00:00)'];
-    }
-
     public function test_fixing_split_at_overflow(): void
     {
         $interval = Interval::between(Time::at(22), Time::at(3));
@@ -1003,4 +982,36 @@ public function test_roundto_interval(): void
         self::assertTrue($updated->start->equals(Time::at(22, 14)));
         self::assertTrue($updated->end->equals(Time::at(3, 42)));
     }
+
+    public function test_roundDurationTo_interval_with_start_anchor(): void
+    {
+        $interval = Interval::between(
+            Time::at(22, 13, 35),
+            Time::at(3, 42, 27)
+        );
+
+        self::assertSame($interval, $interval->roundDurationTo(Unit::Second));
+
+        $updated = $interval->roundDurationTo(Unit::Minute);
+
+        self::assertNotEquals($updated, $interval);
+        self::assertTrue($updated->start->equals($interval->start));
+        self::assertFalse($updated->end->equals($interval->end));
+    }
+
+    public function test_roundDurationTo_interval_with_end_anchor(): void
+    {
+        $interval = Interval::between(
+            Time::at(22, 13, 35),
+            Time::at(3, 42, 27)
+        );
+
+        self::assertSame($interval, $interval->roundDurationTo(Unit::Second));
+
+        $updated = $interval->roundDurationTo(Unit::Minute, SnapMode::Nearest, Bound::End);
+
+        self::assertNotEquals($updated, $interval);
+        self::assertTrue($updated->end->equals($interval->end));
+        self::assertFalse($updated->start->equals($interval->start));
+    }
 }