TranslationExtension::__construct() - Code Metrics - Inspection of "whitespace" - Kdyby/Translation - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 3f54b0...01582d )

by Filip
created 2016-02-10 14:51 UTC
TranslationExtension::__construct() A

↳ Parent: TranslationExtension
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	1	Features	0
Metric	Value
c	1
b	1
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	0
<?php

/**
 * This file is part of the Kdyby (http://www.kdyby.org)
 *
 * Copyright (c) 2008 Filip Procházka ([email protected])
 *
 * For the full copyright and license information, please view the file license.txt that was distributed with this source code.
 */

namespace Kdyby\Translation\DI;

use Kdyby;
use Kdyby\Translation\InvalidResourceException;
use Nette;
use Nette\DI\Statement;
use Nette\PhpGenerator as Code;
use Nette\Reflection;
use Nette\Utils\Callback;
use Nette\Utils\Finder;
use Nette\Utils\Strings;
use Nette\Utils\Validators;
use Symfony\Component\Translation\Loader\LoaderInterface;
use Tracy;



/**
 * @author Filip Procházka <[email protected]>
 */
class TranslationExtension extends Nette\DI\CompilerExtension
{

	/** @deprecated */
	const LOADER_TAG = self::TAG_LOADER;
	/** @deprecated */
	const DUMPER_TAG = self::TAG_DUMPER;
	/** @deprecated */
	const EXTRACTOR_TAG = self::TAG_EXTRACTOR;

	const TAG_LOADER = 'translation.loader';
	const TAG_DUMPER = 'translation.dumper';
	const TAG_EXTRACTOR = 'translation.extractor';

	const RESOLVER_REQUEST = 'request';
	const RESOLVER_HEADER = 'header';
	const RESOLVER_SESSION = 'session';

	/**
	 * @var array
	 */
	public $defaults = array(
		'whitelist' => NULL, // array('cs', 'en'),

		'default' => 'en',
		'logging' => NULL, //  TRUE for psr/log, or string for kdyby/monolog channel
		// 'fallback' => array('en_US', 'en'), // using custom merge strategy becase Nette's config merger appends lists of values

		'dirs' => array('%appDir%/lang', '%appDir%/locale'),
		'cache' => 'Kdyby\Translation\Caching\PhpFileStorage',
		'debugger' => '%debugMode%',
		'resolvers' => array(
			self::RESOLVER_SESSION => FALSE,
			self::RESOLVER_REQUEST => TRUE,
			self::RESOLVER_HEADER => TRUE,
		),
	);

	/**
	 * @var array
	 */
	private $loaders;



	public function __construct()
	{
		$this->defaults['cache'] = new Statement($this->defaults['cache'], array('%tempDir%/cache'));
	}



	public function loadConfiguration()
	{
		$this->loaders = array();

		$builder = $this->getContainerBuilder();
		$config = $this->getConfig();

		$translator = $builder->addDefinition($this->prefix('default'))
			->setClass('Kdyby\Translation\Translator', array($this->prefix('@userLocaleResolver')))
			->addSetup('?->setTranslator(?)', array($this->prefix('@userLocaleResolver.param'), '@self'))
			->addSetup('setDefaultLocale', array($config['default']))
			->addSetup('setLocaleWhitelist', array($config['whitelist']))
			->setInject(FALSE);

		Validators::assertField($config, 'fallback', 'list');
		$translator->addSetup('setFallbackLocales', array($config['fallback']));

		$catalogueCompiler = $builder->addDefinition($this->prefix('catalogueCompiler'))
			->setClass('Kdyby\Translation\CatalogueCompiler', self::filterArgs($config['cache']))
			->setInject(FALSE);

		if ($config['debugger'] && interface_exists('Tracy\IBarPanel')) {
			$builder->addDefinition($this->prefix('panel'))
				->setClass('Kdyby\Translation\Diagnostics\Panel', array(dirname($builder->expand('%appDir%'))))

				->addSetup('setLocaleWhitelist', array($config['whitelist']));

			$translator->addSetup('?->register(?)', array($this->prefix('@panel'), '@self'));
			$catalogueCompiler->addSetup('enableDebugMode');
		}

		$this->loadLocaleResolver($config);

		$builder->addDefinition($this->prefix('helpers'))
			->setClass('Kdyby\Translation\TemplateHelpers')
			->setFactory($this->prefix('@default') . '::createTemplateHelpers')
			->setInject(FALSE);

		$builder->addDefinition($this->prefix('fallbackResolver'))
			->setClass('Kdyby\Translation\FallbackResolver')
			->setInject(FALSE);

		$builder->addDefinition($this->prefix('catalogueFactory'))
			->setClass('Kdyby\Translation\CatalogueFactory')
			->setInject(FALSE);

		$builder->addDefinition($this->prefix('selector'))
			->setClass('Symfony\Component\Translation\MessageSelector')
			->setInject(FALSE);

		$builder->addDefinition($this->prefix('extractor'))
			->setClass('Symfony\Component\Translation\Extractor\ChainExtractor')
			->setInject(FALSE);

		$this->loadExtractors();

		$builder->addDefinition($this->prefix('writer'))
			->setClass('Symfony\Component\Translation\Writer\TranslationWriter')
			->setInject(FALSE);

		$this->loadDumpers();

		$builder->addDefinition($this->prefix('loader'))
			->setClass('Kdyby\Translation\TranslationLoader')
			->setInject(FALSE);

		$this->loadLoaders();

		if ($this->isRegisteredConsoleExtension()) {
			$this->loadConsole($config);
		}
	}



