Add tryFromMixed method to float classes, refine convertMixedToString calls, update tests, and restore UndefinedStandard functionality.

Author: georgedeploy

composer.json

@@ -46,6 +46,7 @@
       "composer validate --strict",
       "@cs",
       "@sca",
+      "@usage",
       "@test",
       "@type",
       "@coverage",

src/Abstract/Undefined/UndefinedType.php

@@ -25,61 +25,4 @@
  */
 abstract readonly class UndefinedType extends AbstractType implements UndefinedTypeInterface
 {
-    public static function create(): static
-    {
-        return new static();
-    }
-
-    public static function fromString(string $value): static
-    {
-        return new static();
-    }
-
-    /**
-     * @throws UndefinedTypeException
-     */
-    public function toInt(): never
-    {
-        throw new UndefinedTypeException('UndefinedType cannot be converted to integer.');
-    }
-
-    /**
-     * @throws UndefinedTypeException
-     */
-    public function toFloat(): never
-    {
-        throw new UndefinedTypeException('UndefinedType cannot be converted to float.');
-    }
-
-    /**
-     * @throws UndefinedTypeException
-     */
-    public function toString(): never
-    {
-        throw new UndefinedTypeException('UndefinedType cannot be converted to string.');
-    }
-
-    /**
-     * @throws UndefinedTypeException
-     */
-    public function value(): never
-    {
-        throw new UndefinedTypeException('UndefinedType has no value.');
-    }
-
-    /**
-     * @throws UndefinedTypeException
-     */
-    public function __toString(): string
-    {
-        throw new UndefinedTypeException('UndefinedType cannot be converted to string.');
-    }
-
-    /**
-     * @throws UndefinedTypeException
-     */
-    public function jsonSerialize(): never
-    {
-        throw new UndefinedTypeException('UndefinedType cannot be serialized for Json.');
-    }
 }

src/Float/FloatPositive.php

@@ -61,7 +61,9 @@ public static function tryFromString(string $value): static|Undefined
     public static function tryFromMixed(mixed $value): static|Undefined
     {
         try {
-            return static::fromString((string) $value);
+            return static::fromString(
+                static::convertMixedToString($value)
+            );
         } catch (TypeException) {
             return Undefined::create();
         }

src/Float/FloatStandard.php

@@ -37,6 +37,17 @@ public static function fromFloat(float $value): static
         return new static($value);
     }
 
