Release/2.0.0 (#22)

* feat: Removes unreachable code from internal classes, simplify value object unwrapping, and reorganize test suite.

Author: gustavofreze

.github/workflows/ci.yml

@@ -8,7 +8,6 @@ permissions:
 
 env:
   PHP_VERSION: '8.5'
-  COMPOSER_ROOT_VERSION: '1.2.0'
 
 jobs:
   build:
@@ -23,7 +22,6 @@ jobs:
         uses: shivammathur/setup-php@v2
         with:
           php-version: ${{ env.PHP_VERSION }}
-          extensions: bcmath
           tools: composer:2
 
       - name: Validate composer.json
@@ -53,7 +51,6 @@ jobs:
         uses: shivammathur/setup-php@v2
         with:
           php-version: ${{ env.PHP_VERSION }}
-          extensions: bcmath
           tools: composer:2
 
       - name: Download vendor artifact from build
@@ -78,7 +75,6 @@ jobs:
         uses: shivammathur/setup-php@v2
         with:
           php-version: ${{ env.PHP_VERSION }}
-          extensions: bcmath
           tools: composer:2
 
       - name: Download vendor artifact from build

composer.json

@@ -25,11 +25,6 @@
         "issues": "https://github.com/tiny-blocks/mapper/issues",
         "source": "https://github.com/tiny-blocks/mapper"
     },
