1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  14:  15:  16:  17:  18:  19:  20:  21:  22:  23:  24:  25:  26:  27:  28:  29:  30:  31:  32:  33:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 218: 219: 220: 221: 222: 223: 224: 225: 226: 227: 228: 229: 230: 231: 232: 233: 234: 235: 236: 237: 238: 239: 240: 241: 242: 243: 244: 245: 246: 247: 248: 249: 250: 251: 252: 253: 254: 255: 256: 257: 258: 259: 260: 261: 262: 263: 264: 265: 266: 267: 268: 269: 270: 271: 272: 273: 274: 275: 276: 277: 278: 279: 280: 281: 282: 283: 284: 285: 286: 287: 288: 289: 290: 291: 292: 293: 294: 295: 296: 297: 298: 299: 300: 301: 302: 303: 304: 305: 306: 307: 308: 309: 310: 311: 312: 313: 314: 315: 316: 317: 318: 319: 320: 321: 322: 323: 324: 325: 326: 327: 328: 329: 330: 331: 332: 333: 334: 335: 

<?php

/*
 * This file is part of the webmozart/console package.
 *
 * (c) Bernhard Schussek <bschussek@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Webmozart\Console;

use Exception;
use LogicException;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Webmozart\Assert\Assert;
use Webmozart\Console\Api\Application\Application;
use Webmozart\Console\Api\Args\Format\ArgsFormat;
use Webmozart\Console\Api\Args\RawArgs;
use Webmozart\Console\Api\Command\CannotAddCommandException;
use Webmozart\Console\Api\Command\Command;
use Webmozart\Console\Api\Command\CommandCollection;
use Webmozart\Console\Api\Config\ApplicationConfig;
use Webmozart\Console\Api\Config\CommandConfig;
use Webmozart\Console\Api\Event\ConfigEvent;
use Webmozart\Console\Api\Event\ConsoleEvents;
use Webmozart\Console\Api\Event\PreResolveEvent;
use Webmozart\Console\Api\IO\InputStream;
use Webmozart\Console\Api\IO\IO;
use Webmozart\Console\Api\IO\OutputStream;
use Webmozart\Console\Args\ArgvArgs;
use Webmozart\Console\IO\ConsoleIO;
use Webmozart\Console\UI\Component\ExceptionTrace;

/**
 * A console application.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <bschussek@gmail.com>
 */
class ConsoleApplication implements Application
{
    /**
     * @var ApplicationConfig
     */
    private $config;

    /**
     * @var CommandCollection
     */
    private $commands;

    /**
     * @var CommandCollection
     */
    private $namedCommands;

    /**
     * @var CommandCollection
     */
    private $defaultCommands;

    /**
     * @var ArgsFormat
     */
    private $globalArgsFormat;

    /**
     * @var EventDispatcherInterface
     */
    private $dispatcher;

    /**
     * @var ConsoleIO
     */
    private $preliminaryIo;

