Locale::normalizeDomain() - Code Metrics - Inspection of "Several small cleanups" - XOOPS/XoopsCore - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#482)

by Richard

created 2016-04-11 23:15 UTC

Locale::normalizeDomain() A

↳ Parent: Locale

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	4
rs	10
c	1
b	0
f	0
ccs	0
cts	2
cp	0
cc	1
eloc	2
nc	1
nop	1
crap	2

<?php
/*
 You may not change or alter any portion of this comment or credits
 of supporting developers from this source code or any supporting source code
 which is considered copyrighted (c) material of the original comment or credit authors.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 */

namespace Xoops;

use Punic\Data;
use Punic\Exception\InvalidLocale;
use Xoops\Core\HttpRequest;
use Xmf\Request;
use Xoops\Core\Theme\XoopsTheme;

/**
 * Locale
 *
 * @author    trabis <[email protected]>
 * @copyright 2011-2015 XOOPS Project (http://xoops.org)
 * @license   GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
 */
class Locale
{
    const FALLBACK_LOCALE = 'en_US';

    protected static $currentLocale = null;
    protected static $currentTimeZone = null;
    protected static $defaultTimeZone = null;
    protected static $systemTimeZone = null;
    protected static $userLocales = array();

    /**
     * get the current active locale
     *
     * @return string current locale
     */
    public static function getCurrent()
    {
        // if none set, take the top of the user locales
        if (null === static::$currentLocale) {
            $localeArray = static::getUserLocales();
            static::$currentLocale = reset($localeArray);
        }
        return static::$currentLocale;
    }

    /**
     * Set the current locale
     *
     * @param string $locale local code
     *
     * @return void
     *
     * @throws InvalidLocale
     */
    public static function setCurrent($locale)
    {
        Data::setDefaultLocale($locale);
        static::$currentLocale = static::normalizeLocale($locale);
    }

    /**
     * Get the current timezone
     *
     * @return \DateTimeZone current timezone
     */
    public static function getTimeZone()
    {
        if (null === static::$currentTimeZone) {
            $xoops = \Xoops::getInstance();
            static::$currentTimeZone = static::getDefaultTimeZone();
            if ($xoops->isUser()) {
                $tz = $xoops->user->timezone();
                if (is_a($tz, '\DateTimeZone')) {
                    static::$currentTimeZone = $tz;
                } elseif (is_string($tz)) {
                    static::$currentTimeZone = static::newDateTimeZone($tz);
                }
            }
        }
        return static::$currentTimeZone;
    }

    /**
     * Set the current timezone
     *
     * @param \DateTimeZone $timeZone
     *
     * @return void
     */
    public static function setTimeZone(\DateTimeZone $timeZone)
    {
        static::$currentTimeZone = $timeZone;
    }

    /**
     * Instantiate a new DateTimeZone object for a timezone name, with fallback to UTC on error
     *
     * @param string $timeZoneName name of timezone
     *
     * @return \DateTimeZone
     */
    protected static function newDateTimeZone($timeZoneName)
    {
        try {
            $timeZone = new \DateTimeZone($timeZoneName);
        } catch (\Exception $e) {
            $timeZone = new \DateTimeZone('UTC');
        }

        return $timeZone;
    }

    /**
     * Get the default timezone as set in default_TZ config
     *
     * @return \DateTimeZone
     */
    public static function getDefaultTimeZone()
    {
        if (null === static::$defaultTimeZone) {
            $tz = \Xoops::getInstance()->getConfig('default_TZ');
            if (is_numeric($tz)) {
                $tz = 'UTC';
            }
            static::$defaultTimeZone = static::newDateTimeZone($tz);
        }
        return static::$defaultTimeZone;
    }

    /**
     * Get the server timezone as set in server_TZ config
     *
     * @return \DateTimeZone
     */
    public static function getSystemTimeZone()
    {
        if (null === static::$systemTimeZone) {
            $tz = \Xoops::getInstance()->getConfig('server_TZ');
            if (is_numeric($tz)) {
                $tz = 'UTC';
            }
            static::$systemTimeZone = static::newDateTimeZone($tz);
        }
        return static::$systemTimeZone;
    }

