Merge pull request #27 from php-school/throw-an-expression

Throw an expression

Author: AydinHassan

app/bootstrap.php

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

app/config.php

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

composer.json

@@ -21,7 +21,7 @@
     ],
     "require": {
         "php": "^8.0",
-        "php-school/php-workshop": "dev-master"
+        "php-school/php-workshop": "dev-wrap-in-try-catch-patch"
     },
     "require-dev": {
         "phpunit/phpunit": "^9",

composer.lock

@@ -0,0 +1,7 @@
+<?php
+
+if (str_starts_with($_SERVER['REQUEST_URI'], '/forbidden')) {
+    throw new InvalidArgumentException('Access denied!');
+} else {
+    echo 'Welcome!';
+}

exercises/throw-an-expression/initial/throw-an-expression.php

@@ -0,0 +1,23 @@
+You have been given a piece of code (look for `throw-an-expression.php` in your working directory) which is checking the requested URL and throwing an exception when a secret area of the website is accessed.
+
+If the request is allowed, `Welcome!` is printed out.
+
+
+Traditionally, pre PHP 8, an exception throw has been a statement. There are certain places where statements cannot be used, and only expressions can be used. For example, in ternaries and short closures, only expressions can be used.
+
+Now with PHP 8, throw statements are expressions making them available to use in pretty much all locations.
+
+----------------------------------------------------------------------
+Your task is to convert the `if` statement to one line of code, using the ternary operator.
+
+### The advantages of throwing being an exception
+
+* It is possible to throw an exception in a short closure
+* It is possible to throw an exception in a ternary or coalesce operation
+
+----------------------------------------------------------------------
+## HINTS
+
+Documentation on throwing exception can be found by pointing your browser here:
+[https://www.php.net/manual/en/language.exceptions.php]()
+

exercises/throw-an-expression/problem/problem.md

@@ -0,0 +1,5 @@
+<?php
+
+echo str_starts_with($_SERVER['REQUEST_URI'], '/forbidden')
+    ? throw new InvalidArgumentException('Access denied!')
+    : 'Welcome!';

exercises/throw-an-expression/solution/solution.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace PhpSchool\PHP8Appreciate\Exercise;
+
+use Faker\Generator as FakerGenerator;
+use GuzzleHttp\Psr7\Request;
+use PhpParser\Node\Expr\Ternary;
+use PhpParser\Node\Expr\Throw_;
+use PhpParser\Node\Stmt;
+use PhpParser\Node\Stmt\If_;
+use PhpParser\NodeFinder;
+use PhpParser\Parser;
+use PhpSchool\PhpWorkshop\Exercise\AbstractExercise;
+use PhpSchool\PhpWorkshop\Exercise\CgiExercise;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
+use PhpSchool\PhpWorkshop\Exercise\ProvidesInitialCode;
+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 PhpSchool\PhpWorkshop\Solution\SingleFileSolution;
+use PhpSchool\PhpWorkshop\Solution\SolutionInterface;
+
+class ThrowAnExpression extends AbstractExercise implements
+    ExerciseInterface,
+    CgiExercise,
+    SelfCheck,
+    ProvidesInitialCode,
+    SubmissionPatchable
+{
+    public function __construct(private Parser $parser, private FakerGenerator $faker)
+    {
+    }
+
+    public function getName(): string
+    {
+        return 'Throw an Expression';
+    }
+
+    public function getDescription(): string
+    {
+        return 'PHP 8\'s throw expression';
+    }
+
+    public function getType(): ExerciseType
+    {
+        return ExerciseType::CGI();
+    }
+
+    public function getRequests(): array
+    {
+        return [
+            (new Request('GET', 'https://top-secret.com/forbidden')),
+            (new Request('GET', 'https://top-secret.com/blog'))
+        ];
+    }
+
+    public function check(Input $input): ResultInterface
+    {
+        /** @var array<Stmt> $statements */
+        $statements = $this->parser->parse((string) file_get_contents($input->getRequiredArgument('program')));
+
+        /** @var If_|null $if */
+        $if = (new NodeFinder())->findFirstInstanceOf($statements, If_::class);
+
+        if ($if) {
+            return Failure::fromNameAndReason($this->getName(), 'If statement found');
+        }
+
+        /** @var Ternary|null $ternary */
+        $ternary = (new NodeFinder())->findFirstInstanceOf($statements, Ternary::class);
+
+        if ($ternary === null) {
+            return Failure::fromNameAndReason($this->getName(), 'No ternary statement found');
+        }
+
+        if (!$ternary->if instanceof Throw_ && !$ternary->else instanceof Throw_) {
+            return Failure::fromNameAndReason($this->getName(), 'Ternary does not make use of throw expression');
+        }
+
+        return new Success($this->getName());
+    }
+
+    public function getInitialCode(): SolutionInterface
+    {
+        return SingleFileSolution::fromFile(
+            __DIR__ . '/../../exercises/throw-an-expression/initial/throw-an-expression.php'
+        );
+    }
+
+    public function getPatch(): Patch
+    {
+        return (new Patch())
+            ->withTransformer(new Patch\WrapInTryCatch(\InvalidArgumentException::class));
+    }
+}

src/Exercise/ThrowAnExpression.php

@@ -0,0 +1,92 @@
+<?php
+
+namespace PhpSchool\PHP8AppreciateTest\Exercise;
+
+use PhpSchool\PHP8Appreciate\Exercise\ThrowAnExpression;
+use PhpSchool\PhpWorkshop\Application;
+use PhpSchool\PhpWorkshop\Result\Cgi\GenericFailure;
+use PhpSchool\PhpWorkshop\Result\Cgi\RequestFailure;
+use PhpSchool\PhpWorkshop\Result\Cgi\Success;
+use PhpSchool\PhpWorkshop\Result\Failure;
+use PhpSchool\PhpWorkshop\TestUtils\WorkshopExerciseTest;
+
+class ThrowAnExpressionTest extends WorkshopExerciseTest
+{
+    public function getExerciseClass(): string
+    {
+        return ThrowAnExpression::class;
+    }
+
+    public function getApplication(): Application
+    {
+        return require __DIR__ . '/../../app/bootstrap.php';
+    }
+
+    public function testThrowingWrongException(): void
+    {
+        $this->runExercise('wrong-exception.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $output = $this->getOutputResult();
+
+        self::assertInstanceOf(GenericFailure::class, $output->getResults()[0]);
+        self::assertInstanceOf(Success::class, $output->getResults()[1]);
+
+        self::assertMatchesRegularExpression(
+            '/Fatal error:  Uncaught Exception: Access denied!/',
+            $output->getResults()[0]->getReason()
+        );
+
+        $this->assertOutputWasIncorrect();
+    }
+
+    public function testUsingIfStatement(): void
+    {
+        $this->runExercise('if-statement.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(Failure::class, 'If statement found');
+
+        $this->assertOutputWasCorrect();
+    }
+
+    public function testUsingNoTernary(): void
+    {
+        $this->runExercise('no-ternary.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(Failure::class, 'No ternary statement found');
+
+        $this->assertOutputWasIncorrect();
+    }
+
+    public function testNoThrowExpression(): void
+    {
+        $this->runExercise('no-throw-expression.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(Failure::class, 'Ternary does not make use of throw expression');
+
+        $this->assertOutputWasCorrect();
+    }
+
+    public function testSuccessfulSolution(): void
+    {
+        $this->runExercise('solution-correct.php');
+
+        $this->assertVerifyWasSuccessful();
+        $this->assertOutputWasCorrect();
+    }
+
+    public function testSuccessfulSolutionThrowOnElse(): void
+    {
+        $this->runExercise('solution-correct-else.php');
+
+        $this->assertVerifyWasSuccessful();
+        $this->assertOutputWasCorrect();
+    }
+}

test/Exercise/ThrowAnExpressionTest.php

@@ -1,9 +1,12 @@
 <?php
 
+date_default_timezone_set("Europe/London");
+error_reporting(E_ALL);
+ini_set("display_errors", "1");
 echo match ($argv[1]) {
     'enter' => 13 + 10,
     'up' => 119 + 10,
     'down' => 73 + 10,
     'esc' => 27 + 10,
-    default => 0 + 10
-};
+    default => 0 + 10,
+};