Class yii\console\controllers\MigrateController

                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 actionCreate($name)
{
    if (!preg_match('/^[\w\\\\]+$/', $name)) {
        throw new Exception('The migration name should contain letters, digits, underscore and/or backslash characters only.');
    }
    list($namespace, $className) = $this->generateClassName($name);
    // Abort if name is too long
    $nameLimit = $this->getMigrationNameLimit();
    if ($nameLimit !== null && strlen($className) > $nameLimit) {
        throw new Exception('The migration name is too long.');
    }
    $migrationPath = $this->findMigrationPath($namespace);
    $file = $migrationPath . DIRECTORY_SEPARATOR . $className . '.php';
    if ($this->confirm("Create new migration '$file'?")) {
        $content = $this->generateMigrationSourceCode([
            'name' => $name,
            'className' => $className,
            'namespace' => $namespace,
        ]);
        FileHelper::createDirectory($migrationPath);
        if (file_put_contents($file, $content, LOCK_EX) === false) {
            $this->stdout("Failed to create new migration.\n", Console::FG_RED);
            return ExitCode::IOERR;
        }
        FileHelper::changeOwnership($file, $this->newFileOwnership, $this->newFileMode);
        $this->stdout("New migration created successfully.\n", Console::FG_GREEN);
    }
    return ExitCode::OK;
}

            

                public function actionDown($limit = 1)
{
    if ($limit === 'all') {
        $limit = null;
    } else {
        $limit = (int) $limit;
        if ($limit < 1) {
            throw new Exception('The step argument must be greater than 0.');
        }
    }
    $migrations = $this->getMigrationHistory($limit);
    if (empty($migrations)) {
        $this->stdout("No migration has been done before.\n", Console::FG_YELLOW);
        return ExitCode::OK;
    }
    $migrations = array_keys($migrations);
    $n = count($migrations);
    $this->stdout("Total $n " . ($n === 1 ? 'migration' : 'migrations') . " to be reverted:\n", Console::FG_YELLOW);
    foreach ($migrations as $migration) {
        $this->stdout("\t$migration\n");
    }
    $this->stdout("\n");
    $reverted = 0;
    if ($this->confirm('Revert the above ' . ($n === 1 ? 'migration' : 'migrations') . '?')) {
        foreach ($migrations as $migration) {
            if (!$this->migrateDown($migration)) {
                $this->stdout("\n$reverted from $n " . ($reverted === 1 ? 'migration was' : 'migrations were') . " reverted.\n", Console::FG_RED);
                $this->stdout("\nMigration failed. The rest of the migrations are canceled.\n", Console::FG_RED);
                return ExitCode::UNSPECIFIED_ERROR;
            }
            $reverted++;
        }
        $this->stdout("\n$n " . ($n === 1 ? 'migration was' : 'migrations were') . " reverted.\n", Console::FG_GREEN);
        $this->stdout("\nMigrated down successfully.\n", Console::FG_GREEN);
    }
    return ExitCode::OK;
}

            

                public function actionFresh()
{
    if (YII_ENV_PROD) {
        $this->stdout("YII_ENV is set to 'prod'.\nRefreshing migrations is not possible on production systems.\n");
        return ExitCode::OK;
    }
    if ($this->confirm("Are you sure you want to drop all tables and related constraints and start the migration from the beginning?\nAll data will be lost irreversibly!")) {
        $this->truncateDatabase();
        return $this->actionUp();
    }
    $this->stdout('Action was cancelled by user. Nothing has been performed.');
    return ExitCode::OK;
}

            

                public function actionHistory($limit = 10)
{
    if ($limit === 'all') {
        $limit = null;
    } else {
        $limit = (int) $limit;
        if ($limit < 1) {
            throw new Exception('The limit must be greater than 0.');
        }
    }
    $migrations = $this->getMigrationHistory($limit);
    if (empty($migrations)) {
        $this->stdout("No migration has been done before.\n", Console::FG_YELLOW);
    } else {
        $n = count($migrations);
        if ($limit > 0) {
            $this->stdout("Showing the last $n applied " . ($n === 1 ? 'migration' : 'migrations') . ":\n", Console::FG_YELLOW);
        } else {
            $this->stdout("Total $n " . ($n === 1 ? 'migration has' : 'migrations have') . " been applied before:\n", Console::FG_YELLOW);
        }
        foreach ($migrations as $version => $time) {
            $this->stdout("\t(" . date('Y-m-d H:i:s', $time) . ') ' . $version . "\n");
        }
    }
    return ExitCode::OK;
}

            

                public function actionMark($version)
{
    $originalVersion = $version;
    if (($namespaceVersion = $this->extractNamespaceMigrationVersion($version)) !== false) {
        $version = $namespaceVersion;
    } elseif (($migrationName = $this->extractMigrationVersion($version)) !== false) {
        $version = $migrationName;
    } elseif ($version !== static::BASE_MIGRATION) {
        throw new Exception("The version argument must be either a timestamp (e.g. 101129_185401)\nor the full name of a migration (e.g. m101129_185401_create_user_table)\nor the full name of a namespaced migration (e.g. app\\migrations\\M101129185401CreateUserTable).");
    }
    // try mark up
    $migrations = $this->getNewMigrations();
    foreach ($migrations as $i => $migration) {
        if (strpos($migration, $version) === 0) {
            if ($this->confirm("Set migration history at $originalVersion?")) {
                for ($j = 0; $j <= $i; ++$j) {
                    $this->addMigrationHistory($migrations[$j]);
                }
                $this->stdout("The migration history is set at $originalVersion.\nNo actual migration was performed.\n", Console::FG_GREEN);
            }
            return ExitCode::OK;
        }
    }
    // try mark down
    $migrations = array_keys($this->getMigrationHistory(null));
    $migrations[] = static::BASE_MIGRATION;
    foreach ($migrations as $i => $migration) {
        if (strpos($migration, $version) === 0) {
            if ($i === 0) {
                $this->stdout("Already at '$originalVersion'. Nothing needs to be done.\n", Console::FG_YELLOW);
            } elseif ($this->confirm("Set migration history at $originalVersion?")) {
                for ($j = 0; $j < $i; ++$j) {
                    $this->removeMigrationHistory($migrations[$j]);
                }
                $this->stdout("The migration history is set at $originalVersion.\nNo actual migration was performed.\n", Console::FG_GREEN);
            }
            return ExitCode::OK;
        }
    }
    throw new Exception("Unable to find the version '$originalVersion'.");
}

            

                public function actionNew($limit = 10)
{
    if ($limit !== 'all') {
        $limit = (int) $limit;
        if ($limit < 1) {
            throw new Exception('The limit must be greater than 0.');
        }
    }
    $migrations = $this->getNewMigrations();
    if (empty($migrations)) {
        $this->stdout("No new migrations found. Your system is up-to-date.\n", Console::FG_GREEN);
    } else {
        $n = count($migrations);
        if ($limit !== 'all' && $n > $limit) {
            $migrations = array_slice($migrations, 0, $limit);
            $this->stdout("Showing $limit out of $n new " . ($n === 1 ? 'migration' : 'migrations') . ":\n", Console::FG_YELLOW);
        } else {
            $this->stdout("Found $n new " . ($n === 1 ? 'migration' : 'migrations') . ":\n", Console::FG_YELLOW);
        }
        foreach ($migrations as $migration) {
            $this->stdout("\t" . $migration . "\n");
        }
    }
    return ExitCode::OK;
}

            

                public function actionRedo($limit = 1)
{
    if ($limit === 'all') {
        $limit = null;
    } else {
        $limit = (int) $limit;
        if ($limit < 1) {
            throw new Exception('The step argument must be greater than 0.');
        }
    }
    $migrations = $this->getMigrationHistory($limit);
    if (empty($migrations)) {
        $this->stdout("No migration has been done before.\n", Console::FG_YELLOW);
        return ExitCode::OK;
    }
    $migrations = array_keys($migrations);
    $n = count($migrations);
    $this->stdout("Total $n " . ($n === 1 ? 'migration' : 'migrations') . " to be redone:\n", Console::FG_YELLOW);
    foreach ($migrations as $migration) {
        $this->stdout("\t$migration\n");
    }
    $this->stdout("\n");
    if ($this->confirm('Redo the above ' . ($n === 1 ? 'migration' : 'migrations') . '?')) {
        foreach ($migrations as $migration) {
            if (!$this->migrateDown($migration)) {
                $this->stdout("\nMigration failed. The rest of the migrations are canceled.\n", Console::FG_RED);
                return ExitCode::UNSPECIFIED_ERROR;
            }
        }
        foreach (array_reverse($migrations) as $migration) {
            if (!$this->migrateUp($migration)) {
                $this->stdout("\nMigration failed. The rest of the migrations are canceled.\n", Console::FG_RED);
                return ExitCode::UNSPECIFIED_ERROR;
            }
        }
        $this->stdout("\n$n " . ($n === 1 ? 'migration was' : 'migrations were') . " redone.\n", Console::FG_GREEN);
        $this->stdout("\nMigration redone successfully.\n", Console::FG_GREEN);
    }
    return ExitCode::OK;
}

            

                public function actionTo($version)
{
    if (($namespaceVersion = $this->extractNamespaceMigrationVersion($version)) !== false) {
        return $this->migrateToVersion($namespaceVersion);
    } elseif (($migrationName = $this->extractMigrationVersion($version)) !== false) {
        return $this->migrateToVersion($migrationName);
    } elseif ((string) (int) $version == $version) {
        return $this->migrateToTime($version);
    } elseif (($time = strtotime($version)) !== false) {
        return $this->migrateToTime($time);
    } else {
        throw new Exception("The version argument must be either a timestamp (e.g. 101129_185401),\n the full name of a migration (e.g. m101129_185401_create_user_table),\n the full namespaced name of a migration (e.g. app\\migrations\\M101129185401CreateUserTable),\n a UNIX timestamp (e.g. 1392853000), or a datetime string parseable\nby the strtotime() function (e.g. 2014-02-15 13:00:50).");
    }
}

            

                public function actionUp($limit = 0)
{
    $migrations = $this->getNewMigrations();
    if (empty($migrations)) {
        $this->stdout("No new migrations found. Your system is up-to-date.\n", Console::FG_GREEN);
        return ExitCode::OK;
    }
    $total = count($migrations);
    $limit = (int) $limit;
    if ($limit > 0) {
        $migrations = array_slice($migrations, 0, $limit);
    }
    $n = count($migrations);
    if ($n === $total) {
        $this->stdout("Total $n new " . ($n === 1 ? 'migration' : 'migrations') . " to be applied:\n", Console::FG_YELLOW);
    } else {
        $this->stdout("Total $n out of $total new " . ($total === 1 ? 'migration' : 'migrations') . " to be applied:\n", Console::FG_YELLOW);
    }
    foreach ($migrations as $migration) {
        $nameLimit = $this->getMigrationNameLimit();
        if ($nameLimit !== null && strlen($migration) > $nameLimit) {
            $this->stdout("\nThe migration name '$migration' is too long. Its not possible to apply this migration.\n", Console::FG_RED);
            return ExitCode::UNSPECIFIED_ERROR;
        }
        $this->stdout("\t$migration\n");
    }
    $this->stdout("\n");
    $applied = 0;
    if ($this->confirm('Apply the above ' . ($n === 1 ? 'migration' : 'migrations') . '?')) {
        foreach ($migrations as $migration) {
            if (!$this->migrateUp($migration)) {
                $this->stdout("\n$applied from $n " . ($applied === 1 ? 'migration was' : 'migrations were') . " applied.\n", Console::FG_RED);
                $this->stdout("\nMigration failed. The rest of the migrations are canceled.\n", Console::FG_RED);
                return ExitCode::UNSPECIFIED_ERROR;
            }
            $applied++;
        }
        $this->stdout("\n$n " . ($n === 1 ? 'migration was' : 'migrations were') . " applied.\n", Console::FG_GREEN);
        $this->stdout("\nMigrated up successfully.\n", Console::FG_GREEN);
    }
    return ExitCode::OK;
}

            

                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 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;
}

            

                protected function getNewMigrations()
{
    $applied = [];
    foreach ($this->getMigrationHistory(null) as $class => $time) {
        $applied[trim($class, '\\')] = true;
    }
    $migrationPaths = [];
    if (is_array($this->migrationPath)) {
        foreach ($this->migrationPath as $path) {
            $migrationPaths[] = [$path, ''];
        }
    } elseif (!empty($this->migrationPath)) {
        $migrationPaths[] = [$this->migrationPath, ''];
    }
    foreach ($this->migrationNamespaces as $namespace) {
        $migrationPaths[] = [$this->getNamespacePath($namespace), $namespace];
    }
    $migrations = [];
    foreach ($migrationPaths as $item) {
        list($migrationPath, $namespace) = $item;
        if (!file_exists($migrationPath)) {
            continue;
        }
        $handle = opendir($migrationPath);
        while (($file = readdir($handle)) !== false) {
            if ($file === '.' || $file === '..') {
                continue;
            }
            $path = $migrationPath . DIRECTORY_SEPARATOR . $file;
            if (preg_match('/^(m(\d{6}_?\d{6})\D.*?)\.php$/is', $file, $matches) && is_file($path)) {
                $class = $matches[1];
                if (!empty($namespace)) {
                    $class = $namespace . '\\' . $class;
                }
                $time = str_replace('_', '', $matches[2]);
                if (!isset($applied[$class])) {
                    $migrations[$time . '\\' . $class] = $class;
                }
            }
        }
        closedir($handle);
    }
    ksort($migrations);
    return array_values($migrations);
}

            

                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);
}

            

                protected function includeMigrationFile($class)
{
    $class = trim($class, '\\');
    if (strpos($class, '\\') === false) {
        if (is_array($this->migrationPath)) {
            foreach ($this->migrationPath as $path) {
                $file = $path . DIRECTORY_SEPARATOR . $class . '.php';
                if (is_file($file)) {
                    require_once $file;
                    break;
                }
            }
        } else {
            $file = $this->migrationPath . DIRECTORY_SEPARATOR . $class . '.php';
            require_once $file;
        }
    }
}

            

                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;
}

            

                protected function migrateDown($class)
{
    if ($class === self::BASE_MIGRATION) {
        return true;
    }
    $this->stdout("*** reverting $class\n", Console::FG_YELLOW);
    $start = microtime(true);
    $migration = $this->createMigration($class);
    if ($migration->down() !== false) {
        $this->removeMigrationHistory($class);
        $time = microtime(true) - $start;
        $this->stdout("*** reverted $class (time: " . sprintf('%.3f', $time) . "s)\n\n", Console::FG_GREEN);
        return true;
    }
    $time = microtime(true) - $start;
    $this->stdout("*** failed to revert $class (time: " . sprintf('%.3f', $time) . "s)\n\n", Console::FG_RED);
    return false;
}

            

                protected function migrateToTime($time)
{
    $count = 0;
    $migrations = array_values($this->getMigrationHistory(null));
    while ($count < count($migrations) && $migrations[$count] > $time) {
        ++$count;
    }
    if ($count === 0) {
        $this->stdout("Nothing needs to be done.\n", Console::FG_GREEN);
    } else {
        return $this->actionDown($count);
    }
    return ExitCode::OK;
}

            

                protected function migrateToVersion($version)
{
    $originalVersion = $version;
    // try migrate up
    $migrations = $this->getNewMigrations();
    foreach ($migrations as $i => $migration) {
        if (strpos($migration, $version) === 0) {
            return $this->actionUp($i + 1);
        }
    }
    // try migrate down
    $migrations = array_keys($this->getMigrationHistory(null));
    foreach ($migrations as $i => $migration) {
        if (strpos($migration, $version) === 0) {
            if ($i === 0) {
                $this->stdout("Already at '$originalVersion'. Nothing needs to be done.\n", Console::FG_YELLOW);
            } else {
                return $this->actionDown($i);
            }
            return ExitCode::OK;
        }
    }
    throw new Exception("Unable to find the version '$originalVersion'.");
}

            

                protected function migrateUp($class)
{
    if ($class === self::BASE_MIGRATION) {
        return true;
    }
    $this->stdout("*** applying $class\n", Console::FG_YELLOW);
    $start = microtime(true);
    $migration = $this->createMigration($class);
    if ($migration->up() !== false) {
        $this->addMigrationHistory($class);
        $time = microtime(true) - $start;
        $this->stdout("*** applied $class (time: " . sprintf('%.3f', $time) . "s)\n\n", Console::FG_GREEN);
        return true;
    }
    $time = microtime(true) - $start;
    $this->stdout("*** failed to apply $class (time: " . sprintf('%.3f', $time) . "s)\n\n", Console::FG_RED);
    return false;
}

            

                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]);
    }
}

            

                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);
}