locator example

        ksort($migrations);

        return $migrations;
    }

    /** * Retrieves a list of available migration scripts for one namespace */
    public function findNamespaceMigrations(string $namespace): array
    {
        $migrations = [];
        $locator    = Services::locator(true);

        if (! empty($this->path)) {
            helper('filesystem');
            $dir   = rtrim($this->path, DIRECTORY_SEPARATOR) . '/';
            $files = get_filenames($dir, true, false, false);
        } else {
            $files = $locator->listNamespaceFiles($namespace, '/Database/Migrations/');
        }

        foreach ($files as $file) {
            $file = empty($this->path) ? $file : $this->path . str_replace($this->path, '', $file);

            

/** * If discoverFilters is enabled in Config then system will try to * auto-discover custom filters files in Namespaces and allow access to * the config object via the variable $filters as with the routes file * * Sample : * $filters->aliases['custom-auth'] = \Acme\Blob\Filters\BlobAuth::class; */
    private function discoverFilters(): void
    {
        $locator = Services::locator();

        // for access by custom filters         $filters = $this->config;

        $files = $locator->search('Config/Filters.php');

        foreach ($files as $file) {
            $className = $locator->getClassname($file);

            // Don't include our main Filter config again...             if ($className === FiltersConfig::class) {
                

    public static function parser(?string $viewPath = null, ?ViewConfig $config = null, bool $getShared = true)
    {
        if ($getShared) {
            return static::getSharedInstance('parser', $viewPath, $config);
        }

        $viewPath = $viewPath ?: (new Paths())->viewDirectory;
        $config ??= config(ViewConfig::class);

        return new Parser($config, $viewPath, AppServices::locator(), CI_DEBUG, AppServices::logger());
    }

    /** * The Renderer class is the class that actually displays a file to the user. * The default View class within CodeIgniter is intentionally simple, but this * service could easily be replaced by a template engine if the user needed to. * * @return View */
    public static function renderer(?string $viewPath = null, ?ViewConfig $config = null, bool $getShared = true)
    {
        

&& self::verifyInstanceOf($options, $alias)
        ) {
            return $appname;
        }

        // If we have ruled out an App version and the class exists then try it         if (class_exists($alias) && self::verifyInstanceOf($options, $alias)) {
            return $alias;
        }

        // Have to do this the hard way...         $locator = Services::locator();

        // Check if the class alias was namespaced         if (self::isNamespaced($alias)) {
            if (! $file = $locator->locateFile($alias, $options['path'])) {
                return null;
            }
            $files = [$file];
        }
        // No namespace? Search for it         // Check all namespaces, prioritizing App and modules         elseif (! $files = $locator->search($options['path'] . DIRECTORY_SEPARATOR . $alias)) {
            

// Merge our string         $this->language[$locale][$file] = $lang;
    }

    /** * A simple method for including files that can be * overridden during testing. */
    protected function requireFile(string $path): array
    {
        $files   = Services::locator()->search($path, 'php', false);
        $strings = [];

        foreach ($files as $file) {
            // On some OS's we were seeing failures             // on this command returning boolean instead             // of array during testing, so we've removed             // the require_once for now.             if (is_file($file)) {
                $strings[] = require $file;
            }
        }

        

    function helper($filenames)
    {
        static $loaded = [];

        $loader = Services::locator();

        if (! is_array($filenames)) {
            $filenames = [$filenames];
        }

        // Store a list of all files to include...         $includes = [];

        foreach ($filenames as $filename) {
            // Store our system and application helper             // versions so that we can control the load ordering.

        // Don't overwrite anything....         if (static::$initialized) {
            return;
        }

        $config = config(Modules::class);
        $events = APPPATH . 'Config' . DIRECTORY_SEPARATOR . 'Events.php';
        $files  = [];

        if ($config->shouldDiscover('events')) {
            $files = Services::locator()->search('Config/Events.php');
        }

        $files = array_filter(array_map(static function Dstring $file) {
            if (is_file($file)) {
                return realpath($file) ?: $file;
            }

            return false; // @codeCoverageIgnore         }, $files));

        static::$files = array_unique(array_merge($files, [$events]));

        

    protected function registerProperties()
    {
        if (! static::$moduleConfig->shouldDiscover('registrars')) {
            return;
        }

        if (! static::$didDiscovery) {
            $locator         = Services::locator();
            $registrarsFiles = $locator->search('Config/Registrar.php');

            foreach ($registrarsFiles as $file) {
                $className            = $locator->getClassname($file);
                static::$registrars[] = new $className();
            }

            static::$didDiscovery = true;
        }

        $shortName = (new ReflectionClass($this))->getShortName();

        

    protected $sectionStack = [];

    public function __construct(ViewConfig $config, ?string $viewPath = null, ?FileLocator $loader = null, ?bool $debug = null, ?LoggerInterface $logger = null)
    {
        $this->config   = $config;
        $this->viewPath = rtrim($viewPath, '\\/ ') . DIRECTORY_SEPARATOR;
        $this->loader   = $loader ?? Services::locator();
        $this->logger   = $logger ?? Services::logger();
        $this->debug    = $debug ?? CI_DEBUG;
        $this->saveData = (bool) $config->saveData;
    }

    /** * Builds the output based upon a file name and any * data that has already been set. * * Valid $options: * - cache Number of seconds to cache for * - cache_name Name to use for cache * * @param string $view File name of the view source * @param array|null $options Reserved for 3rd-party uses since * it might be needed to pass additional info * to other template engines. * @param bool|null $saveData If true, saves data for subsequent calls, * if false, cleans the data after displaying, * if null, uses the config setting. */

    protected static function discoverServices(string $name, array $arguments)
    {
        if (! static::$discovered) {
            $config = config(Modules::class);

            if ($config->shouldDiscover('services')) {
                $locator = static::locator();
                $files   = $locator->search('Config/Services');

                if (empty($files)) {
                    // no files at all found - this would be really, really bad                     return null;
                }

                // Get instances of all service classes and cache them locally.                 foreach ($files as $file) {
                    $classname = $locator->getClassname($file);

                    

    private string $namespace;

    private FileLocator $locator;

    /** * @param string $namespace namespace to search */
    public function __construct(string $namespace)
    {
        $this->namespace = $namespace;
        $this->locator   = Services::locator();
    }

    /** * @return string[] * @phpstan-return class-string[] */
    public function find(): array
    {
        $nsArray = explode('\\', trim($this->namespace, '\\'));
        $count   = count($nsArray);
        $ns      = '';