Issues in TranslationExtension.php - Fixed Issues - Inspection of "explicitely declare visibility of methods" - nexendrie/translation - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( bb74df...01777c )

by Jakub

created 2017-06-28 12:10 UTC

src/Bridges/NetteDI/TranslationExtension.php (2 issues)

Showing only issues like (Show All)

Checks opening function brace kernighan ritchie space after bracket

Coding Style Informational

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php
declare(strict_types=1);

namespace Nexendrie\Translation\Bridges\NetteDI;

use Nette\DI\CompilerExtension,
    Nette\PhpGenerator\ClassType,
    Nette\Utils\Validators,
    Nexendrie\Translation\Resolvers\ILocaleResolver,
    Nexendrie\Translation\Bridges\NetteApplication\IAppRequestAwareLocaleResolver,
    Nexendrie\Translation\Resolvers\EnvironmentLocaleResolver,
    Nexendrie\Translation\Resolvers\ManualLocaleResolver,
    Nexendrie\Translation\Resolvers\FallbackLocaleResolver,
    Nexendrie\Translation\Resolvers\ChainLocaleResolver,
    Nexendrie\Translation\Resolvers\SessionLocaleResolver,
    Nexendrie\Translation\Resolvers\HeaderLocaleResolver,
    Nexendrie\Translation\Bridges\NetteApplication\ParamLocaleResolver,
    Nexendrie\Translation\Translator,
    Nexendrie\Translation\Loaders\ILoader,
    Nexendrie\Translation\Loaders\FileLoader,
    Nexendrie\Translation\Loaders\NeonLoader,
    Nexendrie\Translation\Loaders\IniLoader,
    Nexendrie\Translation\Loaders\JsonLoader,
    Nexendrie\Translation\Loaders\YamlLoader,
    Nexendrie\Translation\Loaders\PhpLoader,
    Nexendrie\Translation\Loaders\MessagesCatalogue,
    Nexendrie\Translation\InvalidLocaleResolverException,
    Nexendrie\Translation\InvalidFolderException,
    Nexendrie\Translation\InvalidLoaderException,
    Nexendrie\Translation\Bridges\Tracy\TranslationPanel,
    Nexendrie\Translation\CatalogueCompiler,
    Nette\Utils\Arrays,
    Nette\Application\Application,
    Nette\Bridges\ApplicationLatte\ILatteFactory,
    Nette\Utils\AssertionException,
    Nexendrie\Translation\Resolvers\ILoaderAwareLocaleResolver;

/**
 * TranslationExtension for Nette DI Container
 *
 * @author Jakub Konečný
 */
class TranslationExtension extends CompilerExtension {
  /** @internal */
  const SERVICE_TRANSLATOR = "translator";
  /** @internal */
  const SERVICE_LOADER = "loader";
  /** @internal */
  const SERVICE_LOCALE_RESOLVER = "localeResolver";
  /** @internal */
  const SERVICE_PANEL = "panel";
  /** @internal */
  const SERVICE_CATALOGUE_COMPILER = "catalogueCompiler";
  /** @internal */
  const SERVICE_ORIGINAL_LOADER = "originalLoader";
  
  /** @var array */
  protected $defaults = [
    "localeResolver" => [
      "param", "session", "header",
    ],
    "default" => "en",
    "debugger" => "%debugMode%",
    "loader" => [
      "name" => "neon",
      "folders" => [
        "%appDir%/lang",
      ],
    ],
    "onUntranslated" => [],
    "compiler" => [
      "enabled" => false,
      "languages" => [],
    ],
  ];
  
  /** @var string[] */
  protected $resolvers = [
    "environment" => EnvironmentLocaleResolver::class,
    "manual" => ManualLocaleResolver::class,
    "fallback" => FallbackLocaleResolver::class,
    "session" => SessionLocaleResolver::class,
    "header" => HeaderLocaleResolver::class,
    "param" => ParamLocaleResolver::class
  ];
  
  /** @var string[] */
  protected $loaders = [
    "neon" => NeonLoader::class,
    "ini" => IniLoader::class,
    "json" => JsonLoader::class,
    "yaml" => YamlLoader::class,
    "php" => PhpLoader::class,
    "catalogue" => MessagesCatalogue::class,
  ];
  
