Monospice\LaravelRedisSentinel\Horizon\HorizonServiceProvider

Complexity

Total Complexity

12

Size/Duplication

Total Lines	145
Duplicated Lines	11.72 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	2
A	register()	9	18	2
A	createHorizonConnectionConfiguration()	0	10	1
A	getSelectedConnectionConfiguration()	0	13	2
A	shouldRebindHorizonRedisFactory()	0	7	2
A	rebindHorizonRedisFactory()	0	14	2
A	addHorizonSentinelQueueConnector()	8	8	1

<?php

namespace Monospice\LaravelRedisSentinel\Horizon;

use Illuminate\Contracts\Config\Repository as ConfigRepository;
use Illuminate\Contracts\Container\Container;
use Illuminate\Contracts\Redis\Factory as RedisFactory;
use Illuminate\Support\Arr;
use Illuminate\Support\ServiceProvider;
use Laravel\Horizon\Connectors\RedisConnector as HorizonRedisConnector;
use Monospice\LaravelRedisSentinel\Configuration\Loader as ConfigurationLoader;
use Monospice\LaravelRedisSentinel\Horizon\HorizonServiceBindings;
use Monospice\LaravelRedisSentinel\RedisSentinelManager;
use RuntimeException;

/**
 * Configures the application to use Redis Sentinel connections for Laravel
 * Horizon.
 *
 * @category Package
 * @package  Monospice\LaravelRedisSentinel
 * @author   Cy Rossignol <cy@rossignols.me>
 * @license  See LICENSE file
 * @link     https://github.com/monospice/laravel-redis-sentinel-drivers
 */
class HorizonServiceProvider extends ServiceProvider
{
    /**
     * Loads the package's configuration and provides configuration values.
     *
     * @var ConfigurationLoader
     */
    protected $config;

    /**
     * Create a new service provider instance.
     *
     * @param Container           $app    The current Laravel/Lumen application
     * instance.
     * @param ConfigurationLoader $config Loads the package's configuration and

Should the type for parameter $config not be null|ConfigurationLoader?

     * provides configuration values.
     */
    public function __construct(
        Container $app,
        ConfigurationLoader $config = null
    ) {
        parent::__construct($app);

$app of type object<Illuminate\Contracts\Container\Container> is not a sub-type of object<Illuminate\Contracts\Foundation\Application>. It seems like you assume a child interface of the interface Illuminate\Contracts\Container\Container to be always present.

        if ($config === null) {
            $config = ConfigurationLoader::load($app);

$app is of type object<Illuminate\Contracts\Container\Container>, but the function expects a object<Illuminate\Foundation\Application>|object<Laravel\Lumen\Application>.

        }

        $this->config = $config;
    }

    /**
     * Configure the package for use with Laravel Horizon.
     *
     * @return void
     */
    public function register()
    {
        $this->app->singleton('redis-sentinel', function ($app) {

The parameter $app is not used and could be removed.

This code seems to be duplicated across your project.

            $this->createHorizonConnectionConfiguration();

            $class = $this->config->getVersionedRedisSentinelManagerClass();
            $config = $this->config->get('database.redis-sentinel', [ ]);
            $driver = Arr::pull($config, 'client', 'predis');

            return new RedisSentinelManager(new $class($driver, $config));
        });

        if ($this->shouldRebindHorizonRedisFactory()) {
            $this->rebindHorizonRedisFactory();
        }

        $this->addHorizonSentinelQueueConnector();
    }

    /**
     * Sets the Horizon Redis Sentinel connection configuration.
     *
     * @return void
     */
    protected function createHorizonConnectionConfiguration()
    {
        $horizonConfig = $this->getSelectedConnectionConfiguration();
        $options = Arr::get($horizonConfig, 'options', [ ]);
        $options['prefix'] = $this->config->get('horizon.prefix', 'horizon:');

        $horizonConfig['options'] = $options;

        $this->config->set('database.redis-sentinel.horizon', $horizonConfig);
    }

    /**
     * Copy the Redis Sentinel connection configuration to use for Horizon
     * connections from the connection specified by "horizon.use".
     *
     * @return array The configuration matching the connection name specified
     * by the "horizon.use" config directive.
     *
     * @throws RuntimeException If no Redis Sentinel connection matches the
     * name declared by "horizon.use".
     */
    protected function getSelectedConnectionConfiguration()
    {
        $use = $this->config->get('horizon.use', 'default');
        $connectionConfig = $this->config->get("database.redis-sentinel.$use");

As per coding-style, please use concatenation or sprintf for the variable $use instead of interpolation.

        if ($connectionConfig === null) {
            throw new RuntimeException(
                "The Redis Sentinel connection [$use] is not defined."

As per coding-style, please use concatenation or sprintf for the variable $use instead of interpolation.

            );
        }

        return $connectionConfig;
    }

    /**
     * Determine whether the package needs to override the Redis service
     * injected into Horizon classes with the Sentinel service.
     *
     * @return bool True if configured as such and the package doesn't already
     * override the application's Redis API.
     */
    protected function shouldRebindHorizonRedisFactory()
    {
        // If we're already overriding Laravel's standard Redis API, we don't
        // need to rebind the "redis" service for Horizon.
        return ! $this->config->shouldOverrideLaravelRedisApi
            && $this->config->get('horizon.driver') === 'redis-sentinel';
    }

    /**
     * Add contextual bindings for Horizon's services that inject the package's
     * Redis Sentinel manager.
     *
     * @return void
     */
    protected function rebindHorizonRedisFactory()
    {
        // Although not all of the classes that Horizon registers need an
        // instance of the Redis service, we'll set up contextual bindings
        // for any declared so we don't need to update this package in the
        // future every time Horizon adds or removes one:
        foreach ((new HorizonServiceBindings()) as $serviceClass) {
            $this->app->when($serviceClass)
                ->needs(RedisFactory::class)
                ->give(function () {
                    return $this->app->make('redis-sentinel.manager');
                });
        }
    }

    /**
     * Add "redis-sentinel" as an available queue connection driver option to
     * the Laravel queue manager using Horizon's modified Redis connector.
     *
     * @return void
     */
    protected function addHorizonSentinelQueueConnector()

This method seems to be duplicated in your project.

    {
        $this->app->make('queue')->extend('redis-sentinel', function () {
            $redis = $this->app->make('redis-sentinel.manager');

            return new HorizonRedisConnector($redis);
        });
    }
}