allow vendord

vendor/beste/clock/src/Clock/FrozenClock.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Beste\Clock;
+
+use Beste\Clock;
+use DateTimeImmutable;
+use DateTimeZone;
+use Psr\Clock\ClockInterface;
+
+final class FrozenClock implements Clock
+{
+    private DateTimeImmutable $frozenAt;
+
+    private function __construct(DateTimeImmutable $frozenAt)
+    {
+        $this->frozenAt = $frozenAt;
+    }
+
+    public static function at(DateTimeImmutable $time): self
+    {
+        return new self($time);
+    }
+
+    public static function withNowFrom(ClockInterface $clock): self
+    {
+        return new self($clock->now());
+    }
+
+    public static function fromUTC(): self
+    {
+        return new self(new DateTimeImmutable('now', new DateTimeZone('UTC')));
+    }
+
+    public function setTo(DateTimeImmutable $time): self
+    {
+        $this->frozenAt = $time;
+
+        return $this;
+    }
+
+    public function now(): DateTimeImmutable
+    {
+        return clone $this->frozenAt;
+    }
+}

vendor/beste/clock/src/Clock/LocalizedClock.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Beste\Clock;
+
+use Beste\Clock;
+use DateTimeImmutable;
+use DateTimeZone;
+use InvalidArgumentException;
+use Throwable;
+
+final class LocalizedClock implements Clock
+{
+    private DateTimeZone $timeZone;
+
+    private function __construct(DateTimeZone $timeZone)
+    {
+        $this->timeZone = $timeZone;
+    }
+
+    /**
+     * @param DateTimeZone|string $timeZone
+     */
+    public static function in($timeZone): self
+    {
+        if (is_string($timeZone)) {
+            try {
+                $timeZone = new DateTimeZone($timeZone);
+            } catch (Throwable $e) {
+                throw new InvalidArgumentException($e->getMessage());
+            }
+        }
+
+        return new self($timeZone);
+    }
+
+    public function now(): DateTimeImmutable
+    {
+        return new DateTimeImmutable('now', $this->timeZone);
+    }
+}

vendor/beste/clock/src/Clock/MinuteClock.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Beste\Clock;
+
+use Beste\Clock;
+use DateTimeImmutable;
+use Psr\Clock\ClockInterface;
+
+final class MinuteClock implements Clock
+{
+    private ClockInterface $clock;
+
+    private function __construct(ClockInterface $clock)
+    {
+        $this->clock = $clock;
+    }
+
+    public static function wrapping(ClockInterface $clock): self
+    {
+        return new self($clock);
+    }
+
+    public function now(): DateTimeImmutable
+    {
+        return $this->floor($this->clock->now());
+    }
+
+    private function floor(DateTimeImmutable $now): DateTimeImmutable
+    {
+        return $now->setTime(
+            (int) $now->format('H'),
+            (int) $now->format('i')
+        );
+    }
+}

vendor/beste/clock/src/Clock/SystemClock.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Beste\Clock;
+
+use Beste\Clock;
+use DateTimeImmutable;
+
+final class SystemClock implements Clock
+{
+    private function __construct()
+    {
+    }
+
+    public static function create(): self
+    {
+        return new self();
+    }
+
+    public function now(): DateTimeImmutable
+    {
+        return new DateTimeImmutable();
+    }
+}

vendor/beste/clock/src/Clock/UTCClock.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Beste\Clock;
+
+use Beste\Clock;
+use DateTimeImmutable;
+use DateTimeZone;
+
+final class UTCClock implements Clock
+{
+    private DateTimeZone $timeZone;
+
+    private function __construct()
+    {
+        $this->timeZone = new DateTimeZone('UTC');
+    }
+
+    public static function create(): self
+    {
+        return new self();
+    }
+
+    public function now(): DateTimeImmutable
+    {
+        return new DateTimeImmutable('now', $this->timeZone);
+    }
+}

vendor/beste/clock/src/Clock/WrappingClock.php

@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Beste\Clock;
+
+use Beste\Clock;
+use DateTimeImmutable;
+use Psr\Clock\ClockInterface;
+
+final class WrappingClock implements Clock
+{
+    private ClockInterface $wrappedClock;
+
+    private function __construct(ClockInterface $wrappedClock)
+    {
+        $this->wrappedClock = $wrappedClock;
+    }
+
+    public static function wrapping(object $clock): self
+    {
+        if ($clock instanceof ClockInterface) {
+            return new self($clock);
+        }
+
+        if (!method_exists($clock, 'now')) {
+            throw new \InvalidArgumentException('$clock must implement StellaMaris\Clock\ClockInterface or have a now() method');
+        }
+
+        if (!($clock->now() instanceof DateTimeImmutable)) {
+            throw new \InvalidArgumentException('$clock->now() must return a DateTimeImmutable');
+        }
+
+        $wrappedClock = new class($clock) implements ClockInterface {
+            private object $clock;
+
+            public function __construct(object $clock)
+            {
+                $this->clock = $clock;
+            }
+
+            public function now(): \DateTimeImmutable
+            {
+                assert(method_exists($this->clock, 'now'));
+
+                $now = $this->clock->now();
+
+                assert($now instanceof \DateTimeImmutable);
+
+                return $now;
+            }
+        };
+
+        return new self($wrappedClock);
+    }
+
+    public function now(): DateTimeImmutable
+    {
+        return $this->wrappedClock->now();
+    }
+}