fdiv exercise

Author: AydinHassan

app/bootstrap.php

@@ -22,6 +22,7 @@
 use PhpSchool\PHP8Appreciate\Exercise\AMatchMadeInHeaven;
 use PhpSchool\PHP8Appreciate\Exercise\CautionWithCatches;
 use PhpSchool\PHP8Appreciate\Exercise\HaveTheLastSay;
+use PhpSchool\PHP8Appreciate\Exercise\InfiniteDivisions;
 use PhpSchool\PHP8Appreciate\Exercise\PhpPromotion;
 use PhpSchool\PHP8Appreciate\Exercise\LordOfTheStrings;
 use PhpSchool\PHP8Appreciate\Exercise\UniteTheTypes;
@@ -35,6 +36,7 @@
 $app->addExercise(CautionWithCatches::class);
 $app->addExercise(LordOfTheStrings::class);
 $app->addExercise(UniteTheTypes::class);
+$app->addExercise(InfiniteDivisions::class);
 
 $art = <<<ART
         _ __ _

app/config.php

@@ -3,6 +3,7 @@
 use PhpSchool\PHP8Appreciate\Exercise\AMatchMadeInHeaven;
 use PhpSchool\PHP8Appreciate\Exercise\CautionWithCatches;
 use PhpSchool\PHP8Appreciate\Exercise\HaveTheLastSay;
+use PhpSchool\PHP8Appreciate\Exercise\InfiniteDivisions;
 use PhpSchool\PHP8Appreciate\Exercise\PhpPromotion;
 use PhpSchool\PHP8Appreciate\Exercise\LordOfTheStrings;
 use PhpSchool\PHP8Appreciate\Exercise\UniteTheTypes;
@@ -33,4 +34,7 @@
     UniteTheTypes::class => function (ContainerInterface $c) {
         return new UniteTheTypes($c->get(PhpParser\Parser::class), $c->get(\Faker\Generator::class));
     },
+    InfiniteDivisions::class => function (ContainerInterface $c) {
+        return new InfiniteDivisions($c->get(PhpParser\Parser::class), $c->get(\Faker\Generator::class));
+    },
 ];

exercises/infinite-divisions/problem/problem.md

