├── test
    ├── res
    │   ├── composer
    │   │   ├── no-klein
    │   │   │   ├── vendor
    │   │   │   │   └── .gitkeep
    │   │   │   ├── solution.php
    │   │   │   └── composer.json
    │   │   ├── good-solution
    │   │   │   ├── vendor
    │   │   │   │   └── .gitkeep
    │   │   │   └── composer.json
    │   │   ├── no-stringy
    │   │   │   ├── vendor
    │   │   │   │   └── .gitkeep
    │   │   │   ├── solution.php
    │   │   │   └── composer.json
    │   │   ├── no-vendor
    │   │   │   ├── composer.json
    │   │   │   └── solution.php
    │   │   └── not-locked
    │   │   │   ├── composer.json
    │   │   │   └── solution.php
    │   ├── cgi
    │   │   ├── user-error.php
    │   │   ├── solution-error.php
    │   │   ├── get-solution.php
    │   │   ├── get-user-wrong.php
    │   │   ├── post-solution.php
    │   │   ├── post-multiple-solution.php
    │   │   ├── get-solution-header.php
    │   │   └── get-user-header-wrong.php
    │   ├── cli
    │   │   ├── user-wrong.php
    │   │   ├── user.php
    │   │   ├── solution.php
    │   │   ├── user-error.php
    │   │   └── solution-error.php
    │   ├── database
    │   │   ├── user-wrong.php
    │   │   ├── user.php
    │   │   ├── solution.php
    │   │   ├── user-error.php
    │   │   ├── solution-error.php
    │   │   ├── solution-alter-db.php
    │   │   └── user-solution-alter-db.php
    │   ├── lint
    │   │   ├── fail.php
    │   │   └── pass.php
    │   ├── function-requirements
    │   │   ├── fail-invalid-code.php
    │   │   ├── fail-banned-function.php
    │   │   └── success.php
    │   ├── app-run-missing-solution-expected.txt
    │   ├── app-credits-core-expected.txt
    │   ├── app-credits-expected.txt
    │   ├── exercise-help-expected.txt
    │   ├── exercise-renderer
    │   │   ├── test-render-all-failures.txt
    │   │   ├── test-render-success.txt
    │   │   ├── test-render-success-and-failure.txt
    │   │   ├── test-render-success-with-solution.txt
    │   │   ├── test-render-success-with-php-solution-file-is-syntax-highlighted.txt
    │   │   └── test-all-success-results-are-hoisted-to-the-top.txt
    │   └── app-help-expected.txt
    ├── Asset
    │   ├── provided-solution
    │   │   └── solution.php
    │   ├── initial-code
    │   │   └── init-solution.php
    │   ├── SelfCheckExerciseInterface.php
    │   ├── TemporaryDirectoryTraitImpl.php
    │   ├── ResultResultAggregator.php
    │   ├── AbstractExerciseImpl.php
    │   ├── CliExerciseMissingInterface.php
    │   ├── CustomVerifyingExerciseImpl.php
    │   ├── PatchableExercise.php
    │   ├── MockEventDispatcher.php
    │   ├── ProvidesSolutionExercise.php
    │   ├── ExerciseWithInitialCode.php
    │   └── ComposerExercise.php
    ├── bootstrap.php
    ├── ExerciseRunner
    │   ├── Context
    │   │   └── NoEntryPointTest.php
    │   └── CustomVerifyingRunnerTest.php
    ├── Exception
    │   ├── SolutionExecutionExceptionTest.php
    │   ├── CliRouteNotExistsTest.php
    │   ├── SolutionFileDoesNotExistExceptionTest.php
    │   ├── MissingArgumentExceptionTest.php
    │   ├── ExerciseNotConfiguredExceptionTest.php
    │   ├── CheckNotApplicableExceptionTest.php
    │   └── CodeExecutionExceptionTest.php
    ├── TestWorkshopType.php
    ├── Process
    │   ├── ProcessNotFoundExceptionTest.php
    │   └── ProcessInputTest.php
    ├── Command
    │   ├── MenuCommandTest.php
    │   ├── HelpCommandTest.php
    │   ├── MenuCommandInvokerTest.php
    │   └── PrintCommandTest.php
    ├── Exercise
    │   ├── TemporaryDirectoryTraitTest.php
    │   └── Scenario
    │   │   ├── CgiScenarioTest.php
    │   │   └── CliScenarioTest.php
    ├── ResultRenderer
    │   ├── FailureRendererTest.php
    │   ├── ComparisonFailureRendererTest.php
    │   ├── Cli
    │   │   └── RequestFailureRendererTest.php
    │   ├── FileComparisonFailureRendererTest.php
    │   └── FunctionRequirementsFailureRendererTest.php
    ├── Result
    │   ├── Cli
    │   │   ├── SuccessTest.php
    │   │   ├── CliResultTest.php
    │   │   ├── RequestFailureTest.php
    │   │   └── GenericFailureTest.php
    │   ├── Cgi
    │   │   ├── SuccessTest.php
    │   │   └── CgiResultTest.php
    │   ├── FileComparisonFailureTest.php
    │   ├── FunctionRequirementsFailureTest.php
    │   ├── SuccessTest.php
    │   └── ComparisonFailureTest.php
    ├── Markdown
    │   ├── Shorthands
    │   │   ├── Cloud
    │   │   │   ├── RunTest.php
    │   │   │   └── VerifyTest.php
    │   │   ├── Cli
    │   │   │   ├── RunTest.php
    │   │   │   └── VerifyTest.php
    │   │   └── ContextTest.php
    │   ├── CurrentContextTest.php
    │   └── Block
    │   │   └── ContextSpecificBlockTest.php
    ├── CommandArgumentTest.php
    ├── CodeInsertionTest.php
    ├── Solution
    │   └── SingleFileSolutionTest.php
    ├── Event
    │   ├── ContainerListenerHelperTest.php
    │   ├── ExerciseRunnerEventTest.php
    │   ├── EventTest.php
    │   ├── CgiExerciseRunnerEventTest.php
    │   ├── CliExerciseRunnerEventTest.php
    │   └── CliExecuteEventTest.php
    ├── MarkdownRendererTest.php
    ├── MockLogger.php
    ├── Listener
    │   ├── TearDownListenerTest.php
    │   └── SelfCheckListenerTest.php
    ├── Utils
    │   ├── SystemTest.php
    │   └── PathTest.php
    ├── ComposerUtil
    │   └── LockFileParserTest.php
    ├── Patch
    │   └── ForceStrictTypesTest.php
    ├── BaseTest.php
    ├── Logger
    │   └── ConsoleLoggerTest.php
    ├── Input
    │   └── InputTest.php
    └── FunctionsTest.php
├── codecov.yml
├── .gitignore
├── vendor-bin
    └── php-cs-fixer
    │   └── composer.json
├── src
    ├── Exception
    │   ├── RuntimeException.php
    │   ├── SolutionExecutionException.php
    │   ├── ExerciseNotAssignedException.php
    │   ├── ProblemFileDoesNotExistException.php
    │   ├── CliRouteNotExistsException.php
    │   ├── SolutionFileDoesNotExistException.php
    │   ├── CouldNotRunException.php
    │   ├── CodeExecutionException.php
    │   ├── ExerciseNotConfiguredException.php
    │   ├── CheckNotApplicableException.php
    │   └── MissingArgumentException.php
    ├── UserState
    │   └── Serializer.php
    ├── Process
    │   ├── ProcessFactory.php
    │   ├── ProcessNotFoundException.php
    │   ├── ProcessInput.php
    │   └── HostProcessFactory.php
    ├── Utils
    │   ├── Collection.php
    │   ├── Path.php
    │   ├── System.php
    │   └── RequestRenderer.php
    ├── Patch
    │   ├── Transformer.php
    │   ├── ForceStrictTypes.php
    │   └── WrapInTryCatch.php
    ├── Result
    │   ├── SuccessInterface.php
    │   ├── Cgi
    │   │   ├── SuccessInterface.php
    │   │   ├── FailureInterface.php
    │   │   ├── ResultInterface.php
    │   │   └── Success.php
    │   ├── Cli
    │   │   ├── SuccessInterface.php
    │   │   ├── FailureInterface.php
    │   │   ├── ResultInterface.php
    │   │   └── Success.php
    │   ├── FailureInterface.php
    │   ├── ResultGroupInterface.php
    │   ├── ResultInterface.php
    │   ├── ResultTrait.php
    │   └── Success.php
    ├── ExerciseRunner
    │   ├── Context
    │   │   └── NoEntryPoint.php
    │   └── Factory
    │   │   ├── ExerciseRunnerFactoryInterface.php
    │   │   └── CustomVerifyingRunnerFactory.php
    ├── Event
    │   ├── functions.php
    │   ├── CgiExerciseRunnerEvent.php
    │   ├── CliExerciseRunnerEvent.php
    │   ├── EventInterface.php
    │   ├── ContainerListenerHelper.php
    │   ├── ExerciseRunnerEvent.php
    │   └── Event.php
    ├── Exercise
    │   ├── CustomVerifyingExercise.php
    │   ├── ProvidesSolution.php
    │   ├── ProvidesInitialCode.php
    │   ├── MockExercise.php
    │   ├── Scenario
    │   │   ├── ExerciseScenario.php
    │   │   ├── CgiScenario.php
    │   │   └── CliScenario.php
    │   ├── TemporaryDirectoryTrait.php
    │   ├── CgiExercise.php
    │   ├── SubmissionPatchable.php
    │   ├── CliExercise.php
    │   ├── ExerciseType.php
    │   └── ExerciseInterface.php
    ├── ExerciseCheck
    │   ├── FileComparisonExerciseCheck.php
    │   ├── ComposerExerciseCheck.php
    │   ├── FunctionRequirementsExerciseCheck.php
    │   ├── SelfCheck.php
    │   └── DatabaseExerciseCheck.php
    ├── Markdown
    │   ├── Shorthands
    │   │   ├── ShorthandInterface.php
    │   │   ├── Cloud
    │   │   │   ├── AppName.php
    │   │   │   ├── Run.php
    │   │   │   └── Verify.php
    │   │   ├── Context.php
    │   │   ├── Cli
    │   │   │   ├── Run.php
    │   │   │   ├── Verify.php
    │   │   │   └── AppName.php
    │   │   └── Documentation.php
    │   ├── CurrentContext.php
    │   ├── Renderer
    │   │   └── ContextSpecificRenderer.php
    │   ├── Block
    │   │   └── ContextSpecificBlock.php
    │   ├── Parser
    │   │   └── ContextSpecificBlockParser.php
    │   └── ProblemFileExtension.php
    ├── Check
    │   ├── CheckInterface.php
    │   └── ListenableCheckInterface.php
    ├── WorkshopType.php
    ├── Listener
    │   ├── TearDownListener.php
    │   ├── RealPathListener.php
    │   ├── SelfCheckListener.php
    │   ├── CheckExerciseAssignedListener.php
    │   ├── LazyContainerListener.php
    │   └── PrepareSolutionListener.php
    ├── Command
    │   ├── MenuCommand.php
    │   └── MenuCommandInvoker.php
    ├── ResultRenderer
    │   ├── ResultRendererInterface.php
    │   ├── FailureRenderer.php
    │   ├── ComposerFailureRenderer.php
    │   └── ComparisonFailureRenderer.php
    ├── Output
    │   ├── NullOutput.php
    │   ├── BufferedOutput.php
    │   └── OutputInterface.php
    ├── Solution
    │   └── SolutionInterface.php
    ├── Logger
    │   ├── ConsoleLogger.php
    │   └── Logger.php
    ├── MenuItem
    │   └── ResetProgress.php
    ├── MarkdownRenderer.php
    └── CommandArgument.php
├── .phpstorm.meta.php
├── .php-cs-fixer.php
├── phpstan.neon
├── phpunit.xml
├── LICENSE
├── README.md
└── .github
    └── workflows
        └── php-workshop.yml


/test/res/composer/no-klein/vendor/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/test/res/composer/good-solution/vendor/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/test/res/composer/no-stringy/vendor/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/test/res/cgi/user-error.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo
4 | 


--------------------------------------------------------------------------------
/test/res/cgi/solution-error.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo
4 | 


--------------------------------------------------------------------------------
/test/res/cli/user-wrong.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo 10;
4 | 


--------------------------------------------------------------------------------
/test/res/database/user-wrong.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo 10;
4 | 


--------------------------------------------------------------------------------
/test/res/lint/fail.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo 'Hello World'
4 | 


--------------------------------------------------------------------------------
/test/res/lint/pass.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo 'Hello World';
4 | 


--------------------------------------------------------------------------------
/test/res/cgi/get-solution.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo $_GET['number'] * 2;
4 | 


--------------------------------------------------------------------------------
/test/res/cgi/get-user-wrong.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo $_GET['number'] * 3;
4 | 


--------------------------------------------------------------------------------
/test/res/cgi/post-solution.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo $_POST['number'] * 2;
4 | 


--------------------------------------------------------------------------------
/test/Asset/provided-solution/solution.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo 'Hello World';
4 | 


--------------------------------------------------------------------------------
/test/bootstrap.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | require_once __DIR__ . '/../vendor/autoload.php';
4 | 


--------------------------------------------------------------------------------
/test/res/cgi/post-multiple-solution.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | echo $_POST['start'] + ($_POST['number'] * 2);
4 | 


--------------------------------------------------------------------------------
/test/res/cgi/get-solution-header.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | header('Pragma: cache');
4 | echo $_GET['number'] * 2;
5 | 


--------------------------------------------------------------------------------
/test/res/cgi/get-user-header-wrong.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | header('Pragma: no-cache');
4 | echo $_GET['number'] * 2;
5 | 


--------------------------------------------------------------------------------
/codecov.yml:
--------------------------------------------------------------------------------
1 | coverage:
2 |   status:
3 |     project:
4 |       default:
5 |         target: 70%
6 |     patch: false
7 | 


--------------------------------------------------------------------------------
/test/res/function-requirements/fail-invalid-code.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $lines = file($argv[1])
4 | echo count($lines) + 1;
5 | 


--------------------------------------------------------------------------------
/test/res/function-requirements/fail-banned-function.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $lines = file($argv[1]);
4 | echo count($lines) + 1;
5 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor
2 | /.idea
3 | program.php
4 | .phpunit.result.cache
5 | /build
6 | /vendor-bin/**/vendor/
7 | .php-cs-fixer.cache


--------------------------------------------------------------------------------
/test/Asset/initial-code/init-solution.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | echo "This is an initial solution";
6 | 


--------------------------------------------------------------------------------
/vendor-bin/php-cs-fixer/composer.json:
--------------------------------------------------------------------------------
1 | {
2 |     "require-dev": {
3 |         "friendsofphp/php-cs-fixer": "^3.56"
4 |     }
5 | }
6 | 


--------------------------------------------------------------------------------
/test/res/composer/no-klein/solution.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | // Require composer autoloader
4 | require __DIR__ . '/vendor/autoload.php';
5 | 


--------------------------------------------------------------------------------
/test/res/composer/no-stringy/solution.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | // Require composer autoloader
4 | require __DIR__ . '/vendor/autoload.php';
5 | 


--------------------------------------------------------------------------------
/test/res/cli/user.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $count = 0;
4 | for ($i = 1; $i < count($argv); $i++) {
5 |     $count += $argv[$i];
6 | }
7 | 
8 | echo $count;
9 | 


--------------------------------------------------------------------------------
/test/res/cli/solution.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $count = 0;
4 | for ($i = 1; $i < count($argv); $i++) {
5 |     $count += $argv[$i];
6 | }
7 | 
8 | echo $count;
9 | 


--------------------------------------------------------------------------------
/test/res/cli/user-error.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $count = 0;
4 | for ($i = 1; $i < count($argv); $i++) {
5 |     $count += $argv[$i];
6 | }
7 | 
8 | echo $count
9 | 


--------------------------------------------------------------------------------
/test/res/database/user.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $count = 0;
4 | for ($i = 2; $i < count($argv); $i++) {
5 |     $count += $argv[$i];
6 | }
7 | 
8 | echo $count;
9 | 


--------------------------------------------------------------------------------
/test/res/cli/solution-error.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $count = 0;
4 | for ($i = 1; $i < count($argv); $i++) {
5 |     $count += $argv[$i];
6 | }
7 | 
8 | echo $count
9 | 


--------------------------------------------------------------------------------
/test/res/database/solution.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $count = 0;
4 | for ($i = 2; $i < count($argv); $i++) {
5 |     $count += $argv[$i];
6 | }
7 | 
8 | echo $count;
9 | 


--------------------------------------------------------------------------------
/test/res/database/user-error.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $count = 0;
4 | for ($i = 1; $i < count($argv); $i++) {
5 |     $count += $argv[$i];
6 | }
7 | 
8 | echo $count
9 | 


--------------------------------------------------------------------------------
/test/res/database/solution-error.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $count = 0;
4 | for ($i = 1; $i < count($argv); $i++) {
5 |     $count += $argv[$i];
6 | }
7 | 
8 | echo $count
9 | 


--------------------------------------------------------------------------------
/test/res/function-requirements/success.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $contents = file_get_contents($argv[1]);
4 | $lines = explode("\n", $contents);
5 | echo count($lines);
6 | 


--------------------------------------------------------------------------------
/src/Exception/RuntimeException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | namespace PhpSchool\PhpWorkshop\Exception;
6 | 
7 | class RuntimeException extends \RuntimeException {}
8 | 


--------------------------------------------------------------------------------
/test/res/app-run-missing-solution-expected.txt:
--------------------------------------------------------------------------------
1 | 
2 |                                       
3 |   File: "solution.php" does not exist 
4 |                                       
5 | 
6 | 


--------------------------------------------------------------------------------
/src/UserState/Serializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\UserState;
 4 | 
 5 | interface Serializer
 6 | {
 7 |     public function serialize(UserState $state): void;
 8 | 
 9 |     public function deSerialize(): UserState;
10 | }
11 | 


--------------------------------------------------------------------------------
/test/res/database/solution-alter-db.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $db = new \PDO($argv[1]);
4 | 
5 | $stmt = $db->prepare('INSERT into users (name, age, gender) VALUES (:name, :age, :gender)');
6 | $stmt->execute([':name' => 'Jim Morrison', ':age' => 27, ':gender' => 'Male']);
7 | 


--------------------------------------------------------------------------------
/test/res/database/user-solution-alter-db.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $db = new \PDO($argv[1]);
4 | 
5 | $stmt = $db->prepare('INSERT into users (name, age, gender) VALUES (:name, :age, :gender)');
6 | $stmt->execute([':name' => 'Kurt Cobain', ':age' => 27, ':gender' => 'Male']);
7 | 


--------------------------------------------------------------------------------
/src/Process/ProcessFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Process;
 6 | 
 7 | use Symfony\Component\Process\Process;
 8 | 
 9 | interface ProcessFactory
10 | {
11 |     public function create(ProcessInput $processInput): Process;
12 | }
13 | 


--------------------------------------------------------------------------------
/test/Asset/SelfCheckExerciseInterface.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace PhpSchool\PhpWorkshopTest\Asset;
4 | 
5 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
6 | use PhpSchool\PhpWorkshop\ExerciseCheck\SelfCheck;
7 | 
8 | interface SelfCheckExerciseInterface extends ExerciseInterface, SelfCheck {}
9 | 


--------------------------------------------------------------------------------
/test/res/app-credits-core-expected.txt:
--------------------------------------------------------------------------------
1 | PHP School is bought to you by...
2 | 
3 | Name              GitHub Username
4 | ---------------------------------
5 | Aydin Hassan      @AydinHassan
6 | Michael Woodward  @mikeymike
7 | Shane Osbourne    @shakeyShane
8 | Chris Bailey      @chris3ailey
9 | 


--------------------------------------------------------------------------------
/.phpstorm.meta.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace PHPSTORM_META
 3 | {
 4 |     $STATIC_METHOD_TYPES = [
 5 |         \DI\Container::get('') => [
 6 |             "" == "@",
 7 |         ],
 8 |         \Psr\Container\ContainerInterface::get('') => [
 9 |             "" == "@",
10 |         ],
11 |     ];
12 | }
13 | 


--------------------------------------------------------------------------------
/.php-cs-fixer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $finder = (new PhpCsFixer\Finder())
 4 |     ->in(__DIR__)
 5 |     ->exclude('test/res')
 6 | ;
 7 | 
 8 | return (new PhpCsFixer\Config())
 9 |     ->setRules([
10 |         '@PER-CS2.0' => true,
11 |         'no_unused_imports' => true,
12 |     ])
13 |     ->setFinder($finder);


--------------------------------------------------------------------------------
/src/Utils/Collection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Utils;
 6 | 
 7 | /**
 8 |  * ArrayObject is not a good name...
 9 |  * @template TKey of array-key
10 |  * @template T
11 |  * @extends ArrayObject<TKey, T>
12 |  */
13 | class Collection extends ArrayObject {}
14 | 


--------------------------------------------------------------------------------
/src/Patch/Transformer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Patch;
 4 | 
 5 | use PhpParser\Node\Stmt;
 6 | 
 7 | interface Transformer
 8 | {
 9 |     /**
10 |      * @param array<Stmt> $statements
11 |      * @return array<Stmt>
12 |      */
13 |     public function transform(array $statements): array;
14 | }
15 | 


