bearsunday / BEAR.Resource

src/AppIterator.php

<?php

declare(strict_types=1);

namespace BEAR\Resource;

use BEAR\Resource\Exception\ResourceDirException;
use Iterator;
use Override;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use ReflectionClass;
use SplFileInfo;

use function array_diff_key;
use function array_key_exists;
use function array_keys;
use function array_values;
use function assert;
use function class_exists;
use function file_exists;
use function get_declared_classes;
use function str_contains;

/**
 * @psalm-import-type ResourceClassName from Types
 * @psalm-import-type MetaMap from Types
 * @psalm-import-type ClassNameList from Types
 * @implements Iterator<string, Meta>
 */
final class AppIterator implements Iterator
{
    private int $i = 0;

    /** @var MetaMap */

The type BEAR\Resource\MetaMap was not found. Maybe you did not declare it correctly or list all dependencies?

    private array $metaCollection = [];

    /** @var list<string> */

The type BEAR\Resource\list was not found. Maybe you did not declare it correctly or list all dependencies?

    private array $keys = [];

    /** @throws ResourceDirException */
    public function __construct(string $resourceDir)
    {
        if (! file_exists($resourceDir)) {
            throw new ResourceDirException($resourceDir);
        }

        $iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($resourceDir),
            RecursiveIteratorIterator::SELF_FIRST,
        );
        $this->metaCollection = $this->getMetaCollection($iterator);

It seems like $this->getMetaCollection($iterator) of type array or array is incompatible with the declared type BEAR\Resource\MetaMap of property $metaCollection.

        $this->keys = array_keys($this->metaCollection);

It seems like array_keys($this->metaCollection) of type array is incompatible with the declared type BEAR\Resource\list of property $keys.

    }

    /**
     * {@inheritDoc}
     */
    #[Override]
    public function current(): Meta
    {
        return $this->metaCollection[$this->keys[$this->i]];
    }

    /**
     * {@inheritDoc}
     */
    #[Override]
    public function next(): void
    {
        ++$this->i;
    }

    /**
     * {@inheritDoc}
     */
    #[Override]
    public function key(): string
    {
        return $this->keys[$this->i]; // @codeCoverageIgnore
    }

    /**
     * {@inheritDoc}
     */
    #[Override]
    public function valid(): bool
    {
        return array_key_exists($this->i, $this->keys);
    }

    /**
     * {@inheritDoc}
     */
    #[Override]
    public function rewind(): void
    {
        $this->i = 0;
    }

    /**
     * @param Iterator<SplFileInfo> $iterator
     *
     * @return MetaMap
     */
    private function getMetaCollection(Iterator $iterator): array
    {
        $metaCollection = [];
        foreach ($iterator as $item) {
            if ($this->isNotPhp($item)) {
                continue;
            }

            $resourceClass = $this->getResourceClassName($item);
            if ($resourceClass === '' || ! class_exists($resourceClass)) {
                continue;
            }

            $meta = new Meta($resourceClass);
            $metaCollection[$meta->uri] = $meta;
        }

        return $metaCollection;

The expression return $metaCollection returns the type array which is incompatible with the documented return type BEAR\Resource\MetaMap.

    }

    private function isNotPhp(SplFileInfo $item): bool
    {
        $isPhp = $item->isFile()
            && $item->getExtension() === 'php'
            && (! str_contains($item->getBasename('.php'), '.'));

        return ! $isPhp;
    }

    /** @return ResourceClassName|'' */

The doc comment ResourceClassName|'' at position 2 could not be parsed: Unknown type name '''' at position 2 in ResourceClassName|''.

    private function getResourceClassName(SplFileInfo $file): string
    {
        $pathName = $file->getPathname();
        $declaredClasses = get_declared_classes();
        assert(file_exists($pathName));
        include_once $pathName;
        $newClasses = array_values(array_diff_key(get_declared_classes(), $declaredClasses));

        return $this->getName($newClasses);
    }

    /**
     * @param ClassNameList $newClasses

The type BEAR\Resource\ClassNameList was not found. Maybe you did not declare it correctly or list all dependencies?

     *
     * @return ResourceClassName|''

The doc comment ResourceClassName|'' at position 2 could not be parsed: Unknown type name '''' at position 2 in ResourceClassName|''.

     */
    private function getName(array $newClasses): string
    {
        foreach ($newClasses as $newClass) {
            $parent = (new ReflectionClass($newClass))->getParentClass();
            if ($parent && $parent->name === ResourceObject::class) {
                /** @var ResourceClassName $newClass */
                return $newClass;
            }
        }

        return '';
    }
}