+    public static function tryFromMixed(mixed $value): static|Undefined
+    {
+        try {
+            return static::fromString(
+                static::convertMixedToString($value)
+            );
+        } catch (TypeException) {
+            return Undefined::create();
+        }
+    }
+
     public static function tryFromString(string $value): static|Undefined
     {
         try {

src/Undefined/UndefinedStandard.php

@@ -5,6 +5,7 @@
 namespace PhpTypedValues\Undefined;
 
 use PhpTypedValues\Abstract\Undefined\UndefinedType;
+use PhpTypedValues\Exception\UndefinedTypeException;
 
 /**
  * Base implementation for a special "UndefinedStandard" typed value.
@@ -20,4 +21,61 @@
  */
 readonly class UndefinedStandard extends UndefinedType
 {
+    public static function create(): static
+    {
+        return new static();
+    }
+
+    public static function fromString(string $value): static
+    {
+        return new static();
+    }
+
+    /**
+     * @throws UndefinedTypeException
+     */
+    public function toInt(): never
+    {
+        throw new UndefinedTypeException('UndefinedType cannot be converted to integer.');
+    }
+
+    /**
+     * @throws UndefinedTypeException
+     */
+    public function toFloat(): never
+    {
+        throw new UndefinedTypeException('UndefinedType cannot be converted to float.');
+    }
+
+    /**
+     * @throws UndefinedTypeException
+     */
+    public function toString(): never
+    {
+        throw new UndefinedTypeException('UndefinedType cannot be converted to string.');
+    }
+
+    /**
+     * @throws UndefinedTypeException
+     */
+    public function value(): never
+    {
+        throw new UndefinedTypeException('UndefinedType has no value.');
+    }
+
+    /**
+     * @throws UndefinedTypeException
+     */
+    public function __toString(): string
+    {
+        throw new UndefinedTypeException('UndefinedType cannot be converted to string.');
+    }
+
+    /**
+     * @throws UndefinedTypeException
+     */
+    public function jsonSerialize(): never
+    {
+        throw new UndefinedTypeException('UndefinedType cannot be serialized for Json.');
+    }
 }

src/Usage/Primitive/Float.php

@@ -30,6 +30,7 @@
 echo FloatType::fromString('2.71828')->toString() . PHP_EOL;
 echo Double::fromString('2.71828')->toString() . PHP_EOL;
 echo Positive::fromString('2.8')->toString() . PHP_EOL;
+echo FloatStandard::tryFromMixed('2.8')->toString() . PHP_EOL;
 
 // PositiveFloat usage
 testPositiveFloat(FloatNonNegative::fromFloat(0.5)->value());

src/Usage/Primitive/Integer.php

@@ -44,8 +44,8 @@
 echo Integer::tryFromInt(127)->toString() . PHP_EOL;
 echo IntegerNonNegative::tryFromString('10')->toString() . PHP_EOL;
 echo IntegerPositive::tryFromString('10')->toString() . PHP_EOL;
-echo IntegerWeekDay::tryFromString('10')->toString() . PHP_EOL;
-echo IntegerTiny::tryFromString('10')->toString() . PHP_EOL;
+echo IntegerWeekDay::tryFromString('5')->toString() . PHP_EOL;
+echo IntegerTiny::tryFromString('1')->toString() . PHP_EOL;
 
 /**
  * Artificial functions.

tests/Unit/Abstract/AbstractTypeTest.php

@@ -5,13 +5,21 @@
 use PhpTypedValues\Abstract\AbstractType;
 use PhpTypedValues\Exception\TypeException;
 
+abstract readonly class AbstractTypeTest extends AbstractType
+{
+    public static function convert(mixed $value): string
+    {
+        return self::convertMixedToString($value);
+    }
+}
+
 it('convertMixedToString casts scalars and null to string', function (): void {
-    expect(AbstractType::convertMixedToString(123))->toBe('123')
-        ->and(AbstractType::convertMixedToString(1.5))->toBe('1.5')
-        ->and(AbstractType::convertMixedToString('foo'))->toBe('foo')
-        ->and(AbstractType::convertMixedToString(true))->toBe('1')
-        ->and(AbstractType::convertMixedToString(false))->toBe('')
-        ->and(AbstractType::convertMixedToString(null))->toBe('');
+    expect(AbstractTypeTest::convert(123))->toBe('123')
+        ->and(AbstractTypeTest::convert(1.5))->toBe('1.5')
+        ->and(AbstractTypeTest::convert('foo'))->toBe('foo')
+        ->and(AbstractTypeTest::convert(true))->toBe('1')
+        ->and(AbstractTypeTest::convert(false))->toBe('')
+        ->and(AbstractTypeTest::convert(null))->toBe('');
 });
 
 it('convertMixedToString accepts Stringable objects', function (): void {
@@ -22,22 +30,22 @@ public function __toString(): string
         }
     };
 
-    expect(AbstractType::convertMixedToString($obj))->toBe('3.5');
+    expect(AbstractTypeTest::convert($obj))->toBe('3.5');
 });
 
 it('convertMixedToString throws TypeException for non-stringable objects, arrays and resources', function (): void {
     // array
-    expect(fn() => AbstractType::convertMixedToString(['x']))
+    expect(fn() => AbstractTypeTest::convert(['x']))
         ->toThrow(TypeException::class, 'Value cannot be cast to string');
 
     // stdClass (non-stringable)
-    expect(fn() => AbstractType::convertMixedToString(new stdClass()))
+    expect(fn() => AbstractTypeTest::convert(new stdClass()))
         ->toThrow(TypeException::class, 'Value cannot be cast to string');
 
     // resource
     $res = fopen('php://memory', 'r');
     try {
-        expect(fn() => AbstractType::convertMixedToString($res))
+        expect(fn() => AbstractTypeTest::convert($res))
             ->toThrow(TypeException::class, 'Value cannot be cast to string');
     } finally {
         \is_resource($res) && fclose($res);

tests/Unit/Float/FloatPositiveTest.php

@@ -98,3 +98,51 @@
 it('jsonSerialize returns float', function (): void {
     expect(FloatPositive::tryFromString('1.1')->jsonSerialize())->toBeFloat();
 });
+
+it('__toString mirrors toString and value', function (): void {
+    $v = FloatPositive::fromFloat(3.14);
+
+    expect((string) $v)
+        ->toBe('3.14')
+        ->and($v->toString())
+        ->toBe('3.14')
+        ->and($v->value())
+        ->toBe(3.14);
+});
+
+it('tryFromMixed covers positive, non-positive, and non-numeric inputs', function (): void {
+    // Positive inputs
+    $fromNumericString = FloatPositive::tryFromMixed('1.2');
+    $fromInt = FloatPositive::tryFromMixed(3);
+    $fromFloat = FloatPositive::tryFromMixed(2.5);
+
+    // Non-positive inputs
+    $zero = FloatPositive::tryFromMixed(0);
+    $negative = FloatPositive::tryFromMixed(-1);
+
+    // Non-numeric inputs
+    $fromArray = FloatPositive::tryFromMixed([1]);
+    $fromNull = FloatPositive::tryFromMixed(null);
+
+    // Stringable object
+    $stringable = new class {
+        public function __toString(): string
+        {
+            return '1.23';
+        }
+    };
+    $fromStringable = FloatPositive::tryFromMixed($stringable);
+
+    expect($fromNumericString)->toBeInstanceOf(FloatPositive::class)
+        ->and($fromNumericString->value())->toBe(1.2)
+        ->and($fromInt)->toBeInstanceOf(FloatPositive::class)
+        ->and($fromInt->value())->toBe(3.0)
+        ->and($fromFloat)->toBeInstanceOf(FloatPositive::class)
+        ->and($fromFloat->value())->toBe(2.5)
+        ->and($zero)->toBeInstanceOf(Undefined::class)
+        ->and($negative)->toBeInstanceOf(Undefined::class)
+        ->and($fromArray)->toBeInstanceOf(Undefined::class)
+        ->and($fromNull)->toBeInstanceOf(Undefined::class)
+        ->and($fromStringable)->toBeInstanceOf(FloatPositive::class)
+        ->and($fromStringable->value())->toBe(1.23);
+});

tests/Unit/Float/FloatStandardTest.php

@@ -40,3 +40,45 @@
 it('jsonSerialize returns float', function (): void {
     expect(FloatStandard::tryFromString('1.1')->jsonSerialize())->toBeFloat();
 });
+
+it('__toString mirrors toString and value', function (): void {
+    $v = FloatStandard::fromFloat(3.14);
+
+    expect((string) $v)
+        ->toBe('3.14')
+        ->and($v->toString())
+        ->toBe('3.14')
+        ->and($v->value())
+        ->toBe(3.14);
+});
+
+it('tryFromMixed covers numeric, non-numeric, and stringable inputs', function (): void {
+    // Numeric inputs
+    $fromNumericString = FloatStandard::tryFromMixed('1.2');
+    $fromInt = FloatStandard::tryFromMixed(3);
+    $fromFloat = FloatStandard::tryFromMixed(2.5);
+
+    // Non-numeric inputs
+    $fromArray = FloatStandard::tryFromMixed([1]);
+    $fromNull = FloatStandard::tryFromMixed(null);
+
+    // Stringable object
+    $stringable = new class {
+        public function __toString(): string
+        {
+            return '1.23';
+        }
+    };
+    $fromStringable = FloatStandard::tryFromMixed($stringable);
+
+    expect($fromNumericString)->toBeInstanceOf(FloatStandard::class)
+        ->and($fromNumericString->value())->toBe(1.2)
+        ->and($fromInt)->toBeInstanceOf(FloatStandard::class)
+        ->and($fromInt->value())->toBe(3.0)
+        ->and($fromFloat)->toBeInstanceOf(FloatStandard::class)
+        ->and($fromFloat->value())->toBe(2.5)
+        ->and($fromArray)->toBeInstanceOf(Undefined::class)
+        ->and($fromNull)->toBeInstanceOf(Undefined::class)
+        ->and($fromStringable)->toBeInstanceOf(FloatStandard::class)
+        ->and($fromStringable->value())->toBe(1.23);
+});