Code patch updates

app/config.php

@@ -384,6 +384,12 @@ function (CgiResult $result) use ($c) {
             ],
         ],
         'code-patcher' => [
+            'application.tear-down' => [
+                containerListener(CodePatchListener::class, 'revert'),
+            ],
+            'verify.post.exception' => [
+                containerListener(CodePatchListener::class, 'revert'),
+            ],
             'cli.verify.start' => [
                 containerListener(CodePatchListener::class, 'patch'),
             ],

src/Application.php

@@ -7,6 +7,8 @@
 use DI\Container;
 use DI\ContainerBuilder;
 use PhpSchool\PhpWorkshop\Check\CheckRepository;
+use PhpSchool\PhpWorkshop\Event\Event;
+use PhpSchool\PhpWorkshop\Event\EventDispatcher;
 use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
 use PhpSchool\PhpWorkshop\Exception\MissingArgumentException;
 use PhpSchool\PhpWorkshop\Factory\ResultRendererFactory;
@@ -84,6 +86,8 @@ public function __construct(string $workshopTitle, string $diConfigFile)
 
         $this->workshopTitle = $workshopTitle;
         $this->diConfigFile = $diConfigFile;
+
+        set_error_handler([$this, 'handleInternalError']);
     }
 
     /**
@@ -192,6 +196,18 @@ public function configure(): ContainerInterface
             }
         }
 
+        $tearDown = function () use ($container): bool {
+            // TODO: This works.. but wrong event as PatchListener take ExerciseRunnerEvent
+            $container
+                ->get(EventDispatcher::class)
+                ->dispatch(new Event('application.tear-down'));
+
+            // Fallback to default error handler
+            return false;
+        };
+
+        set_error_handler($tearDown);
+
         return $container;
     }
 
@@ -227,6 +243,10 @@ public function run(): int
                 $message = str_replace($basePath, '', $message);
             }
 
+            $container
+                ->get(EventDispatcher::class)
+                ->dispatch(new Event('application.tear-down'));
+
             $container
                 ->get(OutputInterface::class)
                 ->printError(
@@ -268,4 +288,16 @@ private function getContainer(): Container
 
         return $containerBuilder->build();
     }
+
+    private function handleInternalError(
+        int $errno,
+        string $errstr,
+        string $errfile,
+        int $errline
+    ): bool {
+
+
+
+        return false;
+    }
 }

src/Exercise/AbstractExercise.php

@@ -15,6 +15,7 @@
  */
 abstract class AbstractExercise
 {
+    protected ?SolutionInterface $solution = null;
 
     /**
      * Get the name of the exercise, like `Hello World!`.
@@ -35,15 +36,19 @@ abstract public function getName(): string;
      */
     public function getSolution(): SolutionInterface
     {
-        return SingleFileSolution::fromFile(
-            (string) realpath(
-                sprintf(
-                    '%s/../../exercises/%s/solution/solution.php',
-                    dirname((string) (new ReflectionClass(static::class))->getFileName()),
-                    self::normaliseName($this->getName())
+        if (null === $this->solution) {
+            $this->solution = SingleFileSolution::fromFile(
+                (string)realpath(
+                    sprintf(
+                        '%s/../../exercises/%s/solution/solution.php',
+                        dirname((string)(new ReflectionClass(static::class))->getFileName()),
+                        self::normaliseName($this->getName())
+                    )
                 )
-            )
-        );
+            );
+        }
+
+        return $this->solution;
     }
 
     /**

src/ExerciseDispatcher.php

@@ -151,6 +151,9 @@ public function verify(ExerciseInterface $exercise, Input $input): ResultAggrega
 
         try {
             $this->results->add($runner->verify($input));
+        } catch (\Throwable $e) {
+            $this->eventDispatcher->dispatch(new ExerciseRunnerEvent('verify.post.exception', $exercise, $input));
+            throw $e;
         } finally {
             $this->eventDispatcher->dispatch(new ExerciseRunnerEvent('verify.post.execute', $exercise, $input));
         }

src/Listener/CodePatchListener.php

@@ -6,10 +6,12 @@
 
 use PhpSchool\PhpWorkshop\CodePatcher;
 use PhpSchool\PhpWorkshop\Event\ExerciseRunnerEvent;
+use PhpSchool\PhpWorkshop\Exercise\ProvidesSolution;
+use PhpSchool\PhpWorkshop\Solution\SolutionFile;
 use RuntimeException;
 
 /**
- * Listener which patches student's solutions
+ * Listener which patches internal and student's solutions
  */
 class CodePatchListener
 {
@@ -19,9 +21,9 @@ class CodePatchListener
     private $codePatcher;
 
     /**
-     * @var string
+     * @var array<string, string>
      */
-    private $originalCode;
+    private $originalCode = [];
 
     /**
      * @param CodePatcher $codePatcher
@@ -36,34 +38,40 @@ public function __construct(CodePatcher $codePatcher)
      */
     public function patch(ExerciseRunnerEvent $event): void
     {
-        $fileName = $event->getInput()->getArgument('program');
+        $files = [
+            $event->getInput()->getArgument('program'),
+        ];
 
-        if (null === $fileName) {
-            return;
+        $exercise = $event->getExercise();
+        if ($exercise instanceof ProvidesSolution) {
+            $files[] = $exercise->getSolution()->getEntryPoint();
         }
 
-        $this->originalCode = (string) file_get_contents($fileName);
-        file_put_contents(
-            $fileName,
-            $this->codePatcher->patch($event->getExercise(), $this->originalCode)
-        );
+        foreach ($files as $fileName) {
+            if (null === $fileName) {
+                return;
+            }
+
+            $this->originalCode[$fileName] = (string) file_get_contents($fileName);
+
+            file_put_contents(
+                $fileName,
+                $this->codePatcher->patch($event->getExercise(), $this->originalCode[$fileName])
+            );
+        }
     }
 
     /**
-     * @param ExerciseRunnerEvent $event
+     * @param \PhpSchool\PhpWorkshop\Event\EventInterface $event
      */
-    public function revert(ExerciseRunnerEvent $event): void
+    public function revert(\PhpSchool\PhpWorkshop\Event\EventInterface $event): void
     {
         if (null === $this->originalCode) {
             throw new RuntimeException('Can only revert previously patched code');
         }
 
-        $fileName = $event->getInput()->getArgument('program');
-
-        if (null === $fileName) {
-            return;
+        foreach ($this->originalCode as $fileName => $contents) {
+            file_put_contents($fileName, $contents);
         }
-
-        file_put_contents($fileName, $this->originalCode);
     }
 }

src/Listener/InMemorySolutionListener.php

@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpSchool\PhpWorkshop\Listener;
+
+use PhpSchool\PhpWorkshop\Event\ExerciseRunnerEvent;
+use Symfony\Component\Filesystem\Filesystem;
+
+/**
+ * Move solution to temp and replace program arg
+ */
+class InMemorySolutionListener
+{
+    /**
+     * @param ExerciseRunnerEvent $event
+     */
+    public function __invoke(ExerciseRunnerEvent $event): void
+    {
+        if (!$event->getInput()->hasArgument('program')) {
+            return;
+        }
+
+        $program = $event->getInput()->getRequiredArgument('program');
+
+        if (!file_exists($program)) {
+            return;
+        }
+
+        $filesystem = new Filesystem();
+        $basedir = basename($program);
+        $tmp = sprintf('%s/php-school/user-solution', sys_get_temp_dir());
+
+        if ($filesystem->exists($tmp)) {
+            $filesystem->remove($tmp);
+        }
+
+        $filesystem->mkdir($tmp);
+
+        // Iterator with exclusions... TODO: Useful?
+        $dirIterator = new \RecursiveDirectoryIterator($basedir, \RecursiveDirectoryIterator::SKIP_DOTS);
+        $filter = new class($dirIterator) extends RecursiveFilterIterator {
+            private const FILTERS = ['vendor', '.idea', ',git'];
+            public function accept() {
+                return !in_array($this->current()->getFilename(), self::FILTERS, true);
+            }
+        };
+        $iterator = new \RecursiveIteratorIterator($filter, \RecursiveIteratorIterator::SELF_FIRST);
+
+        $composerFile = sprintf('%s/composer.json', $basedir);
+        if ($filesystem->exists($composerFile)) {
+            $filesystem->copy($composerFile, $tmp . '/composer.json');
+        }
+
+
+        // TODO should this event be somewhere we have the exercise
+        // TODO: We could then check if it's a single file solutino or dir solution
+        // TODO: Single file solutions can be just copying entrypoint to temp
+        // TODO: dir solution we can copy the dirname to temp, however we should take care here
+        // TODO: e.g. what if it's all just in the root home dir... we can't recursively copy that all into temp...
+        // TODO: how do we prevent such an issue ?!?
+
+
+        $event->getInput()->setArgument('program', (string) realpath($program));
+    }
+}

src/Solution/DirectorySolution.php

@@ -40,7 +40,7 @@ class DirectorySolution implements SolutionInterface
      * @param array<string> $exclusions An array of file names to exclude from the folder.
      * @throws InvalidArgumentException If the entry point does not exist in the folder.
      */
-    public function __construct(string $directory, string $entryPoint, array $exclusions = [])
+    private function __construct(string $directory, string $entryPoint, array $exclusions = [])
     {
         $directory  = (string) realpath(rtrim($directory, '/'));
         $entryPoint = ltrim($entryPoint, '/');
@@ -83,13 +83,18 @@ public function __construct(string $directory, string $entryPoint, array $exclus
      * @param string $entryPoint The relative path from the directory of the entry point file.
      * @return self
      */
-    public static function fromDirectory(string $directory, array $exclusions = [], $entryPoint = 'solution.php'): self
-    {
-        return new self($directory, $entryPoint, array_merge($exclusions, ['composer.lock', 'vendor']));
+    public static function fromDirectory(
+        string $directory,
+        array $exclusions = [],
+        $entryPoint = 'solution.php'
+    ): SolutionInterface {
+        return InMemorySolution::fromSolution(
+            new self($directory, $entryPoint, array_merge($exclusions, ['composer.lock', 'vendor']))
+        );
     }
 
     /**
-     * Get the entry point. This is the PHP file that PHO would execute in order to run the
+     * Get the entry point. This is the PHP file that PHP would execute in order to run the
      * program. This should be the absolute path.
      *
      * @return string