Algolia\ScoutExtended\ScoutExtendedServiceProvider

Complexity

Total Complexity

6

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Test Coverage

Coverage

86.84%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	7	1
A	boot()	0	3	1
A	registerCommands()	0	11	2
A	registerBinds()	0	38	1
A	registerMacros()	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;

use ReflectionClass;
use Laravel\Scout\Builder;
use Algolia\AlgoliaSearch\Analytics;

The type Algolia\AlgoliaSearch\Analytics was not found. Maybe you did not declare it correctly or list all dependencies?

use Illuminate\Support\ServiceProvider;
use Laravel\Scout\ScoutServiceProvider;
use Algolia\ScoutExtended\Engines\AlgoliaEngine;
use Algolia\ScoutExtended\Managers\EngineManager;
use Algolia\AlgoliaSearch\Interfaces\ClientInterface;

The type Algolia\AlgoliaSearch\Interfaces\ClientInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Algolia\ScoutExtended\Console\Commands\SyncCommand;
use Algolia\ScoutExtended\Console\Commands\FlushCommand;
use Algolia\ScoutExtended\Searchable\AggregatorObserver;
use Algolia\ScoutExtended\Console\Commands\ImportCommand;
use Algolia\ScoutExtended\Console\Commands\StatusCommand;
use Algolia\ScoutExtended\Console\Commands\OptimizeCommand;
use Algolia\ScoutExtended\Console\Commands\ReImportCommand;
use Algolia\ScoutExtended\Console\Commands\MakeAggregatorCommand;

final class ScoutExtendedServiceProvider extends ServiceProvider
{
    /**
     * {@inheritdoc}
     */
    public function boot(): void
    {
        $this->loadViewsFrom(__DIR__.'/../resources/views', 'algolia');
    }

    /**
     * {@inheritdoc}
     */
    public function register(): void
    {
        $this->app->register(ScoutServiceProvider::class);

        $this->registerBinds();
        $this->registerCommands();
        $this->registerMacros();
    }

    /**
     * Binds Algolia services into the container.
     *
     * @return void
     */
    private function registerBinds(): void
    {
        $this->app->bind(Algolia::class, function () {
            return new Algolia($this->app);
        });

        $this->app->alias(Algolia::class, 'algolia');

        $this->app->singleton(EngineManager::class, function ($app) {
            return new EngineManager($app);
        });

        $this->app->alias(EngineManager::class, \Laravel\Scout\EngineManager::class);

        $this->app->bind(AlgoliaEngine::class, function (): AlgoliaEngine {
            return $this->app->make(\Laravel\Scout\EngineManager::class)->createAlgoliaDriver();

The expression return $this->app->make(Laravel\Scout\EngineManager::class)->createAlgoliaDriver() returns the type Laravel\Scout\Engines\AlgoliaEngine which includes types incompatible with the type-hinted return Algolia\ScoutExtended\Engines\AlgoliaEngine.

        });

        $this->app->alias(AlgoliaEngine::class, 'algolia.engine');

        $this->app->bind(ClientInterface::class, function (): ClientInterface {
            $engine = $this->app->make('algolia.engine');
            $reflection = new ReflectionClass(AlgoliaEngine::class);
            $property = $reflection->getProperty('algolia');
            $property->setAccessible(true);

            return $property->getValue($engine);
        });

        $this->app->alias(ClientInterface::class, 'algolia.client');

        $this->app->bind(Analytics::class, function (): Analytics {
            return Analytics::create(config('scout.algolia.id'), config('scout.algolia.secret'));
        });

        $this->app->alias(Analytics::class, 'algolia.analytics');

        $this->app->singleton(AggregatorObserver::class, AggregatorObserver::class);
        // $this->loadRoutesFrom(__DIR__.'/../routes/web.php');
    }

    /**
     * Register artisan commands.
     *
     * @return void
     */
    private function registerCommands(): void
    {
        if ($this->app->runningInConsole()) {
            $this->commands([
                MakeAggregatorCommand::class,
                ImportCommand::class,
                FlushCommand::class,
                OptimizeCommand::class,
                ReImportCommand::class,
                StatusCommand::class,
                SyncCommand::class,
            ]);
        }
    }

    /**
     * Register macros.
     *
     * @return void
     *
     * @throws \ReflectionException
     */
    private function registerMacros(): void
    {
        Builder::mixin(new BuilderMacros);
    }
}