	protected function loadLocaleResolver(array $config)
	{
		$builder = $this->getContainerBuilder();

		$builder->addDefinition($this->prefix('userLocaleResolver.param'))
			->setClass('Kdyby\Translation\LocaleResolver\LocaleParamResolver')
			->setAutowired(FALSE)
			->setInject(FALSE);

		$builder->addDefinition($this->prefix('userLocaleResolver.acceptHeader'))
			->setClass('Kdyby\Translation\LocaleResolver\AcceptHeaderResolver')
			->setInject(FALSE);

		$builder->addDefinition($this->prefix('userLocaleResolver.session'))
			->setClass('Kdyby\Translation\LocaleResolver\SessionResolver')
			->setInject(FALSE);

		$chain = $builder->addDefinition($this->prefix('userLocaleResolver'))
			->setClass('Kdyby\Translation\IUserLocaleResolver')
			->setFactory('Kdyby\Translation\LocaleResolver\ChainResolver')
			->setInject(FALSE);

		$resolvers = array();
		if ($config['resolvers'][self::RESOLVER_HEADER]) {

			$resolvers[] = $this->prefix('@userLocaleResolver.acceptHeader');
			$chain->addSetup('addResolver', array($this->prefix('@userLocaleResolver.acceptHeader')));
		}

		if ($config['resolvers'][self::RESOLVER_REQUEST]) {

			$resolvers[] = $this->prefix('@userLocaleResolver.param');
			$chain->addSetup('addResolver', array($this->prefix('@userLocaleResolver.param')));
		}

		if ($config['resolvers'][self::RESOLVER_SESSION]) {

			$resolvers[] = $this->prefix('@userLocaleResolver.session');
			$chain->addSetup('addResolver', array($this->prefix('@userLocaleResolver.session')));
		}

		if ($config['debugger'] && interface_exists('Tracy\IBarPanel')) {
			$builder->getDefinition($this->prefix('panel'))
				->addSetup('setLocaleResolvers', array(array_reverse($resolvers)));
		}
	}



	protected function loadConsole(array $config)
	{
		$builder = $this->getContainerBuilder();

		Validators::assertField($config, 'dirs', 'list');
		$builder->addDefinition($this->prefix('console.extract'))
			->setClass('Kdyby\Translation\Console\ExtractCommand')
			->addSetup('$defaultOutputDir', array(reset($config['dirs'])))
			->setInject(FALSE)
			->addTag('kdyby.console.command', 'latte');
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
	}



	protected function loadDumpers()