@@ -0,0 +1,21 @@
+You have been given a piece of code (look for `the-return-of-static.php` in your working directory) which is using static return types.
+
+You will find two classes. `File`, a base class, and `Image` a class extending and adding behavior to `File`. We instantiate `Image`, set some properties using a fluent interface and then dump the object using `var_dump`.
+
+If you run the code using `{appname} run the-return-of-static.php` you will see it is broken.
+
+Locate and fix the issue!
+
+### The advantages of the static return type
+
+* Enforces that an instance of the class the method is called from, is returned. 
+* Most useful for fluent interfaces and static constructors to ensure an instance of a parent class is not returned.
+
+----------------------------------------------------------------------
+## HINTS
+
+(Brief) Documentation on the static return type feature can be found by pointing your browser here:
+[https://www.php.net/manual/en/language.types.declarations.php#language.types.declarations.static]()
+
+The static return type enforces methods to return an instance of the class that the method was called from, rather than the one it was defined in.
+

exercises/infinite-divisions/solution/solution.php

@@ -0,0 +1,15 @@
+<?php
+
+try {
+    $argv[1] / $argv[2];
+} catch (DivisionByZeroError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+echo match ($res = fdiv($argv[1], $argv[2])) {
+    INF => 'Infinite',
+    -INF => 'Minus Infinite',
+    default => $res
+};
+
+echo "\n";

src/Exercise/InfiniteDivisions.php

@@ -0,0 +1,117 @@
+<?php
+
+namespace PhpSchool\PHP8Appreciate\Exercise;
+
+use DivisionByZeroError;
+use Faker\Generator as FakerGenerator;
+use PhpParser\Node;
+use PhpParser\Node\Expr\BinaryOp\Div;
+use PhpParser\Node\Name;
+use PhpParser\Node\Stmt;
+use PhpParser\Node\Stmt\Catch_;
+use PhpParser\NodeFinder;
+use PhpParser\Parser;
+use PhpSchool\PhpWorkshop\Check\FunctionRequirementsCheck;
+use PhpSchool\PhpWorkshop\Exercise\AbstractExercise;
+use PhpSchool\PhpWorkshop\Exercise\CliExercise;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
+use PhpSchool\PhpWorkshop\ExerciseCheck\FunctionRequirementsExerciseCheck;
+use PhpSchool\PhpWorkshop\ExerciseCheck\SelfCheck;
+use PhpSchool\PhpWorkshop\ExerciseDispatcher;
+use PhpSchool\PhpWorkshop\Input\Input;
+use PhpSchool\PhpWorkshop\Result\Failure;
+use PhpSchool\PhpWorkshop\Result\ResultInterface;
+use PhpSchool\PhpWorkshop\Result\Success;
+
+class InfiniteDivisions extends AbstractExercise implements
+    ExerciseInterface,
+    CliExercise,
+    FunctionRequirementsExerciseCheck,
+    SelfCheck
+{
+    public function __construct(private Parser $parser, private FakerGenerator $faker)
+    {
+    }
+
+    public function getName(): string
+    {
+        return 'Infinite Divisions';
+    }
+
+    public function getDescription(): string
+    {
+        return 'PHP 8\'s fdiv function and DivisionByZeroError exception';
+    }
+
+    public function getType(): ExerciseType
+    {
+        return ExerciseType::CLI();
+    }
+
+    public function configure(ExerciseDispatcher $dispatcher): void
+    {
+        $dispatcher->requireCheck(FunctionRequirementsCheck::class);
+    }
+
+    public function getArgs(): array
+    {
+        return [
+            [
+                (string) $this->faker->numberBetween(10, 100),
+                (string) $this->faker->numberBetween(0, 10)
+            ]
+        ];
+    }
+
+    public function getRequiredFunctions(): array
+    {
+        return ['fdiv'];
+    }
+
+    public function getBannedFunctions(): 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 Stmt\TryCatch|null $tryCatch */
+        $tryCatch = $finder->findFirstInstanceOf($statements, Stmt\TryCatch::class);
+
+        if (!$tryCatch) {
+            return new Failure($this->getName(), 'No try/catch statement could be found');
+        }
+
+        /** @var Div|null $divOp */
+        $divOp = $finder->findFirstInstanceOf($tryCatch->stmts, Div::class);
+
+        if (!$divOp) {
+            return new Failure($this->getName(), 'No division operation could be found in the try block');
+        }
+
+        /** @var Catch_|null $catch */
+        $catch = $finder->findFirst($tryCatch->catches, function (Node $node) {
+            if ($node instanceof Catch_) {
+                return in_array(
+                    DivisionByZeroError::class,
+                    array_map(fn (Name $n) => $n->toString(), $node->types),
+                    true
+                );
+            }
+
+            return false;
+        });
+
+        if (!$catch) {
+            return new Failure($this->getName(), 'No catch block for the DivisionByZeroError exception found');
+        }
+
+        return new Success($this->getName());
+    }
+}

test/Exercise/InfiniteDivisionsTest.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace PhpSchool\PHP8AppreciateTest\Exercise;
+
+use PhpSchool\PHP8Appreciate\Exercise\InfiniteDivisions;
+use PhpSchool\PhpWorkshop\Application;
+use PhpSchool\PhpWorkshop\Result\Failure;
+use PhpSchool\PhpWorkshop\TestUtils\WorkshopExerciseTest;
+
+class InfiniteDivisionsTest extends WorkshopExerciseTest
+{
+    public function getExerciseClass(): string
+    {
+        return InfiniteDivisions::class;
+    }
+
+    public function getApplication(): Application
+    {
+        return require __DIR__ . '/../../app/bootstrap.php';
+    }
+
+    public function testFailureWhenNoTryCatch(): void
+    {
+        $this->runExercise('no-try-catch.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(Failure::class, 'No try/catch statement could be found');
+    }
+
+    public function testFailureWhenNoDivisionOperationFoundInTryBlock(): void
+    {
+        $this->runExercise('no-divide-in-try.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(Failure::class, 'No division operation could be found in the try block');
+    }
+
+    public function testFailureWhenNoDivisionByZeroCatch(): void
+    {
+        $this->runExercise('no-division-by-zero-catch.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(Failure::class, 'No catch block for the DivisionByZeroError exception found');
+    }
+
+    public function testSuccessfulSolution(): void
+    {
+        $this->runExercise('solution-correct.php');
+
+        $this->assertVerifyWasSuccessful();
+    }
+}

test/solutions/infinite-divisions/no-divide-in-try.php

@@ -0,0 +1,14 @@
+<?php
+
+try {
+} catch (DivisionByZeroError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+echo match ($res = fdiv($argv[1], $argv[2])) {
+    INF => 'Infinite',
+    -INF => 'Minus infinite',
+    default => $res
+};
+
+echo "\n";

test/solutions/infinite-divisions/no-division-by-zero-catch.php

@@ -0,0 +1,15 @@
+<?php
+
+try {
+    $argv[1] / $argv[2];
+} catch (Exception $e) {
+    echo $e->getMessage() . "\n";
+}
+
+echo match ($res = fdiv($argv[1], $argv[2])) {
+    INF => 'Infinite',
+    -INF => 'Minus infinite',
+    default => $res
+};
+
+echo "\n";

test/solutions/infinite-divisions/no-try-catch.php

@@ -0,0 +1,11 @@
+<?php
+
+$argv[1] / $argv[2];
+
+echo match ($res = fdiv($argv[1], $argv[2])) {
+    INF => 'Infinite',
+    -INF => 'Minus infinite',
+    default => $res
+};
+
+echo "\n";

test/solutions/infinite-divisions/solution-correct.php

@@ -0,0 +1,15 @@
+<?php
+
+try {
+    $argv[1] / $argv[2];
+} catch (DivisionByZeroError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+echo match ($res = fdiv($argv[1], $argv[2])) {
+    INF => 'Infinite',
+    -INF => 'Minus infinite',
+    default => $res
+};
+
+echo "\n";