/**
* @param string|mixed $class
*/
public function registerPlugins($class)
{
switch (true) {
case is_string($class):
$class = is_string($class) ? new $class() : $class;
case $class instanceof AbstractHelper:
$reflector = new \ReflectionClass($class);
$path = realpath(dirname($reflector->getFileName()));
$class = array();
foreach (scandir($path) as $file) {
if (strpos($file, '.php') !== FALSE && strpos($file, 'Abstract') === FALSE) {
$className = str_replace('.php', '', $file);
$class[lcfirst($className)] = $reflector->getNamespaceName() . '\\' . $className;
$p = strtolower(preg_replace("/([a-z])([A-Z])/", "\$1_\$2", $className));
$class[$p] = $reflector->getNamespaceName() . '\\' . $className;
}
}
break;
case is_array($class):
break;
default:
throw new \Exception('Invalid input for $class variable. Type must be string, Zend\\Form\\View\\Helper\\AbstractHelper or array.');
}
foreach ($class as $name => $invokableClass) {
$this->registerPlugin($name, $invokableClass);
}
return $this;
}
protected static function qualifiedClass(\ReflectionClass $class, $type)
{
if (substr($type, 0, 1) == '\\') {
return substr($type, 1);
}
$classNamespace = $class->getNamespaceName();
if (!($uses = self::$namespaceUses[$classNamespace])) {
$scriptContent = file_get_contents($class->getFileName());
$scriptContent = substr($scriptContent, strpos($scriptContent, 'namespace ' . $class->getNamespaceName()));
preg_match_all("/use\\s+([a-z]+(\\\\[a-z]+)*);/i", $scriptContent, $uses);
if (isset($uses[1])) {
$uses = $uses[1];
} else {
$uses = [];
}
$_temp = [];
foreach ($uses as $use) {
$parts = explode('\\', $use);
$className = end($parts);
$_temp[$className] = implode('\\', array_slice($parts, 0, -1));
}
$uses = $_temp;
self::$namespaceUses[$classNamespace] = $uses;
}
if (isset($uses[$type])) {
$classNamespace = $uses[$type];
}
return $classNamespace . '\\' . $type;
}
/**
* {@inheritdoc}
*/
public function toObjectValue($value, $type, \ReflectionProperty $property, $object)
{
$className = null;
$context = new \ReflectionClass($property->class);
//try to get the class from use statements in the class file
if ($className === null) {
$classContent = file_get_contents($context->getFileName());
$regExps = ["/use\\s+([\\w\\\\]+{$type});/", "/use\\s+([\\w\\\\]+)\\s+as\\s+{$type}/"];
foreach ($regExps as $regExp) {
if ($matchClass = $this->extractClass($regExp, $classContent)) {
$className = $matchClass;
break;
}
}
}
//use the same namespace as class container
if ($className === null && class_exists($context->getNamespaceName() . '\\' . $type)) {
$className = $context->getNamespaceName() . '\\' . $type;
}
//use the type as class
if (class_exists($type)) {
$className = $type;
}
if (is_array($value) && $className !== null && class_exists($className) && $this->array2Object) {
$property->setAccessible(true);
$currentValue = $property->getValue($object);
if (is_object($currentValue)) {
$this->array2Object->populate($currentValue, $value);
return $currentValue;
} else {
return $this->array2Object->createObject($className, $value);
}
}
return $value;
}
/**
* Generate Remote API from a list of controllers
*/
public function generateRemotingApi()
{
$list = array();
foreach ($this->remotingBundles as $bundle) {
$bundleRef = new \ReflectionClass($bundle);
$controllerDir = new Finder();
$controllerDir->files()->in(dirname($bundleRef->getFileName()) . '/Controller/')->name('/.*Controller\\.php$/');
foreach ($controllerDir as $controllerFile) {
/** @var SplFileInfo $controllerFile */
$controller = $bundleRef->getNamespaceName() . "\\Controller\\" . substr($controllerFile->getFilename(), 0, -4);
$controllerRef = new \ReflectionClass($controller);
foreach ($controllerRef->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
/** @var $methodDirectAnnotation Direct */
$methodDirectAnnotation = $this->annoReader->getMethodAnnotation($method, 'Tpg\\ExtjsBundle\\Annotation\\Direct');
if ($methodDirectAnnotation !== null) {
$nameSpace = str_replace("\\", ".", $bundleRef->getNamespaceName());
$className = str_replace("Controller", "", $controllerRef->getShortName());
$methodName = str_replace("Action", "", $method->getName());
$list[$nameSpace][$className][] = array('name' => $methodName, 'len' => count($method->getParameters()));
}
}
}
}
return $list;
}
/**
* @return string $classNamespace
*/
protected function getNamespace() : string
{
if (is_null($this->namespace)) {
$this->namespace = $this->reflection->getNamespaceName();
}
return $this->namespace;
}
/**
* @param Controller $controller
* @param null $entityClassName
* @return $this
*/
public function initialize(Controller $controller, $entityClassName = null)
{
$entityClassName = explode('\\', $entityClassName);
$this->entityClassName = $entityClassName[count($entityClassName) - 1];
$this->reflector = new \ReflectionClass($controller);
$this->namespace = explode('\\', $this->reflector->getNamespaceName());
$key = array_search('__CG__', $this->namespace);
//if the controller come from jms aop bundle
if ($key) {
for ($i = $key; $i >= 0; $i--) {
unset($this->namespace[$i]);
}
}
$this->namespace = array_values($this->namespace);
$key = array_search('Controller', $this->namespace);
$lastValue = $this->namespace[count($this->namespace) - 1];
//May be you have nested controller
if ('Controller' !== $lastValue) {
$this->exclude = $lastValue;
}
for ($i = $key; $i <= count($this->namespace); $i++) {
array_pop($this->namespace);
}
return $this;
}
/**
* Recursively brings value to type
* @param $parent
* @param $type
* @param $value
* @param bool $isNullable
* @param array $restrictions
* @throws Exception
* @return mixed
*/
public static function bringValueToType($parent, $type, $value, $isNullable = false, $restrictions = [])
{
if ($isNullable && null === $value || empty($type)) {
return $value;
}
$typeParts = explode("[]", $type);
$singleType = current($typeParts);
if (count($typeParts) > 2) {
throw new Exception(sprintf("In %s type '{$type}' is invalid", get_class($parent)), Exception::INTERNAL_ERROR);
}
//for array type
if (count($typeParts) === 2) {
if (!is_array($value)) {
if ($parent instanceof \JsonRpc2\Dto) {
throw new Exception(sprintf("In %s value has type %s, but array expected", get_class($parent), gettype($value)), Exception::INTERNAL_ERROR);
} else {
throw new Exception("Value has type %s, but array expected", gettype($value), Exception::INTERNAL_ERROR);
}
}
foreach ($value as $key => $childValue) {
$value[$key] = self::bringValueToType($parent, $singleType, $childValue, $isNullable);
}
return $value;
}
$class = new \ReflectionClass($parent);
if (0 !== strpos($type, "\\") && class_exists($class->getNamespaceName() . "\\" . $type)) {
$type = $class->getNamespaceName() . "\\" . $type;
}
if (class_exists($type)) {
if (!is_subclass_of($type, '\\JsonRpc2\\Dto')) {
throw new Exception(sprintf("In %s class '%s' MUST be instance of '\\JsonRpc2\\Dto'", get_class($parent), $type), Exception::INTERNAL_ERROR);
}
return new $type($value);
} else {
switch ($type) {
case "string":
$value = (string) $value;
self::restrictValue($parent, $type, $value, $restrictions);
return $value;
break;
case "int":
$value = (int) $value;
self::restrictValue($parent, $type, $value, $restrictions);
return $value;
break;
case "float":
$value = (double) $value;
self::restrictValue($parent, $type, $value, $restrictions);
return $value;
break;
case "array":
throw new Exception("Parameter type 'array' is deprecated. Use square brackets with simply types or DTO based classes instead.", Exception::INTERNAL_ERROR);
case "bool":
return (bool) $value;
break;
}
}
return $value;
}
/**
*
*/
public function getXmlNamespace()
{
$namespace = $this->_parseAnnotation($this->reflection->getDocComment(), 'xmlNamespace');
if (!$namespace && $this->configuration) {
$namespace = $this->configuration->getXmlNamespace($this->reflection->getNamespaceName());
}
return $namespace;
}
/**
* Initializes a new ClassMetadata instance that will hold the object-relational mapping
* metadata of the class with the given name.
*
* @param string $entityName The name of the entity class the new instance is used for.
*/
public function __construct($entityName)
{
$this->name = $entityName;
$this->reflClass = new \ReflectionClass($entityName);
$this->namespace = $this->reflClass->getNamespaceName();
$this->primaryTable['name'] = $this->reflClass->getShortName();
$this->rootEntityName = $entityName;
}
public function __construct(\ReflectionClass $intf)
{
$this->intf = $intf;
$classParser = new PhpParser();
$uses = array_merge($classParser->parseClass($this->intf), [$this->intf->getNamespaceName()]);
$this->reader = new AnnotationReader($this->intf);
$this->converter = new AnnotationConverter($uses);
}
public function initialize()
{
$ref = new \ReflectionClass($this);
$namespace = str_replace(basename($ref->getNamespaceName()), '', $ref->getNamespaceName());
$this->moduleInstance = $this->getDI()->get($namespace . 'Module');
$this->modelName = strtolower(basename($ref->name));
$this->setSource(TH_DB_PREFIX . $this->modelName);
$this->onInitialize();
}
static function widget_name()
{
$function_name = 'widget_';
$r = new \ReflectionClass(get_called_class());
$function_name .= Str::snake(str_replace('Widget', '', $r->getShortName()));
if ('Larakit\\Widget' != $r->getNamespaceName()) {
$function_name .= '__' . Str::snake(str_replace(['\\', 'Widget'], '', $r->getNamespaceName()));
}
return $function_name;
}
private function generateClassName()
{
$shortName = $this->reflection->getShortName();
$fullName = $this->reflection->getNamespaceName() . "\\{$shortName}Mock";
$counter = 1;
while (class_exists($fullName . $counter)) {
$counter++;
}
return ["{$shortName}Mock{$counter}", $fullName . $counter];
}
/**
* Creates the factory for this concrete product.
* If the class does not exists yet, it is generated on the fly.
*
* The factory implements an interface named after the short name of the
* product class name with the suffix "Factory". The namespace is the
* same namespace as the product classname.
*
* The concrete factory is not of your concern, that's the trick of
* factory method. That's why I put a random number after the classname
* of the concrete factory : do not use that name !
*
* @param string $fqcnProduct
*
* @return object the the new factory
*/
public function getFactory($fqcnProduct)
{
$refl = new \ReflectionClass($fqcnProduct);
$fmName = 'Concrete' . $refl->getShortName() . 'Factory' . crc32($fqcnProduct);
$fqcnFM = $refl->getNamespaceName() . '\\' . $fmName;
if (!class_exists($fqcnFM)) {
eval($this->generate($refl->getNamespaceName(), $refl->getShortName() . 'Factory', $fmName, $refl->getName()));
}
return new $fqcnFM();
}
public function initialize()
{
$ref = new \ReflectionClass($this);
$namespace = str_replace(basename($ref->getNamespaceName()), '', $ref->getNamespaceName());
$this->moduleInstance = $this->getDI()->get($namespace . 'Module');
$this->tag->setTitleSeparator(' - ');
$this->tag->setTitle('thunderhawk');
$this->onInitialize();
$this->onPrepareAssets();
$this->onPrepareThemeAssets();
}
/**
* Parses a class.
*
* @param \ReflectionClass $class A <code>ReflectionClass</code> object.
* @return array A list with use statements in the form (Alias => FQN).
*/
public function parseClass(\ReflectionClass $class)
{
if (false === ($filename = $class->getFilename())) {
return array();
}
$content = $this->getFileContent($filename, $class->getStartLine());
$namespace = str_replace('\\', '\\\\', $class->getNamespaceName());
$content = preg_replace('/^.*?(\\bnamespace\\s+' . $namespace . '\\s*[;{].*)$/s', '\\1', $content);
$this->tokens = token_get_all('<?php ' . $content);
$this->numTokens = count($this->tokens);
$this->pointer = 0;
$statements = $this->parseUseStatements($class->getNamespaceName());
return $statements;
}
/**
* @return array A list with use statements in the form (Alias => FQN).
*/
public function parseUseStatements(\ReflectionClass $class)
{
if (false === ($filename = $class->getFilename())) {
return array();
}
$content = $this->getFileContent($filename, $class->getStartLine());
if (null === $content) {
return array();
}
$namespace = preg_quote($class->getNamespaceName());
$content = preg_replace('/^.*?(\\bnamespace\\s+' . $namespace . '\\s*[;{].*)$/s', '\\1', $content);
$tokenizer = new TokenParser('<?php ' . $content);
$statements = $tokenizer->parseUseStatements($class->getNamespaceName());
return $statements;
}
/**
* @param \ReflectionClass|string
* @return self
*/
public static function from($from)
{
$from = new \ReflectionClass($from instanceof \ReflectionClass ? $from->getName() : $from);
if (PHP_VERSION_ID >= 70000 && $from->isAnonymous()) {
$class = new static('anonymous');
} else {
$class = new static($from->getShortName(), new PhpNamespace($from->getNamespaceName()));
}
$class->type = $from->isInterface() ? 'interface' : (PHP_VERSION_ID >= 50400 && $from->isTrait() ? 'trait' : 'class');
$class->final = $from->isFinal() && $class->type === 'class';
$class->abstract = $from->isAbstract() && $class->type === 'class';
$class->implements = $from->getInterfaceNames();
$class->documents = $from->getDocComment() ? array(preg_replace('#^\\s*\\* ?#m', '', trim($from->getDocComment(), "/* \r\n\t"))) : array();
if ($from->getParentClass()) {
$class->extends = $from->getParentClass()->getName();
$class->implements = array_diff($class->implements, $from->getParentClass()->getInterfaceNames());
}
foreach ($from->getProperties() as $prop) {
if ($prop->getDeclaringClass()->getName() === $from->getName()) {
$class->properties[$prop->getName()] = Property::from($prop);
}
}
foreach ($from->getMethods() as $method) {
if ($method->getDeclaringClass()->getName() === $from->getName()) {
$class->methods[$method->getName()] = Method::from($method)->setNamespace($class->namespace);
}
}
return $class;
}
protected function registerMetadataDirectories(ContainerBuilder $container, array $config)
{
$bundles = $container->getParameter('kernel.bundles');
// directories
$directories = array();
if ($config['metadata']['auto_detection']) {
foreach ($bundles as $class) {
$ref = new \ReflectionClass($class);
$directory = dirname($ref->getFileName()) . '/Resources/config/vich_uploader';
if (!is_dir($directory)) {
continue;
}
$directories[$ref->getNamespaceName()] = $directory;
}
}
foreach ($config['metadata']['directories'] as $directory) {
$directory['path'] = rtrim(str_replace('\\', '/', $directory['path']), '/');
if ('@' === $directory['path'][0]) {
$bundleName = substr($directory['path'], 1, strpos($directory['path'], '/') - 1);
if (!isset($bundles[$bundleName])) {
throw new \RuntimeException(sprintf('The bundle "%s" has not been registered with AppKernel. Available bundles: %s', $bundleName, implode(', ', array_keys($bundles))));
}
$ref = new \ReflectionClass($bundles[$bundleName]);
$directory['path'] = dirname($ref->getFileName()) . substr($directory['path'], strlen('@' . $bundleName));
}
$directories[rtrim($directory['namespace_prefix'], '\\')] = rtrim($directory['path'], '\\/');
}
$container->getDefinition('vich_uploader.metadata.file_locator')->replaceArgument(0, $directories);
}
/**
* @return INamespaceReflection
*/
public function getNamespaceReflection()
{
if ($this->namespaceReflection === null) {
$this->namespaceReflection = $this->getSourceReflection()->getNamespaceReflection($this->reflectionClass->getNamespaceName());
}
return $this->namespaceReflection;
}
/**
* Check for added admin menu's
*/
public function __construct()
{
// Get loaded providers
$providers = array_keys(\App::getLoadedProviders());
// Get Tdt matches, but not core
$packages = preg_grep('/^Tdt[\\\\](?!Core)/i', $providers);
$menu = $this->core_menu;
// Check for UI controller
foreach ($packages as $package) {
// Get package namespace
$reflector = new \ReflectionClass($package);
$namespace = $reflector->getNamespaceName();
// Check for a UI controller
$controller = $namespace . "\\Ui\\UiController";
if (class_exists($controller)) {
// Create controller instance
$controller = \App::make($controller);
$package_menu = @$controller->menu();
// Check for added menu items
if (!empty($package_menu)) {
$menu = array_merge($menu, $package_menu);
}
// Push for future use
array_push($this->package_controllers, $controller);
}
}
// Sort menu's
usort($menu, function ($a, $b) {
return $a['priority'] - $b['priority'];
});
// Share menu with views
\View::share('menu', $menu);
}
/**
* @return Router
*/
protected function createBoxRouter()
{
$class = new \ReflectionClass($this);
$namespace = $class->getNamespaceName();
$directory = dirname($class->getFileName());
return new WebRouter($this->factory, $directory, $namespace);
}
/**
* Attempts to read the uploadable annotation.
*
* @param \ReflectionClass $class The reflection class.
* @return null|\Iphp\FileStoreBundle\Annotation\Uploadable The annotation.
*/
public function readUploadable(\ReflectionClass $class)
{
$baseClassName = $className = $class->getNamespaceName() . '\\' . $class->getName();
do {
if (isset($this->uploadedClass[$className])) {
if ($baseClassName != $className) {
$this->uploadedClass[$baseClassName] = $this->uploadedClass[$className];
}
return $this->uploadedClass[$baseClassName];
}
$annotation = $this->reader->getClassAnnotation($class, 'Iphp\\FileStoreBundle\\Mapping\\Annotation\\Uploadable');
if ($annotation) {
$this->uploadedClass[$baseClassName] = $annotation;
if ($baseClassName != $className) {
$this->uploadedClass[$className] = $annotation;
}
return $annotation;
}
$class = $class->getParentClass();
if ($class) {
$className = $class->getNamespaceName() . '\\' . $class->getName();
}
} while ($class);
return $annotation;
}
/**
* Init
* This method must return self
* @return self
*/
public function init()
{
parent::init();
$reflector = new \ReflectionClass($this);
$this->_applicationNamespace = $reflector->getNamespaceName();
//Define BASE Asset paths
$assetConfig = $this->config()->get("assets");
$assetPath = $assetConfig->get("assets", "assets");
if (!defined("BASE_ASSETS")) {
define("BASE_ASSETS", Router::buildPath(SITE_URL, $assetPath));
}
if (!defined("BASE_IMAGES")) {
define("BASE_IMAGES", Router::buildPath(SITE_URL, $assetPath, $assetConfig->get("images", "images")));
}
if (!defined("BASE_STYLES")) {
define("BASE_STYLES", Router::buildPath(SITE_URL, $assetPath, $assetConfig->get("css", "css")));
}
if (!defined("BASE_SCRIPTS")) {
define("BASE_SCRIPTS", Router::buildPath(SITE_URL, $assetPath, $assetConfig->get("js", "js")));
}
if (!defined("BASE_TEMPLATES")) {
define("BASE_TEMPLATES", Filesystem::buildPath(PROJECT_PATH, $assetConfig->get("templates", "Templates")));
}
return $this;
}
private function getExpectedTableClasses()
{
$tablesReflection = new \ReflectionClass(Tables::class);
$rootDir = dirname($tablesReflection->getFileName());
$rootNamespace = $tablesReflection->getNamespaceName();
return $this->scanForTables($rootDir, $rootNamespace);
}
/**
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
$bundles = $container->getParameter('kernel.bundles');
$reader = $container->get('annotation_reader');
$registry = $container->getDefinition('lemon_rest.object_registry');
foreach ($bundles as $name => $bundle) {
$reflection = new \ReflectionClass($bundle);
$baseNamespace = $reflection->getNamespaceName() . '\\Entity\\';
$dir = dirname($reflection->getFileName()) . '/Entity';
if (is_dir($dir)) {
$finder = new Finder();
$iterator = $finder->files()->name('*.php')->in($dir);
/** @var SplFileInfo $file */
foreach ($iterator as $file) {
// Translate the directory path from our starting namespace forward
$expandedNamespace = substr($file->getPath(), strlen($dir) + 1);
// If we are in a sub namespace add a trailing separation
$expandedNamespace = $expandedNamespace === false ? '' : $expandedNamespace . '\\';
$className = $baseNamespace . $expandedNamespace . $file->getBasename('.php');
if (class_exists($className)) {
$reflectionClass = new \ReflectionClass($className);
foreach ($reader->getClassAnnotations($reflectionClass) as $annotation) {
if ($annotation instanceof Resource) {
$name = $annotation->name ?: Inflector::pluralize(lcfirst($reflectionClass->getShortName()));
$definition = new Definition('Lemon\\RestBundle\\Object\\Definition', array($name, $className, $annotation->search, $annotation->create, $annotation->update, $annotation->delete, $annotation->partialUpdate));
$container->setDefinition('lemon_rest.object_resources.' . $name, $definition);
$registry->addMethodCall('add', array($definition));
}
}
}
}
}
}
}
public function parse($symfonyControllerName)
{
if (isset($this->cache[$symfonyControllerName])) {
return $this->cache[$symfonyControllerName];
}
// skip controllers as services
if (strpos($symfonyControllerName, ".") !== false) {
return array();
}
if (substr_count($symfonyControllerName, "::") == 1) {
$details = array();
list($controllerName, $actionName) = explode("::", $symfonyControllerName);
$details['action'] = str_replace("Action", "", $actionName);
$controllerRefl = new \ReflectionClass($controllerName);
$details['controller'] = str_replace("Controller", "", $controllerRefl->getShortName());
$controllerNamespace = $controllerRefl->getNamespaceName();
foreach ($this->kernel->getBundles() as $bundle) {
if (strpos($controllerNamespace, $bundle->getNamespace()) === 0) {
$details['module'] = str_replace("Bundle", "", $bundle->getName());
break;
}
}
} else {
list($module, $controller, $action) = explode(":", $symfonyControllerName);
$details['action'] = $action;
$details['controller'] = $controller;
$details['module'] = str_replace("Bundle", "", $module);
}
return $this->cache[$symfonyControllerName] = $details;
}
protected static function mockImpl($type_, array $args_ = [])
{
$type = new \ReflectionClass($type_);
if ($type->isFinal()) {
throw new Exception_IllegalArgument('mock/factory', 'Can not mock final class.');
}
$mtime = @filemtime($type->getFileName());
$classMock = 'Mock_' . str_replace('\\', '_', $type->getNamespaceName()) . '_' . $type->getShortName() . "_{$mtime}";
if (false === @class_exists($classMock)) {
if (null === self::$m_tmpPath) {
self::$m_tmpPath = (string) Test_Runner::get()->getTempPath();
}
$fileName = self::$m_tmpPath . "/{$classMock}.php";
if (false === @file_exists($fileName)) {
$source = self::weaveMock($classMock, new \ReflectionClass('Components\\Mock'), $type);
if (false === @file_put_contents($fileName, $source, 0644)) {
throw new Exception_IllegalState('mock/factory', sprintf('Unable to create mock [type: %1$s, path: %2$s].', $type_, $fileName));
}
}
require_once $fileName;
}
$classMock = "Components\\{$classMock}";
if (0 < count($args_)) {
$refl = new \ReflectionClass($classMock);
$mock = $refl->newInstanceArgs($args_);
} else {
$mock = new $classMock();
}
$mock->mockType = $type;
return $mock;
}
protected function detectModuleName()
{
$refl = new \ReflectionClass($this);
$namespace = $refl->getNamespaceName();
$namespace = ltrim($namespace, '\\');
return false === strpos($namespace, 'Settings\\') ? substr($namespace, 0, strpos($namespace, '\\')) : null;
}
private function _getParsedRoutes($target)
{
$route_name = null;
$uses = [];
if (is_string($target)) {
$uses = explode('@', $target);
} elseif (is_array($target)) {
$route_name = @$target['as'] ?: null;
if (isset($target['uses'])) {
$uses = explode('@', $target['uses']);
}
}
# - get the default namespace from the dispatcher
$default_namespace = $this->getDI()->get('dispatcher')->getDefaultNamespace() . '\\';
# - if the uses is not empty, we should get the class properties
# such as namespace, class short name
if (!empty($uses)) {
$reflection = new \ReflectionClass($default_namespace . $uses[0]);
# - let's get the reflected class namespace
$namespace = $reflection->getNamespaceName();
# - this strips out all the word 'Controller'
# and then getting the reflected class short name
$controller = str_replace('Controller', '', $reflection->getShortName());
# - get the action based on the index[1]
$action = $uses[1];
$target = ['controller' => $controller, 'action' => $action];
if ($namespace) {
$target['namespace'] = $namespace;
}
}
return ['target' => $target, 'name' => $route_name];
}
