Matchish\ScoutElasticSearch\Searchable\SearchableListFactory

Complexity

Total Complexity

19

Size/Duplication

Total Lines	164
Duplicated Lines	0 %

Test Coverage

Coverage

91.23%

Importance

Changes	8
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getErrors()	0	3	1
A	make()	0	3	1
A	__construct()	0	4	1
A	getStmts()	0	22	3
B	findSearchableTraitRecursively()	0	26	7
A	classReflector()	0	7	2
A	getProjectClasses()	0	10	1
A	find()	0	6	1
A	getSearchableClasses()	0	11	2

<?php

declare(strict_types=1);

namespace Matchish\ScoutElasticSearch\Searchable;

use Illuminate\Support\Collection;
use Illuminate\Support\Str;
use Laravel\Scout\Searchable;
use PhpParser\Error;
use PhpParser\Node;
use PhpParser\Node\Stmt\Class_;
use PhpParser\NodeFinder;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitor\NameResolver;
use PhpParser\ParserFactory;
use Roave\BetterReflection\BetterReflection;
use Roave\BetterReflection\Reflector\ClassReflector;
use Roave\BetterReflection\Reflector\Exception\IdentifierNotFound;
use Symfony\Component\Finder\Finder;

final class SearchableListFactory
{
    /**
     * @var array
     */
    private static $searchableClasses;
    /**
     * @var string
     */
    private $namespace;
    /**
     * @var string
     */
    private $appPath;
    /**
     * @var array
     */
    private $errors = [];
    /**
     * @var ClassReflector
     */
    private $classReflector;

    /**
     * @param string $namespace
     */
    public function __construct(string $namespace, string $appPath)
    {
        $this->namespace = $namespace;
        $this->appPath = $appPath;
    }

    /**
     * @return array
     */
    public function getErrors(): array
    {
        return $this->errors;
    }

    /**
     * @return Collection
     */
    public function make(): Collection
    {
        return new Collection($this->find());
    }

    /**
     * Get a list of searchable models.
     *
     * @return string[]
     */
    private function find(): array
    {
        $appNamespace = $this->namespace;

        return array_values(array_filter($this->getSearchableClasses(), function (string $class) use ($appNamespace) {
            return Str::startsWith($class, $appNamespace);
        }));
    }

    /**
     * @return string[]
     */
    private function getSearchableClasses(): array
    {
        if (self::$searchableClasses === null) {

The condition self::searchableClasses === null is always false.

            $projectClasses = $this->getProjectClasses();

            self::$searchableClasses = $projectClasses->filter(function ($class) {
                return $this->findSearchableTraitRecursively($class);
            })->toArray();
        }

        return self::$searchableClasses;
    }

    /**
     * @return Collection
     */
    private function getProjectClasses(): Collection
    {
        $nodeFinder = new NodeFinder();
        /** @var Class_[] $nodes */
        $nodes = $nodeFinder->find($this->getStmts(), function (Node $node) {
            return $node instanceof Class_;
        });

        return Collection::make($nodes)->map(function ($node) {
            return $node->namespacedName->toCodeString();
        });
    }

    /**
     * @return array
     */
    private function getStmts(): array
    {
        $parser = (new ParserFactory())->create(ParserFactory::PREFER_PHP7);
        $nameResolverVisitor = new NameResolver();
        $nodeTraverser = new NodeTraverser();
        $nodeTraverser->addVisitor($nameResolverVisitor);
        $stmts = [];
        $finder = Finder::create()->files()->name('*.php')->in($this->appPath);

        foreach ($finder as $file) {
            try {
                $stmts[] = $parser->parse($file->getContents());
            } catch (Error $e) {
                $this->errors[] = $e->getMessage();
                continue;
            }
        }

        $stmts = Collection::make($stmts)->flatten(1)->toArray();
        $stmts = $nodeTraverser->traverse($stmts);

        return $stmts;
    }

    /**
     * @param string $class
     * @return bool
     */
    private function findSearchableTraitRecursively(string $class): bool
    {
        try {
            $reflection = $this->classReflector()->reflect($class);

            if (in_array(Searchable::class, $traits = $reflection->getTraitNames())) {
                return true;
            }

            foreach ($traits as $trait) {
                if ($this->findSearchableTraitRecursively($trait)) {
                    return true;
                }
            }

            if ($parent = $reflection->getParentClass()) {
                if ($this->findSearchableTraitRecursively($parent->getName())) {
                    return true;
                }
            }

            return false;
        } catch (IdentifierNotFound $e) {
            $this->errors[] = $e->getMessage();

            return false;
        }
    }

    /**
     * @return ClassReflector
     */
    private function classReflector(): ClassReflector
    {
        if (null === $this->classReflector) {
            $this->classReflector = (new BetterReflection())->classReflector();
        }

        return $this->classReflector;
    }
}