Kunstmaan\TranslatorBundle\Service\Command\Importer\ImportCommandHandler

Complexity

Total Complexity

36

Size/Duplication

Total Lines	259
Duplicated Lines	12.74 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	executeImportCommand()	0	8	4
A	importGlobalTranslationFiles()	0	9	3
A	importBundleTranslationFiles()	0	22	5
A	importAllBundlesTranslationFiles()	17	17	3
A	importOwnBundlesTranslationFiles()	0	19	4
A	importCustomBundlesTranslationFiles()	16	16	3
A	importSingleBundleTranslationFiles()	0	12	2
A	importTranslationFiles()	0	14	3
A	validateBundleName()	0	11	2
A	determineLocalesToImport()	0	8	3
A	setTranslationFileExplorer()	0	4	1
A	setImporter()	0	4	1
A	importSf4TranslationFiles()	0	10	2

<?php

namespace Kunstmaan\TranslatorBundle\Service\Command\Importer;

use Kunstmaan\TranslatorBundle\Model\Import\ImportCommand;
use Kunstmaan\TranslatorBundle\Service\Command\AbstractCommandHandler;
use Kunstmaan\TranslatorBundle\Service\Exception\TranslationsNotFoundException;
use Kunstmaan\TranslatorBundle\Service\TranslationFileExplorer;
use Symfony\Component\Finder\Finder;
use Symfony\Component\HttpKernel\Kernel;

/**
 * Parses an ImportCommand
 */
class ImportCommandHandler extends AbstractCommandHandler
{
    /**
     * TranslationFileExplorer
     *
     * @var TranslationFileExplorer
     */
    private $translationFileExplorer;

    /**
     * Importer
     *
     * @var Importer
     */
    private $importer;

    /**
     * Execute an import command
     *
     * @param ImportCommand $importCommand
     *
     * @return int total number of files imported

Should the return type not be false|integer|double?

     */
    public function executeImportCommand(ImportCommand $importCommand)
    {
        if ($importCommand->getGlobals() || $importCommand->getDefaultBundle() === false || $importCommand->getDefaultBundle() === null) {
            return $this->importGlobalTranslationFiles($importCommand);
        }

        return $this->importBundleTranslationFiles($importCommand);
    }

    /**
     * Import all translation files from app resources
     *
     * @param ImportCommand $importCommand
     *
     * @return int total number of files imported

Should the return type not be false|integer?

     */
    private function importGlobalTranslationFiles(ImportCommand $importCommand)
    {
        $baseDir = Kernel::VERSION_ID >= 40000 ? $this->kernel->getProjectDir() : $this->kernel->getRootDir();
        $translationsDir = Kernel::VERSION_ID >= 40000 ? 'translations' : null;
        $locales = $this->determineLocalesToImport($importCommand);
        $finder = $this->translationFileExplorer->find($baseDir, $locales, $translationsDir);

        return $this->importTranslationFiles($finder, $importCommand->getForce());
    }

    /**
     * Import all translation files from a specific bundle, bundle name will be lowercased so cases don't matter
     *
     * @param ImportCommand $importCommand
     *
     * @return int total number of files imported

Should the return type not be integer|double|false?

     */
    public function importBundleTranslationFiles(ImportCommand $importCommand)
    {
        $importBundle = strtolower($importCommand->getDefaultBundle());

        if ($importBundle == 'all') {
            $importCount = $this->importAllBundlesTranslationFiles($importCommand);

            if (Kernel::VERSION_ID >= 40000) {
                $importCount += $this->importSf4TranslationFiles($importCommand);
            }

            return $importCount;
        } elseif ($importBundle == 'custom') {
            return $this->importCustomBundlesTranslationFiles($importCommand);
        } else {
            if (Kernel::VERSION_ID >= 40000) {
                return $this->importSf4TranslationFiles($importCommand);
            }

            return $this->importOwnBundlesTranslationFiles($importCommand);
        }
    }

    /**
     * Import all translation files from all registered bundles (in AppKernel)
     *
     * @param ImportCommand $importCommand
     *
     * @return int total number of files imported

Should the return type not be integer|double?

     */
    private function importAllBundlesTranslationFiles(ImportCommand $importCommand)

This method seems to be duplicated in your project.

    {
        $bundles = array_map('strtolower', array_keys($this->kernel->getBundles()));
        $imported = 0;

        foreach ($bundles as $bundle) {
            $importCommand->setDefaultBundle($bundle);

            try {
                $imported += $this->importSingleBundleTranslationFiles($importCommand);
            } catch (TranslationsNotFoundException $e) {
                continue;
            }
        }

        return $imported;
    }

