Charcoal\Translator\Script\TranslationParserScript

Complexity

Total Complexity

44

Size/Duplication

Total Lines	516
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	setDependencies()	0	6	1
A	defaultArguments()	0	48	1
B	run()	0	26	1
B	displayInformations()	0	24	1
A	filePath()	0	11	2
A	locales()	0	4	1
A	locale()	0	4	1
A	output()	0	9	2
A	domain()	0	4	1
A	regEx()	0	20	3
A	getTranslations()	0	22	3
B	getTranslationsFromPath()	0	49	5
A	globRecursive()	0	14	2
A	path()	0	7	2
A	paths()	0	11	2
A	fileTypes()	0	10	2
B	toCSV()	0	39	6
A	enclosure()	0	4	1
A	separator()	0	4	1
A	maxRecursiveLevel()	0	7	2
A	phpFunction()	0	8	2
A	mustacheTag()	0	7	2

<?php
namespace Charcoal\Translator\Script;

use Pimple\Container;

// PSR-7 (http messaging) dependencies
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

// Intra-module (`charcoal-admin`) dependencies
use Charcoal\Admin\AdminScript;

use Charcoal\Translator\TranslatorAwareTrait;

/**
 * Find all strings to be translated in templates
 */
class TranslationParserScript extends AdminScript
{
    use TranslatorAwareTrait;

    /**
     * App configurations from dependencies
     * @var AppConfig
     */
    private $appConfig;

    /**
     * @var string $fileType
     */
    protected $fileType;

    /**
     * Output file
     * @var string $output
     */
    protected $output;

    /**
     * @var array $paths
     */
    protected $paths;

    /**
     * @var string $path
     */
    protected $path;

    /**
     * Path where the CSV file will be
     * Full path with base path.
     * @var string
     */
    protected $filePath;

    /**
     * @var array $locales
     */
    protected $locales;


    /**
     * {@inheritDoc}
     */
    public function setDependencies(Container $container)
    {
        $this->appConfig = $container['config'];
        $this->setTranslator($container['translator']);
        parent::setDependencies($container);
    }

    /**
     * Arguments that can be use in the script.
     * If no path is provided, all views path are parsed.
     * If you do precise a path, notice that you will loose
     * all modified translations that comes from other paths.
     *
     * Valid arguments:
     * - output : path-to-csv/
     * - domain : filename prefix
     * - recursive : level of recursiveness (how deep the glob checks for the strings)
     * - path : Path to get translation from a precise location (i.e: templates/emails/)
     * - type : file type (either mustache or php)
     *
     * @todo Support php file type.
     * @return array
     */
    public function defaultArguments()
    {
        $arguments = [
            'output' => [
                'prefix' => 'o',
                'longPrefix' => 'output',
                'description' => 'Output file path. Make sure the path exists in the translator paths definition. (Default: translation/)',
                'defaultValue' => 'translations/'
            ],
            'domain' => [
                'prefix' => 'd',
                'longPrefix' => 'domain',
                'description' => 'Doman for the csv file. Based on symfony/translator CsvLoader.',
                'defaultValue' => 'messages'
            ],
            'recursive' => [
                'prefix' => 'r',
                'longPrefix' => 'recursive-level',
                'description' => 'Max recursive level for the glob operation on folders.',
                'defaultValue' => 4
            ],
            'path' => [
                'longPrefix'   => 'path',
                'prefix'  => 'p',
                'description'  => 'Path relative to the project installation (ex: templates/*/*/)',
                'defaultValue' => false
            ],
            'type' => [
                'longPrefix'   => 'type',
                'prefix'  => 't',
                'description'  => 'File type (mustache || php)',
                'defaultValue' => 'mustache'
            ],
            'php_function' => [
                'longPrefix'   => 'php',
                'description'  => 'Php function to be parsed.',
                'defaultValue' => 'translate'
            ],
            'mustache_tag' => [
                'longPrefix'   => 'mustache',
                'description'  => 'Mustache function to be parsed.',
                'defaultValue' => '_t'
            ]
        ];

        $arguments = array_merge(parent::defaultArguments(), $arguments);
        return $arguments;
    }

    /**
     * @param RequestInterface  $request  A PSR-7 compatible Request instance.
     * @param ResponseInterface $response A PSR-7 compatible Response instance.
     * @return ResponseInterface
     */
    public function run(RequestInterface $request, ResponseInterface $response)
    {
        // Unused
        unset($request);

        // Parse arguments
        $this->climate()->arguments->parse();
        $this->displayInformations();

        // Get translations
        $translations = $this->getTranslations();

        // Output to CSV file.
        $this->toCSV($translations);

        // Warn the user
        $base = $this->appConfig->get('base_path');
        $output = $this->output();
        $filePath = str_replace('/', DIRECTORY_SEPARATOR, $base.$output);

        $this->climate()->backgroundGreen()->out(
            'Make sure to include <light_green>' . $filePath . '</light_green> in your <light_green>translator/paths</light_green> configurations.'
        );

        return $response;
    }

