I18N::getFilePath() - Code Metrics - Inspection of "Laravel 5.5 compatibility" - RocketPropelledTortoise/Core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 488702...18fedf )

by Stéphane

created 2020-04-12 20:22 UTC

I18N::getFilePath() A

↳ Parent: I18N

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

/**
 * Translation management
 */
namespace Rocket\Translation;

use Exception;
use Illuminate\Contracts\Cache\Repository as CacheRepository;
use Illuminate\Contracts\Config\Repository as ConfigRepository;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Contracts\Session\Session;
use Illuminate\Contracts\Logging\Log;
use Request;
use Rocket\Translation\Model\Language;
use Rocket\Translation\Model\StringModel;
use Rocket\Translation\Model\Translation;

/**
 * Class I18N
 */
class I18N implements I18NInterface
{
    /**
     * An array of the loaded languages
     * @var array
     */
    protected $languagesLoaded = [];

    /**
     * An array of existing languages by ISO
     * @var array
     */
    protected $languagesIso = [];

    /**
     * An array of existing languages by ID
     * @var array
     */
    protected $languagesId = [];

    /**
     * Language currently in use
     * @var string
     */
    protected $currentLanguage;

    /**
     * Language currently in use (ID)
     * @var string
     */
    protected $currentLanguageId;

    /**
     * All the translation strings
     * @var array
     */
    protected $strings = [];

    /**
     * Context of the current page
     * @var string
     */
    protected $pageContext;

    /**
     * Strings cache
     * @var array
     */
    protected $stringsRaw = [];

    /**
     * @var CacheRepository The cache to store the terms in
     */
    protected $cache;

    /**
     * @var Session The session store
     */
    protected $session;

    /**
     * @var Log The log writer
     */
    protected $log;

    /**
     * @var ConfigRepository
     */
    protected $config;

    /**
     * @var Application
     */
    protected $app;

    /**
     * Prepare the translation service
     *
     * @param Application $app
     */
    public function __construct(Application $app, CacheRepository $cache, Session $session, Log $log, ConfigRepository $config)
    {
        $this->app = $app;
        $this->cache = $cache;
        $this->session = $session;
        $this->log = $log;

        $lang = $this->cache->remember(
            'Lang::List',
            60 * 24,
            function () {
                return Language::all();
            }
        );

        foreach ($lang as $l) {
            $this->languagesIso[$l->iso] = $this->languagesId[$l->id] = [
                'id' => $l->id,
                'name' => $l->title,
                'iso' => $l->iso,
            ];
        }

        $locale = $config['app.locale'];
        $fallback = $config['app.fallback_locale'];

        //current default language
        $language = $this->getDefaultLanguage($locale, $fallback);
        $this->setLanguage($language);
    }

    protected function getFilePath() {
        return $this->app['path.storage'] . '/languages/';
    }

    /**
     * Detects the default languages in the following order :
     *
     * 1. Is a user session var defined ?
     * 2. Can we take it from the browser ?
     * 3. Take the site default
     *
     * @param $locale string
     * @param $fallback string
     * @throws Exception if a default language cannot be found
     * @return string
     */
    public function getDefaultLanguage($locale, $fallback)
    {
        //1. detect user session
        $session_lang = $this->session->get('language');

        if (!empty($session_lang)) {
            return $session_lang;
        }

        //TODO :: move languages to subdomains
        //Special workaroud : only french for the moment
        if (defined('F_LANGUAGES') && !F_LANGUAGES) {
            return 'fr';
        }

        //2. detect browser language
        $browser_languages = Request::getLanguages();

        //is one of them available ?
        foreach ($browser_languages as $lang) {
            if ($this->isAvailable($lang)) {
                $this->session->put('language', $lang);

                return $lang;
            }
        }

        //3. Site default
        if ($this->isAvailable($locale)) {
            return $locale;
        }

        //4. Site fallback
        if ($this->isAvailable($fallback)) {
            return $fallback;
        }

        throw new \Exception('Cannot find an adapted language');
    }