	{
		$builder = $this->getContainerBuilder();

		foreach ($this->loadFromFile(__DIR__ . '/config/dumpers.neon') as $format => $class) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
			$builder->addDefinition($this->prefix('dumper.' . $format))
				->setClass($class)
				->addTag(self::TAG_DUMPER, $format);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		}
	}



	protected function loadLoaders()

	{
		$builder = $this->getContainerBuilder();

		foreach ($this->loadFromFile(__DIR__ . '/config/loaders.neon') as $format => $class) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
			$builder->addDefinition($this->prefix('loader.' . $format))
				->setClass($class)
				->addTag(self::TAG_LOADER, $format);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		}
	}



	protected function loadExtractors()

	{
		$builder = $this->getContainerBuilder();

		foreach ($this->loadFromFile(__DIR__ . '/config/extractors.neon') as $format => $class) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
			$builder->addDefinition($this->prefix('extractor.' . $format))
				->setClass($class)
				->addTag(self::TAG_EXTRACTOR, $format);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		}
	}



	public function beforeCompile()
	{
		$builder = $this->getContainerBuilder();
		$config = $this->getConfig();

		$this->beforeCompileLogging($config);

		$registerToLatte = function (Nette\DI\ServiceDefinition $def) {
			$def
				->addSetup('?->onCompile[] = function($engine) { Kdyby\Translation\Latte\TranslateMacros::install($engine->getCompiler()); }', array('@self'))
				->addSetup('addFilter', array('translate', array($this->prefix('@helpers'), 'translate')))
				->addSetup('addFilter', array('getTranslator', array($this->prefix('@helpers'), 'getTranslator')));
		};

		$latteFactoryService = $builder->getByType('Nette\Bridges\ApplicationLatte\ILatteFactory') ?: 'nette.latteFactory';
		if ($builder->hasDefinition($latteFactoryService)) {
			$registerToLatte($builder->getDefinition($latteFactoryService));
		}

		if ($builder->hasDefinition('nette.latte')) {
			$registerToLatte($builder->getDefinition('nette.latte'));
		}

		$applicationService = $builder->getByType('Nette\Application\Application') ?: 'application';
		if ($builder->hasDefinition($applicationService)) {
			$builder->getDefinition($applicationService)
				->addSetup('$service->onRequest[] = ?', array(array($this->prefix('@userLocaleResolver.param'), 'onRequest')));

			if ($config['debugger'] && interface_exists('Tracy\IBarPanel')) {
				$builder->getDefinition($applicationService)
					->addSetup('$self = $this; $service->onStartup[] = function () use ($self) { $self->getService(?); }', array($this->prefix('default')))
					->addSetup('$service->onRequest[] = ?', array(array($this->prefix('@panel'), 'onRequest')));
			}
		}

		if (class_exists('Tracy\Debugger')) {
			Kdyby\Translation\Diagnostics\Panel::registerBluescreen();
		}

		$extractor = $builder->getDefinition($this->prefix('extractor'));
		foreach ($builder->findByTag(self::TAG_EXTRACTOR) as $extractorId => $meta) {

			Validators::assert($meta, 'string:2..');

			$extractor->addSetup('addExtractor', array($meta, '@' . $extractorId));

			$builder->getDefinition($extractorId)->setAutowired(FALSE)->setInject(FALSE);
		}

		$writer = $builder->getDefinition($this->prefix('writer'));
		foreach ($builder->findByTag(self::TAG_DUMPER) as $dumperId => $meta) {

			Validators::assert($meta, 'string:2..');

			$writer->addSetup('addDumper', array($meta, '@' . $dumperId));

			$builder->getDefinition($dumperId)->setAutowired(FALSE)->setInject(FALSE);
		}

		$this->loaders = array();
		foreach ($builder->findByTag(self::TAG_LOADER) as $loaderId => $meta) {
			Validators::assert($meta, 'string:2..');
			$builder->getDefinition($loaderId)->setAutowired(FALSE)->setInject(FALSE);
			$this->loaders[$meta] = $loaderId;
		}

		$builder->getDefinition($this->prefix('loader'))
			->addSetup('injectServiceIds', array($this->loaders))
			->setInject(FALSE);

		foreach ($this->compiler->getExtensions() as $extension) {
			if (!$extension instanceof ITranslationProvider) {
				continue;
			}

			$config['dirs'] = array_merge($config['dirs'], array_values($extension->getTranslationResources()));
		}

		if ($dirs = array_values(array_filter($config['dirs'], Callback::closure('is_dir')))) {
			foreach ($dirs as $dir) {
				$builder->addDependency($dir);
			}

			$this->loadResourcesFromDirs($dirs);
		}
	}



	protected function beforeCompileLogging(array $config)
	{
		$builder = $this->getContainerBuilder();
		$translator = $builder->getDefinition($this->prefix('default'));

		if ($config['logging'] === TRUE) {
			$translator->addSetup('injectPsrLogger');

		} elseif (is_string($config['logging'])) { // channel for kdyby/monolog
			$translator->addSetup('injectPsrLogger', [
				new Statement('@Kdyby\Monolog\Logger::channel', [$config['logging']]),
			]);

		} elseif ($config['logging'] !== NULL) {
			throw new Kdyby\Translation\InvalidArgumentException(sprintf(
				"Invalid config option for logger. Valid are TRUE for general psr/log or string for kdyby/monolog channel, but %s was given",
				$config['logging']
			));
		}
	}



	protected function loadResourcesFromDirs($dirs)
	{
		$builder = $this->getContainerBuilder();
		$config = $this->getConfig();

		$whitelistRegexp = Kdyby\Translation\Translator::buildWhitelistRegexp($config['whitelist']);
		$translator = $builder->getDefinition($this->prefix('default'));

		foreach ($this->loaders as $format => $_) {
			foreach (Finder::findFiles('*.*.' . $format)->from($dirs) as $file) {
				/** @var \SplFileInfo $file */
				if (!$m = Strings::match($file->getFilename(), '~^(?P<domain>.*?)\.(?P<locale>[^\.]+)\.' . preg_quote($format) . '$~')) {
					continue;
				}

				if ($whitelistRegexp && !preg_match($whitelistRegexp, $m['locale']) && $builder->parameters['productionMode']) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
					continue; // ignore in production mode, there is no need to pass the ignored resources
				}

				$this->validateResource($format, $file->getPathname(), $m['locale'], $m['domain']);
				$translator->addSetup('addResource', array($format, $file->getPathname(), $m['locale'], $m['domain']));
				$builder->addDependency($file->getPathname());
			}
		}
	}



	protected function validateResource($format, $file, $locale, $domain)
	{
		$builder = $this->getContainerBuilder();

		if (!isset($this->loaders[$format])) {
			return;
		}

		try {
			$def = $builder->getDefinition($this->loaders[$format]);
			$refl = Reflection\ClassType::from($def->factory ? $def->factory->entity : $def->class);
			if (($method = $refl->getConstructor()) && $method->getNumberOfRequiredParameters() > 1) {
				return;
			}

			$loader = $refl->newInstance();
			if (!$loader instanceof LoaderInterface) {
				return;
			}

		} catch (\ReflectionException $e) {
			return;
		}

		try {
			$loader->load($file, $locale, $domain);

		} catch (\Exception $e) {
			throw new InvalidResourceException("Resource $file is not valid and cannot be loaded.", 0, $e);
		}
	}



	public function afterCompile(Code\ClassType $class)
	{
		$initialize = $class->methods['initialize'];
		if (class_exists('Tracy\Debugger')) {
			$initialize->addBody('Kdyby\Translation\Diagnostics\Panel::registerBluescreen();');
		}
	}



	private function isRegisteredConsoleExtension()
	{
		foreach ($this->compiler->getExtensions() as $extension) {
			if ($extension instanceof Kdyby\Console\DI\ConsoleExtension) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
				return TRUE;
			}
		}

		return FALSE;
	}



	/**
	 * {@inheritdoc}
	 */
	public function getConfig(array $defaults = NULL, $expand = TRUE)

	{
		return parent::getConfig($this->defaults) + array('fallback' => array('en_US'));
	}



	/**
	 * @param string|\stdClass $statement
	 * @return Nette\DI\Statement[]
	 */
	public static function filterArgs($statement)
	{
		return Nette\DI\Compiler::filterArguments(array(is_string($statement) ? new Nette\DI\Statement($statement) : $statement));
	}



	/**
	 * @param \Nette\Configurator $configurator
	 */
	public static function register(Nette\Configurator $configurator)
	{
		$configurator->onCompile[] = function ($config, Nette\DI\Compiler $compiler) {
			$compiler->addExtension('translation', new TranslationExtension());
		};
	}

}

