Initial static return exercise

Author: AydinHassan

app/bootstrap.php

@@ -27,6 +27,7 @@
 use PhpSchool\PHP8Appreciate\Exercise\InfiniteDivisions;
 use PhpSchool\PHP8Appreciate\Exercise\PhpPromotion;
 use PhpSchool\PHP8Appreciate\Exercise\LordOfTheStrings;
+use PhpSchool\PHP8Appreciate\Exercise\TheReturnOfStatic;
 use PhpSchool\PHP8Appreciate\Exercise\UniteTheTypes;
 use PhpSchool\PhpWorkshop\Application;
 
@@ -41,6 +42,7 @@
 $app->addExercise(InfiniteDivisions::class);
 $app->addExercise(ASafeSpaceForNulls::class);
 $app->addExercise(AllMixedUp::class);
+$app->addExercise(TheReturnOfStatic::class);
 
 $art = <<<ART
         _ __ _

app/config.php

@@ -8,6 +8,7 @@
 use PhpSchool\PHP8Appreciate\Exercise\InfiniteDivisions;
 use PhpSchool\PHP8Appreciate\Exercise\PhpPromotion;
 use PhpSchool\PHP8Appreciate\Exercise\LordOfTheStrings;
+use PhpSchool\PHP8Appreciate\Exercise\TheReturnOfStatic;
 use PhpSchool\PHP8Appreciate\Exercise\UniteTheTypes;
 use Psr\Container\ContainerInterface;
 
@@ -44,5 +45,8 @@
     },
     AllMixedUp::class => function (ContainerInterface $c) {
         return new AllMixedUp($c->get(PhpParser\Parser::class), $c->get(\Faker\Generator::class));
+    },
+    TheReturnOfStatic::class => function (ContainerInterface $c) {
+        return new TheReturnOfStatic($c->get(PhpParser\Parser::class));
     }
 ];

exercises/the-return-of-static/initial/the-return-of-static.php

@@ -0,0 +1,38 @@
+<?php
+
+class File
+{
+    private ?string $permissions = null;
+    public function withPermissions(string $permissions): static
+    {
+        $clone = new self();
+        $clone->permissions = $permissions;
+        return $clone;
+    }
+}
+
+class Image extends File
+{
+    private ?string $ext = null;
+    private ?string $crop = null;
+
+    public function withExt(string $ext): static
+    {
+        $clone = clone $this;
+        $clone->ext = $ext;
+        return $clone;
+    }
+
+    public function withCrop(string $crop): static
+    {
+        $clone = clone $this;
+        $clone->crop = $crop;
+        return $clone;
+    }
+}
+$image = (new Image())
+    ->withPermissions('w+')
+    ->withExt('jpeg')
+    ->withCrop('16x9');
+
+var_dump($image);

exercises/the-return-of-static/problem/problem.md

@@ -0,0 +1,38 @@
+<?php
+
+class File
+{
+    private ?string $permissions = null;
+    public function withPermissions(string $permissions): static
+    {
+        $clone = clone $this;
+        $clone->permissions = $permissions;
+        return $clone;
+    }
+}
+
+class Image extends File
+{
+    private ?string $ext = null;
+    private ?string $crop = null;
+
+    public function withExt(string $ext): static
+    {
+        $clone = clone $this;
+        $clone->ext = $ext;
+        return $clone;
+    }
+
+    public function withCrop(string $crop): static
+    {
+        $clone = clone $this;
+        $clone->crop = $crop;
+        return $clone;
+    }
+}
+$image = (new Image())
+    ->withPermissions('w+')
+    ->withExt('jpeg')
+    ->withCrop('16x9');
+
+var_dump($image);

exercises/the-return-of-static/solution/solution.php

@@ -0,0 +1,127 @@
+<?php
+
+namespace PhpSchool\PHP8Appreciate\Exercise;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\Assign;
+use PhpParser\Node\Expr\Clone_;
+use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Stmt;
+use PhpParser\Node\Stmt\ClassMethod;
+use PhpParser\Node\Stmt\Expression;
+use PhpParser\Node\Stmt\Function_;
+use PhpParser\NodeFinder;
+use PhpParser\Parser;
+use PhpSchool\PhpWorkshop\Exercise\AbstractExercise;
+use PhpSchool\PhpWorkshop\Exercise\CliExercise;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
+use PhpSchool\PhpWorkshop\Exercise\ProvidesInitialCode;
+use PhpSchool\PhpWorkshop\ExerciseCheck\SelfCheck;
+use PhpSchool\PhpWorkshop\Input\Input;
+use PhpSchool\PhpWorkshop\Result\Failure;
+use PhpSchool\PhpWorkshop\Result\ResultInterface;
+use PhpSchool\PhpWorkshop\Result\Success;
+use PhpSchool\PhpWorkshop\Solution\SingleFileSolution;
+use PhpSchool\PhpWorkshop\Solution\SolutionInterface;
+
+class TheReturnOfStatic extends AbstractExercise implements
+    ExerciseInterface,
+    ProvidesInitialCode,
+    CliExercise,
+    SelfCheck
+{
+    public function __construct(private Parser $parser)
+    {
+    }
+
+    public function getName(): string
+    {
+        return 'The Return of Static';
+    }
+
+    public function getDescription(): string
+    {
+        return 'PHP 8\'s static return types';
+    }
+
+    public function getInitialCode(): SolutionInterface
+    {
+        return SingleFileSolution::fromFile(
+            __DIR__ . '/../../exercises/the-return-of-static/initial/the-return-of-static.php'
+        );
+    }
+
+    public function getType(): ExerciseType
+    {
+        return ExerciseType::CLI();
+    }
+
+    public function getArgs(): array
+    {
+        return [];
+    }
+
+    public function check(Input $input): ResultInterface
+    {
+        /** @var array<Stmt> $statements */
+        $statements = $this->parser->parse((string) file_get_contents($input->getRequiredArgument('program')));
+
+        $finder = new NodeFinder();
+
+        /** @var Function_|null $adder */
+        $class = $finder->findFirst($statements, function (Node $node) {
+            return $node instanceof Stmt\Class_ && $node->name->toString() === 'File';
+        });
+
+        /** @var ClassMethod $method */
+        $method = $finder->findFirst([$class], function (Node $node) {
+            return $node instanceof ClassMethod && $node->name->toString() === 'withPermissions';
+        });
+
+        if (!$class || !$method) {
+            return new Failure($this->getName(), 'The method withPermissions cannot be found');
+        }
+
+
+        if (!($assign = $this->findAssignOnFirstLine($method))) {
+            return new Failure($this->getName(), 'The first statement in withPermissions is not an assign');
+        }
+
+        if ($this->isCloneOfThis($assign)) {
+            return new Success($this->getName());
+        }
+
+        return new Failure($this->getName(), 'The first statement is not a clone of `$this`');
+    }
+
+    private function findAssignOnFirstLine(ClassMethod $method): ?Assign
+    {
+        if (!isset($method->stmts[0])) {
+            return null;
+        }
+
+        if (!$method->stmts[0] instanceof Expression) {
+            return null;
+        }
+
+        if (!$method->stmts[0]->expr instanceof Assign) {
+            return null;
+        }
+
+        return $method->stmts[0]->expr;
+    }
+
+    private function isCloneOfThis(Assign $assign): bool
+    {
+        if (!$assign->expr instanceof Clone_) {
+            return false;
+        }
+
+        if (!$assign->expr->expr instanceof Variable) {
+            return false;
+        }
+
+        return $assign->expr->expr->name === 'this';
+    }
+}