Longman\LaravelMultiLang\MultiLang

Complexity

Total Complexity

43

Size/Duplication

Total Lines	329
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

94.57%

Importance

Changes	5
Bugs	1	Features	2

20 Methods

Rating	Name	Duplication	Size	Complexity
A	getUrl()	0	8	2
A	getLocale()	0	4	1
A	__construct()	0	8	1
A	setConfig()	0	21	2
A	getConfig()	0	8	3
A	setLocale()	0	19	4
B	loadTexts()	0	18	5
A	get()	0	20	4
A	getTexts()	0	5	1
A	setTexts()	0	11	2
A	queueToSave()	0	4	1
A	mustLoadFromCache()	0	4	1
A	storeTextsInCache()	0	6	1
A	loadTextsFromDatabase()	0	12	3
A	loadTextsFromCache()	0	6	1
A	setCacheName()	0	4	1
A	getCacheName()	0	4	1
A	autoSaveIsAllowed()	0	7	4
B	saveTexts()	0	26	4
A	getTableName()	0	5	1

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

namespace Longman\LaravelMultiLang;

use Illuminate\Contracts\Cache\Factory as CacheContract;
use Illuminate\Database\DatabaseManager as DatabaseContract;
use Illuminate\Support\Collection;
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 collection.
     *
     * @var \Illuminate\Support\Collection
     */
    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
     * @return void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct($environment, array $config, CacheContract $cache, DatabaseContract $db)
    {
        $this->environment = $environment;
        $this->cache       = $cache;

$cache is of type object<Illuminate\Contracts\Cache\Factory>, but the property $cache was declared to be of type object<Illuminate\Cache\CacheManager>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

        $this->db          = $db;

        $this->setConfig($config);
    }

    public function setConfig(array $config)
    {
        $this->config = [
            'enabled'        => true,
            'locales'        => [
                'en' => [
                    'name'        => 'English',
                    'native_name' => 'English',
                    'default'     => true,
                ],
            ],
            'autosave'       => true,
            'cache'          => true,
            'cache_lifetime' => 1440,
            'texts_table'    => 'texts',
        ];

        foreach ($config as $k => $v) {
            $this->config[$k] = $v;
        }
    }

    public function getConfig($key = null)
    {
        if ($key === null) {
            return $this->config;
        }

        return isset($this->config[$key]) ? $this->config[$key] : null;
    }

    /**
     * Set locale and load texts
     *
     * @param  string $lang
     * @param  array  $text

There is no parameter named $text. Was it maybe removed?

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

        $this->setCacheName($lang);

        if (is_array($texts)) {
            $texts = new Collection($texts);
        }

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

        $this->texts = new Collection($texts);
    }

    /**
     * Load texts
     *
     * @param  string  $lang
     * @return array
     */
    public function loadTexts($lang = null)
    {
        $cache = $this->getConfig('cache');

        if (!$cache || $this->cache === 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
     * @param  string   $default

There is no parameter named $default. Was it maybe removed?

     * @return string
     */
    public function get($key)
    {

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

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

        if (!$this->texts->has($key)) {
            $this->queueToSave($key);
            return $key;
        }

        $text = $this->texts->get($key);

        return $text;
    }

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

        return $this->texts->toArray();
    }

    /**
     * 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 = new Collection($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->cache->has($this->getCacheName());
    }

    protected function storeTextsInCache(array $texts)
    {
        $cache_lifetime = $this->getConfig('cache_lifetime', 1440);

The call to MultiLang::getConfig() has too many arguments starting with 1440.

        $status         = $this->cache->put($this->getCacheName(), $texts, $cache_lifetime);
        return $status;
    }

    public function loadTextsFromDatabase($lang)
    {
        $texts = $lang ? $this->db->table($this->getTableName())
            ->where('lang', $lang)
            ->get(['key', 'value', 'lang', 'scope']) : $this->db->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->cache->get($this->getCacheName());

The method get() cannot be called from this context as it is declared protected in class Illuminate\Cache\CacheManager.

        return $texts;
    }

    public function setCacheName($lang)
    {
        $this->cache_name = $this->getConfig('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('autosave') && $this->db !== null) {
            return true;
        }
        return false;
    }

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

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

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

            if ($exists) {
                continue;
            }

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

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