railt / console

src/Application.php

<?php
/**
 * This file is part of Railt package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace Railt\Console;

use Railt\Console\Language\GraphQLLanguage;
use Railt\Console\Language\LanguageInterface;
use Railt\Console\Language\PHPLanguage;
use Symfony\Component\Console\Application as Symfony;
use Symfony\Component\Console\Command\Command;

This use statement conflicts with another class in this namespace, Railt\Console\Command.

use Symfony\Component\Console\Input\ArgvInput;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\ConsoleOutput;
use Symfony\Component\Console\Output\OutputInterface;

/**
 * Class Application
 */
class Application extends Symfony
{
    /**
     * @var string
     */
    public const APP_NAME = 'Railt';

    /**
     * @var string
     */
    public const APP_VERSION = '1.2';

    /**
     * @var ExceptionRenderer
     */
    private $renderer;

    /**
     * @var Highlighter
     */
    private $highlighter;

    /**
     * Application constructor.
     * @throws \InvalidArgumentException
     * @throws \Railt\Lexer\Exception\BadLexemeException
     */
    public function __construct()
    {
        parent::__construct(self::APP_NAME, self::APP_VERSION);

        $this->highlighter = $this->bootHighlight();
        $this->renderer    = new ExceptionRenderer($this->highlighter);
    }

    /**
     * @param string ...$paths
     * @throws \Symfony\Component\Console\Exception\InvalidArgumentException
     */
    public function tryReadManifest(string ...$paths): void
    {
        foreach ($paths as $path) {
            if (\is_file($path) && \is_readable($path)) {
                $this->readManifest($path);
            }
        }
    }

    /**
     * @param string $path
     * @throws \Symfony\Component\Console\Exception\InvalidArgumentException
     */
    public function readManifest(string $path): void
    {
        $manifest = \json_decode(\file_get_contents($path), true);

        try {
            foreach ($manifest['commands'] ?? [] as $command) {
                $this->add(new $command());
            }
        } catch (\Throwable $e) {
            $this->throw($e);
        }
    }

    /**
     * @return Highlighter
     * @throws \InvalidArgumentException
     * @throws \Railt\Lexer\Exception\BadLexemeException
     */
    private function bootHighlight(): Highlighter
    {
        $hl = new Highlighter();

        $hl->add(new PHPLanguage());
        $hl->add(new GraphQLLanguage());

        return $hl;
    }

    /**
     * @param LanguageInterface $language
     * @return Application
     */
    public function addLanguage(LanguageInterface $language): self
    {
        $this->highlighter->add($language);

        return $this;
    }

    /**
     * @param InputInterface|null $input
     * @param OutputInterface|null $output
     * @throws \Throwable
     */
    public function gracefulRun(InputInterface $input = null, OutputInterface $output = null): void
    {
        [$input, $output] = $this->bootPipes($input, $output);

        try {
            $this->setCatchExceptions(false);
            $code = parent::run($input, $output);
        } catch (\Throwable $e) {
            $code = $this->exitCode($e);
            $this->throw($e);
        } finally {
            exit($code);

The variable $code does not seem to be defined for all execution paths leading up to this point.

        }
    }

    /**
     * @param InputInterface|null $input
     * @param OutputInterface|null $output
     * @return array
     * @throws \Symfony\Component\Console\Exception\InvalidArgumentException
     * @throws \Symfony\Component\Console\Exception\RuntimeException
     */
    private function bootPipes(InputInterface $input = null, OutputInterface $output = null): array
    {
        $input  = $input ?? new ArgvInput();
        $output = $output ?? new ConsoleOutput();

        return [$input, $output];
    }

    /**
     * @param \Throwable $e
     * @return int
     */
    private function exitCode(\Throwable $e): int
    {
        return $e->getCode() ?: 1;
    }

    /**
     * @param Command $command
     * @return Command
     * @throws \Symfony\Component\Console\Exception\InvalidArgumentException
     */
    public function add(Command $command): Command
    {
        try {
            parent::add($command);
        } catch (\Throwable $e) {
            $this->throw($e);
        }

        return $command;
    }

    /**
     * @param \Throwable $e
     * @param ConsoleOutput|null $output
     * @return void
     * @throws \Symfony\Component\Console\Exception\InvalidArgumentException
     */
    public function throw(\Throwable $e, ConsoleOutput $output = null): void
    {
        try {
            $result = $this->renderer->render($e);
        } catch (\Throwable $error) {
            $result = (string)new $error($error->getMessage(), $e->getCode(), $e);
        }

        ($output ?? new ConsoleOutput())->write($result);

        exit($this->exitCode($e));
    }
}