    /**
     * Give feedback about what's going on.
     * @return self Chainable.
     */
    protected function displayInformations()
    {
        $this->climate()->underline()->out(
            'Initializing translations parser script...'
        );

        $this->climate()->green()->out(
            'CSV file output: <white>' . $this->filePath() . '</white>'
        );

        $this->climate()->green()->out(
            'CSV file names: <white>' . $this->domain().'.{locale}.csv</white>'
        );

        $this->climate()->green()->out(
            'Looping through <white>'.$this->maxRecursiveLevel().'</white> level of folders'
        );

        $this->climate()->green()->out(
            'File type parsed: <white>mustache</white>'
        );

        return $this;
    }

    /**
     * Complete filepath to the CSV location.
     * @return string Filepath to the csv.
     */
    protected function filePath()
    {
        if ($this->filePath) {
            return $this->filePath;
        }

        $base = $this->appConfig->get('base_path');
        $output = $this->output();
        $this->filePath = str_replace('/', DIRECTORY_SEPARATOR, $base.$output);
        return $this->filePath;
    }

    /**
     * Available locales (languages)
     * @return array Locales.
     */
    protected function locales()
    {
        return $this->translator()->availableLocales();
    }

    /**
     * @return string Current locale.
     */
    protected function locale()
    {
        return $this->translator()->getLocale();
    }

    /**
     * @return string
     */
    public function output()
    {
        if ($this->output) {
            return $this->output;
        }
        $output = $this->argOrInput('output');
        $this->output = $output;
        return $this->output;
    }

    /**
     * Domain which is the csv file name prefix
     * @return string domain.
     */
    public function domain()
    {
        return $this->argOrInput('domain');
    }

    /**
     * Regex to match in files.
     * @param  string $type File type (mustache|php)
     * @return string       Regex string.
     */
    public function regEx($type)
    {
        switch ($type) {
            case 'php' :

There must be no space before the colon in a CASE statement

                $f = $this->phpFunction();
                $regex = '/->'.$f.'\(\s*\n*\r*(["\'])(?<text>(.|\n|\r|\n\r)*?)\s*\n*\r*\1\)/i';
            break;

            case 'mustache' :

There must be no space before the colon in a CASE statement

                $tag = $this->mustacheTag();
                $regex = '/{{\s*#\s*'.$tag.'\s*}}(?<text>(.|\n|\r|\n\r)*?){{\s*\/\s*'.$tag.'\s*}}/i';
            break;

            default:
                $regex = '/{{\s*#\s*_t\s*}}(?<text>(.|\n|\r|\n\r)*?){{\s*\/\s*_t\s*}}/i';
            break;
        }

        return $regex;
    }

    /**
     * Loop through all paths to get translations.
     * Also merge with already existing translations.
     * Translations associated with the locale.
     * [
     *    'fr' => [
     *        'string' => 'translation',
     *        'string' => 'translation',
     *        'string' => 'translation',
     *        'string' => 'translation'
     *    ],
     *    'en' => [
     *        'string' => 'translation',
     *        'string' => 'translation',
     *        'string' => 'translation',
     *        'string' => 'translation'
     *    ]
     * ]
     * @return array        Translations.
     */
    public function getTranslations()
    {
        $path = $this->path();

        if ($path) {
            $this->climate()->green()->out('Parsing files in <white>' . $path .'</white>');
            $translations = $this->getTranslationsFromPath($path, 'mustache');
            $translations = array_merge($translations, $this->getTranslationsFromPath($path, 'php'));
            return $translations;
        }

        $paths = $this->paths();

        $translations = [];
        foreach ($paths as $p) {
            $this->climate()->green()->out('Parsing files in <white>' . $p .'</white>');
            $translations = array_merge_recursive($translations, $this->getTranslationsFromPath($p, 'mustache'));
            $translations = array_merge_recursive($translations, $this->getTranslationsFromPath($p, 'php'));
        }

        return $translations;
    }

