MultiLang::mustLoadFromCache() - Code Metrics - Inspection of "added routes and views for publish" - akalongman/laravel-multilang - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 49cc2f...b2199f )

unknown

created 2016-04-23 15:53 UTC

MultiLang::mustLoadFromCache() A

↳ Parent: MultiLang

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	5
Bugs	2	Features	2

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

<?php
/*
 * This file is part of the Laravel MultiLang package.
 *
 * (c) Avtandil Kikabidze aka LONGMAN <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Longman\LaravelMultiLang;

use Illuminate\Cache\CacheManager as Cache;
use Illuminate\Database\DatabaseManager as Database;
use Illuminate\Http\Request;
use InvalidArgumentException;

class MultiLang
{
    /**
     * Language/Locale.
     *
     * @var string
     */
    protected $lang;

    /**
     * System environment
     *
     * @var string
     */
    protected $environment;

    /**
     * The instance of the cache.
     *
     * @var \Illuminate\Cache\CacheManager
     */
    protected $cache;

    /**
     * Config.
     *
     * @var array
     */
    protected $config;

    /**
     * The instance of the database.
     *
     * @var \Illuminate\Database\DatabaseManager
     */
    protected $db;

    /**
     * Name of the cache.
     *
     * @var string
     */
    protected $cache_name;

    /**
     * Texts.
     *
     * @var array
     */
    protected $texts;

    /**
     * Missing texts.
     *
     * @var array
     */
    protected $new_texts;

    /**
     * Create a new MultiLang instance.
     *
     * @param string                               $environment
     * @param array                                $config
     * @param \Illuminate\Cache\CacheManager       $cache
     * @param \Illuminate\Database\DatabaseManager $db
     */
    public function __construct($environment, array $config, Cache $cache, Database $db)
    {
        $this->environment = $environment;
        $this->cache       = $cache;
        $this->db          = $db;

        $this->setConfig($config);
    }

    public function setConfig(array $config)
    {
        $this->config = $config;
        return $this;
    }

    public function getConfig($key = null, $default = null)
    {
        $array = $this->config;

        if ($key === null) {
            return $array;
        }

        if (array_key_exists($key, $array)) {
            return $array[$key];
        }

        foreach (explode('.', $key) as $segment) {
            if (is_array($array) && array_key_exists($segment, $array)) {
                $array = $array[$segment];
            } else {
                return $default;
            }
        }

        return $array;
    }

    /**
     * Get a cache driver instance.
     *
     * @return \Illuminate\Contracts\Cache\Repository
     */
    public function getCache()
    {
        if ($this->getConfig('cache.enabled', true) === false) {
            return null;
        }
        $store = $this->getConfig('cache.store', 'default');
        if ($store == 'default') {
            return $this->cache->store();
        }
        return $this->cache->store($store);
    }

    /**
     * Get a database connection instance.
     *
     * @return \Illuminate\Database\Connection
     */
    public function getDb()
    {
        $connection = $this->getConfig('db.connection');
        if ($connection == 'default') {
            return $this->db->connection();
        }
        return $this->db->connection($connection);
    }

    /**
     * Set locale and load texts
     *
     * @param  string $lang
     * @param  array  $texts
     * @return void
     */
    public function setLocale($lang, array $texts = null)
    {
        if (!$lang) {
            throw new InvalidArgumentException('Locale is empty');
        }
        $this->lang = $lang;

        $this->setCacheName($lang);

        if (!is_array($texts)) {
            $texts = $this->loadTexts($this->getLocale());
        }

        $this->texts = $texts;
    }

    /**
     * Load texts
     *
     * @param  string  $lang
     * @return array
     */
    public function loadTexts($lang = null)
    {
        if ($this->getCache() === null || $this->environment != 'production') {
            $texts = $this->loadTextsFromDatabase($lang);
            return $texts;
        }

        if ($this->mustLoadFromCache()) {
            $texts = $this->loadTextsFromCache();
        } else {
            $texts = $this->loadTextsFromDatabase($lang);
            $this->storeTextsInCache($texts);
        }

        return $texts;
    }

    /**
     * Get translated text
     *
     * @param  string   $key
     * @return string
     */
    public function get($key)
    {

        if (empty($key)) {
            throw new InvalidArgumentException('String key not provided');
        }

        if (!$this->lang) {
            return $key;
        }

        if (!isset($this->texts[$key])) {
            $this->queueToSave($key);
            return $key;
        }

        $text = $this->texts[$key];

        return $text;
    }

    /**
     * Get texts
     *
     * @return array
     */
    public function getRedirectUrl(Request $request)
    {
        $locale          = $request->segment(1);
        $fallback_locale = $this->getConfig('default_locale');

        if (strlen($locale) == 2) {
            $locales = $this->getConfig('locales');

            if (!isset($locales[$locale])) {
                $segments    = $request->segments();
                $segments[0] = $fallback_locale;
                $url         = implode('/', $segments);
                if ($query_string = $request->server->get('QUERY_STRING')) {
                    $url .= '?' . $query_string;
                }

                return $url;
            }
        } else {
            $segments = $request->segments();
            $url      = $fallback_locale . '/' . implode('/', $segments);
            if ($query_string = $request->server->get('QUERY_STRING')) {
                $url .= '?' . $query_string;
            }
            return $url;
        }

        return null;
    }

    public function detectLocale(Request $request)
    {
        $locale  = $request->segment(1);
        $locales = $this->getConfig('locales');

        if (isset($locales[$locale])) {
            return isset($locales[$locale]['locale']) ? $locales[$locale]['locale'] : $locale;
        }

        return $this->getConfig('default_locale', 'en');
    }

    /**
     * Get texts
     *
     * @return array
     */
    public function getTexts()
    {

        return $this->texts;
    }

    /**
     * Set texts manually
     *
     * @param  array                                 $texts_array
     * @return \Longman\LaravelMultiLang\MultiLang
     */
    public function setTexts(array $texts_array)
    {
        $texts = [];
        foreach ($texts_array as $key => $value) {
            $texts[$key] = $value;
        }

        $this->texts = $texts;

        return $this;
    }

    /**
     * Queue missing texts
     *
     * @param  string $key
     * @return void
     */
    protected function queueToSave($key)
    {
        $this->new_texts[$key] = $key;
    }

    /**
     * Check if we must load texts from cache
     *
     * @return bool
     */
    public function mustLoadFromCache()
    {
        return $this->getCache()->has($this->getCacheName());
    }

    protected function storeTextsInCache(array $texts)
    {
        $this->getCache()->put($this->getCacheName(), $texts, $this->getConfig('cache.lifetime', 1440));
        return $this;
    }

    public function loadTextsFromDatabase($lang)
    {
        $texts = $lang ? $this->getDb()->table($this->getTableName())
            ->where('lang', $lang)
            ->get(['key', 'value', 'lang', 'scope']) : $this->getDb()->table($this->getTableName())->get(['key', 'value', 'lang', 'scope']);

        $array = [];
        foreach ($texts as $row) {
            $array[$row->key] = $row->value;
        }
        return $array;
    }

    public function loadTextsFromCache()
    {
        $texts = $this->getCache()->get($this->getCacheName());

        return $texts;
    }

    public function setCacheName($lang)
    {
        $this->cache_name = $this->getConfig('db.texts_table') . '_' . $lang;
    }

    public function getCacheName()
    {
        return $this->cache_name;
    }

    public function getUrl($path)
    {
        $locale = $this->getLocale();
        if ($locale) {
            $path = $locale . '/' . $path;
        }
        return $path;
    }

    public function autoSaveIsAllowed()
    {
        if ($this->environment == 'local' && $this->getConfig('db.autosave', true) && $this->getDb() !== null) {
            return true;
        }
        return false;
    }

    public function getLocale()
    {
        return $this->lang;
    }

    public function saveTexts()
    {
        if (empty($this->new_texts)) {
            return false;
        }

        $table   = $this->getTableName();
        $locales = $this->getConfig('locales');

        foreach ($this->new_texts as $k => $v) {
            foreach ($locales as $lang => $locale_data) {
                $exists = $this->getDb()->table($table)->where([
                    'key'  => $k,
                    'lang' => $lang,
                ])->first();

                if ($exists) {
                    continue;
                }

                $this->getDb()->table($table)->insert([
                    'key'   => $k,
                    'lang'  => $lang,
                    'value' => $v,
                ]);
            }
        }
        return true;
    }

    protected function getTableName()
    {
        $table = $this->getConfig('db.texts_table', 'texts');
        return $table;
    }
}