    /**
     * Creates a new console application.
     *
     * @param ApplicationConfig|callable $config The application configuration
     *                                           or a callable that creates the
     *                                           configuration.
     */
    public function __construct($config)
    {
        $this->preliminaryIo = new ConsoleIO();

        // Enable trace output for exceptions thrown during boot
        $this->preliminaryIo->setVerbosity(IO::VERBOSE);

        if (is_callable($config)) {
            try {
                $config = $config();
            } catch (Exception $e) {
                $trace = new ExceptionTrace($e);
                $trace->render($this->preliminaryIo);

                exit($this->exceptionToExitCode($e->getCode()));
            }
        }

        Assert::isInstanceOf($config, 'Webmozart\Console\Api\Config\ApplicationConfig', 'The $config argument must be an ApplicationConfig or a callable. Got: %s');

        try {
            $dispatcher = $config->getEventDispatcher();

            if ($dispatcher && $dispatcher->hasListeners(ConsoleEvents::CONFIG)) {
                $dispatcher->dispatch(ConsoleEvents::CONFIG,
                    new ConfigEvent($config));
            }

            $this->config = $config;
            $this->dispatcher = $config->getEventDispatcher();
            $this->commands = new CommandCollection();
            $this->namedCommands = new CommandCollection();
            $this->defaultCommands = new CommandCollection();

            $this->globalArgsFormat = new ArgsFormat(array_merge(
                $config->getOptions(),
                $config->getArguments()
            ));

            foreach ($config->getCommandConfigs() as $commandConfig) {
                $this->addCommand($commandConfig);
            }
        } catch (Exception $e) {
            if (!$config->isExceptionCaught()) {
                throw $e;
            }

            // Render the trace to the preliminary IO
            $trace = new ExceptionTrace($e);
            $trace->render($this->preliminaryIo);

            // Ignore isTerminatedAfterRun() setting. This is a fatal error.
            exit($this->exceptionToExitCode($e->getCode()));
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getConfig()
    {
        return $this->config;
    }

    /**
     * {@inheritdoc}
     */
    public function getGlobalArgsFormat()
    {
        return $this->globalArgsFormat;
    }

    /**
     * {@inheritdoc}
     */
    public function getCommand($name)
    {
        return $this->commands->get($name);
    }

    /**
     * {@inheritdoc}
     */
    public function getCommands()
    {
        return clone $this->commands;
    }

    /**
     * {@inheritdoc}
     */
    public function hasCommand($name)
    {
        return $this->commands->contains($name);
    }

    /**
     * {@inheritdoc}
     */
    public function hasCommands()
    {
        return !$this->commands->isEmpty();
    }

    /**
     * {@inheritdoc}
     */
    public function getNamedCommands()
    {
        return $this->namedCommands;
    }

    /**
     * {@inheritdoc}
     */
    public function hasNamedCommands()
    {
        return count($this->namedCommands) > 0;
    }

    /**
     * {@inheritdoc}
     */
    public function getDefaultCommands()
    {
        return $this->defaultCommands;
    }

    /**
     * {@inheritdoc}
     */
    public function hasDefaultCommands()
    {
        return count($this->defaultCommands) > 0;
    }

    /**
     * {@inheritdoc}
     */
    public function resolveCommand(RawArgs $args)
    {
        if ($this->dispatcher && $this->dispatcher->hasListeners(ConsoleEvents::PRE_RESOLVE)) {
            $event = new PreResolveEvent($args, $this);
            $this->dispatcher->dispatch(ConsoleEvents::PRE_RESOLVE, $event);

            if ($resolvedCommand = $event->getResolvedCommand()) {
                return $resolvedCommand;
            }
        }

        return $this->config->getCommandResolver()->resolveCommand($args, $this);
    }

    /**
     * {@inheritdoc}
     */
    public function run(RawArgs $args = null, InputStream $inputStream = null, OutputStream $outputStream = null, OutputStream $errorStream = null)
    {
        // Render errors to the preliminary IO until the final IO is created
        $io = $this->preliminaryIo;

        try {
            if (null === $args) {
                $args = new ArgvArgs();
            }

            $ioFactory = $this->config->getIOFactory();

            if (null === $ioFactory) {
                throw new LogicException('The IO factory must be set.');
            }

            /** @var IO $io */
            $io = call_user_func($ioFactory, $this, $args, $inputStream, $outputStream, $errorStream);

            $resolvedCommand = $this->resolveCommand($args);
            $command = $resolvedCommand->getCommand();
            $parsedArgs = $resolvedCommand->getArgs();

            $statusCode = $command->handle($parsedArgs, $io);
        } catch (Exception $e) {
            if (!$this->config->isExceptionCaught()) {
                throw $e;
            }

            $trace = new ExceptionTrace($e);
            $trace->render($io);

            $statusCode = $this->exceptionToExitCode($e->getCode());
        }

        if ($this->config->isTerminatedAfterRun()) {
            exit($statusCode);
        }

        return $statusCode;
    }

    /**
     * Converts an exception code to an exit code.
     *
     * @param int $code The exception code.
     *
     * @return int The exit code.
     */
    private function exceptionToExitCode($code)
    {
        if (!is_numeric($code)) {
            return 1;
        }

        return min(max((int) $code, 1), 255);
    }

    private function addCommand(CommandConfig $config)
    {
        if (!$config->isEnabled()) {
            return;
        }

        $this->validateCommandName($config);

        $command = new Command($config, $this);

        $this->commands->add($command);

        if ($config->isDefault()) {
            $this->defaultCommands->add($command);
        }

        if (!$config->isAnonymous()) {
            $this->namedCommands->add($command);
        }
    }

    private function validateCommandName(CommandConfig $config)
    {
        $name = $config->getName();

        if (!$name) {
            throw CannotAddCommandException::nameEmpty();
        }

        if ($this->commands->contains($name)) {
            throw CannotAddCommandException::nameExists($name);
        }
    }
}