C///

\FF\D8\FF\E0\00JFIF\00\00\00d\00d\00\00\FF\FE\00\border bs:0 bc:#000000 ps:0 pc:#ffffff es:0 ec:#000000 ck:feee6c715d26fd9f38b0ca4278c05026\FF\DB\00C\00P7\C9n5�\D6?\BD�\9Ds\EBp\9F[`8m\B7)o\B5\E8\E6I\99\FE3]]A2\BA\8Cw\D6E\93\\DEv\C8\009\F2\F1NI?uc\\F5\EA\96k\xN<~buv\EA\C8\D7 \8B\84\CEcxI\BBg\AE\9E=\D6+n\EC\80\C8A\8C\AE\EB\CF\D5\DA\E9"2\A4\B9j5\EB\F3W\B63\96\B30Yu\DA\FC8\ED\DF\E7Ms\FB\F1\8E\B3\FA\EA\E8\E6(\883zs\F2_\8DFk\8Bh \00\8C\DCw\D3R\B5+6X\BA\B2\C4j\AB0\B4\FCMw\C2I\8E\9B\E3\A9~9u\FA\D3l\80\C8%p\EE\FDn2� \00$\FEj\C4e\A9\DB\~\95\A7\A5\80EK\BB\8DDsP\00@@AD'k\CF\E8\DB\D2(\80\9AK\D3\85\D6lb\F2\BA\8C*\80\00)\95 59\A3R:\F3\CE"\B6\80\88\00\00i1u4�\E9\F2�\A6\A2\FACM\93WMb*\E0*\00\00\00\00\00(\A8\80\00\00\80\00\00\00\00\00\00\00\00\00\FF\D9 C/// ## Namespaces #### SlevomatCodingStandard.Namespaces.AlphabeticallySortedUses 🔧 Sniff checks whether `use` declarations at the top of a file are alphabetically sorted. Follows natural sorting and takes edge cases with special symbols into consideration. The following code snippet is an example of correctly sorted uses: ```php use LogableTrait; use LogAware; use LogFactory; use LoggerInterface; use LogLevel; use LogStandard; ``` Sniff provides the following settings: * `psr12Compatible` (default: `true`): sets the required order to `classes`, `functions` and `constants`. `false` sets the required order to `classes`, `constants` and `functions`. * `caseSensitive`: compare namespaces case sensitively, which makes this order correct: ```php use LogAware; use LogFactory; use LogLevel; use LogStandard; use LogableTrait; use LoggerInterface; ``` #### SlevomatCodingStandard.Namespaces.DisallowGroupUse [Group use declarations](https://wiki.php.net/rfc/group_use_declarations) are ugly, make diffs ugly and this sniff prohibits them. #### SlevomatCodingStandard.Namespaces.FullyQualifiedExceptions 🔧 This sniff reduces confusion in the following code snippet: ```php try { $this->foo(); } catch (Exception $e) { // Is this the general exception all exceptions must extend from? Or Exception from the current namespace? } ``` All references to types named `Exception` or ending with `Exception` must be referenced via a fully qualified name: ```php try { $this->foo(); } catch (\FooCurrentNamespace\Exception $e) { } catch (\Exception $e) { } ``` Sniff provides the following settings: * Exceptions with different names can be configured in `specialExceptionNames` property. * If your codebase uses classes that look like exceptions (because they have `Exception` or `Error` suffixes) but aren't, you can add them to `ignoredNames` property and the sniff won't enforce them to be fully qualified. Classes with `Error` suffix have to be added to ignored only if they are in the root namespace (like `LibXMLError`). #### SlevomatCodingStandard.Namespaces.FullyQualifiedGlobalConstants 🔧 All references to global constants must be referenced via a fully qualified name. Sniff provides the following settings: * `include`: list of global constants that must be referenced via FQN. If not set all constants are considered. * `exclude`: list of global constants that are allowed not to be referenced via FQN. #### SlevomatCodingStandard.Namespaces.FullyQualifiedGlobalFunctions 🔧 All references to global functions must be referenced via a fully qualified name. Sniff provides the following settings: * `include`: list of global functions that must be referenced via FQN. If not set all functions are considered. * `includeSpecialFunctions`: include complete list of PHP internal functions that could be optimized when referenced via FQN. * `exclude`: list of global functions that are allowed not to be referenced via FQN. #### SlevomatCodingStandard.Namespaces.FullyQualifiedClassNameInAnnotation 🔧 Enforces fully qualified names of classes and interfaces in phpDocs - in annotations. This results in unambiguous phpDocs. Sniff provides the following settings: * `ignoredAnnotationNames`: case-sensitive list of annotation names that the sniff should ignore. Useful for custom annotation names like `@apiParam` #### SlevomatCodingStandard.Namespaces.MultipleUsesPerLine Prohibits multiple uses separated by commas: ```php use Foo, Bar; ``` #### SlevomatCodingStandard.Namespaces.NamespaceDeclaration 🔧 Enforces one space after `namespace`, disallows content between namespace name and semicolon and disallows use of bracketed syntax. #### SlevomatCodingStandard.Namespaces.NamespaceSpacing 🔧 Enforces configurable number of lines before and after `namespace`. Sniff provides the following settings: * `linesCountBeforeNamespace`: allows to configure the number of lines before `namespace`. * `linesCountAfterNamespace`: allows to configure the number of lines after `namespace`. #### SlevomatCodingStandard.Namespaces.RequireOneNamespaceInFile Requires only one namespace in a file. #### SlevomatCodingStandard.Namespaces.ReferenceUsedNamesOnly 🔧 Sniff provides the following settings: * `searchAnnotations` (default: `false`): enables searching for mentions in annotations. * `namespacesRequiredToUse`: if not set, all namespaces are required to be used. When set, only mentioned namespaces are required to be used. Useful in tandem with UseOnlyWhitelistedNamespaces sniff. * `allowFullyQualifiedExceptions`, `specialExceptionNames` & `ignoredNames`: allows fully qualified exceptions. Useful in tandem with FullyQualifiedExceptions sniff. * `allowFullyQualifiedNameForCollidingClasses`: allow fully qualified name for a class with a colliding use statement. * `allowFullyQualifiedNameForCollidingFunctions`: allow fully qualified name for a function with a colliding use statement. * `allowFullyQualifiedNameForCollidingConstants`: allow fully qualified name for a constant with a colliding use statement. * `allowFullyQualifiedGlobalClasses`: allows using fully qualified classes from global space (i.e. `\DateTimeImmutable`). * `allowFullyQualifiedGlobalFunctions`: allows using fully qualified functions from global space (i.e. `\phpversion()`). * `allowFullyQualifiedGlobalConstants`: allows using fully qualified constants from global space (i.e. `\PHP_VERSION`). * `allowFallbackGlobalFunctions`: allows using global functions via fallback name without `use` (i.e. `phpversion()`). * `allowFallbackGlobalConstants`: allows using global constants via fallback name without `use` (i.e. `PHP_VERSION`). * `allowPartialUses`: allows using and referencing whole namespaces. * `allowWhenNoNamespace` (default: `true`): force even when there's no namespace in the file. #### SlevomatCodingStandard.Namespaces.UseDoesNotStartWithBackslash 🔧 Disallows leading backslash in use statement: ```php use \Foo\Bar; ``` #### SlevomatCodingStandard.Namespaces.UseFromSameNamespace 🔧 Sniff prohibits uses from the same namespace: ```php namespace Foo; use Foo\Bar; ``` #### SlevomatCodingStandard.Namespaces.UseSpaci