resolvePaths method.

@todo

@return array
183949
protected function getResolvedPaths()
    {
        if (null === $this->resolvedPaths) {
            $this->resolveDirectories();
            // Collect all path properties and put them into $paths associatively using propertyName => propertyValue
            $paths = [];
            collect(array_keys(get_class_vars(get_class($this))))->filter(function ($propertyName) {
                return ends_with($propertyName, 'Path');
            })->each(function ($propertyName) use (&$paths) {
                $paths[ $propertyName ] = $this->{$propertyName};
            });

            // Use the paths to generate parsed paths, resolving all the {vars}
            $this->resolvedPaths = collect($paths)->transform(function ($path) use ($paths) {
                return Util::template($path, $paths);
            })->transform(function ($path, $propertyName) {
                return ends_with($propertyName, 'DestinationPath') ? base_path($path) : path_join($this->rootDir, $path);
            })->toArray();
        }

        return $this->resolvedPaths;
    }
682939
protected function _getPaths()
    {
        $directories = $this->_createDirectoryIterator($this->_getRootDir());
        $flattened   = $this->_createRecursiveIteratorIterator($directories);
        $flattened->setMaxDepth($this->_getMaxDepth());
        $filter = $this->_createFilterIterator($flattened, function (SplFileInfo $current, $key, Iterator $iterator) {
            return $this->_filterFile($current);
        });

        return $filter;
    }
581563
public function paths()
    {
        $roots = [
            'root'         => $this->root(),
            //App
            'app'          => $this->root().'App/',
            'controllers'  => $this->root().'App/Controllers/',
            'locale'       => $this->root().'App/Locale/',
            'middleware'   => $this->root().'App/Middleware/',
            'models'       => $this->root().'App/Models/',
            'views'        => __config()->config->theme_path,
            //components
            'com'          => $this->root().'App/Components/',
            //config
            'config'       => $this->root().'Config/',
            //public
            'public'       => getcwd().'/',
            //routes
            'routes'       => $this->root().'routes/',
            //Storage
            'storage'      => [
                'storage'  => $this->root().'Storage/',
                'backup'   => $this->root().'Storage/Backup/',
                'data'     => $this->root().'Storage/'.__config()->config->data_dir,
                'cache'    => $this->root().'Storage/'.__config()->config->cache_dir,
                'session'  => $this->root().'Storage/'.__config()->config->session_path,
                'log'      => $this->root().'Storage/Logs/',
            ],
            'views'        => $this->root().__config()->config->theme_path,
        ];

        return Conversion::arrayObject($roots);
    }
460795
public function resolve()
    {
        $result = $this->app->getUrlManager()->parseRequest($this);
        if ($result !== false) {
            [$route, $params] = $result;
            if ($this->_queryParams === null) {
                $_GET = $params + $_GET; // preserve numeric keys
            } else {
                $this->_queryParams = $params + $this->_queryParams;
            }

            return [$route, $this->getQueryParams()];
        }

        throw new NotFoundHttpException(Yii::t('yii', 'Page not found.'));
    }
589769
public function getPathInfo() {
    /** @var TokenNode $first */
    $first = $this->firstChild();
    $absolute = $first->getType() === T_NS_SEPARATOR;
    $relative = $first->getType() === T_NAMESPACE;
    $parts = $this->getParts();
    return [
      'absolute' => $absolute,
      'relative' => $relative,
      'qualified' => !$absolute && count($parts) > 1,
      'unqualified' => !$absolute && count($parts) === 1,
      'parts' => $parts,
    ];
  }
183138
public function getRoutingResourcesPaths()
    {
        $ds = DIRECTORY_SEPARATOR;
        $path = $this->getPath().$ds.'Resources'.$ds.'config'.$ds.'routing.yml';

        if (file_exists($path)) {
            return [$path];
        }

        return [];
    }
368254
public function getPaths() : array
    {
        $templatePaths = [];

        $paths = $this->template->getFinder()->getPaths();
        $hints = $this->template->getFinder()->getHints();

        foreach ($paths as $path) {
            $templatePaths[] = new TemplatePath($path);
        }

        foreach ($hints as $namespace => $path) {
            $templatePaths[] = new TemplatePath($namespace, $path);
        }

        return $templatePaths;
    }
