Terranet\Administrator\Services\TranslationsManager

Complexity

Total Complexity

22

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	files()	0	18	3
A	save()	0	18	4
A	locales()	0	3	1
A	loadTranslationFile()	0	9	2
A	filters()	0	13	3
A	keyToArray()	0	6	2
A	exporter()	0	3	1
A	arrayToString()	0	6	1
A	setLocales()	0	5	1
A	makeFile()	0	11	2
A	load()	0	5	1
A	__construct()	0	4	1

<?php

namespace Terranet\Administrator\Services;

use Illuminate\Filesystem\Filesystem;
use Illuminate\Support\Collection;
use Illuminate\Support\Str;
use Terranet\Administrator\Services\Translations\Reader;
use Zend\Code\Generator\ValueGenerator;

class TranslationsManager
{
    /** @var Collection */
    protected $locales;

    /** @var Translations\Reader */
    protected $reader;

    /** @var Filesystem */
    protected $filesystem;

    /**
     * TranslationsManager constructor.
     */
    public function __construct(Reader $translationsReader, Filesystem $filesystem)
    {
        $this->reader = $translationsReader;
        $this->filesystem = $filesystem;
    }

    /**
     * @param Collection $locales
     * @return $this
     */
    public function setLocales(Collection $locales)
    {
        $this->locales = $locales;

        return $this;
    }

    /**
     * @param null $term

Are you sure the doc-type for parameter $term is correct as it would always require null to be passed?

     * @param null $only

Are you sure the doc-type for parameter $only is correct as it would always require null to be passed?

     * @param int $page
     * @param int $perPage
     * @return \Illuminate\Pagination\LengthAwarePaginator

The type Illuminate\Pagination\LengthAwarePaginator was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public function load($term = null, $only = null, $page = 1, $perPage = 20)
    {
        return (new Translations\Finder())->find(
            $this->reader->read($this->files($only), $this->locales()),
            $term, $page, $perPage
        );
    }

    /**
     * @return Translations\Exporter
     */
    public function exporter()
    {
        return new Translations\Exporter();
    }

    /**
     * Retrieves public filters.
     *
     * @return mixed
     */
    public function filters()
    {
        $filters = $this->files();

        if ($only = config('administrator.translations.filters.only', [])) {

The function config was not found. Maybe you did not declare it correctly or list all dependencies?

            $filters = $filters->intersect($only);
        }

        if ($except = config('administrator.translations.filters.except', [])) {
            $filters = $filters->diff($except);
        }

        return $filters;
    }

    /**
     * @param $translation
     * @param $locale
     */
    public function save($translation, $locale)
    {
        $translations = [];

        foreach ($translation as $key => $value) {
            $this->keyToArray($translations, $key, $value[$locale]);
        }

        foreach ($translations as $key => $value) {
            if (!$translations = $this->loadTranslationFile($key, $locale)) {
                continue;
            }

            $data = array_replace_recursive($translations['content'], $value);

            $content = '<?php'.str_repeat(PHP_EOL, 2).'return '.$this->arrayToString($data).';';

            $this->filesystem->put($translations['path'], $content, true);
        }
    }

    /**
     * @param null $only

Are you sure the doc-type for parameter $only is correct as it would always require null to be passed?

     * @return Collection
     */
    protected function files($only = null): Collection
    {
        static $files = null;

        if (null === $files) {
            $path = 'lang'.\DIRECTORY_SEPARATOR.\localizer\locale()->iso6391();

            $files = collect(
                glob(resource_path("{$path}/*.php"))

The function resource_path was not found. Maybe you did not declare it correctly or list all dependencies?

            );

            $files = $files->map(function ($file) {
                return Str::replaceLast('.php', '', basename($file));
            }, $files);

The call to Illuminate\Support\Collection::map() has too many arguments starting with $files.

        }

        return $files->when($only, function (Collection $files) use ($only) {
            return $files->intersect(\is_array($only) ? $only : [$only]);

The condition is_array($only) is always false.

        });
    }

    /**
     * @param $file
     * @param $locale
     * @return array
     */
    protected function loadTranslationFile($file, $locale)
    {
        if (!file_exists($path = $this->reader->pathToFile($file, $locale))) {
            $this->makeFile($file, $locale);
        }

        return [
            'path' => $path,
            'content' => include_once $path,
        ];
    }

    /**
     * @param $file
     * @param $locale
     */
    protected function makeFile($file, $locale)
    {
        $directoryTranslationsPath = resource_path('lang'.\DIRECTORY_SEPARATOR.$locale);

The function resource_path was not found. Maybe you did not declare it correctly or list all dependencies?

        if (!$this->filesystem->exists($directoryTranslationsPath)) {
            $this->filesystem->makeDirectory($directoryTranslationsPath);
        }

        $content = '<?php'.str_repeat(PHP_EOL, 2).'return [];';

        $this->filesystem->put($directoryTranslationsPath.\DIRECTORY_SEPARATOR.$file.'.php', $content, true);
    }

    /**
     * @param $arr
     * @param $path
     * @param $value
     * @param string $separator
     */
    protected function keyToArray(&$arr, $path, $value, $separator = '.')
    {
        foreach ($keys = explode($separator, $path) as $key) {

The assignment to $keys is dead and can be removed.

            $arr = &$arr[$key];
        }
        $arr = $value;
    }

    /**
     * @param $data
     * @return string
     */
    protected function arrayToString($data): string
    {
        $generator = new ValueGenerator($data, ValueGenerator::TYPE_ARRAY_SHORT);
        $generator->setIndentation('    '); // 4 spaces

        return $generator->generate();
    }

    /**
     * @return Collection
     */
    protected function locales(): Collection
    {
        return collect($this->locales);
    }
}