update union

Author: nejcdev

Tests/UnionTest.php

@@ -0,0 +1,105 @@
+<?php
+declare(strict_types=1);
+
+namespace Nejcc\PhpDatatypes\Tests;
+
+use DateTime;
+use InvalidArgumentException;
+use Nejcc\PhpDatatypes\Composite\Union\Union;
+use PHPUnit\Framework\TestCase;
+use stdClass;
+
+class UnionTest extends TestCase
+{
+    /**
+     * Test the constructor sets the allowed types.
+     */
+    public function testConstructorSetsAllowedTypes()
+    {
+        $union = new Union(['int', 'string']);
+        $this->assertInstanceOf(Union::class, $union);
+    }
+
+    /**
+     * Test that setting a valid value works.
+     */
+    public function testSetValueWithValidType()
+    {
+        $union = new Union(['int', 'string']);
+        $union->setValue(123);
+        $this->assertEquals(123, $union->getValue());
+
+        $union->setValue('hello');
+        $this->assertEquals('hello', $union->getValue());
+    }
+
+    /**
+     * Test that setting an invalid type throws an exception.
+     */
+    public function testSetValueWithInvalidTypeThrowsException()
+    {
+        $union = new Union(['int', 'string']);
+
+        $this->expectException(InvalidArgumentException::class);
+        $union->setValue(1.5); // float is not allowed
+    }
+
+    /**
+     * Test that object type validation works.
+     */
+    public function testSetValueWithObjectType()
+    {
+        $union = new Union([DateTime::class]);
+        $date = new DateTime();
+
+        $union->setValue($date);
+        $this->assertEquals($date, $union->getValue());
+    }
+
+    /**
+     * Test that dynamically adding allowed types works.
+     */
+    public function testAddAllowedType()
+    {
+        $union = new Union(['int']);
+        $union->addAllowedType('float');
+
+        $union->setValue(1.5);
+        $this->assertEquals(1.5, $union->getValue());
+    }
+
+    /**
+     * Test that isType works for scalar types.
+     */
+    public function testIsTypeWithScalarTypes()
+    {
+        $union = new Union(['int', 'string']);
+        $union->setValue(123);
+
+        $this->assertTrue($union->isType('int'));
+        $this->assertFalse($union->isType('string'));
+    }
+
+    /**
+     * Test that isType works for object types.
+     */
+    public function testIsTypeWithObjectTypes()
+    {
+        $union = new Union([DateTime::class]);
+        $date = new DateTime();
+
+        $union->setValue($date);
+        $this->assertTrue($union->isType(DateTime::class));
+    }
+
+    /**
+     * Test that validateType correctly handles invalid object types.
+     */
+    public function testValidateTypeThrowsExceptionForInvalidObjectType()
+    {
+        $union = new Union([DateTime::class]);
+
+        $this->expectException(InvalidArgumentException::class);
+        $union->setValue(new stdClass()); // stdClass is not allowed
+    }
+}

src/Composite/Union/Union.php

@@ -7,26 +7,48 @@
 final class Union
 {
     /**
+     * The current value of the union.
+     *
      * @var mixed
      */
     private mixed $value;
 
     /**
+     * The allowed types for this union.
+     *
      * @var array
      */
     private array $allowedTypes;
 
     /**
+     * A mapping of PHP shorthand types to their gettype() equivalents.
+     *
+     * @var array
+     */
+    private static array $typeMap = [
+        'int' => 'integer',
+        'float' => 'double',
+        'bool' => 'boolean',
+    ];
+
+    /**
+     * Create a new Union instance with allowed types.
+     *
      * @param array $allowedTypes
+     * @return void
      */
     public function __construct(array $allowedTypes)
     {
         $this->allowedTypes = $allowedTypes;
     }
 
     /**
+     * Set the value of the union, validating the type.
+     *
      * @param mixed $value
      * @return void
+     *
+     * @throws InvalidArgumentException
      */
     public function setValue(mixed $value): void
     {
@@ -35,6 +57,8 @@ public function setValue(mixed $value): void
     }
 
     /**
+     * Get the current value of the union.
+     *
      * @return mixed
      */
     public function getValue(): mixed
@@ -43,15 +67,65 @@ public function getValue(): mixed
     }
 
     /**
+     * Validate the type of the value against allowed types.
+     *
      * @param mixed $value
      * @return void
+     *
+     * @throws InvalidArgumentException
      */
     private function validateType(mixed $value): void
     {
         $type = gettype($value);
 
+        // If the type is in the type map, convert to the shorthand notation
+        $shorthandType = array_search($type, self::$typeMap, true);
+        if ($shorthandType) {
+            $type = $shorthandType;
+        }
+
+        // If it's a class, validate using 'instanceof' for better OOP support.
+        foreach ($this->allowedTypes as $allowedType) {
+            if (class_exists($allowedType) && $value instanceof $allowedType) {
+                return;
+            }
+        }
+
+        // Check against the allowed types array.
+        if (!in_array($type, $this->allowedTypes, true)) {
+            throw new InvalidArgumentException(
+                "Invalid type: $type. Allowed types: " . implode(', ', $this->allowedTypes)
+            );
+        }
+    }
+
+    /**
+     * Determine if the current value is of a specific type.
+     *
+     * @param string $type
+     * @return bool
+     */
+    public function isType(string $type): bool
+    {
+        $actualType = gettype($this->value);
+
+        // Map to shorthand if applicable
+        $shorthandType = array_search($actualType, self::$typeMap, true);
+        $actualType = $shorthandType ?: $actualType;
+
+        return $actualType === $type || $this->value instanceof $type;
+    }
+
+    /**
+     * Add a new type to the allowed types of the union.
+     *
+     * @param string $type
+     * @return void
+     */
+    public function addAllowedType(string $type): void
+    {
         if (!in_array($type, $this->allowedTypes, true)) {
-            throw new InvalidArgumentException("Invalid type: $type. Allowed types: " . implode(', ', $this->allowedTypes));
+            $this->allowedTypes[] = $type;
         }
     }
 }