Push — master ( 3f54b0...01582d )

TranslationExtension::__construct() A

Complexity

Size

Duplication

Importance

1. Missing dependencies

2. Missing use statement

1			<?php
2
3			/**
4			* This file is part of the Kdyby (http://www.kdyby.org)
5			*
6			* Copyright (c) 2008 Filip Procházka ([email protected])
7			*
8			* For the full copyright and license information, please view the file license.txt that was distributed with this source code.
9			*/
10
11			namespace Kdyby\Translation\DI;
12
13			use Kdyby;
14			use Kdyby\Translation\InvalidResourceException;
15			use Nette;
16			use Nette\DI\Statement;
17			use Nette\PhpGenerator as Code;
18			use Nette\Reflection;
19			use Nette\Utils\Callback;
20			use Nette\Utils\Finder;
21			use Nette\Utils\Strings;
22			use Nette\Utils\Validators;
23			use Symfony\Component\Translation\Loader\LoaderInterface;
24			use Tracy;
25
26
27
28			/**
29			* @author Filip Procházka <[email protected]>
30			*/
31			class TranslationExtension extends Nette\DI\CompilerExtension
32			{
33
34			/** @deprecated */
35			const LOADER_TAG = self::TAG_LOADER;
36			/** @deprecated */
37			const DUMPER_TAG = self::TAG_DUMPER;
38			/** @deprecated */
39			const EXTRACTOR_TAG = self::TAG_EXTRACTOR;
40
Kdyby / Translation

Push — master ( 3f54b0...01582d )

TranslationExtension::__construct() A

Complexity

Size

Duplication

Importance

1. Missing dependencies

2. Missing use statement

Duplication Side-by-Side

Filter issues like
