Kunstmaan\AdminBundle\Helper\DomainConfiguration

Complexity

Total Complexity

19

Size/Duplication

Total Lines	175
Duplicated Lines	15.43 %

Coupling/Cohesion

Components	3
Dependencies	3

Test Coverage

Coverage

85.42%

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	getHost()	3	7	2
A	getHosts()	0	4	1
A	getDefaultLocale()	0	4	1
A	isMultiLanguage()	0	4	1
A	getFrontendLocales()	0	4	1
A	getBackendLocales()	0	4	1
A	isMultiDomainHost()	0	4	1
A	getRootNode()	0	4	1
A	getExtraData()	0	4	1
A	getLocalesExtraData()	0	4	1
A	getMasterRequest()	0	4	1
A	getFullHostConfig()	0	4	1
A	getFullHost()	0	4	1
A	getFullHostById()	0	4	1
A	getHostSwitched()	0	4	1
A	getHostBaseUrl()	0	4	1
A	__construct()	20	20	2

<?php

namespace Kunstmaan\AdminBundle\Helper;

use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\RequestStack;

/**
 * Class DomainConfiguration
 *
 * Default (single domain) configuration handling
 */
class DomainConfiguration implements DomainConfigurationInterface
{
    /** @var ContainerInterface */
    protected $container;

    /** @var RequestStack */
    private $requestStack;

    /** @var bool */
    protected $multiLanguage;

    /** @var array */
    protected $requiredLocales;

    /** @var string */
    protected $defaultLocale;

    /**
     * @param ContainerInterface|string $multilanguage

Should the type for parameter $multilanguage not be ContainerInterface|string|null?

     */
    public function __construct(/*ContainerInterface|RequestStack*/ $requestStack, $multilanguage = null, $defaultLocale = null, $requiredLocales = null)

This method seems to be duplicated in your project.

    {
        if ($requestStack instanceof ContainerInterface) {
            @trigger_error('Container injection and the usage of the container is deprecated in KunstmaanNodeBundle 5.1 and will be removed in KunstmaanNodeBundle 6.0.', E_USER_DEPRECATED);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

            $this->container = $requestStack;
            $this->multiLanguage = $this->container->getParameter('kunstmaan_admin.multi_language');
            $this->defaultLocale = $this->container->getParameter('kunstmaan_admin.default_locale');
            $this->requiredLocales = explode('|', $this->container->getParameter('kunstmaan_admin.required_locales'));
            $this->requestStack = $this->container->get('request_stack');

            return;
        }

        $this->requestStack = $requestStack;
        $this->multiLanguage = $multilanguage;

It seems like $multilanguage can also be of type object<Symfony\Component\DependencyInjection\ContainerInterface> or string. However, the property $multiLanguage is declared as type boolean. Maybe add an additional type check?

        $this->defaultLocale = $defaultLocale;

        $this->requiredLocales = explode('|', $requiredLocales);
    }

    /**
     * @return string
     */
    public function getHost()
    {
        $request = $this->getMasterRequest();
        $host = \is_null($request) ? '' : $request->getHost();

        return $host;
    }

    /**
     * @return array

Consider making the return type a bit more specific; maybe use string[].

     */
    public function getHosts()
    {
        return array($this->getHost());
    }

    /**
     * @return string
     */
    public function getDefaultLocale()
    {
        return $this->defaultLocale;
    }

    /**
     * @param string|null $host
     *
     * @return bool
     */
    public function isMultiLanguage($host = null)
    {
        return $this->multiLanguage;
    }

    /**
     * @param string|null $host
     *
     * @return array
     */
    public function getFrontendLocales($host = null)
    {
        return $this->requiredLocales;
    }

    /**
     * @param string|null $host
     *
     * @return array
     */
    public function getBackendLocales($host = null)
    {
        return $this->requiredLocales;
    }

    /**
     * @return bool
     */
    public function isMultiDomainHost()
    {
        return false;
    }

    /**
     * @param string|null $host
     */
    public function getRootNode($host = null)
    {
        return null;
    }

    /**
     * @return array
     */
    public function getExtraData()
    {
        return array();
    }

    /**
     * @return array
     */
    public function getLocalesExtraData()
    {
        return array();
    }

    /**
     * @return \Symfony\Component\HttpFoundation\Request|null
     */
    protected function getMasterRequest()
    {
        return $this->requestStack->getMasterRequest();
    }

    /**
     * @return array
     */
    public function getFullHostConfig()
    {
        return array();
    }

    /**
     * @param string|null $host
     */
    public function getFullHost($host = null)
    {
        return null;
    }

    /**
     * @param string|int $id
     */
    public function getFullHostById($id)
    {
        return null;
    }

    public function getHostSwitched()
    {
        return null;
    }

    /**
     * @param string|null $host
     */
    public function getHostBaseUrl($host = null)
    {
        return null;
    }
}