    /**
     * @param string $name     Name of language file to be loaded, without extension
     * @param mixed  $domain   string: Module dirname; global language file will be loaded if
     *                                 $domain is set to 'global' or not specified
     *                         array:  example; array('Frameworks/moduleclasses/moduleadmin')
     * @param string $language Language to be loaded, current language content will be loaded if not specified
     *
     * @return  boolean
     */
    public static function loadLanguage($name, $domain = '', $language = null)
    {
        if (empty($name)) {
            return false;
        }
        $language = empty($language) ? \XoopsLocale::getLegacyLanguage() : $language;
        // expanded domain to multiple categories, e.g. module:system, framework:filter, etc.
        if ((empty($domain) || 'global' === $domain)) {
            $path = '';
        } else {
            $path = (is_array($domain)) ? array_shift($domain) : "modules/{$domain}";
        }
        $xoops = \Xoops::getInstance();
        $fullPath = $xoops->path("{$path}/language/{$language}/{$name}.php");
        if (!$ret = \XoopsLoad::loadFile($fullPath)) {
            $fullPath2 = $xoops->path("{$path}/language/english/{$name}.php");
            $ret = \XoopsLoad::loadFile($fullPath2);
        }
        return $ret;
    }

    /**
     * @param string $domain       module dirname to load, if null will load global locale
     * @param string $forcedLocale Locale to be loaded, current language content will be loaded if not specified
     *
     * @return  boolean
     */
    public static function loadLocale($domain = null, $forcedLocale = null)
    {
        $xoops = \Xoops::getInstance();
        // expanded domain to multiple categories, e.g. module:system, framework:filter, etc.
        if ($domain === null) {
            $path = '';
            $domain = 'xoops';
        } else {
            $path = (is_array($domain)) ? array_shift($domain) : "modules/{$domain}";
        }
        if (null !== $forcedLocale) {
            try {
                Data::setDefaultLocale($locale);
            } catch (InvalidLocale $e) {

                return false;
            }
            $locales = [$forcedLocale];
            $locale = $forcedLocale;
        } else {
            $locales = self::getUserLocales();
            $locale = reset($locales);
            try {
                Data::setDefaultLocale($locale);
            } catch (InvalidLocale $e) {

                $locale = static::FALLBACK_LOCALE;
                array_shift($locales);
                array_unshift($locales, $locale);
                Data::setDefaultLocale($locale);
            }
        }
        foreach ($locales as $locale) {
            $fullPath = $xoops->path("{$path}/locale/{$locale}/locale.php");
            $fullPath2 = $xoops->path("{$path}/locale/{$locale}/{$locale}.php");
            if (\XoopsLoad::fileExists($fullPath)) {
                \XoopsLoad::addMap(array($domain . 'locale' => $fullPath));
                if (\XoopsLoad::fileExists($fullPath2)) {
                    \XoopsLoad::addMap(array(strtolower($domain . "locale{$locale}") => $fullPath2));
                }
                return true;
            }
        }
        return false;
    }

    /**
     * load locale for theme
     *
     * @param XoopsTheme $theme
     *
     * @return bool
     */
    public static function loadThemeLocale(XoopsTheme $theme)
    {
        $xoops = \Xoops::getInstance();
        $locales = self::getUserLocales();
        foreach ($locales as $locale) {
            $fullPath = $xoops->path($theme->resourcePath("locale/{$locale}/locale.php"));
            $fullPath2 = $xoops->path($theme->resourcePath("locale/{$locale}/{$locale}.php"));
            if (\XoopsLoad::fileExists($fullPath)) {
                \XoopsLoad::addMap(array(strtolower($theme->folderName . 'ThemeLocale') => $fullPath));
                if (\XoopsLoad::fileExists($fullPath2)) {
                    \XoopsLoad::addMap(array(strtolower($theme->folderName . "ThemeLocale{$locale}") => $fullPath2));
                }
                return true;
            }
        }
        return false;
    }

