Locale::getLocaleFromRequest() - Code Metrics - Inspection of "Fix #44: Support subtags in locales" - yiisoft/yii-middleware - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#50)

by Rustam

created 2023-04-04 12:31 UTC

Locale::getLocaleFromRequest() A

↳ Parent: Locale

Complexity

Conditions	3
Paths	3

Size

Total Lines	17
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	10
nc	3
nop	1
dl	0
loc	17
ccs	12
cts	12
cp	1
crap	3
rs	9.9332
c	1
b	0
f	0

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Middleware;

use DateInterval;
use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Psr\Log\LoggerInterface;
use Yiisoft\Aliases\Aliases;
use Yiisoft\Cookies\Cookie;
use Yiisoft\Http\Header;
use Yiisoft\Http\Method;
use Yiisoft\Http\Status;
use Yiisoft\Router\UrlGeneratorInterface;
use Yiisoft\Session\SessionInterface;
use Yiisoft\Strings\WildcardPattern;
use Yiisoft\Translator\TranslatorInterface;
use Yiisoft\Yii\Middleware\Exception\InvalidLocalesFormatException;

final class Locale implements MiddlewareInterface
{
    private const DEFAULT_LOCALE = 'en';
    private const DEFAULT_LOCALE_NAME = '_language';

    private bool $enableSaveLocale = true;
    private bool $enableDetectLocale = false;
    private string $defaultLocale = self::DEFAULT_LOCALE;
    private string $queryParameterName = self::DEFAULT_LOCALE_NAME;
    private string $sessionName = self::DEFAULT_LOCALE_NAME;
    private ?DateInterval $cookieDuration;

    /**
     * @param array $locales List of supported locales in key-value format e.g. ['ru' => 'ru_RU', 'uz' => 'uz_UZ']
     * @param string[] $ignoredRequests
     */
    public function __construct(
        private TranslatorInterface $translator,
        private UrlGeneratorInterface $urlGenerator,
        private SessionInterface $session,
        private Aliases $aliases,
        private LoggerInterface $logger,
        private ResponseFactoryInterface $responseFactory,
        private array $locales = [],
        private array $ignoredRequests = [],
        private bool $cookieSecure = false,
        private string $baseUrlAlias = '@baseUrl',
    ) {
        $this->cookieDuration = new DateInterval('P30D');
    }

    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        if ($this->locales === []) {
            return $handler->handle($request);
        }

        $this->assertLocalesFormat();

        $uri = $request->getUri();
        $path = $uri->getPath();
        $query = $uri->getQuery();

        $locale = $this->getLocaleFromPath($path);

        if ($locale !== null) {
            $this->translator->setLocale($this->locales[$locale]);
            $this->urlGenerator->setDefaultArgument($this->queryParameterName, $locale);

            $response = $handler->handle($request);
            $newPath = null;
            if ($this->isDefaultLocale($locale) && $request->getMethod() === Method::GET) {
                $length = strlen($locale);
                $newPath = substr($path, $length + 1);
            }
            return $this->applyLocaleFromPath($locale, $response, $query, $newPath);
        }
        if ($this->enableSaveLocale) {
            $locale = $this->getLocaleFromRequest($request);
        }
        if ($locale === null && $this->enableDetectLocale) {
            $locale = $this->detectLocale($request);
        }
        if ($locale === null || $this->isDefaultLocale($locale) || $this->isRequestIgnored($request)) {
            $this->urlGenerator->setDefaultArgument($this->queryParameterName, null);
            $request = $request->withUri($uri->withPath('/' . $this->defaultLocale . $path));
            return $handler->handle($request);
        }

        $this->translator->setLocale($this->locales[$locale]);
        $this->urlGenerator->setDefaultArgument($this->queryParameterName, $locale);

        if ($request->getMethod() === Method::GET) {
            $location = rtrim($this->aliases->get($this->baseUrlAlias), '/') . '/'
                . $locale . $path . ($query !== '' ? '?' . $query : '');
            return $this->responseFactory
                ->createResponse(Status::FOUND)
                ->withHeader(Header::LOCATION, $location);
        }