-    "extra": {
-        "branch-alias": {
-            "dev-develop": "1.3.x-dev"
-        }
-    },
     "config": {
         "sort-packages": true,
         "allow-plugins": {
@@ -43,7 +38,7 @@
     },
     "autoload-dev": {
         "psr-4": {
-            "TinyBlocks\\Mapper\\": "tests/"
+            "Test\\TinyBlocks\\Mapper\\": "tests/"
         }
     },
     "require": {
@@ -53,8 +48,7 @@
         "phpunit/phpunit": "^11.5",
         "phpstan/phpstan": "^2.1",
         "infection/infection": "^0.32",
-        "tiny-blocks/collection": "1.10.*",
-        "squizlabs/php_codesniffer": "^3.13"
+        "squizlabs/php_codesniffer": "^4.0"
     },
     "scripts": {
         "test": "php -d memory_limit=2G ./vendor/bin/phpunit --configuration phpunit.xml tests",

phpstan.neon.dist

@@ -4,11 +4,11 @@ parameters:
   level: 9
   tmpDir: report/phpstan
   ignoreErrors:
-    - '#method#'
-    - '#expects#'
-    - '#should return#'
+    - '#T of#'
+    - '#mixed#'
+    - '#UnitEnum#'
+    - '#Reflection#'
+    - '#Traversable#'
     - '#is used zero times#'
-    - '#type mixed supplied#'
-    - '#not specify its types#'
-    - '#no value type specified#'
+    - '#type specified in iterable type#'
   reportUnmatchedIgnoredErrors: false

src/Internal/Builders/ObjectBuilder.php

@@ -0,0 +1,98 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TinyBlocks\Mapper\Internal\Builders;
+
+use ReflectionClass;
+use ReflectionException;
+use ReflectionMethod;
+use ReflectionParameter;
+use TinyBlocks\Mapper\Internal\Extractors\ReflectionExtractor;
+use TinyBlocks\Mapper\Internal\Mappers\Object\Casters\CasterHandler;
+
+final readonly class ObjectBuilder
+{
+    public function __construct(private ReflectionExtractor $extractor)
+    {
+    }
+
+    /**
+     * @template T of object
+     * @param class-string<T> $class
+     * @return T
+     * @throws ReflectionException
+     */
+    public function build(iterable $iterable, string $class): object
+    {
+        $reflection = new ReflectionClass(objectOrClass: $class);
+        $parameters = $this->extractor->extractConstructorParameters(class: $class);
+        $inputProperties = iterator_to_array(iterator: $iterable);
+
+        $arguments = $this->buildArguments(
+            parameters: $parameters,
+            inputProperties: $inputProperties
+        );
+
+        return $this->instantiate(reflection: $reflection, arguments: $arguments);
+    }
+
+    protected function buildArguments(array $parameters, array $inputProperties): array
+    {
+        $arguments = [];
+
+        /** @var ReflectionParameter $parameter */
+        foreach ($parameters as $parameter) {
+            $name = $parameter->getName();
+            $value = $inputProperties[$name] ?? null;
+
+            $arguments[] = $value !== null
+                ? $this->castValue(parameter: $parameter, value: $value)
+                : $this->getDefaultValue(parameter: $parameter);
+        }
+
+        return $arguments;
+    }
+
+    protected function castValue(ReflectionParameter $parameter, mixed $value): mixed
+    {
+        $caster = new CasterHandler(parameter: $parameter);
+        return $caster->castValue(value: $value);
+    }
+
+    protected function getDefaultValue(ReflectionParameter $parameter): mixed
+    {
+        return $parameter->isDefaultValueAvailable()
+            ? $parameter->getDefaultValue()
+            : null;
+    }
+
+    protected function instantiate(ReflectionClass $reflection, array $arguments): object
+    {
+        $constructor = $reflection->getConstructor();
+
+        if ($constructor === null) {
+            return $reflection->newInstance();
+        }
+
+        if ($constructor->isPrivate()) {
+            return $this->instantiateWithPrivateConstructor(
+                reflection: $reflection,
+                constructor: $constructor,
+                arguments: $arguments
+            );
+        }
+
+        return $reflection->newInstanceArgs(args: $arguments);
+    }
+
+    protected function instantiateWithPrivateConstructor(
+        ReflectionClass $reflection,
+        ReflectionMethod $constructor,
+        array $arguments
+    ): object {
+        $instance = $reflection->newInstanceWithoutConstructor();
+        $constructor->invokeArgs(object: $instance, args: $arguments);
+        return $instance;
+    }
+}

src/Internal/Detectors/DateTimeDetector.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TinyBlocks\Mapper\Internal\Detectors;
+
+use DateTimeInterface;
+
+final readonly class DateTimeDetector implements TypeDetector
+{
+    public function matches(mixed $value): bool
+    {
+        return $value instanceof DateTimeInterface;
+    }
+}

src/Internal/Detectors/EnumDetector.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TinyBlocks\Mapper\Internal\Detectors;
+
+use UnitEnum;
+
+final readonly class EnumDetector implements TypeDetector
+{
+    public function matches(mixed $value): bool
+    {
+        return $value instanceof UnitEnum;
+    }
+}

src/Internal/Detectors/TypeDetector.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TinyBlocks\Mapper\Internal\Detectors;
+
+/**
+ * Defines the contract for type detection strategies.
+ */
+interface TypeDetector
+{
+    /**
+     * Determines if the given value matches the detector's type criteria.
+     *
+     * @param mixed $value The value to detect.
+     * @return bool True if the value matches, false otherwise.
+     */
+    public function matches(mixed $value): bool;
+}

src/Internal/Detectors/ValueObjectDetector.php

@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TinyBlocks\Mapper\Internal\Detectors;
+
+use ReflectionClass;
+use ReflectionProperty;
+use UnitEnum;
+
+final readonly class ValueObjectDetector implements TypeDetector
+{
+    private const int SINGLE_PROPERTY = 1;
+
+    public function matches(mixed $value): bool
+    {
+        $reflection = new ReflectionClass($value);
+        $properties = $reflection->getProperties(
+            ReflectionProperty::IS_PUBLIC
+            | ReflectionProperty::IS_PROTECTED
+            | ReflectionProperty::IS_PRIVATE
+        );
+
+        return !$value instanceof UnitEnum && count($properties) === self::SINGLE_PROPERTY;
+    }
+}

src/Internal/Exceptions/InvalidCast.php

@@ -11,7 +11,6 @@ final class InvalidCast extends InvalidArgumentException
     public static function forEnumValue(int|string $value, string $class): InvalidCast
     {
         $message = sprintf('Invalid value <%s> for enum <%s>.', $value, $class);
-
         return new InvalidCast(message: $message);
     }
 }

src/Internal/Extractors/IterableExtractor.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TinyBlocks\Mapper\Internal\Extractors;
+
+use Traversable;
+
+final readonly class IterableExtractor implements PropertyExtractor
+{
+    public function __construct(private ReflectionExtractor $extractor)
+    {
+    }
+
+    public function extract(object $object): array
+    {
+        $properties = $this->extractor->extractProperties(object: $object);
+
+        $candidates = array_filter(
+            $properties,
+            static fn(mixed $value): bool => is_array($value) || $value instanceof Traversable
+        );
+
+        $iterable = reset($candidates);
+
+        return is_array($iterable) ? $iterable : iterator_to_array($iterable);
+    }
+}