クラス yii\console\controllers\CacheController

                public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __clone()
{
    $this->_events = [];
    $this->_eventWildcards = [];
    $this->_behaviors = null;
}

            

                public function __construct($id, $module, $config = [])
{
    $this->id = $id;
    $this->module = $module;
    parent::__construct($config);
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        // read property, e.g. getName()
        return $this->$getter();
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name;
        }
    }
    if (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name !== null;
        }
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        // set property
        $this->$setter($value);
        return;
    } elseif (strncmp($name, 'on ', 3) === 0) {
        // on event: attach event handler
        $this->on(trim(substr($name, 3)), $value);
        return;
    } elseif (strncmp($name, 'as ', 3) === 0) {
        // as behavior: attach behavior
        $name = trim(substr($name, 3));
        $this->attachBehavior($name, $value instanceof Behavior ? $value : Yii::createObject($value));
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = $value;
            return;
        }
    }
    if (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = null;
            return;
        }
    }
    throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

            

                public function actions()
{
    return [];
}

            

                public function afterAction($action, $result)
{
    $event = new ActionEvent($action);
    $event->result = $result;
    $this->trigger(self::EVENT_AFTER_ACTION, $event);
    return $event->result;
}

            

                public function ansiFormat($string)
{
    if ($this->isColorEnabled()) {
        $args = func_get_args();
        array_shift($args);
        $string = Console::ansiFormat($string, $args);
    }
    return $string;
}

            

                public function attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            

                public function attachBehaviors($behaviors)
{
    $this->ensureBehaviors();
    foreach ($behaviors as $name => $behavior) {
        $this->attachBehaviorInternal($name, $behavior);
    }
}

            

                public function beforeAction($action)
{
    $silentExit = $this->silentExitOnException !== null ? $this->silentExitOnException : YII_ENV_TEST;
    Yii::$app->errorHandler->silentExitOnException = $silentExit;
    return parent::beforeAction($action);
}

            

                public function behaviors()
{
    return [];
}

            

                public function bindActionParams($action, $params)
{
    if ($action instanceof InlineAction) {
        $method = new \ReflectionMethod($this, $action->actionMethod);
    } else {
        $method = new \ReflectionMethod($action, 'run');
    }
    $args = [];
    $missing = [];
    $actionParams = [];
    $requestedParams = [];
    foreach ($method->getParameters() as $i => $param) {
        $name = $param->getName();
        $key = null;
        if (array_key_exists($i, $params)) {
            $key = $i;
        } elseif (array_key_exists($name, $params)) {
            $key = $name;
        }
        if ($key !== null) {
            if (PHP_VERSION_ID >= 80000) {
                $isArray = ($type = $param->getType()) instanceof \ReflectionNamedType && $type->getName() === 'array';
            } else {
                $isArray = $param->isArray();
            }
            if ($isArray) {
                $params[$key] = $params[$key] === '' ? [] : preg_split('/\s*,\s*/', $params[$key]);
            }
            $args[] = $actionParams[$key] = $params[$key];
            unset($params[$key]);
        } elseif (
            PHP_VERSION_ID >= 70100
            && ($type = $param->getType()) !== null
            && $type instanceof \ReflectionNamedType
            && !$type->isBuiltin()
        ) {
            try {
                $this->bindInjectedParams($type, $name, $args, $requestedParams);
            } catch (\yii\base\Exception $e) {
                throw new Exception($e->getMessage());
            }
        } elseif ($param->isDefaultValueAvailable()) {
            $args[] = $actionParams[$i] = $param->getDefaultValue();
        } else {
            $missing[] = $name;
        }
    }
    if (!empty($missing)) {
        throw new Exception(Yii::t('yii', 'Missing required arguments: {params}', ['params' => implode(', ', $missing)]));
    }
    // We use a different array here, specifically one that doesn't contain service instances but descriptions instead.
    if (\Yii::$app->requestedParams === null) {
        \Yii::$app->requestedParams = array_merge($actionParams, $requestedParams);
    }
    return array_merge($args, $params);
}

            

                final protected function bindInjectedParams(\ReflectionType $type, $name, &$args, &$requestedParams)
{
    // Since it is not a builtin type it must be DI injection.
    $typeName = $type->getName();
    if (($component = $this->module->get($name, false)) instanceof $typeName) {
        $args[] = $component;
        $requestedParams[$name] = 'Component: ' . get_class($component) . " \$$name";
    } elseif ($this->module->has($typeName) && ($service = $this->module->get($typeName)) instanceof $typeName) {
        $args[] = $service;
        $requestedParams[$name] = 'Module ' . get_class($this->module) . " DI: $typeName \$$name";
    } elseif (\Yii::$container->has($typeName) && ($service = \Yii::$container->get($typeName)) instanceof $typeName) {
        $args[] = $service;
        $requestedParams[$name] = "Container DI: $typeName \$$name";
    } elseif ($type->allowsNull()) {
        $args[] = null;
        $requestedParams[$name] = "Unavailable service: $name";
    } else {
        throw new Exception('Could not load required service: ' . $name);
    }
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canGetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canSetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public static function className()
{
    return get_called_class();
}

            

                public function confirm($message, $default = false)
{
    if ($this->interactive) {
        return Console::confirm($message, $default);
    }
    return true;
}

            

                public function createAction($id)
{
    if ($id === '') {
        $id = $this->defaultAction;
    }
    $actionMap = $this->actions();
    if (isset($actionMap[$id])) {
        return Yii::createObject($actionMap[$id], [$id, $this]);
    }
    if (preg_match('/^(?:[a-z0-9_]+-)*[a-z0-9_]+$/', $id)) {
        $methodName = 'action' . str_replace(' ', '', ucwords(str_replace('-', ' ', $id)));
        if (method_exists($this, $methodName)) {
            $method = new \ReflectionMethod($this, $methodName);
            if ($method->isPublic() && $method->getName() === $methodName) {
                return new InlineAction($id, $this, $methodName);
            }
        }
    }
    return null;
}

            

                public function detachBehavior($name)
{
    $this->ensureBehaviors();
    if (isset($this->_behaviors[$name])) {
        $behavior = $this->_behaviors[$name];
        unset($this->_behaviors[$name]);
        $behavior->detach();
        return $behavior;
    }
    return null;
}

            

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            

                public function ensureBehaviors()
{
    if ($this->_behaviors === null) {
        $this->_behaviors = [];
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

            

                public function findLayoutFile($view)
{
    $module = $this->module;
    $layout = null;
    if (is_string($this->layout)) {
        $layout = $this->layout;
    } elseif ($this->layout === null) {
        while ($module !== null && $module->layout === null) {
            $module = $module->module;
        }
        if ($module !== null && is_string($module->layout)) {
            $layout = $module->layout;
        }
    }
    if ($layout === null) {
        return false;
    }
    if (strncmp($layout, '@', 1) === 0) {
        $file = Yii::getAlias($layout);
    } elseif (strncmp($layout, '/', 1) === 0) {
        $file = Yii::$app->getLayoutPath() . DIRECTORY_SEPARATOR . substr($layout, 1);
    } else {
        $file = $module->getLayoutPath() . DIRECTORY_SEPARATOR . $layout;
    }
    if (pathinfo($file, PATHINFO_EXTENSION) !== '') {
        return $file;
    }
    $path = $file . '.' . $view->defaultExtension;
    if ($view->defaultExtension !== 'php' && !is_file($path)) {
        $path = $file . '.php';
    }
    return $path;
}

            

                public function getActionArgsHelp($action)
{
    $method = $this->getActionMethodReflection($action);
    $tags = $this->parseDocCommentTags($method);
    $tags['param'] = isset($tags['param']) ? (array) $tags['param'] : [];
    $phpDocParams = [];
    foreach ($tags['param'] as $i => $tag) {
        if (preg_match('/^(?<type>\S+)(\s+\$(?<name>\w+))?(?<comment>.*)/us', $tag, $matches) === 1) {
            $key = empty($matches['name']) ? $i : $matches['name'];
            $phpDocParams[$key] = ['type' => $matches['type'], 'comment' => $matches['comment']];
        }
    }
    unset($tags);
    $args = [];
    /** @var \ReflectionParameter $parameter */
    foreach ($method->getParameters() as $i => $parameter) {
        $type = null;
        $comment = '';
        if (PHP_MAJOR_VERSION > 5 && $parameter->hasType()) {
            $reflectionType = $parameter->getType();
            if (PHP_VERSION_ID >= 70100) {
                $types = method_exists($reflectionType, 'getTypes') ? $reflectionType->getTypes() : [$reflectionType];
                foreach ($types as $key => $reflectionType) {
                    $types[$key] = $reflectionType->getName();
                }
                $type = implode('|', $types);
            } else {
                $type = (string) $reflectionType;
            }
        }
        // find PhpDoc tag by property name or position
        $key = isset($phpDocParams[$parameter->name]) ? $parameter->name : (isset($phpDocParams[$i]) ? $i : null);
        if ($key !== null) {
            $comment = $phpDocParams[$key]['comment'];
            if ($type === null && !empty($phpDocParams[$key]['type'])) {
                $type = $phpDocParams[$key]['type'];
            }
        }
        // if type still not detected, then using type of default value
        if ($type === null && $parameter->isDefaultValueAvailable() && $parameter->getDefaultValue() !== null) {
            $type = gettype($parameter->getDefaultValue());
        }
        $args[$parameter->name] = [
            'required' => !$parameter->isOptional(),
            'type' => $type,
            'default' => $parameter->isDefaultValueAvailable() ? $parameter->getDefaultValue() : null,
            'comment' => $comment,
        ];
    }
    return $args;
}

            

                public function getActionHelp($action)
{
    return $this->parseDocCommentDetail($this->getActionMethodReflection($action));
}

            

                public function getActionHelpSummary($action)
{
    if ($action === null) {
        return $this->ansiFormat(Yii::t('yii', 'Action not found.'), Console::FG_RED);
    }
    return $this->parseDocCommentSummary($this->getActionMethodReflection($action));
}

            

                protected function getActionMethodReflection($action)
{
    if (!isset($this->_reflections[$action->id])) {
        if ($action instanceof InlineAction) {
            $this->_reflections[$action->id] = new \ReflectionMethod($this, $action->actionMethod);
        } else {
            $this->_reflections[$action->id] = new \ReflectionMethod($action, 'run');
        }
    }
    return $this->_reflections[$action->id];
}

            

                public function getActionOptionsHelp($action)
{
    $optionNames = $this->options($action->id);
    if (empty($optionNames)) {
        return [];
    }
    $class = new \ReflectionClass($this);
    $options = [];
    foreach ($class->getProperties() as $property) {
        $name = $property->getName();
        if (!in_array($name, $optionNames, true)) {
            continue;
        }
        $defaultValue = $property->getValue($this);
        $tags = $this->parseDocCommentTags($property);
        // Display camelCase options in kebab-case
        $name = Inflector::camel2id($name, '-', true);
        if (isset($tags['var']) || isset($tags['property'])) {
            $doc = isset($tags['var']) ? $tags['var'] : $tags['property'];
            if (is_array($doc)) {
                $doc = reset($doc);
            }
            if (preg_match('/^(\S+)(.*)/s', $doc, $matches)) {
                $type = $matches[1];
                $comment = $matches[2];
            } else {
                $type = null;
                $comment = $doc;
            }
            $options[$name] = [
                'type' => $type,
                'default' => $defaultValue,
                'comment' => $comment,
            ];
        } else {
            $options[$name] = [
                'type' => null,
                'default' => $defaultValue,
                'comment' => '',
            ];
        }
    }
    return $options;
}

            

                public function getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            

                public function getHelp()
{
    return $this->parseDocCommentDetail(new \ReflectionClass($this));
}

            

                public function getHelpSummary()
{
    return $this->parseDocCommentSummary(new \ReflectionClass($this));
}

            

                public function getModules()
{
    $modules = [$this->module];
    $module = $this->module;
    while ($module->module !== null) {
        array_unshift($modules, $module->module);
        $module = $module->module;
    }
    return $modules;
}

            

                public function getOptionValues($actionID)
{
    // $actionId might be used in subclasses to provide properties specific to action id
    $properties = [];
    foreach ($this->options($this->action->id) as $property) {
        $properties[$property] = $this->$property;
    }
    return $properties;
}

            

                public function getPassedOptionValues()
{
    $properties = [];
    foreach ($this->_passedOptions as $property) {
        $properties[$property] = $this->$property;
    }
    return $properties;
}

            

                public function getPassedOptions()
{
    return $this->_passedOptions;
}

            

                public function getRoute()
{
    return $this->action !== null ? $this->action->getUniqueId() : $this->getUniqueId();
}

            

                public function getUniqueId()
{
    return $this->module instanceof Application ? $this->id : $this->module->getUniqueId() . '/' . $this->id;
}

            

                public function getView()
{
    if ($this->_view === null) {
        $this->_view = Yii::$app->getView();
    }
    return $this->_view;
}

            

                public function getViewPath()
{
    if ($this->_viewPath === null) {
        $this->_viewPath = $this->module->getViewPath() . DIRECTORY_SEPARATOR . $this->id;
    }
    return $this->_viewPath;
}

            

                public function hasEventHandlers($name)
{
    $this->ensureBehaviors();
    if (!empty($this->_events[$name])) {
        return true;
    }
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
            return true;
        }
    }
    return Event::hasHandlers($this, $name);
}

            

                public function hasMethod($name, $checkBehaviors = true)
{
    if (method_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->hasMethod($name)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
    return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

            

                public function init()
{
    parent::init();
    $this->request = Instance::ensure($this->request, Request::className());
    $this->response = Instance::ensure($this->response, Response::className());
}

            

                public function isColorEnabled($stream = \STDOUT)
{
    return $this->color === null ? Console::streamSupportsAnsiColors($stream) : $this->color;
}

            

                public function off($name, $handler = null)
{
    $this->ensureBehaviors();
    if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
        return false;
    }
    if ($handler === null) {
        unset($this->_events[$name], $this->_eventWildcards[$name]);
        return true;
    }
    $removed = false;
    // plain event names
    if (isset($this->_events[$name])) {
        foreach ($this->_events[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_events[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_events[$name] = array_values($this->_events[$name]);
            return true;
        }
    }
    // wildcard event names
    if (isset($this->_eventWildcards[$name])) {
        foreach ($this->_eventWildcards[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_eventWildcards[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
            // remove empty wildcards to save future redundant regex checks:
            if (empty($this->_eventWildcards[$name])) {
                unset($this->_eventWildcards[$name]);
            }
        }
    }
    return $removed;
}

            

                public function on($name, $handler, $data = null, $append = true)
{
    $this->ensureBehaviors();
    if (strpos($name, '*') !== false) {
        if ($append || empty($this->_eventWildcards[$name])) {
            $this->_eventWildcards[$name][] = [$handler, $data];
        } else {
            array_unshift($this->_eventWildcards[$name], [$handler, $data]);
        }
        return;
    }
    if ($append || empty($this->_events[$name])) {
        $this->_events[$name][] = [$handler, $data];
    } else {
        array_unshift($this->_events[$name], [$handler, $data]);
    }
}

            

                public function optionAliases()
{
    return [
        'h' => 'help',
    ];
}

            

                public function options($actionID)
{
    // $actionId might be used in subclasses to provide options specific to action id
    return ['color', 'interactive', 'help', 'silentExitOnException'];
}

            

                protected function parseDocCommentDetail($reflection)
{
    $comment = strtr(trim(preg_replace('/^\s*\**([ \t])?/m', '', trim($reflection->getDocComment(), '/'))), "\r", '');
    if (preg_match('/^\s*@\w+/m', $comment, $matches, PREG_OFFSET_CAPTURE)) {
        $comment = trim(substr($comment, 0, $matches[0][1]));
    }
    if ($comment !== '') {
        return rtrim(Console::renderColoredString(Console::markdownToAnsi($comment)));
    }
    return '';
}

            

                protected function parseDocCommentSummary($reflection)
{
    $docLines = preg_split('~\R~u', $reflection->getDocComment());
    if (isset($docLines[1])) {
        return trim($docLines[1], "\t *");
    }
    return '';
}

            

                protected function parseDocCommentTags($reflection)
{
    $comment = $reflection->getDocComment();
    $comment = "@description \n" . strtr(trim(preg_replace('/^\s*\**([ \t])?/m', '', trim($comment, '/'))), "\r", '');
    $parts = preg_split('/^\s*@/m', $comment, -1, PREG_SPLIT_NO_EMPTY);
    $tags = [];
    foreach ($parts as $part) {
        if (preg_match('/^(\w+)(.*)/ms', trim($part), $matches)) {
            $name = $matches[1];
            if (!isset($tags[$name])) {
                $tags[$name] = trim($matches[2]);
            } elseif (is_array($tags[$name])) {
                $tags[$name][] = trim($matches[2]);
            } else {
                $tags[$name] = [$tags[$name], trim($matches[2])];
            }
        }
    }
    return $tags;
}

            

                public function prompt($text, $options = [])
{
    if ($this->interactive) {
        return Console::prompt($text, $options);
    }
    return isset($options['default']) ? $options['default'] : '';
}

            

                public function render($view, $params = [])
{
    $content = $this->getView()->render($view, $params, $this);
    return $this->renderContent($content);
}

            

                public function renderContent($content)
{
    $layoutFile = $this->findLayoutFile($this->getView());
    if ($layoutFile !== false) {
        return $this->getView()->renderFile($layoutFile, ['content' => $content], $this);
    }
    return $content;
}

            

                public function renderFile($file, $params = [])
{
    return $this->getView()->renderFile($file, $params, $this);
}

            

                public function renderPartial($view, $params = [])
{
    return $this->getView()->render($view, $params, $this);
}

            

                public function run($route, $params = [])
{
    $pos = strpos($route, '/');
    if ($pos === false) {
        return $this->runAction($route, $params);
    } elseif ($pos > 0) {
        return $this->module->runAction($route, $params);
    }
    return Yii::$app->runAction(ltrim($route, '/'), $params);
}

            

                public function runAction($id, $params = [])
{
    if (!empty($params)) {
        // populate options here so that they are available in beforeAction().
        $options = $this->options($id === '' ? $this->defaultAction : $id);
        if (isset($params['_aliases'])) {
            $optionAliases = $this->optionAliases();
            foreach ($params['_aliases'] as $name => $value) {
                if (array_key_exists($name, $optionAliases)) {
                    $params[$optionAliases[$name]] = $value;
                } else {
                    $message = Yii::t('yii', 'Unknown alias: -{name}', ['name' => $name]);
                    if (!empty($optionAliases)) {
                        $aliasesAvailable = [];
                        foreach ($optionAliases as $alias => $option) {
                            $aliasesAvailable[] = '-' . $alias . ' (--' . $option . ')';
                        }
                        $message .= '. ' . Yii::t('yii', 'Aliases available: {aliases}', [
                            'aliases' => implode(', ', $aliasesAvailable)
                        ]);
                    }
                    throw new Exception($message);
                }
            }
            unset($params['_aliases']);
        }
        foreach ($params as $name => $value) {
            // Allow camelCase options to be entered in kebab-case
            if (!in_array($name, $options, true) && strpos($name, '-') !== false) {
                $kebabName = $name;
                $altName = lcfirst(Inflector::id2camel($kebabName));
                if (in_array($altName, $options, true)) {
                    $name = $altName;
                }
            }
            if (in_array($name, $options, true)) {
                $default = $this->$name;
                if (is_array($default) && is_string($value)) {
                    $this->$name = preg_split('/\s*,\s*(?![^()]*\))/', $value);
                } elseif ($default !== null) {
                    settype($value, gettype($default));
                    $this->$name = $value;
                } else {
                    $this->$name = $value;
                }
                $this->_passedOptions[] = $name;
                unset($params[$name]);
                if (isset($kebabName)) {
                    unset($params[$kebabName]);
                }
            } elseif (!is_int($name)) {
                $message = Yii::t('yii', 'Unknown option: --{name}', ['name' => $name]);
                if (!empty($options)) {
                    $message .= '. ' . Yii::t('yii', 'Options available: {options}', ['options' => '--' . implode(', --', $options)]);
                }
                throw new Exception($message);
            }
        }
    }
    if ($this->help) {
        $route = $this->getUniqueId() . '/' . $id;
        return Yii::$app->runAction('help', [$route]);
    }
    return parent::runAction($id, $params);
}

            

                public function select($prompt, $options = [], $default = null)
{
    if ($this->interactive) {
        return Console::select($prompt, $options, $default);
    }
    return $default;
}

            

                public function setView($view)
{
    $this->_view = $view;
}

            

                public function setViewPath($path)
{
    $this->_viewPath = Yii::getAlias($path);
}

            

                public function stderr($string)
{
    if ($this->isColorEnabled(\STDERR)) {
        $args = func_get_args();
        array_shift($args);
        $string = Console::ansiFormat($string, $args);
    }
    return fwrite(\STDERR, $string);
}

            

                public function stdout($string)
{
    if ($this->isColorEnabled()) {
        $args = func_get_args();
        array_shift($args);
        $string = Console::ansiFormat($string, $args);
    }
    return Console::stdout($string);
}

            

                public function trigger($name, Event $event = null)
{
    $this->ensureBehaviors();
    $eventHandlers = [];
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (StringHelper::matchWildcard($wildcard, $name)) {
            $eventHandlers[] = $handlers;
        }
    }
    if (!empty($this->_events[$name])) {
        $eventHandlers[] = $this->_events[$name];
    }
    if (!empty($eventHandlers)) {
        $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
        if ($event === null) {
            $event = new Event();
        }
        if ($event->sender === null) {
            $event->sender = $this;
        }
        $event->handled = false;
        $event->name = $name;
        foreach ($eventHandlers as $handler) {
            $event->data = $handler[1];
            call_user_func($handler[0], $event);
            // stop further handling if the event is handled
            if ($event->handled) {
                return;
            }
        }
    }
    // invoke class-level attached handlers
    Event::trigger($this, $name, $event);
}