Custom runner

app/config.php

@@ -22,6 +22,7 @@
 use PhpSchool\PhpWorkshop\ExerciseDispatcher;
 use PhpSchool\PhpWorkshop\ExerciseRunner\Factory\CgiRunnerFactory;
 use PhpSchool\PhpWorkshop\ExerciseRunner\Factory\CliRunnerFactory;
+use PhpSchool\PhpWorkshop\ExerciseRunner\Factory\CustomVerifyingRunnerFactory;
 use PhpSchool\PhpWorkshop\ExerciseRunner\RunnerManager;
 use PhpSchool\PhpWorkshop\Factory\EventDispatcherFactory;
 use PhpSchool\PhpWorkshop\Factory\MenuFactory;
@@ -125,6 +126,7 @@
         $manager = new RunnerManager;
         $manager->addFactory(new CliRunnerFactory($c->get(EventDispatcher::class)));
         $manager->addFactory(new CgiRunnerFactory($c->get(EventDispatcher::class)));
+        $manager->addFactory(new CustomVerifyingRunnerFactory);
         return $manager;
     },
 
@@ -326,25 +328,25 @@
                 containerListener(CodePatchListener::class, 'patch'),
             ],
             'cli.verify.finish' => [
-                containerListener(CodePatchListener::class, 'patch'),
+                containerListener(CodePatchListener::class, 'revert'),
             ],
             'cli.run.start' => [
                 containerListener(CodePatchListener::class, 'patch'),
             ],
             'cli.run.finish' => [
-                containerListener(CodePatchListener::class, 'patch'),
+                containerListener(CodePatchListener::class, 'revert'),
             ],
             'cgi.verify.start' => [
                 containerListener(CodePatchListener::class, 'patch'),
             ],
             'cgi.verify.finish' => [
-                containerListener(CodePatchListener::class, 'patch'),
+                containerListener(CodePatchListener::class, 'revert'),
             ],
             'cgi.run.start' => [
                 containerListener(CodePatchListener::class, 'patch'),
             ],
             'cgi.run.finish' => [
-                containerListener(CodePatchListener::class, 'patch'),
+                containerListener(CodePatchListener::class, 'revert'),
             ],
         ],
         'self-check' => [

src/Exercise/CustomVerifyingExercise.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace PhpSchool\PhpWorkshop\Exercise;
+
+use PhpSchool\PhpWorkshop\Result\ResultInterface;
+
+/**
+ * @author Aydin Hassan <[email protected]>
+ */
+interface CustomVerifyingExercise
+{
+    /**
+     * @return ResultInterface
+     */
+    public function verify();
+}

src/Exercise/ExerciseType.php

@@ -20,6 +20,8 @@ class ExerciseType extends Enum
 {
     const CLI    = 'CLI';
     const CGI    = 'CGI';
+    const CUSTOM = 'CUSTOM';
+
 
     /**
      * Map of exercise types to the required interfaces exercises of that particular
@@ -30,6 +32,7 @@ class ExerciseType extends Enum
     private static $exerciseTypeToExerciseInterfaceMap = [
         self::CLI    => CliExercise::class,
         self::CGI    => CgiExercise::class,
+        self::CUSTOM => CustomVerifyingExercise::class,
     ];
 
     /**

src/ExerciseRunner/CustomVerifyingRunner.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace PhpSchool\PhpWorkshop\ExerciseRunner;
+
+use PhpSchool\PhpWorkshop\Exercise\CustomVerifyingExercise;
+use PhpSchool\PhpWorkshop\Input\Input;
+use PhpSchool\PhpWorkshop\Output\OutputInterface;
+use PhpSchool\PhpWorkshop\Result\ResultInterface;
+
+/**
+ * @author Aydin Hassan <[email protected]>
+ */
+class CustomVerifyingRunner implements ExerciseRunnerInterface
+{
+    /**
+     * @var CustomVerifyingExercise
+     */
+    private $exercise;
+
+    /**
+     * @param CustomVerifyingExercise $exercise
+     */
+    public function __construct(CustomVerifyingExercise $exercise)
+    {
+        $this->exercise = $exercise;
+    }
+
+    /**
+     * Get the name of the exercise runner.
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return 'Custom Verifying Runner';
+    }
+
+    /**
+     * Get an array of the class names of the required checks this runner needs.
+     *
+     * @return array
+     */
+    public function getRequiredChecks()
+    {
+        return [];
+    }
+
+    /**
+     * Verify a solution to an exercise. Verification involves executing the reference solution
+     * and the student's solution and comparing their output. If the output is the same
+     * an instance of `PhpSchool\PhpWorkshop\Result\SuccessInterface` should be returned, if the output
+     * is not the same, or something else went wrong then an instance of
+     * `\PhpSchool\PhpWorkshop\Result\FailureInterface` should be returned.
+     *
+     * Other things that could go wrong include the student's solution returning a non-zero
+     * exit code, or a notice/warning being exhibited.
+     *
+     * @param Input $input The command line arguments passed to the command.
+     * @return ResultInterface The result of the check.
+     */
+    public function verify(Input $input)
+    {
+        return $this->exercise->verify();
+    }
+
+    /**
+     * Run a solution to an exercise. This simply run's the student's solution with the correct input from the exercise
+     * (such as the CLI arguments) and prints the output directly. This allows the student to have the environment
+     * setup for them including getting a different set of arguments each time (if the exercise supports that).
+     *
+     * @param Input $input The command line arguments passed to the command.
+     * @param OutputInterface $output A wrapper around STDOUT.
+     * @return bool If the solution was successfully executed, eg. exit code was 0.
+     */
+    public function run(Input $input, OutputInterface $output)
+    {
+        $message  = 'Nothing to run here. This exercise does not require a code solution, ';
+        $message .= 'so there is nothing to execute.';
+        $output->writeLine($message);
+        return true;
+    }
+}

src/ExerciseRunner/Factory/CustomVerifyingRunnerFactory.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace PhpSchool\PhpWorkshop\ExerciseRunner\Factory;
+
+use PhpSchool\PhpWorkshop\CommandDefinition;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
+use PhpSchool\PhpWorkshop\ExerciseRunner\CustomVerifyingRunner;
+use PhpSchool\PhpWorkshop\ExerciseRunner\ExerciseRunnerInterface;
+
+/**
+ * @author Aydin Hassan <[email protected]>
+ */
+class CustomVerifyingRunnerFactory implements ExerciseRunnerFactoryInterface
+{
+    /**
+     * @var string
+     */
+    private static $type = ExerciseType::CUSTOM;
+
+    /**
+     * Whether the factory supports this exercise type.
+     *
+     * @param ExerciseInterface $exercise
+     * @return bool
+     */
+    public function supports(ExerciseInterface $exercise)
+    {
+        return $exercise->getType()->getValue() === self::$type;
+    }
+
+    /**
+     * Add any extra required arguments to the command.
+     *
+     * @param CommandDefinition $commandDefinition
+     */
+    public function configureInput(CommandDefinition $commandDefinition)
+    {
+    }
+
+    /**
+     * Create and return an instance of the runner.
+     *
+     * @param ExerciseInterface $exercise
+     * @return ExerciseRunnerInterface
+     */
+    public function create(ExerciseInterface $exercise)
+    {
+        return new CustomVerifyingRunner($exercise);
+    }
+}

test/Asset/CustomVerifyingExerciseImpl.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace PhpSchool\PhpWorkshopTest\Asset;
+
+use PhpSchool\PhpWorkshop\Exercise\AbstractExercise;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
+use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
+use PhpSchool\PhpWorkshop\Exercise\CustomVerifyingExercise;
+use PhpSchool\PhpWorkshop\Result\ResultInterface;
+use PhpSchool\PhpWorkshop\Result\Success;
+
+/**
+ * @author Aydin Hassan <[email protected]>
+ */
+class CustomVerifyingExerciseImpl extends AbstractExercise implements ExerciseInterface, CustomVerifyingExercise
+{
+
+    /**
+     * Get the name of the exercise, like `Hello World!`.
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return 'Custom Verifying exercise';
+    }
+
+    /**
+     * A short description of the exercise.
+     *
+     * @return string
+     */
+    public function getDescription()
+    {
+        return 'Custom Verifying exercise';
+    }
+
+    /**
+     * Return the type of exercise. This is an ENUM. See `PhpSchool\PhpWorkshop\Exercise\ExerciseType`.
+     *
+     * @return ExerciseType
+     */
+    public function getType()
+    {
+        return ExerciseType::CUSTOM();
+    }
+
+    /**
+     * @return ResultInterface
+     */
+    public function verify()
+    {
+        return new Success('success');
+    }
+}

test/ExerciseRunner/CustomVerifyingRunnerTest.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace PhpSchool\PhpWorkshop\ExerciseRunner;
+
+use Colors\Color;
+use PhpSchool\CliMenu\Terminal\TerminalInterface;
+use PhpSchool\PhpWorkshop\Input\Input;
+use PhpSchool\PhpWorkshop\Output\StdOutput;
+use PhpSchool\PhpWorkshopTest\Asset\CustomVerifyingExerciseImpl;
+use PHPUnit_Framework_TestCase;
+
+/**
+ * @author Aydin Hassan <[email protected]>
+ */
+class ExtRunnerTest extends PHPUnit_Framework_TestCase
+{
+    /**
+     * @var CustomVerifyingRunner
+     */
+    private $runner;
+
+    /**
+     * @var CustomVerifyingExerciseImpl
+     */
+    private $exercise;
+
+    public function setUp()
+    {
+        $this->exercise = new CustomVerifyingExerciseImpl;
+        $this->runner = new CustomVerifyingRunner($this->exercise);
+
+        $this->assertEquals('Custom Verifying Runner', $this->runner->getName());
+    }
+
+    public function testRequiredChecks()
+    {
+        $this->assertEquals([], $this->runner->getRequiredChecks());
+    }
+
+    public function testRunOutputsErrorMessage()
+    {
+        $color = new Color;
+        $color->setForceStyle(true);
+        $output = new StdOutput($color, $this->createMock(TerminalInterface::class));
+
+        $exp  = 'Nothing to run here. This exercise does not require a code solution, ';
+        $exp .= "so there is nothing to execute.\n";
+
+        $this->expectOutputString($exp);
+
+        $this->runner->run(new Input('app'), $output);
+    }
+
+    public function testVerifyProxiesToExercise()
+    {
+        self::assertEquals($this->exercise->verify(), $this->runner->verify(new Input('app')));
+    }
+}

test/ExerciseRunner/Factory/CliRunnerFactoryTest.php

@@ -4,13 +4,11 @@
 
 use PhpSchool\PhpWorkshop\CommandDefinition;
 use PhpSchool\PhpWorkshop\Event\EventDispatcher;
-use PhpSchool\PhpWorkshop\Exercise\CliExercise;
 use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
 use PhpSchool\PhpWorkshop\ExerciseRunner\CliRunner;
 use PhpSchool\PhpWorkshop\ExerciseRunner\Factory\CliRunnerFactory;
 use PhpSchool\PhpWorkshopTest\Asset\CliExerciseImpl;
-use PhpSchool\PhpWorkshopTest\Asset\CliExerciseInterface;
 use PHPUnit_Framework_TestCase;
 
 /**