Merge pull request #26 from php-school/mixed

Author: AydinHassan

app/bootstrap.php

@@ -19,6 +19,7 @@
         throw new RuntimeException('Unable to locate Composer autoloader; please run "composer install".');
 }
 
+use PhpSchool\PHP8Appreciate\Exercise\AllMixedUp;
 use PhpSchool\PHP8Appreciate\Exercise\AMatchMadeInHeaven;
 use PhpSchool\PHP8Appreciate\Exercise\ASafeSpaceForNulls;
 use PhpSchool\PHP8Appreciate\Exercise\CautionWithCatches;
@@ -39,6 +40,7 @@
 $app->addExercise(UniteTheTypes::class);
 $app->addExercise(InfiniteDivisions::class);
 $app->addExercise(ASafeSpaceForNulls::class);
+$app->addExercise(AllMixedUp::class);
 
 $art = <<<ART
         _ __ _

app/config.php

@@ -1,5 +1,6 @@
 <?php
 
+use PhpSchool\PHP8Appreciate\Exercise\AllMixedUp;
 use PhpSchool\PHP8Appreciate\Exercise\AMatchMadeInHeaven;
 use PhpSchool\PHP8Appreciate\Exercise\ASafeSpaceForNulls;
 use PhpSchool\PHP8Appreciate\Exercise\CautionWithCatches;
@@ -41,4 +42,7 @@
     ASafeSpaceForNulls::class => function (ContainerInterface $c) {
         return new ASafeSpaceForNulls($c->get(PhpParser\Parser::class), $c->get(\Faker\Generator::class));
     },
