Algolia\ScoutExtended\Helpers\SearchableFinder

Complexity

Total Complexity

12

Size/Duplication

Total Lines	116
Duplicated Lines	0 %

Test Coverage

Coverage

93.75%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	find()	0	6	2
A	fromCommand()	0	9	3
A	__construct()	0	3	1
A	getProjectClasses()	0	17	3
A	inferProjectSourcePaths()	0	13	2
A	isSearchableModel()	0	3	1

<?php

declare(strict_types=1);

/**
 * This file is part of Scout Extended.
 *
 * (c) Algolia Team <contact@algolia.com>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 */

namespace Algolia\ScoutExtended\Helpers;

use function in_array;
use Illuminate\Support\Str;
use Laravel\Scout\Searchable;
use Illuminate\Console\Command;
use RuntimeException;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Console\Exception\InvalidArgumentException;

/**
 * @internal
 */
final class SearchableFinder
{
    /**
     * @var array
     */
    private static $declaredClasses;

    /**
     * @var \Illuminate\Contracts\Foundation\Application
     */
    private $app;

    /**
     * @var array
     */
    private $projectNamespaces;

    /**
     * @var array
     */
    private $projectSources;

    /**
     * SearchableModelsFinder constructor.
     *
     * @param \Illuminate\Contracts\Foundation\Application $app
     * @return void
     */
    public function __construct($app)
    {
        $this->app = $app;
    }

    /**
     * Get a list of searchable models from the given command.
     *
     * @param \Illuminate\Console\Command $command
     *
     * @return array
     */
    public function fromCommand(Command $command): array
    {
        $searchables = (array) $command->argument('searchable');

        if (empty($searchables) && empty($searchables = $this->find())) {
            throw new InvalidArgumentException('No searchable classes found.');
        }

        return $searchables;
    }

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

        return array_values(array_filter($this->getProjectClasses(), function (string $class) {
            return Str::startsWith($class, $this->projectNamespaces) && $this->isSearchableModel($class);
        }));
    }

    /**
     * @param  string $class
     *
     * @return bool
     */
    private function isSearchableModel($class): bool
    {
        return in_array(Searchable::class, class_uses_recursive($class), true);
    }

    /**
     * @return array
     */
    private function getProjectClasses(): array
    {
        if (self::$declaredClasses === null) {

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

            $configFiles = Finder::create()
                ->files()
                ->notName('*.blade.php')
                ->name('*.php')
                ->in($this->projectSources);

            foreach ($configFiles->files() as $file) {
                require_once $file;
            }

            self::$declaredClasses = get_declared_classes();
        }

        return self::$declaredClasses;
    }

    /**
     * Using the laravel project's composer.json retrieve the PSR-4 autoload to determine
     * the paths to search and namespaces to check against.
     *
     * @return void
     */
    private function inferProjectSourcePaths(): void
    {
        $composerJson = json_decode(file_get_contents(base_path('composer.json')), true);
        $autoload = $composerJson['autoload'] ?? [];

        if (!isset($autoload['psr-4'])) {
            throw new RuntimeException('psr-4 autoload mappings are not present in composer.json');
        }

        $psr4 = collect($autoload['psr-4']);

        $this->projectSources = $psr4->values()->map(function($path) { return base_path($path); })->toArray();
        $this->projectNamespaces = $psr4->keys()->toArray();
    }
}