    /**
     * Get all translations in given path for the given file extension (mustache | php).
     * @param  string $path The path.
     * @param  string $fileType The file extension|type.
     * @return array        Translations.
     */
    public function getTranslationsFromPath($path, $fileType)
    {
        // remove vendor/locomotivemtl/charcoal-app
        $base = $this->appConfig->get('base_path');
        $glob = $this->globRecursive($base.$path.'*.'.$fileType);
        $regex = $this->regEx($fileType);

        $translations = [];

        // Array index for the preg_match.
        $index = 'text';
        // if ($fileType == 'php') {

50% of this comment could be valid code. Did you maybe forget this after debugging?

        //     $index = 'text';

43% of this comment could be valid code. Did you maybe forget this after debugging?

        // }

        $k = 0;

        $this->climate()->inline('.');
        // Loop files to get original text.
        foreach ($glob as $k => $file) {
            $k++;
            $this->climate()->inline('.');
            $text = file_get_contents($file);

            if (preg_match($regex, $text)) {
                preg_match_all($regex, $text, $array);


                $i = 0;
                $t = count($array[$index]);
                $locales = $this->locales();

                for (; $i<$t; $i++) {
                    $this->climate()->inline('.');
                    $orig = $array[$index][$i];
                    foreach ($locales as $lang) {
                        $this->climate()->inline('.');
                        $this->translator()->setLocale($lang);
                        // By calling translate, we make sure all existings translations are taking into consideration.

                        $translations[$lang][$orig] = stripslashes($this->translator()->translate($orig));
                    }
                }
            }
        }
        $this->climate()->out('.');
        $this->climate()->green()->out('Translations parsed from ' . $path);
        return $translations;
    }

    /**
     * @param string  $pattern The pattern to search.
     * @param integer $flags   The glob flags.
     * @return array
     * @see http://in.php.net/manual/en/function.glob.php#106595
     */
    public function globRecursive($pattern, $flags = 0)
    {
        $max = $this->maxRecursiveLevel();

$max is not used, you could remove the assignment.

        $i = 1;
        $files = glob($pattern, $flags);
        foreach (glob(dirname($pattern).'/*', (GLOB_ONLYDIR|GLOB_NOSORT)) as $dir) {
            $files = array_merge($files, $this->globRecursive($dir.'/'.basename($pattern), $flags));
            $i++;
            // if ($i >= $max) {

47% of this comment could be valid code. Did you maybe forget this after debugging?

            //     break;
            // }
        }
        return $files;
    }

    /**
     * Custom path
     * @return [type] [description]

The doc-type [type] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     */
    public function path()
    {
        if ($this->climate()->arguments->defined('path')) {
            $this->path = $this->climate()->arguments->get('path');
        }
        return $this->path;
    }

    /**
     * @return string
     */
    public function paths()
    {
        if (!$this->paths) {

The expression $this->paths of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->paths = $this->appConfig->get('view.paths');

            // Hardcoded
            // @todo change this
            $this->paths[] = 'src/';
        }
        return $this->paths;
    }

    /**
     * @return string
     */
    public function fileTypes()
    {
        if (!$this->fileTypes) {
            $this->fileTypes = [
                'php',
                'mustache'
            ];
        }
        return $this->fileTypes;
    }

    /**
     * @param array $translations The translations to save in CSV.
     * @return TranslateScript Chainable
     */
    public function toCSV(array $translations)
    {
        if (!count($translations)) {
            $this->climate()->error('
                There was no translations in the provided path ('. $this->path() .')
                with the given recursive level ('.$this->maxRecursiveLevel().')
            ');
            return $this;
        }
        $base = $this->appConfig->get('base_path');
        $output = $this->output();
        $domain = $this->domain();

        $separator = $this->separator();
        $enclosure = $this->enclosure();

        foreach ($translations as $lang => $trans) {
            // Create / open the handle
            $filePath = str_replace('/', DIRECTORY_SEPARATOR, $base.$output);
            $dirname = dirname($filePath);

$dirname is not used, you could remove the assignment.

            if (!file_exists($filePath)) {
                mkdir($filePath, 0755, true);
            }
            $file = fopen($base.$output.$domain.'.'.$lang.'.csv', 'w');
            if (!$file) {
                continue;
            }

            foreach ($trans as $key => $translation) {
                $data = [ $key, $translation ];
                fputcsv($file, $data, $separator, $enclosure);
            }
            fclose($file);
        }


        return $this;
    }

    /**
     * @return string
     */
    public function enclosure()
    {
        return '"';
    }

    /**
     * @return string
     */
    public function separator()
    {
        return ';';
    }

    /**
     * @return integer
     */
    public function maxRecursiveLevel()
    {
        if ($this->climate()->arguments->defined('recursive')) {
            return $this->climate()->arguments->get('recursive');
        }
        return 10;
    }

    /**
     * @return string Php function
     */
    private function phpFunction()
    {
        if ($this->climate()->arguments->defined('php_function')) {
            return $this->climate()->arguments->get('php_function');
        }

        return 'translate';
    }

    /**
     * @return string Mustache tag
     */
    private function mustacheTag()
    {
        if ($this->climate()->arguments->defined('mustache_tag')) {
            return $this->climate()->arguments->get('mustache_tag');
        }
        return '_t';
    }
}