Unite the types WIP

Author: AydinHassan

app/bootstrap.php

@@ -24,6 +24,7 @@
 use PhpSchool\PHP8Appreciate\Exercise\HaveTheLastSay;
 use PhpSchool\PHP8Appreciate\Exercise\PhpPromotion;
 use PhpSchool\PHP8Appreciate\Exercise\LordOfTheStrings;
+use PhpSchool\PHP8Appreciate\Exercise\UniteTheTypes;
 use PhpSchool\PhpWorkshop\Application;
 
 $app = new Application('PHP8 Appreciate', __DIR__ . '/config.php');
@@ -33,6 +34,7 @@
 $app->addExercise(PhpPromotion::class);
 $app->addExercise(CautionWithCatches::class);
 $app->addExercise(LordOfTheStrings::class);
+$app->addExercise(UniteTheTypes::class);
 
 $art = <<<ART
         _ __ _

app/config.php

@@ -5,11 +5,11 @@
 use PhpSchool\PHP8Appreciate\Exercise\HaveTheLastSay;
 use PhpSchool\PHP8Appreciate\Exercise\PhpPromotion;
 use PhpSchool\PHP8Appreciate\Exercise\LordOfTheStrings;
+use PhpSchool\PHP8Appreciate\Exercise\UniteTheTypes;
 use Psr\Container\ContainerInterface;
 
 use function DI\create;
 use function DI\factory;
-use function DI\object;
 
 return [
     'basePath' => __DIR__ . '/../',
@@ -30,4 +30,7 @@
     LordOfTheStrings::class => function (ContainerInterface $c) {
         return new LordOfTheStrings($c->get(\Faker\Generator::class));
     },
+    UniteTheTypes::class => function (ContainerInterface $c) {
+        return new UniteTheTypes($c->get(PhpParser\Parser::class), $c->get(\Faker\Generator::class));
+    },
 ];

exercises/unite-the-types/problem/problem.md

@@ -0,0 +1,12 @@
+<?php
+
+function adder(string|float|int ...$numbers)
+{
+    return array_sum($numbers);
+}
+
+$nums = $argv;
+array_shift($nums);
+
+echo adder(...$nums) . "\n";
+

exercises/unite-the-types/solution/solution.php

@@ -0,0 +1,146 @@
+<?php
+
+
+namespace PhpSchool\PHP8Appreciate\Exercise;
+
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Stmt;
+use PhpParser\Node\Stmt\Function_;
+use PhpParser\Node\UnionType;
+use PhpParser\NodeFinder;
+use PhpParser\Parser;
+use PhpSchool\PhpWorkshop\CodeInsertion;
+use PhpSchool\PhpWorkshop\Exercise\AbstractExercise;
+use PhpSchool\PhpWorkshop\Exercise\CliExercise;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
+use PhpSchool\PhpWorkshop\Exercise\SubmissionPatchable;
+use PhpSchool\PhpWorkshop\ExerciseCheck\SelfCheck;
+use PhpSchool\PhpWorkshop\Input\Input;
+use PhpSchool\PhpWorkshop\Patch;
+use PhpSchool\PhpWorkshop\Result\Failure;
+use PhpSchool\PhpWorkshop\Result\ResultInterface;
+use PhpSchool\PhpWorkshop\Result\Success;
+use Faker\Generator as FakerGenerator;
+
+class UniteTheTypes extends AbstractExercise implements
+    ExerciseInterface,
+    CliExercise,
+    SelfCheck,
+    SubmissionPatchable
+{
+
+    private float $total;
+
+    public function __construct(private Parser $parser, private FakerGenerator $faker)
+    {
+    }
+
+    public function getName(): string
+    {
+        return 'Unite The Types';
+    }
+
+    public function getDescription(): string
+    {
+        return 'PHP 8\'s union types';
+    }
+
+    public function getType(): ExerciseType
+    {
+        return ExerciseType::CLI();
+    }
+
+    public function getArgs(): array
+    {
+        $numbers = array_map(
+            function (): string {
+                if ($this->faker->boolean) {
+                    return $this->faker->numberBetween(0, 50);
+                }
+                return $this->faker->randomFloat(3, 0, 50);
+            },
+            range(0, random_int(5, 15))
+        );
+
+        $this->total = array_sum($numbers);
+
+        return [$numbers];
+    }
+
+    public function getPatch(): Patch
+    {
+        $code = <<<'CODE'
+        declare(strict_types=1);
+        
+        $argv = array_map(function ($value) {
+            return match (true) {
+                (int) $value != (float) $value => (float) $value,
+                (bool) random_int(0, 1) => (int) $value,
+                default => (string) $value
+            };
+        }, $argv);
+        CODE;
+
+        $casterInsertion = new CodeInsertion(CodeInsertion::TYPE_BEFORE, $code);
+
+        return (new Patch())->withInsertion($casterInsertion);
+    }
+
+    public function check(Input $input): ResultInterface
+    {
+        /** @var array<Stmt> $statements */
+        $statements = $this->parser->parse((string) file_get_contents($input->getRequiredArgument('program')));
+
+        /** @var Function_|null $adder */
+        $adder = (new NodeFinder())->findFirst($statements, function (\PhpParser\Node $node) {
+            return $node instanceof Function_ && $node->name->toString() === 'adder';
+        });
+
+        if (null === $adder) {
+            return Failure::fromNameAndReason($this->getName(), 'No function named adder was found');
+        }
+
+        if (!isset($adder->params[0])) {
+            return Failure::fromNameAndReason($this->getName(), 'Function adder has no parameters');
+        }
+
+        /** @var \PhpParser\Node\Param $firstParam */
+        $firstParam = $adder->params[0];
+
+        if (!$firstParam->type instanceof UnionType) {
+            return Failure::fromNameAndReason(
+                $this->getName(),
+                'Function adder does not use a union type for it\'s first param'
+            );
+        }
+
+        $incorrectTypes = array_filter(
+            $firstParam->type->types,
+            fn ($type) => !$type instanceof Identifier
+        );
+
+        if (count($incorrectTypes)) {
+            return Failure::fromNameAndReason(
+                $this->getName(),
+                'Union type is incorrect, it should only accept the required types'
+            );
+        }
+
+        $types = array_map(
+            fn (Identifier $type) => $type->__toString(),
+            $firstParam->type->types
+        );
+
+        sort($types);
+
+        if ($types !== ['float', 'int', 'string']) {
+            return Failure::fromNameAndReason(
+                $this->getName(),
+                'Union type is incorrect, it should only accept the required types'
+            );
+        }
+
+        return new Success('Union type for adder is correct');
+    }
+}