beyondcode / laravel-er-diagram-generator

src/ModelFinder.php

<?php

namespace BeyondCode\ErdGenerator;

use Illuminate\Database\Eloquent\Model as EloquentModel;
use Illuminate\Filesystem\Filesystem;
use Illuminate\Support\Collection;
use Illuminate\Support\Str;
use PhpParser\Node\Stmt\Class_;
use PhpParser\Node\Stmt\Namespace_;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitor\NameResolver;
use PhpParser\ParserFactory;
use ReflectionClass;

class ModelFinder
{

    /** @var Filesystem */
    protected $filesystem;

    public function __construct(Filesystem $filesystem)
    {
        $this->filesystem = $filesystem;
    }

    public function getModelsInDirectory(string $directory): Collection
    {
        $files = config('erd-generator.recursive') ?
            $this->filesystem->allFiles($directory) :
            $this->filesystem->files($directory);

        $ignoreModels = array_filter(config('erd-generator.ignore', []), 'is_string');
        $whitelistModels = array_filter(config('erd-generator.whitelist', []), 'is_string');

        $collection = Collection::make($files)->filter(function ($path) {

$files of type Symfony\Component\Finder\SplFileInfo[] is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $items of Illuminate\Support\Collection::make().

            return Str::endsWith($path, '.php');
        })->map(function ($path) {
            return $this->getFullyQualifiedClassNameFromFile($path);
        })->filter(function (string $className) {
            return !empty($className)
                && is_subclass_of($className, EloquentModel::class)
                && ! (new ReflectionClass($className))->isAbstract();
        });

        if(!count($whitelistModels)) {
          return $collection->diff($ignoreModels)->sort();

$ignoreModels of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $items of Illuminate\Support\Collection::diff().

        }

        return $collection->filter(function (string $className) use ($whitelistModels) {
            return in_array($className, $whitelistModels);
        });
    }

    protected function getFullyQualifiedClassNameFromFile(string $path): string
    {
        $factory = new ParserFactory();
        $parser = method_exists($factory, 'createForHostVersion')
            ? $factory->createForHostVersion()
            : $factory->create(ParserFactory::PREFER_PHP7);

The constant PhpParser\ParserFactory::PREFER_PHP7 was not found. Maybe you did not declare it correctly or list all dependencies?

The method create() does not exist on PhpParser\ParserFactory. Did you maybe mean createForNewestSupportedVersion()?

        $traverser = new NodeTraverser();
        $traverser->addVisitor(new NameResolver());

        $code = file_get_contents($path);

        $statements = $parser->parse($code);
        $statements = $traverser->traverse($statements);

It seems like $statements can also be of type null; however, parameter $nodes of PhpParser\NodeTraverser::traverse() does only seem to accept array, maybe add an additional type check?

        // get the first namespace declaration in the file
        $root_statement = collect($statements)->first(function ($statement) {

$statements of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            return $statement instanceof Namespace_;
        });

        if (! $root_statement) {
            return '';
        }

        return collect($root_statement->stmts)
                ->filter(function ($statement) {
                    return $statement instanceof Class_;
                })
                ->map(function (Class_ $statement) {
                    return $statement->namespacedName->toString();

The method toString() does not exist on null.

                })
                ->first() ?? '';
    }
}