fix: separated mapper modules

Author: patrykbaszak

src/Blueprint/Application/Model/Assets/AttributeBlueprint.php

@@ -10,7 +10,7 @@
 
 class AttributeBlueprint implements Normalizable
 {
-    public ClassBlueprint|PropertyBlueprint $parent;
+    public ClassBlueprint|ParameterBlueprint|PropertyBlueprint $parent;
 
     /** @var class-string */
     public string $class;
@@ -20,7 +20,7 @@ class AttributeBlueprint implements Normalizable
     public false|string $filePath;
     public false|string $fileHash;
 
-    public static function create(\ReflectionAttribute $attribute, ClassBlueprint|PropertyBlueprint $parent): self
+    public static function create(\ReflectionAttribute $attribute, ClassBlueprint|ParameterBlueprint|PropertyBlueprint $parent): self
     {
         $instance = new self();
         $instance->parent = $parent;

src/Blueprint/Application/Model/Type.php

@@ -57,7 +57,7 @@ public function getAllClassTypes(): array
     {
         $classTypes = [];
         $function = function ($type) use (&$classTypes) {
-            if (class_exists($type)) {
+            if (class_exists($type, false) || interface_exists($type, false)) {
                 $classTypes[] = $type;
             }
         };

src/Build/Application/Model/Assets/ClassCard.php

@@ -9,9 +9,6 @@
 
 class Briefcase
 {
-    /** @var Assets\ClassCard[] */
-    public array $classes = [];
-
     public function __construct(
         public Blueprint $origin,
         public TypeInterface $from,

src/Build/Application/Model/Assets/ConstructorCard.php

@@ -8,14 +8,13 @@
 use PBaszak\UltraMapper\Blueprint\Application\Model\Blueprint;
 use PBaszak\UltraMapper\Build\Application\Contract\BuilderInterface;
 use PBaszak\UltraMapper\Mapper\Application\Contract\MapperInterface;
-use PBaszak\UltraMapper\Mapper\Application\Contract\ModificatorInterface;
 use PBaszak\UltraMapper\Mapper\Application\Contract\TypeInterface;
 use PBaszak\UltraMapper\Mapper\Application\Model\Context;
 use PBaszak\UltraMapper\Mapper\Application\Model\Envelope;
 use PBaszak\UltraMapper\Mapper\Domain\Contract\ClassMapperInterface;
+use PBaszak\UltraMapper\Mapper\Domain\Modules;
 use PBaszak\UltraMapper\Mapper\Domain\Resolver\MapperResolver;
 use PBaszak\UltraMapper\Mapper\Domain\Resolver\ProcessResolver;
-use PBaszak\UltraMapper\Mapper\Domain\Service\Matcher;
 
 class Mapper implements MapperInterface
 {
@@ -38,10 +37,16 @@ class Mapper implements MapperInterface
     public bool $throwExceptionWhenMappingError = false;
 
     public function __construct(
-        protected BlueprintInterface $blueprint,
-        protected BuilderInterface $build,
         protected MapperResolver $mapperResolver,
-        protected ModificatorInterface $modificator,
+        protected BlueprintInterface $blueprint,
+
+        // Build module - required for the mapper creation
+        protected BuilderInterface $builder,
+        // blueprint preparation modules - required for the mapper creation
+        protected Modules\Checker\Contract\CheckerInterface $checker,
+        protected Modules\Extender\Contract\ExtenderInterface $extender,
+        protected Modules\Matcher\Contract\MatcherInterface $matcher,
+        protected Modules\Modificator\Contract\ModificatorInterface $modificator,
     ) {
     }
 
@@ -78,13 +83,17 @@ protected function getMapper(
             $processType = (new ProcessResolver())->resolve($from, $to);
 
             foreach ($blueprints as $processUse => $blueprint) {
-                $this->modificator->prepareBlueprint($blueprint, $processType, $processUse);
-            }
+                do {
+                    $hasExtended = $this->extender->extend($blueprint, $processType, $context);
+                    $hasModified = $this->modificator->modify($blueprint, $processType, $context, $processUse);
+                } while ($hasExtended || $hasModified);
 
-            (new Matcher())->matchBlueprints($context, $processType, ...$blueprints);
+                $this->checker->check($blueprint, $processType, $context);
+            }
 
-            // modify blueprints
+            $this->matcher->matchBlueprints($context, $processType, ...$blueprints);
 
+            // not implemented yet
             // $build = $this->build->build(
             //     $shortName,
             //     $blueprints,

src/Build/Application/Model/Assets/ParameterCard.php

@@ -30,9 +30,11 @@ class ClassObjectType implements TypeInterface
      * @param bool              $canUseDirectProperty    Requires public properties. If the property is not public, it will be ignored.
      * @param bool              $canUseConstructor       Requires the parameters with the same name as the properties. You can use
      *                                                   #[TargetProperty] attribute on parameters to map them to the properties.
+     *                                                   Recommended for the creation of the objects from the incoming data.
      * @param bool              $canUseGettersAndSetters #[Accessor] attribute ignores this flag. If `true`, then
      *                                                   UltraMapper will search for the getter and setter methods.
      * @param bool              $canUseReflectionClass   Probably the slowest option but the most universal. Still is fast enough.
+     *                                                   Recommended for recreation of the objects from persistence.
      */
     public function __construct(
         /** @var class-string|null */

src/Build/Application/Model/Assets/PropertyCard.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PBaszak\UltraMapper\Mapper\Domain\Modules\Checker;
+
+use PBaszak\UltraMapper\Blueprint\Application\Model\Blueprint;
+use PBaszak\UltraMapper\Mapper\Application\Model\Context;
+use PBaszak\UltraMapper\Mapper\Domain\Model\Process;
+
+class Checker implements Contract\CheckerInterface
+{
+    /**
+     * @param array<Contract\CheckerStrategyInterface> $strategies
+     */
+    public function __construct(
+        private array $strategies
+    ) {
+    }
+
+    public function check(Blueprint $blueprint, Process $process, Context $context): void
+    {
+        foreach ($this->strategies as $strategy) {
+            $strategy->check($blueprint, $process, $context);
+        }
+    }
+}