    /**
     * Import all translation files from your own registered bundles (in src/ directory)
     *
     * @param ImportCommand $importCommand
     *
     * @return int The total number of imported files

Should the return type not be integer|double?

     */
    private function importOwnBundlesTranslationFiles(ImportCommand $importCommand)
    {
        $imported = 0;
        $srcDir = dirname($this->kernel->getRootDir()) . '/src';

        foreach ($this->kernel->getBundles() as $name => $bundle) {
            if (strpos($bundle->getPath(), $srcDir) !== false) {
                $importCommand->setDefaultBundle(strtolower($name));

                try {
                    $imported += $this->importSingleBundleTranslationFiles($importCommand);
                } catch (TranslationsNotFoundException $e) {
                    continue;
                }
            }
        }

        return $imported;
    }

    /**
     * Import the translation files from the defined bundles.
     *
     * @param ImportCommand $importCommand
     *
     * @return int The total number of imported files

Should the return type not be integer|double?

     */
    private function importCustomBundlesTranslationFiles(ImportCommand $importCommand)

This method seems to be duplicated in your project.

    {
        $imported = 0;

        foreach ($importCommand->getBundles() as $bundle) {
            $importCommand->setDefaultBundle(strtolower($bundle));

            try {
                $imported += $this->importSingleBundleTranslationFiles($importCommand);
            } catch (TranslationsNotFoundException $e) {
                continue;
            }
        }

        return $imported;
    }

    /**
     * Import all translation files from a single bundle
     *
     * @param ImportCommand $importCommand
     *
     * @return int total number of files imported

Should the return type not be integer|false?

     */
    private function importSingleBundleTranslationFiles(ImportCommand $importCommand)
    {
        $this->validateBundleName($importCommand->getDefaultBundle());

$importCommand->getDefaultBundle() is of type boolean, but the function expects a string.

        $bundles = array_change_key_case($this->kernel->getBundles(), CASE_LOWER);
        $finder = $this->translationFileExplorer->find($bundles[strtolower($importCommand->getDefaultBundle())]->getPath(), $this->determineLocalesToImport($importCommand));

        if ($finder === null) {
            return 0;
        }

        return $this->importTranslationFiles($finder, $importCommand->getForce());
    }

    /**
     * Import translation files from a specific Finder object
     * The finder object shoud already have the files to look for defined;
     * Forcing the import will override all existing translations in the stasher
     *
     * @param Finder $finder
     * @param bool   $force  override identical translations in the stasher (domain/locale and keyword combination)
     *
     * @return int total number of files imported

Should the return type not be false|integer?

     */
    private function importTranslationFiles(Finder $finder, $force = flase)
    {
        if (!$finder instanceof Finder) {
            return false;
        }

        $imported = 0;

        foreach ($finder as $file) {
            $imported += $this->importer->import($file, $force);
        }

        return $imported;
    }

    /**
     * Validates that a bundle is registered in the AppKernel
     *
     * @param string $bundle
     *
     * @return bool bundle is valid or not
     *
     * @throws \Exception If the bundlename isn't valid
     */
    public function validateBundleName($bundle)
    {
        // strtolower all bundle names
        $bundles = array_map('strtolower', array_keys($this->kernel->getBundles()));

        if (in_array(strtolower(trim($bundle)), $bundles)) {
            return true;
        }

        throw new \Exception(sprintf('bundle "%s" not found in available bundles: %s', $bundle, implode(', ', $bundles)));
    }

    /**
     * Gives an array with all languages that needs to be imported (from the given ImportCommand)
     * If non is given, all managed locales will be used (defined in config)
     *
     * @param ImportCommand $importCommand
     *
     * @return array all locales to import by the given ImportCommand
     */
    public function determineLocalesToImport(ImportCommand $importCommand)
    {
        if ($importCommand->getLocales() === false || $importCommand->getLocales() === null) {
            return $this->managedLocales;
        }

        return $this->parseRequestedLocales($importCommand->getLocales());

$importCommand->getLocales() is of type boolean, but the function expects a string.

    }

    public function setTranslationFileExplorer($translationFileExplorer)
    {
        $this->translationFileExplorer = $translationFileExplorer;
    }

    public function setImporter($importer)
    {
        $this->importer = $importer;
    }

    private function importSf4TranslationFiles($importCommand)
    {
        $finder = $this->translationFileExplorer->find($this->kernel->getProjectDir(), $this->determineLocalesToImport($importCommand), 'translations');

        if ($finder === null) {
            return 0;
        }

        return $this->importTranslationFiles($finder, $importCommand->getForce());
    }
}