    /**
     * @return  boolean
     */
    public static function loadMailerLocale()
    {
        $xoops = \Xoops::getInstance();
        $locales = self::getUserLocales();
        foreach ($locales as $locale) {
            $fullPath = $xoops->path("locale/{$locale}/mailer.php");
            if (\XoopsLoad::fileExists($fullPath)) {
                \XoopsLoad::addMap(array(strtolower('XoopsMailerLocale') => $fullPath));
                return true;
            }
        }
        return false;
    }

    /**
     * @param string $key
     * @param string $dirname
     *
     * @return string
     */
    public static function translate($key, $dirname = 'xoops')
    {
        $class = self::getClassFromDirname($dirname);
        if (defined("$class::$key")) {
            return constant("$class::$key");
        } elseif (defined($key)) {
            return constant($key);
        }
        return $key;
    }

    /**
     * @param string $key
     * @param string $dirname
     *
     * @return string
     */
    public static function translateTheme($key, $dirname = '')
    {
        $class = self::getThemeClassFromDirname($dirname);

        if (defined("$class::$key")) {
            return constant("$class::$key");
        } elseif (defined($key)) {
            return constant($key);
        }
        return $key;
    }

    /**
     * @param string $dirname
     *
     * @return string
     */
    protected static function getClassFromDirname($dirname)
    {
        return ucfirst($dirname) . 'Locale';
    }

    /**
     * @param string $dirname
     *
     * @return string
     */
    protected static function getThemeClassFromDirname($dirname = '')
    {
        if (!$dirname) {
            $dirname = \Xoops::getInstance()->theme()->folderName;
        }
        return ucfirst($dirname) . 'ThemeLocale';
    }

    /**
     * getUserLocales()
     * Returns the user locales
     * Normally it returns an array like this:
     * 1. Forced language
     * 2. Language in $_GET['lang']
     * 3. Language in $_SESSION['lang']
     * 4. HTTP_ACCEPT_LANGUAGE
     * 5. Fallback language
     * Note: duplicate values are deleted.
     *
     * @return array with the user locales sorted by priority. Highest is best.
     */
    public static function getUserLocales()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
    {
        if (empty(self::$userLocales)) {
            // reset user_lang array
            $userLocales = array();

            // Highest priority: forced language
            //if ($this->forcedLang != NULL) {
            //    $userLocales[] = $this->forcedLang;
            //}

            // 2nd highest priority: GET parameter 'lang'
            $requestLocale = self::normalizeLocale(Request::getString('lang', ''));
            if (!empty($requestLocale)) {
                $userLocales[] = $requestLocale;
            }

            // 3rd highest priority: SESSION parameter 'lang'
            if (isset($_SESSION['lang']) && is_string($_SESSION['lang'])) {
                $userLocales[] = self::normalizeLocale($_SESSION['lang']);
            }

            // 4th highest priority: HTTP_ACCEPT_LANGUAGE
            $browserLocales = HttpRequest::getInstance()->getAcceptedLanguages();
            $browserLocales = array_keys($browserLocales);
            foreach ($browserLocales as $bloc) {
                $userLocales[] = self::normalizeLocale($bloc);
            }

            $configLocale = \Xoops::getInstance()->getConfig('locale');
            if (!empty($configLocale)) {
                $userLocales[] = $configLocale;
            }

            // Lowest priority: fallback
            $userLocales[] = static::FALLBACK_LOCALE;

            static::$userLocales = array_unique($userLocales);
        }
        return static::$userLocales;
    }

    /**
     * Convert a locale designation to a normal form ll_Ssss_CC, where
     *   ll   is language code
     *   Ssss is the script code, if specified
     *   CC   is the country code, if specified
     *
     * @param string $locale     locale code
     * @param string $separator  string to use to join locale parts
     * @param bool   $withScript include script if specified, always remove if false
     *
     * @return string normalized locale, or empty string on error
     */
    public static function normalizeLocale($locale, $separator = '_', $withScript = true)
    {
        try {
            $keys = Data::explodeLocale($locale);
            $key = strtolower($keys['language']);
            $key .= (empty($keys['script']) || false===$withScript) ?
                '' : $separator . ucfirst(strtolower($keys['script']));
            $key .= empty($keys['territory']) ? '' : $separator . strtoupper($keys['territory']);
        } catch (InvalidLocale $e) {

            $key = '';
        }

        return $key;
    }

