Merge pull request #28 from php-school/stringify-to-demystify

Add stringify to demysitify exercise

Author: AydinHassan

app/bootstrap.php

@@ -30,6 +30,7 @@
 use PhpSchool\PHP8Appreciate\Exercise\TheReturnOfStatic;
 use PhpSchool\PHP8Appreciate\Exercise\ThrowAnExpression;
 use PhpSchool\PHP8Appreciate\Exercise\UniteTheTypes;
+use PhpSchool\PHP8Appreciate\Exercise\StringifyToDemystify;
 use PhpSchool\PhpWorkshop\Application;
 
 $app = new Application('PHP8 Appreciate', __DIR__ . '/config.php');
@@ -45,6 +46,7 @@
 $app->addExercise(AllMixedUp::class);
 $app->addExercise(TheReturnOfStatic::class);
 $app->addExercise(ThrowAnExpression::class);
+$app->addExercise(StringifyToDemystify::class);
 
 $art = <<<ART
         _ __ _

app/config.php

@@ -11,6 +11,7 @@
 use PhpSchool\PHP8Appreciate\Exercise\TheReturnOfStatic;
 use PhpSchool\PHP8Appreciate\Exercise\ThrowAnExpression;
 use PhpSchool\PHP8Appreciate\Exercise\UniteTheTypes;
+use PhpSchool\PHP8Appreciate\Exercise\StringifyToDemystify;
 use Psr\Container\ContainerInterface;
 
 use function DI\create;
@@ -52,5 +53,8 @@
     },
     ThrowAnExpression::class => function (ContainerInterface $c) {
         return new ThrowAnExpression($c->get(PhpParser\Parser::class), $c->get(\Faker\Generator::class));
-    }
+    },
+    StringifyToDemystify::class => function (ContainerInterface $c) {
+        return new StringifyToDemystify($c->get(PhpParser\Parser::class));
+    },
 ];

exercises/stringify-to-demystify/problem/problem.md