--------------------------------------------------------------------------------
/test/Asset/TemporaryDirectoryTraitImpl.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Asset;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exercise\TemporaryDirectoryTrait;
 6 | 
 7 | class TemporaryDirectoryTraitImpl
 8 | {
 9 |     use TemporaryDirectoryTrait {
10 |         getTemporaryPath as public;
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Result/SuccessInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result;
 6 | 
 7 | /**
 8 |  * This interface represents a success. Any result implementing this interface will
 9 |  * be treated as a success.
10 |  */
11 | interface SuccessInterface extends ResultInterface {}
12 | 


--------------------------------------------------------------------------------
/src/Result/Cgi/SuccessInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result\Cgi;
 6 | 
 7 | /**
 8 |  * This interface represents a success. Any result implementing this interface will
 9 |  * be treated as a success.
10 |  */
11 | interface SuccessInterface extends ResultInterface {}
12 | 


--------------------------------------------------------------------------------
/src/Result/Cli/SuccessInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result\Cli;
 6 | 
 7 | /**
 8 |  * This interface represents a success. Any result implementing this interface will
 9 |  * be treated as a success.
10 |  */
11 | interface SuccessInterface extends ResultInterface {}
12 | 


--------------------------------------------------------------------------------
/src/Process/ProcessNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Process;
 4 | 
 5 | class ProcessNotFoundException extends \RuntimeException
 6 | {
 7 |     public static function fromExecutable(string $executable): self
 8 |     {
 9 |         return new self(sprintf('Could not find executable: "%s"', $executable));
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/ExerciseRunner/Context/NoEntryPoint.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\ExerciseRunner\Context;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exception\RuntimeException;
 6 | 
 7 | class NoEntryPoint extends RuntimeException
 8 | {
 9 |     public function __construct()
10 |     {
11 |         parent::__construct('No entry point provided');
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/test/res/composer/no-stringy/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "learn-you-php/dependency-heaven",
 3 |     "description": "String manipulation with Composer",
 4 |     "require": {
 5 |         "klein/klein": "^2.1"
 6 |     },
 7 |     "authors": [
 8 |         {
 9 |             "name": "Michael Woodward",
10 |             "email": "mikeymike.mw@gmail.com"
11 |         }
12 |     ]
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Event/functions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Event;
 6 | 
 7 | if (!function_exists('PhpSchool\PhpWorkshop\Event\containerListener')) {
 8 | 
 9 |     function containerListener(string $service, string $method = '__invoke'): callable
10 |     {
11 |         return fn() => new ContainerListenerHelper($service, $method);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/test/res/composer/no-klein/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "learn-you-php/dependency-heaven",
 3 |     "description": "String manipulation with Composer",
 4 |     "require": {
 5 |         "danielstjules/stringy": "^2.1"
 6 |     },
 7 |     "authors": [
 8 |         {
 9 |             "name": "Michael Woodward",
10 |             "email": "mikeymike.mw@gmail.com"
11 |         }
12 |     ]
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Exception/SolutionExecutionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exception;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | /**
10 |  * Represents the situation where a reference solution cannot be executed (this should only really happen during
11 |  * workshop development).
12 |  */
13 | class SolutionExecutionException extends RuntimeException {}
14 | 


--------------------------------------------------------------------------------
/test/Asset/ResultResultAggregator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Asset;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Result\ResultInterface;
 6 | use PhpSchool\PhpWorkshop\ResultAggregator;
 7 | 
 8 | class ResultResultAggregator extends ResultAggregator implements ResultInterface
 9 | {
10 |     public function getCheckName(): string
11 |     {
12 |         return self::class;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/test/res/composer/no-vendor/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "learn-you-php/dependency-heaven",
 3 |     "description": "String manipulation with Composer",
 4 |     "require": {
 5 |         "danielstjules/stringy": "^2.1",
 6 |         "klein/klein": "^2.1"
 7 |     },
 8 |     "authors": [
 9 |         {
10 |             "name": "Michael Woodward",
11 |             "email": "mikeymike.mw@gmail.com"
12 |         }
13 |     ]
14 | }
15 | 


--------------------------------------------------------------------------------
/test/res/composer/good-solution/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "learn-you-php/dependency-heaven",
 3 |     "description": "String manipulation with Composer",
 4 |     "require": {
 5 |         "danielstjules/stringy": "^2.1",
 6 |         "klein/klein": "^2.1"
 7 |     },
 8 |     "authors": [
 9 |         {
10 |             "name": "Michael Woodward",
11 |             "email": "mikeymike.mw@gmail.com"
12 |         }
13 |     ]
14 | }
15 | 


--------------------------------------------------------------------------------
/test/res/composer/not-locked/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "learn-you-php/dependency-heaven",
 3 |     "description": "String manipulation with Composer",
 4 |     "require": {
 5 |         "danielstjules/stringy": "^2.1",
 6 |         "klein/klein": "^2.1"
 7 |     },
 8 |     "authors": [
 9 |         {
10 |             "name": "Michael Woodward",
11 |             "email": "mikeymike.mw@gmail.com"
12 |         }
13 |     ]
14 | }
15 | 


--------------------------------------------------------------------------------
/src/Exercise/CustomVerifyingExercise.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exercise;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Result\ResultInterface;
 8 | 
 9 | /**
10 |  * This interface describes the methods for a CUSTOM type exercise.
11 |  */
12 | interface CustomVerifyingExercise
13 | {
14 |     /**
15 |      * @return ResultInterface
16 |      */
17 |     public function verify(): ResultInterface;
18 | }
19 | 


--------------------------------------------------------------------------------
/test/ExerciseRunner/Context/NoEntryPointTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\ExerciseRunner\Context;
 4 | 
 5 | use PhpSchool\PhpWorkshop\ExerciseRunner\Context\NoEntryPoint;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class NoEntryPointTest extends TestCase
 9 | {
10 |     public function testException(): void
11 |     {
12 |         $e = new NoEntryPoint();
13 |         static::assertSame('No entry point provided', $e->getMessage());
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/test/Exception/SolutionExecutionExceptionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Exception;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | use PhpSchool\PhpWorkshop\Exception\SolutionExecutionException;
 7 | 
 8 | class SolutionExecutionExceptionTest extends TestCase
 9 | {
10 |     public function testException(): void
11 |     {
12 |         $e = new SolutionExecutionException('nope');
13 |         $this->assertEquals('nope', $e->getMessage());
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exercise/ProvidesSolution.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exercise;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Solution\SolutionInterface;
 8 | 
 9 | /**
10 |  * Exercises can implement this method if they provide solutions
11 |  */
12 | interface ProvidesSolution
13 | {
14 |     /**
15 |      * Get the exercise solution.
16 |      *
17 |      * @return SolutionInterface
18 |      */
19 |     public function getSolution(): SolutionInterface;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Result/FailureInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result;
 6 | 
 7 | /**
 8 |  * This interface represents a failure. Any result implementing this interface will
 9 |  * be treated as a failure.
10 |  */
11 | interface FailureInterface extends ResultInterface
12 | {
13 |     /**
14 |      * Return the failure data as an array
15 |      *
16 |      * @return array<string, mixed>
17 |      */
18 |     public function toArray(): array;
19 | }
20 | 


--------------------------------------------------------------------------------
/test/Exception/CliRouteNotExistsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Exception;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | use PhpSchool\PhpWorkshop\Exception\CliRouteNotExistsException;
 7 | 
 8 | class CliRouteNotExistsTest extends TestCase
 9 | {
10 |     public function testException(): void
11 |     {
12 |         $e = new CliRouteNotExistsException('some-route');
13 |         $this->assertEquals('Command: "some-route" does not exist', $e->getMessage());
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Exception/ExerciseNotAssignedException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exception;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | /**
10 |  * When a student has no exercise assigned
11 |  */
12 | class ExerciseNotAssignedException extends RuntimeException
13 | {
14 |     /**
15 |      * @return self
16 |      */
17 |     public static function notAssigned(): self
18 |     {
19 |         return new self('Student has no exercise assigned');
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Result/Cgi/FailureInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result\Cgi;
 6 | 
 7 | /**
 8 |  * This interface represents a failure. Any result implementing this interface will
 9 |  * be treated as a failure.
10 |  */
11 | interface FailureInterface extends ResultInterface
12 | {
13 |     /**
14 |      * Return the failure data as an array
15 |      *
16 |      * @return array<string, mixed>
17 |      */
18 |     public function toArray(): array;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Result/Cli/FailureInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result\Cli;
 6 | 
 7 | /**
 8 |  * This interface represents a failure. Any result implementing this interface will
 9 |  * be treated as a failure.
10 |  */
11 | interface FailureInterface extends ResultInterface
12 | {
13 |     /**
14 |      * Return the failure data as an array
15 |      *
16 |      * @return array<string, mixed>
17 |      */
18 |     public function toArray(): array;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Utils/Path.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Utils;
 4 | 
 5 | class Path
 6 | {
 7 |     public static function join(string $base, string ...$parts): string
 8 |     {
 9 |         return implode(
10 |             '/',
11 |             array_merge(
12 |                 [rtrim($base, '/')],
13 |                 array_map(function (string $part) {
14 |                     return trim($part, '/');
15 |                 }, array_filter($parts)),
16 |             ),
17 |         );
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/test/res/app-credits-expected.txt:
--------------------------------------------------------------------------------
 1 | PHP School is bought to you by...
 2 | 
 3 | Name              GitHub Username
 4 | ---------------------------------
 5 | Aydin Hassan      @AydinHassan
 6 | Michael Woodward  @mikeymike
 7 | Shane Osbourne    @shakeyShane
 8 | Chris Bailey      @chris3ailey
 9 | 
10 | 
11 | This workshop is brought to you by...
12 | 
13 | Name              GitHub Username
14 | ---------------------------------
15 | Aydin Hassan      @AydinHassan
16 | Michael Woodward  @mikeymike
17 | 


--------------------------------------------------------------------------------
/src/ExerciseCheck/FileComparisonExerciseCheck.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\ExerciseCheck;
 6 | 
 7 | /**
 8 |  * This interface should be implemented when you require the check `\PhpSchool\PhpWorkshop\Check\FileComparisonCheck`
 9 |  * in your exercise.
10 |  */
11 | interface FileComparisonExerciseCheck
12 | {
13 |     /**
14 |      * @return array<int|string, string|array{strip: string}>
15 |      */
16 |     public function getFilesToCompare(): array;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Result/Cgi/ResultInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result\Cgi;
 6 | 
 7 | use Psr\Http\Message\RequestInterface;
 8 | 
 9 | /**
10 |  * Base CGI result interface
11 |  */
12 | interface ResultInterface extends \PhpSchool\PhpWorkshop\Result\ResultInterface
13 | {
14 |     /**
15 |      * Get the request associated with this result.
16 |      *
17 |      * @return RequestInterface
18 |      */
19 |     public function getRequest(): RequestInterface;
20 | }
21 | 


--------------------------------------------------------------------------------
/test/Asset/AbstractExerciseImpl.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Asset;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exercise\AbstractExercise;
 6 | 
 7 | class AbstractExerciseImpl extends AbstractExercise
 8 | {
 9 |     /**
10 |      * @var string
11 |      */
12 |     private $name;
13 | 
14 |     public function __construct(string $name)
15 |     {
16 |         $this->name = $name;
17 |     }
18 | 
19 |     public function getName(): string
20 |     {
21 |         return $this->name;
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/phpstan.neon:
--------------------------------------------------------------------------------
 1 | parameters:
 2 |     treatPhpDocTypesAsCertain: false
 3 |     ignoreErrors:
 4 |         -
 5 |             message: '#Call to an undefined method PhpParser\\Node\\Expr\|PhpParser\\Node\\Name\:\:__toString\(\)#'
 6 |             path: src/Check/FunctionRequirementsCheck.php
 7 | 
 8 |         -
 9 |             message: '#Class PHPUnit\\Framework\\TestCase not found#'
10 |             path: src/TestUtils/WorkshopExerciseTest.php
11 | 
12 |     excludePaths:
13 |         - src/TestUtils/WorkshopExerciseTest.php
14 | 


--------------------------------------------------------------------------------
/src/Markdown/Shorthands/ShorthandInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Markdown\Shorthands;
 6 | 
 7 | use League\CommonMark\Node\Node;
 8 | 
 9 | interface ShorthandInterface
10 | {
11 |     /**
12 |      * The code the shorthand should react to
13 |      */
14 |     public function getCode(): string;
15 | 
16 |     /**
17 |      * @param array<string> $callArgs
18 |      * @return array<Node>
19 |      */
20 |     public function __invoke(array $callArgs): array;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Result/Cli/ResultInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result\Cli;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Utils\ArrayObject;
 8 | 
 9 | /**
10 |  * Base CLI result interface
11 |  */
12 | interface ResultInterface extends \PhpSchool\PhpWorkshop\Result\ResultInterface
13 | {
14 |     /**
15 |      * Get the arguments associated with this result.
16 |      *
17 |      * @return ArrayObject<int, string>
18 |      */
19 |     public function getArgs(): ArrayObject;
20 | }
21 | 


--------------------------------------------------------------------------------
/test/TestWorkshopType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest;
 4 | 
 5 | use PhpSchool\PhpWorkshop\WorkshopType;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class TestWorkshopType extends TestCase
 9 | {
10 |     public function testIsTutorialMode(): void
11 |     {
12 |         $tutorial = WorkshopType::TUTORIAL();
13 |         $standard = WorkshopType::STANDARD();
14 | 
15 |         static::assertTrue($tutorial->isTutorialMode());
16 |         static::assertFalse($standard->isTutorialMode());
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/test/Process/ProcessNotFoundExceptionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Process;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Process\ProcessNotFoundException;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class ProcessNotFoundExceptionTest extends TestCase
 9 | {
10 |     public function testFromExecutable(): void
11 |     {
12 |         $exception = ProcessNotFoundException::fromExecutable('composer');
13 | 
14 |         static::assertSame('Could not find executable: "composer"', $exception->getMessage());
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd"
 3 |           colors="true"
 4 |           bootstrap="test/bootstrap.php">
 5 |   <testsuite name="PHP Workshop Test Suite">
 6 |     <directory>./test</directory>
 7 |   </testsuite>
 8 |   <filter>
 9 |     <whitelist addUncoveredFilesFromWhitelist="true">
10 |       <directory suffix=".php">./src</directory>
11 |     </whitelist>
12 |   </filter>
13 | </phpunit>
14 | 


--------------------------------------------------------------------------------
/src/Check/CheckInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Check;
 6 | 
 7 | /**
 8 |  * Base Interface for Checks.
 9 |  */
10 | interface CheckInterface
11 | {
12 |     /**
13 |      * Return the check's name
14 |      */
15 |     public function getName(): string;
16 | 
17 |     /**
18 |      * This returns the interface the exercise should implement
19 |      * when requiring this check. It should be the FQCN of the interface.
20 |      */
21 |     public function getExerciseInterface(): string;
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Exception/ProblemFileDoesNotExistException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exception;
 6 | 
 7 | use function PhpSchool\PhpWorkshop\canonicalise_path;
 8 | 
 9 | class ProblemFileDoesNotExistException extends \RuntimeException
10 | {
11 |     public static function fromFile(string $file): self
12 |     {
13 |         return new self(sprintf(
14 |             'Exercise problem file: "%s" does not exist or is not readable',
15 |             canonicalise_path($file),
16 |         ));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Result/ResultGroupInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result;
 6 | 
 7 | /**
 8 |  * A result to wrap multiple results
 9 |  */
10 | interface ResultGroupInterface extends ResultInterface
11 | {
12 |     /**
13 |      * @return bool
14 |      */
15 |     public function isSuccessful(): bool;
16 | 
17 |     /**
18 |      * @return array<ResultInterface>
19 |      */
20 |     public function getResults(): array;
21 | 
22 |     public function isResultSuccess(ResultInterface $result): bool;
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Exercise/ProvidesInitialCode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exercise;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Solution\SolutionInterface;
 8 | 
 9 | /**
10 |  * Exercises can implement this method if they want to provide some
11 |  * code for the user to start with, eg a failing solution.
12 |  */
13 | interface ProvidesInitialCode
14 | {
15 |     /**
16 |      * Get the exercise solution.
17 |      *
18 |      * @return SolutionInterface
19 |      */
20 |     public function getInitialCode(): SolutionInterface;
21 | }
22 | 


--------------------------------------------------------------------------------
/test/Command/MenuCommandTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Command;
 4 | 
 5 | use PhpSchool\CliMenu\CliMenu;
 6 | use PHPUnit\Framework\TestCase;
 7 | use PhpSchool\PhpWorkshop\Command\MenuCommand;
 8 | 
 9 | class MenuCommandTest extends TestCase
10 | {
11 |     public function testInvoke(): void
12 |     {
13 |         $menu = $this->createMock(CliMenu::class);
14 |         $menu
15 |             ->expects($this->once())
16 |             ->method('open');
17 | 
18 |         $command = new MenuCommand($menu);
19 |         $command->__invoke();
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/test/Exception/SolutionFileDoesNotExistExceptionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Exception;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exception\SolutionFileDoesNotExistException;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class SolutionFileDoesNotExistExceptionTest extends TestCase
 9 | {
10 |     public function testException(): void
11 |     {
12 |         $e =  SolutionFileDoesNotExistException::fromExpectedFile('some-file.csv');
13 |         $this->assertEquals('File: "some-file.csv" does not exist in solution folder', $e->getMessage());
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/test/Exercise/TemporaryDirectoryTraitTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Exercise;
 4 | 
 5 | use PhpSchool\PhpWorkshopTest\Asset\TemporaryDirectoryTraitImpl;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class TemporaryDirectoryTraitTest extends TestCase
 9 | {
10 |     public function testGetTemporaryPath(): void
11 |     {
12 |         $impl = new TemporaryDirectoryTraitImpl();
13 |         $path = $impl->getTemporaryPath();
14 | 
15 |         mkdir($path, 0775, true);
16 |         $this->assertFileExists($path);
17 |         rmdir($path);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Result/ResultInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result;
 6 | 
 7 | /**
 8 |  * The base result interface, on it's own does not mean much, instead the
 9 |  * interfaces `PhpSchool\PhpWorkshop\Result\SuccessInterface` & `PhpSchool\PhpWorkshop\Result\FailureInterface`
10 |  * should be used.
11 |  */
12 | interface ResultInterface
13 | {
14 |     /**
15 |      * Get the name of the check that this result was produced from.
16 |      *
17 |      * @return string
18 |      */
19 |     public function getCheckName(): string;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/WorkshopType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop;
 6 | 
 7 | use MyCLabs\Enum\Enum;
 8 | 
 9 | /**
10 |  * @method static WorkshopType STANDARD()
11 |  * @method static WorkshopType TUTORIAL()
12 |  *
13 |  * @extends Enum<int>
14 |  */
15 | class WorkshopType extends Enum
16 | {
17 |     public const STANDARD = 1;
18 |     public const TUTORIAL = 2;
19 | 
20 |     /**
21 |      * @return bool
22 |      */
23 |     public function isTutorialMode(): bool
24 |     {
25 |         return $this->getValue() === static::TUTORIAL;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/test/res/exercise-help-expected.txt:
--------------------------------------------------------------------------------
 1 | 
 2 |  LEARN YOU THE PHP FOR MUCH WIN! 
 3 | *********************************
 4 | 
 5 |  
 6 |  Exercise 2 of 2
 7 | 
 8 | 
 9 | ### Exercise Content
10 | 
11 | 
12 |  » To print these instructions again, run: phpschool print
13 |  » To execute your program in a test environment, run: phpschool run program.php
14 |  » To verify your program, run: phpschool verify program.php
15 |  » For help run: phpschool help
16 | 
17 | 
18 | 


--------------------------------------------------------------------------------
/test/ResultRenderer/FailureRendererTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\ResultRenderer;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Result\Failure;
 6 | use PhpSchool\PhpWorkshop\ResultRenderer\FailureRenderer;
 7 | 
 8 | class FailureRendererTest extends AbstractResultRendererTest
 9 | {
10 |     public function testRender(): void
11 |     {
12 |         $failure = new Failure('My check', 'Something went wrong');
13 |         $renderer = new FailureRenderer($failure);
14 |         $this->assertEquals("               Something went wrong\n", $renderer->render($this->getRenderer()));
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Listener/TearDownListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Listener;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Utils\System;
 8 | use Symfony\Component\Filesystem\Filesystem;
 9 | 
10 | class TearDownListener
11 | {
12 |     /**
13 |      * @var Filesystem
14 |      */
15 |     private $filesystem;
16 | 
17 |     public function __construct(Filesystem $filesystem)
18 |     {
19 |         $this->filesystem = $filesystem;
20 |     }
21 | 
22 |     public function cleanupTempDir(): void
23 |     {
24 |         $this->filesystem->remove(System::tempDir());
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Exercise/MockExercise.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Exercise;
 4 | 
 5 | class MockExercise extends AbstractExercise implements ExerciseInterface
 6 | {
 7 |     public function getName(): string
 8 |     {
 9 |         return 'Mock Exercise';
10 |     }
11 | 
12 |     public function getDescription(): string
13 |     {
14 |         return 'Mock Exercise';
15 |     }
16 | 
17 |     public function getType(): ExerciseType
18 |     {
19 |         return ExerciseType::CUSTOM();
20 |     }
21 | 
22 |     public function getProblem(): string
23 |     {
24 |         return 'problem-file.md';
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Exception/CliRouteNotExistsException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exception;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | /**
10 |  * Represents the situation where a command is called which does not exist in the framework.
11 |  */
12 | class CliRouteNotExistsException extends RuntimeException
13 | {
14 |     /**
15 |      * @param string $routeName The name of the command which was typed.
16 |      */
17 |     public function __construct(string $routeName)
18 |     {
19 |         parent::__construct(sprintf('Command: "%s" does not exist', $routeName));
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Exercise/Scenario/ExerciseScenario.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Exercise\Scenario;
 4 | 
 5 | abstract class ExerciseScenario
 6 | {
 7 |     /**
 8 |      * @var array<string, string>
 9 |      */
10 |     private array $files = [];
11 | 
12 |     public function withFile(string $relativeFileName, string $content): static
13 |     {
14 |         $this->files[$relativeFileName] = $content;
15 | 
16 |         return $this;
17 |     }
18 | 
19 |     /**
20 |      * @return array<string, string>
21 |      */
22 |     public function getFiles(): array
23 |     {
24 |         return $this->files;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/ExerciseCheck/ComposerExerciseCheck.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\ExerciseCheck;
 6 | 
 7 | /**
 8 |  * This interface should be implemented when you require the check `PhpSchool\PhpWorkshop\Check\ComposerCheck` in your
 9 |  * exercise.
10 |  */
11 | interface ComposerExerciseCheck
12 | {
13 |     /**
14 |      * Returns an array of composer package names that student's solution should
15 |      * have required via composer.
16 |      *
17 |      * @return array<string> An array of composer package names.
18 |      */
19 |     public function getRequiredPackages(): array;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Markdown/Shorthands/Cloud/AppName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Markdown\Shorthands\Cloud;
 6 | 
 7 | use League\CommonMark\Node\Node;
 8 | use PhpSchool\PhpWorkshop\Markdown\Shorthands\ShorthandInterface;
 9 | 
10 | final class AppName implements ShorthandInterface
11 | {
12 |     /**
13 |      * @param array<string> $callArgs
14 |      * @return array<Node>
15 |      */
16 |     public function __invoke(array $callArgs): array
17 |     {
18 |         return [];
19 |     }
20 | 
21 |     public function getCode(): string
22 |     {
23 |         return 'appname';
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/test/Result/Cli/SuccessTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Result\Cli;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Result\Cli\Success;
 6 | use PhpSchool\PhpWorkshop\Utils\ArrayObject;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class SuccessTest extends TestCase
10 | {
11 |     public function testSuccess(): void
12 |     {
13 |         $args = new ArrayObject();
14 |         $success = new Success($args);
15 |         $this->assertInstanceOf(Success::class, $success);
16 |         $this->assertSame($args, $success->getArgs());
17 |         $this->assertEquals('CLI Program Runner', $success->getCheckName());
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Command/MenuCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Command;
 6 | 
 7 | use PhpSchool\CliMenu\CliMenu;
 8 | 
 9 | /**
10 |  * A command to open the app menu
11 |  */
12 | class MenuCommand
13 | {
14 |     /**
15 |      * @var CliMenu
16 |      */
17 |     private $menu;
18 | 
19 |     /**
20 |      * @param CliMenu $menu
21 |      */
22 |     public function __construct(CliMenu $menu)
23 |     {
24 |         $this->menu = $menu;
25 |     }
26 | 
27 |     /**
28 |      * @return void
29 |      */
30 |     public function __invoke(): void
31 |     {
32 |         $this->menu->open();
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Check/ListenableCheckInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Check;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Event\EventDispatcher;
 8 | 
 9 | /**
10 |  * The interface for advanced listener checks which can execute logic at any dispatched event.
11 |  */
12 | interface ListenableCheckInterface extends CheckInterface
13 | {
14 |     /**
15 |      * Attach to events throughout the running/verifying process. Inject verifiers
16 |      * and listeners.
17 |      *
18 |      * @param EventDispatcher $eventDispatcher
19 |      */
20 |     public function attach(EventDispatcher $eventDispatcher): void;
21 | }
22 | 


--------------------------------------------------------------------------------
/test/Result/Cgi/SuccessTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Result\Cgi;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Result\Cgi\Success;
 6 | use PHPUnit\Framework\TestCase;
 7 | use Psr\Http\Message\RequestInterface;
 8 | 
 9 | class SuccessTest extends TestCase
10 | {
11 |     public function testSuccess(): void
12 |     {
13 |         $request = $this->createMock(RequestInterface::class);
14 |         $success = new Success($request);
15 |         $this->assertInstanceOf(Success::class, $success);
16 |         $this->assertSame($request, $success->getRequest());
17 |         $this->assertEquals('CGI Program Runner', $success->getCheckName());
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Exercise/Scenario/CgiScenario.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Exercise\Scenario;
 4 | 
 5 | use Psr\Http\Message\RequestInterface;
 6 | 
 7 | class CgiScenario extends ExerciseScenario
 8 | {
 9 |     /**
10 |      * @var array<RequestInterface>
11 |      */
12 |     private array $executions = [];
13 | 
14 |     public function withExecution(RequestInterface $request): self
15 |     {
16 |         $this->executions[] = $request;
17 | 
18 |         return $this;
19 |     }
20 | 
21 |     /**
22 |      * @return array<RequestInterface>
23 |      */
24 |     public function getExecutions(): array
25 |     {
26 |         return $this->executions;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/test/Markdown/Shorthands/Cloud/RunTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Markdown\Shorthands\Cloud;
 4 | 
 5 | use League\CommonMark\Inline\Element\Text;
 6 | use PhpSchool\PhpWorkshop\Markdown\Shorthands\Cloud\Run;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class RunTest extends TestCase
10 | {
11 |     public function testShorthand(): void
12 |     {
13 |         $shorthand = new Run();
14 | 
15 |         $result = $shorthand->__invoke([]);
16 |         self::assertCount(1, $result);
17 |         self::assertInstanceOf(Text::class, $result[0]);
18 |         self::assertEquals('Click the Run button in the bottom right', $result[0]->getContent());
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Exercise/TemporaryDirectoryTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exercise;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Utils\System;
 8 | 
 9 | /**
10 |  * Helper trait to use in exercises to get a temporary path
11 |  * for IO stuff.
12 |  */
13 | trait TemporaryDirectoryTrait
14 | {
15 |     /**
16 |      * Get a temporary directory to use in exercises, takes in to account
17 |      * the class-name.
18 |      *
19 |      * @return string The absolute path to the temporary directory.
20 |      */
21 |     public function getTemporaryPath(): string
22 |     {
23 |         return System::tempDir(str_replace('\\', '_', __CLASS__));
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/test/Exception/MissingArgumentExceptionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Exception;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | use PhpSchool\PhpWorkshop\Exception\MissingArgumentException;
 7 | 
 8 | class MissingArgumentExceptionTest extends TestCase
 9 | {
10 |     public function testException(): void
11 |     {
12 |         $e = new MissingArgumentException('some-route', ['arg1', 'arg2']);
13 |         $this->assertEquals(
14 |             'Command: "some-route" is missing the following arguments: "arg1", "arg2"',
15 |             $e->getMessage(),
16 |         );
17 | 
18 |         $this->assertSame(['arg1', 'arg2'], $e->getMissingArguments());
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/test/Markdown/Shorthands/Cloud/VerifyTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Markdown\Shorthands\Cloud;
 4 | 
 5 | use League\CommonMark\Inline\Element\Text;
 6 | use PhpSchool\PhpWorkshop\Markdown\Shorthands\Cloud\Verify;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class VerifyTest extends TestCase
10 | {
11 |     public function testShorthand(): void
12 |     {
13 |         $shorthand = new Verify();
14 | 
15 |         $result = $shorthand->__invoke([]);
16 |         self::assertCount(1, $result);
17 |         self::assertInstanceOf(Text::class, $result[0]);
18 |         self::assertEquals('Click the Verify button in the bottom right', $result[0]->getContent());
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Exception/SolutionFileDoesNotExistException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exception;
 6 | 
 7 | /**
 8 |  * Represents the situation where an exercise requires compares a user generated file with
 9 |  * one provided with the solution but it does not exist
10 |  */
11 | class SolutionFileDoesNotExistException extends RuntimeException
12 | {
13 |     /**
14 |      * Static constructor to create an instance from the expected filename.
15 |      */
16 |     public static function fromExpectedFile(string $expectedFile): self
17 |     {
18 |         return new self(sprintf('File: "%s" does not exist in solution folder', $expectedFile));
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/test/CommandArgumentTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest;
 4 | 
 5 | use PhpSchool\PhpWorkshop\CommandArgument;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class CommandArgumentTest extends TestCase
 9 | {
10 |     public function testRequiredArgument(): void
11 |     {
12 |         $arg = new CommandArgument('arg1');
13 |         $this->assertSame('arg1', $arg->getName());
14 |         $this->assertFalse($arg->isOptional());
15 |     }
16 | 
17 |     public function testOptionalArgument(): void
18 |     {
19 |         $arg = new CommandArgument('arg1', true);
20 |         $this->assertSame('arg1', $arg->getName());
21 |         $this->assertTrue($arg->isOptional());
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Markdown/Shorthands/Cloud/Run.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Markdown\Shorthands\Cloud;
 6 | 
 7 | use League\CommonMark\Inline\Element\Text;
 8 | use PhpSchool\PhpWorkshop\Markdown\Shorthands\ShorthandInterface;
 9 | 
10 | final class Run implements ShorthandInterface
11 | {
12 |     /**
13 |      * @param array<string> $callArgs
14 |      * @return Text[]
15 |      */
16 |     public function __invoke(array $callArgs): array
17 |     {
18 |         return [
19 |             new Text('Click the Run button in the bottom right'),
20 |         ];
21 |     }
22 | 
23 |     public function getCode(): string
24 |     {
25 |         return 'run';
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Markdown/Shorthands/Cloud/Verify.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Markdown\Shorthands\Cloud;
 6 | 
 7 | use League\CommonMark\Inline\Element\Text;
 8 | use PhpSchool\PhpWorkshop\Markdown\Shorthands\ShorthandInterface;
 9 | 
10 | final class Verify implements ShorthandInterface
11 | {
12 |     /**
13 |      * @param array<string> $callArgs
14 |      * @return Text[]
15 |      */
16 |     public function __invoke(array $callArgs): array
17 |     {
18 |         return [
19 |             new Text('Click the Verify button in the bottom right'),
20 |         ];
21 |     }
22 | 
23 |     public function getCode(): string
24 |     {
25 |         return 'verify';
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Exception/CouldNotRunException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exception;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Result\FailureInterface;
 8 | 
 9 | class CouldNotRunException extends RuntimeException
10 | {
11 |     private FailureInterface $failure;
12 | 
13 |     public function __construct(FailureInterface $failure)
14 |     {
15 |         $this->failure = $failure;
16 |         parent::__construct('Could not run exercise');
17 |     }
18 | 
19 |     public static function fromFailure(FailureInterface $failure): self
20 |     {
21 |         return new self($failure);
22 |     }
23 | 
24 |     public function getFailure(): FailureInterface
25 |     {
26 |         return $this->failure;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Exercise/CgiExercise.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exercise;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Exercise\Scenario\CgiScenario;
 8 | 
 9 | /**
10 |  * This interface describes the additional methods a CGI type exercise should implement.
11 |  */
12 | interface CgiExercise extends ProvidesSolution
13 | {
14 |     /**
15 |      * This method should return an instance of CgiScenario which contains PSR-7 requests,
16 |      * which will be forwarded to the student's solution.
17 |      *
18 |      * Use like so:
19 |      *
20 |      * ```
21 |      * return (new CgiScenario())
22 |      *     ->withExecution($request1)
23 |      * ```
24 |      */
25 |     public function defineTestScenario(): CgiScenario;
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Exercise/Scenario/CliScenario.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Exercise\Scenario;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Utils\Collection;
 6 | 
 7 | class CliScenario extends ExerciseScenario
 8 | {
 9 |     /**
10 |      * @var array<Collection<int, string>>
11 |      */
12 |     private array $executions = [];
13 | 
14 |     /**
15 |      * @param array<string> $args
16 |      */
17 |     public function withExecution(array $args = []): static
18 |     {
19 |         $this->executions[] = new Collection($args);
20 | 
21 |         return $this;
22 |     }
23 | 
24 |     /**
25 |      * @return array<Collection<int, string>>
26 |      */
27 |     public function getExecutions(): array
28 |     {
29 |         return $this->executions;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/test/CodeInsertionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest;
 4 | 
 5 | use PhpSchool\PhpWorkshop\CodeInsertion;
 6 | use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class CodeInsertionTest extends TestCase
10 | {
11 |     public function testInvalidType(): void
12 |     {
13 |         $this->expectException(InvalidArgumentException::class);
14 |         new CodeInsertion('notatype', '');
15 |     }
16 | 
17 |     public function testGetters(): void
18 |     {
19 |         $mod = new CodeInsertion(CodeInsertion::TYPE_BEFORE, '<?php codez');
20 |         $this->assertEquals(CodeInsertion::TYPE_BEFORE, $mod->getType());
21 |         $this->assertEquals('<?php codez', $mod->getCode());
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/test/Process/ProcessInputTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Process;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Process\ProcessInput;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class ProcessInputTest extends TestCase
 9 | {
10 |     public function testProcessInput(): void
11 |     {
12 |         $input = new ProcessInput('composer', ['one', 'two'], __DIR__, ['SOME_VAR' => 'value'], 'input');
13 | 
14 |         static::assertSame('composer', $input->getExecutable());
15 |         static::assertSame(['one', 'two'], $input->getArgs());
16 |         static::assertSame(__DIR__, $input->getWorkingDirectory());
17 |         static::assertSame(['SOME_VAR' => 'value'], $input->getEnv());
18 |         static::assertSame('input', $input->getInput());
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Command/MenuCommandInvoker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Command;
 6 | 
 7 | use PhpSchool\CliMenu\CliMenu;
 8 | 
 9 | /**
10 |  * A helper to expose commands as callables for menu items
11 |  */
12 | class MenuCommandInvoker
13 | {
14 |     /**
15 |      * @var callable
16 |      */
17 |     private $command;
18 | 
19 |     /**
20 |      * @param callable $command
21 |      */
22 |     public function __construct(callable $command)
23 |     {
24 |         $this->command = $command;
25 |     }
26 | 
27 |     /**
28 |      * @param CliMenu $menu
29 |      */
30 |     public function __invoke(CliMenu $menu): void
31 |     {
32 |         $menu->close();
33 |         $command = $this->command;
34 |         $command();
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Listener/RealPathListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Listener;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Event\ExerciseRunnerEvent;
 8 | 
 9 | /**
10 |  * Replace program arg with absolute path
11 |  */
12 | class RealPathListener
13 | {
14 |     /**
15 |      * @param ExerciseRunnerEvent $event
16 |      */
17 |     public function __invoke(ExerciseRunnerEvent $event): void
18 |     {
19 |         if (!$event->getInput()->hasArgument('program')) {
20 |             return;
21 |         }
22 | 
23 |         $program = $event->getInput()->getRequiredArgument('program');
24 | 
25 |         if (file_exists($program)) {
26 |             $event->getInput()->setArgument('program', (string) realpath($program));
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/test/res/composer/no-vendor/solution.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // Require composer autoloader
 4 | require __DIR__ . '/vendor/autoload.php';
 5 | 
 6 | use Klein\Klein;
 7 | use Klein\Request;
 8 | use Klein\Response;
 9 | use Stringy\Stringy as S;
10 | 
11 | $klein = new Klein();
12 | 
13 | $klein->respond('POST', '/reverse', function (Request $req, Response $res) {
14 |     $res->json(['result' => (new S($req->param('data', '')))->reverse()]);
15 | });
16 | 
17 | $klein->respond('POST', '/swapcase', function (Request $req, Response $res) {
18 |     $res->json(['result' => (new S($req->param('data', '')))->swapCase()]);
19 | });
20 | 
21 | $klein->respond('POST', '/titleize', function (Request $req, Response $res) {
22 |     $res->json(['result' => (new S($req->param('data', '')))->titleize()]);
23 | });
24 | 


--------------------------------------------------------------------------------
/test/res/composer/not-locked/solution.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | // Require composer autoloader
 4 | require __DIR__ . '/vendor/autoload.php';
 5 | 
 6 | use Klein\Klein;
 7 | use Klein\Request;
 8 | use Klein\Response;
 9 | use Stringy\Stringy as S;
10 | 
11 | $klein = new Klein();
12 | 
13 | $klein->respond('POST', '/reverse', function (Request $req, Response $res) {
14 |     $res->json(['result' => (new S($req->param('data', '')))->reverse()]);
15 | });
16 | 
17 | $klein->respond('POST', '/swapcase', function (Request $req, Response $res) {
18 |     $res->json(['result' => (new S($req->param('data', '')))->swapCase()]);
19 | });
20 | 
21 | $klein->respond('POST', '/titleize', function (Request $req, Response $res) {
22 |     $res->json(['result' => (new S($req->param('data', '')))->titleize()]);
23 | });
24 | 


--------------------------------------------------------------------------------
/src/Result/ResultTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Check\CheckInterface;
 8 | 
 9 | /**
10 |  * Helper to proxy the `getCheckName()` method through to the `PhpSchool\PhpWorkshop\Check\CheckInterface`
11 |  * instance.
12 |  */
13 | trait ResultTrait
14 | {
15 |     /**
16 |      * @var CheckInterface
17 |      */
18 |     private $check;
19 | 
20 |     /**
21 |      * Get the check name from the underlying check. Assumes that the `check` property has been
22 |      * assigned an instance of `PhpSchool\PhpWorkshop\Check\CheckInterface`.
23 |      *
24 |      * @return string
25 |      */
26 |     public function getCheckName(): string
27 |     {
28 |         return $this->check->getName();
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/test/Solution/SingleFileSolutionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Solution;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Solution\SingleFileSolution;
 6 | use PhpSchool\PhpWorkshopTest\BaseTest;
 7 | 
 8 | class SingleFileSolutionTest extends BaseTest
 9 | {
10 |     public function testGetters(): void
11 |     {
12 |         $filePath = $this->getTemporaryFile('test.file', 'FILE CONTENTS');
13 | 
14 |         $solution = SingleFileSolution::fromFile($filePath);
15 | 
16 |         self::assertSame('FILE CONTENTS', file_get_contents($solution->getEntryPoint()));
17 |         self::assertFalse($solution->hasComposerFile());
18 |         self::assertCount(1, $solution->getFiles());
19 |         self::assertSame('FILE CONTENTS', file_get_contents($solution->getFiles()[0]->__toString()));
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Exercise/SubmissionPatchable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exercise;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Patch;
 8 | 
 9 | /**
10 |  * This interface, when implemented by an exercise, tells the workshop framework that the exercise
11 |  * would like to patch the student's solution. This might include adding code to the top of the file like
12 |  * injecting variables. The exercise should implement the `getPatch()` method and it should return a `Patch`.
13 |  * See [Patching Exercise Submissions](https://www.phpschool.io/docs/reference/patching-exercise-solutions) for
14 |  * more details.
15 |  */
16 | interface SubmissionPatchable
17 | {
18 |     /**
19 |      * Get the patch.
20 |      *
21 |      * @return Patch
22 |      */
23 |     public function getPatch(): Patch;
24 | }
25 | 


--------------------------------------------------------------------------------
/test/Command/HelpCommandTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Command;
 4 | 
 5 | use Colors\Color;
 6 | use PhpSchool\Terminal\Terminal;
 7 | use PhpSchool\PhpWorkshop\Command\HelpCommand;
 8 | use PhpSchool\PhpWorkshop\Output\StdOutput;
 9 | use PHPUnit\Framework\TestCase;
10 | 
11 | class HelpCommandTest extends TestCase
12 | {
13 |     public function testInvoke(): void
14 |     {
15 |         $this->expectOutputString(file_get_contents(__DIR__ . '/../res/app-help-expected.txt'));
16 | 
17 |         $color = new Color();
18 |         $color->setForceStyle(true);
19 | 
20 |         $command = new HelpCommand(
21 |             'learnyouphp',
22 |             new StdOutput($color, $this->createMock(Terminal::class)),
23 |             $color,
24 |         );
25 | 
26 |         $command->__invoke();
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Event/CgiExerciseRunnerEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Event;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exercise\Scenario\CgiScenario;
 6 | use PhpSchool\PhpWorkshop\ExerciseRunner\Context\ExecutionContext;
 7 | 
 8 | class CgiExerciseRunnerEvent extends ExerciseRunnerEvent
 9 | {
10 |     private CgiScenario $scenario;
11 | 
12 |     /**
13 |      * @param array<string, mixed> $parameters
14 |      */
15 |     public function __construct(
16 |         string $name,
17 |         ExecutionContext $context,
18 |         CgiScenario $scenario,
19 |         array $parameters = [],
20 |     ) {
21 |         $this->scenario = $scenario;
22 |         parent::__construct($name, $context, $parameters);
23 |     }
24 | 
25 |     public function getScenario(): CgiScenario
26 |     {
27 |         return $this->scenario;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Event/CliExerciseRunnerEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Event;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exercise\Scenario\CliScenario;
 6 | use PhpSchool\PhpWorkshop\ExerciseRunner\Context\ExecutionContext;
 7 | 
 8 | class CliExerciseRunnerEvent extends ExerciseRunnerEvent
 9 | {
10 |     private CliScenario $scenario;
11 | 
12 |     /**
13 |      * @param array<string, mixed> $parameters
14 |      */
15 |     public function __construct(
16 |         string $name,
17 |         ExecutionContext $context,
18 |         CliScenario $scenario,
19 |         array $parameters = [],
20 |     ) {
21 |         $this->scenario = $scenario;
22 |         parent::__construct($name, $context, $parameters);
23 |     }
24 | 
25 |     public function getScenario(): CliScenario
26 |     {
27 |         return $this->scenario;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/ResultRenderer/ResultRendererInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\ResultRenderer;
 6 | 
 7 | /**
 8 |  * The interface, result renderers should adhere to.
 9 |  */
10 | interface ResultRendererInterface
11 | {
12 |     /**
13 |      * This method should return a string representation of the result,
14 |      * formatted for output on the command line.
15 |      *
16 |      * The `PhpSchool\PhpWorkshop\ResultRenderer\ResultsRenderer` method has
17 |      * various helpers to render line breaks, colour output and can also render child
18 |      * results.
19 |      *
20 |      * @param ResultsRenderer $renderer The main renderer instance.
21 |      * @return string The string representation of the result.
22 |      */
23 |     public function render(ResultsRenderer $renderer): string;
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Exercise/CliExercise.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exercise;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Exercise\Scenario\CliScenario;
 8 | 
 9 | /**
10 |  * This interface describes the additional methods a CLI type exercise should implement.
11 |  */
12 | interface CliExercise extends ProvidesSolution
13 | {
14 |     /**
15 |      * This method should return an instance of CliScenario which contains sets of arguments,
16 |      * which will be passed to the students solution as command line arguments.
17 |      *
18 |      * Use like so:
19 |      *
20 |      * ```
21 |      * return (new CliScenario())
22 |      *     ->withExecution(['arg1', 'arg2'])
23 |      *     ->withExecution(['round2-arg1', 'round2-arg2'])
24 |      * ```
25 |      */
26 |     public function defineTestScenario(): CliScenario;
27 | }
28 | 


--------------------------------------------------------------------------------
/test/Command/MenuCommandInvokerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Command;
 4 | 
 5 | use PhpSchool\CliMenu\CliMenu;
 6 | use PhpSchool\PhpWorkshop\Command\MenuCommandInvoker;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class MenuCommandInvokerTest extends TestCase
10 | {
11 |     public function testInvoker(): void
12 |     {
13 |         $menu = $this->createMock(CliMenu::class);
14 |         $menu
15 |             ->expects($this->once())
16 |             ->method('close');
17 | 
18 |         $command = $this->getMockBuilder('stdClass')
19 |             ->setMethods(['__invoke'])
20 |             ->getMock();
21 | 
22 |         $command
23 |             ->expects($this->once())
24 |             ->method('__invoke');
25 | 
26 |         $invoker = new MenuCommandInvoker($command);
27 |         $invoker->__invoke($menu);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/test/Event/ContainerListenerHelperTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Event;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Event\ContainerListenerHelper;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class ContainerListenerHelperTest extends TestCase
 9 | {
10 |     public function testDefaultMethodIsInvoke(): void
11 |     {
12 |         $helper = new ContainerListenerHelper('Some\Object');
13 | 
14 |         $this->assertEquals('Some\Object', $helper->getService());
15 |         $this->assertEquals('__invoke', $helper->getMethod());
16 |     }
17 | 
18 |     public function testWithCustomMethod(): void
19 |     {
20 |         $helper = new ContainerListenerHelper('Some\Object', 'myMethod');
21 | 
22 |         $this->assertEquals('Some\Object', $helper->getService());
23 |         $this->assertEquals('myMethod', $helper->getMethod());
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Utils/System.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Utils;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Exception\RuntimeException;
 8 | 
 9 | class System
10 | {
11 |     public static function realpath(string $path): string
12 |     {
13 |         $realpath = realpath($path);
14 | 
15 |         if (false === $realpath) {
16 |             throw new RuntimeException(sprintf('Failed to get realpath of "%s"', $path));
17 |         }
18 | 
19 |         return $realpath;
20 |     }
21 | 
22 |     public static function tempDir(string $path = ''): string
23 |     {
24 |         return Path::join(self::realpath(sys_get_temp_dir()), 'php-school', $path);
25 |     }
26 | 
27 |     public static function randomTempDir(): string
28 |     {
29 |         return Path::join(self::realpath(sys_get_temp_dir()), 'php-school', bin2hex(random_bytes(4)));
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/test/MarkdownRendererTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest;
 4 | 
 5 | use PhpSchool\CliMdRenderer\CliRendererFactory;
 6 | use League\CommonMark\DocParser;
 7 | use League\CommonMark\Environment;
 8 | use PHPUnit\Framework\TestCase;
 9 | use PhpSchool\PhpWorkshop\MarkdownRenderer;
10 | 
11 | class MarkdownRendererTest extends TestCase
12 | {
13 |     public function testRender(): void
14 |     {
15 |         $docParser      = new DocParser(Environment::createCommonMarkEnvironment());
16 |         $cliRenderer    = (new CliRendererFactory())->__invoke();
17 | 
18 |         $renderer       = new MarkdownRenderer($docParser, $cliRenderer);
19 | 
20 |         $markdown       = "### HONEY BADGER DON'T CARE";
21 |         $expected       = "\n### HONEY BADGER DON'T CARE\n\n";
22 | 
23 |         $this->assertSame($expected, $renderer->render($markdown));
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/test/MockLogger.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshopTest;
 6 | 
 7 | use Psr\Log\AbstractLogger;
 8 | use Psr\Log\LoggerInterface;
 9 | 
10 | class MockLogger extends AbstractLogger implements LoggerInterface
11 | {
12 |     /**
13 |      * @var array<array{level: string, message: string, context: array<mixed>}>
14 |      */
15 |     public $messages = [];
16 | 
17 |     public function log($level, $message, array $context = []): void
18 |     {
19 |         $this->messages[] = [
20 |             'level' => $level,
21 |             'message' => $message,
22 |             'context' => $context,
23 |         ];
24 |     }
25 | 
26 |     /**
27 |      * @return array<array{level: string, message: string, context: array<mixed>}>
28 |      */
29 |     public function getLastMessage(): array
30 |     {
31 |         return $this->messages[count($this->messages) - 1];
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/test/ResultRenderer/ComparisonFailureRendererTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\ResultRenderer;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Result\ComparisonFailure;
 6 | use PhpSchool\PhpWorkshop\ResultRenderer\ComparisonFailureRenderer;
 7 | 
 8 | class ComparisonFailureRendererTest extends AbstractResultRendererTest
 9 | {
10 |     public function testRender(): void
11 |     {
12 |         $failure  = new ComparisonFailure('Name', 'EXPECTED OUTPUT', 'ACTUAL OUTPUT');
13 |         $renderer = new ComparisonFailureRenderer($failure);
14 | 
15 |         $expected  = "  \e[33m\e[1mYOUR OUTPUT:\e[0m\e[0m\n";
16 |         $expected .= "  \e[31m\"ACTUAL OUTPUT\"\e[0m\n\n";
17 |         $expected .= "  \e[33m\e[1mEXPECTED OUTPUT:\e[0m\e[0m\n";
18 |         $expected .= "  \e[32m\"EXPECTED OUTPUT\"\e[0m\n";
19 | 
20 |         $this->assertEquals($expected, $renderer->render($this->getRenderer()));
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/ResultRenderer/FailureRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\ResultRenderer;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Result\Failure;
 8 | 
 9 | /**
10 |  * Renderer for `PhpSchool\PhpWorkshop\Result\Failure`.
11 |  */
12 | class FailureRenderer implements ResultRendererInterface
13 | {
14 |     /**
15 |      * @var Failure
16 |      */
17 |     private $result;
18 | 
19 |     /**
20 |      * @param Failure $result The failure.
21 |      */
22 |     public function __construct(Failure $result)
23 |     {
24 |         $this->result = $result;
25 |     }
26 | 
27 |     /**
28 |      * Simply print the reason.
29 |      *
30 |      * @param ResultsRenderer $renderer
31 |      * @return string
32 |      */
33 |     public function render(ResultsRenderer $renderer): string
34 |     {
35 |         return $renderer->center((string) $this->result->getReason()) . "\n";
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/test/Result/FileComparisonFailureTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshopTest\Result;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Check\CheckInterface;
 8 | use PhpSchool\PhpWorkshop\Result\FileComparisonFailure;
 9 | use PHPUnit\Framework\TestCase;
10 | 
11 | class FileComparisonFailureTest extends TestCase
12 | {
13 |     public function testGetters(): void
14 |     {
15 |         $check = $this->createMock(CheckInterface::class);
16 |         $check
17 |             ->method('getName')
18 |             ->willReturn('Some Check');
19 | 
20 |         $failure = new FileComparisonFailure($check, 'users.txt', 'Expected Output', 'Actual Output');
21 |         $this->assertEquals('Expected Output', $failure->getExpectedValue());
22 |         $this->assertEquals('Actual Output', $failure->getActualValue());
23 |         $this->assertEquals('users.txt', $failure->getFileName());
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Listener/SelfCheckListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Listener;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Event\ExerciseRunnerEvent;
 8 | use PhpSchool\PhpWorkshop\ExerciseCheck\SelfCheck;
 9 | use PhpSchool\PhpWorkshop\Input\Input;
10 | use PhpSchool\PhpWorkshop\ResultAggregator;
11 | 
12 | /**
13 |  * Listener to handle exercises which inject their own checks
14 |  */
15 | class SelfCheckListener
16 | {
17 |     public function __construct(private ResultAggregator $results) {}
18 | 
19 |     public function __invoke(ExerciseRunnerEvent $event): void
20 |     {
21 |         $exercise = $event->getContext()->getExercise();
22 | 
23 |         if ($exercise instanceof SelfCheck) {
24 |             /** @var Input $input */
25 |             $input = $event->getParameter('input');
26 |             $this->results->add($exercise->check($event->getContext()));
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/test/Result/FunctionRequirementsFailureTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Result;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Check\CheckInterface;
 6 | use PHPUnit\Framework\TestCase;
 7 | use PhpSchool\PhpWorkshop\Result\FunctionRequirementsFailure;
 8 | 
 9 | class FunctionRequirementsFailureTest extends TestCase
10 | {
11 |     public function testGetters(): void
12 |     {
13 |         $check = $this->createMock(CheckInterface::class);
14 |         $check
15 |             ->method('getName')
16 |             ->willReturn('Some Check');
17 | 
18 |         $failure = new FunctionRequirementsFailure($check, ['function' => 'file', 'line' => 3], ['explode']);
19 |         $this->assertEquals(['function' => 'file', 'line' => 3], $failure->getBannedFunctions());
20 |         $this->assertEquals(['explode'], $failure->getMissingFunctions());
21 |         $this->assertSame('Some Check', $failure->getCheckName());
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Event/EventInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Event;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
 8 | 
 9 | /**
10 |  * An event representation.
11 |  */
12 | interface EventInterface
13 | {
14 |     /**
15 |      * Get the name of this event.
16 |      *
17 |      * @return string
18 |      */
19 |     public function getName(): string;
20 | 
21 |     /**
22 |      * Get an array of parameters that were triggered with this event.
23 |      *
24 |      * @return array<mixed>
25 |      */
26 |     public function getParameters(): array;
27 | 
28 |     /**
29 |      * Get a parameter by its name.
30 |      *
31 |      * @param string $name The name of the parameter.
32 |      * @return mixed The value.
33 |      * @throws InvalidArgumentException If the parameter by name does not exist.
34 |      */
35 |     public function getParameter(string $name): mixed;
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Exception/CodeExecutionException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exception;
 6 | 
 7 | use RuntimeException;
 8 | use Symfony\Component\Process\Process;
 9 | 
10 | /**
11 |  * Represents the situation where some PHP code could not be executed successfully.
12 |  */
13 | class CodeExecutionException extends RuntimeException
14 | {
15 |     /**
16 |      * Static constructor to create an instance from a failed `Symfony\Component\Process\Process` instance.
17 |      *
18 |      * @param Process $process The `Symfony\Component\Process\Process` instance which failed.
19 |      * @return self
20 |      */
21 |     public static function fromProcess(Process $process): self
22 |     {
23 |         return new self(
24 |             sprintf(
25 |                 'PHP Code failed to execute. Error: "%s"',
26 |                 trim($process->getErrorOutput() ?: $process->getOutput()),
27 |             ),
28 |         );
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Event/ContainerListenerHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Event;
 6 | 
 7 | /**
 8 |  * A utility to reference listeners in the container
 9 |  */
10 | class ContainerListenerHelper
11 | {
12 |     /**
13 |      * @var string
14 |      */
15 |     private $service;
16 | 
17 |     /**
18 |      * @var string
19 |      */
20 |     private $method;
21 | 
22 |     /**
23 |      * @param string $service
24 |      * @param string $method
25 |      */
26 |     public function __construct(string $service, string $method = '__invoke')
27 |     {
28 |         $this->service = $service;
29 |         $this->method = $method;
30 |     }
31 | 
32 |     /**
33 |      * @return string
34 |      */
35 |     public function getService(): string
36 |     {
37 |         return $this->service;
38 |     }
39 | 
40 |     /**
41 |      * @return string
42 |      */
43 |     public function getMethod(): string
44 |     {
45 |         return $this->method;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Exception/ExerciseNotConfiguredException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exception;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 8 | use RuntimeException;
 9 | 
10 | /**
11 |  * Represents the situation where an exercise requires a check but does not implement
12 |  * the correct interface enforced by the check.
13 |  */
14 | class ExerciseNotConfiguredException extends RuntimeException
15 | {
16 |     /**
17 |      * Static constructor to create an instance from the exercise and interface name.
18 |      *
19 |      * @param ExerciseInterface $exercise The exercise instance.
20 |      * @param string $interface The FQCN of the interface.
21 |      * @return self
22 |      */
23 |     public static function missingImplements(ExerciseInterface $exercise, string $interface): self
24 |     {
25 |         return new self(sprintf('Exercise: "%s" should implement interface: "%s"', $exercise->getName(), $interface));
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Output/NullOutput.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Output;
 6 | 
 7 | use Throwable;
 8 | 
 9 | class NullOutput implements OutputInterface
10 | {
11 |     public function printError(string $error): void
12 |     {
13 |         // noop
14 |     }
15 | 
16 |     public function printException(Throwable $exception): void
17 |     {
18 |         // noop
19 |     }
20 | 
21 |     public function write(string $content): void
22 |     {
23 |         // noop
24 |     }
25 | 
26 |     public function writeLines(array $lines): void
27 |     {
28 |         // noop
29 |     }
30 | 
31 |     public function writeLine(string $line): void
32 |     {
33 |         // noop
34 |     }
35 | 
36 |     public function emptyLine(): void
37 |     {
38 |         // noop
39 |     }
40 | 
41 |     public function lineBreak(): void
42 |     {
43 |         // noop
44 |     }
45 | 
46 |     public function writeTitle(string $title): void
47 |     {
48 |         // noop
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/test/Event/ExerciseRunnerEventTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Event;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Event\ExerciseRunnerEvent;
 6 | use PhpSchool\PhpWorkshop\ExerciseRunner\Context\TestContext;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class ExerciseRunnerEventTest extends TestCase
10 | {
11 |     public function testGetters(): void
12 |     {
13 |         $context = new TestContext();
14 | 
15 |         $event = new ExerciseRunnerEvent('Some Event', $context, ['number' => 1]);
16 |         self::assertSame($context, $event->getContext());
17 |         self::assertSame($context->getExercise(), $event->getExercise());
18 |         self::assertSame($context->getInput(), $event->getInput());
19 |         self::assertEquals(
20 |             [
21 |                 'exercise' => $context->getExercise(),
22 |                 'input' => $context->getInput(),
23 |                 'number' => 1,
24 |             ],
25 |             $event->getParameters(),
26 |         );
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Markdown/Shorthands/Context.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Markdown\Shorthands;
 6 | 
 7 | use League\CommonMark\Inline\Element\Text;
 8 | use PhpSchool\PhpWorkshop\Markdown\CurrentContext;
 9 | 
10 | final class Context implements ShorthandInterface
11 | {
12 |     /**
13 |      * @var CurrentContext
14 |      */
15 |     private $currentContext;
16 | 
17 |     public function __construct(CurrentContext $currentContext)
18 |     {
19 |         $this->currentContext = $currentContext;
20 |     }
21 | 
22 |     public function __invoke(array $callArgs): array
23 |     {
24 |         $offset = array_search($this->currentContext->get(), $callArgs, true);
25 | 
26 |         if (false === $offset || !is_int($offset) || !isset($callArgs[$offset + 1])) {
27 |             return [];
28 |         }
29 | 
30 |         return [new Text($callArgs[$offset + 1])];
31 |     }
32 | 
33 |     public function getCode(): string
34 |     {
35 |         return 'context';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/test/Result/SuccessTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Result;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Check\CheckInterface;
 6 | use PHPUnit\Framework\TestCase;
 7 | use PhpSchool\PhpWorkshop\Result\ResultInterface;
 8 | use PhpSchool\PhpWorkshop\Result\Success;
 9 | 
10 | class SuccessTest extends TestCase
11 | {
12 |     public function testSuccess(): void
13 |     {
14 |         $success = new Success('Some Check');
15 |         $this->assertInstanceOf(ResultInterface::class, $success);
16 |         $this->assertEquals('Some Check', $success->getCheckName());
17 |     }
18 | 
19 |     public function testSuccessFromCheck(): void
20 |     {
21 |         $check = $this->createMock(CheckInterface::class);
22 |         $check
23 |             ->method('getName')
24 |             ->willReturn('Some Check');
25 | 
26 |         $success = Success::fromCheck($check);
27 |         $this->assertInstanceOf(ResultInterface::class, $success);
28 |         $this->assertEquals('Some Check', $success->getCheckName());
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/test/Result/ComparisonFailureTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Result;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Result\ComparisonFailure;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class ComparisonFailureTest extends TestCase
 9 | {
10 |     public function testGetters(): void
11 |     {
12 |         $failure = new ComparisonFailure('Name', 'Expected Output', 'Actual Output');
13 |         self::assertSame('Name', $failure->getCheckName());
14 |         self::assertEquals('Expected Output', $failure->getExpectedValue());
15 |         self::assertEquals('Actual Output', $failure->getActualValue());
16 |     }
17 | 
18 |     public function testFailureFromArgsAndOutput(): void
19 |     {
20 |         $failure = ComparisonFailure::fromNameAndValues('Name', 'Expected Output', 'Actual Output');
21 |         self::assertSame('Name', $failure->getCheckName());
22 |         self::assertEquals('Expected Output', $failure->getExpectedValue());
23 |         self::assertEquals('Actual Output', $failure->getActualValue());
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/test/ResultRenderer/Cli/RequestFailureRendererTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\ResultRenderer\Cli;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Result\Cli\RequestFailure;
 6 | use PhpSchool\PhpWorkshop\ResultRenderer\Cli\RequestFailureRenderer;
 7 | use PhpSchool\PhpWorkshop\Utils\ArrayObject;
 8 | use PhpSchool\PhpWorkshopTest\ResultRenderer\AbstractResultRendererTest;
 9 | 
10 | class RequestFailureRendererTest extends AbstractResultRendererTest
11 | {
12 |     public function testRender(): void
13 |     {
14 |         $failure  = new RequestFailure(new ArrayObject(), 'EXPECTED OUTPUT', 'ACTUAL OUTPUT');
15 |         $renderer = new RequestFailureRenderer($failure);
16 | 
17 |         $expected  = "  \e[33m\e[1mYOUR OUTPUT:\e[0m\e[0m\n";
18 |         $expected .= "  \e[31m\"ACTUAL OUTPUT\"\e[0m\n\n";
19 |         $expected .= "  \e[33m\e[1mEXPECTED OUTPUT:\e[0m\e[0m\n";
20 |         $expected .= "  \e[32m\"EXPECTED OUTPUT\"\e[0m\n";
21 | 
22 |         $this->assertEquals($expected, $renderer->render($this->getRenderer()));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/ExerciseCheck/FunctionRequirementsExerciseCheck.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\ExerciseCheck;
 6 | 
 7 | /**
 8 |  * This interface should be implemented when you require the check
 9 |  * `PhpSchool\PhpWorkshop\Check\FunctionRequirementsCheck` in your exercise.
10 |  */
11 | interface FunctionRequirementsExerciseCheck
12 | {
13 |     /**
14 |      * Returns an array of function names that the student's solution should use. The solution
15 |      * will be parsed and checked for usages of these functions.
16 |      *
17 |      * @return array<string> An array of function names that *should* be used.
18 |      */
19 |     public function getRequiredFunctions(): array;
20 | 
21 |     /**
22 |      * Returns an array of function names that the student's solution should not use. The solution
23 |      * will be parsed and checked for usages of these functions.
24 |      *
25 |      * @return array<string> An array of function names that *should not* be used.
26 |      */
27 |     public function getBannedFunctions(): array;
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Solution/SolutionInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Solution;
 6 | 
 7 | /**
 8 |  * Interface for reference solution representations.
 9 |  */
10 | interface SolutionInterface
11 | {
12 |     /**
13 |      * Get the entry point. This is the PHP file that php would execute in order to run the
14 |      * program.
15 |      *
16 |      * @return SolutionFile
17 |      */
18 |     public function getEntryPoint(): SolutionFile;
19 | 
20 |     /**
21 |      * Get all the files which are contained with the solution.
22 |      *
23 |      * @return array<SolutionFile>
24 |      */
25 |     public function getFiles(): array;
26 | 
27 |     /**
28 |      * Get the absolute path to the directory containing the solution.
29 |      *
30 |      * @return string
31 |      */
32 |     public function getBaseDirectory(): string;
33 | 
34 |     /**
35 |      * Whether or not the solution has a `composer.json` & `composer.lock` file.
36 |      *
37 |      * @return bool
38 |      */
39 |     public function hasComposerFile(): bool;
40 | }
41 | 


--------------------------------------------------------------------------------
/test/Exception/ExerciseNotConfiguredExceptionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Exception;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exception\ExerciseNotConfiguredException;
 6 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class ExerciseNotConfiguredExceptionTest extends TestCase
10 | {
11 |     public function testException(): void
12 |     {
13 |         $e = new ExerciseNotConfiguredException('nope');
14 |         $this->assertEquals('nope', $e->getMessage());
15 |     }
16 | 
17 |     public function testMissingImplementsConstructor(): void
18 |     {
19 |         $exercise = $this->createMock(ExerciseInterface::class);
20 |         $exercise
21 |             ->expects($this->once())
22 |             ->method('getName')
23 |             ->willReturn('Some Exercise');
24 | 
25 |         $e = ExerciseNotConfiguredException::missingImplements($exercise, 'SomeInterface');
26 |         $this->assertSame('Exercise: "Some Exercise" should implement interface: "SomeInterface"', $e->getMessage());
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/test/Markdown/Shorthands/Cli/RunTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Markdown\Shorthands\Cli;
 4 | 
 5 | use League\CommonMark\Inline\Element\Text;
 6 | use PhpSchool\PhpWorkshop\Exception\RuntimeException;
 7 | use PhpSchool\PhpWorkshop\Markdown\Shorthands\Cli\Run;
 8 | use PHPUnit\Framework\TestCase;
 9 | 
10 | class RunTest extends TestCase
11 | {
12 |     public function testExceptionIsThrownIfNoSolutionFile(): void
13 |     {
14 |         static::expectException(RuntimeException::class);
15 |         static::expectExceptionMessage('The solution file must be specified');
16 | 
17 |         $context = new Run('learnyouphp');
18 | 
19 |         $context->__invoke([]);
20 |     }
21 | 
22 |     public function testShorthand(): void
23 |     {
24 |         $context = new Run('learnyouphp');
25 | 
26 |         $result = $context->__invoke(['solution.php']);
27 |         self::assertCount(1, $result);
28 |         self::assertInstanceOf(Text::class, $result[0]);
29 |         self::assertEquals('learnyouphp run solution.php', $result[0]->getContent());
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Markdown/Shorthands/Cli/Run.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Markdown\Shorthands\Cli;
 6 | 
 7 | use League\CommonMark\Inline\Element\Text;
 8 | use PhpSchool\PhpWorkshop\Exception\RuntimeException;
 9 | use PhpSchool\PhpWorkshop\Markdown\Shorthands\ShorthandInterface;
10 | 
11 | final class Run implements ShorthandInterface
12 | {
13 |     /**
14 |      * @var string
15 |      */
16 |     private $appName;
17 | 
18 |     public function __construct(string $appName)
19 |     {
20 |         $this->appName = $appName;
21 |     }
22 | 
23 |     /**
24 |      * @param array<string> $callArgs
25 |      * @return Text[]
26 |      */
27 |     public function __invoke(array $callArgs): array
28 |     {
29 |         if (!isset($callArgs[0])) {
30 |             throw new RuntimeException('The solution file must be specified');
31 |         }
32 | 
33 |         return [
34 |             new Text($this->appName . ' run ' . $callArgs[0]),
35 |         ];
36 |     }
37 | 
38 |     public function getCode(): string
39 |     {
40 |         return 'run';
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/test/Markdown/Shorthands/Cli/VerifyTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Markdown\Shorthands\Cli;
 4 | 
 5 | use League\CommonMark\Inline\Element\Text;
 6 | use PhpSchool\PhpWorkshop\Exception\RuntimeException;
 7 | use PhpSchool\PhpWorkshop\Markdown\Shorthands\Cli\Verify;
 8 | use PHPUnit\Framework\TestCase;
 9 | 
10 | class VerifyTest extends TestCase
11 | {
12 |     public function testExceptionIsThrownIfNoSolutionFile(): void
13 |     {
14 |         static::expectException(RuntimeException::class);
15 |         static::expectExceptionMessage('The solution file must be specified');
16 | 
17 |         $shorthand = new Verify('learnyouphp');
18 | 
19 |         $shorthand->__invoke([]);
20 |     }
21 | 
22 |     public function testShorthand(): void
23 |     {
24 |         $shorthand = new Verify('learnyouphp');
25 | 
26 |         $result = $shorthand->__invoke(['solution.php']);
27 |         self::assertCount(1, $result);
28 |         self::assertInstanceOf(Text::class, $result[0]);
29 |         self::assertEquals('learnyouphp verify solution.php', $result[0]->getContent());
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Markdown/Shorthands/Cli/Verify.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Markdown\Shorthands\Cli;
 6 | 
 7 | use League\CommonMark\Inline\Element\Text;
 8 | use PhpSchool\PhpWorkshop\Exception\RuntimeException;
 9 | use PhpSchool\PhpWorkshop\Markdown\Shorthands\ShorthandInterface;
10 | 
11 | final class Verify implements ShorthandInterface
12 | {
13 |     /**
14 |      * @var string
15 |      */
16 |     private $appName;
17 | 
18 |     public function __construct(string $appName)
19 |     {
20 |         $this->appName = $appName;
21 |     }
22 | 
23 |     /**
24 |      * @param array<string> $callArgs
25 |      * @return Text[]
26 |      */
27 |     public function __invoke(array $callArgs): array
28 |     {
29 |         if (!isset($callArgs[0])) {
30 |             throw new RuntimeException('The solution file must be specified');
31 |         }
32 | 
33 |         return [
34 |             new Text($this->appName . ' verify ' . $callArgs[0]),
35 |         ];
36 |     }
37 | 
38 |     public function getCode(): string
39 |     {
40 |         return 'verify';
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/test/Event/EventTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Event;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Event\Event;
 6 | use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class EventTest extends TestCase
10 | {
11 |     public function testGetName(): void
12 |     {
13 |         $e = new Event('super-sweet-event!');
14 |         $this->assertEquals('super-sweet-event!', $e->getName());
15 |     }
16 | 
17 |     public function testGetParameters(): void
18 |     {
19 |         $e = new Event('super-sweet-event-with-cool-params', ['cool' => 'stuff']);
20 |         $this->assertEquals('stuff', $e->getParameter('cool'));
21 |         $this->assertEquals(['cool' => 'stuff'], $e->getParameters());
22 |     }
23 | 
24 |     public function testExeceptionIsThrownIfParameterDoesNotExist(): void
25 |     {
26 |         $this->expectException(InvalidArgumentException::class);
27 |         $this->expectExceptionMessage('Parameter: "cool" does not exist');
28 |         $e = new Event('super-sweet-event-with-cool-params');
29 |         $e->getParameter('cool');
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/test/Listener/TearDownListenerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshopTest\Listener;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Listener\TearDownListener;
 8 | use PhpSchool\PhpWorkshop\Utils\System;
 9 | use PHPUnit\Framework\TestCase;
10 | use Symfony\Component\Filesystem\Filesystem;
11 | use Yoast\PHPUnitPolyfills\Polyfills\AssertionRenames;
12 | 
13 | class TearDownListenerTest extends TestCase
14 | {
15 |     use AssertionRenames;
16 | 
17 |     public function testCleansUpTempDir(): void
18 |     {
19 |         $tempDir = System::tempDir();
20 | 
21 |         mkdir($tempDir . '/some/path', 0777, true);
22 |         touch($tempDir . '/some.file');
23 |         touch($tempDir . '/some/path/another.file');
24 | 
25 |         self::assertFileExists($tempDir . '/some.file');
26 |         self::assertFileExists($tempDir . '/some/path/another.file');
27 | 
28 |         (new TearDownListener(new Filesystem()))->cleanupTempDir();
29 | 
30 |         self::assertFileDoesNotExist($tempDir . '/some.file');
31 |         self::assertFileDoesNotExist($tempDir . '/some/path/another.file');
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/ExerciseCheck/SelfCheck.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\ExerciseCheck;
 6 | 
 7 | use PhpSchool\PhpWorkshop\ExerciseRunner\Context\ExecutionContext;
 8 | use PhpSchool\PhpWorkshop\Result\ResultInterface;
 9 | 
10 | /**
11 |  * When implemented in an exercise, this interface allows for an exercise to check it's self.
12 |  * That is, perform additional verifications in the actual exercise class
13 |  * itself. See [Self Checking Exercises](https://www.phpschool.io/docs/reference/self-checking-exercises) for more
14 |  * information.
15 |  *
16 |  * Self checking runs *after* the student's solution has been run/verified.
17 |  */
18 | interface SelfCheck
19 | {
20 |     /**
21 |      * The method is passed the absolute file path to the student's solution and should return a result
22 |      * object which indicates the success or not of the check.
23 |      *
24 |      * @param ExecutionContext $context The current execution context.
25 |      * @return ResultInterface The result of the check.
26 |      */
27 |     public function check(ExecutionContext $context): ResultInterface;
28 | }
29 | 


--------------------------------------------------------------------------------
/test/Asset/CliExerciseMissingInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Asset;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exercise\AbstractExercise;
 6 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 7 | use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
 8 | 
 9 | class CliExerciseMissingInterface extends AbstractExercise implements ExerciseInterface
10 | {
11 |     /**
12 |      * Get the name of the exercise, like `Hello World!`.
13 |      */
14 |     public function getName(): string
15 |     {
16 |         return 'CLI exercise missing interface';
17 |     }
18 | 
19 |     /**
20 |      * A short description of the exercise.
21 |      */
22 |     public function getDescription(): string
23 |     {
24 |         return 'CLI exercise missing interface';
25 |     }
26 | 
27 |     /**
28 |      * Return the type of exercise. This is an ENUM. See `PhpSchool\PhpWorkshop\Exercise\ExerciseType`.
29 |      */
30 |     public function getType(): ExerciseType
31 |     {
32 |         return ExerciseType::CLI();
33 |     }
34 | 
35 |     public function getRequiredChecks(): array
36 |     {
37 |         return [];
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Markdown/CurrentContext.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Markdown;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
 6 | 
 7 | class CurrentContext
 8 | {
 9 |     public const CONTEXT_CLI = 'cli';
10 |     public const CONTEXT_CLOUD = 'cloud';
11 | 
12 |     /**
13 |      * @var string
14 |      */
15 |     private $context;
16 | 
17 |     public function __construct(string $context)
18 |     {
19 |         if (!in_array($context, [self::CONTEXT_CLI, self::CONTEXT_CLOUD], true)) {
20 |             throw InvalidArgumentException::notValidParameter(
21 |                 'context',
22 |                 [self::CONTEXT_CLI, self::CONTEXT_CLOUD],
23 |                 $context,
24 |             );
25 |         }
26 |         $this->context = $context;
27 |     }
28 | 
29 |     public static function cli(): self
30 |     {
31 |         return new self(self::CONTEXT_CLI);
32 |     }
33 | 
34 |     public static function cloud(): self
35 |     {
36 |         return new self(self::CONTEXT_CLOUD);
37 |     }
38 | 
39 |     public function get(): string
40 |     {
41 |         return $this->context;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Process/ProcessInput.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Process;
 4 | 
 5 | class ProcessInput
 6 | {
 7 |     /**
 8 |      * @param list<string> $args
 9 |      * @param array<string, string> $env
10 |      */
11 |     public function __construct(
12 |         private string $executable,
13 |         private array $args,
14 |         private string $workingDirectory,
15 |         private array $env,
16 |         private ?string $input = null,
17 |     ) {}
18 | 
19 |     public function getExecutable(): string
20 |     {
21 |         return $this->executable;
22 |     }
23 | 
24 |     /**
25 |      * @return list<string>
26 |      */
27 |     public function getArgs(): array
28 |     {
29 |         return $this->args;
30 |     }
31 | 
32 |     public function getWorkingDirectory(): string
33 |     {
34 |         return $this->workingDirectory;
35 |     }
36 | 
37 |     /**
38 |      * @return array<string, string>
39 |      */
40 |     public function getEnv(): array
41 |     {
42 |         return $this->env;
43 |     }
44 | 
45 |     public function getInput(): ?string
46 |     {
47 |         return $this->input;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Aydin Hassan
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <h1 align="center">PHP Workshop</h1>
 2 | 
 3 | <p align="center">
 4 | The core of PHP School, the workshop application. This is the library which runs and compares users solutions to pre-defined known working solutions bundled with each workshop.
 5 | </p>
 6 | 
 7 | <p align="center">
 8 | <a href="https://github.com/php-school/php-workshop/actions">
 9 |     <img src="https://github.com/php-school/php-workshop/workflows/PhpWorkshop/badge.svg">
10 | </a>
11 | <a href="https://codecov.io/github/php-school/php-workshop">
12 |     <img src="https://img.shields.io/codecov/c/github/php-school/php-workshop/master.svg?style=flat-square">
13 | </a>
14 | <a href="https://scrutinizer-ci.com/g/php-school/php-workshop/">
15 |     <img src="ttps://img.shields.io/scrutinizer/g/php-school/php-workshop/master.svg?style=flat-square">
16 | </a>
17 | <a href="https://phpschool-team.slack.com/messages">
18 |     <img src="https://phpschool.herokuapp.com/badge.svg">
19 | </a>
20 | </p>
21 | 
22 | ----
23 | 
24 | <p align="center">
25 | Check the <a target="_blank" href="https://www.phpschool.io/docs">documentation</a> to learn how to create your own workshop.
26 | </p>
27 | 


--------------------------------------------------------------------------------
/.github/workflows/php-workshop.yml:
--------------------------------------------------------------------------------
 1 | name: PhpWorkshop
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 |   pull_request:
 8 | 
 9 | jobs:
10 |   build:
11 |     runs-on: ubuntu-latest
12 |     strategy:
13 |       fail-fast: false
14 |       matrix:
15 |         php: [8.0, 8.1, 8.2, 8.3]
16 | 
17 |     name: PHP ${{ matrix.php }}
18 |     steps:
19 |       - name: Checkout
20 |         uses: actions/checkout@v2
21 | 
22 |       - name: Setup PHP
23 |         uses: shivammathur/setup-php@v2
24 |         with:
25 |           php-version: ${{ matrix.php }}
26 |           tools: php-cs-fixer,composer:v2
27 |           coverage: none
28 | 
29 |       - name: Install Dependencies
30 |         run: composer update --prefer-dist
31 | 
32 |       - name: Run phpunit tests
33 |         run: |
34 |           mkdir -p build/logs
35 |           vendor/bin/phpunit --coverage-clover ./build/logs/clover.xml
36 | 
37 |       - name: Run phpcs
38 |         run: composer cs
39 | 
40 |       - name: Run phpstan
41 |         run: composer static
42 | 
43 |       - name: Coverage upload
44 |         if: matrix.php == '7.4'
45 |         run: bash <(curl -s https://codecov.io/bash)
46 | 
47 | 


--------------------------------------------------------------------------------
/src/Patch/ForceStrictTypes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Patch;
 4 | 
 5 | use PhpParser\Node\Scalar\LNumber;
 6 | use PhpParser\Node\Stmt;
 7 | use PhpParser\Node\Stmt\Declare_;
 8 | use PhpParser\Node\Stmt\DeclareDeclare;
 9 | 
10 | class ForceStrictTypes implements Transformer
11 | {
12 |     /**
13 |      * @param array<Stmt> $statements
14 |      * @return array<Stmt>
15 |      */
16 |     public function transform(array $statements): array
17 |     {
18 |         if ($this->isFirstStatementStrictTypesDeclare($statements)) {
19 |             return $statements;
20 |         }
21 | 
22 |         $declare = new \PhpParser\Node\Stmt\Declare_([
23 |             new DeclareDeclare(
24 |                 new \PhpParser\Node\Identifier('strict_types'),
25 |                 new LNumber(1),
26 |             ),
27 |         ]);
28 | 
29 |         return array_merge([$declare], $statements);
30 |     }
31 | 
32 |     /**
33 |      * @param array<Stmt> $statements
34 |      */
35 |     public function isFirstStatementStrictTypesDeclare(array $statements): bool
36 |     {
37 |         return isset($statements[0]) && $statements[0] instanceof Declare_;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Listener/CheckExerciseAssignedListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Listener;
 6 | 
 7 | use PhpSchool\PhpWorkshop\CommandDefinition;
 8 | use PhpSchool\PhpWorkshop\Event\Event;
 9 | use PhpSchool\PhpWorkshop\UserState\UserState;
10 | use RuntimeException;
11 | 
12 | class CheckExerciseAssignedListener
13 | {
14 |     /**
15 |      * @var UserState
16 |      */
17 |     private $userState;
18 | 
19 |     /**
20 |      * @param UserState $userState
21 |      */
22 |     public function __construct(UserState $userState)
23 |     {
24 |         $this->userState = $userState;
25 |     }
26 | 
27 |     /**
28 |      * @param Event $event
29 |      */
30 |     public function __invoke(Event $event): void
31 |     {
32 |         /** @var CommandDefinition $command */
33 |         $command = $event->getParameter('command');
34 | 
35 |         if (!in_array($command->getName(), ['verify', 'run', 'print'])) {
36 |             return;
37 |         }
38 | 
39 |         if (!$this->userState->isAssignedExercise()) {
40 |             throw new RuntimeException('No active exercise. Select one from the menu');
41 |         }
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/test/Markdown/CurrentContextTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Markdown;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
 6 | use PhpSchool\PhpWorkshop\Markdown\CurrentContext;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class CurrentContextTest extends TestCase
10 | {
11 |     public function testExceptionIsThrownIfConstructedWithInvalidType(): void
12 |     {
13 |         static::expectException(InvalidArgumentException::class);
14 |         static::expectExceptionMessage('Parameter: "context" can only be one of: "cli", "cloud" Received: "invalid"');
15 | 
16 |         new CurrentContext('invalid');
17 |     }
18 | 
19 |     public function testContext(): void
20 |     {
21 |         $context = new CurrentContext('cloud');
22 |         static::assertEquals('cloud', $context->get());
23 | 
24 |         $context = new CurrentContext('cli');
25 |         static::assertEquals('cli', $context->get());
26 | 
27 |         $context = CurrentContext::cli();
28 |         static::assertEquals('cli', $context->get());
29 | 
30 |         $context = CurrentContext::cloud();
31 |         static::assertEquals('cloud', $context->get());
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/test/Exercise/Scenario/CgiScenarioTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Exercise\Scenario;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exercise\Scenario\CgiScenario;
 6 | use PHPUnit\Framework\TestCase;
 7 | use Psr\Http\Message\RequestInterface;
 8 | 
 9 | class CgiScenarioTest extends TestCase
10 | {
11 |     public function testScenario(): void
12 |     {
13 |         $requestOne = $this->createMock(RequestInterface::class);
14 |         $requestTwo = $this->createMock(RequestInterface::class);
15 | 
16 |         $scenario = (new CgiScenario())
17 |             ->withFile('file1.txt', 'content1')
18 |             ->withFile('file2.txt', 'content2')
19 |             ->withExecution($requestOne)
20 |             ->withExecution($requestTwo);
21 | 
22 |         static::assertEquals(
23 |             [
24 |                 'file1.txt' => 'content1',
25 |                 'file2.txt' => 'content2',
26 |             ],
27 |             $scenario->getFiles(),
28 |         );
29 | 
30 |         static::assertEquals(
31 |             [
32 |                 $requestOne,
33 |                 $requestTwo,
34 |             ],
35 |             $scenario->getExecutions(),
36 |         );
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/test/Result/Cli/CliResultTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Result\Cli;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Result\Cli\CliResult;
 6 | use PhpSchool\PhpWorkshop\Result\Cli\RequestFailure;
 7 | use PhpSchool\PhpWorkshop\Result\Cli\Success;
 8 | use PhpSchool\PhpWorkshop\Utils\ArrayObject;
 9 | use PHPUnit\Framework\TestCase;
10 | 
11 | class CliResultTest extends TestCase
12 | {
13 |     public function testName(): void
14 |     {
15 |         $request = new RequestFailure(new ArrayObject(), 'EXPECTED', 'ACTUAL');
16 |         $cliResult = new CliResult([$request]);
17 |         $this->assertSame('CLI Program Runner', $cliResult->getCheckName());
18 |     }
19 | 
20 |     public function testIsSuccessful(): void
21 |     {
22 |         $request = new RequestFailure(new ArrayObject(), 'EXPECTED', 'ACTUAL');
23 |         $cliResult = new CliResult([$request]);
24 | 
25 |         $this->assertFalse($cliResult->isSuccessful());
26 | 
27 |         $cliResult = new CliResult([new Success(new ArrayObject())]);
28 |         $this->assertTrue($cliResult->isSuccessful());
29 | 
30 |         $cliResult->add($request);
31 |         $this->assertFalse($cliResult->isSuccessful());
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/test/Event/CgiExerciseRunnerEventTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Event;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Event\CgiExerciseRunnerEvent;
 6 | use PhpSchool\PhpWorkshop\Exercise\Scenario\CgiScenario;
 7 | use PhpSchool\PhpWorkshop\ExerciseRunner\Context\TestContext;
 8 | use PHPUnit\Framework\TestCase;
 9 | 
10 | class CgiExerciseRunnerEventTest extends TestCase
11 | {
12 |     public function testGetters(): void
13 |     {
14 |         $context = new TestContext();
15 |         $scenario = new CgiScenario();
16 | 
17 |         $event = new CgiExerciseRunnerEvent('Some Event', $context, $scenario, ['number' => 1]);
18 |         self::assertSame($context->getExercise(), $event->getExercise());
19 |         self::assertSame($context->getInput(), $event->getInput());
20 |         $this->assertSame($context, $event->getContext());
21 |         $this->assertSame($scenario, $event->getScenario());
22 |         self::assertEquals(
23 |             [
24 |                 'exercise' => $context->getExercise(),
25 |                 'input' => $context->getInput(),
26 |                 'number' => 1,
27 |             ],
28 |             $event->getParameters(),
29 |         );
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/test/Event/CliExerciseRunnerEventTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Event;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Event\CliExerciseRunnerEvent;
 6 | use PhpSchool\PhpWorkshop\Exercise\Scenario\CliScenario;
 7 | use PhpSchool\PhpWorkshop\ExerciseRunner\Context\TestContext;
 8 | use PHPUnit\Framework\TestCase;
 9 | 
10 | class CliExerciseRunnerEventTest extends TestCase
11 | {
12 |     public function testGetters(): void
13 |     {
14 |         $context = new TestContext();
15 |         $scenario = new CliScenario();
16 | 
17 |         $event = new CliExerciseRunnerEvent('Some Event', $context, $scenario, ['number' => 1]);
18 |         self::assertSame($context->getExercise(), $event->getExercise());
19 |         self::assertSame($context->getInput(), $event->getInput());
20 |         $this->assertSame($context, $event->getContext());
21 |         $this->assertSame($scenario, $event->getScenario());
22 |         self::assertEquals(
23 |             [
24 |                 'exercise' => $context->getExercise(),
25 |                 'input' => $context->getInput(),
26 |                 'number' => 1,
27 |             ],
28 |             $event->getParameters(),
29 |         );
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/test/Exercise/Scenario/CliScenarioTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Exercise\Scenario;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exercise\Scenario\CliScenario;
 6 | use PhpSchool\PhpWorkshop\Utils\Collection;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class CliScenarioTest extends TestCase
10 | {
11 |     public function testScenario(): void
12 |     {
13 |         $scenario = (new CliScenario())
14 |             ->withFile('file1.txt', 'content1')
15 |             ->withFile('file2.txt', 'content2')
16 |             ->withExecution(['arg1', 'arg2'])
17 |             ->withExecution(['arg3', 'arg4']);
18 | 
19 |         static::assertEquals(
20 |             [
21 |                 'file1.txt' => 'content1',
22 |                 'file2.txt' => 'content2',
23 |             ],
24 |             $scenario->getFiles(),
25 |         );
26 | 
27 |         static::assertEquals(
28 |             [
29 |                 ['arg1', 'arg2'],
30 |                 ['arg3', 'arg4'],
31 |             ],
32 |             array_map(
33 |                 fn(Collection $collection) => $collection->getArrayCopy(),
34 |                 $scenario->getExecutions(),
35 |             ),
36 |         );
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Exception/CheckNotApplicableException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exception;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Check\CheckInterface;
 8 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 9 | use RuntimeException;
10 | 
11 | /**
12 |  * Represents the situation when a workshop developer tries to use a check in an exercise which has
13 |  * a type not supported by the check.
14 |  */
15 | class CheckNotApplicableException extends RuntimeException
16 | {
17 |     /**
18 |      * Static constructor to create an instance from the check & exercise.
19 |      *
20 |      * @param CheckInterface $check The check Instance.
21 |      * @param ExerciseInterface $exercise The exercise Instance.
22 |      * @return self
23 |      */
24 |     public static function fromCheckAndExercise(CheckInterface $check, ExerciseInterface $exercise): self
25 |     {
26 |         return new self(
27 |             sprintf(
28 |                 'Check: "%s" cannot process exercise: "%s" with type: "%s"',
29 |                 $check->getName(),
30 |                 $exercise->getName(),
31 |                 $exercise->getType(),
32 |             ),
33 |         );
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/ExerciseRunner/Factory/ExerciseRunnerFactoryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\ExerciseRunner\Factory;
 6 | 
 7 | use PhpSchool\PhpWorkshop\CommandDefinition;
 8 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 9 | use PhpSchool\PhpWorkshop\ExerciseRunner\ExerciseRunnerInterface;
10 | 
11 | /**
12 |  * Exercise runner factory interface
13 |  */
14 | interface ExerciseRunnerFactoryInterface
15 | {
16 |     /**
17 |      * Whether the factory supports this exercise type.
18 |      *
19 |      * @param ExerciseInterface $exercise
20 |      * @return bool
21 |      */
22 |     public function supports(ExerciseInterface $exercise): bool;
23 | 
24 |     /**
25 |      * Add any extra required arguments to the command.
26 |      *
27 |      * @param CommandDefinition $commandDefinition
28 |      */
29 |     public function configureInput(CommandDefinition $commandDefinition): void;
30 | 
31 |     /**
32 |      * Create and return an instance of the runner.
33 |      *
34 |      * @param ExerciseInterface $exercise
35 |      * @return ExerciseRunnerInterface
36 |      */
37 |     public function create(ExerciseInterface $exercise): ExerciseRunnerInterface;
38 | }
39 | 


--------------------------------------------------------------------------------
/test/res/exercise-renderer/test-render-all-failures.txt:
--------------------------------------------------------------------------------
 1 | 
 2 |                                           *** RESULTS ***
 3 | 
 4 |                                                              
 5 |                                        ✗ Check: Failure 1    
 6 |                                                              
 7 | 
 8 | Failure 1
 9 |                                                              
10 |                                        ✗ Check: Failure 2    
11 |                                                              
12 | 
13 | Failure 2
14 | ────────────────────────────────────────────────────────────────────────────────────────────────────
15 | 
16 |                                                                                                     
17 |                                    Your solution was unsuccessful!                                  
18 |                                                                                                     
19 | 
20 |                               Your solution to  didn't pass. Try again!
21 | 
22 | 
23 | 


--------------------------------------------------------------------------------
/src/Result/Cgi/Success.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result\Cgi;
 6 | 
 7 | use Psr\Http\Message\RequestInterface;
 8 | 
 9 | /**
10 |  * Default implementation of `PhpSchool\PhpWorkshop\Result\Cgi\SuccessInterface`.
11 |  */
12 | class Success implements SuccessInterface
13 | {
14 |     /**
15 |      * @var RequestInterface
16 |      */
17 |     private $request;
18 | 
19 |     /**
20 |      * @var string
21 |      */
22 |     private $name = 'CGI Program Runner';
23 | 
24 |     /**
25 |      * @param RequestInterface $request The request for this success.
26 |      */
27 |     public function __construct(RequestInterface $request)
28 |     {
29 |         $this->request = $request;
30 |     }
31 | 
32 |     /**
33 |      * Get the name of the check that this result was produced from.
34 |      *
35 |      * @return string
36 |      */
37 |     public function getCheckName(): string
38 |     {
39 |         return $this->name;
40 |     }
41 | 
42 |     /**
43 |      * Get the request for this success.
44 |      *
45 |      * @return RequestInterface
46 |      */
47 |     public function getRequest(): RequestInterface
48 |     {
49 |         return $this->request;
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Result/Cli/Success.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result\Cli;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Utils\ArrayObject;
 8 | 
 9 | /**
10 |  * Default implementation of `PhpSchool\PhpWorkshop\Result\Cli\SuccessInterface`.
11 |  */
12 | class Success implements SuccessInterface
13 | {
14 |     /**
15 |      * @var ArrayObject<int, string>
16 |      */
17 |     private $args;
18 | 
19 |     /**
20 |      * @var string
21 |      */
22 |     private $name = 'CLI Program Runner';
23 | 
24 |     /**
25 |      * @param ArrayObject<int, string> $args The arguments for this success.
26 |      */
27 |     public function __construct(ArrayObject $args)
28 |     {
29 |         $this->args = $args;
30 |     }
31 | 
32 |     /**
33 |      * Get the name of the check that this result was produced from.
34 |      *
35 |      * @return string
36 |      */
37 |     public function getCheckName(): string
38 |     {
39 |         return $this->name;
40 |     }
41 | 
42 |     /**
43 |      * Get the arguments for this success.
44 |      *
45 |      * @return ArrayObject<int, string>
46 |      */
47 |     public function getArgs(): ArrayObject
48 |     {
49 |         return $this->args;
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/test/ResultRenderer/FileComparisonFailureRendererTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshopTest\ResultRenderer;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Check\CheckInterface;
 8 | use PhpSchool\PhpWorkshop\Result\FileComparisonFailure;
 9 | use PhpSchool\PhpWorkshop\ResultRenderer\FileComparisonFailureRenderer;
10 | 
11 | class FileComparisonFailureRendererTest extends AbstractResultRendererTest
12 | {
13 |     public function testRender(): void
14 |     {
15 |         $failure  = new FileComparisonFailure(
16 |             $this->createMock(CheckInterface::class),
17 |             'some-file.text',
18 |             'EXPECTED OUTPUT',
19 |             'ACTUAL OUTPUT',
20 |         );
21 |         $renderer = new FileComparisonFailureRenderer($failure);
22 | 
23 |         $expected  = "  \e[33m\e[1mYOUR OUTPUT FOR: \e[0m\e[0m\e[32m\e[1msome-file.text\e[0m\e[0m\n";
24 |         $expected .= "  \e[31m\"ACTUAL OUTPUT\"\e[0m\n\n";
25 |         $expected .= "  \e[33m\e[1mEXPECTED OUTPUT FOR: \e[0m\e[0m\e[32m\e[1msome-file.text\e[0m\e[0m\n";
26 |         $expected .= "  \e[32m\"EXPECTED OUTPUT\"\e[0m\n";
27 | 
28 |         $this->assertEquals($expected, $renderer->render($this->getRenderer()));
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Result/Success.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Result;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Check\CheckInterface;
 8 | 
 9 | /**
10 |  * Default implementation of `PhpSchool\PhpWorkshop\Result\SuccessInterface`.
11 |  */
12 | class Success implements SuccessInterface
13 | {
14 |     /**
15 |      * @var string
16 |      */
17 |     private $name;
18 | 
19 |     /**
20 |      * @param string $name The name of the check that produced this result.
21 |      */
22 |     public function __construct(string $name)
23 |     {
24 |         $this->name = $name;
25 |     }
26 | 
27 |     /**
28 |      * Static constructor to create from an instance of `PhpSchool\PhpWorkshop\Check\CheckInterface`.
29 |      *
30 |      * @param CheckInterface $check The check instance.
31 |      * @return self The result.
32 |      */
33 |     public static function fromCheck(CheckInterface $check): self
34 |     {
35 |         return new self($check->getName());
36 |     }
37 | 
38 |     /**
39 |      * Get the name of the check that this result was produced from.
40 |      *
41 |      * @return string
42 |      */
43 |     public function getCheckName(): string
44 |     {
45 |         return $this->name;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/test/Result/Cgi/CgiResultTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Result\Cgi;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Result\Cgi\CgiResult;
 6 | use PhpSchool\PhpWorkshop\Result\Cgi\RequestFailure;
 7 | use PhpSchool\PhpWorkshop\Result\Cgi\Success;
 8 | use PHPUnit\Framework\TestCase;
 9 | use Psr\Http\Message\RequestInterface;
10 | 
11 | class CgiResultTest extends TestCase
12 | {
13 |     public function testName(): void
14 |     {
15 |         $request = new RequestFailure($this->createMock(RequestInterface::class), '', '', [], []);
16 |         $cgiResult = new CgiResult([$request]);
17 |         $this->assertSame('CGI Program Runner', $cgiResult->getCheckName());
18 |     }
19 | 
20 |     public function testIsSuccessful(): void
21 |     {
22 |         $request = new RequestFailure($this->createMock(RequestInterface::class), '', '', [], []);
23 |         $cgiResult = new CgiResult([$request]);
24 | 
25 |         $this->assertFalse($cgiResult->isSuccessful());
26 | 
27 |         $cgiResult = new CgiResult([new Success($this->createMock(RequestInterface::class))]);
28 |         $this->assertTrue($cgiResult->isSuccessful());
29 | 
30 |         $cgiResult->add($request);
31 |         $this->assertFalse($cgiResult->isSuccessful());
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/test/res/exercise-renderer/test-render-success.txt:
--------------------------------------------------------------------------------
 1 | 
 2 |                                           *** RESULTS ***
 3 | 
 4 |                                                               
 5 |                                        ✔ Check: Success 1!    
 6 |                                                               
 7 | 
 8 |                                                               
 9 |                                        ✔ Check: Success 2!    
10 |                                                               
11 | 
12 | ────────────────────────────────────────────────────────────────────────────────────────────────────
13 | 
14 |                                                                                                     
15 |                                                 PASS!                                               
16 |                                                                                                     
17 | 
18 | 
19 |                                     You have 1 challenges left.
20 |                              Type "app" and hit enter to show the menu.
21 | 
22 | 


--------------------------------------------------------------------------------
/src/Markdown/Renderer/ContextSpecificRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Markdown\Renderer;
 6 | 
 7 | use League\CommonMark\Block\Element\AbstractBlock;
 8 | use League\CommonMark\Block\Renderer\BlockRendererInterface;
 9 | use League\CommonMark\ElementRendererInterface;
10 | use PhpSchool\PhpWorkshop\Markdown\Block\ContextSpecificBlock;
11 | use PhpSchool\PhpWorkshop\Markdown\CurrentContext;
12 | 
13 | final class ContextSpecificRenderer implements BlockRendererInterface
14 | {
15 |     /**
16 |      * @var CurrentContext
17 |      */
18 |     private $currentContext;
19 | 
20 |     public function __construct(CurrentContext $currentContext)
21 |     {
22 |         $this->currentContext = $currentContext;
23 |     }
24 | 
25 |     public function render(AbstractBlock $block, ElementRendererInterface $renderer, bool $inTightList = false): string
26 |     {
27 |         if (!$block instanceof ContextSpecificBlock) {
28 |             return '';
29 |         }
30 | 
31 |         if ($this->currentContext->get() !== $block->getType()) {
32 |             return '';
33 |         }
34 | 
35 |         /** @var iterable<AbstractBlock> $children */
36 |         $children = $block->children();
37 |         return $renderer->renderBlocks($children);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/Logger/ConsoleLogger.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Logger;
 6 | 
 7 | use Colors\Color;
 8 | use PhpSchool\PhpWorkshop\Output\OutputInterface;
 9 | use Psr\Log\AbstractLogger;
10 | use Psr\Log\LoggerInterface;
11 | 
12 | class ConsoleLogger extends AbstractLogger implements LoggerInterface
13 | {
14 |     /**
15 |      * @var OutputInterface
16 |      */
17 |     private $output;
18 | 
19 |     /**
20 |      * @var Color
21 |      */
22 |     private $color;
23 | 
24 |     public function __construct(OutputInterface $output, Color $color)
25 |     {
26 |         $this->output = $output;
27 |         $this->color = $color;
28 |     }
29 | 
30 |     /**
31 |      * @param string $level
32 |      */
33 |     public function log($level, $message, array $context = []): void
34 |     {
35 |         $parts = [
36 |             sprintf(
37 |                 '%s - %s - %s',
38 |                 $this->color->fg('yellow', (new \DateTime())->format('H:i:s')),
39 |                 $this->color->bg('red', strtoupper($level)),
40 |                 $this->color->fg('red', $message),
41 |             ),
42 |             json_encode($context, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT),
43 |         ];
44 | 
45 |         $this->output->writeLine(implode("\n", $parts));
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Markdown/Shorthands/Documentation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Markdown\Shorthands;
 6 | 
 7 | use League\CommonMark\Inline\Element\Code;
 8 | use League\CommonMark\Inline\Element\Link;
 9 | use League\CommonMark\Inline\Element\Newline;
10 | use League\CommonMark\Inline\Element\Text;
11 | 
12 | final class Documentation implements ShorthandInterface
13 | {
14 |     public function __invoke(array $callArgs): array
15 |     {
16 |         if (\count($callArgs) < 3) {
17 |             return [];
18 |         }
19 | 
20 |         $callout = array_shift($callArgs);
21 |         $lang = array_shift($callArgs);
22 |         $url = "https://php.net/manual/{$lang}/";
23 | 
24 |         $links = array_map(function (string $link) use ($url) {
25 |             $link = $url . $link;
26 |             return new Link($link, $link, $link);
27 |         }, $callArgs);
28 | 
29 |         return array_merge(
30 |             [
31 |                 new Text('Documentation on '),
32 |                 new Code($callout),
33 |                 new Text(' can be found by pointing your browser here:'),
34 |                 new Newline(),
35 |             ],
36 |             $links,
37 |         );
38 |     }
39 | 
40 |     public function getCode(): string
41 |     {
42 |         return 'doc';
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/test/Asset/CustomVerifyingExerciseImpl.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Asset;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exercise\AbstractExercise;
 6 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 7 | use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
 8 | use PhpSchool\PhpWorkshop\Exercise\CustomVerifyingExercise;
 9 | use PhpSchool\PhpWorkshop\Result\ResultInterface;
10 | use PhpSchool\PhpWorkshop\Result\Success;
11 | 
12 | class CustomVerifyingExerciseImpl extends AbstractExercise implements ExerciseInterface, CustomVerifyingExercise
13 | {
14 |     /**
15 |      * Get the name of the exercise, like `Hello World!`.
16 |      */
17 |     public function getName(): string
18 |     {
19 |         return 'Custom Verifying exercise';
20 |     }
21 | 
22 |     /**
23 |      * A short description of the exercise.
24 |      */
25 |     public function getDescription(): string
26 |     {
27 |         return 'Custom Verifying exercise';
28 |     }
29 | 
30 |     /**
31 |      * Return the type of exercise. This is an ENUM. See `PhpSchool\PhpWorkshop\Exercise\ExerciseType`.
32 |      */
33 |     public function getType(): ExerciseType
34 |     {
35 |         return ExerciseType::CUSTOM();
36 |     }
37 | 
38 |     public function verify(): ResultInterface
39 |     {
40 |         return new Success('success');
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Logger/Logger.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Logger;
 6 | 
 7 | use Psr\Log\AbstractLogger;
 8 | use Psr\Log\LoggerInterface;
 9 | 
10 | class Logger extends AbstractLogger implements LoggerInterface
11 | {
12 |     /**
13 |      * @var string
14 |      */
15 |     private $filePath;
16 | 
17 |     public function __construct(string $filePath)
18 |     {
19 |         $this->filePath = $filePath;
20 |     }
21 | 
22 |     /**
23 |      * @param string $level
24 |      */
25 |     public function log($level, $message, array $context = []): void
26 |     {
27 |         if (!file_exists(dirname($this->filePath))) {
28 |             if (!mkdir($concurrentDirectory = dirname($this->filePath), 0777, true) && !is_dir($concurrentDirectory)) {
29 |                 throw new \RuntimeException(sprintf('Directory "%s" was not created', $concurrentDirectory));
30 |             }
31 |         }
32 | 
33 |         file_put_contents(
34 |             $this->filePath,
35 |             sprintf(
36 |                 "Time: %s, Level: %s, Message: %s, Context: %s\n\n",
37 |                 (new \DateTime())->format('d-m-y H:i:s'),
38 |                 $level,
39 |                 $message,
40 |                 json_encode($context),
41 |             ),
42 |             FILE_APPEND,
43 |         );
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/MenuItem/ResetProgress.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\MenuItem;
 6 | 
 7 | use PhpSchool\CliMenu\CliMenu;
 8 | use PhpSchool\PhpWorkshop\UserState\Serializer;
 9 | use PhpSchool\PhpWorkshop\UserState\UserState;
10 | 
11 | /**
12 |  * Menu action to reset the workshop progress
13 |  */
14 | class ResetProgress
15 | {
16 |     /**
17 |      * @var Serializer
18 |      */
19 |     private $userStateSerializer;
20 | 
21 |     /**
22 |      * @param Serializer $userStateSerializer
23 |      */
24 |     public function __construct(Serializer $userStateSerializer)
25 |     {
26 |         $this->userStateSerializer = $userStateSerializer;
27 |     }
28 | 
29 |     /**
30 |      * @param CliMenu $menu
31 |      */
32 |     public function __invoke(CliMenu $menu): void
33 |     {
34 |         $this->userStateSerializer->serialize(new UserState());
35 | 
36 |         $parent = $menu->getParent();
37 | 
38 |         if (!$parent) {
39 |             return;
40 |         }
41 | 
42 |         $items = $parent->getItems();
43 | 
44 |         foreach ($items as $item) {
45 |             $item->hideItemExtra();
46 |         }
47 | 
48 |         $confirm = $menu->confirm('Status Reset!');
49 |         $confirm->getStyle()->setBg('magenta')->setFg('black');
50 |         $confirm->display('OK');
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/test/res/app-help-expected.txt:
--------------------------------------------------------------------------------
 1 | Usage
 2 | 
 3 |   learnyouphp
 4 |     Show a menu to interactively select a workshop.
 5 |   learnyouphp print
 6 |     Print the instructions for the currently selected workshop.
 7 |   learnyouphp verify program.php
 8 |     Verify your program against the expected output.
 9 |   learnyouphp help
10 |     Show this help.
11 |   learnyouphp credits
12 |     Show the people who made this happen.
13 | 
14 | Having trouble with a PHPSchool exercise?
15 | 
16 |   A team of expert helper elves is eagerly waiting to assist you in
17 |   mastering the basics of PHP, simply go to:
18 |     https://github.com/php-school/discussions
19 |   and add a New Issue and let us know what you're having trouble
20 |   with. There are no dumb questions!
21 | 
22 |   If you're looking for general help with PHP, the #php
23 |   channel on Freenode IRC is usually a great place to find someone
24 |   willing to help. There is also the PHP StackOverflow Chat:
25 |     https://chat.stackoverflow.com/rooms/11/php
26 | 
27 | Found a bug with PHPSchool or just want to contribute?
28 |   The official repository for PHPSchool is:
29 |     https://github.com/php-school/php-workshop
30 |   Feel free to file a bug report or (preferably) a pull request.
31 | 
32 | 


--------------------------------------------------------------------------------
/test/ResultRenderer/FunctionRequirementsFailureRendererTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\ResultRenderer;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Check\CheckInterface;
 6 | use PhpSchool\PhpWorkshop\Result\FunctionRequirementsFailure;
 7 | use PhpSchool\PhpWorkshop\ResultRenderer\FunctionRequirementsFailureRenderer;
 8 | 
 9 | class FunctionRequirementsFailureRendererTest extends AbstractResultRendererTest
10 | {
11 |     public function testRenderer(): void
12 |     {
13 |         $failure = new FunctionRequirementsFailure(
14 |             $this->createMock(CheckInterface::class),
15 |             [['function' => 'file', 'line' => 3], ['function' => 'explode', 'line' => 5]],
16 |             ['implode'],
17 |         );
18 |         $renderer = new FunctionRequirementsFailureRenderer($failure);
19 | 
20 |         $expected  = "  Some functions were used which should not be used in this exercise\n";
21 |         $expected .= "    file on line 3\n";
22 |         $expected .= "    explode on line 5\n";
23 | 
24 |         $expected .= '  Some function requirements were missing. You should use the functions';
25 |         $expected .= "\n";
26 |         $expected .= "    implode\n";
27 | 
28 |         $this->assertEquals($expected, $renderer->render($this->getRenderer()));
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/test/Markdown/Shorthands/ContextTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Markdown\Shorthands;
 4 | 
 5 | use League\CommonMark\Inline\Element\Text;
 6 | use PhpSchool\PhpWorkshop\Markdown\CurrentContext;
 7 | use PhpSchool\PhpWorkshop\Markdown\Shorthands\Context;
 8 | use PHPUnit\Framework\TestCase;
 9 | 
10 | class ContextTest extends TestCase
11 | {
12 |     public function testIgnoresContextsNotMatchingTheCurrentContext(): void
13 |     {
14 |         $currentContext = CurrentContext::cli();
15 | 
16 |         $context = new Context($currentContext);
17 | 
18 |         self::assertEquals([], $context->__invoke([]));
19 |     }
20 | 
21 |     public function testIgnoresCallsWithNoContent(): void
22 |     {
23 |         $currentContext = CurrentContext::cli();
24 | 
25 |         $context = new Context($currentContext);
26 | 
27 |         self::assertEquals([], $context->__invoke(['cli']));
28 |     }
29 | 
30 |     public function testWithContent(): void
31 |     {
32 |         $currentContext = CurrentContext::cli();
33 | 
34 |         $context = new Context($currentContext);
35 | 
36 |         $result = $context->__invoke(['cli', 'some content']);
37 |         self::assertCount(1, $result);
38 |         self::assertInstanceOf(Text::class, $result[0]);
39 |         self::assertEquals('some content', $result[0]->getContent());
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Exception/MissingArgumentException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exception;
 6 | 
 7 | use RuntimeException;
 8 | 
 9 | /**
10 |  * Represents the situation where a command was called without required parameters.
11 |  */
12 | class MissingArgumentException extends RuntimeException
13 | {
14 |     /**
15 |      * @var array<string>
16 |      */
17 |     private $missingArguments;
18 | 
19 |     /**
20 |      * Create the exception, requires the command name and missing arguments.
21 |      *
22 |      * @param string $commandName The command name.
23 |      * @param array<string> $missingArguments An array of missing arguments.
24 |      */
25 |     public function __construct(string $commandName, array $missingArguments)
26 |     {
27 |         $this->missingArguments = $missingArguments;
28 |         parent::__construct(
29 |             sprintf(
30 |                 'Command: "%s" is missing the following arguments: "%s"',
31 |                 $commandName,
32 |                 implode('", "', $missingArguments),
33 |             ),
34 |         );
35 |     }
36 | 
37 |     /**
38 |      * Retrieve the list of missing arguments.
39 |      *
40 |      * @return array<string>
41 |      */
42 |     public function getMissingArguments(): array
43 |     {
44 |         return $this->missingArguments;
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/test/Utils/SystemTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshopTest\Utils;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Exception\RuntimeException;
 8 | use PhpSchool\PhpWorkshop\Utils\System;
 9 | use PHPUnit\Framework\TestCase;
10 | 
11 | class SystemTest extends TestCase
12 | {
13 |     public function testRealpathThrowsOnFailure(): void
14 |     {
15 |         $this->expectException(RuntimeException::class);
16 |         $this->expectExceptionMessage('Failed to get realpath of "non_existing_file.txt"');
17 | 
18 |         System::realpath('non_existing_file.txt');
19 |     }
20 | 
21 |     public function testRealpathReturnsFullPath(): void
22 |     {
23 |         self::assertSame(realpath(__DIR__), System::realpath(__DIR__));
24 |     }
25 | 
26 |     public function testTempDir(): void
27 |     {
28 |         self::assertSame(realpath(sys_get_temp_dir()) . '/php-school', System::tempDir());
29 |     }
30 | 
31 |     public function testTempDirWithPath(): void
32 |     {
33 |         $expect = sprintf('%s/php-school/%s', realpath(sys_get_temp_dir()), 'test');
34 |         self::assertSame($expect, System::tempDir('test'));
35 |     }
36 | 
37 |     public function testRandomTempDir(): void
38 |     {
39 |         self::assertTrue(str_starts_with(System::randomTempDir(), realpath(sys_get_temp_dir()) . '/php-school'));
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Markdown/Block/ContextSpecificBlock.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Markdown\Block;
 6 | 
 7 | use League\CommonMark\Cursor;
 8 | use League\CommonMark\Block\Element\AbstractBlock;
 9 | use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
10 | use PhpSchool\PhpWorkshop\Markdown\Parser\ContextSpecificBlockParser;
11 | 
12 | final class ContextSpecificBlock extends AbstractBlock
13 | {
14 |     /**
15 |      * @var string
16 |      */
17 |     private $type;
18 | 
19 |     public function __construct(string $type)
20 |     {
21 |         if (!in_array($type, ContextSpecificBlockParser::TYPES, true)) {
22 |             throw InvalidArgumentException::notValidParameter('type', ContextSpecificBlockParser::TYPES, $type);
23 |         }
24 | 
25 |         $this->type = $type;
26 |     }
27 | 
28 |     public function getType(): string
29 |     {
30 |         return $this->type;
31 |     }
32 | 
33 |     public function canContain(AbstractBlock $block): bool
34 |     {
35 |         return true;
36 |     }
37 | 
38 |     public function isCode(): bool
39 |     {
40 |         return false;
41 |     }
42 | 
43 |     public function matchesNextLine(Cursor $cursor): bool
44 |     {
45 |         $content = $cursor->match(ContextSpecificBlockParser::getEndBlockRegex($this->type));
46 |         return $content === null;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/test/ComposerUtil/LockFileParserTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\ComposerUtil;
 4 | 
 5 | use PhpSchool\PhpWorkshop\ComposerUtil\LockFileParser;
 6 | use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class LockFileParserTest extends TestCase
10 | {
11 |     public function testGetPackages(): void
12 |     {
13 |         $locker = new LockFileParser(__DIR__ . '/../res/composer.lock');
14 |         $this->assertEquals([
15 |             ['name' => 'danielstjules/stringy', 'version' => '2.1.0'],
16 |             ['name' => 'klein/klein', 'version' => 'v2.1.0'],
17 |         ], $locker->getInstalledPackages());
18 |     }
19 | 
20 |     public function testHasPackage(): void
21 |     {
22 |         $locker = new LockFileParser(__DIR__ . '/../res/composer.lock');
23 |         $this->assertTrue($locker->hasInstalledPackage('danielstjules/stringy'));
24 |         $this->assertTrue($locker->hasInstalledPackage('klein/klein'));
25 |         $this->assertFalse($locker->hasInstalledPackage('not-a-package'));
26 |     }
27 | 
28 |     public function testExceptionIsThrownIfFileNotExists(): void
29 |     {
30 |         $this->expectException(InvalidArgumentException::class);
31 |         $this->expectExceptionMessage('Lock File: "not-a-file" does not exist');
32 |         new LockFileParser('not-a-file');
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/test/Patch/ForceStrictTypesTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Patch;
 4 | 
 5 | use PhpParser\ParserFactory;
 6 | use PhpParser\PrettyPrinter\Standard;
 7 | use PhpSchool\PhpWorkshop\Patch\ForceStrictTypes;
 8 | use PHPUnit\Framework\TestCase;
 9 | 
10 | class ForceStrictTypesTest extends TestCase
11 | {
12 |     public function testStrictTypesDeclareIsAppended(): void
13 |     {
14 |         $parser = (new ParserFactory())->create(ParserFactory::PREFER_PHP7);
15 |         $ast = $parser->parse("<?php echo 'Hello World';");
16 | 
17 |         $transformer = new ForceStrictTypes();
18 |         $ast = $transformer->transform($ast);
19 | 
20 |         self::assertSame(
21 |             "declare (strict_types=1);\necho 'Hello World';",
22 |             (new Standard())->prettyPrint($ast),
23 |         );
24 |     }
25 | 
26 |     public function testStrictTypesDeclareIsNotAppendedIfItAlreadyExists(): void
27 |     {
28 |         $parser = (new ParserFactory())->create(ParserFactory::PREFER_PHP7);
29 |         $ast = $parser->parse("<?php declare (strict_types=1);\necho 'Hello World';");
30 |         $transformer = new ForceStrictTypes();
31 | 
32 |         $ast = $transformer->transform($ast);
33 | 
34 |         self::assertSame(
35 |             "declare (strict_types=1);\necho 'Hello World';",
36 |             (new Standard())->prettyPrint($ast),
37 |         );
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/ExerciseCheck/DatabaseExerciseCheck.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\ExerciseCheck;
 6 | 
 7 | use PDO;
 8 | 
 9 | /**
10 |  * This interface should be implemented when you require the check `PhpSchool\PhpWorkshop\Check\DatabaseCheck` in your
11 |  * exercise.
12 |  */
13 | interface DatabaseExerciseCheck
14 | {
15 |     /**
16 |      * This method allows your exercise to seed the database *before* the solution's are executed. You can do anything
17 |      * you normally could with a `PDO` object.
18 |      *
19 |      * @param PDO $db A `PDO` instance pointing to the database which will be accessible to the student's solution.
20 |      * @return void
21 |      */
22 |     public function seed(PDO $db): void;
23 | 
24 |     /**
25 |      * This method allows your exercise to verify the state of database *after* the student's solution has been
26 |      * executed. You can count rows in tables, check for the existence of tables & rows and of course anything else
27 |      * you can do with a `PDO` object. The method should return a boolean indicating whether the verification
28 |      * was successful or not.
29 |      *
30 |      * @param PDO $db A `PDO` instance pointing to the database which was accessible by the student's solution.
31 |      * @return bool The result of the verification.
32 |      */
33 |     public function verify(PDO $db): bool;
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Event/ExerciseRunnerEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Event;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 8 | use PhpSchool\PhpWorkshop\ExerciseRunner\Context\ExecutionContext;
 9 | use PhpSchool\PhpWorkshop\Input\Input;
10 | 
11 | /**
12 |  * An event which is dispatched during exercise running
13 |  */
14 | class ExerciseRunnerEvent extends Event
15 | {
16 |     private ExecutionContext $context;
17 | 
18 |     /**
19 |      * @param string $name
20 |      * @param array<string, mixed> $parameters
21 |      */
22 |     public function __construct(string $name, ExecutionContext $context, array $parameters = [])
23 |     {
24 |         $this->context = $context;
25 | 
26 |         $parameters['input'] = $context->getInput();
27 |         $parameters['exercise'] = $context->getExercise();
28 |         parent::__construct($name, $parameters);
29 |     }
30 | 
31 |     public function getContext(): ExecutionContext
32 |     {
33 |         return $this->context;
34 |     }
35 | 
36 |     /**
37 |      * @return Input
38 |      */
39 |     public function getInput(): Input
40 |     {
41 |         return $this->context->getInput();
42 |     }
43 | 
44 |     /**
45 |      * @return ExerciseInterface
46 |      */
47 |     public function getExercise(): ExerciseInterface
48 |     {
49 |         return $this->context->getExercise();
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Output/BufferedOutput.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Output;
 4 | 
 5 | use Throwable;
 6 | 
 7 | class BufferedOutput implements OutputInterface
 8 | {
 9 |     /**
10 |      * @var string
11 |      */
12 |     private $buffer = '';
13 | 
14 |     public function printError(string $error): void
15 |     {
16 |         // noop
17 |     }
18 | 
19 |     public function printException(Throwable $exception): void
20 |     {
21 |         // noop
22 |     }
23 | 
24 |     public function write(string $content): void
25 |     {
26 |         $this->buffer .= $content;
27 |     }
28 | 
29 |     public function writeLines(array $lines): void
30 |     {
31 |         foreach ($lines as $line) {
32 |             $this->writeLine($line);
33 |         }
34 |     }
35 | 
36 |     public function writeLine(string $line): void
37 |     {
38 |         $this->buffer .= $line . "\n";
39 |     }
40 | 
41 |     public function emptyLine(): void
42 |     {
43 |         $this->buffer .= "\n";
44 |     }
45 | 
46 |     public function lineBreak(): void
47 |     {
48 |         // noop
49 |     }
50 | 
51 |     public function writeTitle(string $title): void
52 |     {
53 |         // noop
54 |     }
55 | 
56 |     public function fetch(bool $clear = false): string
57 |     {
58 |         $buffer =  $this->buffer;
59 | 
60 |         if ($clear) {
61 |             $this->buffer = '';
62 |         }
63 | 
64 |         return $buffer;
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/MarkdownRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop;
 6 | 
 7 | use League\CommonMark\DocParser;
 8 | use PhpSchool\CliMdRenderer\CliRenderer;
 9 | 
10 | /**
11 |  * Utility to render a markdown string to a string formatted with ANSI escape codes for output
12 |  * on the console.
13 |  */
14 | class MarkdownRenderer
15 | {
16 |     /**
17 |      * @var DocParser
18 |      */
19 |     private $docParser;
20 | 
21 |     /**
22 |      * @var CliRenderer
23 |      */
24 |     private $cliRenderer;
25 | 
26 |     /**
27 |      * Should be constructed with an instance of `DocParser` with parses the markdown to an AST.
28 |      * `CliRenderer` renders the AST to a string formatted for the console.
29 |      *
30 |      * @param DocParser $docParser
31 |      * @param CliRenderer $cliRenderer
32 |      */
33 |     public function __construct(DocParser $docParser, CliRenderer $cliRenderer)
34 |     {
35 |         $this->docParser = $docParser;
36 |         $this->cliRenderer = $cliRenderer;
37 |     }
38 | 
39 |     /**
40 |      * Expects a string of markdown and returns a string which has been formatted for
41 |      * displaying on the console.
42 |      *
43 |      * @param string $markdown
44 |      * @return string
45 |      */
46 |     public function render(string $markdown): string
47 |     {
48 |         $ast = $this->docParser->parse($markdown);
49 |         return $this->cliRenderer->renderBlock($ast);
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Process/HostProcessFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Process;
 6 | 
 7 | use Symfony\Component\Process\ExecutableFinder;
 8 | use Symfony\Component\Process\Process;
 9 | 
10 | final class HostProcessFactory implements ProcessFactory
11 | {
12 |     private ExecutableFinder $executableFinder;
13 | 
14 |     public function __construct(ExecutableFinder $executableFinder = null)
15 |     {
16 |         $this->executableFinder = $executableFinder ?? new ExecutableFinder();
17 |     }
18 | 
19 | 
20 |     public function create(ProcessInput $processInput): Process
21 |     {
22 |         $executablePath = $this->executableFinder->find($processInput->getExecutable());
23 | 
24 |         if ($executablePath === null) {
25 |             throw ProcessNotFoundException::fromExecutable($processInput->getExecutable());
26 |         }
27 | 
28 |         return new Process(
29 |             [$executablePath, ...$processInput->getArgs()],
30 |             $processInput->getWorkingDirectory(),
31 |             $this->getDefaultEnv() + $processInput->getEnv(),
32 |             $processInput->getInput(),
33 |             10,
34 |         );
35 |     }
36 | 
37 |     /**
38 |      * @return array<string, false>
39 |      */
40 |     private function getDefaultEnv(): array
41 |     {
42 |         $env = array_map(fn() => false, $_ENV);
43 |         $env + array_map(fn() => false, $_SERVER);
44 | 
45 |         return $env;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/test/BaseTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshopTest;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Utils\Path;
 8 | use PhpSchool\PhpWorkshop\Utils\System;
 9 | use PHPUnit\Framework\TestCase;
10 | use Symfony\Component\Filesystem\Filesystem;
11 | 
12 | abstract class BaseTest extends TestCase
13 | {
14 |     private $tempDirectory;
15 | 
16 |     public function getTemporaryDirectory(): string
17 |     {
18 |         if (!$this->tempDirectory) {
19 |             $this->tempDirectory = System::tempDir($this->getName());
20 |             mkdir($this->tempDirectory, 0777, true);
21 |         }
22 | 
23 |         return $this->tempDirectory;
24 |     }
25 | 
26 |     public function getTemporaryFile(string $filename, string $content = null): string
27 |     {
28 |         $file = Path::join($this->getTemporaryDirectory(), $filename);
29 | 
30 |         if (file_exists($file)) {
31 |             return $file;
32 |         }
33 | 
34 |         if (!file_exists(dirname($file))) {
35 |             mkdir(dirname($file), 0777, true);
36 |         }
37 | 
38 |         $content !== null
39 |             ? file_put_contents($file, $content)
40 |             : touch($file);
41 | 
42 |         return $file;
43 |     }
44 | 
45 |     public function tearDown(): void
46 |     {
47 |         if (file_exists(System::tempDir($this->getName()))) {
48 |             (new Filesystem())->remove(System::tempDir($this->getName()));
49 |         }
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/test/res/exercise-renderer/test-render-success-and-failure.txt:
--------------------------------------------------------------------------------
 1 | 
 2 |                                           *** RESULTS ***
 3 | 
 4 |                                                               
 5 |                                        ✔ Check: Success 1!    
 6 |                                                               
 7 | 
 8 |                                                               
 9 |                                        ✗ Check: Check 1       
10 |                                                               
11 | 
12 | Failure
13 |                                                               
14 |                                        ✗ Check: Check 2       
15 |                                                               
16 | 
17 | Failure
18 | ────────────────────────────────────────────────────────────────────────────────────────────────────
19 | 
20 |                                                                                                     
21 |                                    Your solution was unsuccessful!                                  
22 |                                                                                                     
23 | 
24 |                               Your solution to  didn't pass. Try again!
25 | 
26 | 
27 | 


--------------------------------------------------------------------------------
/test/Result/Cli/RequestFailureTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Result\Cli;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Result\Cli\RequestFailure;
 6 | use PhpSchool\PhpWorkshop\Utils\ArrayObject;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class RequestFailureTest extends TestCase
10 | {
11 |     public function setUp(): void
12 |     {
13 |         $args = new ArrayObject();
14 |         $failure = new RequestFailure($args, 'Expected Output', 'Actual Output');
15 |         $this->assertSame('Request Failure', $failure->getCheckName());
16 |         $this->assertSame($args, $failure->getArgs());
17 |     }
18 | 
19 |     public function testGetters(): void
20 |     {
21 |         $args = new ArrayObject();
22 |         $failure = new RequestFailure($args, 'Expected Output', 'Actual Output');
23 |         $this->assertEquals('Expected Output', $failure->getExpectedOutput());
24 |         $this->assertEquals('Actual Output', $failure->getActualOutput());
25 |         $this->assertSame($args, $failure->getArgs());
26 |     }
27 | 
28 |     public function testFailureFromArgsAndOutput(): void
29 |     {
30 |         $args = new ArrayObject();
31 |         $failure = RequestFailure::fromArgsAndOutput($args, 'Expected Output', 'Actual Output');
32 |         $this->assertEquals('Expected Output', $failure->getExpectedOutput());
33 |         $this->assertEquals('Actual Output', $failure->getActualOutput());
34 |         $this->assertSame($args, $failure->getArgs());
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/test/Asset/PatchableExercise.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Asset;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Event\EventDispatcher;
 6 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 7 | use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
 8 | use PhpSchool\PhpWorkshop\Exercise\SubmissionPatchable;
 9 | use PhpSchool\PhpWorkshop\Patch;
10 | 
11 | class PatchableExercise implements ExerciseInterface, SubmissionPatchable
12 | {
13 |     public function getName(): string
14 |     {
15 |         // TODO: Implement getName() method.
16 |     }
17 | 
18 |     public function getDescription(): string
19 |     {
20 |         // TODO: Implement getDescription() method.
21 |     }
22 | 
23 |     public function getSolution(): string
24 |     {
25 |         // TODO: Implement getSolution() method.
26 |     }
27 | 
28 |     public function getProblem(): string
29 |     {
30 |         // TODO: Implement getProblem() method.
31 |     }
32 | 
33 |     public function tearDown(): void
34 |     {
35 |         // TODO: Implement tearDown() method.
36 |     }
37 | 
38 |     public function getPatch(): Patch
39 |     {
40 |         // TODO: Implement getPatch() method.
41 |     }
42 | 
43 |     public function getType(): ExerciseType
44 |     {
45 |         // TODO: Implement getType() method.
46 |     }
47 | 
48 |     public function getRequiredChecks(): array
49 |     {
50 |         return [];
51 |     }
52 | 
53 |     public function defineListeners(EventDispatcher $dispatcher): void {}
54 | }
55 | 


--------------------------------------------------------------------------------
/src/Exercise/ExerciseType.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exercise;
 6 | 
 7 | use MyCLabs\Enum\Enum;
 8 | 
 9 | /**
10 |  * This class is a ENUM which represents the types that exercises can be. Instantiation looks like:
11 |  *
12 |  * ```php
13 |  * $typeCli = ExerciseType::CLI();
14 |  * $typeCgi = ExerciseType::CGI();
15 |  * $typeCustom = ExerciseType::CUSTOM();
16 |  * ```
17 |  * @extends Enum<string>
18 |  * @method static self CLI()
19 |  * @method static self CGI()
20 |  * @method static self CUSTOM()
21 |  */
22 | class ExerciseType extends Enum
23 | {
24 |     public const CLI    = 'CLI';
25 |     public const CGI    = 'CGI';
26 |     public const CUSTOM = 'CUSTOM';
27 | 
28 |     /**
29 |      * Map of exercise types to the required interfaces exercises of that particular
30 |      * type should implement.
31 |      *
32 |      * @var array<string, class-string>
33 |      */
34 |     private static $exerciseTypeToExerciseInterfaceMap = [
35 |         self::CLI => CliExercise::class,
36 |         self::CGI => CgiExercise::class,
37 |         self::CUSTOM => CustomVerifyingExercise::class,
38 |     ];
39 | 
40 |     /**
41 |      * Get the FQCN of the interface this exercise should implement for this
42 |      * exercise type.
43 |      *
44 |      * @return class-string
45 |      */
46 |     public function getExerciseInterface(): string
47 |     {
48 |         return self::$exerciseTypeToExerciseInterfaceMap[$this->getKey()];
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/test/Asset/MockEventDispatcher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshopTest\Asset;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Event\EventDispatcher;
 8 | use PhpSchool\PhpWorkshop\Event\EventInterface;
 9 | 
10 | class MockEventDispatcher extends EventDispatcher
11 | {
12 |     private $dispatches = [];
13 |     private $listeners = [];
14 | 
15 |     public function __construct()
16 |     {
17 |         // noop
18 |     }
19 | 
20 |     public function dispatch(EventInterface $event): EventInterface
21 |     {
22 |         isset($this->dispatches[$event->getName()])
23 |             ? $this->dispatches[$event->getName()]++
24 |             : $this->dispatches[$event->getName()] = 1;
25 | 
26 |         return $event;
27 |     }
28 | 
29 |     public function listen($eventNames, callable $callback): void
30 |     {
31 |         if (!is_array($eventNames)) {
32 |             $eventNames = [$eventNames];
33 |         }
34 | 
35 |         foreach ($eventNames as $eventName) {
36 |             isset($this->listeners[$eventName])
37 |                 ? $this->listeners[$eventName][] = $callback
38 |                 : $this->listeners[$eventName] = [$callback];
39 |         }
40 |     }
41 | 
42 |     public function getEventDispatchCount(string $eventName): int
43 |     {
44 |         return $this->dispatches[$eventName] ?? 0;
45 |     }
46 | 
47 |     public function getEventListeners(string $eventName): array
48 |     {
49 |         return $this->listeners[$eventName] ?? [];
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/test/Logger/ConsoleLoggerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Logger;
 4 | 
 5 | use PhpSchool\CliMenu\Util\StringUtil;
 6 | use PhpSchool\PhpWorkshop\Logger\ConsoleLogger;
 7 | use PhpSchool\PhpWorkshopTest\ContainerAwareTest;
 8 | use Psr\Log\LoggerInterface;
 9 | use Yoast\PHPUnitPolyfills\Polyfills\AssertionRenames;
10 | 
11 | class ConsoleLoggerTest extends ContainerAwareTest
12 | {
13 |     use AssertionRenames;
14 | 
15 |     public function setUp(): void
16 |     {
17 |         parent::setUp();
18 | 
19 |         $this->container->set('phpschoolGlobalDir', $this->getTemporaryDirectory());
20 |         $this->container->set('appName', 'my-workshop');
21 |         $this->container->set('basePath', __DIR__ . '/../');
22 |         $this->container->set('debugMode', true);
23 |     }
24 | 
25 |     public function testConsoleLoggerIsCreatedIfDebugModeEnable(): void
26 |     {
27 |         $this->assertInstanceOf(ConsoleLogger::class, $this->container->get(LoggerInterface::class));
28 |     }
29 | 
30 |     public function testLoggerWithContext(): void
31 |     {
32 |         $logger = $this->container->get(LoggerInterface::class);
33 |         $logger->critical('Failed to copy file', ['exercise' => 'my-exercise']);
34 | 
35 |         $out = StringUtil::stripAnsiEscapeSequence($this->getActualOutputForAssertion());
36 | 
37 |         $match  = '/\d{2}\:\d{2}\:\d{2} - CRITICAL - Failed to copy file\n{\n    "exercise": "my-exercise"\n}/';
38 |         $this->assertMatchesRegularExpression($match, $out);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/test/Asset/ProvidesSolutionExercise.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshopTest\Asset;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Event\EventDispatcher;
 8 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 9 | use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
10 | use PhpSchool\PhpWorkshop\Exercise\ProvidesSolution;
11 | use PhpSchool\PhpWorkshop\Solution\SingleFileSolution;
12 | use PhpSchool\PhpWorkshop\Solution\SolutionInterface;
13 | 
14 | class ProvidesSolutionExercise implements ExerciseInterface, ProvidesSolution
15 | {
16 |     public function getName(): string
17 |     {
18 |         return 'exercise-provides-solution';
19 |     }
20 | 
21 |     public function getType(): ExerciseType
22 |     {
23 |         // TODO: Implement getType() method.
24 |     }
25 | 
26 |     public function getProblem(): string
27 |     {
28 |         // TODO: Implement getProblem() method.
29 |     }
30 | 
31 |     public function getDescription(): string
32 |     {
33 |         // TODO: Implement getDescription() method.
34 |     }
35 | 
36 |     public function tearDown(): void
37 |     {
38 |         // TODO: Implement tearDown() method.
39 |     }
40 | 
41 |     public function getSolution(): SolutionInterface
42 |     {
43 |         return SingleFileSolution::fromFile(__DIR__ . '/provided-solution/solution.php');
44 |     }
45 | 
46 |     public function getRequiredChecks(): array
47 |     {
48 |         return [];
49 |     }
50 | 
51 |     public function defineListeners(EventDispatcher $dispatcher): void {}
52 | }
53 | 


--------------------------------------------------------------------------------
/src/CommandArgument.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop;
 6 | 
 7 | /**
 8 |  * Command argument definition
 9 |  */
10 | class CommandArgument
11 | {
12 |     /**
13 |      * @var string
14 |      */
15 |     private $name;
16 | 
17 |     /**
18 |      * @var bool
19 |      */
20 |     private $optional;
21 | 
22 |     /**
23 |      * @param string $name The name of the argument
24 |      * @param bool $optional Whether it is required or not
25 |      */
26 |     public function __construct(string $name, bool $optional = false)
27 |     {
28 |         $this->name = $name;
29 |         $this->optional = $optional;
30 |     }
31 | 
32 |     /**
33 |      * @param string $name
34 |      * @return self
35 |      */
36 |     public static function optional(string $name): self
37 |     {
38 |         return new self($name, true);
39 |     }
40 | 
41 |     /**
42 |      * @param string $name
43 |      * @return self
44 |      */
45 |     public static function required(string $name): self
46 |     {
47 |         return new self($name);
48 |     }
49 | 
50 |     /**
51 |      * @return string
52 |      */
53 |     public function getName(): string
54 |     {
55 |         return $this->name;
56 |     }
57 | 
58 |     /**
59 |      * @return bool
60 |      */
61 |     public function isRequired(): bool
62 |     {
63 |         return !$this->isOptional();
64 |     }
65 | 
66 |     /**
67 |      * @return bool
68 |      */
69 |     public function isOptional(): bool
70 |     {
71 |         return $this->optional;
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/test/Exception/CheckNotApplicableExceptionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Exception;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Check\CheckInterface;
 6 | use PhpSchool\PhpWorkshop\Exception\CheckNotApplicableException;
 7 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 8 | use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
 9 | use PHPUnit\Framework\TestCase;
10 | 
11 | class CheckNotApplicableExceptionTest extends TestCase
12 | {
13 |     public function testException(): void
14 |     {
15 |         $e = new CheckNotApplicableException('nope');
16 |         $this->assertEquals('nope', $e->getMessage());
17 |     }
18 | 
19 |     public function testFromCheckAndExerciseConstructor(): void
20 |     {
21 |         $exercise = $this->createMock(ExerciseInterface::class);
22 |         $exercise
23 |             ->expects($this->once())
24 |             ->method('getName')
25 |             ->willReturn('Some Exercise');
26 | 
27 |         $exercise
28 |             ->expects($this->once())
29 |             ->method('getType')
30 |             ->willReturn(ExerciseType::CLI());
31 | 
32 |         $check = $this->createMock(CheckInterface::class);
33 |         $check
34 |             ->expects($this->once())
35 |             ->method('getName')
36 |             ->willReturn('Some Check');
37 | 
38 | 
39 |         $e = CheckNotApplicableException::fromCheckAndExercise($check, $exercise);
40 | 
41 |         $msg  = 'Check: "Some Check" cannot process exercise: "Some Exercise" with type: "CLI"';
42 |         $this->assertSame($msg, $e->getMessage());
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/test/Input/InputTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Input;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
 6 | use PhpSchool\PhpWorkshop\Input\Input;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class InputTest extends TestCase
10 | {
11 |     public function testGetAppName(): void
12 |     {
13 |         $input = new Input('app');
14 |         $this->assertEquals('app', $input->getAppName());
15 |     }
16 | 
17 |     public function testGetArgument(): void
18 |     {
19 |         $input = new Input('app', ['arg1' => 'some-value']);
20 |         $this->assertEquals('some-value', $input->getArgument('arg1'));
21 |     }
22 | 
23 |     public function testGetArgumentThrowsExceptionIfArgumentNotExist(): void
24 |     {
25 |         $this->expectException(InvalidArgumentException::class);
26 |         $this->expectExceptionMessage('Argument with name: "arg1" does not exist');
27 | 
28 |         $input = new Input('app');
29 |         $input->getArgument('arg1');
30 |     }
31 | 
32 |     public function testHasArgument(): void
33 |     {
34 |         $input = new Input('app', ['arg1' => 'some-value']);
35 |         $this->assertTrue($input->hasArgument('arg1'));
36 |         $this->assertFalse($input->hasArgument('arg2'));
37 |     }
38 | 
39 |     public function testSetArgument(): void
40 |     {
41 |         $input = new Input('app');
42 |         $this->assertFalse($input->hasArgument('arg1'));
43 |         $input->setArgument('arg1', 'some-value');
44 |         $this->assertEquals('some-value', $input->getArgument('arg1'));
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/test/Command/PrintCommandTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Command;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Command\PrintCommand;
 6 | use PhpSchool\PhpWorkshop\UserState\UserState;
 7 | use PhpSchool\PhpWorkshopTest\Asset\CliExerciseImpl;
 8 | use PHPUnit\Framework\TestCase;
 9 | use PhpSchool\PhpWorkshop\ExerciseRepository;
10 | use PhpSchool\PhpWorkshop\MarkdownRenderer;
11 | use PhpSchool\PhpWorkshop\Output\OutputInterface;
12 | 
13 | class PrintCommandTest extends TestCase
14 | {
15 |     public function testExerciseIsPrintedIfAssigned(): void
16 |     {
17 |         $file = tempnam(sys_get_temp_dir(), 'pws');
18 |         file_put_contents($file, '### Exercise 1');
19 | 
20 |         $exercise = new CliExerciseImpl();
21 |         $exercise->setProblem($file);
22 | 
23 |         $repo = new ExerciseRepository([$exercise]);
24 | 
25 |         $state = new UserState();
26 |         $state->setCurrentExercise('my-exercise');
27 | 
28 |         $output = $this->createMock(OutputInterface::class);
29 |         $renderer = $this->createMock(MarkdownRenderer::class);
30 | 
31 |         $renderer
32 |             ->expects($this->once())
33 |             ->method('render')
34 |             ->with('### Exercise 1')
35 |             ->willReturn('### Exercise 1');
36 | 
37 |         $output
38 |             ->expects($this->once())
39 |             ->method('write')
40 |             ->with('### Exercise 1');
41 | 
42 |         $command = new PrintCommand('phpschool', $repo, $state, $renderer, $output);
43 |         $command->__invoke();
44 | 
45 |         unlink($file);
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/test/Exception/CodeExecutionExceptionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Exception;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exception\CodeExecutionException;
 6 | use PHPUnit\Framework\TestCase;
 7 | use Symfony\Component\Process\Process;
 8 | 
 9 | class CodeExecutionExceptionTest extends TestCase
10 | {
11 |     public function testException(): void
12 |     {
13 |         $e = new CodeExecutionException('nope');
14 |         $this->assertEquals('nope', $e->getMessage());
15 |     }
16 | 
17 |     public function testFromProcessUsesErrorOutputIfNotEmpty(): void
18 |     {
19 |         $process = $this->createMock(Process::class);
20 | 
21 |         $process
22 |             ->expects($this->once())
23 |             ->method('getErrorOutput')
24 |             ->willReturn('Error Output');
25 | 
26 |         $e = CodeExecutionException::fromProcess($process);
27 |         $this->assertEquals('PHP Code failed to execute. Error: "Error Output"', $e->getMessage());
28 |     }
29 | 
30 |     public function testFromProcessUsesStdOutputIfErrorOutputEmpty(): void
31 |     {
32 |         $process = $this->createMock(Process::class);
33 |         $process
34 |             ->expects($this->once())
35 |             ->method('getErrorOutput')
36 |             ->willReturn('');
37 | 
38 |         $process
39 |             ->expects($this->once())
40 |             ->method('getOutput')
41 |             ->willReturn('Std Output');
42 | 
43 |         $e = CodeExecutionException::fromProcess($process);
44 |         $this->assertEquals('PHP Code failed to execute. Error: "Std Output"', $e->getMessage());
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/Patch/WrapInTryCatch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Patch;
 4 | 
 5 | use PhpParser\Node\Stmt;
 6 | use PhpParser\Node\Expr\MethodCall;
 7 | use PhpParser\Node\Expr\Variable;
 8 | use PhpParser\Node\Name;
 9 | use PhpParser\Node\Stmt\Catch_;
10 | use PhpParser\Node\Stmt\Echo_;
11 | use PhpParser\Node\Stmt\TryCatch;
12 | 
13 | class WrapInTryCatch implements Transformer
14 | {
15 |     /**
16 |      * @var string
17 |      */
18 |     private $exceptionClass;
19 | 
20 |     /**
21 |      * @var array<Stmt>
22 |      */
23 |     private $statements;
24 | 
25 |     /**
26 |      * @param string $exceptionClass
27 |      * @param array<Stmt>|null $statements
28 |      */
29 |     public function __construct(string $exceptionClass = \Exception::class, array $statements = null)
30 |     {
31 |         $this->exceptionClass = $exceptionClass;
32 |         $this->statements = $statements ?: [
33 |             new Echo_([
34 |                 new MethodCall(new Variable('e'), 'getMessage'),
35 |             ]),
36 |         ];
37 |     }
38 | 
39 |     /**
40 |      * @param array<Stmt> $statements
41 |      * @return array<Stmt>
42 |      */
43 |     public function transform(array $statements): array
44 |     {
45 |         return [
46 |             new TryCatch(
47 |                 $statements,
48 |                 [
49 |                     new Catch_(
50 |                         [new Name($this->exceptionClass)],
51 |                         new Variable('e'),
52 |                         $this->statements,
53 |                     ),
54 |                 ],
55 |             ),
56 |         ];
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Markdown/Shorthands/Cli/AppName.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Markdown\Shorthands\Cli;
 6 | 
 7 | use League\CommonMark\Inline\Element\Code;
 8 | use League\CommonMark\Inline\Element\Emphasis;
 9 | use League\CommonMark\Inline\Element\Strong;
10 | use League\CommonMark\Inline\Element\Text;
11 | use PhpSchool\PhpWorkshop\Markdown\Shorthands\ShorthandInterface;
12 | 
13 | final class AppName implements ShorthandInterface
14 | {
15 |     /**
16 |      * @var string
17 |      */
18 |     private $appName;
19 | 
20 |     public function __construct(string $appName)
21 |     {
22 |         $this->appName = $appName;
23 |     }
24 | 
25 |     public function __invoke(array $callArgs): array
26 |     {
27 |         $wrapped = isset($callArgs[0]);
28 | 
29 |         if (false === $wrapped) {
30 |             return [new Text($this->appName)];
31 |         }
32 | 
33 |         switch ($callArgs[0]) {
34 |             case '`':
35 |                 return [new Code($this->appName)];
36 |             case '*':
37 |                 $text = new Text($this->appName);
38 |                 $container = new Strong();
39 |                 $container->appendChild($text);
40 |                 return [$container];
41 |             case '_':
42 |                 $text = new Text($this->appName);
43 |                 $container = new Emphasis();
44 |                 $container->appendChild($text);
45 |                 return [$container];
46 |         }
47 | 
48 |         return [];
49 |     }
50 | 
51 |     public function getCode(): string
52 |     {
53 |         return 'appname';
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/test/Asset/ExerciseWithInitialCode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Asset;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Event\EventDispatcher;
 6 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 7 | use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
 8 | use PhpSchool\PhpWorkshop\Exercise\ProvidesInitialCode;
 9 | use PhpSchool\PhpWorkshop\Solution\SingleFileSolution;
10 | use PhpSchool\PhpWorkshop\Solution\SolutionInterface;
11 | 
12 | class ExerciseWithInitialCode implements ExerciseInterface, ProvidesInitialCode
13 | {
14 |     public function getName(): string
15 |     {
16 |         return 'exercise-with-initial-code';
17 |     }
18 | 
19 |     public function getDescription(): string
20 |     {
21 |         // TODO: Implement getDescription() method.
22 |     }
23 | 
24 |     public function getSolution(): string
25 |     {
26 |         // TODO: Implement getSolution() method.
27 |     }
28 | 
29 |     public function getProblem(): string
30 |     {
31 |         // TODO: Implement getProblem() method.
32 |     }
33 | 
34 |     public function tearDown(): void
35 |     {
36 |         // TODO: Implement tearDown() method.
37 |     }
38 | 
39 |     public function getType(): ExerciseType
40 |     {
41 |         // TODO: Implement getType() method.
42 |     }
43 | 
44 |     public function getInitialCode(): SolutionInterface
45 |     {
46 |         return SingleFileSolution::fromFile(__DIR__ . '/initial-code/init-solution.php');
47 |     }
48 | 
49 |     public function getRequiredChecks(): array
50 |     {
51 |         return [];
52 |     }
53 | 
54 |     public function defineListeners(EventDispatcher $dispatcher): void {}
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Markdown/Parser/ContextSpecificBlockParser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Markdown\Parser;
 6 | 
 7 | use League\CommonMark\Block\Parser\BlockParserInterface;
 8 | use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
 9 | use PhpSchool\PhpWorkshop\Markdown\Block\ContextSpecificBlock;
10 | use League\CommonMark\ContextInterface;
11 | use League\CommonMark\Cursor;
12 | use PhpSchool\PhpWorkshop\Markdown\CurrentContext;
13 | 
14 | final class ContextSpecificBlockParser implements BlockParserInterface
15 | {
16 |     public const TYPES = [CurrentContext::CONTEXT_CLI, CurrentContext::CONTEXT_CLOUD];
17 | 
18 |     public static function getParserRegex(): string
19 |     {
20 |         return '/^{{\s?(' . implode('|', self::TYPES) . ')\s?}}/';
21 |     }
22 | 
23 |     public static function getEndBlockRegex(string $type): string
24 |     {
25 |         if (!in_array($type, self::TYPES, true)) {
26 |             throw InvalidArgumentException::notValidParameter('type', self::TYPES, $type);
27 |         }
28 | 
29 |         return '/^{{\s?(' . $type . ')\s?}}/';
30 |     }
31 | 
32 |     public function parse(ContextInterface $context, Cursor $cursor): bool
33 |     {
34 |         if ($cursor->getCharacter() !== '{') {
35 |             return false;
36 |         }
37 | 
38 |         $tagged = $cursor->match(self::getParserRegex());
39 |         if ($tagged === null) {
40 |             return false;
41 |         }
42 | 
43 |         $type = trim(str_replace(['{', '}'], '', $tagged));
44 | 
45 |         $context->addBlock(new ContextSpecificBlock($type));
46 | 
47 |         return true;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Utils/RequestRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Utils;
 6 | 
 7 | use Psr\Http\Message\RequestInterface;
 8 | 
 9 | /**
10 |  * Utility to render a PSR-7 request
11 |  */
12 | class RequestRenderer
13 | {
14 |     /**
15 |      * Render a PSR-7 request.
16 |      *
17 |      * @param RequestInterface $request
18 |      * @return string
19 |      */
20 |     public function renderRequest(RequestInterface $request): string
21 |     {
22 |         $return  = '';
23 |         $return .= sprintf("URL:     %s\n", $request->getUri());
24 |         $return .= sprintf("METHOD:  %s\n", $request->getMethod());
25 | 
26 |         if ($request->getHeaders()) {
27 |             $return .= 'HEADERS:';
28 |         }
29 | 
30 |         $indent = false;
31 |         foreach ($request->getHeaders() as $name => $values) {
32 |             if ($indent) {
33 |                 $return .= str_repeat(' ', 8);
34 |             }
35 | 
36 |             $return .= sprintf(" %s: %s\n", $name, implode(', ', $values));
37 |             $indent  = true;
38 |         }
39 | 
40 |         if ($body = (string) $request->getBody()) {
41 |             $return .= 'BODY:    ';
42 | 
43 |             switch ($request->getHeaderLine('Content-Type')) {
44 |                 case 'application/json':
45 |                     $return .= json_encode(json_decode($body, true), JSON_PRETTY_PRINT);
46 |                     break;
47 |                 default:
48 |                     $return .= $body;
49 |                     break;
50 |             }
51 | 
52 |             $return .= "\n";
53 |         }
54 | 
55 |         return $return;
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Markdown/ProblemFileExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Markdown;
 6 | 
 7 | use League\CommonMark\ConfigurableEnvironmentInterface;
 8 | use League\CommonMark\Extension\ExtensionInterface;
 9 | use PhpSchool\PhpWorkshop\Markdown\Block\ContextSpecificBlock;
10 | use PhpSchool\PhpWorkshop\Markdown\Renderer\ContextSpecificRenderer;
11 | use PhpSchool\PhpWorkshop\Markdown\Parser\ContextSpecificBlockParser;
12 | use PhpSchool\PhpWorkshop\Markdown\Parser\HandleBarParser;
13 | use PhpSchool\PhpWorkshop\Markdown\Shorthands\ShorthandInterface;
14 | 
15 | final class ProblemFileExtension implements ExtensionInterface
16 | {
17 |     /**
18 |      * @var ContextSpecificRenderer
19 |      */
20 |     private $contextSpecificRenderer;
21 | 
22 |     /**
23 |      * @var array<string, ShorthandInterface>
24 |      */
25 |     private $shorthandExpanders;
26 | 
27 |     /**
28 |      * @param array<ShorthandInterface> $shorthandExpanders
29 |      */
30 |     public function __construct(
31 |         ContextSpecificRenderer $contextSpecificRenderer,
32 |         array $shorthandExpanders,
33 |     ) {
34 |         $this->contextSpecificRenderer = $contextSpecificRenderer;
35 |         $this->shorthandExpanders = $shorthandExpanders;
36 |     }
37 | 
38 |     public function register(ConfigurableEnvironmentInterface $environment): void
39 |     {
40 |         $environment
41 |             ->addBlockParser(new ContextSpecificBlockParser())
42 |             ->addInlineParser(new HandleBarParser($this->shorthandExpanders))
43 |             ->addBlockRenderer(ContextSpecificBlock::class, $this->contextSpecificRenderer);
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/ResultRenderer/ComposerFailureRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\ResultRenderer;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Result\ComposerFailure;
 8 | 
 9 | /**
10 |  * Renderer for `PhpSchool\PhpWorkshop\Result\ComposerFailure`.
11 |  */
12 | class ComposerFailureRenderer implements ResultRendererInterface
13 | {
14 |     /**
15 |      * @var ComposerFailure
16 |      */
17 |     private $result;
18 | 
19 |     /**
20 |      * @param ComposerFailure $result The failure.
21 |      */
22 |     public function __construct(ComposerFailure $result)
23 |     {
24 |         $this->result = $result;
25 |     }
26 | 
27 |     /**
28 |      * Print a list of the missing components and packages.
29 |      *
30 |      * @param ResultsRenderer $renderer
31 |      * @return string
32 |      */
33 |     public function render(ResultsRenderer $renderer): string
34 |     {
35 |         if ($this->result->isMissingComponent()) {
36 |             /** @var string $component */
37 |             $component = $this->result->getMissingComponent();
38 | 
39 |             $type = str_contains($component, '.') ? 'file' : 'folder';
40 | 
41 |             return $renderer->center("No $component $type found") . "\n";
42 |         }
43 | 
44 |         if ($this->result->isMissingPackages()) {
45 |             $missingPackages = $this->result->getMissingPackages();
46 | 
47 |             return $renderer->center(sprintf(
48 |                 "Lockfile doesn't include the following packages at any version: \"%s\"\n",
49 |                 implode('", "', $missingPackages),
50 |             ));
51 |         }
52 | 
53 |         return '';
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/Listener/LazyContainerListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshop\Listener;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Event\ContainerListenerHelper;
 6 | use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
 7 | use Psr\Container\ContainerInterface;
 8 | 
 9 | class LazyContainerListener
10 | {
11 |     /**
12 |      * @var ContainerInterface
13 |      */
14 |     private $container;
15 | 
16 |     /**
17 |      * @var ContainerListenerHelper
18 |      */
19 |     private $listener;
20 | 
21 |     public function __construct(ContainerInterface $container, ContainerListenerHelper $listener)
22 |     {
23 |         $this->container = $container;
24 |         $this->listener = $listener;
25 |     }
26 | 
27 |     /**
28 |      * @param mixed ...$args
29 |      */
30 |     public function __invoke(...$args): void
31 |     {
32 |         /** @var object $service */
33 |         $service = $this->container->get($this->listener->getService());
34 | 
35 |         if (!method_exists($service, $this->listener->getMethod())) {
36 |             throw new InvalidArgumentException(
37 |                 sprintf('Method "%s" does not exist on "%s"', $this->listener->getMethod(), get_class($service)),
38 |             );
39 |         }
40 | 
41 |         $service->{$this->listener->getMethod()}(...$args);
42 |     }
43 | 
44 |     /**
45 |      * @return callable
46 |      */
47 |     public function getWrapped(): callable
48 |     {
49 |         /** @var callable $listener */
50 |         $listener =  [
51 |             $this->container->get($this->listener->getService()),
52 |             $this->listener->getMethod(),
53 |         ];
54 | 
55 |         return $listener;
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/test/res/exercise-renderer/test-render-success-with-solution.txt:
--------------------------------------------------------------------------------
 1 | 
 2 |                                           *** RESULTS ***
 3 | 
 4 |                                                               
 5 |                                        ✔ Check: Success 1!    
 6 |                                                               
 7 | 
 8 |                                                               
 9 |                                        ✔ Check: Success 2!    
10 |                                                               
11 | 
12 | ────────────────────────────────────────────────────────────────────────────────────────────────────
13 | 
14 |                                                                                                     
15 |                                                 PASS!                                               
16 |                                                                                                     
17 | 
18 |                   Here's the official solution in case you want to compare notes:
19 | 
20 | ────────────────────────────────────────────────────────────────────────────────────────────────────
21 | some-file
22 | 
23 | FILE CONTENTS
24 | ────────────────────────────────────────────────────────────────────────────────────────────────────
25 | 
26 |                                     You have 1 challenges left.
27 |                              Type "app" and hit enter to show the menu.
28 | 
29 | 


--------------------------------------------------------------------------------
/test/Asset/ComposerExercise.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Asset;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Check\ComposerCheck;
 6 | use PhpSchool\PhpWorkshop\Event\EventDispatcher;
 7 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 8 | use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
 9 | use PhpSchool\PhpWorkshop\ExerciseCheck\ComposerExerciseCheck;
10 | 
11 | class ComposerExercise implements ExerciseInterface, ComposerExerciseCheck
12 | {
13 |     public function getName(): string
14 |     {
15 |         return 'composer-exercise';
16 |     }
17 | 
18 |     public function getDescription(): string
19 |     {
20 |         // TODO: Implement getDescription() method.
21 |     }
22 | 
23 |     public function getSolution(): string
24 |     {
25 |         // TODO: Implement getSolution() method.
26 |     }
27 | 
28 |     public function getProblem(): string
29 |     {
30 |         // TODO: Implement getProblem() method.
31 |     }
32 | 
33 |     public function tearDown(): void
34 |     {
35 |         // TODO: Implement tearDown() method.
36 |     }
37 | 
38 |     public function getArgs(): array
39 |     {
40 |         return []; // TODO: Implement getArgs() method.
41 |     }
42 | 
43 |     public function getRequiredPackages(): array
44 |     {
45 |         return [
46 |             'klein/klein',
47 |             'danielstjules/stringy',
48 |         ];
49 |     }
50 | 
51 |     public function getType(): ExerciseType
52 |     {
53 |         return ExerciseType::CLI();
54 |     }
55 | 
56 |     public function getRequiredChecks(): array
57 |     {
58 |         return [ComposerCheck::class];
59 |     }
60 | 
61 |     public function defineListeners(EventDispatcher $dispatcher): void {}
62 | }
63 | 


--------------------------------------------------------------------------------
/test/res/exercise-renderer/test-render-success-with-php-solution-file-is-syntax-highlighted.txt:
--------------------------------------------------------------------------------
 1 | 
 2 |                                           *** RESULTS ***
 3 | 
 4 |                                                               
 5 |                                        ✔ Check: Success 1!    
 6 |                                                               
 7 | 
 8 |                                                               
 9 |                                        ✔ Check: Success 2!    
10 |                                                               
11 | 
12 | ────────────────────────────────────────────────────────────────────────────────────────────────────
13 | 
14 |                                                                                                     
15 |                                                 PASS!                                               
16 |                                                                                                     
17 | 
18 |                   Here's the official solution in case you want to compare notes:
19 | 
20 | ────────────────────────────────────────────────────────────────────────────────────────────────────
21 | some-file.php
22 | 
23 | FILE CONTENTS
24 | ────────────────────────────────────────────────────────────────────────────────────────────────────
25 | 
26 |                                     You have 1 challenges left.
27 |                              Type "app" and hit enter to show the menu.
28 | 
29 | 


--------------------------------------------------------------------------------
/src/Output/OutputInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Output;
 6 | 
 7 | use Throwable;
 8 | 
 9 | /**
10 |  * Output interface
11 |  */
12 | interface OutputInterface
13 | {
14 |     /**
15 |      * Write a string as an error. Should be decorated in someway
16 |      * which highlights the severity.
17 |      *
18 |      * @param string $error
19 |      */
20 |     public function printError(string $error): void;
21 | 
22 |     /**
23 |      * Write an Exception. Should be decorated in someway
24 |      * which highlights the severity.
25 |      *
26 |      * @param Throwable $exception
27 |      */
28 |     public function printException(Throwable $exception): void;
29 | 
30 |     /**
31 |      * Write a string to the output.
32 |      *
33 |      * @param string $content
34 |      */
35 |     public function write(string $content): void;
36 | 
37 |     /**
38 |      * Write an array of strings, each on a new line.
39 |      *
40 |      * @param array<string> $lines
41 |      */
42 |     public function writeLines(array $lines): void;
43 | 
44 |     /**
45 |      * Write a string terminated with a newline.
46 |      *
47 |      * @param string $line
48 |      */
49 |     public function writeLine(string $line): void;
50 | 
51 |     /**
52 |      * Write an empty line.
53 |      */
54 |     public function emptyLine(): void;
55 | 
56 |     /**
57 |      * Write a line break.
58 |      */
59 |     public function lineBreak(): void;
60 | 
61 |     /**
62 |      * Write a title section. Should be decorated in a way which makes
63 |      * the title stand out.
64 |      *
65 |      * @param string $title
66 |      */
67 |     public function writeTitle(string $title): void;
68 | }
69 | 


--------------------------------------------------------------------------------
/test/Markdown/Block/ContextSpecificBlockTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Markdown\Block;
 4 | 
 5 | use League\CommonMark\Block\Element\AbstractBlock;
 6 | use League\CommonMark\Cursor;
 7 | use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
 8 | use PhpSchool\PhpWorkshop\Markdown\Block\ContextSpecificBlock;
 9 | use PHPUnit\Framework\TestCase;
10 | 
11 | class ContextSpecificBlockTest extends TestCase
12 | {
13 |     public function testExceptionIsThrownIfConstructedWithInvalidType(): void
14 |     {
15 |         static::expectException(InvalidArgumentException::class);
16 |         static::expectExceptionMessage('Parameter: "type" can only be one of: "cli", "cloud" Received: "invalid"');
17 | 
18 |         new ContextSpecificBlock('invalid');
19 |     }
20 | 
21 |     public function testGetType(): void
22 |     {
23 |         $block = new ContextSpecificBlock('cli');
24 |         static::assertEquals('cli', $block->getType());
25 |     }
26 | 
27 |     public function testConfig(): void
28 |     {
29 |         $block = new ContextSpecificBlock('cli');
30 | 
31 |         static::assertTrue($block->canContain($this->getMockForAbstractClass(AbstractBlock::class)));
32 |         static::assertFalse($block->isCode());
33 |     }
34 | 
35 |     public function testMatchesNextLine(): void
36 |     {
37 |         $block = new ContextSpecificBlock('cli');
38 | 
39 |         static::assertTrue($block->matchesNextLine(new Cursor('Some line')));
40 |         static::assertTrue($block->matchesNextLine(new Cursor('* Item 1')));
41 |         static::assertTrue($block->matchesNextLine(new Cursor('* Item 2')));
42 | 
43 |         static::assertFalse($block->matchesNextLine(new Cursor('{{ cli }}')));
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/ExerciseRunner/Factory/CustomVerifyingRunnerFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\ExerciseRunner\Factory;
 6 | 
 7 | use PhpSchool\PhpWorkshop\CommandDefinition;
 8 | use PhpSchool\PhpWorkshop\Exercise\CustomVerifyingExercise;
 9 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
10 | use PhpSchool\PhpWorkshop\Exercise\ExerciseType;
11 | use PhpSchool\PhpWorkshop\ExerciseRunner\CustomVerifyingRunner;
12 | use PhpSchool\PhpWorkshop\ExerciseRunner\ExerciseRunnerInterface;
13 | 
14 | /**
15 |  * Factory class for `CustomVerifyingRunner`
16 |  */
17 | class CustomVerifyingRunnerFactory implements ExerciseRunnerFactoryInterface
18 | {
19 |     /**
20 |      * @var string
21 |      */
22 |     private static $type = ExerciseType::CUSTOM;
23 | 
24 |     /**
25 |      * Whether the factory supports this exercise type.
26 |      *
27 |      * @param ExerciseInterface $exercise
28 |      * @return bool
29 |      */
30 |     public function supports(ExerciseInterface $exercise): bool
31 |     {
32 |         return $exercise->getType()->getValue() === self::$type;
33 |     }
34 | 
35 |     /**
36 |      * Add any extra required arguments to the command.
37 |      *
38 |      * @param CommandDefinition $commandDefinition
39 |      */
40 |     public function configureInput(CommandDefinition $commandDefinition): void {}
41 | 
42 |     /**
43 |      * Create and return an instance of the runner.
44 |      *
45 |      * @param ExerciseInterface&CustomVerifyingExercise $exercise
46 |      * @return ExerciseRunnerInterface
47 |      */
48 |     public function create(ExerciseInterface $exercise): ExerciseRunnerInterface
49 |     {
50 |         return new CustomVerifyingRunner($exercise);
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/test/res/exercise-renderer/test-all-success-results-are-hoisted-to-the-top.txt:
--------------------------------------------------------------------------------
 1 | 
 2 |                                           *** RESULTS ***
 3 | 
 4 |                                                               
 5 |                                        ✔ Check: Success 1!    
 6 |                                                               
 7 | 
 8 |                                                               
 9 |                                        ✔ Check: Success 2!    
10 |                                                               
11 | 
12 |                                                               
13 |                                        ✗ Check: Failure 1     
14 |                                                               
15 | 
16 | Failure 1
17 |                                                               
18 |                                        ✗ Check: Failure 2     
19 |                                                               
20 | 
21 | Failure 2
22 | ────────────────────────────────────────────────────────────────────────────────────────────────────
23 | 
24 |                                                                                                     
25 |                                    Your solution was unsuccessful!                                  
26 |                                                                                                     
27 | 
28 |                               Your solution to  didn't pass. Try again!
29 | 
30 | 
31 | 


--------------------------------------------------------------------------------
/test/Utils/PathTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Util\s;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Utils\Path;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class PathTest extends TestCase
 9 | {
10 |     public function testJoin(): void
11 |     {
12 |         $this->assertEquals(
13 |             '/some/path/some-folder/file.txt',
14 |             Path::join('/some/path', 'some-folder/file.txt'),
15 |         );
16 | 
17 |         $this->assertEquals(
18 |             '/some/path/some-folder/file.txt',
19 |             Path::join('/some/path/', 'some-folder/file.txt'),
20 |         );
21 | 
22 |         $this->assertEquals(
23 |             '/some/path/some-folder/file.txt',
24 |             Path::join('/some/path', '/some-folder/file.txt'),
25 |         );
26 | 
27 |         $this->assertEquals(
28 |             '/some/path/some-folder/file.txt',
29 |             Path::join('/some/path/', '/some-folder/file.txt'),
30 |         );
31 | 
32 |         $this->assertEquals(
33 |             '/some/path/some-folder/file.txt',
34 |             Path::join('/some/path//', '//some-folder/file.txt'),
35 |         );
36 | 
37 |         $this->assertEquals(
38 |             '/some/path/some-folder/file.txt',
39 |             Path::join('/some/path/', 'some-folder', 'file.txt'),
40 |         );
41 | 
42 |         $this->assertEquals(
43 |             '/some/path/some-folder/file.txt',
44 |             Path::join('/some/path/', '/some-folder/', '/file.txt'),
45 |         );
46 | 
47 |         $this->assertEquals(
48 |             '/some/path',
49 |             Path::join('/some/path/'),
50 |         );
51 | 
52 |         $this->assertEquals(
53 |             '/some/path',
54 |             Path::join('/some/path/', ''),
55 |         );
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Exercise/ExerciseInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Exercise;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Event\EventDispatcher;
 8 | 
 9 | /**
10 |  * This interface describes all of the methods an exercise
11 |  * should implement.
12 |  */
13 | interface ExerciseInterface
14 | {
15 |     /**
16 |      * Get the name of the exercise, like `Hello World!`.
17 |      *
18 |      * @return string
19 |      */
20 |     public function getName(): string;
21 | 
22 |     /**
23 |      * Return the type of exercise. This is an ENUM. See `PhpSchool\PhpWorkshop\Exercise\ExerciseType`.
24 |      *
25 |      * @return ExerciseType
26 |      */
27 |     public function getType(): ExerciseType;
28 | 
29 |     /**
30 |      * Get the absolute path to the markdown file which contains the exercise problem.
31 |      *
32 |      * @return string
33 |      */
34 |     public function getProblem(): string;
35 | 
36 |     /**
37 |      * Subscribe to events triggered throughout the verification process
38 |      */
39 |     public function defineListeners(EventDispatcher $dispatcher): void;
40 | 
41 |     /**
42 |      * This is where the exercise specifies the extra checks it may require.
43 |      *
44 |      * @return array<class-string>
45 |      */
46 |     public function getRequiredChecks(): array;
47 | 
48 |     /**
49 |      * A short description of the exercise.
50 |      *
51 |      * @return string
52 |      */
53 |     public function getDescription(): string;
54 | 
55 |     /**
56 |      * Allows to perform some cleanup after the exercise solution's have been executed, for example
57 |      * remove files, close DB connections.
58 |      *
59 |      * @return void
60 |      */
61 |     public function tearDown(): void;
62 | }
63 | 


--------------------------------------------------------------------------------
/test/Event/CliExecuteEventTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Event;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Event\CliExecuteEvent;
 6 | use PhpSchool\PhpWorkshop\Exercise\Scenario\CliScenario;
 7 | use PhpSchool\PhpWorkshop\ExerciseRunner\Context\TestContext;
 8 | use PhpSchool\PhpWorkshop\Utils\Collection;
 9 | use PHPUnit\Framework\TestCase;
10 | 
11 | class CliExecuteEventTest extends TestCase
12 | {
13 |     public function testAppendArg(): void
14 |     {
15 |         $context = new TestContext();
16 |         $scenario = new CliScenario();
17 | 
18 |         $arr = new Collection([1, 2, 3]);
19 |         $e = new CliExecuteEvent('event', $context, $scenario, $arr);
20 | 
21 |         $e->appendArg('4');
22 |         $this->assertEquals([1, 2, 3, 4], $e->getArgs()->getArrayCopy());
23 |         $this->assertNotSame($arr, $e->getArgs());
24 |     }
25 | 
26 |     public function testPrependArg(): void
27 |     {
28 |         $context = new TestContext();
29 |         $scenario = new CliScenario();
30 | 
31 |         $arr = new Collection([1, 2, 3]);
32 |         $e = new CliExecuteEvent('event', $context, $scenario, $arr);
33 | 
34 |         $e->prependArg('4');
35 |         $this->assertEquals([4, 1, 2, 3], $e->getArgs()->getArrayCopy());
36 |         $this->assertNotSame($arr, $e->getArgs());
37 |     }
38 | 
39 |     public function testGetters(): void
40 |     {
41 |         $context = new TestContext();
42 |         $scenario = new CliScenario();
43 | 
44 |         $arr = new Collection([1, 2, 3]);
45 |         $e = new CliExecuteEvent('event', $context, $scenario, $arr);
46 | 
47 |         $this->assertSame($arr, $e->getArgs());
48 |         $this->assertSame($context, $e->getContext());
49 |         $this->assertSame($scenario, $e->getScenario());
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Event/Event.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Event;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Exception\InvalidArgumentException;
 8 | 
 9 | /**
10 |  * A generic `PhpSchool\PhpWorkshop\Event\EventInterface` implementation.
11 |  */
12 | class Event implements EventInterface
13 | {
14 |     private string $name;
15 | 
16 |     /**
17 |      * @var array<mixed>
18 |      */
19 |     protected array $parameters;
20 | 
21 |     /**
22 |      * @param string $name The event name.
23 |      * @param array<mixed> $parameters The event parameters.
24 |      */
25 |     public function __construct(string $name, array $parameters = [])
26 |     {
27 |         $this->name = $name;
28 |         $this->parameters = $parameters;
29 |     }
30 | 
31 |     /**
32 |      * Get the name of this event.
33 |      *
34 |      * @return string
35 |      */
36 |     public function getName(): string
37 |     {
38 |         return $this->name;
39 |     }
40 | 
41 |     /**
42 |      * Get an array of parameters that were triggered with this event.
43 |      *
44 |      * @return array<mixed>
45 |      */
46 |     public function getParameters(): array
47 |     {
48 |         return $this->parameters;
49 |     }
50 | 
51 |     /**
52 |      * Get a parameter by its name.
53 |      *
54 |      * @param string $name The name of the parameter.
55 |      * @return mixed The value.
56 |      * @throws InvalidArgumentException If the parameter by name does not exist.
57 |      */
58 |     public function getParameter(string $name): mixed
59 |     {
60 |         if (!array_key_exists($name, $this->parameters)) {
61 |             throw new InvalidArgumentException(sprintf('Parameter: "%s" does not exist', $name));
62 |         }
63 | 
64 |         return $this->parameters[$name];
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/ResultRenderer/ComparisonFailureRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\ResultRenderer;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Result\ComparisonFailure;
 8 | 
 9 | /**
10 |  * Renderer for `PhpSchool\PhpWorkshop\Result\ComparisonFailure`.
11 |  */
12 | class ComparisonFailureRenderer implements ResultRendererInterface
13 | {
14 |     /**
15 |      * @var ComparisonFailure
16 |      */
17 |     private $result;
18 | 
19 |     /**
20 |      * @param ComparisonFailure $result The failure.
21 |      */
22 |     public function __construct(ComparisonFailure $result)
23 |     {
24 |         $this->result = $result;
25 |     }
26 | 
27 |     /**
28 |      * Print the actual and expected output.
29 |      *
30 |      * @param ResultsRenderer $renderer
31 |      * @return string
32 |      */
33 |     public function render(ResultsRenderer $renderer): string
34 |     {
35 |         return sprintf(
36 |             "  %s\n%s\n\n  %s\n%s\n",
37 |             $renderer->style('YOUR OUTPUT:', ['bold', 'yellow']),
38 |             $this->indent($renderer->style(sprintf('"%s"', $this->result->getActualValue()), 'red')),
39 |             $renderer->style('EXPECTED OUTPUT:', ['bold', 'yellow']),
40 |             $this->indent($renderer->style(sprintf('"%s"', $this->result->getExpectedValue()), 'green')),
41 |         );
42 |     }
43 | 
44 |     /**
45 |      * @param string $string
46 |      * @return string
47 |      */
48 |     private function indent(string $string): string
49 |     {
50 |         return implode(
51 |             "\n",
52 |             array_map(
53 |                 function ($line) {
54 |                     return sprintf('  %s', $line);
55 |                 },
56 |                 explode("\n", $string),
57 |             ),
58 |         );
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/test/ExerciseRunner/CustomVerifyingRunnerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\ExerciseRunner;
 4 | 
 5 | use Colors\Color;
 6 | use PhpSchool\PhpWorkshop\ExerciseRunner\Context\TestContext;
 7 | use PhpSchool\Terminal\Terminal;
 8 | use PhpSchool\PhpWorkshop\ExerciseRunner\CustomVerifyingRunner;
 9 | use PhpSchool\PhpWorkshop\Output\StdOutput;
10 | use PhpSchool\PhpWorkshopTest\Asset\CustomVerifyingExerciseImpl;
11 | use PHPUnit\Framework\TestCase;
12 | 
13 | class CustomVerifyingRunnerTest extends TestCase
14 | {
15 |     private CustomVerifyingRunner $runner;
16 |     private CustomVerifyingExerciseImpl $exercise;
17 | 
18 |     public function setUp(): void
19 |     {
20 |         $this->exercise = new CustomVerifyingExerciseImpl();
21 |         $this->runner = new CustomVerifyingRunner($this->exercise);
22 | 
23 |         $this->assertEquals('Custom Verifying Runner', $this->runner->getName());
24 |     }
25 | 
26 |     public function testRequiredChecks(): void
27 |     {
28 |         $this->assertEquals([], $this->runner->getRequiredChecks());
29 |     }
30 | 
31 |     public function testRunOutputsErrorMessage(): void
32 |     {
33 |         $color = new Color();
34 |         $color->setForceStyle(true);
35 |         $output = new StdOutput($color, $this->createMock(Terminal::class));
36 | 
37 |         $exp  = 'Nothing to run here. This exercise does not require a code solution, ';
38 |         $exp .= "so there is nothing to execute.\n";
39 | 
40 |         $this->expectOutputString($exp);
41 | 
42 |         $this->runner->run(new TestContext(), $output);
43 |     }
44 | 
45 |     public function testVerifyProxiesToExercise(): void
46 |     {
47 |         $result = $this->runner->verify(new TestContext());
48 | 
49 |         self::assertEquals($this->exercise->verify(), $result);
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/test/FunctionsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | 
 7 | use function PhpSchool\PhpWorkshop\any;
 8 | use function PhpSchool\PhpWorkshop\camel_case_to_kebab_case;
 9 | use function PhpSchool\PhpWorkshop\mb_str_pad;
10 | 
11 | class FunctionsTest extends TestCase
12 | {
13 |     /**
14 |      * @dataProvider mbStrPadProvider
15 |      */
16 |     public function testMbStrPad(string $string, int $pad, string $expected): void
17 |     {
18 |         self::assertSame(mb_str_pad($string, $pad), $expected);
19 |     }
20 | 
21 |     public function mbStrPadProvider(): array
22 |     {
23 |         return [
24 |             ['hello', 10, 'hello     '],
25 |             ['hello😂', 10, 'hello😂    '],
26 |         ];
27 |     }
28 | 
29 |     /**
30 |      * @dataProvider camelCaseToKebabCaseProvider
31 |      */
32 |     public function testCamelCaseToKebabCase(string $string, string $expected): void
33 |     {
34 |         self::assertSame(camel_case_to_kebab_case($string), $expected);
35 |     }
36 | 
37 |     public function camelCaseToKebabCaseProvider(): array
38 |     {
39 |         return [
40 |             ['camelCase', 'camel-case'],
41 |             [
42 |                 'educationIsThePassportToTheFutureForTomorrowBelongsToThoseWhoPrepareForItToday',
43 |                 'education-is-the-passport-to-the-future-for-tomorrow-belongs-to-those-who-prepare-for-it-today',
44 |             ],
45 |         ];
46 |     }
47 | 
48 |     public function testAny(): void
49 |     {
50 |         self::assertEquals(true, any([1, 2, 3, 10, 11], function (int $num) {
51 |             return $num > 10;
52 |         }));
53 | 
54 |         self::assertEquals(false, any([1, 2, 3, 10, 11], function (int $num) {
55 |             return $num > 11;
56 |         }));
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/test/Listener/SelfCheckListenerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Listener;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Event\ExerciseRunnerEvent;
 6 | use PhpSchool\PhpWorkshop\Exercise\ExerciseInterface;
 7 | use PhpSchool\PhpWorkshop\ExerciseRunner\Context\TestContext;
 8 | use PhpSchool\PhpWorkshop\Listener\SelfCheckListener;
 9 | use PhpSchool\PhpWorkshop\Result\Success;
10 | use PhpSchool\PhpWorkshop\ResultAggregator;
11 | use PhpSchool\PhpWorkshopTest\Asset\SelfCheckExerciseInterface;
12 | use PHPUnit\Framework\TestCase;
13 | 
14 | class SelfCheckListenerTest extends TestCase
15 | {
16 |     public function testSelfCheck(): void
17 |     {
18 |         $exercise = $this->createMock(SelfCheckExerciseInterface::class);
19 |         $context  = new TestContext($exercise);
20 |         $event    = new ExerciseRunnerEvent('event', $context);
21 | 
22 |         $success = new Success('Success');
23 |         $exercise
24 |             ->expects($this->once())
25 |             ->method('check')
26 |             ->willReturn($success);
27 | 
28 |         $results = new ResultAggregator();
29 |         $listener = new SelfCheckListener($results);
30 |         $listener->__invoke($event);
31 | 
32 |         $this->assertTrue($results->isSuccessful());
33 |         $this->assertCount(1, $results);
34 |     }
35 | 
36 |     public function testExerciseWithOutSelfCheck(): void
37 |     {
38 |         $exercise = $this->createMock(ExerciseInterface::class);
39 |         $context  = new TestContext($exercise);
40 |         $event    = new ExerciseRunnerEvent('event', $context);
41 | 
42 |         $results = new ResultAggregator();
43 |         $listener = new SelfCheckListener($results);
44 |         $listener->__invoke($event);
45 | 
46 |         $this->assertTrue($results->isSuccessful());
47 |         $this->assertCount(0, $results);
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/test/Result/Cli/GenericFailureTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpSchool\PhpWorkshopTest\Result\Cli;
 4 | 
 5 | use PhpSchool\PhpWorkshop\Exception\CodeExecutionException;
 6 | use PhpSchool\PhpWorkshop\Result\Cli\GenericFailure;
 7 | use PhpSchool\PhpWorkshop\Utils\ArrayObject;
 8 | use PHPUnit\Framework\TestCase;
 9 | 
10 | class GenericFailureTest extends TestCase
11 | {
12 |     public function testFailure(): void
13 |     {
14 |         $args = new ArrayObject();
15 |         $failure = new GenericFailure($args, 'Oops');
16 |         $this->assertInstanceOf(GenericFailure::class, $failure);
17 |         $this->assertEquals($args, $failure->getArgs());
18 |         $this->assertEquals('Oops', $failure->getReason());
19 |         $this->assertEquals('CLI Program Runner', $failure->getCheckName());
20 |     }
21 | 
22 |     public function testFailureWithRequestAndReason(): void
23 |     {
24 |         $args = new ArrayObject();
25 |         $failure = GenericFailure::fromArgsAndReason($args, 'Oops');
26 |         $this->assertInstanceOf(GenericFailure::class, $failure);
27 |         $this->assertEquals($args, $failure->getArgs());
28 |         $this->assertEquals('Oops', $failure->getReason());
29 |         $this->assertEquals('CLI Program Runner', $failure->getCheckName());
30 |     }
31 | 
32 |     public function testFailureFromCodeExecutionException(): void
33 |     {
34 |         $args = new ArrayObject();
35 |         $e = new CodeExecutionException('Something went wrong yo');
36 |         $failure = GenericFailure::fromArgsAndCodeExecutionFailure($args, $e);
37 |         $this->assertInstanceOf(GenericFailure::class, $failure);
38 |         $this->assertEquals($args, $failure->getArgs());
39 |         $this->assertEquals('Something went wrong yo', $failure->getReason());
40 |         $this->assertEquals('CLI Program Runner', $failure->getCheckName());
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Listener/PrepareSolutionListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace PhpSchool\PhpWorkshop\Listener;
 6 | 
 7 | use PhpSchool\PhpWorkshop\Event\ExerciseRunnerEvent;
 8 | use PhpSchool\PhpWorkshop\Exercise\ProvidesSolution;
 9 | use PhpSchool\PhpWorkshop\Exception\RuntimeException;
10 | use PhpSchool\PhpWorkshop\Process\ProcessFactory;
11 | use PhpSchool\PhpWorkshop\Process\ProcessInput;
12 | 
13 | /**
14 |  * Listener to install composer deps for an exercise solution
15 |  */
16 | class PrepareSolutionListener
17 | {
18 |     public function __construct(private ProcessFactory $processFactory)
19 |     {
20 |         $this->processFactory = $processFactory;
21 |     }
22 | 
23 |     /**
24 |      * @param ExerciseRunnerEvent $event
25 |      */
26 |     public function __invoke(ExerciseRunnerEvent $event): void
27 |     {
28 |         $exercise = $event->getExercise();
29 | 
30 |         if (!$exercise instanceof ProvidesSolution) {
31 |             return;
32 |         }
33 | 
34 |         $solution = $exercise->getSolution();
35 | 
36 |         if (!$solution->hasComposerFile()) {
37 |             return;
38 |         }
39 | 
40 |         //prepare composer deps
41 |         //only install if vendor folder not available
42 |         if (!file_exists(sprintf('%s/vendor', $event->getContext()->getReferenceExecutionDirectory()))) {
43 |             $process = $this->processFactory->create(
44 |                 new ProcessInput('composer', ['install', '--no-interaction'], $event->getContext()->getReferenceExecutionDirectory(), []),
45 |             );
46 | 
47 |             try {
48 |                 $process->mustRun();
49 |             } catch (\Symfony\Component\Process\Exception\RuntimeException $e) {
50 |                 throw new RuntimeException('Composer dependencies could not be installed', 0, $e);
51 |             }
52 |         }
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------