    /**
     * Set the current language
     *
     * @param  string $language
     * @return bool
     */
    public function setCurrentLanguage($language)
    {
        if (!$this->isAvailable($language)) {
            return false;
        }

        $this->session->put('language', $language);

        $this->setLanguage($language);

        return true;
    }

    /**
     * Load a language file
     *
     * @param  string $language
     * @return bool
     */
    public function loadLanguage($language)
    {
        if ($this->isLoaded($language)) {
            return;
        }

        $langfile = $language . '.php';

        $this->strings[$language] = [];

        // Determine where the language file is and load it
        $filePath = $this->getFilePath();
        if (file_exists($filePath . $langfile)) {
            $this->strings[$language] = include $filePath . $langfile;
        }

        $this->languagesLoaded[] = $language;
    }

    /**
     * Get the current language
     * @return string
     */
    public function getCurrent()
    {
        return $this->currentLanguage;
    }

    /**
     * Get the current language id
     * @return int
     */
    public function getCurrentId()
    {
        return $this->currentLanguageId;
    }

    /**
     * Set the language to use
     *
     * @param  string $language
     * @return bool
     */
    public function setLanguage($language)
    {
        if ($language == $this->currentLanguage) {
            return;
        }

        if (!$this->isLoaded($language)) {
            $this->loadLanguage($language);
        }

        switch ($language) {
            case 'fr':
                setlocale(LC_ALL, 'fr_FR.utf8', 'fr_FR.UTF-8', 'fr_FR@euro', 'fr_FR', 'french');
                break;
            case 'en':
                setlocale(LC_ALL, 'en_US.utf8', 'en_US.UTF-8', 'en_US');
                break;
            case 'de':
                setlocale(LC_ALL, 'de_DE.utf8', 'de_DE.UTF-8', 'de_DE@euro', 'de_DE', 'deutsch');
                break;
        }

        $this->currentLanguage = $language;
        $this->currentLanguageId = $this->languagesIso[$language]['id'];
    }

    /**
     * Checks if a language is loaded or not
     *
     * @param  string $language
     * @return bool
     */
    protected function isLoaded($language)
    {
        return in_array($language, $this->languagesLoaded);
    }

    /**
     * Checks if a language is the default one
     *
     * @param  string $language
     * @return bool
     */
    protected function isDefault($language)
    {
        if ($language == 'default' or $this->currentLanguage == $language) {
            return true;
        }

        return false;
    }

    /**
     * Checks if the language is availavble
     *
     * @param  string $language
     * @return bool
     */
    protected function isAvailable($language)
    {
        return array_key_exists($language, $this->languagesIso);
    }

    /**
     * Retrieve languages.
     *
     * this is a hybrid method.
     *
     *
     *     I18N::languages();
     *     returns ['fr' => ['id' => 1, 'name' => 'francais', 'iso' => 'fr'], 'en' => ...]
     *
     *
     *     I18N::languages('fr');
     *     returns ['id' => 1, 'name' => 'francais', 'iso' => 'fr']
     *
     *
     *     I18N::languages(1);
     *     returns ['id' => 1, 'name' => 'francais', 'iso' => 'fr']
     *
     *
     *     I18N::languages('fr', 'id');
     *     returns 1
     *
     * @param int|string $key
     * @param string $subkey
     * @return array
     */
    public function languages($key = null, $subkey = null)
    {
        if ($key === null) {
            return $this->languagesIso;
        }

        if (is_int($key)) {
            if (is_null($subkey)) {
                return $this->languagesId[$key];
            }

            return $this->languagesId[$key][$subkey];
        }

        if (is_null($subkey)) {
            return $this->languagesIso[$key];
        }

        return $this->languagesIso[$key][$subkey];
    }

    public function languagesForSelect()
    {
        $languages = [];
        foreach (static::languages() as $lang) {
            $languages[$lang['id']] = t($lang['name'], [], 'languages');
        }

        return $languages;
    }

