Code cleanup

src/Abstracts/BooleanValueObject.php

@@ -13,14 +13,14 @@ final protected function __construct(private bool $value)
     {
     }
 
-    final public function equals(?ValueObject $valueObject): bool
+    final public function asBoolean(): bool
     {
-        return $valueObject instanceof static && $valueObject->asBoolean() === $this->value;
+        return $this->value;
     }
 
-    final public function asBoolean(): bool
+    final public function equals(?ValueObject $valueObject): bool
     {
-        return $this->value;
+        return $valueObject instanceof static && $valueObject->asBoolean() === $this->value;
     }
 
     final public static function fromBoolean(bool $value): static

src/Abstracts/FloatValueObject.php

@@ -4,6 +4,7 @@
 
 use FrankVanHest\ValueObjects\Interfaces\FloatValueObject as FloatValueObjectInterface;
 use FrankVanHest\ValueObjects\Interfaces\ValueObject;
+use Throwable;
 
 abstract readonly class FloatValueObject implements FloatValueObjectInterface
 {
@@ -14,14 +15,14 @@ final protected function __construct(private float $value)
         $this->assert($this->value);
     }
 
-    final public function equals(?ValueObject $valueObject): bool
+    final public function asFloat(): float
     {
-        return $valueObject instanceof static && $valueObject->asFloat() === $this->value;
+        return $this->value;
     }
 
-    final public function asFloat(): float
+    final public function equals(?ValueObject $valueObject): bool
     {
-        return $this->value;
+        return $valueObject instanceof static && $valueObject->asFloat() === $this->value;
     }
 
     final public static function fromFloat(float $value): static
@@ -30,7 +31,7 @@ final public static function fromFloat(float $value): static
     }
 
     /**
-     * @throws \Throwable When the float value does not match the requirements
+     * @throws Throwable When the float value does not match the requirements
      */
     abstract protected function assert(float $value): void;
 }

src/Abstracts/IntegerValueObject.php

@@ -4,6 +4,7 @@
 
 use FrankVanHest\ValueObjects\Interfaces\IntegerValueObject as IntegerValueObjectInterface;
 use FrankVanHest\ValueObjects\Interfaces\ValueObject;
+use Throwable;
 
 abstract readonly class IntegerValueObject implements IntegerValueObjectInterface
 {
@@ -14,14 +15,14 @@ final private function __construct(private int $value)
         $this->assert($this->value);
     }
 
-    final public function equals(?ValueObject $valueObject): bool
+    final public function asInteger(): int
     {
-        return $valueObject instanceof static && $valueObject->asInteger() === $this->value;
+        return $this->value;
     }
 
-    final public function asInteger(): int
+    final public function equals(?ValueObject $valueObject): bool
     {
-        return $this->value;
+        return $valueObject instanceof static && $valueObject->asInteger() === $this->value;
     }
 
     final public static function fromInteger(int $value): static
@@ -30,7 +31,7 @@ final public static function fromInteger(int $value): static
     }
 
     /**
-     * @throws \Throwable When the integer value does not match the requirements
+     * @throws Throwable When the integer value does not match the requirements
      */
     abstract protected function assert(int $value): void;
 }

src/Abstracts/StringValueObject.php

@@ -4,6 +4,7 @@
 
 use FrankVanHest\ValueObjects\Interfaces\StringValueObject as StringValueObjectInterface;
 use FrankVanHest\ValueObjects\Interfaces\ValueObject;
+use Throwable;
 
 abstract readonly class StringValueObject implements StringValueObjectInterface
 {
@@ -30,7 +31,7 @@ final public static function fromString(string $value): static
     }
 
     /**
-     * @throws \Throwable When the string value does not match the requirements
+     * @throws Throwable When the string value does not match the requirements
      */
     abstract protected function assert(string $value): void;
 }

src/Exceptions/DontUseMagicMethodCall.php

@@ -4,8 +4,13 @@
 
 namespace FrankVanHest\ValueObjects\Exceptions;
 