1		<?php
2		/*
3		* This file is part of the Laravel MultiLang package.
4		*
5		* (c) Avtandil Kikabidze aka LONGMAN <[email protected]>
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		*/
10
11		namespace Longman\LaravelMultiLang;
12
13		use Illuminate\Cache\CacheManager as Cache;
14		use Illuminate\Database\DatabaseManager as Database;
15		use Illuminate\Http\Request;
16		use InvalidArgumentException;
17
18		class MultiLang
19		{
20		/**
21		* Language/Locale.
22		*
23		* @var string
24		*/
25		protected $lang;
26
27		/**
28		* System environment
29		*
30		* @var string
31		*/
32		protected $environment;
33
34		/**
35		* The instance of the cache.
36		*
37		* @var \Illuminate\Cache\CacheManager
38		*/
39		protected $cache;
40
41		/**
42		* Config.
43		*
44		* @var array
45		*/
46		protected $config;
47
48		/**
49		* The instance of the database.
50		*
51		* @var \Illuminate\Database\DatabaseManager
52		*/
53		protected $db;
54
55		/**
56		* Name of the cache.
57		*
58		* @var string
59		*/
60		protected $cache_name;
61
62		/**
63		* Texts.
64		*
65		* @var array
66		*/
67		protected $texts;
68
69		/**
70		* Missing texts.
71		*
72		* @var array
73		*/
74		protected $new_texts;
75
76		/**
77		* Create a new MultiLang instance.
78		*
79		* @param string $environment
80		* @param array $config
81		* @param \Illuminate\Cache\CacheManager $cache
82		* @param \Illuminate\Database\DatabaseManager $db
83		*/
84	24	public function __construct($environment, array $config, Cache $cache, Database $db)
85		{
86	24	$this->environment = $environment;
87	24	$this->cache = $cache;
88	24	$this->db = $db;
89
90	24	$this->setConfig($config);
91	24	}
92
93	24	public function setConfig(array $config)
94		{
95	24	$this->config = $config;
96	24	return $this;
97		}
98
99	21	public function getConfig($key = null, $default = null)
100		{
101	21	$array = $this->config;
102
103	21	if ($key === null) {
104		return $array;
105		}
106
107	21	if (array_key_exists($key, $array)) {
108	7	return $array[$key];
109		}
110
111	21	foreach (explode('.', $key) as $segment) {
112	21	if (is_array($array) && array_key_exists($segment, $array)) {
113	21	$array = $array[$segment];
114	21	} else {
115		return $default;
116		}
117	21	}
118
119	21	return $array;
120		}
121
122		/**
123		* Get a cache driver instance.
124		*
125		* @return \Illuminate\Contracts\Cache\Repository
126		*/
127	18	public function getCache()
128		{
129	18	if ($this->getConfig('cache.enabled', true) === false) {
130	1	return null;
131		}
132	17	$store = $this->getConfig('cache.store', 'default');
133	17	if ($store == 'default') {
134		return $this->cache->store();
135		}
136	17	return $this->cache->store($store);
137		}
138
139		/**
140		* Get a database connection instance.
141		*
142		* @return \Illuminate\Database\Connection
143		*/
144	18	public function getDb()
145		{
146	18	$connection = $this->getConfig('db.connection');
147	18	if ($connection == 'default') {
148	18	return $this->db->connection();
149		}
150		return $this->db->connection($connection);
151		}
152
153		/**
154		* Set locale and load texts
155		*
156		* @param string $lang
157		* @param array $texts
158		* @return void
159		*/
160	22	public function setLocale($lang, array $texts = null)
161		{
162	22	if (!$lang) {
163	1	throw new InvalidArgumentException('Locale is empty');
164		}
165	21	$this->lang = $lang;
166
167	21	$this->setCacheName($lang);
168
169	21	if (!is_array($texts)) {
170	18	$texts = $this->loadTexts($this->getLocale());
171	18	}
172
173	21	$this->texts = $texts;
174	21	}
175
176		/**
177		* Load texts
178		*
179		* @param string $lang
180		* @return array
181		*/
182	18	public function loadTexts($lang = null)
183		{
184	18	if ($this->getCache() === null \|\| $this->environment != 'production') {
185	15	$texts = $this->loadTextsFromDatabase($lang);
186	15	return $texts;
187		}
188
189	4	if ($this->mustLoadFromCache()) {
190		$texts = $this->loadTextsFromCache();
191		} else {
192	4	$texts = $this->loadTextsFromDatabase($lang);
193	4	$this->storeTextsInCache($texts);
194		}
195
196	4	return $texts;
197		}
198
199		/**
200		* Get translated text
201		*
202		* @param string $key
203		* @return string
204		*/
205	8	public function get($key)
206		{
207
208	8	if (empty($key)) {
209	1	throw new InvalidArgumentException('String key not provided');
210		}
211
212	7	if (!$this->lang) {
213	1	return $key;
214		}
215
216	6	if (!isset($this->texts[$key])) {
217	4	$this->queueToSave($key);
218	4	return $key;
219		}
220
221	2	$text = $this->texts[$key];
222
223	2	return $text;
224		}
225
226		/**
227		* Get texts
228		*
229		* @return array
230		*/
231	4	public function getRedirectUrl(Request $request)
232		{
233	4	$locale = $request->segment(1);
234	4	$fallback_locale = $this->getConfig('default_locale');
235
236	4	if (strlen($locale) == 2) {
237	3	$locales = $this->getConfig('locales');
238
239	3	if (!isset($locales[$locale])) {
240	2	$segments = $request->segments();
241	2	$segments[0] = $fallback_locale;
242	2	$url = implode('/', $segments);
243	2	if ($query_string = $request->server->get('QUERY_STRING')) {
244	1	$url .= '?' . $query_string;
245	1	}
246
247	2	return $url;
248		}
249	1	} else {
250	1	$segments = $request->segments();
251	1	$url = $fallback_locale . '/' . implode('/', $segments);
252	1	if ($query_string = $request->server->get('QUERY_STRING')) {
253		$url .= '?' . $query_string;
254		}
255	1	return $url;
256		}
257
258	1	return null;
259		}
260
261	1	public function detectLocale(Request $request)
262		{
263	1	$locale = $request->segment(1);
264	1	$locales = $this->getConfig('locales');
265
266	1	if (isset($locales[$locale])) {
267	1	return isset($locales[$locale]['locale']) ? $locales[$locale]['locale'] : $locale;
268		}
269
270		return $this->getConfig('default_locale', 'en');
271		}
272
273		/**
274		* Get texts
275		*
276		* @return array
277		*/
278	4	public function getTexts()
279		{
280
281	4	return $this->texts;
282		}
283
284		/**
285		* Set texts manually
286		*
287		* @param array $texts_array
288		* @return \Longman\LaravelMultiLang\MultiLang
289		*/
290	3	public function setTexts(array $texts_array)
291		{
292	3	$texts = [];
293	3	foreach ($texts_array as $key => $value) {
294	3	$texts[$key] = $value;
295	3	}
296
297	3	$this->texts = $texts;
298
299	3	return $this;
300		}
301
302		/**
303		* Queue missing texts
304		*
305		* @param string $key
306		* @return void
307		*/
308	4	protected function queueToSave($key)
309		{
310	4	$this->new_texts[$key] = $key;
311	4	}
312
313		/**
314		* Check if we must load texts from cache
315		*
316		* @return bool
317		*/
318	4	public function mustLoadFromCache()
319		{
320	4	return $this->getCache()->has($this->getCacheName());
321		}
322
323	4	protected function storeTextsInCache(array $texts)
324		{
325	4	$this->getCache()->put($this->getCacheName(), $texts, $this->getConfig('cache.lifetime', 1440));
326	4	return $this;
327		}
328
329	18	public function loadTextsFromDatabase($lang)
330		{
331	18	$texts = $lang ? $this->getDb()->table($this->getTableName())
332	18	->where('lang', $lang)
333	18	->get(['key', 'value', 'lang', 'scope']) : $this->getDb()->table($this->getTableName())->get(['key', 'value', 'lang', 'scope']);
334
335	18	$array = [];
336	18	foreach ($texts as $row) {
337	13	$array[$row->key] = $row->value;
338	18	}
339	18	return $array;
340		}
341
342	1	public function loadTextsFromCache()
343		{
344	1	$texts = $this->getCache()->get($this->getCacheName());
345
346	1	return $texts;
347		}
348
349	21	public function setCacheName($lang)
350		{
351	21	$this->cache_name = $this->getConfig('db.texts_table') . '_' . $lang;
352	21	}
353
354	4	public function getCacheName()
355		{
356	4	return $this->cache_name;
357		}
358
359	2	public function getUrl($path)
360		{
361	2	$locale = $this->getLocale();
362	2	if ($locale) {
363	2	$path = $locale . '/' . $path;
364	2	}
365	2	return $path;
366		}
367
368	5	public function autoSaveIsAllowed()
369		{
370	5	if ($this->environment == 'local' && $this->getConfig('db.autosave', true) && $this->getDb() !== null) {
371	1	return true;
372		}
373	5	return false;
374		}
375
376	19	public function getLocale()
377		{
378	19	return $this->lang;
379		}
380
381	3	public function saveTexts()
382		{
383	3	if (empty($this->new_texts)) {
384	3	return false;
385		}
386
387	3	$table = $this->getTableName();
388	3	$locales = $this->getConfig('locales');
389
390	3	foreach ($this->new_texts as $k => $v) {
391	3	foreach ($locales as $lang => $locale_data) {
392	3	$exists = $this->getDb()->table($table)->where([
393	3	'key' => $k,
394	3	'lang' => $lang,
395	3	])->first();
396
397	3	if ($exists) {
398	1	continue;
399		}
400
401	3	$this->getDb()->table($table)->insert([
402	3	'key' => $k,
403	3	'lang' => $lang,
404	3	'value' => $v,
405	3	]);
406	3	}
407	3	}
408	3	return true;
409		}
410
411	18	protected function getTableName()
412		{
413	18	$table = $this->getConfig('db.texts_table', 'texts');
414	18	return $table;
415		}
416		}
417

akalongman / laravel-multilang

Push — master ( 49cc2f...b2199f )

MultiLang::mustLoadFromCache() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like