A17\Twill\Commands\SyncLang

Complexity

Total Complexity

20

Size/Duplication

Total Lines	156
Duplicated Lines	0 %

Test Coverage

Coverage

5.56%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	generateLangFileContent()	0	17	3
A	convertArrayToString()	0	8	1
A	getArrayFromCsv()	0	3	1
A	cleanup()	0	4	1
A	__construct()	0	4	1
A	generateLangFiles()	0	9	2
A	handle()	0	12	3
A	getLangCodesFromCsv()	0	8	1
A	getIndexByCode()	0	3	1
A	toCsv()	0	28	6

<?php

namespace A17\Twill\Commands;

use Illuminate\Console\Command;

This use statement conflicts with another class in this namespace, A17\Twill\Commands\Command. Consider defining an alias.

use Illuminate\Filesystem\Filesystem;
use Illuminate\Support\Arr;

class SyncLang extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'twill:lang {--toCsv}';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = "Sync the translations";

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

    protected $langDirPath = __DIR__ . '/../../lang';

    protected $csvPath = __DIR__ . '/../../lang/lang.csv';

    protected $langStubPath = __DIR__ . '/stubs/lang.stub';

    /**
     * @param ValidatorFactory $validatorFactory

The type A17\Twill\Commands\ValidatorFactory was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param Config $config

The type A17\Twill\Commands\Config was not found. Did you mean Config? If so, make sure to prefix the type with \.

     */
    public function __construct(Filesystem $files)
    {
        parent::__construct();
        $this->files = $files;
    }

    /**
     * Create super admin account.
     *
     * @return void
     */
    public function handle()
    {
        if ($this->option('toCsv')) {
            return $this->toCsv();

Are you sure the usage of $this->toCsv() targeting A17\Twill\Commands\SyncLang::toCsv() seems to always return null.

        }

        $this->info('Converting csv to lang files...');
        if ($this->confirm('This operation will overwrite all your changes made on lang file, are you sure?')) {
            $this->cleanup();
            $this->info('Generating the new lang directories...');
            $this->generateLangFiles();
            $this->info('Done!');
        }
    }

    // BETA METHOD, NOT STABLE
    private function toCsv()
    {
        if ($this->confirm('This operation will overwrite the lang.csv file, are you sure?')) {
            $csvArray = $this->getArrayFromCsv();
            foreach ($this->files->directories($this->langDirPath) as $directory) {
                $code = $this->files->basename($directory);
                $columnIndex = $this->getIndexByCode($code);
                $translations = $this->files->getRequire($directory . '/lang.php');
                foreach (Arr::dot($translations) as $key => $translation) {
                    $rowIndex = array_search($key, Arr::pluck(array_slice($csvArray, 2), 0));
                    if ($rowIndex === FALSE) {
                        $newRow = array_fill(0, count($csvArray[0]), "");
                        $newRow[0] = $key;
                        $newRow[$columnIndex] = $translation;
                        array_push($csvArray, $newRow);
                    } else {
                        $csvArray[$rowIndex + 2][$columnIndex] = $translation;
                    }
                }
            }

            $fp = fopen($this->csvPath, 'w');

            foreach ($csvArray as $row) {
                fputcsv($fp, $row);

It seems like $fp can also be of type false; however, parameter $handle of fputcsv() does only seem to accept resource, maybe add an additional type check?

            }

            fclose($fp);

It seems like $fp can also be of type false; however, parameter $handle of fclose() does only seem to accept resource, maybe add an additional type check?

        }
    }

    private function getArrayFromCsv()
    {
        return array_map('str_getcsv', file($this->csvPath));

It seems like file($this->csvPath) can also be of type false; however, parameter $arr1 of array_map() does only seem to accept array, maybe add an additional type check?

    }

    private function getLangCodesFromCsv()
    {
        $codes = $this->getArrayFromCsv()[1];

        // Remove the first element: row name
        array_shift($codes);

        return $codes;
    }

    private function generateLangFiles()
    {
        foreach ($this->getLangCodesFromCsv() as $code) {
            $langDirPath = $this->langDirPath . '/' . $code;
            $this->files->makeDirectory($langDirPath);
            $this->files->put(
                $this->langDirPath . '/' . $code . '/lang.php',
                // increment the index by one to match its actual index in csv
                $this->generateLangFileContent($code)
            );
        }
    }

    private function generateLangFileContent($code)
    {
        $content = [];
        $index = $this->getIndexByCode($code);

        foreach (array_slice($this->getArrayFromCsv(), 2) as $row) {
            $key = $row[0];
            $translation = $row[$index];
            if (!empty($translation)) {
                Arr::set($content, $key, $translation);
            }
        }

        return str_replace(
            ['{{content}}'],
            [$this->convertArrayToString($content)],
            $this->files->get($this->langStubPath)
        );
    }

    private function getIndexByCode($code)
    {
        return array_search($code, $this->getArrayFromCsv()[1]);
    }

    private function convertArrayToString($array)
    {
        $export = var_export($array, true);
        $export = preg_replace("/^([ ]*)(.*)/m", '$1$1$2', $export);
        $array = preg_split("/\r\n|\n|\r/", $export);
        $array = preg_replace(["/\s*array\s\($/", "/\)(,)?$/", "/\s=>\s$/"], [null, ']$1', ' => ['], $array);
        $export = join(PHP_EOL, array_filter(["["] + $array));
        return $export;
    }

    private function cleanup()
    {
        $this->info('Cleaning up the lang directories...');
        $this->files->deleteDirectories($this->langDirPath);
    }
}