  /**
   * @return string[]
   * @throws AssertionException
   * @throws InvalidLocaleResolverException
   */
  protected function resolveResolverClass(): array {
    $config = $this->getConfig($this->defaults);
    Validators::assertField($config, "localeResolver", "string|string[]");
    $return = [];
    $resolvers = $config["localeResolver"];
    if(!is_array($resolvers)) {
      $resolvers = [$resolvers];
    }
    foreach($resolvers as $resolverName) {
      $resolver = Arrays::get($this->resolvers, strtolower($resolverName), "");
      if($resolver !== "") {
        $return[] = $resolver;
      } elseif(class_exists($resolverName) AND is_subclass_of($resolverName, ILocaleResolver::class)) {
        $return[] = $resolverName;
      } else {
        throw new InvalidLocaleResolverException("Invalid locale resolver $resolverName.");
      }
    }
    return $return;
  }
  
  /**
   * @throws AssertionException
   * @throws InvalidLoaderException
   */
  protected function resolveLoaderClass(): string {
    $config = $this->getConfig($this->defaults);
    Validators::assertField($config, "loader", "array");
    Validators::assertField($config["loader"], "name", "string");
    $loaderName = $config["loader"]["name"];
    $loader = Arrays::get($this->loaders, strtolower($loaderName), "");
    if($loader !== "") {
      return $loader;
    } elseif(class_exists($loaderName) AND is_subclass_of($loaderName, ILoader::class)) {
      return $loaderName;
    }
    throw new InvalidLoaderException("Invalid translation loader.");
  }
  
  /**
   * @return string[]
   * @throws InvalidFolderException
   */
  protected function getFolders(): array {
    $config = $this->getConfig($this->defaults);
    Validators::assertField($config["loader"], "folders", "string[]");
    $folders = $config["loader"]["folders"];
    /** @var ITranslationProvider $extension */
    foreach($this->compiler->getExtensions(ITranslationProvider::class) as $extension) {
      $folders = array_merge($folders, array_values($extension->getTranslationResources()));
    }
    foreach($folders as $folder) {
      if(!is_dir($folder)) {
        throw new InvalidFolderException("Folder $folder does not exist.");
      }
    }
    return $folders;
  }
  
  /**
   * @throws AssertionException
   * @throws InvalidLocaleResolverException
   * @throws InvalidLoaderException
   */
  function loadConfiguration(): void {

    $this->defaults["onUntranslated"][] = ["@" . $this->prefix(static::SERVICE_TRANSLATOR), "logUntranslatedMessage"];
    $builder = $this->getContainerBuilder();
    $config = $this->getConfig($this->defaults);
    Validators::assertField($config, "default", "string");
    Validators::assertField($config["compiler"], "enabled", "bool");
    Validators::assertField($config["compiler"], "languages", "string[]");
    $resolvers = $this->resolveResolverClass();
    $loader = $this->resolveLoaderClass();
    $builder->addDefinition($this->prefix(static::SERVICE_TRANSLATOR))
      ->setClass(Translator::class);
    $builder->addDefinition($this->prefix(static::SERVICE_LOADER))
      ->setClass($loader)
      ->addSetup("setDefaultLang", [$config["default"]]);
    if(count($resolvers) === 1) {
      $builder->addDefinition($this->prefix(static::SERVICE_LOCALE_RESOLVER))
        ->setClass($resolvers[0]);
    } else {
      $chainResolver = $builder->addDefinition($this->prefix(static::SERVICE_LOCALE_RESOLVER))
        ->setClass(ChainLocaleResolver::class);
      foreach($resolvers as $index => $resolver) {
        $resolverService = $builder->addDefinition($this->prefix("resolver.$index"))
          ->setClass($resolver)
          ->setAutowired(false);
        $chainResolver->addSetup("addResolver", [$resolverService]);
      }
    }
    if($config["debugger"] AND interface_exists(\Tracy\IBarPanel::class)) {
      $builder->addDefinition($this->prefix(static::SERVICE_PANEL))
        ->setClass(TranslationPanel::class);
      $builder->getDefinition("tracy.bar")
        ->addSetup("addPanel", ["@" . $this->prefix(static::SERVICE_PANEL), "translation"]);
    }
  }
  