        return $handler->handle($request);
    }

    private function applyLocaleFromPath(
        string $locale,
        ResponseInterface $response,
        string $query,
        ?string $newPath = null,
    ): ResponseInterface {
        if ($newPath === '') {
            $newPath = '/';
        }

        if ($newPath !== null) {
            $location = rtrim($this->aliases->get($this->baseUrlAlias), '/')
                . $newPath . ($query !== '' ? '?' . $query : '');
            $response = $this->responseFactory
                ->createResponse(Status::FOUND)
                ->withHeader(Header::LOCATION, $location);
        }
        if ($this->enableSaveLocale) {
            $response = $this->saveLocale($locale, $response);
        }
        return $response;
    }

    private function getLocaleFromPath(string $path): ?string
    {
        $parts = [];
        /**
         * @var string $code
         * @var string $locale
         */
        foreach ($this->locales as $code => $locale) {
            $parts[] = $code;
            $parts[] = $locale;
        }

        $pattern = implode('|', $parts);
        if (preg_match("#^/($pattern)\b(/?)#i", $path, $matches)) {
            $matchedLocale = $matches[1];
            if (!isset($this->locales[$matchedLocale])) {
                $matchedLocale = $this->parseLocale($matchedLocale);
            }
            if (isset($this->locales[$matchedLocale])) {
                $this->logger->debug(sprintf("Locale '%s' found in URL", $matchedLocale));
                return $matchedLocale;
            }
        }
        return null;
    }

    private function getLocaleFromRequest(ServerRequestInterface $request): ?string
    {
        /** @var array<string, string> $cookies */
        $cookies = $request->getCookieParams();
        if (isset($cookies[$this->sessionName])) {
            $this->logger->debug(sprintf("Locale '%s' found in cookies", $cookies[$this->sessionName]));
            return $this->parseLocale($cookies[$this->sessionName]);
        }
        /** @var array<string, string> $queryParameters */
        $queryParameters = $request->getQueryParams();
        if (isset($queryParameters[$this->queryParameterName])) {
            $this->logger->debug(
                sprintf("Locale '%s' found in query string", $queryParameters[$this->queryParameterName])
            );
            return $this->parseLocale($queryParameters[$this->queryParameterName]);
        }
        return null;
    }

    private function isDefaultLocale(string $locale): bool
    {
        return $locale === $this->defaultLocale || $this->locales[$locale] === $this->defaultLocale;
    }

    private function detectLocale(ServerRequestInterface $request): ?string
    {
        foreach ($request->getHeader(Header::ACCEPT_LANGUAGE) as $language) {
            if (!isset($this->locales[$language])) {
                $language = $this->parseLocale($language);
            }
            if (isset($this->locales[$language])) {
                return $language;
            }
        }
        return null;
    }

    private function saveLocale(string $locale, ResponseInterface $response): ResponseInterface
    {
        $this->logger->debug('Saving found locale to cookies');
        $this->session->set($this->sessionName, $locale);
        $cookie = new Cookie(name: $this->sessionName, value: $locale, secure: $this->cookieSecure);
        if ($this->cookieDuration !== null) {
            $cookie = $cookie->withMaxAge($this->cookieDuration);
        }
        return $cookie->addToResponse($response);
    }

    private function parseLocale(string $locale): string
    {
        if (str_contains($locale, '-')) {
            [$locale] = explode('-', $locale, 2);
        } elseif (str_contains($locale, '_')) {
            [$locale] = explode('_', $locale, 2);
        }

        return $locale;
    }

    private function isRequestIgnored(ServerRequestInterface $request): bool
    {
        foreach ($this->ignoredRequests as $ignoredRequest) {
            if ((new WildcardPattern($ignoredRequest))->match($request->getUri()->getPath())) {
                return true;
            }
        }
        return false;
    }

    /**
     * @throws InvalidLocalesFormatException
     */
    private function assertLocalesFormat(): void
    {
        foreach ($this->locales as $code => $locale) {
            if (!is_string($code) || !is_string($locale)) {
                throw new InvalidLocalesFormatException();
            }
        }
    }

    /**
     * @param array $locales List of supported locales in key-value format e.g. ['ru' => 'ru_RU', 'uz' => 'uz_UZ']
     *
     * @return $this
     */
    public function withLocales(array $locales): self
    {
        $new = clone $this;
        $new->locales = $locales;
        return $new;
    }

    public function withDefaultLocale(string $defaultLocale): self
    {
        $new = clone $this;
        $new->defaultLocale = $defaultLocale;
        return $new;
    }

    public function withQueryParameterName(string $queryParameterName): self
    {
        $new = clone $this;
        $new->queryParameterName = $queryParameterName;
        return $new;
    }

    public function withSessionName(string $sessionName): self
    {
        $new = clone $this;
        $new->sessionName = $sessionName;
        return $new;
    }

    public function withEnableSaveLocale(bool $enableSaveLocale): self
    {
        $new = clone $this;
        $new->enableSaveLocale = $enableSaveLocale;
        return $new;
    }

    public function withEnableDetectLocale(bool $enableDetectLocale): self
    {
        $new = clone $this;
        $new->enableDetectLocale = $enableDetectLocale;
        return $new;
    }

    /**
     * @param string[] $ignoredRequests
     *
     * @return $this
     */
    public function withIgnoredRequests(array $ignoredRequests): self
    {
        $new = clone $this;
        $new->ignoredRequests = $ignoredRequests;
        return $new;
    }

    public function withCookieSecure(bool $secure): self
    {
        $new = clone $this;
        $new->cookieSecure = $secure;
        return $new;
    }

    public function withBaseUrlAlias(string $baseUrlAlias): self
    {
        $new = clone $this;
        $new->baseUrlAlias = $baseUrlAlias;
        return $new;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Yii\Middleware;
6
7		use DateInterval;
8		use Psr\Http\Message\ResponseFactoryInterface;
9		use Psr\Http\Message\ResponseInterface;
10		use Psr\Http\Message\ServerRequestInterface;
11		use Psr\Http\Server\MiddlewareInterface;
12		use Psr\Http\Server\RequestHandlerInterface;
13		use Psr\Log\LoggerInterface;
14		use Yiisoft\Aliases\Aliases;
15		use Yiisoft\Cookies\Cookie;
16		use Yiisoft\Http\Header;
17		use Yiisoft\Http\Method;
18		use Yiisoft\Http\Status;
19		use Yiisoft\Router\UrlGeneratorInterface;
20		use Yiisoft\Session\SessionInterface;
21		use Yiisoft\Strings\WildcardPattern;
22		use Yiisoft\Translator\TranslatorInterface;
23		use Yiisoft\Yii\Middleware\Exception\InvalidLocalesFormatException;
24
25		final class Locale implements MiddlewareInterface
26		{
27		private const DEFAULT_LOCALE = 'en';
28		private const DEFAULT_LOCALE_NAME = '_language';
29
30		private bool $enableSaveLocale = true;
31		private bool $enableDetectLocale = false;
32		private string $defaultLocale = self::DEFAULT_LOCALE;
33		private string $queryParameterName = self::DEFAULT_LOCALE_NAME;
34		private string $sessionName = self::DEFAULT_LOCALE_NAME;
35		private ?DateInterval $cookieDuration;
36
37		/**
38		* @param array $locales List of supported locales in key-value format e.g. ['ru' => 'ru_RU', 'uz' => 'uz_UZ']
39		* @param string[] $ignoredRequests
40		*/
41	19	public function __construct(
42		private TranslatorInterface $translator,
43		private UrlGeneratorInterface $urlGenerator,
44		private SessionInterface $session,
45		private Aliases $aliases,
46		private LoggerInterface $logger,
47		private ResponseFactoryInterface $responseFactory,
48		private array $locales = [],
49		private array $ignoredRequests = [],
50		private bool $cookieSecure = false,
51		private string $baseUrlAlias = '@baseUrl',
52		) {
53	19	$this->cookieDuration = new DateInterval('P30D');
54		}
55
56	18	public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
57		{
58	18	if ($this->locales === []) {
59	1	return $handler->handle($request);
60		}
61
62	17	$this->assertLocalesFormat();
63
64	16	$uri = $request->getUri();
65	16	$path = $uri->getPath();
66	16	$query = $uri->getQuery();
67
68	16	$locale = $this->getLocaleFromPath($path);
69
70	16	if ($locale !== null) {
71	9	$this->translator->setLocale($this->locales[$locale]);
72	9	$this->urlGenerator->setDefaultArgument($this->queryParameterName, $locale);
73
74	9	$response = $handler->handle($request);
75	9	$newPath = null;
76	9	if ($this->isDefaultLocale($locale) && $request->getMethod() === Method::GET) {
77	3	$length = strlen($locale);
78	3	$newPath = substr($path, $length + 1);
79		}
80	9	return $this->applyLocaleFromPath($locale, $response, $query, $newPath);
81		}
82	7	if ($this->enableSaveLocale) {
83	7	$locale = $this->getLocaleFromRequest($request);
84		}
85	7	if ($locale === null && $this->enableDetectLocale) {
86	2	$locale = $this->detectLocale($request);
87		}
88	7	if ($locale === null \|\| $this->isDefaultLocale($locale) \|\| $this->isRequestIgnored($request)) {
89	2	$this->urlGenerator->setDefaultArgument($this->queryParameterName, null);
90	2	$request = $request->withUri($uri->withPath('/' . $this->defaultLocale . $path));
91	2	return $handler->handle($request);
92		}
93
94	5	$this->translator->setLocale($this->locales[$locale]);
95	5	$this->urlGenerator->setDefaultArgument($this->queryParameterName, $locale);
96
97	5	if ($request->getMethod() === Method::GET) {
98	4	$location = rtrim($this->aliases->get($this->baseUrlAlias), '/') . '/'
99	4	. $locale . $path . ($query !== '' ? '?' . $query : '');
100	4	return $this->responseFactory
101	4	->createResponse(Status::FOUND)
102	4	->withHeader(Header::LOCATION, $location);
103		}
104
105
106	1	return $handler->handle($request);
107		}
108
109	9	private function applyLocaleFromPath(
110		string $locale,
111		ResponseInterface $response,
112		string $query,
113		?string $newPath = null,
114		): ResponseInterface {
115	9	if ($newPath === '') {
116	1	$newPath = '/';
117		}
118
119	9	if ($newPath !== null) {
120	3	$location = rtrim($this->aliases->get($this->baseUrlAlias), '/')
121	3	. $newPath . ($query !== '' ? '?' . $query : '');
122	3	$response = $this->responseFactory
123	3	->createResponse(Status::FOUND)
124	3	->withHeader(Header::LOCATION, $location);
125		}
126	9	if ($this->enableSaveLocale) {
127	9	$response = $this->saveLocale($locale, $response);
128		}
129	9	return $response;
130		}
131
132	16	private function getLocaleFromPath(string $path): ?string
133		{
134	16	$parts = [];
135		/**
136		* @var string $code
137		* @var string $locale
138		*/
139	16	foreach ($this->locales as $code => $locale) {
140	16	$parts[] = $code;
141	16	$parts[] = $locale;
142		}
143
144	16	$pattern = implode('\|', $parts);
145	16	if (preg_match("#^/($pattern)\b(/?)#i", $path, $matches)) {
146	9	$matchedLocale = $matches[1];
147	9	if (!isset($this->locales[$matchedLocale])) {
148	1	$matchedLocale = $this->parseLocale($matchedLocale);
149		}
150	9	if (isset($this->locales[$matchedLocale])) {
151	9	$this->logger->debug(sprintf("Locale '%s' found in URL", $matchedLocale));
152	9	return $matchedLocale;
153		}
154		}
155	7	return null;
156		}
157
158	7	private function getLocaleFromRequest(ServerRequestInterface $request): ?string
159		{
160		/** @var array<string, string> $cookies */
161	7	$cookies = $request->getCookieParams();
162	7	if (isset($cookies[$this->sessionName])) {
163	1	$this->logger->debug(sprintf("Locale '%s' found in cookies", $cookies[$this->sessionName]));
164	1	return $this->parseLocale($cookies[$this->sessionName]);
165		}
166		/** @var array<string, string> $queryParameters */
167	6	$queryParameters = $request->getQueryParams();
168	6	if (isset($queryParameters[$this->queryParameterName])) {
169	4	$this->logger->debug(
170	4	sprintf("Locale '%s' found in query string", $queryParameters[$this->queryParameterName])
171	4	);
172	4	return $this->parseLocale($queryParameters[$this->queryParameterName]);
173		}
174	2	return null;
175		}
176
177	15	private function isDefaultLocale(string $locale): bool
178		{
179	15	return $locale === $this->defaultLocale \|\| $this->locales[$locale] === $this->defaultLocale;
180		}
181
182	2	private function detectLocale(ServerRequestInterface $request): ?string
183		{
184	2	foreach ($request->getHeader(Header::ACCEPT_LANGUAGE) as $language) {
185	1	if (!isset($this->locales[$language])) {
186	1	$language = $this->parseLocale($language);
187		}
188	1	if (isset($this->locales[$language])) {
189	1	return $language;
190		}
191		}
192	1	return null;
193		}
194
195	9	private function saveLocale(string $locale, ResponseInterface $response): ResponseInterface
196		{
197	9	$this->logger->debug('Saving found locale to cookies');
198	9	$this->session->set($this->sessionName, $locale);
199	9	$cookie = new Cookie(name: $this->sessionName, value: $locale, secure: $this->cookieSecure);
200	9	if ($this->cookieDuration !== null) {
201	9	$cookie = $cookie->withMaxAge($this->cookieDuration);
202		}
203	9	return $cookie->addToResponse($response);
204		}
205
206	7	private function parseLocale(string $locale): string
207		{
208	7	if (str_contains($locale, '-')) {
209	2	[$locale] = explode('-', $locale, 2);
210	5	} elseif (str_contains($locale, '_')) {
211	1	[$locale] = explode('_', $locale, 2);
212		}
213
214	7	return $locale;
215		}
216
217	6	private function isRequestIgnored(ServerRequestInterface $request): bool
218		{
219	6	foreach ($this->ignoredRequests as $ignoredRequest) {
220	1	if ((new WildcardPattern($ignoredRequest))->match($request->getUri()->getPath())) {
221	1	return true;
222		}
223		}
224	5	return false;
225		}
226
227		/**
228		* @throws InvalidLocalesFormatException
229		*/
230	17	private function assertLocalesFormat(): void
231		{
232	17	foreach ($this->locales as $code => $locale) {
233	17	if (!is_string($code) \|\| !is_string($locale)) {
234	1	throw new InvalidLocalesFormatException();
235		}
236		}
237		}
238
239		/**
240		* @param array $locales List of supported locales in key-value format e.g. ['ru' => 'ru_RU', 'uz' => 'uz_UZ']
241		*
242		* @return $this
243		*/
244	1	public function withLocales(array $locales): self
245		{
246	1	$new = clone $this;
247	1	$new->locales = $locales;
248	1	return $new;
249		}
250
251	3	public function withDefaultLocale(string $defaultLocale): self
252		{
253	3	$new = clone $this;
254	3	$new->defaultLocale = $defaultLocale;
255	3	return $new;
256		}
257
258	1	public function withQueryParameterName(string $queryParameterName): self
259		{
260	1	$new = clone $this;
261	1	$new->queryParameterName = $queryParameterName;
262	1	return $new;
263		}
264
265	1	public function withSessionName(string $sessionName): self
266		{
267	1	$new = clone $this;
268	1	$new->sessionName = $sessionName;
269	1	return $new;
270		}
271
272	1	public function withEnableSaveLocale(bool $enableSaveLocale): self
273		{
274	1	$new = clone $this;
275	1	$new->enableSaveLocale = $enableSaveLocale;
276	1	return $new;
277		}
278
279	3	public function withEnableDetectLocale(bool $enableDetectLocale): self
280		{
281	3	$new = clone $this;
282	3	$new->enableDetectLocale = $enableDetectLocale;
283	3	return $new;
284		}
285
286		/**
287		* @param string[] $ignoredRequests
288		*
289		* @return $this
290		*/
291	2	public function withIgnoredRequests(array $ignoredRequests): self
292		{
293	2	$new = clone $this;
294	2	$new->ignoredRequests = $ignoredRequests;
295	2	return $new;
296		}
297
298	1	public function withCookieSecure(bool $secure): self
299		{
300	1	$new = clone $this;
301	1	$new->cookieSecure = $secure;
302	1	return $new;
303		}
304
305	1	public function withBaseUrlAlias(string $baseUrlAlias): self
306		{
307	1	$new = clone $this;
308	1	$new->baseUrlAlias = $baseUrlAlias;
309	1	return $new;
310		}
311		}
312

yiisoft / yii-middleware

Pull Request — master (#50)

Locale::getLocaleFromRequest() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like