+    AllMixedUp::class => function (ContainerInterface $c) {
+        return new AllMixedUp($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-file-comparison-regex-strip"
     },
     "require-dev": {
         "phpunit/phpunit": "^9",

exercises/all-mixed-up/problem/problem.md

@@ -0,0 +1,56 @@
+As alluded to earlier in `Unite The Types` PHP's type system has been constantly and consistently growing for a long time.
+
+PHP8 comes with a new type `mixed` which is essentially a union of `array|bool|callable|int|float|object|resource|string|null`. 
+
+This means that any value which can be produced in PHP will pass the check. Which is exactly the same as no type check.
+
+I guess you're wondering why you would use it, right?
+
+If anything - it signals intent. Your function really does accept anything. It's not just missing type information.
+
+----------------------------------------------------------------------
+Create a program which contains one function named `logParameter`. It should have one parameter, and it's type must be `mixed`.
+
+Within your function you should log the type of the parameter that was passed. For this, you can use a new PHP8 function called `get_debug_type`.
+
+This function will give you a string identifier representing the type of any PHP variable.
+
+You should log the parameter to a file named `param.log` next to your PHP script.
+
+We will call this function multiple times when we verify it, so make sure you append to the file instead of overwriting it with each log.
+
+Each log entry should be on a new line and should follow the format: `10:04:06: Got: string` where `10:04:06` is the time: hours, minutes & seconds and where `string` is the type, the result of `get_debug_type`.
+
+The format of the line is very important, including the time.
+
+You do not need to call the function, just define it. We will call it for you, with every PHP value we can think of!
+
+### The advantages of the mixed type
+
+* Allows us to indicate that the type has not been forgotten, it just cannot be specified more precisely.
+* Allows us to move information from phpdoc into function signatures.
+----------------------------------------------------------------------
+## HINTS
+
+The function you implement must be called `logParameter`.
+
+`file_put_contents` has a handy flag to append to a file instead of creating it anew: `FILE_APPEND`.
+
+We will call your function automatically with a bunch of different types to make sure that it can accept anything.
+
+We will specifically check that you used the `mixed` type. Omitting the type will not pass.
+
+Documentation on the `mixed` type can be found by pointing your browser here:
+[https://www.php.net/manual/en/language.types.declarations.php#language.types.declarations.mixed]()
+
+Documentation on `get_debug_type` can be found by pointing your browser here:
+[https://www.php.net/manual/en/function.get-debug-type.php]()
+
+----------------------------------------------------------------------
+## EXTRA
+
+You might want to delete or empty your log file each time your program starts, otherwise it will grow and grow and the comparison will fail.
+
+Think about the return type of your `adder` function - you could declare it as `void`.
+
+If you are curious how we compare the output of your program when it includes time, we simply check that it matches the format, rather than comparing exactly. More specifically, we use the regex `/\d{2}:\d{2}:\d{2}/`.

exercises/all-mixed-up/solution/solution.php

@@ -0,0 +1,14 @@
+<?php
+
+function logParameter(mixed $parameter): void
+{
+    file_put_contents(
+        'param.log',
+        sprintf(
+            "%s: Got: %s\n",
+            (new \DateTime())->format('H:i:s'),
+            get_debug_type($parameter)
+        ),
+        FILE_APPEND
+    );
+}

src/Exercise/AllMixedUp.php

@@ -0,0 +1,173 @@
+<?php
+
+namespace PhpSchool\PHP8Appreciate\Exercise;
+
+use Faker\Generator as FakerGenerator;
+use PhpParser\BuilderFactory;
+use PhpParser\Node\Expr\Assign;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Stmt;
+use PhpParser\Node\Stmt\Expression;
+use PhpParser\Node\Stmt\Foreach_;
+use PhpParser\Node\Stmt\Function_;
+use PhpParser\NodeFinder;
+use PhpParser\Parser;
+use PhpSchool\PhpWorkshop\Check\FileComparisonCheck;
+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\Exercise\SubmissionPatchable;
+use PhpSchool\PhpWorkshop\ExerciseCheck\FileComparisonExerciseCheck;
+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;
+
+class AllMixedUp extends AbstractExercise implements
+    ExerciseInterface,
+    CliExercise,
+    SubmissionPatchable,
+    FunctionRequirementsExerciseCheck,
+    FileComparisonExerciseCheck,
+    SelfCheck
+{
+    private ?Patch $patch = null;
+
+    public function __construct(private Parser $parser, private FakerGenerator $faker)
+    {
+    }
+
+    public function getName(): string
+    {
+        return 'All Mixed Up';
+    }
+
+    public function getDescription(): string
+    {
+        return 'PHP 8\'s mixed type';
+    }
+
+    public function getType(): ExerciseType
+    {
+        return ExerciseType::CLI();
+    }
+
+    public function configure(ExerciseDispatcher $dispatcher): void
+    {
+        $dispatcher->requireCheck(FunctionRequirementsCheck::class);
+        $dispatcher->requireCheck(FileComparisonCheck::class);
+    }
+
+    public function getArgs(): array
+    {
+        return [];
+    }
+
+    public function getPatch(): Patch
+    {
+        if ($this->patch) {
+            return $this->patch;
+        }
+
+        $factory = new BuilderFactory();
+
+        $statements = [
+            new Expression(
+                new Assign(
+                    $factory->var('items'),
+                    $factory->val([
+                        $this->faker->word(),
+                        $this->faker->randomNumber(3),
+                        $this->faker->words($this->faker->numberBetween(3, 7)),
+                        $this->faker->randomFloat(),
+                        $this->faker->boolean(),
+                        null,
+                        $factory->new('stdClass')
+                    ])
+                )
+            )
+        ];
+
+        $statements[] = new Foreach_(
+            $factory->var('items'),
+            $factory->var('item'),
+            [
+                'stmts' => [
+                    new Expression(
+                        $factory->funcCall(
+                            'logParameter',
+                            $factory->args([$factory->var('item')])
+                        )
+                    )
+                ]
+            ]
+        );
+
+        return $this->patch = (new Patch())
+            ->withTransformer(function (array $originalStatements) use ($statements) {
+                return array_merge($originalStatements, $statements);
+            });
+    }
+
+    public function getFilesToCompare(): array
+    {
+        return [
+            'param.log' => [
+                'strip' => '/\d{2}:\d{2}:\d{2}/' //strip out time strings
+            ]
+        ];
+    }
+
+    public function getRequiredFunctions(): array
+    {
+        return ['get_debug_type'];
+    }
+
+    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')));
+
+        /** @var Function_|null $logger */
+        $logger = (new NodeFinder())->findFirst($statements, function (\PhpParser\Node $node) {
+            return $node instanceof Function_ && $node->name->toString() === 'logParameter';
+        });
+
+        if (null === $logger) {
+            return Failure::fromNameAndReason($this->getName(), 'No function named logParameter was found');
+        }
+
+        if (!isset($logger->params[0])) {
+            return Failure::fromNameAndReason($this->getName(), 'Function logParameter has no parameters');
+        }
+
+        if ($logger->params[0]->type === null) {
+            return Failure::fromNameAndReason(
+                $this->getName(),
+                'Function logParameter has no type for it\'s for first parameter'
+            );
+        }
+
+        $type = $logger->params[0]->type;
+
+        if (!$type instanceof Identifier || $type->name !== 'mixed') {
+            return Failure::fromNameAndReason(
+                $this->getName(),
+                'Function logParameter does not use the mixed type for it\'s first param'
+            );
+        }
+
+        return new Success($this->getName());
+    }
+}