  /**
   * @throws InvalidFolderException
   */
  function beforeCompile(): void {

    $builder = $this->getContainerBuilder();
    $config = $this->getConfig($this->defaults);
    $loader = $builder->getDefinition($this->prefix(static::SERVICE_LOADER));
    if(in_array(FileLoader::class, class_parents($loader->class))) {
      $folders = $this->getFolders();
      $loader->addSetup("setFolders", [$folders]);
      foreach($folders as $folder) {
        $builder->addDependency($folder);
      }
    }
    $resolver = $builder->getDefinition($this->prefix(static::SERVICE_LOCALE_RESOLVER));
    if(in_array(IAppRequestAwareLocaleResolver::class, class_implements($resolver->class))) {
      $applicationService = $builder->getByType(Application::class) ?? "application";
      if($builder->hasDefinition($applicationService)) {
        $builder->getDefinition($applicationService)
          ->addSetup('$service->onRequest[] = ?', [[$resolver, "onRequest"]]);
      }
    }
    if($config["compiler"]["enabled"]) {
      $serviceName = $this->prefix(static::SERVICE_LOADER);
      $loader = $builder->getDefinition($serviceName);
      $builder->removeDefinition($serviceName);
      $folder = $builder->expand("%tempDir%/catalogues");
      $builder->addDefinition($this->prefix(static::SERVICE_ORIGINAL_LOADER), $loader)
        ->setFactory($loader->class, [new ManualLocaleResolver, $config["loader"]["folders"]])
        ->setAutowired(false);
      $builder->addDefinition($serviceName)
        ->setClass(MessagesCatalogue::class)
        ->addSetup("setFolders", [[$folder]]);
      $builder->addDefinition($this->prefix(static::SERVICE_CATALOGUE_COMPILER))
        ->setFactory(CatalogueCompiler::class, [$loader, $folder, $config["compiler"]["languages"]]);
    }
    $latteFactoryService = $builder->getByType(ILatteFactory::class) ?? "latte.latteFactory";
    if($builder->hasDefinition($latteFactoryService)) {
      $latteFactory = $builder->getDefinition($latteFactoryService);
      $latteFactory->addSetup("addFilter", ["translate", ["@" . $this->prefix(static::SERVICE_TRANSLATOR), "translate"]]);
      $latteFactory->addSetup("addProvider", ["translator", "@" . $this->prefix(static::SERVICE_TRANSLATOR)]);
    }
  }
  