    /**
     * Return a normalized form of a resource domain. A resource domain is always lowercase.
     *
     * @param string $domain resource domain (usually a module dirname)
     *
     * @return string normalized resource domain
     */
    public static function normalizeDomain($domain)
    {
        return strtolower($domain);
    }
}


1			<?php
2			/*
3			You may not change or alter any portion of this comment or credits
4			of supporting developers from this source code or any supporting source code
5			which is considered copyrighted (c) material of the original comment or credit authors.
6
7			This program is distributed in the hope that it will be useful,
8			but WITHOUT ANY WARRANTY; without even the implied warranty of
9			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
10			*/
11
12			namespace Xoops;
13
14			use Punic\Data;
15			use Punic\Exception\InvalidLocale;
16			use Xoops\Core\HttpRequest;
17			use Xmf\Request;
18			use Xoops\Core\Theme\XoopsTheme;
19
20			/**
21			* Locale
22			*
23			* @author trabis <[email protected]>
24			* @copyright 2011-2015 XOOPS Project (http://xoops.org)
25			* @license GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
26			*/
27			class Locale
28			{
29			const FALLBACK_LOCALE = 'en_US';
30
31			protected static $currentLocale = null;
32			protected static $currentTimeZone = null;
33			protected static $defaultTimeZone = null;
34			protected static $systemTimeZone = null;
35			protected static $userLocales = array();
36
37			/**
38			* get the current active locale
39			*
40			* @return string current locale
41			*/
42	24		public static function getCurrent()
43			{
44			// if none set, take the top of the user locales
45	24		if (null === static::$currentLocale) {
46	1		$localeArray = static::getUserLocales();
47	1		static::$currentLocale = reset($localeArray);
48	1		}
49	24		return static::$currentLocale;
50			}
51
52			/**
53			* Set the current locale
54			*
55			* @param string $locale local code
56			*
57			* @return void
58			*
59			* @throws InvalidLocale
60			*/
61	53		public static function setCurrent($locale)
62			{
63	53		Data::setDefaultLocale($locale);
64	53		static::$currentLocale = static::normalizeLocale($locale);
65	53		}
66
67			/**
68			* Get the current timezone
69			*
70			* @return \DateTimeZone current timezone
71			*/
72	38		public static function getTimeZone()
73			{
74	38		if (null === static::$currentTimeZone) {
75			$xoops = \Xoops::getInstance();
76			static::$currentTimeZone = static::getDefaultTimeZone();
77			if ($xoops->isUser()) {
78			$tz = $xoops->user->timezone();
79			if (is_a($tz, '\DateTimeZone')) {
80			static::$currentTimeZone = $tz;
81			} elseif (is_string($tz)) {
82			static::$currentTimeZone = static::newDateTimeZone($tz);
83			}
84			}
85			}
86	38		return static::$currentTimeZone;
87			}
88
89			/**
90			* Set the current timezone
91			*
92			* @param \DateTimeZone $timeZone
93			*
94			* @return void
95			*/
96	53		public static function setTimeZone(\DateTimeZone $timeZone)
97			{
98	53		static::$currentTimeZone = $timeZone;
99	53		}
100
101			/**
102			* Instantiate a new DateTimeZone object for a timezone name, with fallback to UTC on error
103			*
104			* @param string $timeZoneName name of timezone
105			*
106			* @return \DateTimeZone
107			*/
108			protected static function newDateTimeZone($timeZoneName)
109			{
110			try {
111			$timeZone = new \DateTimeZone($timeZoneName);
112			} catch (\Exception $e) {
113			$timeZone = new \DateTimeZone('UTC');
114			}
115
116			return $timeZone;
117			}
118
119			/**
120			* Get the default timezone as set in default_TZ config
121			*
122			* @return \DateTimeZone
123			*/
124		View Code Duplication	public static function getDefaultTimeZone()
125			{
126			if (null === static::$defaultTimeZone) {
127			$tz = \Xoops::getInstance()->getConfig('default_TZ');
128			if (is_numeric($tz)) {
129			$tz = 'UTC';
130			}
131			static::$defaultTimeZone = static::newDateTimeZone($tz);
132			}
133			return static::$defaultTimeZone;
134			}
135
136			/**
137			* Get the server timezone as set in server_TZ config
138			*
139			* @return \DateTimeZone
140			*/
141		View Code Duplication	public static function getSystemTimeZone()
142			{
143			if (null === static::$systemTimeZone) {
144			$tz = \Xoops::getInstance()->getConfig('server_TZ');
145			if (is_numeric($tz)) {
146			$tz = 'UTC';
147			}
148			static::$systemTimeZone = static::newDateTimeZone($tz);
149			}
150			return static::$systemTimeZone;
151			}
152
153			/**
154			* @param string $name Name of language file to be loaded, without extension
155			* @param mixed $domain string: Module dirname; global language file will be loaded if
156			* $domain is set to 'global' or not specified
157			* array: example; array('Frameworks/moduleclasses/moduleadmin')
158			* @param string $language Language to be loaded, current language content will be loaded if not specified
159			*
160			* @return boolean
161			*/
162	1		public static function loadLanguage($name, $domain = '', $language = null)
163			{
164	1		if (empty($name)) {
165	1		return false;
166			}
167	1		$language = empty($language) ? \XoopsLocale::getLegacyLanguage() : $language;
168			// expanded domain to multiple categories, e.g. module:system, framework:filter, etc.
169	1	View Code Duplication	if ((empty($domain) \|\| 'global' === $domain)) {
170	1		$path = '';
171	1		} else {
172			$path = (is_array($domain)) ? array_shift($domain) : "modules/{$domain}";
173			}
174	1		$xoops = \Xoops::getInstance();
175	1		$fullPath = $xoops->path("{$path}/language/{$language}/{$name}.php");
176	1		if (!$ret = \XoopsLoad::loadFile($fullPath)) {
177	1		$fullPath2 = $xoops->path("{$path}/language/english/{$name}.php");
178	1		$ret = \XoopsLoad::loadFile($fullPath2);
179	1		}
180	1		return $ret;
181			}
182
183			/**
184			* @param string $domain module dirname to load, if null will load global locale
185			* @param string $forcedLocale Locale to be loaded, current language content will be loaded if not specified
186			*
187			* @return boolean
188			*/
189	4		public static function loadLocale($domain = null, $forcedLocale = null)
190			{
191	4		$xoops = \Xoops::getInstance();
192			// expanded domain to multiple categories, e.g. module:system, framework:filter, etc.
193	4	View Code Duplication	if ($domain === null) {
194	1		$path = '';
195	1		$domain = 'xoops';
196	1		} else {
197	3		$path = (is_array($domain)) ? array_shift($domain) : "modules/{$domain}";
198			}
199	4		if (null !== $forcedLocale) {
200			try {
201			Data::setDefaultLocale($locale);
202			} catch (InvalidLocale $e) {
			0 ignored issues – show Bug introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The class `Punic\Exception\InvalidLocale` does not exist. Did you forget a USE statement, or did you not list all dependencies? Scrutinizer analyzes your `composer.json`/`composer.lock` file if available to determine the classes, and functions that are defined by your dependencies. It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis. Loading history...
203			return false;
204			}
205			$locales = [$forcedLocale];
206			$locale = $forcedLocale;
207			} else {
208	4		$locales = self::getUserLocales();
209	4		$locale = reset($locales);
210			try {
211	4		Data::setDefaultLocale($locale);
212	4		} catch (InvalidLocale $e) {
			0 ignored issues – show Bug introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The class `Punic\Exception\InvalidLocale` does not exist. Did you forget a USE statement, or did you not list all dependencies? Scrutinizer analyzes your `composer.json`/`composer.lock` file if available to determine the classes, and functions that are defined by your dependencies. It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis. Loading history...
213			$locale = static::FALLBACK_LOCALE;
214			array_shift($locales);
215			array_unshift($locales, $locale);
216			Data::setDefaultLocale($locale);
217			}
218			}
219	4		foreach ($locales as $locale) {
220	4		$fullPath = $xoops->path("{$path}/locale/{$locale}/locale.php");
221	4		$fullPath2 = $xoops->path("{$path}/locale/{$locale}/{$locale}.php");
222	4	View Code Duplication	if (\XoopsLoad::fileExists($fullPath)) {
223	4		\XoopsLoad::addMap(array($domain . 'locale' => $fullPath));
224	4		if (\XoopsLoad::fileExists($fullPath2)) {
225	4		\XoopsLoad::addMap(array(strtolower($domain . "locale{$locale}") => $fullPath2));
226	4		}
227	4		return true;
228			}
229	4		}
230			return false;
231			}
232
233			/**
234			* load locale for theme
235			*
236			* @param XoopsTheme $theme
237			*
238			* @return bool
239			*/
240	4		public static function loadThemeLocale(XoopsTheme $theme)
241			{
242	4		$xoops = \Xoops::getInstance();
243	4		$locales = self::getUserLocales();
244	4		foreach ($locales as $locale) {
245	4		$fullPath = $xoops->path($theme->resourcePath("locale/{$locale}/locale.php"));
246	4		$fullPath2 = $xoops->path($theme->resourcePath("locale/{$locale}/{$locale}.php"));
247	4	View Code Duplication	if (\XoopsLoad::fileExists($fullPath)) {
248	4		\XoopsLoad::addMap(array(strtolower($theme->folderName . 'ThemeLocale') => $fullPath));
249	4		if (\XoopsLoad::fileExists($fullPath2)) {
250	4		\XoopsLoad::addMap(array(strtolower($theme->folderName . "ThemeLocale{$locale}") => $fullPath2));
251	4		}
252	4		return true;
253			}
254	4		}
255			return false;
256			}
257
258			/**
259			* @return boolean
260			*/
261	2		public static function loadMailerLocale()
262			{
263	2		$xoops = \Xoops::getInstance();
264	2		$locales = self::getUserLocales();
265	2		foreach ($locales as $locale) {
266	2		$fullPath = $xoops->path("locale/{$locale}/mailer.php");
267	2		if (\XoopsLoad::fileExists($fullPath)) {
268	2		\XoopsLoad::addMap(array(strtolower('XoopsMailerLocale') => $fullPath));
269	2		return true;
270			}
271	2		}
272			return false;
273			}
274
275			/**
276			* @param string $key
277			* @param string $dirname
278			*
279			* @return string
280			*/
281	3	View Code Duplication	public static function translate($key, $dirname = 'xoops')
282			{
283	3		$class = self::getClassFromDirname($dirname);
284	3		if (defined("$class::$key")) {
285	1		return constant("$class::$key");
286	2		} elseif (defined($key)) {
287			return constant($key);
288			}
289	2		return $key;
290			}
291
292			/**
293			* @param string $key
294			* @param string $dirname
295			*
296			* @return string
297			*/
298	1	View Code Duplication	public static function translateTheme($key, $dirname = '')
299			{
300	1		$class = self::getThemeClassFromDirname($dirname);
301
302	1		if (defined("$class::$key")) {
303			return constant("$class::$key");
304	1		} elseif (defined($key)) {
305			return constant($key);
306			}
307	1		return $key;
308			}
309
310			/**
311			* @param string $dirname
312			*
313			* @return string
314			*/
315	3		protected static function getClassFromDirname($dirname)
316			{
317	3		return ucfirst($dirname) . 'Locale';
318			}
319
320			/**
321			* @param string $dirname
322			*
323			* @return string
324			*/
325	1		protected static function getThemeClassFromDirname($dirname = '')
326			{
327	1		if (!$dirname) {
328	1		$dirname = \Xoops::getInstance()->theme()->folderName;
329	1		}
330	1		return ucfirst($dirname) . 'ThemeLocale';
331			}
332
333			/**
334			* getUserLocales()
335			* Returns the user locales
336			* Normally it returns an array like this:
337			* 1. Forced language
338			* 2. Language in $_GET['lang']
339			* 3. Language in $_SESSION['lang']
340			* 4. HTTP_ACCEPT_LANGUAGE
341			* 5. Fallback language
342			* Note: duplicate values are deleted.
343			*
344			* @return array with the user locales sorted by priority. Highest is best.
345			*/
346	10		public static function getUserLocales()
			0 ignored issues – show Coding Style introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report `getUserLocales` uses the super-global variable `$_SESSION` which is generally not recommended. Instead of super-globals, we recommend to explicitly inject the dependencies of your class. This makes your code less dependent on global state and it becomes generally more testable: // Bad class Router { public function generate($path) { return $_SERVER['HOST'].$path; } } // Better class Router { private $host; public function __construct($host) { $this->host = $host; } public function generate($path) { return $this->host.$path; } } class Controller { public function myAction(Request $request) { // Instead of $page = isset($_GET['page']) ? intval($_GET['page']) : 1; // Better (assuming you use the Symfony2 request) $page = $request->query->get('page', 1); } } Loading history...
347			{
348	10		if (empty(self::$userLocales)) {
349			// reset user_lang array
350			$userLocales = array();
351
352			// Highest priority: forced language
353			//if ($this->forcedLang != NULL) {
354			// $userLocales[] = $this->forcedLang;
355			//}
356
357			// 2nd highest priority: GET parameter 'lang'
358			$requestLocale = self::normalizeLocale(Request::getString('lang', ''));
359			if (!empty($requestLocale)) {
360			$userLocales[] = $requestLocale;
361			}
362
363			// 3rd highest priority: SESSION parameter 'lang'
364			if (isset($_SESSION['lang']) && is_string($_SESSION['lang'])) {
365			$userLocales[] = self::normalizeLocale($_SESSION['lang']);
366			}
367
368			// 4th highest priority: HTTP_ACCEPT_LANGUAGE
369			$browserLocales = HttpRequest::getInstance()->getAcceptedLanguages();
370			$browserLocales = array_keys($browserLocales);
371			foreach ($browserLocales as $bloc) {
372			$userLocales[] = self::normalizeLocale($bloc);
373			}
374
375			$configLocale = \Xoops::getInstance()->getConfig('locale');
376			if (!empty($configLocale)) {
377			$userLocales[] = $configLocale;
378			}
379
380			// Lowest priority: fallback
381			$userLocales[] = static::FALLBACK_LOCALE;
382
383			static::$userLocales = array_unique($userLocales);
384			}
385	10		return static::$userLocales;
386			}
387
388			/**
389			* Convert a locale designation to a normal form ll_Ssss_CC, where
390			* ll is language code
391			* Ssss is the script code, if specified
392			* CC is the country code, if specified
393			*
394			* @param string $locale locale code
395			* @param string $separator string to use to join locale parts
396			* @param bool $withScript include script if specified, always remove if false
397			*
398			* @return string normalized locale, or empty string on error
399			*/
400	68		public static function normalizeLocale($locale, $separator = '_', $withScript = true)
401			{
402			try {
403	68		$keys = Data::explodeLocale($locale);
404	68		$key = strtolower($keys['language']);
405	68		$key .= (empty($keys['script']) \|\| false===$withScript) ?
406	68		'' : $separator . ucfirst(strtolower($keys['script']));
407	68		$key .= empty($keys['territory']) ? '' : $separator . strtoupper($keys['territory']);
408	68		} catch (InvalidLocale $e) {
			0 ignored issues – show Bug introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The class `Punic\Exception\InvalidLocale` does not exist. Did you forget a USE statement, or did you not list all dependencies? Scrutinizer analyzes your `composer.json`/`composer.lock` file if available to determine the classes, and functions that are defined by your dependencies. It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis. Loading history...
409			$key = '';
410			}
411
412	68		return $key;
413			}
414
415			/**
416			* Return a normalized form of a resource domain. A resource domain is always lowercase.
417			*
418			* @param string $domain resource domain (usually a module dirname)
419			*
420			* @return string normalized resource domain
421			*/
422			public static function normalizeDomain($domain)
423			{
424			return strtolower($domain);
425			}
426			}
427

XOOPS / XoopsCore

Pull Request — master (#482)

Locale::normalizeDomain() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like