Nip\Container\ServiceProviders\ServiceProviderAwareTrait

Complexity

Total Complexity

15

Size/Duplication

Total Lines	78
Duplicated Lines	0 %

Test Coverage

Coverage

43.33%

Importance

Changes	3
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
B	getConfigProvidersValue()	0	20	8
A	registerConfiguredProviders()	0	8	2
A	getConfiguredProviders()	0	3	1
A	getProviderRepository()	0	8	2
A	bootProviders()	0	3	1
A	getGenericProviders()	0	3	1

<?php

namespace Nip\Container\ServiceProviders;

use Nip\Config\Config;
use Nip\Container\Container;

/**
 * Class ServiceProviderAwareTrait
 * @package Nip\Container\ServiceProviders
 */
trait ServiceProviderAwareTrait
{
    /**
     * All of the registered service providers.
     *
     * @var ProviderRepository
     */
    protected $providerRepository = null;

    public function registerConfiguredProviders()
    {
        $providers = $this->getConfiguredProviders();
        foreach ($providers as $provider) {
            $this->getProviderRepository()->add($provider);
        }

        return $this->getProviderRepository()->register();

Are you sure the usage of $this->getProviderRepository()->register() targeting Nip\Container\ServiceProviders\ProviderRepository::register() seems to always return null.

    }

    /**
     * @return ProviderRepository
     */
    public function getProviderRepository()
    {
        if ($this->providerRepository === null) {
            $this->providerRepository = new ProviderRepository();
            $this->providerRepository->setContainer($this->getContainer());

It seems like getContainer() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        return $this->providerRepository;
    }

    /**
     * @return array
     */
    public function getConfiguredProviders()
    {
        return $this->getConfigProvidersValue($this->getGenericProviders());
    }

    /**
     * @param null $default

Are you sure the doc-type for parameter $default is correct as it would always require null to be passed?

     * @return array|null
     * @throws \Exception
     */
    protected function getConfigProvidersValue($default = null)
    {
        if (function_exists('config') === false) {
            return $default;
        }
        if (function_exists('app') === false && !(Container::getInstance() instanceof Container)) {

Nip\Container\Container::getInstance() is always a sub-type of Nip\Container\Container.

            return $default;
        }
        $container = function_exists('app') ? app() : Container::getInstance();
        if ($container->has('config') == false) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            return $default;
        }
        $value = config('app.providers');
        if ($value instanceof Config) {
            $value = $value->toArray();
        }
        if (empty($value)) {
            return $default;
        }
        return $value;
    }

    /**
     * @return array
     */
    public function getGenericProviders()
    {
        return [];
    }

    public function bootProviders()
    {
        $this->getProviderRepository()->boot();
    }
}