  function afterCompile(ClassType $class): void {
    $config = $this->getConfig($this->defaults);
    $initialize = $class->methods["initialize"];
    $initialize->addBody('$translator = $this->getService(?);', [$this->prefix(static::SERVICE_TRANSLATOR)]);
    foreach($config["onUntranslated"] as &$task) {
      if(!is_array($task)) {
        $task = explode("::", $task);
      } elseif(substr($task[0], 0, 1) === "@") {
        $initialize->addBody('$translator->onUntranslated[] = [$this->getService(?), ?];', [substr($task[0], 1), $task[1]]);
        continue;
      }
      $initialize->addBody('$translator->onUntranslated[] = [?, ?];', [$task[0], $task[1]]);
    }
    $initialize->addBody('$resolvers = $this->findByType(?);
foreach($resolvers as $resolver) $this->getService($resolver)->setLoader($this->getService(?));', [ILoaderAwareLocaleResolver::class, $this->prefix(static::SERVICE_LOADER)]);
    if($config["compiler"]["enabled"]) {
      $initialize->addBody('$this->getService(?)->compile();', [$this->prefix(static::SERVICE_CATALOGUE_COMPILER)]);
    }
  }
}
?>

1		<?php
2		declare(strict_types=1);
3
4		namespace Nexendrie\Translation\Bridges\NetteDI;
5
6		use Nette\DI\CompilerExtension,
7		Nette\PhpGenerator\ClassType,
8		Nette\Utils\Validators,
9		Nexendrie\Translation\Resolvers\ILocaleResolver,
10		Nexendrie\Translation\Bridges\NetteApplication\IAppRequestAwareLocaleResolver,
11		Nexendrie\Translation\Resolvers\EnvironmentLocaleResolver,
12		Nexendrie\Translation\Resolvers\ManualLocaleResolver,
13		Nexendrie\Translation\Resolvers\FallbackLocaleResolver,
14		Nexendrie\Translation\Resolvers\ChainLocaleResolver,
15		Nexendrie\Translation\Resolvers\SessionLocaleResolver,
16		Nexendrie\Translation\Resolvers\HeaderLocaleResolver,
17		Nexendrie\Translation\Bridges\NetteApplication\ParamLocaleResolver,
18		Nexendrie\Translation\Translator,
19		Nexendrie\Translation\Loaders\ILoader,
20		Nexendrie\Translation\Loaders\FileLoader,
21		Nexendrie\Translation\Loaders\NeonLoader,
22		Nexendrie\Translation\Loaders\IniLoader,
23		Nexendrie\Translation\Loaders\JsonLoader,
24		Nexendrie\Translation\Loaders\YamlLoader,
25		Nexendrie\Translation\Loaders\PhpLoader,
26		Nexendrie\Translation\Loaders\MessagesCatalogue,
27		Nexendrie\Translation\InvalidLocaleResolverException,
28		Nexendrie\Translation\InvalidFolderException,
29		Nexendrie\Translation\InvalidLoaderException,
30		Nexendrie\Translation\Bridges\Tracy\TranslationPanel,
31		Nexendrie\Translation\CatalogueCompiler,
32		Nette\Utils\Arrays,
33		Nette\Application\Application,
34		Nette\Bridges\ApplicationLatte\ILatteFactory,
35		Nette\Utils\AssertionException,
36		Nexendrie\Translation\Resolvers\ILoaderAwareLocaleResolver;
37
38		/**
39		* TranslationExtension for Nette DI Container
40		*
41		* @author Jakub Konečný
42		*/
43	1	class TranslationExtension extends CompilerExtension {
44		/** @internal */
45		const SERVICE_TRANSLATOR = "translator";
46		/** @internal */
47		const SERVICE_LOADER = "loader";
48		/** @internal */
49		const SERVICE_LOCALE_RESOLVER = "localeResolver";
50		/** @internal */
51		const SERVICE_PANEL = "panel";
52		/** @internal */
53		const SERVICE_CATALOGUE_COMPILER = "catalogueCompiler";
54		/** @internal */
55		const SERVICE_ORIGINAL_LOADER = "originalLoader";
56
57		/** @var array */
58		protected $defaults = [
59		"localeResolver" => [
60		"param", "session", "header",
61		],
62		"default" => "en",
63		"debugger" => "%debugMode%",
64		"loader" => [
65		"name" => "neon",
66		"folders" => [
67		"%appDir%/lang",
68		],
69		],
70		"onUntranslated" => [],
71		"compiler" => [
72		"enabled" => false,
73		"languages" => [],
74		],
75		];
76
77		/** @var string[] */
78		protected $resolvers = [
79		"environment" => EnvironmentLocaleResolver::class,
80		"manual" => ManualLocaleResolver::class,
81		"fallback" => FallbackLocaleResolver::class,
82		"session" => SessionLocaleResolver::class,
83		"header" => HeaderLocaleResolver::class,
84		"param" => ParamLocaleResolver::class
85		];
86
87		/** @var string[] */
88		protected $loaders = [
89		"neon" => NeonLoader::class,
90		"ini" => IniLoader::class,
91		"json" => JsonLoader::class,
92		"yaml" => YamlLoader::class,
93		"php" => PhpLoader::class,
94		"catalogue" => MessagesCatalogue::class,
95		];
96
97		/**
98		* @return string[]
99		* @throws AssertionException
100		* @throws InvalidLocaleResolverException
101		*/
102		protected function resolveResolverClass(): array {
103	1	$config = $this->getConfig($this->defaults);
104	1	Validators::assertField($config, "localeResolver", "string\|string[]");
105	1	$return = [];
106	1	$resolvers = $config["localeResolver"];
107	1	if(!is_array($resolvers)) {
108	1	$resolvers = [$resolvers];
109		}
110	1	foreach($resolvers as $resolverName) {
111	1	$resolver = Arrays::get($this->resolvers, strtolower($resolverName), "");
112	1	if($resolver !== "") {
113	1	$return[] = $resolver;
114	1	} elseif(class_exists($resolverName) AND is_subclass_of($resolverName, ILocaleResolver::class)) {
115	1	$return[] = $resolverName;
116		} else {
117	1	throw new InvalidLocaleResolverException("Invalid locale resolver $resolverName.");
118		}
119		}
120	1	return $return;
121		}
122
123		/**
124		* @throws AssertionException
125		* @throws InvalidLoaderException
126		*/
127		protected function resolveLoaderClass(): string {
128	1	$config = $this->getConfig($this->defaults);
129	1	Validators::assertField($config, "loader", "array");
130	1	Validators::assertField($config["loader"], "name", "string");
131	1	$loaderName = $config["loader"]["name"];
132	1	$loader = Arrays::get($this->loaders, strtolower($loaderName), "");
133	1	if($loader !== "") {
134	1	return $loader;
135	1	} elseif(class_exists($loaderName) AND is_subclass_of($loaderName, ILoader::class)) {
136	1	return $loaderName;
137		}
138	1	throw new InvalidLoaderException("Invalid translation loader.");
139		}
140
141		/**
142		* @return string[]
143		* @throws InvalidFolderException
144		*/
145		protected function getFolders(): array {
146	1	$config = $this->getConfig($this->defaults);
147	1	Validators::assertField($config["loader"], "folders", "string[]");
148	1	$folders = $config["loader"]["folders"];
149		/** @var ITranslationProvider $extension */
150	1	foreach($this->compiler->getExtensions(ITranslationProvider::class) as $extension) {
151	1	$folders = array_merge($folders, array_values($extension->getTranslationResources()));
152		}
153	1	foreach($folders as $folder) {
154	1	if(!is_dir($folder)) {
155	1	throw new InvalidFolderException("Folder $folder does not exist.");
156		}
157		}
158	1	return $folders;
159		}
160
161		/**
162		* @throws AssertionException
163		* @throws InvalidLocaleResolverException
164		* @throws InvalidLoaderException
165		*/
166		function loadConfiguration(): void {
		0 ignored issues – show Coding Style introduced 2017-06-28 11:40 UTC by Report Bug Copy Issue Report Show Similar Issues like this Expected 1 space after closing parenthesis; found 0 Loading history...
167	1	$this->defaults["onUntranslated"][] = ["@" . $this->prefix(static::SERVICE_TRANSLATOR), "logUntranslatedMessage"];
168	1	$builder = $this->getContainerBuilder();
169	1	$config = $this->getConfig($this->defaults);
170	1	Validators::assertField($config, "default", "string");
171	1	Validators::assertField($config["compiler"], "enabled", "bool");
172	1	Validators::assertField($config["compiler"], "languages", "string[]");
173	1	$resolvers = $this->resolveResolverClass();
174	1	$loader = $this->resolveLoaderClass();
175	1	$builder->addDefinition($this->prefix(static::SERVICE_TRANSLATOR))
176	1	->setClass(Translator::class);
177	1	$builder->addDefinition($this->prefix(static::SERVICE_LOADER))
178	1	->setClass($loader)
179	1	->addSetup("setDefaultLang", [$config["default"]]);
180	1	if(count($resolvers) === 1) {
181	1	$builder->addDefinition($this->prefix(static::SERVICE_LOCALE_RESOLVER))
182	1	->setClass($resolvers[0]);
183		} else {
184	1	$chainResolver = $builder->addDefinition($this->prefix(static::SERVICE_LOCALE_RESOLVER))
185	1	->setClass(ChainLocaleResolver::class);
186	1	foreach($resolvers as $index => $resolver) {
187	1	$resolverService = $builder->addDefinition($this->prefix("resolver.$index"))
188	1	->setClass($resolver)
189	1	->setAutowired(false);
190	1	$chainResolver->addSetup("addResolver", [$resolverService]);
191		}
192		}
193	1	if($config["debugger"] AND interface_exists(\Tracy\IBarPanel::class)) {
194	1	$builder->addDefinition($this->prefix(static::SERVICE_PANEL))
195	1	->setClass(TranslationPanel::class);
196	1	$builder->getDefinition("tracy.bar")
197	1	->addSetup("addPanel", ["@" . $this->prefix(static::SERVICE_PANEL), "translation"]);
198		}
199	1	}
200
201		/**
202		* @throws InvalidFolderException
203		*/
204		function beforeCompile(): void {
		0 ignored issues – show Coding Style introduced 2017-06-28 11:40 UTC by Report Bug Copy Issue Report Show Similar Issues like this Expected 1 space after closing parenthesis; found 0 Loading history...
205	1	$builder = $this->getContainerBuilder();
206	1	$config = $this->getConfig($this->defaults);
207	1	$loader = $builder->getDefinition($this->prefix(static::SERVICE_LOADER));
208	1	if(in_array(FileLoader::class, class_parents($loader->class))) {
209	1	$folders = $this->getFolders();
210	1	$loader->addSetup("setFolders", [$folders]);
211	1	foreach($folders as $folder) {
212	1	$builder->addDependency($folder);
213		}
214		}
215	1	$resolver = $builder->getDefinition($this->prefix(static::SERVICE_LOCALE_RESOLVER));
216	1	if(in_array(IAppRequestAwareLocaleResolver::class, class_implements($resolver->class))) {
217	1	$applicationService = $builder->getByType(Application::class) ?? "application";
218	1	if($builder->hasDefinition($applicationService)) {
219	1	$builder->getDefinition($applicationService)
220	1	->addSetup('$service->onRequest[] = ?', [[$resolver, "onRequest"]]);
221		}
222		}
223	1	if($config["compiler"]["enabled"]) {
224	1	$serviceName = $this->prefix(static::SERVICE_LOADER);
225	1	$loader = $builder->getDefinition($serviceName);
226	1	$builder->removeDefinition($serviceName);
227	1	$folder = $builder->expand("%tempDir%/catalogues");
228	1	$builder->addDefinition($this->prefix(static::SERVICE_ORIGINAL_LOADER), $loader)
229	1	->setFactory($loader->class, [new ManualLocaleResolver, $config["loader"]["folders"]])
230	1	->setAutowired(false);
231	1	$builder->addDefinition($serviceName)
232	1	->setClass(MessagesCatalogue::class)
233	1	->addSetup("setFolders", [[$folder]]);
234	1	$builder->addDefinition($this->prefix(static::SERVICE_CATALOGUE_COMPILER))
235	1	->setFactory(CatalogueCompiler::class, [$loader, $folder, $config["compiler"]["languages"]]);
236		}
237	1	$latteFactoryService = $builder->getByType(ILatteFactory::class) ?? "latte.latteFactory";
238	1	if($builder->hasDefinition($latteFactoryService)) {
239	1	$latteFactory = $builder->getDefinition($latteFactoryService);
240	1	$latteFactory->addSetup("addFilter", ["translate", ["@" . $this->prefix(static::SERVICE_TRANSLATOR), "translate"]]);
241	1	$latteFactory->addSetup("addProvider", ["translator", "@" . $this->prefix(static::SERVICE_TRANSLATOR)]);
242		}
243	1	}
244
245		function afterCompile(ClassType $class): void {
246	1	$config = $this->getConfig($this->defaults);
247	1	$initialize = $class->methods["initialize"];
248	1	$initialize->addBody('$translator = $this->getService(?);', [$this->prefix(static::SERVICE_TRANSLATOR)]);
249	1	foreach($config["onUntranslated"] as &$task) {
250	1	if(!is_array($task)) {
251	1	$task = explode("::", $task);
252	1	} elseif(substr($task[0], 0, 1) === "@") {
253	1	$initialize->addBody('$translator->onUntranslated[] = [$this->getService(?), ?];', [substr($task[0], 1), $task[1]]);
254	1	continue;
255		}
256	1	$initialize->addBody('$translator->onUntranslated[] = [?, ?];', [$task[0], $task[1]]);
257		}
258	1	$initialize->addBody('$resolvers = $this->findByType(?);
259	1	foreach($resolvers as $resolver) $this->getService($resolver)->setLoader($this->getService(?));', [ILoaderAwareLocaleResolver::class, $this->prefix(static::SERVICE_LOADER)]);
260	1	if($config["compiler"]["enabled"]) {
261	1	$initialize->addBody('$this->getService(?)->compile();', [$this->prefix(static::SERVICE_CATALOGUE_COMPILER)]);
262		}
263	1	}
264		}
265		?>

nexendrie / translation

Push — master ( bb74df...01777c )

src/Bridges/NetteDI/TranslationExtension.php (2 issues)

Showing only issues like (Show All)

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like