395776
public function getContainmentTreeWithRequestPaths() {
    $tree_by_path = [];

    $tree = $this->getContainmentTree();

    foreach ($tree as $parent => $children) {
      foreach ($children as $child) {
        $tree_by_path[$this->requestPaths[$parent]][] = $this->requestPaths[$child];
      }
    }

    return $tree_by_path;
  }
1199858
protected function getMigrationPaths()
    {
        // Here, we will check to see if a path option has been defined. If it has we will
        // use the path relative to the root of the installation folder so our database
        // migrations may be run for any customized path from within the application.
        if ($this->input->hasOption('path') && $this->option('path')) {
            return collect($this->option('path'))->map(function ($path) {
                return $this->laravel->basePath().'/'.$path;
            })->all();
        }

        return [$this->getMigrationPath()];
    }
1151599
public function listPaths() {
		$request = new CPS_ListPathsRequest();
		$this->_lastResponse = $this->_connection->sendRequest($request);
		return $this->_lastResponse->getPaths();
	}
290767
protected function resolve()
    {
        $extensionsManager = $this->getServiceLocator()->get(\common_ext_ExtensionsManager::SERVICE_ID);
        $installed = $extensionsManager->getInstalledExtensionsIds();
        foreach ($installed as $extId) {
            $extension = $extensionsManager->getExtensionById($extId);
            foreach ($this->getRoutes($extension) as $entry) {
                /** @var Route $route */
                $route = $entry['route'];
                $called = $route->resolve($this->getRequest());
                if ($called !== null) {
                    list($controller, $action) = explode('@', $called);
                    $this->controller = $controller;
                    $this->action = $action;
                    $this->extensionId = $entry['extId'];

                    return true;
                }
            }
        }

        throw new \ResolverException('Unable to resolve '.$this->request->getUri()->getPath());
    }
638804
protected function resolveDumpPath()
    {
        $path = $this->basePath . '/' . $this->dumpPath;
        $this->ensureDirectory($path);
        return realpath($path) . '/' . $this->dumpFile;
    }
384095
public function resolveLocalPath($path)
    {
        if (is_array($path)) {
            $paths  = array();
            foreach ($path as $p) {
                $paths[]    = $this->resolveLocalPath($p);
            }
            return $paths;
        } else {
            $path   = FileSystem::normalizeDirectorySeparator($path);
            if (strpos($path, $this->getRepositoryPath()) === 0) {
                $path  = substr($path, strlen($this->getRepositoryPath()));
            }
            return ltrim($path, '/');
        }
    }
809559
public function allPsr4SourcePaths()
    {
        $autoloadPsr4Paths = array();
        foreach ($this->autoloadPsr4() as $namespace => $paths) {
            $autoloadPsr4Paths = array_merge($autoloadPsr4Paths, $paths);
        }

        return $autoloadPsr4Paths;
    }
1263065
protected function resolvePath($path)
    {
        $parts = explode('.', $path);
        $settings = $this->settings;
        foreach ($parts as $part) {
            if (!isset($settings[$part])) {
                return null;
            }
        
            $settings = $settings[$part];
        }
        
        return $settings;
    }
594925
protected function _initPaths()
    {
        $path = Path::getInstance();
        $path->setRoot(ROOT);

        //  Setup all webroot paths
        $path->set('webroot', Configure::read('App.wwwRoot'));
        foreach ((array) Plugin::loaded() as $name) {
            $plgPath = Plugin::path($name) . '/' . Configure::read('App.webroot') . '/';
            $path->set('webroot', FS::clean($plgPath), Path::MOD_APPEND);
        }

        //  Setup applicatiojn paths
        $paths = Configure::read('App.paths');
        foreach ($paths as $alias => $_paths) {
            $path->set($alias, $_paths);
        }

        return $path;
    }
832355
protected function getPath()
    {
        if (null === $this->parent) {
            return null;
        }
        if (null !== ( $pPath = $this->parent->getPath() )) {
            return $pPath . '.' . $this->handle;
        }else {
            return $this->handle;
        }
    }