-final class DontUseMagicMethodCall extends \LogicException
+use LogicException;
+
+final class DontUseMagicMethodCall extends LogicException
 {
+    /**
+     * @param class-string $class
+     */
     public function __construct(string $class)
     {
         parent::__construct(sprintf('Don\t use magic method __call in class %s', $class));

src/Exceptions/DontUseMagicMethodCallStatic.php

@@ -4,8 +4,13 @@
 
 namespace FrankVanHest\ValueObjects\Exceptions;
 
-final class DontUseMagicMethodCallStatic extends \LogicException
+use LogicException;
+
+final class DontUseMagicMethodCallStatic extends LogicException
 {
+    /**
+     * @param class-string $class
+     */
     public function __construct(string $class)
     {
         parent::__construct(sprintf('Don\t use magic method __callStatic in class %s', $class));

src/Exceptions/DontUseMagicMethodGet.php

@@ -4,8 +4,13 @@
 
 namespace FrankVanHest\ValueObjects\Exceptions;
 
-final class DontUseMagicMethodGet extends \LogicException
+use LogicException;
+
+final class DontUseMagicMethodGet extends LogicException
 {
+    /**
+     * @param class-string $class
+     */
     public function __construct(string $class)
     {
         parent::__construct(sprintf('Don\t use magic method __get in class %s', $class));

src/Exceptions/DontUseMagicMethodIsset.php

@@ -4,8 +4,13 @@
 
 namespace FrankVanHest\ValueObjects\Exceptions;
 
-final class DontUseMagicMethodIsset extends \LogicException
+use LogicException;
+
+final class DontUseMagicMethodIsset extends LogicException
 {
+    /**
+     * @param class-string $class
+     */
     public function __construct(string $class)
     {
         parent::__construct(sprintf('Don\t use magic method __isset in class %s', $class));

src/Exceptions/DontUseMagicMethodSet.php

@@ -4,8 +4,13 @@
 
 namespace FrankVanHest\ValueObjects\Exceptions;
 
-final class DontUseMagicMethodSet extends \LogicException
+use LogicException;
+
+final class DontUseMagicMethodSet extends LogicException
 {
+    /**
+     * @param class-string $class
+     */
     public function __construct(string $class)
     {
         parent::__construct(sprintf('Don\t use magic method __set in class %s', $class));

src/Exceptions/DontUseMagicMethodUnset.php

@@ -4,8 +4,13 @@
 
 namespace FrankVanHest\ValueObjects\Exceptions;
 
-final class DontUseMagicMethodUnset extends \LogicException
+use LogicException;
+
+final class DontUseMagicMethodUnset extends LogicException
 {
+    /**
+     * @param class-string $class
+     */
     public function __construct(string $class)
     {
         parent::__construct(sprintf('Don\t use magic method __unset in class %s', $class));

tests/Abstracts/BooleanValueObjectTest.php

@@ -12,12 +12,14 @@
 use FrankVanHest\ValueObjects\Interfaces\ValueObject;
 use FrankVanHest\ValueObjects\Tests\Dummies\AreWeGreat;
 use PHPUnit\Framework\TestCase;
+use ReflectionClass;
+use ReflectionMethod;
 
 final class BooleanValueObjectTest extends TestCase
 {
     public function testClassIsReadonly(): void
     {
-        self::assertTrue((new \ReflectionClass(BooleanValueObject::class))->isReadOnly());
+        self::assertTrue((new ReflectionClass(BooleanValueObject::class))->isReadOnly());
     }
 
     public function testEquals(): void
@@ -121,11 +123,11 @@ public function testPreventMagicUnset(): void
 
     public function testPreventedMagicMethodsAreFinal(): void
     {
-        self::assertTrue((new \ReflectionMethod(BooleanValueObject::class, '__call'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(BooleanValueObject::class, '__callStatic'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(BooleanValueObject::class, '__get'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(BooleanValueObject::class, '__isset'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(BooleanValueObject::class, '__set'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(BooleanValueObject::class, '__unset'))->isFinal());
+        self::assertTrue((new ReflectionMethod(BooleanValueObject::class, '__call'))->isFinal());
+        self::assertTrue((new ReflectionMethod(BooleanValueObject::class, '__callStatic'))->isFinal());
+        self::assertTrue((new ReflectionMethod(BooleanValueObject::class, '__get'))->isFinal());
+        self::assertTrue((new ReflectionMethod(BooleanValueObject::class, '__isset'))->isFinal());
+        self::assertTrue((new ReflectionMethod(BooleanValueObject::class, '__set'))->isFinal());
+        self::assertTrue((new ReflectionMethod(BooleanValueObject::class, '__unset'))->isFinal());
     }
 }

tests/Abstracts/FloatValueObjectTest.php

@@ -12,13 +12,15 @@
 use FrankVanHest\ValueObjects\Interfaces\ValueObject;
 use FrankVanHest\ValueObjects\Tests\Dummies\FloatGreaterThanZeroPointOne;
 use PHPUnit\Framework\TestCase;
+use ReflectionClass;
+use ReflectionMethod;
 use Throwable;
 
 final class FloatValueObjectTest extends TestCase
 {
     public function testClassIsReadonly(): void
     {
-        self::assertTrue((new \ReflectionClass(FloatValueObject::class))->isReadOnly());
+        self::assertTrue((new ReflectionClass(FloatValueObject::class))->isReadOnly());
     }
 
     public function testEquals(): void
@@ -133,11 +135,11 @@ public function testPreventMagicUnset(): void
 
     public function testPreventedMagicMethodsAreFinal(): void
     {
-        self::assertTrue((new \ReflectionMethod(FloatValueObject::class, '__call'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(FloatValueObject::class, '__callStatic'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(FloatValueObject::class, '__get'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(FloatValueObject::class, '__isset'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(FloatValueObject::class, '__set'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(FloatValueObject::class, '__unset'))->isFinal());
+        self::assertTrue((new ReflectionMethod(FloatValueObject::class, '__call'))->isFinal());
+        self::assertTrue((new ReflectionMethod(FloatValueObject::class, '__callStatic'))->isFinal());
+        self::assertTrue((new ReflectionMethod(FloatValueObject::class, '__get'))->isFinal());
+        self::assertTrue((new ReflectionMethod(FloatValueObject::class, '__isset'))->isFinal());
+        self::assertTrue((new ReflectionMethod(FloatValueObject::class, '__set'))->isFinal());
+        self::assertTrue((new ReflectionMethod(FloatValueObject::class, '__unset'))->isFinal());
     }
 }

tests/Abstracts/IntegerValueObjectTest.php

@@ -12,13 +12,15 @@
 use FrankVanHest\ValueObjects\Interfaces\ValueObject;
 use FrankVanHest\ValueObjects\Tests\Dummies\IntegerGreaterThanZero;
 use PHPUnit\Framework\TestCase;
+use ReflectionClass;
+use ReflectionMethod;
 use Throwable;
 
 final class IntegerValueObjectTest extends TestCase
 {
     public function testClassIsReadonly(): void
     {
-        self::assertTrue((new \ReflectionClass(IntegerValueObject::class))->isReadOnly());
+        self::assertTrue((new ReflectionClass(IntegerValueObject::class))->isReadOnly());
     }
 
     public function testEquals(): void
@@ -131,11 +133,11 @@ public function testPreventMagicUnset(): void
 
     public function testPreventedMagicMethodsAreFinal(): void
     {
-        self::assertTrue((new \ReflectionMethod(IntegerValueObject::class, '__call'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(IntegerValueObject::class, '__callStatic'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(IntegerValueObject::class, '__get'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(IntegerValueObject::class, '__isset'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(IntegerValueObject::class, '__set'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(IntegerValueObject::class, '__unset'))->isFinal());
+        self::assertTrue((new ReflectionMethod(IntegerValueObject::class, '__call'))->isFinal());
+        self::assertTrue((new ReflectionMethod(IntegerValueObject::class, '__callStatic'))->isFinal());
+        self::assertTrue((new ReflectionMethod(IntegerValueObject::class, '__get'))->isFinal());
+        self::assertTrue((new ReflectionMethod(IntegerValueObject::class, '__isset'))->isFinal());
+        self::assertTrue((new ReflectionMethod(IntegerValueObject::class, '__set'))->isFinal());
+        self::assertTrue((new ReflectionMethod(IntegerValueObject::class, '__unset'))->isFinal());
     }
 }

tests/Abstracts/StringValueObjectTest.php

@@ -12,13 +12,15 @@
 use FrankVanHest\ValueObjects\Interfaces\ValueObject;
 use FrankVanHest\ValueObjects\Tests\Dummies\NotEmptyString;
 use PHPUnit\Framework\TestCase;
+use ReflectionClass;
+use ReflectionMethod;
 use Throwable;
 
 final class StringValueObjectTest extends TestCase
 {
     public function testClassIsReadonly(): void
     {
-        self::assertTrue((new \ReflectionClass(StringValueObject::class))->isReadOnly());
+        self::assertTrue((new ReflectionClass(StringValueObject::class))->isReadOnly());
     }
 
     public function testEquals(): void
@@ -127,11 +129,11 @@ public function testPreventMagicUnset(): void
 
     public function testPreventedMagicMethodsAreFinal(): void
     {
-        self::assertTrue((new \ReflectionMethod(StringValueObject::class, '__call'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(StringValueObject::class, '__callStatic'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(StringValueObject::class, '__get'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(StringValueObject::class, '__isset'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(StringValueObject::class, '__set'))->isFinal());
-        self::assertTrue((new \ReflectionMethod(StringValueObject::class, '__unset'))->isFinal());
+        self::assertTrue((new ReflectionMethod(StringValueObject::class, '__call'))->isFinal());
+        self::assertTrue((new ReflectionMethod(StringValueObject::class, '__callStatic'))->isFinal());
+        self::assertTrue((new ReflectionMethod(StringValueObject::class, '__get'))->isFinal());
+        self::assertTrue((new ReflectionMethod(StringValueObject::class, '__isset'))->isFinal());
+        self::assertTrue((new ReflectionMethod(StringValueObject::class, '__set'))->isFinal());
+        self::assertTrue((new ReflectionMethod(StringValueObject::class, '__unset'))->isFinal());
     }
 }

tests/Factories/FloatValueObjectFactoryTest.php

@@ -11,15 +11,6 @@
 
 final class FloatValueObjectFactoryTest extends TestCase
 {
-    public function testFactoryWithoutValueAlteration(): void
-    {
-        $valueObject = FloatValueObjectFactory::create(FloatGreaterThanZeroPointOne::class, 0.2);
-        self::assertInstanceOf(
-            FloatGreaterThanZeroPointOne::class,
-            $valueObject
-        );
-    }
-
     public function testFactoryWithValueAlteration(): void
     {
         $valueModifierFirst = new AddFloatValue(0.2);
@@ -36,4 +27,13 @@ public function testFactoryWithValueAlteration(): void
         );
         self::assertSame(0.7, $valueObject->asFloat());
     }
+
+    public function testFactoryWithoutValueAlteration(): void
+    {
+        $valueObject = FloatValueObjectFactory::create(FloatGreaterThanZeroPointOne::class, 0.2);
+        self::assertInstanceOf(
+            FloatGreaterThanZeroPointOne::class,
+            $valueObject
+        );
+    }
 }

tests/Factories/IntegerValueObjectFactoryTest.php

@@ -11,15 +11,6 @@
 
 final class IntegerValueObjectFactoryTest extends TestCase
 {
-    public function testFactoryWithoutValueAlteration(): void
-    {
-        $valueObject = IntegerValueObjectFactory::create(IntegerGreaterThanZero::class, 2);
-        self::assertInstanceOf(
-            IntegerGreaterThanZero::class,
-            $valueObject
-        );
-    }
-
     public function testFactoryWithValueAlteration(): void
     {
         $valueModifierFirst = new MultiplyIntegerValue(2);
@@ -36,4 +27,13 @@ public function testFactoryWithValueAlteration(): void
         );
         self::assertSame(8, $valueObject->asInteger());
     }
+
+    public function testFactoryWithoutValueAlteration(): void
+    {
+        $valueObject = IntegerValueObjectFactory::create(IntegerGreaterThanZero::class, 2);
+        self::assertInstanceOf(
+            IntegerGreaterThanZero::class,
+            $valueObject
+        );
+    }
 }