@@ -0,0 +1,47 @@
+`__toString()` a magic class method long-standing in PHP but never truly something you could rely on unless you rolled your own interface. All that has changed with the simple introduction of the `Stringable` interface in PHP 8.
+
+`Stringable` is a simple interface that requires the implementation of `__toString(): string`
+
+----------------------------------------------------------------------
+
+Create a program that reads the JSON body of the request input stream (mimicking an API response). The body will need to be JSON decoded and will be a variation of the example below:
+
+```json
+{
+  "success": false,
+  "status": "401",
+  "error": "Unauthorized: Not authorised for this resource"
+}
+```
+
+You will need to define a new class that implements `Stringable` and it's method requirements. This class should take enough information from the request so that the `__toString` method can return a string like below:
+
+```
+Status: 401
+Error: Unauthorized: Not authorised for this resource
+```
+
+Once constructed pass the object to a `log_failure` function. This function is provided for you and has a signature of `log_failure(\Stringable $error): void`.
+
+Your program may also receive successful payloads, which you should ignore for the purposes of this exercise. These requests will be identifiable by the `success` key in the decoded JSON payload.
+
+### The advantages of the new Stringable interface
+
+* Allows typing of string like objects
+* Can be used in conjunction with union types alongside `string`
+
+----------------------------------------------------------------------
+## HINTS
+
+To easily read the request body you can use `file_get_contents('php://input')`
+
+For more details look at the docs for...
+
+**Stringable** - [https://www.php.net/manual/en/class.stringable.php]()
+
+Note that while the `Stringable` interface isn't required to pass the type hint check, however, it should be used if not only to show intent.  
+
+Oh, and don't forget about the basics for classes and interfaces :)
+
+**class** - [https://www.php.net/manual/en/language.oop5.basic.php]()
+**interfaces** - [https://www.php.net/manual/en/language.oop5.interfaces.php]()

exercises/stringify-to-demystify/solution/solution.php

@@ -0,0 +1,19 @@
+<?php
+
+class FailedResponse implements \Stringable {
+
+    public function __construct(private string $status, private string $error)
+    {
+    }
+
+    public function __toString()
+    {
+        return "Status: {$this->status} \nError: {$this->error}";
+    }
+}
+
+$request = json_decode(file_get_contents('php://input'), true);
+
+if (!$request['success']) {
+    log_failure(new FailedResponse($request['status'], $request['error']));
+}

src/Exercise/StringifyToDemystify.php

@@ -0,0 +1,155 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpSchool\PHP8Appreciate\Exercise;
+
+use GuzzleHttp\Psr7\Request;
+use PhpParser\Node\Name;
+use PhpParser\Node\Stmt;
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\TryCatch;
+use PhpParser\NodeFinder;
+use PhpParser\Parser;
+use PhpSchool\PhpWorkshop\Check\FunctionRequirementsCheck;
+use PhpSchool\PhpWorkshop\CodeInsertion;
+use PhpSchool\PhpWorkshop\Exercise\AbstractExercise;
+use PhpSchool\PhpWorkshop\Exercise\CgiExercise;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
+use PhpSchool\PhpWorkshop\Exercise\SubmissionPatchable;
+use PhpSchool\PhpWorkshop\ExerciseCheck\FunctionRequirementsExerciseCheck;
+use PhpSchool\PhpWorkshop\ExerciseCheck\SelfCheck;
+use PhpSchool\PhpWorkshop\ExerciseDispatcher;
+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 Psr\Http\Message\RequestInterface;
+use Stringable;
+
+class StringifyToDemystify extends AbstractExercise implements
+    ExerciseInterface,
+    CgiExercise,
+    SubmissionPatchable,
+    FunctionRequirementsExerciseCheck,
+    SelfCheck
+{
+    public function __construct(private Parser $parser)
+    {
+    }
+
+    public function getName(): string
+    {
+        return 'Stringify to Demystify';
+    }
+
+    public function getDescription(): string
+    {
+        return 'PHP 8\'s Stringable Interface';
+    }
+
+    public function getType(): ExerciseType
+    {
+        return ExerciseType::CGI();
+    }
+
+    public function configure(ExerciseDispatcher $dispatcher): void
+    {
+        $dispatcher->requireCheck(FunctionRequirementsCheck::class);
+    }
+
+    /**
+     * @return array<RequestInterface>
+     */
+    public function getRequests(): array
+    {
+        return array_map(
+            fn () => new Request(
+                'POST',
+                'https://phpschool.io/api',
+                [],
+                json_encode($this->getRandRequest(), JSON_THROW_ON_ERROR)
+            ),
+            array_fill(0, random_int(3, 6), null)
+        );
+    }
+
+    /**
+     * @return array{'success': bool, 'status': int, 'error'?: string, 'body'?: string}
+     * @throws \Exception
+     */
+    public function getRandRequest(): array
+    {
+        return [
+            [
+                'success' => true,
+                'status' => 200,
+                'body' => ['{fake: "data"}', '{stub: "payload"}'][random_int(0, 1)]
+            ],
+            [
+                'success' => false,
+                'status' => 400,
+                'error' => ['Bad Request: Incorrect mime type', 'Bad Request: Invalid key "id"'][random_int(0, 1)]
+            ],
+            [
+                'success' => false,
+                'status' => 401,
+                'error' => ['Unauthorized: Not authorised for this resource', 'Bad API token'][random_int(0, 1)]
+            ],
+            [
+                'success' => false,
+                'status' => 403,
+                'error' => ['Forbidden: Access forbidden', 'Forbidden: ACL not granted for resource'][random_int(0, 1)]
+            ],
+            [
+                'success' => false,
+                'status' => 500,
+                'error' => ['Server Error: Contact webmaster', 'Server Error: err_code: 3289327'][random_int(0, 1)]
+            ],
+        ][random_int(0, 4)];
+    }
+
+    public function getPatch(): Patch
+    {
+        $code = <<<CODE
+        function log_failure(\Stringable \$error) {
+            echo \$error;
+        }
+        CODE;
+
+        return (new Patch())->withInsertion(new CodeInsertion(CodeInsertion::TYPE_BEFORE, $code));
+    }
+
+    public function getRequiredFunctions(): array
+    {
+        return ['log_failure'];
+    }
+
+    public function getBannedFunctions(): array
+    {
+        return [];
+    }
+
+    public function check(Input $input): ResultInterface
+    {
+        /** @var Stmt[] $statements */
+        $statements = $this->parser->parse((string) file_get_contents($input->getRequiredArgument('program')));
+
+        /** @var Class_|null $classStmt */
+        $classStmt = (new NodeFinder())->findFirstInstanceOf($statements, Class_::class);
+
+        if (!$classStmt) {
+            return new Failure($this->getName(), 'No class statement could be found');
+        }
+
+        $implements = array_filter($classStmt->implements, fn (Name $name) => $name->toString() === Stringable::class);
+
+        if (empty($implements)) {
+            return new Failure($this->getName(), 'Your class should implement the Stringable interface');
+        }
+
+        return new Success($this->getName());
+    }
+}

test/Exercise/StringifyToDemystifyTest.php

@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpSchool\PHP8AppreciateTest\Exercise;
+
+use PhpSchool\PHP8Appreciate\Exercise\StringifyToDemystify;
+use PhpSchool\PhpWorkshop\Application;
+use PhpSchool\PhpWorkshop\Result\Failure;
+use PhpSchool\PhpWorkshop\Result\FunctionRequirementsFailure;
+use PhpSchool\PhpWorkshop\TestUtils\WorkshopExerciseTest;
+
+class StringifyToDemystifyTest extends WorkshopExerciseTest
+{
+    public function getExerciseClass(): string
+    {
+        return StringifyToDemystify::class;
+    }
+
+    public function getApplication(): Application
+    {
+        return require __DIR__ . '/../../app/bootstrap.php';
+    }
+
+    public function testWithNoClass(): void
+    {
+        $this->runExercise('solution-no-class.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailureAndMatches(
+            FunctionRequirementsFailure::class,
+            function (FunctionRequirementsFailure $failure) {
+                self::assertSame(['log_failure'], $failure->getMissingFunctions());
+                return true;
+            }
+        );
+    }
+
+    public function testWithNotImplementingStringable(): void
+    {
+        $this->runExercise('solution-no-stringable.php');
+
+        $this->assertVerifyWasNotSuccessful();
+
+        $this->assertResultsHasFailure(Failure::class, 'Your class should implement the Stringable interface');
+    }
+
+    public function testSolution(): void
+    {
+        $this->runExercise('solution.php');
+
+        $this->assertVerifyWasSuccessful();
+    }
+}

test/solutions/stringify-to-demystify/solution-no-class.php

@@ -0,0 +1,7 @@
+<?php
+
+$request = json_decode(file_get_contents('php://input'), true);
+
+if (!$request['success']) {
+    echo "Status: {$request['status']} \nError: {$request['error']}";
+}

test/solutions/stringify-to-demystify/solution-no-stringable.php

@@ -0,0 +1,19 @@
+<?php
+
+class FailedResponse {
+
+    public function __construct(private string $status, private string $error)
+    {
+    }
+
+    public function __toString()
+    {
+        return "Status: {$this->status} \nError: {$this->error}";
+    }
+}
+
+$request = json_decode(file_get_contents('php://input'), true);
+
+if (!$request['success']) {
+    log_failure(new FailedResponse($request['status'], $request['error']));
+}

test/solutions/stringify-to-demystify/solution.php

@@ -0,0 +1,19 @@
+<?php
+
+class FailedResponse implements \Stringable {
+
+    public function __construct(private string $status, private string $error)
+    {
+    }
+
+    public function __toString()
+    {
+        return "Status: {$this->status} \nError: {$this->error}";
+    }
+}
+
+$request = json_decode(file_get_contents('php://input'), true);
+
+if (!$request['success']) {
+    log_failure(new FailedResponse($request['status'], $request['error']));
+}