    protected function translateGetString($context, $language, $string_id)
    {
        $row = Translation::select('text')
            ->where('string_id', $string_id)
            ->where('language_id', $this->languagesIso[$language]['id'])
            ->first();

        if ($row !== null) {
            return $row->text;
        }

        return false;
    }

    protected function translateInsertString($context, $text)
    {
        $string = new StringModel();
        $string->date_creation = mysql_datetime();
        $string->context = $context;
        $string->string = $text;
        $string->save();

        //insertion de la traduction par défaut.
        $translation = new Translation();
        $translation->string_id = $string->id;
        $translation->language_id = $this->languagesIso[$this->config['app.locale']]['id'];
        $translation->date_edition = mysql_datetime();
        $translation->text = $text;
        $translation->save();

        return $translation;
    }

    /**
     * Retreive a string to translate
     *
     * if it doesn't find it, put it in the database
     *
     * @param  string $string
     * @param  string $context
     * @param  string $language
     * @return string
     */
    public function translate($string, $context = 'default', $language = 'default')
    {
        if ($this->isDefault($language)) {
            $language = $this->currentLanguage;
        } else {
            $this->setLanguage($language);
        }

        //get string from cache
        if (array_key_exists($context, $this->strings[$language]) &&
            array_key_exists($string, $this->strings[$language][$context])) {
            return $this->strings[$language][$context][$string];
        }

        //check in db
        $db_string = StringModel::select('id', 'date_creation')
            ->where('string', $string)
            ->where('context', $context)
            ->first();

        if (!$db_string) {
            $this->translateInsertString($context, $string);

            return $string;
        }

        $text = $this->translateGetString($context, $language, $db_string->id);
        if ($text) {
            $this->strings[$language][$context][$string] = $text;

            return $text;
        }

        return $string;
    }

    /**
     * Get the cached strings
     *
     * @return array
     */
    public function getRawStrings()
    {
        return $this->stringsRaw;
    }

    /**
     * Get the page's context
     *
     * @return string
     */
    public function getContext()
    {
        if ($this->pageContext) {
            return $this->pageContext;
        }

        $current = \Route::getCurrentRoute();

        if (!$current) {
            return 'default';
        }

        if ($current->getName()) {
            return $this->pageContext = $current->getName();
        }

        $action = $current->getAction();
        if (array_key_exists('controller', $action)) {
            return $this->pageContext = $action['controller'];
        }

        return $this->pageContext = implode('/', array_map(['Str', 'slug'], explode('/', $current->getUri())));
    }

    public function generate()
    {
        $filePath = $this->getFilePath();

        if (!is_dir($filePath)) {
            mkdir($filePath, 0755, true);
            chmod($filePath, 0755);
        }

        foreach ($this->languages() as $lang => $d) {
            $strings = StringModel::select('string', 'text', 'context')
                ->where('language_id', $d['id'])
                ->join((new Translation)->getTable(), 'strings.id', '=', 'string_id', 'left')
                ->get();

            $final_strings = [];
            foreach ($strings as $s) {
                $final_strings[$s->context][$s->string] = $s->text;
            }

            file_put_contents("{$filePath}{$lang}.php", '<?php return ' . var_export($final_strings, true) . ';');
        }
    }
}


