ONGR\TranslationsBundle\Service\Import\ImportManager

Complexity

Total Complexity

25

Size/Duplication

Total Lines	219
Duplicated Lines	5.48 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes	4
Bugs	1	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	getLocales()	0	4	1
A	setLocales()	0	4	1
B	writeToStorage()	0	28	5
A	cleanTranslations()	0	11	3
A	importTranslationFiles()	0	5	1
B	getTranslationsFromFiles()	0	26	5
B	getFileTranslationMessages()	0	28	4
A	getFileNamePattern()	0	9	1
A	flatten()	12	12	3

<?php

/*
 * This file is part of the ONGR package.
 *
 * (c) NFQ Technologies UAB <info@nfq.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ONGR\TranslationsBundle\Service\Import;

use ONGR\ElasticsearchBundle\Service\Manager;
use ONGR\ElasticsearchBundle\Service\Repository;
use ONGR\ElasticsearchDSL\Query\FullText\MatchQuery;
use ONGR\TranslationsBundle\Document\Message;
use ONGR\TranslationsBundle\Document\Translation;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Finder\SplFileInfo;
use Symfony\Component\Translation\Exception\InvalidResourceException;
use Symfony\Component\Translation\Loader\YamlFileLoader;
use Symfony\Component\Yaml\Exception\ParseException;
use Symfony\Component\Yaml\Parser as YamlParser;

/**
 * Collects translations.
 */
class ImportManager
{
    /**
     * @var array
     */
    private $locales;

    /**
     * @var Repository
     */
    private $repository;

    /**
     * @var Manager
     */
    private $manager;

    /**
     * @var YamlFileLoader
     */
    private $parser;

    /**
     * @var string
     */
    private $kernelRoot;

    /**
     * @param Repository $repository
     */
    public function __construct(
        Repository $repository,
        $kernelRoot
    )
    {
        $this->parser = new YamlParser();

It seems like new \Symfony\Component\Yaml\Parser() of type object<Symfony\Component\Yaml\Parser> is incompatible with the declared type object<Symfony\Component\Translation\Loader\YamlFileLoader> of property $parser.

        $this->repository = $repository;
        $this->manager = $repository->getManager();
        $this->kernelRoot = $kernelRoot;
    }

    /**
     * @return array
     */
    public function getLocales()
    {
        return $this->locales;
    }

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

    /**
     * Write translations to storage.
     *
     * @param $translations
     */
    public function writeToStorage($domain, $translations)
    {
        foreach ($translations as $keys) {
            foreach ($keys as $key => $transMeta) {
                $search = $this->repository->createSearch();
                $search->addQuery(new MatchQuery('key', $key));
                $results = $this->repository->findDocuments($search);
                if (count($results)) {
                    continue;
                }

                $document = new Translation();
                $document->setDomain($domain);
                $document->setKey($key);
                $document->setPath($transMeta['path']);
                $document->setFormat($transMeta['format']);
                foreach ($transMeta['messages'] as $locale => $text) {
                    $message = new Message();
                    $message->setLocale($locale);
                    $message->setMessage($text);
                    $document->addMessage($message);
                }
                $this->manager->persist($document);
            }
        }

        $this->manager->commit();
    }

    /**
     * @param array $translations
     */
    public function cleanTranslations(array $translations)
    {
        $translationKeys    = array_keys($translations);
        $storedTranslations = $this->repository->findBy([]);

        foreach ($storedTranslations as $document) {
            if (!in_array($document->getKey(), $translationKeys)) {
                $this->repository->remove($document->getId());
            }
        }
    }

    /**
     * Imports translation files from a directory.
     * @param string $dir
     */
    public function importTranslationFiles($domain, $dir)
    {
        $translations = $this->getTranslationsFromFiles($domain, $dir);
        $this->writeToStorage($domain, $translations);
    }

    /**
     * Return a Finder object if $path has a Resources/translations folder.
     *
     * @param string $domain
     * @param string $path
     * @param array $directories
     *
     * @return array
     */
    public function getTranslationsFromFiles($domain, $path, array $directories = [])
    {
        if (!$directories) {

The expression $directories 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.

            $directories = [
                $path . 'Resources' . DIRECTORY_SEPARATOR . 'translations',
                $this->kernelRoot . DIRECTORY_SEPARATOR . 'Resources' . DIRECTORY_SEPARATOR . $domain . DIRECTORY_SEPARATOR . 'translations',
            ];
        }

        $finder = new Finder();
        $translations = [];

        foreach ($directories as $directory) {
            if (is_dir($directory)) {
                $finder->files()
                    ->name($this->getFileNamePattern())
                    ->in($directory);

                foreach ($finder as $file) {
                    $translations = array_replace_recursive($this->getFileTranslationMessages($file, $domain), $translations);
                }
            }
        }

        return $translations;
    }

    /**
     * @param SplFileInfo $file
     * @param string      $domain
     *
     * @return array
     */
    public function getFileTranslationMessages(SplFileInfo $file, $domain)
    {
        $locale = explode('.', $file->getFilename())[1];

        if (!in_array($locale, $this->getLocales())) {
            return [];
        }

        $translations = [];

        try {
            $domainMessages = $this->parser->parse(file_get_contents($file->getPath().DIRECTORY_SEPARATOR.$file->getFilename()));

The method parse() does not seem to exist on object<Symfony\Component\Translation\Loader\YamlFileLoader>.

        } catch (ParseException $e) {
            throw new InvalidResourceException(sprintf('Error parsing YAML, invalid file "%s"', $file->getPath()), 0, $e);
        }

        $path = substr(pathinfo($file->getPathname(), PATHINFO_DIRNAME), strlen(getcwd()) + 1);

        $domainMessages = $this->flatten($domainMessages);

        foreach ($domainMessages as $key => $content) {
            $translations[$domain][$key]['messages'][$locale] = $content;
            $translations[$domain][$key]['path'] = $path;
            $translations[$domain][$key]['format'] = $file->getExtension();
        }

        return $translations;
    }

    /**
     * Flatten multidimensional array and concatenating keys
     *
     * @param $array
     * @return array
     */
    private function flatten($array, $prefix = '') {

This method seems to be duplicated in your project.

        $result = [];
        foreach($array as $key=>$value) {
            if(is_array($value)) {
                $result = $result + $this->flatten($value, $prefix . $key . '.');
            }
            else {
                $result[$prefix . $key] = $value;
            }
        }
        return $result;
    }

    /**
     * @return string
     */
    private function getFileNamePattern()
    {
        $regex = sprintf(
            '/(.*\.(%s)\.(%s))/',
            implode('|', $this->getLocales()),
            'yml$'
        );
        return $regex;
    }
}