Vluzrmos\LanguageDetector\LanguageDetector

Complexity

Total Complexity

22

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	3
A	detectAndApply()	0	10	2
A	detect()	0	4	2
A	getLanguageFromCookie()	0	11	2
A	addCookieToQueue()	0	9	2
A	useCookies()	0	4	2
A	getDriver()	0	4	1
A	setDriver()	0	4	1
A	apply()	0	10	2
A	addCallback()	0	4	1
A	applyCallbacks()	0	6	2
A	routePrefix()	0	10	2

<?php

namespace Vluzrmos\LanguageDetector;

use Closure;
use Illuminate\Contracts\Translation\Translator as IlluminateTranslator;
use Symfony\Component\Translation\TranslatorInterface as SymfonyTranslator;
use Vluzrmos\LanguageDetector\Contracts\DetectorDriverInterface as Driver;
use Vluzrmos\LanguageDetector\Contracts\LanguageDetectorInterface;
use Vluzrmos\LanguageDetector\Contracts\ShouldPrefixRoutesInterface as ShouldPrefixRoute;

/**
 * Class LanguageDetector.
 */
class LanguageDetector implements LanguageDetectorInterface
{
    /**
     * Translator instance.
     * @var SymfonyTranslator|IlluminateTranslator
     */
    protected $translator;

    /**
     * Driver to detect and apply the language.
     * @var Driver
     */
    protected $driver;

    /**
     * @var array
     */
    protected $callbacks = [];

    /**
     * Indicates cookie name or false to do not use cookies.
     * @var string|false|null
     */
    protected $cookie;

    /**
     * @param SymfonyTranslator|IlluminateTranslator $translator
     * @param Driver     $driver
     */
    public function __construct($translator, Driver $driver = null)
    {
        if (!$translator instanceof SymfonyTranslator && !$translator instanceof IlluminateTranslator) {
            throw new \InvalidArgumentException("Translator must implement the 'Symfony\\Component\\Translation\\TranslatorInterface' or 'Illuminate\\Contracts\\Translation\\Translator' interface.");
        }

        $this->translator = $translator;
        $this->driver = $driver;
    }

    /**
     * Detect and apply the detected language.
     *
     * @return string|null Returns the detected locale or null.
     */
    public function detectAndApply()
    {
        $language = $this->detect();

The expression $this->detect(); of type string|array adds the type array to the return on line 67 which is incompatible with the return type declared by the interface Vluzrmos\LanguageDetector\Contracts\LanguageDetectorInterface::detectAndApply of type string.

        if ($language) {
            $this->apply($language);

It seems like $language defined by $this->detect() on line 61 can also be of type array; however, Vluzrmos\LanguageDetector\LanguageDetector::apply() does only seem to accept string, maybe add an additional type check?

        }

        return $language;
    }

    /**
     * Detect the language.
     *
     * @return string
     */
    public function detect()
    {
        return $this->getLanguageFromCookie() ?: $this->getDriver()->detect();

The expression $this->getLanguageFromCookie() ?: $this->getDriver()->detect(); of type string|array adds the type array to the return on line 77 which is incompatible with the return type declared by the interface Vluzrmos\LanguageDetector\Contracts\LanguageDetectorInterface::detect of type string.

    }

    /**
     * @return string
     */
    public function getLanguageFromCookie()
    {
        if ($this->cookie) {
            /** @var \Illuminate\Http\Request $request */
            $request = $this->getDriver()->getRequest();

            return $request->cookie($this->cookie);
        }

        return false;
    }

    /**
     * Add cookie with locale to queue.
     *
     * @param string $locale
     */
    public function addCookieToQueue($locale)
    {
        if ($this->cookie) {
            /** @var \Illuminate\Cookie\CookieJar $cookieJar */
            $cookieJar = cookie();

            $cookieJar->queue($cookieJar->forever($this->cookie, $locale));
        }
    }

    /**
     * Determine if should use cookies.
     * false or null will disable feature, string will set cookie name.
     *
     * @param string|bool|null $cookieName
     */
    public function useCookies($cookieName = 'locale')
    {
        $this->cookie = empty($cookieName) ? false : $cookieName;

It seems like empty($cookieName) ? false : $cookieName can also be of type boolean. However, the property $cookie is declared as type string|false|null. Maybe add an additional type check?

    }

    /**
     * Get the driver.
     *
     * @return Driver
     */
    public function getDriver()
    {
        return $this->driver;
    }

    /**
     * Set driver to detect language.
     *
     * @param Driver $driver
     */
    public function setDriver(Driver $driver)
    {
        $this->driver = $driver;
    }

    /**
     * Set locale to the application.
     *
     * @param string $locale
     */
    public function apply($locale)
    {
        $this->translator->setLocale($locale);

        if (!$this->getLanguageFromCookie()) {
            $this->addCookieToQueue($locale);
        }

        $this->applyCallbacks($locale);
    }

    /**
     * Add a callback to call after applying the detected locale.
     * @param Closure $callback
     */
    public function addCallback(Closure $callback)
    {
        $this->callbacks[] = $callback;
    }

    /**
     * Call all registered callbacks.
     *
     * @param string $language
     */
    protected function applyCallbacks($language)
    {
        foreach ($this->callbacks as $callback) {
            call_user_func($callback, $language, $this);
        }
    }

    /**
     * Get the route prefix.
     *
     * @return string
     */
    public function routePrefix()
    {
        $driver = $this->getDriver();

        if ($driver instanceof ShouldPrefixRoute) {
            return $driver->routePrefix($this->translator->getLocale());
        }

        return '';
    }
}