1		<?php
2
3		/**
4		* Translation management
5		*/
6		namespace Rocket\Translation;
7
8		use Exception;
9		use Illuminate\Contracts\Cache\Repository as CacheRepository;
10		use Illuminate\Contracts\Config\Repository as ConfigRepository;
11		use Illuminate\Contracts\Foundation\Application;
12		use Illuminate\Contracts\Session\Session;
13		use Illuminate\Contracts\Logging\Log;
14		use Request;
15		use Rocket\Translation\Model\Language;
16		use Rocket\Translation\Model\StringModel;
17		use Rocket\Translation\Model\Translation;
18
19		/**
20		* Class I18N
21		*/
22		class I18N implements I18NInterface
23		{
24		/**
25		* An array of the loaded languages
26		* @var array
27		*/
28		protected $languagesLoaded = [];
29
30		/**
31		* An array of existing languages by ISO
32		* @var array
33		*/
34		protected $languagesIso = [];
35
36		/**
37		* An array of existing languages by ID
38		* @var array
39		*/
40		protected $languagesId = [];
41
42		/**
43		* Language currently in use
44		* @var string
45		*/
46		protected $currentLanguage;
47
48		/**
49		* Language currently in use (ID)
50		* @var string
51		*/
52		protected $currentLanguageId;
53
54		/**
55		* All the translation strings
56		* @var array
57		*/
58		protected $strings = [];
59
60		/**
61		* Context of the current page
62		* @var string
63		*/
64		protected $pageContext;
65
66		/**
67		* Strings cache
68		* @var array
69		*/
70		protected $stringsRaw = [];
71
72		/**
73		* @var CacheRepository The cache to store the terms in
74		*/
75		protected $cache;
76
77		/**
78		* @var Session The session store
79		*/
80		protected $session;
81
82		/**
83	177	* @var Log The log writer
84		*/
85	177	protected $log;
86	177
87	177	/**
88	177	* @var ConfigRepository
89		*/
90	177	protected $config;
91	177
92	177	/**
93	177	* @var Application
94	177	*/
95		protected $app;
96	177
97		/**
98	177	* Prepare the translation service
99	177	*
100	177	* @param Application $app
101	177	*/
102	177	public function __construct(Application $app, CacheRepository $cache, Session $session, Log $log, ConfigRepository $config)
103		{
104	177	$this->app = $app;
105		$this->cache = $cache;
106	177	$this->session = $session;
107	177	$this->log = $log;
108
109		$lang = $this->cache->remember(
110	177	'Lang::List',
111	177	60 * 24,
112	177	function () {
113		return Language::all();
114		}
115		);
116
117		foreach ($lang as $l) {
118		$this->languagesIso[$l->iso] = $this->languagesId[$l->id] = [
119		'id' => $l->id,
120		'name' => $l->title,
121		'iso' => $l->iso,
122		];
123		}
124
125		$locale = $config['app.locale'];
126	177	$fallback = $config['app.fallback_locale'];
127
128		//current default language
129	177	$language = $this->getDefaultLanguage($locale, $fallback);
130		$this->setLanguage($language);
131	177	}
132
133		protected function getFilePath() {
134		return $this->app['path.storage'] . '/languages/';
135		}
136
137	177	/**
138		* Detects the default languages in the following order :
139		*
140		* 1. Is a user session var defined ?
141		* 2. Can we take it from the browser ?
142	177	* 3. Take the site default
143		*
144		* @param $locale string
145	177	* @param $fallback string
146	177	* @throws Exception if a default language cannot be found
147	177	* @return string
148		*/
149	177	public function getDefaultLanguage($locale, $fallback)
150		{
151	177	//1. detect user session
152		$session_lang = $this->session->get('language');
153
154		if (!empty($session_lang)) {
155		return $session_lang;
156		}
157
158		//TODO :: move languages to subdomains
159		//Special workaroud : only french for the moment
160		if (defined('F_LANGUAGES') && !F_LANGUAGES) {
161		return 'fr';
162		}
163
164		//2. detect browser language
165		$browser_languages = Request::getLanguages();
166
167		//is one of them available ?
168		foreach ($browser_languages as $lang) {
169		if ($this->isAvailable($lang)) {
170		$this->session->put('language', $lang);
171
172		return $lang;
173		}
174		}
175
176		//3. Site default
177		if ($this->isAvailable($locale)) {
178		return $locale;
179		}
180
181		//4. Site fallback
182		if ($this->isAvailable($fallback)) {
183		return $fallback;
184		}
185
186		throw new \Exception('Cannot find an adapted language');
187		}
188
189		/**
190		* Set the current language
191	177	*
192		* @param string $language
193	177	* @return bool
194		*/
195		public function setCurrentLanguage($language)
196		{
197	177	if (!$this->isAvailable($language)) {
198		return false;
199	177	}
200
201		$this->session->put('language', $language);
202	177
203		$this->setLanguage($language);
204
205		return true;
206	177	}
207	177
208		/**
209		* Load a language file
210		*
211		* @param string $language
212		* @return bool
213	27	*/
214		public function loadLanguage($language)
215	27	{
216		if ($this->isLoaded($language)) {
217		return;
218		}
219
220		$langfile = $language . '.php';
221
222	150	$this->strings[$language] = [];
223
224	150	// Determine where the language file is and load it
225		$filePath = $this->getFilePath();
226		if (file_exists($filePath . $langfile)) {
227		$this->strings[$language] = include $filePath . $langfile;
228		}
229
230		$this->languagesLoaded[] = $language;
231		}
232
233	177	/**
234		* Get the current language
235	177	* @return string
236	156	*/
237		public function getCurrent()
238		{
239	177	return $this->currentLanguage;
240	177	}
241	177
242		/**
243		* Get the current language id
244	177	* @return int
245	21	*/
246	21	public function getCurrentId()
247	177	{
248	177	return $this->currentLanguageId;
249	177	}
250
251		/**
252		* Set the language to use
253		*
254		* @param string $language
255	177	* @return bool
256	177	*/
257	177	public function setLanguage($language)
258		{
259		if ($language == $this->currentLanguage) {
260		return;
261		}
262
263		if (!$this->isLoaded($language)) {
264		$this->loadLanguage($language);
265	177	}
266
267	177	switch ($language) {
268		case 'fr':
269		setlocale(LC_ALL, 'fr_FR.utf8', 'fr_FR.UTF-8', 'fr_FR@euro', 'fr_FR', 'french');
270		break;
271		case 'en':
272		setlocale(LC_ALL, 'en_US.utf8', 'en_US.UTF-8', 'en_US');
273		break;
274		case 'de':
275		setlocale(LC_ALL, 'de_DE.utf8', 'de_DE.UTF-8', 'de_DE@euro', 'de_DE', 'deutsch');
276		break;
277		}
278
279		$this->currentLanguage = $language;
280		$this->currentLanguageId = $this->languagesIso[$language]['id'];
281		}
282
283		/**
284		* Checks if a language is loaded or not
285		*
286		* @param string $language
287		* @return bool
288		*/
289		protected function isLoaded($language)
290		{
291	177	return in_array($language, $this->languagesLoaded);
292		}
293	177
294		/**
295		* Checks if a language is the default one
296		*
297		* @param string $language
298		* @return bool
299		*/
300		protected function isDefault($language)
301		{
302		if ($language == 'default' or $this->currentLanguage == $language) {
303		return true;
304		}
305
306		return false;
307		}
308
309		/**
310		* Checks if the language is availavble
311		*
312		* @param string $language
313		* @return bool
314		*/
315		protected function isAvailable($language)
316		{
317		return array_key_exists($language, $this->languagesIso);
318		}
319
320		/**
321	36	* Retrieve languages.
322		*
323	36	* this is a hybrid method.
324	33	*
325		*
326		* I18N::languages();
327	3	* returns ['fr' => ['id' => 1, 'name' => 'francais', 'iso' => 'fr'], 'en' => ...]
328		*
329		*
330		* I18N::languages('fr');
331		* returns ['id' => 1, 'name' => 'francais', 'iso' => 'fr']
332		*
333		*
334		* I18N::languages(1);
335	3	* returns ['id' => 1, 'name' => 'francais', 'iso' => 'fr']
336		*
337		*
338		* I18N::languages('fr', 'id');
339	3	* returns 1
340		*
341		* @param int\|string $key
342		* @param string $subkey
343		* @return array
344		*/
345		public function languages($key = null, $subkey = null)
346		{
347		if ($key === null) {
348		return $this->languagesIso;
349		}
350
351		if (is_int($key)) {
352		if (is_null($subkey)) {
353		return $this->languagesId[$key];
354		}
355
356		return $this->languagesId[$key][$subkey];
357		}
358
359		if (is_null($subkey)) {
360		return $this->languagesIso[$key];
361		}
362
363		return $this->languagesIso[$key][$subkey];
364		}
365
366		public function languagesForSelect()
367		{
368		$languages = [];
369		foreach (static::languages() as $lang) {
370		$languages[$lang['id']] = t($lang['name'], [], 'languages');
371		}
372
373		return $languages;
374		}
375
376		protected function translateGetString($context, $language, $string_id)
377		{
378		$row = Translation::select('text')
379		->where('string_id', $string_id)
380		->where('language_id', $this->languagesIso[$language]['id'])
381		->first();
382
383		if ($row !== null) {
384		return $row->text;
385		}
386
387		return false;
388		}
389
390		protected function translateInsertString($context, $text)
391		{
392		$string = new StringModel();
393		$string->date_creation = mysql_datetime();
394		$string->context = $context;
395		$string->string = $text;
396		$string->save();
397
398		//insertion de la traduction par défaut.
399		$translation = new Translation();
400		$translation->string_id = $string->id;
401		$translation->language_id = $this->languagesIso[$this->config['app.locale']]['id'];
402		$translation->date_edition = mysql_datetime();
403		$translation->text = $text;
404		$translation->save();
405
406		return $translation;
407		}
408
409		/**
410		* Retreive a string to translate
411		*
412		* if it doesn't find it, put it in the database
413		*
414		* @param string $string
415		* @param string $context
416		* @param string $language
417		* @return string
418		*/
419		public function translate($string, $context = 'default', $language = 'default')
420		{
421		if ($this->isDefault($language)) {
422		$language = $this->currentLanguage;
423		} else {
424		$this->setLanguage($language);
425		}
426
427		//get string from cache
428		if (array_key_exists($context, $this->strings[$language]) &&
429		array_key_exists($string, $this->strings[$language][$context])) {
430		return $this->strings[$language][$context][$string];
431		}
432
433		//check in db
434		$db_string = StringModel::select('id', 'date_creation')
435		->where('string', $string)
436		->where('context', $context)
437		->first();
438
439		if (!$db_string) {
440		$this->translateInsertString($context, $string);
441
442		return $string;
443		}
444
445		$text = $this->translateGetString($context, $language, $db_string->id);
446		if ($text) {
447		$this->strings[$language][$context][$string] = $text;
448
449		return $text;
450		}
451
452		return $string;
453		}
454
455		/**
456		* Get the cached strings
457		*
458		* @return array
459		*/
460		public function getRawStrings()
461		{
462		return $this->stringsRaw;
463		}
464
465		/**
466		* Get the page's context
467		*
468		* @return string
469		*/
470		public function getContext()
471		{
472		if ($this->pageContext) {
473		return $this->pageContext;
474		}
475
476		$current = \Route::getCurrentRoute();
477
478		if (!$current) {
479		return 'default';
480		}
481
482		if ($current->getName()) {
483		return $this->pageContext = $current->getName();
484		}
485
486		$action = $current->getAction();
487		if (array_key_exists('controller', $action)) {
488		return $this->pageContext = $action['controller'];
489		}
490
491		return $this->pageContext = implode('/', array_map(['Str', 'slug'], explode('/', $current->getUri())));
492		}
493
494		public function generate()
495		{
496		$filePath = $this->getFilePath();
497
498		if (!is_dir($filePath)) {
499		mkdir($filePath, 0755, true);
500		chmod($filePath, 0755);
501		}
502
503		foreach ($this->languages() as $lang => $d) {
504		$strings = StringModel::select('string', 'text', 'context')
505		->where('language_id', $d['id'])
506		->join((new Translation)->getTable(), 'strings.id', '=', 'string_id', 'left')
507		->get();
508
509		$final_strings = [];
510		foreach ($strings as $s) {
511		$final_strings[$s->context][$s->string] = $s->text;
512		}
513
514		file_put_contents("{$filePath}{$lang}.php", '<?php return ' . var_export($final_strings, true) . ';');
515		}
516		}
517		}
518

RocketPropelledTortoise / Core

Push — master ( 488702...18fedf )

I18N::getFilePath() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like